mercurial: comparison mercurial/manifest.py

equal deleted inserted replaced

-:c5e1cc0b4c77
+:12450fbea288
 # Allow tests to more easily test the alternate path in manifestdict.fastdelta()
 FASTDELTA_TEXTDIFF_THRESHOLD = 1000
-def _parse(data):
+def _parse(nodelen, data):
 # This method does a little bit of excessive-looking
 # precondition checking. This is so that the behavior of this
 # class exactly matches its C counterpart to try and help
 # prevent surprise breakage for anyone that develops against
 # the pure version.
 if flags in _manifestflags:
 n = n[:-1]
 nl -= 1
 else:
 flags = b''
-if nl not in (40, 64):
+if nl != 2 * nodelen:
 raise ValueError(b'Invalid manifest line')
 yield f, bin(n), flags
 if flags in _manifestflags:
 hlen = nlpos - zeropos - 2
 else:
 hlen = nlpos - zeropos - 1
 flags = b''
-if hlen not in (40, 64):
+if hlen != 2 * self.lm._nodelen:
 raise error.StorageError(b'Invalid manifest line')
 hashval = unhexlify(
 data, self.lm.extrainfo[self.pos], zeropos + 1, hlen
 )
 self.pos += 1
 modified since the manifest was created or compacted.
 """
 def __init__(
 self,
+nodelen,
 data,
 positions=None,
 extrainfo=None,
 extradata=None,
 hasremovals=False,
 ):
+self._nodelen = nodelen
 if positions is None:
 self.positions = self.findlines(data)
 self.extrainfo = [0] * len(self.positions)
 self.data = data
 self.extradata = []
 flags = data[nlpos - 1 : nlpos]
 if flags in _manifestflags:
 hlen -= 1
 else:
 flags = b''
-if hlen not in (40, 64):
+if hlen != 2 * self._nodelen:
 raise error.StorageError(b'Invalid manifest line')
 hashval = unhexlify(data, self.extrainfo[needle], zeropos + 1, hlen)
 return (hashval, flags)
 def __delitem__(self, key):
 )
 def copy(self):
 # XXX call _compact like in C?
 return _lazymanifest(
+self._nodelen,
 self.data,
 self.positions,
 self.extrainfo,
 self.extradata,
 self.hasremovals,
 def __len__(self):
 return len(self.positions)
 def filtercopy(self, filterfn):
 # XXX should be optimized
-c = _lazymanifest(b'')
+c = _lazymanifest(self._nodelen, b'')
 for f, n, fl in self.iterentries():
 if filterfn(f):
 c[f] = n, fl
 return c
 pass
 @interfaceutil.implementer(repository.imanifestdict)
 class manifestdict(object):
-def __init__(self, data=b''):
+def __init__(self, nodelen, data=b''):
-self._lm = _lazymanifest(data)
+self._nodelen = nodelen
+self._lm = _lazymanifest(nodelen, data)
 def __getitem__(self, key):
 return self._lm[key][0]
 def find(self, key):
 '''generate a new manifest filtered by the match argument'''
 if match.always():
 return self.copy()
 if self._filesfastpath(match):
-m = manifestdict()
+m = manifestdict(self._nodelen)
 lm = self._lm
 for fn in match.files():
 if fn in lm:
 m._lm[fn] = lm[fn]
 return m
-m = manifestdict()
+m = manifestdict(self._nodelen)
 m._lm = self._lm.filtercopy(match)
 return m
 def diff(self, m2, match=None, clean=False):
 """Finds changes between the current manifest and m2.
 return self._lm[key][1]
 except KeyError:
 return b''
 def copy(self):
-c = manifestdict()
+c = manifestdict(self._nodelen)
 c._lm = self._lm.copy()
 return c
 def items(self):
 return (x[:2] for x in self._lm.iterentries())
 class treemanifest(object):
 def __init__(self, nodeconstants, dir=b'', text=b''):
 self._dir = dir
 self.nodeconstants = nodeconstants
 self._node = self.nodeconstants.nullid
+self._nodelen = self.nodeconstants.nodelen
 self._loadfunc = _noop
 self._copyfunc = _noop
 self._dirty = False
 self._dirs = {}
 self._lazydirs = {}
 def unmodifiedsince(self, m2):
 return not self._dirty and not m2._dirty and self._node == m2._node
 def parse(self, text, readsubtree):
 selflazy = self._lazydirs
-for f, n, fl in _parse(text):
+for f, n, fl in _parse(self._nodelen, text):
 if fl == b't':
 f = f + b'/'
 # False below means "doesn't need to be copied" and can use the
 # cached value from readsubtree directly.
 selflazy[f] = (n, readsubtree, False)
 @interfaceutil.implementer(repository.imanifestrevisionwritable)
 class memmanifestctx(object):
 def __init__(self, manifestlog):
 self._manifestlog = manifestlog
-self._manifestdict = manifestdict()
+self._manifestdict = manifestdict(manifestlog.nodeconstants.nodelen)
 def _storage(self):
 return self._manifestlog.getstorage(b'')
 def copy(self):
 def parents(self):
 return self._storage().parents(self._node)
 def read(self):
 if self._data is None:
-if self._node == self._manifestlog.nodeconstants.nullid:
+nc = self._manifestlog.nodeconstants
-self._data = manifestdict()
+if self._node == nc.nullid:
+self._data = manifestdict(nc.nodelen)
 else:
 store = self._storage()
 if self._node in store.fulltextcache:
 text = pycompat.bytestr(store.fulltextcache[self._node])
 else:
 text = store.revision(self._node)
 arraytext = bytearray(text)
 store.fulltextcache[self._node] = arraytext
-self._data = manifestdict(text)
+self._data = manifestdict(nc.nodelen, text)
 return self._data
 def readfast(self, shallow=False):
 """Calls either readdelta or read, based on which would be less work.
 readdelta is called if the delta is against the p1, and therefore can be
 Changing the value of `shallow` has no effect on flat manifests.
 """
 store = self._storage()
 r = store.rev(self._node)
 d = mdiff.patchtext(store.revdiff(store.deltaparent(r), r))
-return manifestdict(d)
+return manifestdict(store.nodeconstants.nodelen, d)
 def find(self, key):
 return self.read().find(key)
 """
 store = self._storage()
 if shallow:
 r = store.rev(self._node)
 d = mdiff.patchtext(store.revdiff(store.deltaparent(r), r))
-return manifestdict(d)
+return manifestdict(store.nodeconstants.nodelen, d)
 else:
 # Need to perform a slow delta
 r0 = store.deltaparent(store.rev(self._node))
 m0 = self._manifestlog.get(self._dir, store.node(r0)).read()
 m1 = self.read()
 deltaparent = store.deltaparent(r)
 if deltaparent != nullrev and deltaparent in store.parentrevs(r):
 return self.readdelta(shallow=shallow)
 if shallow:
-return manifestdict(store.revision(self._node))
+return manifestdict(
+store.nodeconstants.nodelen, store.revision(self._node)
+)
 else:
 return self.read()
 def find(self, key):
 return self.read().find(key)

changeset 47043	12450fbea288
parent 47012	d55b71393907
child 47072	4c041c71ec01