o

�]LbR�@s�dd
lm
Z

ddlmZ
ddlmZmZmZmZm	Z	m
Z
mZ
ddlm
Z
mZ
e

e
e
e	f

e
e
e
e�e�
Ze
de	diZdd	�Zd
d�Zdd
�Zdd�Zdd�Zdd�ZdS)�)
�absolute_import�)
�
_�
)�REVIDX_DEFAULT_FLAGS�REVIDX_ELLIPSIS�REVIDX_EXTSTORED�REVIDX_FLAGS_ORDER�REVIDX_HASCOPIESINFO�REVIDX_ISCENSORED�REVIDX_RAWTEXT_CHANGING_FLAGS)�error�utilNcCst||
t
�
d
S)a!Register a flag processor on a revision data flag.

    Invariant:
    - Flags need to be defined in REVIDX_KNOWN_FLAGS and REVIDX_FLAGS_ORDER,
      and REVIDX_RAWTEXT_CHANGING_FLAGS if they can alter rawtext.
    - Only one flag processor can be registered on a specific flag.
    - flagprocessors must be 3-tuples of functions (read, write, raw) with the
      following signatures:
          - (read)  f(self, rawtext) -> text, bool
          - (write) f(self, text) -> rawtext, bool
          - (raw)   f(self, rawtext) -> bool
      "text" is presented to the user. "rawtext" is stored in revlog data, not
      directly visible to the user.
      The boolean returned by these transforms is used to determine whether
      the returned text can be used for hash integrity checking. For example,
      if "write" returns False, then "text" is used to generate hash. If
      "write" returns True, that basically means "rawtext" returned by "write"
      should be used to generate hash. Usually, "write" and "read" return
      different booleans. And "raw" returns a same boolean as "write".

      Note: The 'raw' transform is used for changegroup generation and in some
      debug commands. In this case the transform only indicates whether the
      contents can be used for hash integrity checks.
    N)�insertflagprocessor�flagprocessors)�flag�	processor�r�@/usr/lib/python3/dist-packages/mercurial/revlogutils/flagutil.py�addflagprocessor-srcCsf|t@st
d
�
|}t�|�
�
|tv
rt
d�
|}t�|�
�
||vr-t
d�
|}t�|�
�
|
||<dS)Ns0cannot register processor on unknown flag '%#x'.s+flag '%#x' undefined in REVIDX_FLAGS_ORDER.s2cannot register multiple processors on flag '%#x'.)�REVIDX_KNOWN_FLAGSrr
�ProgrammingErrorr	�Abort)rrr�msgrrrrIs












rcCst||
|d
�dd�S)a�Inspect revision data flags and applies write transformations defined
    by registered flag processors.

    ``text`` - the revision data to process
    ``flags`` - the revision flags

    This method processes the flags in the order (or reverse order if
    ``operation`` is 'write') defined by REVIDX_FLAGS_ORDER, applying the
    flag processors registered for present flags. The order of flags defined
    in REVIDX_FLAGS_ORDER needs to be stable to allow non-commutativity.

    Returns a 2-tuple of ``(text, validatehash)`` where ``text`` is the
    processed text and ``validatehash`` is a bool indicating whether the
    returned text should be checked for hash integrity.
    �writeNr�
�_processflagsfunc��revlog�text�flagsrrr�processflagswriteVs



��r!cCst||
|d
�S)aInspect revision data flags and applies read transformations defined
    by registered flag processors.

    ``text`` - the revision data to process
    ``flags`` - the revision flags
    ``raw`` - an optional argument describing if the raw transform should be
    applied.

    This method processes the flags in the order (or reverse order if
    ``operation`` is 'write') defined by REVIDX_FLAGS_ORDER, applying the
    flag processors registered for present flags. The order of flags defined
    in REVIDX_FLAGS_ORDER needs to be stable to allow non-commutativity.

    Returns a 2-tuple of ``(text, validatehash)`` where ``text`` is the
    processed text and ``validatehash`` is a bool indicating whether the
    returned text should be checked for hash integrity.
    �readrrrrr�processflagsreadnsr#cCst||
|d
�dS)a�Inspect revision data flags to check is the content hash should be
    validated.

    ``text`` - the revision data to process
    ``flags`` - the revision flags

    This method processes the flags in the order (or reverse order if
    ``operation`` is 'write') defined by REVIDX_FLAGS_ORDER, applying the
    flag processors registered for present flags. The order of flags defined
    in REVIDX_FLAGS_ORDER needs to be stable to allow non-commutativity.

    Returns a 2-tuple of ``(text, validatehash)`` where ``text`` is the
    processed text and ``validatehash`` is a bool indicating whether the
    returned text should be checked for hash integrity.
    �rawrrrrrr�processflagsraw�sr%c
Cs
|d
kr|
dfS|dv
rt�
td�
|�
�
|t@r&|�td�
|t@�
�
d}t}|dkr2t|�
}|D]G}||@r{d}||jv
rLtd�
|}|�|�
�
|j|}	|	du
rw|	\}
}}|d	krd|||
�}n|d
krp|
||
�\}
}n|||
�\}
}|oz|}q4|
|fS)z�internal function to process flag on a revlog

    This function is private to this module, code should never needs to call it
    directly.r
T)r"rr$sinvalid '%s' operations incompatible revision flag '%#x'rs missing processor for flag '%#x'Nr$r")r
rrr�_flagserrorclassr	�reversed�_flagprocessors)
rrr �	operation�validatehash�orderedflagsr�vhash�messager�
readtransform�writetransform�rawtransformrrrr�s>






��














�r)�
__future__r�i18nr�	constantsrrrr	r
rr�r
r�bitsfromrrrrr!r#r%rrrrr�<module>
s*$








�