mercurial: comparison mercurial/branchmap.py

equal deleted inserted replaced

-:a03fa40afd01
+:fa9e3976a5a0
 Optional,
 Set,
 TYPE_CHECKING,
 Tuple,
 Union,
+cast,
 )
 from . import (
 encoding,
 error,
 class _LocalBranchCache(_BaseBranchCache):
 """base class of branch-map info for a local repo or repoview"""
 _base_filename = None
+_default_key_hashes: Tuple[bytes] = cast(Tuple[bytes], ())
 def __init__(
 self,
 repo: "localrepo.localrepository",
 entries: Union[
 Dict[bytes, List[bytes]], Iterable[Tuple[bytes, List[bytes]]]
 ] = (),
 tipnode: Optional[bytes] = None,
 tiprev: Optional[int] = nullrev,
-filteredhash: Optional[bytes] = None,
+key_hashes: Optional[Tuple[bytes]] = None,
 closednodes: Optional[Set[bytes]] = None,
 hasnode: Optional[Callable[[bytes], bool]] = None,
 verify_node: bool = False,
 inherited: bool = False,
 ) -> None:
 if tipnode is None:
 self.tipnode = repo.nullid
 else:
 self.tipnode = tipnode
 self.tiprev = tiprev
-self.filteredhash = filteredhash
+if key_hashes is None:
+self.key_hashes = self._default_key_hashes
+else:
+self.key_hashes = key_hashes
 self._state = STATE_CLEAN
 if inherited:
 self._state = STATE_INHERITED
 super().__init__(repo=repo, entries=entries, closed_nodes=closednodes)
 # branches for which nodes are verified
 self._verifiedbranches = set()
 self._hasnode = None
 if self._verify_node:
 self._hasnode = repo.changelog.hasnode
+def _compute_key_hashes(self, repo) -> Tuple[bytes]:
+raise NotImplementedError
 def validfor(self, repo):
 """check that cache contents are valid for (a subset of) this repo
 - False when the order of changesets changed or if we detect a strip.
 return False
 if self.tipnode != node:
 # tiprev doesn't correspond to tipnode: repo was stripped, or this
 # repo has a different order of changesets
 return False
-tiphash = scmutil.combined_filtered_and_obsolete_hash(
+repo_key_hashes = self._compute_key_hashes(repo)
-repo,
-self.tiprev,
-needobsolete=True,
-)
 # hashes don't match if this repo view has a different set of filtered
 # revisions (e.g. due to phase changes) or obsolete revisions (e.g.
 # history was rewritten)
-return self.filteredhash == tiphash
+return self.key_hashes == repo_key_hashes
 @classmethod
 def fromfile(cls, repo):
 f = None
 try:
 return bcache
 @classmethod
 def _load_header(cls, repo, lineiter) -> "dict[str, Any]":
-"""parse the head of a branchmap file
+raise NotImplementedError
-return parameters to pass to a newly created class instance.
-"""
-cachekey = next(lineiter).rstrip(b'\n').split(b" ", 2)
-last, lrev = cachekey[:2]
-last, lrev = bin(last), int(lrev)
-filteredhash = None
-if len(cachekey) > 2:
-filteredhash = bin(cachekey[2])
-return {
-"tipnode": last,
-"tiprev": lrev,
-"filteredhash": filteredhash,
-}
 def _load_heads(self, repo, lineiter):
 """fully loads the branchcache by reading from the file using the line
 iterator passed"""
 for line in lineiter:
 # always replaced, so no need to deepcopy until the above remains
 # true.
 entries=self._entries,
 tipnode=self.tipnode,
 tiprev=self.tiprev,
-filteredhash=self.filteredhash,
+key_hashes=self.key_hashes,
 closednodes=set(self._closednodes),
 verify_node=self._verify_node,
 inherited=True,
 )
 # also copy information about the current verification state
 b"couldn't write branch cache: %s\n"
 % stringutil.forcebytestr(inst)
 )
 def _write_header(self, fp) -> None:
-"""write the branch cache header to a file"""
+raise NotImplementedError
-cachekey = [hex(self.tipnode), b'%d' % self.tiprev]
-if self.filteredhash is not None:
-cachekey.append(hex(self.filteredhash))
-fp.write(b" ".join(cachekey) + b'\n')
 def _write_heads(self, fp) -> int:
 """write list of heads to a file
 Return the number of heads written."""
 # invalid for the repo.
 #
 # However. we've just updated the cache and we assume it's valid,
 # so let's make the cache key valid as well by recomputing it from
 # the cached data
+self.key_hashes = self._compute_key_hashes(repo)
 self.filteredhash = scmutil.combined_filtered_and_obsolete_hash(
 repo,
 self.tiprev,
-needobsolete=True,
 )
 self._state = STATE_DIRTY
 tr = repo.currenttransaction()
 if getattr(tr, 'finalized', True):
 branch head closes a branch or not.
 """
 _base_filename = b"branch2"
+@classmethod
+def _load_header(cls, repo, lineiter) -> "dict[str, Any]":
+"""parse the head of a branchmap file
+return parameters to pass to a newly created class instance.
+"""
+cachekey = next(lineiter).rstrip(b'\n').split(b" ", 2)
+last, lrev = cachekey[:2]
+last, lrev = bin(last), int(lrev)
+filteredhash = ()
+if len(cachekey) > 2:
+filteredhash = (bin(cachekey[2]),)
+return {
+"tipnode": last,
+"tiprev": lrev,
+"key_hashes": filteredhash,
+}
+def _write_header(self, fp) -> None:
+"""write the branch cache header to a file"""
+cachekey = [hex(self.tipnode), b'%d' % self.tiprev]
+if self.key_hashes:
+cachekey.append(hex(self.key_hashes[0]))
+fp.write(b" ".join(cachekey) + b'\n')
+def _compute_key_hashes(self, repo) -> Tuple[bytes]:
+"""return the cache key hashes that match this repoview state"""
+filtered_hash = scmutil.combined_filtered_and_obsolete_hash(
+repo,
+self.tiprev,
+needobsolete=True,
+)
+keys: Tuple[bytes] = cast(Tuple[bytes], ())
+if filtered_hash is not None:
+keys: Tuple[bytes] = (filtered_hash,)
+return keys
 class BranchCacheV3(_LocalBranchCache):
 """a branch cache using version 3 of the format on disk
 This version is still EXPERIMENTAL and the format is subject to changes.
 def _write_header(self, fp) -> None:
 cache_keys = {
 b"tip-node": hex(self.tipnode),
 b"tip-rev": b'%d' % self.tiprev,
 }
-if self.filteredhash is not None:
+if self.key_hashes:
-cache_keys[b"filtered-hash"] = hex(self.filteredhash)
+cache_keys[b"filtered-hash"] = hex(self.key_hashes[0])
 pieces = (b"%s=%s" % i for i in sorted(cache_keys.items()))
 fp.write(b" ".join(pieces) + b'\n')
 @classmethod
 def _load_header(cls, repo, lineiter):
 if k == b"tip-rev":
 args["tiprev"] = int(v)
 elif k == b"tip-node":
 args["tipnode"] = bin(v)
 elif k == b"filtered-hash":
-args["filteredhash"] = bin(v)
+args["key_hashes"] = (bin(v),)
 else:
 msg = b"unknown cache key: %r" % k
 raise ValueError(msg)
 return args
+def _compute_key_hashes(self, repo) -> Tuple[bytes]:
+"""return the cache key hashes that match this repoview state"""
+filtered_hash = scmutil.combined_filtered_and_obsolete_hash(
+repo,
+self.tiprev,
+needobsolete=True,
+)
+if filtered_hash is None:
+return cast(Tuple[bytes], ())
+else:
+return (filtered_hash,)
 class remotebranchcache(_BaseBranchCache):
 """Branchmap info for a remote connection, should not write locally"""

changeset 51527	fa9e3976a5a0
parent 51526	a03fa40afd01
child 51529	4141d12de073