mercurial: comparison mercurial/manifest.py

equal deleted inserted replaced

-:d71837d06597
+:3e5c4af69808
 from i18n import _
 import mdiff, parsers, error, revlog, util
 import array, struct
-# Pure Python fallback
-def _parsemanifest(mfdict, fdict, lines):
+class _lazymanifest(dict):
-bin = revlog.bin
+"""This is the pure implementation of lazymanifest.
-for l in lines.splitlines():
-f, n = l.split('\0')
+It has not been optimized *at all* and is not lazy.
-if len(n) > 40:
+"""
-fdict[f] = n[40:]
-mfdict[f] = bin(n[:40])
+def __init__(self, data):
-else:
+# This init method does a little bit of excessive-looking
-mfdict[f] = bin(n)
+# precondition checking. This is so that the behavior of this
+# class exactly matches its C counterpart to try and help
-def _parse(lines, mfdict, flags):
+# prevent surprise breakage for anyone that develops against
-try:
+# the pure version.
-parsers.parse_manifest(mfdict, flags, lines)
+if data and data[-1] != '\n':
-except AttributeError:
+raise ValueError('Manifest did not end in a newline.')
-_parsemanifest(mfdict, flags, lines)
+dict.__init__(self)
-return mfdict
+prev = None
+for l in data.splitlines():
-class manifestdict(dict):
+if prev is not None and prev > l:
+raise ValueError('Manifest lines not in sorted order.')
+prev = l
+f, n = l.split('\0')
+if len(n) > 40:
+self[f] = revlog.bin(n[:40]), n[40:]
+else:
+self[f] = revlog.bin(n), ''
+def __setitem__(self, k, v):
+node, flag = v
+assert node is not None
+if len(node) > 21:
+node = node[:21] # match c implementation behavior
+dict.__setitem__(self, k, (node, flag))
+def __iter__(self):
+return ((f, e[0], e[1]) for f, e in sorted(self.iteritems()))
+def copy(self):
+c = _lazymanifest('')
+c.update(self)
+return c
+def diff(self, m2, clean=False):
+'''Finds changes between the current manifest and m2.'''
+diff = {}
+for fn, e1 in self.iteritems():
+if fn not in m2:
+diff[fn] = e1, (None, '')
+else:
+e2 = m2[fn]
+if e1 != e2:
+diff[fn] = e1, e2
+elif clean:
+diff[fn] = None
+for fn, e2 in m2.iteritems():
+if fn not in self:
+diff[fn] = (None, ''), e2
+return diff
+def filtercopy(self, filterfn):
+c = _lazymanifest('')
+for f, n, fl in self:
+if filterfn(f):
+c[f] = n, fl
+return c
+def text(self):
+"""Get the full data of this manifest as a bytestring."""
+fl = sorted(self)
+_hex = revlog.hex
+# if this is changed to support newlines in filenames,
+# be sure to check the templates/ dir again (especially *-raw.tmpl)
+return ''.join("%s\0%s%s\n" % (
+f, _hex(n[:20]), flag) for f, n, flag in fl)
+class manifestdict(object):
 def __init__(self, data=''):
-self._flags = {}
+self._lm = _lazymanifest(data)
-_parse(data, self, self._flags)
+def __getitem__(self, key):
-def __setitem__(self, k, v):
+return self._lm[key][0]
-assert v is not None
-dict.__setitem__(self, k, v)
+def __len__(self):
-def flags(self, f):
+return len(self._lm)
-return self._flags.get(f, "")
-def setflag(self, f, flags):
+def __setitem__(self, key, node):
-"""Set the flags (symlink, executable) for path f."""
+self._lm[key] = node, self.flags(key, '')
-self._flags[f] = flags
-def copy(self):
+def __contains__(self, key):
-copy = manifestdict()
+return key in self._lm
-dict.__init__(copy, self)
-copy._flags = dict.copy(self._flags)
+def __delitem__(self, key):
-return copy
+del self._lm[key]
+def keys(self):
+return [x[0] for x in self._lm]
+def iterkeys(self):
+return iter(self.keys())
 def intersectfiles(self, files):
-'''make a new manifestdict with the intersection of self with files
+'''make a new lazymanifest with the intersection of self with files
 The algorithm assumes that files is much smaller than self.'''
 ret = manifestdict()
+lm = self._lm
 for fn in files:
-if fn in self:
+if fn in lm:
-ret[fn] = self[fn]
+ret._lm[fn] = self._lm[fn]
-flags = self._flags.get(fn, None)
-if flags:
-ret._flags[fn] = flags
 return ret
 def filesnotin(self, m2):
 '''Set of files in this manifest that are not in the other'''
 files = set(self.iterkeys())
 files = match.files()
 if (match.matchfn == match.exact or
 (not match.anypats() and util.all(fn in self for fn in files))):
 return self.intersectfiles(files)
-m = self.copy()
+lm = manifestdict('')
-for fn in m.keys():
+lm._lm = self._lm.filtercopy(match)
-if not match(fn):
+return lm
-del m[fn]
-return m
 def diff(self, m2, clean=False):
 '''Finds changes between the current manifest and m2.
 Args:
 nodeid in the current/other manifest and fl1/fl2 is the flag
 in the current/other manifest. Where the file does not exist,
 the nodeid will be None and the flags will be the empty
 string.
 '''
-diff = {}
+return self._lm.diff(m2._lm, clean)
-for fn, n1 in self.iteritems():
+def setflag(self, key, flag):
-fl1 = self._flags.get(fn, '')
+self._lm[key] = self[key], flag
-n2 = m2.get(fn, None)
-fl2 = m2._flags.get(fn, '')
+def get(self, key, default=None):
-if n2 is None:
+try:
-fl2 = ''
+return self._lm[key][0]
-if n1 != n2 or fl1 != fl2:
+except KeyError:
-diff[fn] = ((n1, fl1), (n2, fl2))
+return default
-elif clean:
-diff[fn] = None
+def flags(self, key, default=''):
+try:
-for fn, n2 in m2.iteritems():
+return self._lm[key][1]
-if fn not in self:
+except KeyError:
-fl2 = m2._flags.get(fn, '')
+return default
-diff[fn] = ((None, ''), (n2, fl2))
+def __iter__(self):
-return diff
+return (x[0] for x in self._lm)
+def copy(self):
+c = manifestdict('')
+c._lm = self._lm.copy()
+return c
+def iteritems(self):
+return (x[:2] for x in self._lm)
 def text(self):
-"""Get the full data of this manifest as a bytestring."""
+return self._lm.text()
-fl = sorted(self)
-_checkforbidden(fl)
-hex, flags = revlog.hex, self.flags
-# if this is changed to support newlines in filenames,
-# be sure to check the templates/ dir again (especially *-raw.tmpl)
-return ''.join("%s\0%s%s\n" % (f, hex(self[f]), flags(f)) for f in fl)
 def fastdelta(self, base, changes):
 """Given a base manifest text as an array.array and a list of changes
 relative to that text, compute a delta that can be used by revlog.
 """
 # each line and creates the deltas
 for f, todelete in changes:
 # bs will either be the index of the item or the insert point
 start, end = _msearch(addbuf, f, start)
 if not todelete:
-l = "%s\0%s%s\n" % (f, revlog.hex(self[f]), self.flags(f))
+h, fl = self._lm[f]
+l = "%s\0%s%s\n" % (f, revlog.hex(h), fl)
 else:
 if start == end:
 # item we want to delete was not found, error out
 raise AssertionError(
 _("failed to remove %s from manifest") % f)
 return (node, flags) pair if found, (None, None) if not.'''
 if node in self._mancache:
 m = self._mancache[node][0]
 return m.get(f), m.flags(f)
 text = self.revision(node)
-start, end = _msearch(text, f)
+try:
-if start == end:
+return manifestdict(text)._lm[f]
+except KeyError:
 return None, None
-l = text[start:end]
-f, n = l.split('\0')
-return revlog.bin(n[:40]), n[40:-1]
 def add(self, m, transaction, link, p1, p2, added, removed):
 if p1 in self._mancache:
 # If our first parent is in the manifest cache, we can
 # compute a delta here using properties we know about the

changeset 24225	3e5c4af69808
parent 24224	d71837d06597
child 24226	b992769dd1be