mercurial/dirstate.py
branchstable
changeset 34934 6e66033f91cc
parent 34933 0217f75b6e59
child 34935 ffeea2406276
equal deleted inserted replaced
34933:0217f75b6e59 34934:6e66033f91cc
   127 
   127 
   128     @propertycache
   128     @propertycache
   129     def _map(self):
   129     def _map(self):
   130         '''Return the dirstate contents as a map from filename to
   130         '''Return the dirstate contents as a map from filename to
   131         (state, mode, size, time).'''
   131         (state, mode, size, time).'''
   132         self._read()
   132         self._map = dirstatemap(self._ui, self._opener, self._root)
   133         return self._map
   133         return self._map
   134 
   134 
   135     @property
   135     @property
   136     def _sparsematcher(self):
   136     def _sparsematcher(self):
   137         """The matcher for the sparse checkout.
   137         """The matcher for the sparse checkout.
   350             if ce:
   350             if ce:
   351                 ce.refresh()
   351                 ce.refresh()
   352         except: # re-raises
   352         except: # re-raises
   353             f.discard()
   353             f.discard()
   354             raise
   354             raise
   355 
       
   356     def _read(self):
       
   357         self._map = dirstatemap(self._ui, self._opener, self._root)
       
   358         self._map.read()
       
   359 
   355 
   360     def invalidate(self):
   356     def invalidate(self):
   361         '''Causes the next access to reread the dirstate.
   357         '''Causes the next access to reread the dirstate.
   362 
   358 
   363         This is different from localrepo.invalidatedirstate() because it always
   359         This is different from localrepo.invalidatedirstate() because it always
  1199         self._ui = ui
  1195         self._ui = ui
  1200         self._opener = opener
  1196         self._opener = opener
  1201         self._root = root
  1197         self._root = root
  1202         self._filename = 'dirstate'
  1198         self._filename = 'dirstate'
  1203 
  1199 
  1204         self._map = {}
       
  1205         self.copymap = {}
       
  1206         self._parents = None
  1200         self._parents = None
  1207         self._dirtyparents = False
  1201         self._dirtyparents = False
  1208 
  1202 
  1209         # for consistent view between _pl() and _read() invocations
  1203         # for consistent view between _pl() and _read() invocations
  1210         self._pendingmode = None
  1204         self._pendingmode = None
       
  1205 
       
  1206     @propertycache
       
  1207     def _map(self):
       
  1208         self._map = {}
       
  1209         self.read()
       
  1210         return self._map
       
  1211 
       
  1212     @propertycache
       
  1213     def copymap(self):
       
  1214         self.copymap = {}
       
  1215         self._map
       
  1216         return self.copymap
  1211 
  1217 
  1212     def clear(self):
  1218     def clear(self):
  1213         self._map = {}
  1219         self._map = {}
  1214         self.copymap = {}
  1220         self.copymap = {}
  1215         self.setparents(nullid, nullid)
  1221         self.setparents(nullid, nullid)
  1386         self.nonnormalset = nonnorm
  1392         self.nonnormalset = nonnorm
  1387         return otherparents
  1393         return otherparents
  1388 
  1394 
  1389     @propertycache
  1395     @propertycache
  1390     def identity(self):
  1396     def identity(self):
  1391         self.read()
  1397         self._map
  1392         return self.identity
  1398         return self.identity
  1393 
  1399 
  1394     @propertycache
  1400     @propertycache
  1395     def dirfoldmap(self):
  1401     def dirfoldmap(self):
  1396         f = {}
  1402         f = {}