curlyq: workspace.py comparison

comparison workspace.py @ 1:173e86601dbc

Add views.

author	David Barts <n5jrn@me.com>
date	Thu, 26 Dec 2019 12:00:03 -0800
parents	984876b6a095
children	8884b0bf779d

comparison

equal deleted inserted replaced

-:984876b6a095
+:173e86601dbc
 """
 self._length = 0
 if initial_data is not None:
 data = initial_data.encode(self.encoding, self.errors)
 self._fp = io.BytesIO(data)
-self._dirty = True
 else:
 self._fp = io.BytesIO()
-self._dirty = False
 def close(self):
 """
 Causes our buffer to be discarded and this workspace to become
 unusable.
 """
 self._fp.write(string.encode(self.encoding, self.errors))
 def __len__(self):
 """
-Length as a string.
+Length in characters.
 """
-if self._dirty:
+return len(self._fp.getbuffer()) // 2
-back = self.tell()
-self._length = self.seek(0, io.SEEK_END) // 2
+def _mapped(self, index):
-self.seek(back)
+if index < 0 or index >= len(self):
-self._dirty = False
+raise IndexError("index {0} out of range".format(index))
-return self._length
+i2 = index * 2
+return slice(i2, i2 + 2)
 def __getitem__(self, key):
 """
 Direct access to a single character or range of characters. We do
 not support negative indices. Return value is based on what's most
 useful for curling quotes.
 XXX - might return replacement chars from surrogate fragments.
 """
 if isinstance(key, int):
-if key < 0 or key >= len(self):
+try:
+key = self._mapped(key)
+except IndexError:
 return ""
-k2 = 2 * key
-key = slice(k2, k2 + 2)
 elif isinstance(key, slice):
 if key.step is not None:
 raise ValueError("__getitem__ does not support steps in slices")
 length = len(self)
 start = 0 if key.start is None else key.start
 stop = max(0, min(length, stop))
 if stop <= start:
 return ""
 key = slice(start * 2, stop * 2)
 else:
-raise TypeError("__setitem__ only supports integers and slices")
+raise TypeError("__getitem__ only supports integers and slices")
 return self.codec.decode(self._fp.getbuffer()[key], "replace")[0]
 def __setitem__(self, key, value):
 """
 Direct access to a single character. We do not support negative
 indices or replacing more than a single character at a time.
 XXX - only works on characters in the BMP.
 """
 if not isinstance(key, int):
 raise TypeError("__setitem__ only supports integers")
-if key < 0 or key >= len(self):
-raise IndexError("index {0} out of range".format(key))
 if not value:
 return
-start = key * 2
-end = start + 2
 encoded = value[0].encode(self.encoding, self.errors)
 if len(encoded) != 2:
 raise ValueError("{0!r} not in BMP".format(value[0]))
-self._fp.getbuffer()[start:end] = encoded
+self._fp.getbuffer()[self._mapped(key)] = encoded
 def __del__(self):
 """
 Equivalent to .close().
 """
 """
 Context manager: close on exit.
 """
 self.close()
 return False
+class Bounds(object):
+def __init__(self, start, stop):
+if start > stop or start < 0 or stop < 0:
+raise ValueError("invalid bounds")
+self.start = int(start)
+self.stop = int(stop)
+@classmethod
+def from_object(cls, obj):
+if isinstance(obj, slice):
+return self(slice.start, slice.stop)
+return self(obj[0], obj[1])
+def __lt__(self, other):
+return self.start < other.start
+def __le__(self, other):
+return self.start <= other.start
+def __eq__(self, other):
+return self.start == other.start
+def __ne__(self, other):
+return self.start != other.start
+def __gt__(self, other):
+return self.start > other.start
+def __ge__(self, other):
+return self.start >= other.start
+def __contains__(self, scalar):
+return self.start <= scalar < self.stop
+def __repr__(self):
+return "{0}({1!r}, {2!r})".format(self.__class__.__name__, self.start, self.stop)
+class Mapping(object):
+def __init__(self, bounds, offset):
+if not isinstance(bounds, Bounds):
+raise TypeError("bounds must be a Bounds object")
+if not isinstance(offset, int):
+raise TypeError("offset must be an int")
+self.bounds = bounds
+self.offset = offset
+def __repr__(self):
+return "{0}({1!r}, {2!r})".format(self.__class__.__name__, self.bounds, self.offset)
+class SegmentedView(object):
+"""
+Implements a view on a subscriptable object. The view is composed of
+zero or more segments of the source object. Has the same idiosyncratic
+behavior for out-of-bounds indices that Workspace has (and for the
+same reason).
+"""
+def __init__(self, indexable, bounds):
+self.indexable = indexable
+self._mmap = [ Mapping(Bounds(0, 0), 0) ]
+pos = 0
+for r in sorted(bounds):
+if pos is not None and r.start <= pos and r.stop > pos:
+# merge ranges
+self._mmap[-1].bounds.stop = r.stop
+pos = r.stop
+continue
+opos = pos
+pos += r.stop - r.start
+self._mmap.append(Mapping(Bounds(opos, pos), r.start))
+self._length = pos
+def _mapped(self, index):
+mi = self._binsch(index)
+m = None if mi is None else self._mmap[mi]
+if m is None:
+raise IndexError("index {0} out of range".format(index))
+return index - m.bounds.start + m.offset
+def _binsch(self, index):
+a = 0
+z = len(self._mmap) - 1
+while a <= z:
+m = (a + z) // 2
+if index in self._mmap[m].bounds:
+return m
+if index < self._mmap[m].bounds.start:
+z = m - 1
+else:
+assert index >= self._mmap[m].bounds.stop
+a = m + 1
+return None
+def __setitem__(self, key, value):
+if not isinstance(key, int):
+raise TypeError("__setitem__ only supports integers")
+self.indexable[self._mapped(key)] = value
+# XXX - this is sorta brute-forced and could be more efficient
+def __getitem__(self, key):
+if isinstance(key, int):
+return self._get1(key)
+if not isinstance(key, slice):
+raise TypeError("expecting int or slice")
+with io.StringIO() as buf:
+for i in range(key.start, key.stop, key.step or 1):
+buf.write(self._get1(i))
+return buf.getvalue()
+def __len__(self):
+return self._length
+def _get1(self, index):
+try:
+return self.indexable[self._mapped(index)]
+except IndexError:
+return ""
+def getvalue(self):
+return self[0:len(self)]

Mercurial > cgi-bin > hgweb.cgi > curlyq

comparison workspace.py @ 1:173e86601dbc