| pulkit |
| hg-reviewers |
The current class uses module-level variables which don't allow for reusing the
current logic for a slightly different revlog version.
| No Linters Available |
| No Unit Test Coverage |
| Path | Packages | |||
|---|---|---|---|---|
| M | mercurial/pure/parsers.py (37 lines) |
| Commit | Parents | Author | Summary | Date |
|---|---|---|---|---|
| cf233a20bed4 | 5df10dc2d85c | Raphaël Gomès | Jan 28 2021, 9:26 AM |
| # Some code below makes tuples directly because it's more convenient. However, | # Some code below makes tuples directly because it's more convenient. However, | ||||
| # code outside this module should always use dirstatetuple. | # code outside this module should always use dirstatetuple. | ||||
| def dirstatetuple(*x): | def dirstatetuple(*x): | ||||
| # x is a tuple | # x is a tuple | ||||
| return x | return x | ||||
| indexformatng = b">Qiiiiii20s12x" | |||||
| indexfirst = struct.calcsize(b'Q') | |||||
| sizeint = struct.calcsize(b'i') | |||||
| indexsize = struct.calcsize(indexformatng) | |||||
| nullitem = (0, 0, 0, -1, -1, -1, -1, nullid) | |||||
| def gettype(q): | def gettype(q): | ||||
| return int(q & 0xFFFF) | return int(q & 0xFFFF) | ||||
| def offset_type(offset, type): | def offset_type(offset, type): | ||||
| return int(int(offset) << 16 | type) | return int(int(offset) << 16 | type) | ||||
| class BaseIndexObject(object): | class BaseIndexObject(object): | ||||
| index_format = b">Qiiiiii20s12x" | |||||
| big_int_size = struct.calcsize(b'Q') | |||||
| int_size = struct.calcsize(b'i') | |||||
| index_size = struct.calcsize(index_format) | |||||
| null_item = (0, 0, 0, -1, -1, -1, -1, nullid) | |||||
| @property | @property | ||||
| def nodemap(self): | def nodemap(self): | ||||
| msg = b"index.nodemap is deprecated, use index.[has_node|rev|get_rev]" | msg = b"index.nodemap is deprecated, use index.[has_node|rev|get_rev]" | ||||
| util.nouideprecwarn(msg, b'5.3', stacklevel=2) | util.nouideprecwarn(msg, b'5.3', stacklevel=2) | ||||
| return self._nodemap | return self._nodemap | ||||
| @util.propertycache | @util.propertycache | ||||
| def _nodemap(self): | def _nodemap(self): | ||||
| self.__dict__.pop('_nodemap', None) | self.__dict__.pop('_nodemap', None) | ||||
| def __len__(self): | def __len__(self): | ||||
| return self._lgt + len(self._extra) | return self._lgt + len(self._extra) | ||||
| def append(self, tup): | def append(self, tup): | ||||
| if '_nodemap' in vars(self): | if '_nodemap' in vars(self): | ||||
| self._nodemap[tup[7]] = len(self) | self._nodemap[tup[7]] = len(self) | ||||
| data = _pack(indexformatng, *tup) | data = _pack(self.index_format, *tup) | ||||
| self._extra.append(data) | self._extra.append(data) | ||||
| def _check_index(self, i): | def _check_index(self, i): | ||||
| if not isinstance(i, int): | if not isinstance(i, int): | ||||
| raise TypeError(b"expecting int indexes") | raise TypeError(b"expecting int indexes") | ||||
| if i < 0 or i >= len(self): | if i < 0 or i >= len(self): | ||||
| raise IndexError | raise IndexError | ||||
| def __getitem__(self, i): | def __getitem__(self, i): | ||||
| if i == -1: | if i == -1: | ||||
| return nullitem | return self.null_item | ||||
| self._check_index(i) | self._check_index(i) | ||||
| if i >= self._lgt: | if i >= self._lgt: | ||||
| data = self._extra[i - self._lgt] | data = self._extra[i - self._lgt] | ||||
| else: | else: | ||||
| index = self._calculate_index(i) | index = self._calculate_index(i) | ||||
| data = self._data[index : index + indexsize] | data = self._data[index : index + self.index_size] | ||||
| r = _unpack(indexformatng, data) | r = _unpack(self.index_format, data) | ||||
| if self._lgt and i == 0: | if self._lgt and i == 0: | ||||
| r = (offset_type(0, gettype(r[0])),) + r[1:] | r = (offset_type(0, gettype(r[0])),) + r[1:] | ||||
| return r | return r | ||||
| class IndexObject(BaseIndexObject): | class IndexObject(BaseIndexObject): | ||||
| def __init__(self, data): | def __init__(self, data): | ||||
| assert len(data) % indexsize == 0 | assert len(data) % self.index_size == 0 | ||||
| self._data = data | self._data = data | ||||
| self._lgt = len(data) // indexsize | self._lgt = len(data) // self.index_size | ||||
| self._extra = [] | self._extra = [] | ||||
| def _calculate_index(self, i): | def _calculate_index(self, i): | ||||
| return i * indexsize | return i * self.index_size | ||||
| def __delitem__(self, i): | def __delitem__(self, i): | ||||
| if not isinstance(i, slice) or not i.stop == -1 or i.step is not None: | if not isinstance(i, slice) or not i.stop == -1 or i.step is not None: | ||||
| raise ValueError(b"deleting slices only supports a:-1 with step 1") | raise ValueError(b"deleting slices only supports a:-1 with step 1") | ||||
| i = i.start | i = i.start | ||||
| self._check_index(i) | self._check_index(i) | ||||
| self._stripnodes(i) | self._stripnodes(i) | ||||
| if i < self._lgt: | if i < self._lgt: | ||||
| self._data = self._data[: i * indexsize] | self._data = self._data[: i * self.index_size] | ||||
| self._lgt = i | self._lgt = i | ||||
| self._extra = [] | self._extra = [] | ||||
| else: | else: | ||||
| self._extra = self._extra[: i - self._lgt] | self._extra = self._extra[: i - self._lgt] | ||||
| class PersistentNodeMapIndexObject(IndexObject): | class PersistentNodeMapIndexObject(IndexObject): | ||||
| """a Debug oriented class to test persistent nodemap | """a Debug oriented class to test persistent nodemap | ||||
| self._inline_scan(self._lgt) | self._inline_scan(self._lgt) | ||||
| self._extra = [] | self._extra = [] | ||||
| def _inline_scan(self, lgt): | def _inline_scan(self, lgt): | ||||
| off = 0 | off = 0 | ||||
| if lgt is not None: | if lgt is not None: | ||||
| self._offsets = [0] * lgt | self._offsets = [0] * lgt | ||||
| count = 0 | count = 0 | ||||
| while off <= len(self._data) - indexsize: | while off <= len(self._data) - self.index_size: | ||||
| start = off + self.big_int_size | |||||
| (s,) = struct.unpack( | (s,) = struct.unpack( | ||||
| b'>i', self._data[off + indexfirst : off + sizeint + indexfirst] | b'>i', | ||||
| self._data[start : start + self.int_size], | |||||
| ) | ) | ||||
| if lgt is not None: | if lgt is not None: | ||||
| self._offsets[count] = off | self._offsets[count] = off | ||||
| count += 1 | count += 1 | ||||
| off += indexsize + s | off += self.index_size + s | ||||
| if off != len(self._data): | if off != len(self._data): | ||||
| raise ValueError(b"corrupted data") | raise ValueError(b"corrupted data") | ||||
| return count | return count | ||||
| def __delitem__(self, i): | def __delitem__(self, i): | ||||
| if not isinstance(i, slice) or not i.stop == -1 or i.step is not None: | if not isinstance(i, slice) or not i.stop == -1 or i.step is not None: | ||||
| raise ValueError(b"deleting slices only supports a:-1 with step 1") | raise ValueError(b"deleting slices only supports a:-1 with step 1") | ||||
| i = i.start | i = i.start | ||||