�
1�3\c@@s�dd
lm
Z

ddlZddlmZ
ddlmZmZ
ejd�
Z	d�Z
d�Zd	ef
d
��YZ
d�Zdef
d
��YZdef
d��YZdS(i(
tabsolute_importNi
(
tnullrev(tpolicytpycompattparsersc
G@sIt|
t
�st
|
�
}
nt|
kr1t
�St|
�
d
k
rG|
Sd
t|
�
>d
}dg
t|
�
d
}x(t|
�
D]\}}d
|>||<qWd
|d
>}t
�}t|
�
}t|�
d
}	xr
|	dkrD|rD|	}
|	d
8}	||
s
q�n||
}||kra
|d
8}||kra
|j|
�

||O}|
|
kr^
|
h
Sqa
n||kr�
x�||
�
D]d}||}
|tkr�
qz
n|
dkr�
|||<|d
7}qz
|
|krz
||c|O<qz
qz
Wq�xY||
�
D]K}|tkr
q�
n||}
|
r3|
|kr3|d
8}n|||<q�
Wq�W|S(s�Returns a set with the heads of all common ancestors of all nodes,
    heads(::nodes[0] and ::nodes[1] and ...) .

    pfunc must return a list of parent vertices for a given vertex.
    i
i(t
isinstancetsetR
tlentmaxt	enumeratetadd(tpfunctnodestallseentseent
it
ntpoisontgcatinterestingtnvt
vtsvt
ptsp((s8/usr/lib64/python2.7/site-packages/mercurial/ancestor.pytcommonancestorsheadssZ








	










































c
@s>�f
d
�}t�|
�
}t
|�
dk
r4|S||�
S(s�
    Returns the common ancestors of a and b that are furthest from a
    root (as measured by longest path).

    pfunc must return a list of parent vertices for a given vertex.
    c
@s�i}
t|�
d
}dg
|}dg
|}g}x[t
t|�
�
D]G\}}d
||<d
|>}|||<d
|
|<|j||f�

qIW|d
}	x�
|	dkrct|
�
d
krc|	}
|	d
8}	||
}|dkr�q�n||
}x>
�
|
�
D]0
}
|
tkr
q
n||
}||
}}||k
r�
|d
||
<||kr2|
|cd
7<|}||
<|r�
|
|cd
8<|
|dkr�
|
|=q�
q�
q2q
||d
kr
||B}||kr�
q
n|||
<|
j|d�
|
|cd
7<|
|cd
8<|
|dkr2|
|=q2q
q
W|
|cd
8<|
|dkr�|
|=q�q�Wt|
�
d
krzgSd�x|
D]}�|O�q�Wt�f
d�|D�
�
S(Ni
ic
3@s%|]\}
}�|
@r|V
qdS(
N((t.0RR(
t
k(s8/usr/lib64/python2.7/site-packages/mercurial/ancestor.pys	<genexpr>�s(RR	tsortedtappendRR
t
setdefaultR(RRtcounttdepthRtmappingRRt
bRRtdvRRtdptnspR(
R(
Rs8/usr/lib64/python2.7/site-packages/mercurial/ancestor.pytdeepestSsh



















!











































i
(RR(Rt	orignodesR&R((
Rs8/usr/lib64/python2.7/site-packages/mercurial/ancestor.pyt	ancestorsLs
8

tincrementalmissingancestorsc
B@s;eZ
dZd
�Zd�Zd�Zd�Zd�ZRS(s
persistent state used to calculate missing ancestors incrementally

    Although similar in spirit to lazyancestors below, this is a separate class
    because trying to support contains and missingancestors operations with the
    same internal data structures adds needless complexity.cC@s8t|�
|_
|j
s+|j
jt�

n|
|_dS(
N(RtbasesR
R
R(tselfRR*((s8/usr/lib64/python2.7/site-packages/mercurial/ancestor.pyt__init__�s

	

c

C@s|jo|jt
h
kS(
s0whether the common set has any non-trivial bases(R*R
(
R+((s8/usr/lib64/python2.7/site-packages/mercurial/ancestor.pythasbases�scC@s|jj
|
�

d
S(s)grow the ancestor set by adding new basesN(R*tupdate(R+tnewbases((s8/usr/lib64/python2.7/site-packages/mercurial/ancestor.pytaddbases�sc@s�|j}|j
}|
j|�

|
jt�

|
s6d
St|�
�t�f
d�|
D�
�
}t|
�
|krtd
Sxotj	�t
|
�
dd�D]N}||kr�q�n|
j|�

|j||�
�

t|
�
|kr�Pq�q�Wd
S(s:remove all ancestors of bases from the set revs (in place)Nc
3@s!|]}
|
�krdV
qd
S(i
N((Rt
r(
tstart(s8/usr/lib64/python2.7/site-packages/mercurial/ancestor.pys	<genexpr>�si
i����(R*Rtdifference_updatetdiscardR
RtsumRRtxrangetminR.(R+trevsR*Rt	keepcounttcurr((
R2s8/usr/lib64/python2.7/site-packages/mercurial/ancestor.pytremoveancestorsfrom�s"	
	






&





cC@s�
t|
�
}|j
}|j}|j|�
}|j|�

|sDgStt|�
t|�
�}g}xL
tj|td
�D]5
}|s�Pn||kr�|j	|�

x;||�
D]-}	|j
|	�

|j|	�

|j|	�

q�Wq{n||kr
|j|�

|j	|�

|}
|}n||kr{|}
|}nq{xr||�
D]d}	|	tkr]
qH
|	|ksu
|	|kr�
|j
|	�

|j|	�

|j|	�

qH
|
j|	�

qH
Wq{W|j
�
|S(s
return all the ancestors of revs that are not ancestors of self.bases

        This may include elements from revs.

        Equivalent to the revset (::revs - ::self.bases). Revs are returned in
        revision number order, which is a topological order.i����(RR*RtintersectionR3RRR6R
tremoveR4R
Rtreverse(R+R8t	revsvisitt
basesvisitRt	bothvisitR2tmissingR:Rt	thisvisitt
othervisit((s8/usr/lib64/python2.7/site-packages/mercurial/ancestor.pytmissingancestors�sL
	
	





















	


	








(t__name__t
__module__t__doc__R,R-R0R;RE(((s8/usr/lib64/python2.7/site-packages/mercurial/ancestor.pyR)�s
				cc@s�
th
}t
j}t
j}t
j}|j}|rjg|
D]
}	|	^q:}
|j|
�

t
j|
�

n�g}
t
j|
�

xn|
D]f}	||	�
\}}||kr�||
|�
||�

n||kr�||
|�
||�

q�q�Wx�|
r�
|
d
}
|
|kr
Pn|
V
||
�
\}}||krn
|
|dkrS
||
d
<n||
|�
||�

n
||
�

||kr�||
|�
||�

q�q�WdS(Nii
(R
theapqtheappushtheappoptheapreplaceR
R.theapify(t
parentrevstinitrevststoprevt	inclusiveRRJRKRLtseeR1tvisittp1tp2tcurrent((s8/usr/lib64/python2.7/site-packages/mercurial/ancestor.pyt_lazyancestorsiter

sD
	
	
	
	
	















	












t
lazyancestorscB@s8eZ
ded
�Zd�ZeZd�Zd�ZRS(icC@s{|
|_g|D]}||kr|^q|_
}||_||_t�|_t|j|j
|j|j�|_d
S(s�
Create a new object generating ancestors for the given revs. Does
        not generate revs lower than stoprev.

        This is computed lazily starting from revs. The object supports
        iteration and membership.

        cl should be a changelog and revs should be an iterable. inclusive is
        a boolean that indicates whether revs should be included. Revs lower
        than stoprev will not be generated.

        Result does not include the null revision.N(t_parentrevst	_initrevst_stoprevt
_inclusiveRt
_containsseenRWt
_containsiter(R+RR8RPRQR1((s8/usr/lib64/python2.7/site-packages/mercurial/ancestor.pyR,6
s	
,
	
	
	


c

C@s1ytt
|�
�

tSWntk
r,


tSXd
S(s*False if the set is empty, True otherwise.N(tnexttitertTruet
StopIterationtFalse(
R+((s8/usr/lib64/python2.7/site-packages/mercurial/ancestor.pyt__nonzero__M
s





c

C@st|j
|j|j|j�S(
sGenerate the ancestors of _initrevs in reverse topological order.

        If inclusive is False, yield a sequence of revision numbers starting
        with the parents of each revision in revs, i.e., each revision is
        *not* considered an ancestor of itself. Results are emitted in reverse
        revision number order. That order is also topological: a child is
        always emitted before its parent.

        If inclusive is True, the source revisions are also yielded. The
        reverse revision number order is still enforced.(RWRYRZR[R\(
R+((s8/usr/lib64/python2.7/site-packages/mercurial/ancestor.pyt__iter__W
s
cC@s�|j}|
|krt
S|j}|d
kr2tS|
d
krBtS|j}yGx@t
r�t|�
}||�

||
kr}t
S||
krQtSqQWWntk
r�


d
|_tSXd
S(s5Test whether target is an ancestor of self._initrevs.N(R]RaR^tNoneRcR
R_Rb(R+ttargetRR`RRtrev((s8/usr/lib64/python2.7/site-packages/mercurial/ancestor.pyt__contains__e
s(	


	

	

	








	
(RFRGRcR,Rdt__bool__ReRi(((s8/usr/lib64/python2.7/site-packages/mercurial/ancestor.pyRX5
s

		trustlazyancestorscB@s2eZ
ded
�Zd�Zd�Zd�ZRS(icC@sM|
|_||_
||_t|�
|_}tj|
|||�|_dS(
N(t_indexR[R\tlistRZRRkR^(R+tindexR8RPRQRO((s8/usr/lib64/python2.7/site-packages/mercurial/ancestor.pyR,�
s
	
	
	
c

C@s1ytt
|�
�

tSWntk
r,


tSXd
S(s�False if the set is empty, True otherwise.

        It's better to duplicate this essentially trivial method than
        to subclass lazyancestors
        N(R_R`RaRbRc(
R+((s8/usr/lib64/python2.7/site-packages/mercurial/ancestor.pyRd�
s





c

C@s"tj
|j|j|j|j�S(
N(RRkRlRZR[R\(
R+((s8/usr/lib64/python2.7/site-packages/mercurial/ancestor.pyRe�
s



cC@s
|
|jkS(
N(
R^(R+Rg((s8/usr/lib64/python2.7/site-packages/mercurial/ancestor.pyRi�
s
(RFRGRcR,RdReRi(((s8/usr/lib64/python2.7/site-packages/mercurial/ancestor.pyRk�
s
		(t
__future__RRItnodeR
tRRt	importmodRRR(tobjectR)RWRXRk(((s8/usr/lib64/python2.7/site-packages/mercurial/ancestor.pyt<module>s
	8	Ey	+M