D3154: filelog: wrap revlog instead of inheriting it (API)

indygreg (Gregory Szorc) phabricator at mercurial-scm.org
Mon Apr 9 18:37:29 EDT 2018


This revision was automatically updated to reflect the committed changes.
Closed by commit rHG1541e1a8e87d: filelog: wrap revlog instead of inheriting it (API) (authored by indygreg, committed by ).

REPOSITORY
  rHG Mercurial

CHANGES SINCE LAST UPDATE
  https://phab.mercurial-scm.org/D3154?vs=7860&id=7919

REVISION DETAIL
  https://phab.mercurial-scm.org/D3154

AFFECTED FILES
  mercurial/bundlerepo.py
  mercurial/filelog.py
  mercurial/unionrepo.py

CHANGE DETAILS

diff --git a/mercurial/unionrepo.py b/mercurial/unionrepo.py
--- a/mercurial/unionrepo.py
+++ b/mercurial/unionrepo.py
@@ -92,7 +92,7 @@
 
         return mdiff.textdiff(self.revision(rev1), self.revision(rev2))
 
-    def revision(self, nodeorrev, raw=False):
+    def revision(self, nodeorrev, _df=None, raw=False):
         """return an uncompressed revision of a given node or revision
         number.
         """
@@ -163,13 +163,15 @@
     def baserevdiff(self, rev1, rev2):
         return manifest.manifestrevlog.revdiff(self, rev1, rev2)
 
-class unionfilelog(unionrevlog, filelog.filelog):
+class unionfilelog(filelog.filelog):
     def __init__(self, opener, path, opener2, linkmapper, repo):
         filelog.filelog.__init__(self, opener, path)
         filelog2 = filelog.filelog(opener2, path)
-        unionrevlog.__init__(self, opener, self.indexfile, filelog2,
-                             linkmapper)
+        self._revlog = unionrevlog(opener, self.indexfile,
+                                   filelog2._revlog, linkmapper)
         self._repo = repo
+        self.repotiprev = self._revlog.repotiprev
+        self.revlog2 = self._revlog.revlog2
 
     def baserevision(self, nodeorrev):
         return filelog.filelog.revision(self, nodeorrev)
diff --git a/mercurial/filelog.py b/mercurial/filelog.py
--- a/mercurial/filelog.py
+++ b/mercurial/filelog.py
@@ -11,18 +11,112 @@
     interface as zi,
 )
 from . import (
+    error,
     repository,
     revlog,
 )
 
 @zi.implementer(repository.ifilestorage)
-class filelog(revlog.revlog):
+class filelog(object):
     def __init__(self, opener, path):
-        super(filelog, self).__init__(opener,
-                        "/".join(("data", path + ".i")),
-                                      censorable=True)
+        self._revlog = revlog.revlog(opener,
+                                     '/'.join(('data', path + '.i')),
+                                     censorable=True)
         # full name of the user visible file, relative to the repository root
         self.filename = path
+        self.index = self._revlog.index
+        self.version = self._revlog.version
+        self.storedeltachains = self._revlog.storedeltachains
+        self._generaldelta = self._revlog._generaldelta
+
+    def __len__(self):
+        return len(self._revlog)
+
+    def __iter__(self):
+        return self._revlog.__iter__()
+
+    def revs(self, start=0, stop=None):
+        return self._revlog.revs(start=start, stop=stop)
+
+    def parents(self, node):
+        return self._revlog.parents(node)
+
+    def parentrevs(self, rev):
+        return self._revlog.parentrevs(rev)
+
+    def rev(self, node):
+        return self._revlog.rev(node)
+
+    def node(self, rev):
+        return self._revlog.node(rev)
+
+    def lookup(self, node):
+        return self._revlog.lookup(node)
+
+    def linkrev(self, rev):
+        return self._revlog.linkrev(rev)
+
+    def flags(self, rev):
+        return self._revlog.flags(rev)
+
+    def commonancestorsheads(self, node1, node2):
+        return self._revlog.commonancestorsheads(node1, node2)
+
+    def descendants(self, revs):
+        return self._revlog.descendants(revs)
+
+    def headrevs(self):
+        return self._revlog.headrevs()
+
+    def heads(self, start=None, stop=None):
+        return self._revlog.heads(start, stop)
+
+    def children(self, node):
+        return self._revlog.children(node)
+
+    def deltaparent(self, rev):
+        return self._revlog.deltaparent(rev)
+
+    def candelta(self, baserev, rev):
+        return self._revlog.candelta(baserev, rev)
+
+    def iscensored(self, rev):
+        return self._revlog.iscensored(rev)
+
+    def rawsize(self, rev):
+        return self._revlog.rawsize(rev)
+
+    def checkhash(self, text, node, p1=None, p2=None, rev=None):
+        return self._revlog.checkhash(text, node, p1=p1, p2=p2, rev=rev)
+
+    def revision(self, node, _df=None, raw=False):
+        return self._revlog.revision(node, _df=_df, raw=raw)
+
+    def revdiff(self, rev1, rev2):
+        return self._revlog.revdiff(rev1, rev2)
+
+    def addrevision(self, revisiondata, transaction, linkrev, p1, p2,
+                    node=None, flags=revlog.REVIDX_DEFAULT_FLAGS,
+                    cachedelta=None):
+        return self._revlog.addrevision(revisiondata, transaction, linkrev,
+                                    p1, p2, node=node, flags=flags,
+                                    cachedelta=cachedelta)
+
+    def addgroup(self, deltas, linkmapper, transaction, addrevisioncb=None):
+        return self._revlog.addgroup(deltas, linkmapper, transaction,
+                                 addrevisioncb=addrevisioncb)
+
+    def getstrippoint(self, minlink):
+        return self._revlog.getstrippoint(minlink)
+
+    def strip(self, minlink, transaction):
+        return self._revlog.strip(minlink, transaction)
+
+    def files(self):
+        return self._revlog.files()
+
+    def checksize(self):
+        return self._revlog.checksize()
 
     def read(self, node):
         t = self.revision(node)
@@ -56,7 +150,7 @@
             return 0
 
         # XXX if self.read(node).startswith("\1\n"), this returns (size+4)
-        return super(filelog, self).size(rev)
+        return self._revlog.size(rev)
 
     def cmp(self, node, text):
         """compare text with a given file revision
@@ -68,7 +162,7 @@
         if text.startswith('\1\n'):
             t = '\1\n\1\n' + text
 
-        samehashes = not super(filelog, self).cmp(node, t)
+        samehashes = not self._revlog.cmp(node, t)
         if samehashes:
             return False
 
@@ -83,3 +177,91 @@
             return t2 != text
 
         return True
+
+    @property
+    def filename(self):
+        return self._revlog.filename
+
+    @filename.setter
+    def filename(self, value):
+        self._revlog.filename = value
+
+    # TODO these aren't part of the interface and aren't internal methods.
+    # Callers should be fixed to not use them.
+    @property
+    def indexfile(self):
+        return self._revlog.indexfile
+
+    @indexfile.setter
+    def indexfile(self, value):
+        self._revlog.indexfile = value
+
+    @property
+    def datafile(self):
+        return self._revlog.datafile
+
+    @property
+    def opener(self):
+        return self._revlog.opener
+
+    @property
+    def _lazydeltabase(self):
+        return self._revlog._lazydeltabase
+
+    @_lazydeltabase.setter
+    def _lazydeltabase(self, value):
+        self._revlog._lazydeltabase = value
+
+    @property
+    def _aggressivemergedeltas(self):
+        return self._revlog._aggressivemergedeltas
+
+    @_aggressivemergedeltas.setter
+    def _aggressivemergedeltas(self, value):
+        self._revlog._aggressivemergedeltas = value
+
+    @property
+    def _inline(self):
+        return self._revlog._inline
+
+    @property
+    def _withsparseread(self):
+        return getattr(self._revlog, '_withsparseread', False)
+
+    @property
+    def _srmingapsize(self):
+        return self._revlog._srmingapsize
+
+    @property
+    def _srdensitythreshold(self):
+        return self._revlog._srdensitythreshold
+
+    def _deltachain(self, rev, stoprev=None):
+        return self._revlog._deltachain(rev, stoprev)
+
+    def chainbase(self, rev):
+        return self._revlog.chainbase(rev)
+
+    def chainlen(self, rev):
+        return self._revlog.chainlen(rev)
+
+    def clone(self, tr, destrevlog, **kwargs):
+        if not isinstance(destrevlog, filelog):
+            raise error.ProgrammingError('expected filelog to clone()')
+
+        return self._revlog.clone(tr, destrevlog._revlog, **kwargs)
+
+    def start(self, rev):
+        return self._revlog.start(rev)
+
+    def end(self, rev):
+        return self._revlog.end(rev)
+
+    def length(self, rev):
+        return self._revlog.length(rev)
+
+    def compress(self, data):
+        return self._revlog.compress(data)
+
+    def _addrevision(self, *args, **kwargs):
+        return self._revlog._addrevision(*args, **kwargs)
diff --git a/mercurial/bundlerepo.py b/mercurial/bundlerepo.py
--- a/mercurial/bundlerepo.py
+++ b/mercurial/bundlerepo.py
@@ -217,11 +217,11 @@
                 self._dirlogstarts, dir=d)
         return super(bundlemanifest, self).dirlog(d)
 
-class bundlefilelog(bundlerevlog, filelog.filelog):
+class bundlefilelog(filelog.filelog):
     def __init__(self, opener, path, cgunpacker, linkmapper):
         filelog.filelog.__init__(self, opener, path)
-        bundlerevlog.__init__(self, opener, self.indexfile, cgunpacker,
-                              linkmapper)
+        self._revlog = bundlerevlog(opener, self.indexfile,
+                                    cgunpacker, linkmapper)
 
     def baserevision(self, nodeorrev):
         return filelog.filelog.revision(self, nodeorrev, raw=True)



To: indygreg, #hg-reviewers, durin42
Cc: mercurial-devel


More information about the Mercurial-devel mailing list