Mercurial Mercurial > mercurial / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
mercurial/manifest.py
changeset 48913 f254fc73d956
parent 48875 6000f5b25c9b
child 48926 3d35e7483602
equal deleted inserted replaced
48912:a0674e916fb6 48913:f254fc73d956 
   865           other (it may already be loaded or it may not exist, doesn't matter)
 
   865           other (it may already be loaded or it may not exist, doesn't matter)
 
   866         - if it's present in _lazydirs in both, compare the nodeid; if it
 
   866         - if it's present in _lazydirs in both, compare the nodeid; if it
 
   867           differs, load it in both
 
   867           differs, load it in both
 
   868         """
 
   868         """
 
   869         toloadlazy = []
 
   869         toloadlazy = []
 
   870         for d, v1 in pycompat.iteritems(t1._lazydirs):
 
   870         for d, v1 in t1._lazydirs.items():
 
   871             v2 = t2._lazydirs.get(d)
 
   871             v2 = t2._lazydirs.get(d)
 
   872             if not v2 or v2[0] != v1[0]:
 
   872             if not v2 or v2[0] != v1[0]:
 
   873                 toloadlazy.append(d)
 
   873                 toloadlazy.append(d)
 
   874         for d, v1 in pycompat.iteritems(t2._lazydirs):
 
   874         for d, v1 in t2._lazydirs.items():
 
   875             if d not in t1._lazydirs:
 
   875             if d not in t1._lazydirs:
 
   876                 toloadlazy.append(d)
 
   876                 toloadlazy.append(d)
 
   877 
   877 
   878         for d in toloadlazy:
 
   878         for d in toloadlazy:
 
   879             t1._loadlazy(d)
 
   879             t1._loadlazy(d)
 
   951             itertools.chain(self._dirs.items(), self._files.items())
 
   951             itertools.chain(self._dirs.items(), self._files.items())
 
   952         ):
 
   952         ):
 
   953             if p in self._files:
 
   953             if p in self._files:
 
   954                 yield self._subpath(p), n
 
   954                 yield self._subpath(p), n
 
   955             else:
 
   955             else:
 
   956                 for f, sn in pycompat.iteritems(n):
 
   956                 for f, sn in n.items():
 
   957                     yield f, sn
 
   957                     yield f, sn
 
   958 
   958 
   959     iteritems = items
 
   959     iteritems = items
 
   960 
   960 
   961     def iterkeys(self):
 
   961     def iterkeys(self):
 
  1102         if self._copyfunc is _noop:
 
  1102         if self._copyfunc is _noop:
 
  1103 
  1103 
  1104             def _copyfunc(s):
 
  1104             def _copyfunc(s):
 
  1105                 self._load()
 
  1105                 self._load()
 
  1106                 s._lazydirs = {
 
  1106                 s._lazydirs = {
 
  1107                     d: (n, r, True)
 
  1107                     d: (n, r, True) for d, (n, r, c) in self._lazydirs.items()
 
  1108                     for d, (n, r, c) in pycompat.iteritems(self._lazydirs)
 
       
  1109                 }
 
  1108                 }
 
  1110                 sdirs = s._dirs
 
  1109                 sdirs = s._dirs
 
  1111                 for d, v in pycompat.iteritems(self._dirs):
 
  1110                 for d, v in self._dirs.items():
 
  1112                     sdirs[d] = v.copy()
 
  1111                     sdirs[d] = v.copy()
 
  1113                 s._files = dict.copy(self._files)
 
  1112                 s._files = dict.copy(self._files)
 
  1114                 s._flags = dict.copy(self._flags)
 
  1113                 s._flags = dict.copy(self._flags)
 
  1115 
  1114 
  1116             if self._loadfunc is _noop:
 
  1115             if self._loadfunc is _noop:
 
  1134             if t1._node == t2._node and not t1._dirty and not t2._dirty:
 
  1133             if t1._node == t2._node and not t1._dirty and not t2._dirty:
 
  1135                 return
 
  1134                 return
 
  1136             t1._load()
 
  1135             t1._load()
 
  1137             t2._load()
 
  1136             t2._load()
 
  1138             self._loaddifflazy(t1, t2)
 
  1137             self._loaddifflazy(t1, t2)
 
  1139             for d, m1 in pycompat.iteritems(t1._dirs):
 
  1138             for d, m1 in t1._dirs.items():
 
  1140                 if d in t2._dirs:
 
  1139                 if d in t2._dirs:
 
  1141                     m2 = t2._dirs[d]
 
  1140                     m2 = t2._dirs[d]
 
  1142                     _filesnotin(m1, m2)
 
  1141                     _filesnotin(m1, m2)
 
  1143                 else:
 
  1142                 else:
 
  1144                     files.update(m1.iterkeys())
 
  1143                     files.update(m1.iterkeys())
 
  1247             ret._files[fn] = self._files[fn]
 
  1246             ret._files[fn] = self._files[fn]
 
  1248             if fn in self._flags:
 
  1247             if fn in self._flags:
 
  1249                 ret._flags[fn] = self._flags[fn]
 
  1248                 ret._flags[fn] = self._flags[fn]
 
  1250 
  1249 
  1251         visit = self._loadchildrensetlazy(visit)
 
  1250         visit = self._loadchildrensetlazy(visit)
 
  1252         for dir, subm in pycompat.iteritems(self._dirs):
 
  1251         for dir, subm in self._dirs.items():
 
  1253             if visit and dir[:-1] not in visit:
 
  1252             if visit and dir[:-1] not in visit:
 
  1254                 continue
 
  1253                 continue
 
  1255             m = subm._matches_inner(match)
 
  1254             m = subm._matches_inner(match)
 
  1256             if not m._isempty():
 
  1255             if not m._isempty():
 
  1257                 ret._dirs[dir] = m
 
  1256                 ret._dirs[dir] = m
 
  1292                 return
 
  1291                 return
 
  1293             t1._load()
 
  1292             t1._load()
 
  1294             t2._load()
 
  1293             t2._load()
 
  1295             self._loaddifflazy(t1, t2)
 
  1294             self._loaddifflazy(t1, t2)
 
  1296 
  1295 
  1297             for d, m1 in pycompat.iteritems(t1._dirs):
 
  1296             for d, m1 in t1._dirs.items():
 
  1298                 m2 = t2._dirs.get(d, emptytree)
 
  1297                 m2 = t2._dirs.get(d, emptytree)
 
  1299                 stack.append((m1, m2))
 
  1298                 stack.append((m1, m2))
 
  1300 
  1299 
  1301             for d, m2 in pycompat.iteritems(t2._dirs):
 
  1300             for d, m2 in t2._dirs.items():
 
  1302                 if d not in t1._dirs:
 
  1301                 if d not in t1._dirs:
 
  1303                     stack.append((emptytree, m2))
 
  1302                     stack.append((emptytree, m2))
 
  1304 
  1303 
  1305             for fn, n1 in pycompat.iteritems(t1._files):
 
  1304             for fn, n1 in t1._files.items():
 
  1306                 fl1 = t1._flags.get(fn, b'')
 
  1305                 fl1 = t1._flags.get(fn, b'')
 
  1307                 n2 = t2._files.get(fn, None)
 
  1306                 n2 = t2._files.get(fn, None)
 
  1308                 fl2 = t2._flags.get(fn, b'')
 
  1307                 fl2 = t2._flags.get(fn, b'')
 
  1309                 if n1 != n2 or fl1 != fl2:
 
  1308                 if n1 != n2 or fl1 != fl2:
 
  1310                     result[t1._subpath(fn)] = ((n1, fl1), (n2, fl2))
 
  1309                     result[t1._subpath(fn)] = ((n1, fl1), (n2, fl2))
 
  1311                 elif clean:
 
  1310                 elif clean:
 
  1312                     result[t1._subpath(fn)] = None
 
  1311                     result[t1._subpath(fn)] = None
 
  1313 
  1312 
  1314             for fn, n2 in pycompat.iteritems(t2._files):
 
  1313             for fn, n2 in t2._files.items():
 
  1315                 if fn not in t1._files:
 
  1314                 if fn not in t1._files:
 
  1316                     fl2 = t2._flags.get(fn, b'')
 
  1315                     fl2 = t2._flags.get(fn, b'')
 
  1317                     result[t2._subpath(fn)] = ((None, b''), (n2, fl2))
 
  1316                     result[t2._subpath(fn)] = ((None, b''), (n2, fl2))
 
  1318 
  1317 
  1319         stackls = []
 
  1318         stackls = []
 
  1359         """Get the full data of this directory as a bytestring. Make sure that
 
  1358         """Get the full data of this directory as a bytestring. Make sure that
 
  1360         any submanifests have been written first, so their nodeids are correct.
 
  1359         any submanifests have been written first, so their nodeids are correct.
 
  1361         """
 
  1360         """
 
  1362         self._load()
 
  1361         self._load()
 
  1363         flags = self.flags
 
  1362         flags = self.flags
 
  1364         lazydirs = [
 
  1363         lazydirs = [(d[:-1], v[0], b't') for d, v in self._lazydirs.items()]
 
  1365             (d[:-1], v[0], b't') for d, v in pycompat.iteritems(self._lazydirs)
 
       
  1366         ]
 
       
  1367         dirs = [(d[:-1], self._dirs[d]._node, b't') for d in self._dirs]
 
  1364         dirs = [(d[:-1], self._dirs[d]._node, b't') for d in self._dirs]
 
  1368         files = [(f, self._files[f], flags(f)) for f in self._files]
 
  1365         files = [(f, self._files[f], flags(f)) for f in self._files]
 
  1369         return _text(sorted(dirs + files + lazydirs))
 
  1366         return _text(sorted(dirs + files + lazydirs))
 
  1370 
  1367 
  1371     def read(self, gettext, readsubtree):
 
  1368     def read(self, gettext, readsubtree):
 
  1390         # let's skip investigating things that `match` says we do not need.
 
  1387         # let's skip investigating things that `match` says we do not need.
 
  1391         visit = match.visitchildrenset(self._dir[:-1])
 
  1388         visit = match.visitchildrenset(self._dir[:-1])
 
  1392         visit = self._loadchildrensetlazy(visit)
 
  1389         visit = self._loadchildrensetlazy(visit)
 
  1393         if visit == b'this' or visit == b'all':
 
  1390         if visit == b'this' or visit == b'all':
 
  1394             visit = None
 
  1391             visit = None
 
  1395         for d, subm in pycompat.iteritems(self._dirs):
 
  1392         for d, subm in self._dirs.items():
 
  1396             if visit and d[:-1] not in visit:
 
  1393             if visit and d[:-1] not in visit:
 
  1397                 continue
 
  1394                 continue
 
  1398             subp1 = getnode(m1, d)
 
  1395             subp1 = getnode(m1, d)
 
  1399             subp2 = getnode(m2, d)
 
  1396             subp2 = getnode(m2, d)
 
  1400             if subp1 == self.nodeconstants.nullid:
 
  1397             if subp1 == self.nodeconstants.nullid:
 
  1413             yield self
 
  1410             yield self
 
  1414 
  1411 
  1415         self._load()
 
  1412         self._load()
 
  1416         # OPT: use visitchildrenset to avoid loading everything.
 
  1413         # OPT: use visitchildrenset to avoid loading everything.
 
  1417         self._loadalllazy()
 
  1414         self._loadalllazy()
 
  1418         for d, subm in pycompat.iteritems(self._dirs):
 
  1415         for d, subm in self._dirs.items():
 
  1419             for subtree in subm.walksubtrees(matcher=matcher):
 
  1416             for subtree in subm.walksubtrees(matcher=matcher):
 
  1420                 yield subtree
 
  1417                 yield subtree
 
  1421 
  1418 
  1422 
  1419 
  1423 class manifestfulltextcache(util.lrucachedict):
 
  1420 class manifestfulltextcache(util.lrucachedict):
mercurial