mercurial/revlog.py
changeset 47385 9d9eb22b9b69
parent 47384 fec306b05328
child 47386 0d0fb091c49f
equal deleted inserted replaced
47384:fec306b05328 47385:9d9eb22b9b69
  1965             msg = (
  1965             msg = (
  1966                 b'revlog.revision(..., raw=True) is deprecated, '
  1966                 b'revlog.revision(..., raw=True) is deprecated, '
  1967                 b'use revlog.rawdata(...)'
  1967                 b'use revlog.rawdata(...)'
  1968             )
  1968             )
  1969             util.nouideprecwarn(msg, b'5.2', stacklevel=2)
  1969             util.nouideprecwarn(msg, b'5.2', stacklevel=2)
  1970         return self._revisiondata(nodeorrev, _df, raw=raw)[0]
  1970         return self._revisiondata(nodeorrev, _df, raw=raw)
  1971 
  1971 
  1972     def sidedata(self, nodeorrev, _df=None):
  1972     def sidedata(self, nodeorrev, _df=None):
  1973         """a map of extra data related to the changeset but not part of the hash
  1973         """a map of extra data related to the changeset but not part of the hash
  1974 
  1974 
  1975         This function currently return a dictionary. However, more advanced
  1975         This function currently return a dictionary. However, more advanced
  1992             node = nodeorrev
  1992             node = nodeorrev
  1993             rev = None
  1993             rev = None
  1994 
  1994 
  1995         # fast path the special `nullid` rev
  1995         # fast path the special `nullid` rev
  1996         if node == self.nullid:
  1996         if node == self.nullid:
  1997             return b"", {}
  1997             return b""
  1998 
  1998 
  1999         # ``rawtext`` is the text as stored inside the revlog. Might be the
  1999         # ``rawtext`` is the text as stored inside the revlog. Might be the
  2000         # revision or might need to be processed to retrieve the revision.
  2000         # revision or might need to be processed to retrieve the revision.
  2001         rev, rawtext, validated = self._rawtext(node, rev, _df=_df)
  2001         rev, rawtext, validated = self._rawtext(node, rev, _df=_df)
  2002 
  2002 
  2003         if self.hassidedata:
       
  2004             if rev is None:
       
  2005                 rev = self.rev(node)
       
  2006             sidedata = self._sidedata(rev)
       
  2007         else:
       
  2008             sidedata = {}
       
  2009 
       
  2010         if raw and validated:
  2003         if raw and validated:
  2011             # if we don't want to process the raw text and that raw
  2004             # if we don't want to process the raw text and that raw
  2012             # text is cached, we can exit early.
  2005             # text is cached, we can exit early.
  2013             return rawtext, sidedata
  2006             return rawtext
  2014         if rev is None:
  2007         if rev is None:
  2015             rev = self.rev(node)
  2008             rev = self.rev(node)
  2016         # the revlog's flag for this revision
  2009         # the revlog's flag for this revision
  2017         # (usually alter its state or content)
  2010         # (usually alter its state or content)
  2018         flags = self.flags(rev)
  2011         flags = self.flags(rev)
  2019 
  2012 
  2020         if validated and flags == REVIDX_DEFAULT_FLAGS:
  2013         if validated and flags == REVIDX_DEFAULT_FLAGS:
  2021             # no extra flags set, no flag processor runs, text = rawtext
  2014             # no extra flags set, no flag processor runs, text = rawtext
  2022             return rawtext, sidedata
  2015             return rawtext
  2023 
  2016 
  2024         if raw:
  2017         if raw:
  2025             validatehash = flagutil.processflagsraw(self, rawtext, flags)
  2018             validatehash = flagutil.processflagsraw(self, rawtext, flags)
  2026             text = rawtext
  2019             text = rawtext
  2027         else:
  2020         else:
  2030         if validatehash:
  2023         if validatehash:
  2031             self.checkhash(text, node, rev=rev)
  2024             self.checkhash(text, node, rev=rev)
  2032         if not validated:
  2025         if not validated:
  2033             self._revisioncache = (node, rev, rawtext)
  2026             self._revisioncache = (node, rev, rawtext)
  2034 
  2027 
  2035         return text, sidedata
  2028         return text
  2036 
  2029 
  2037     def _rawtext(self, node, rev, _df=None):
  2030     def _rawtext(self, node, rev, _df=None):
  2038         """return the possibly unvalidated rawtext for a revision
  2031         """return the possibly unvalidated rawtext for a revision
  2039 
  2032 
  2040         returns (rev, rawtext, validated)
  2033         returns (rev, rawtext, validated)
  2107     def rawdata(self, nodeorrev, _df=None):
  2100     def rawdata(self, nodeorrev, _df=None):
  2108         """return an uncompressed raw data of a given node or revision number.
  2101         """return an uncompressed raw data of a given node or revision number.
  2109 
  2102 
  2110         _df - an existing file handle to read from. (internal-only)
  2103         _df - an existing file handle to read from. (internal-only)
  2111         """
  2104         """
  2112         return self._revisiondata(nodeorrev, _df, raw=True)[0]
  2105         return self._revisiondata(nodeorrev, _df, raw=True)
  2113 
  2106 
  2114     def hash(self, text, p1, p2):
  2107     def hash(self, text, p1, p2):
  2115         """Compute a node hash.
  2108         """Compute a node hash.
  2116 
  2109 
  2117         Available as a function so that subclasses can replace the hash
  2110         Available as a function so that subclasses can replace the hash
  3107             # (Possibly) reuse the delta from the revlog if allowed and
  3100             # (Possibly) reuse the delta from the revlog if allowed and
  3108             # the revlog chunk is a delta.
  3101             # the revlog chunk is a delta.
  3109             cachedelta = None
  3102             cachedelta = None
  3110             rawtext = None
  3103             rawtext = None
  3111             if deltareuse == self.DELTAREUSEFULLADD:
  3104             if deltareuse == self.DELTAREUSEFULLADD:
  3112                 text = self._revisiondata(rev)[0]
  3105                 text = self._revisiondata(rev)
  3113                 sidedata = self.sidedata(rev)
  3106                 sidedata = self.sidedata(rev)
  3114 
  3107 
  3115                 if sidedata_helpers is not None:
  3108                 if sidedata_helpers is not None:
  3116                     (sidedata, new_flags) = sidedatautil.run_sidedata_helpers(
  3109                     (sidedata, new_flags) = sidedatautil.run_sidedata_helpers(
  3117                         self, sidedata_helpers, sidedata, rev
  3110                         self, sidedata_helpers, sidedata, rev
  3136                     if dp != nullrev:
  3129                     if dp != nullrev:
  3137                         cachedelta = (dp, bytes(self._chunk(rev)))
  3130                         cachedelta = (dp, bytes(self._chunk(rev)))
  3138 
  3131 
  3139                 sidedata = None
  3132                 sidedata = None
  3140                 if not cachedelta:
  3133                 if not cachedelta:
  3141                     rawtext = self._revisiondata(rev)[0]
  3134                     rawtext = self._revisiondata(rev)
  3142                     sidedata = self.sidedata(rev)
  3135                     sidedata = self.sidedata(rev)
  3143                 if sidedata is None:
  3136                 if sidedata is None:
  3144                     sidedata = self.sidedata(rev)
  3137                     sidedata = self.sidedata(rev)
  3145 
  3138 
  3146                 if sidedata_helpers is not None:
  3139                 if sidedata_helpers is not None: