flagprocessors: make `_processflagsfunc` a module level function

This is the first step toward removing the flag processing mixin.

Differential Revision: https://phab.mercurial-scm.org/D6817

mercurial/revlogutils/flagutil.py

@@ -118,7 +118,7 b' class flagprocessorsmixin(object):'
         processed text and ``validatehash`` is a bool indicating whether the
         returned text should be checked for hash integrity.
         """
-        return self._processflagsfunc(text, flags, 'read')
+        return _processflagsfunc(self, text, flags, 'read')
 
     def _processflagswrite(self, text, flags, sidedata):
         """Inspect revision data flags and applies write transformations defined
@@ -136,7 +136,7 b' class flagprocessorsmixin(object):'
         processed text and ``validatehash`` is a bool indicating whether the
         returned text should be checked for hash integrity.
         """
-        return self._processflagsfunc(text, flags, 'write',
+        return _processflagsfunc(self, text, flags, 'write',
                                       sidedata=sidedata)[:2]
 
     def _processflagsraw(self, text, flags):
@@ -155,9 +155,13 b' class flagprocessorsmixin(object):'
         processed text and ``validatehash`` is a bool indicating whether the
         returned text should be checked for hash integrity.
         """
-        return self._processflagsfunc(text, flags, 'raw')[1]
+        return _processflagsfunc(self, text, flags, 'raw')[1]
 
-    def _processflagsfunc(self, text, flags, operation, sidedata=None):
+def _processflagsfunc(revlog, text, flags, operation, sidedata=None):
+    """internal function to process flag on a revlog
+
+    This function is private to this module, code should never needs to call it
+    directly."""
         # fast path: no flag processors will run
         if flags == 0:
             return text, True, {}
@@ -166,7 +170,7 b' class flagprocessorsmixin(object):'
                                          operation)
         # Check all flags are known.
         if flags & ~REVIDX_KNOWN_FLAGS:
-            raise self._flagserrorclass(_("incompatible revision flag '%#x'") %
+        raise revlog._flagserrorclass(_("incompatible revision flag '%#x'") %
                                         (flags & ~REVIDX_KNOWN_FLAGS))
         validatehash = True
         # Depending on the operation (read or write), the order might be
@@ -182,21 +186,21 b' class flagprocessorsmixin(object):'
             if flag & flags:
                 vhash = True
 
-                if flag not in self._flagprocessors:
+            if flag not in revlog._flagprocessors:
                     message = _("missing processor for flag '%#x'") % (flag)
-                    raise self._flagserrorclass(message)
+                raise revlog._flagserrorclass(message)
 
-                processor = self._flagprocessors[flag]
+            processor = revlog._flagprocessors[flag]
                 if processor is not None:
                     readtransform, writetransform, rawtransform = processor
 
                     if operation == 'raw':
-                        vhash = rawtransform(self, text)
+                    vhash = rawtransform(revlog, text)
                     elif operation == 'read':
-                        text, vhash, s = readtransform(self, text)
+                    text, vhash, s = readtransform(revlog, text)
                         outsidedata.update(s)
                     else: # write operation
-                        text, vhash = writetransform(self, text, sidedata)
+                    text, vhash = writetransform(revlog, text, sidedata)
                 validatehash = validatehash and vhash
 
         return text, validatehash, outsidedata