File: //lib64/python2.7/site-packages/mercurial/revlogutils/deltas.pyo
�
1�3\c @@ su d Z d d l m Z d d l Z d d l Z d d l Z d d l m Z d d l m Z d d l
m Z m Z d d l
m Z d d
l m Z m Z d Z d e f d � � YZ d d d
� Z d d � Z d d d d � Z d d � Z d d � Z d � Z e j d e d e � d e f d � � Y� Z d � Z d � Z d � Z! d � Z" d � Z# d e f d � � YZ$ d S( s4 Helper class to compute deltas stored inside revlogsi ( t absolute_importNi ( t nullrev( t _i ( t REVIDX_ISCENSOREDt REVIDX_RAWTEXT_CHANGING_FLAGS( t attr( t errort mdifft _testrevlogc B@ sA e Z d Z d d d � Z d � Z d � Z d � Z d � Z RS( s) minimalist fake revlog to use in doctestsg �?i c C@ s | | _ | | _ | | _ d S( s. data is an list of revision payload boundariesN( t _datat _srdensitythresholdt
_srmingapsize( t selft datat densityt mingap( ( sB /usr/lib64/python2.7/site-packages/mercurial/revlogutils/deltas.pyt __init__* s c C@ s | d k r d S| j | d S( Ni i ( R ( R t rev( ( sB /usr/lib64/python2.7/site-packages/mercurial/revlogutils/deltas.pyt start0 s c C@ s | j | S( N( R ( R R ( ( sB /usr/lib64/python2.7/site-packages/mercurial/revlogutils/deltas.pyt end5 s c C@ s | j | � | j | � S( N( R R ( R R ( ( sB /usr/lib64/python2.7/site-packages/mercurial/revlogutils/deltas.pyt length8 s c C@ s
t | j � S( N( t lenR ( R ( ( sB /usr/lib64/python2.7/site-packages/mercurial/revlogutils/deltas.pyt __len__; s ( t __name__t
__module__t __doc__R R R R R ( ( ( sB /usr/lib64/python2.7/site-packages/mercurial/revlogutils/deltas.pyR ' s c c@ s� | d k r! t | | j � } n | d k p6 | d k sQ d } t j | � � n xH t | | | | j | j � D]( } x t | | | � D] } | Vq� Wqp Wd S( s� slice revs to reduce the amount of unrelated data to be read from disk.
``revs`` is sliced into groups that should be read in one time.
Assume that revs are sorted.
The initial chunk is sliced until the overall density (payload/chunks-span
ratio) is above `revlog._srdensitythreshold`. No gap smaller than
`revlog._srmingapsize` is skipped.
If `targetsize` is set, no chunk larger than `targetsize` will be yield.
For consistency with other slicing choice, this limit won't go lower than
`revlog._srmingapsize`.
If individual revisions chunk are larger than this limit, they will still
be raised individually.
>>> revlog = _testrevlog([
... 5, #00 (5)
... 10, #01 (5)
... 12, #02 (2)
... 12, #03 (empty)
... 27, #04 (15)
... 31, #05 (4)
... 31, #06 (empty)
... 42, #07 (11)
... 47, #08 (5)
... 47, #09 (empty)
... 48, #10 (1)
... 51, #11 (3)
... 74, #12 (23)
... 85, #13 (11)
... 86, #14 (1)
... 91, #15 (5)
... ])
>>> list(slicechunk(revlog, list(range(16))))
[[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]]
>>> list(slicechunk(revlog, [0, 15]))
[[0], [15]]
>>> list(slicechunk(revlog, [0, 11, 15]))
[[0], [11], [15]]
>>> list(slicechunk(revlog, [0, 11, 13, 15]))
[[0], [11, 13, 15]]
>>> list(slicechunk(revlog, [1, 2, 3, 5, 8, 10, 11, 14]))
[[1, 2], [5, 8, 10, 11], [14]]
Slicing with a maximum chunk size
>>> list(slicechunk(revlog, [0, 11, 13, 15], targetsize=15))
[[0], [11], [13], [15]]
>>> list(slicechunk(revlog, [0, 11, 13, 15], targetsize=20))
[[0], [11], [13, 15]]
s* cannot use `targetsize` with a `deltainfo`N( t Nonet maxR R t ProgrammingErrort _slicechunktodensityR
t _slicechunktosize( t revlogt revst deltainfot
targetsizet msgt chunkt subchunk( ( sB /usr/lib64/python2.7/site-packages/mercurial/revlogutils/deltas.pyt
slicechunk> s 5 c c@ s� | d k s! t | | � | k r* | Vd Sd } | j | d � } d } t | � } t | � x~ | D]v \ } } | j | � | } | | k r� | } qf t | | | | d � }
|
r� |
Vn | } | j | � } | } qf Wt | | | � Vd S( s� slice revs to match the target size
This is intended to be used on chunk that density slicing selected by that
are still too large compared to the read garantee of revlog. This might
happens when "minimal gap size" interrupted the slicing or when chain are
built in a way that create large blocks next to each other.
>>> revlog = _testrevlog([
... 3, #0 (3)
... 5, #1 (2)
... 6, #2 (1)
... 8, #3 (2)
... 8, #4 (empty)
... 11, #5 (3)
... 12, #6 (1)
... 13, #7 (1)
... 14, #8 (1)
... ])
Cases where chunk is already small enough
>>> list(_slicechunktosize(revlog, [0], 3))
[[0]]
>>> list(_slicechunktosize(revlog, [6, 7], 3))
[[6, 7]]
>>> list(_slicechunktosize(revlog, [0], None))
[[0]]
>>> list(_slicechunktosize(revlog, [6, 7], None))
[[6, 7]]
cases where we need actual slicing
>>> list(_slicechunktosize(revlog, [0, 1], 3))
[[0], [1]]
>>> list(_slicechunktosize(revlog, [1, 3], 3))
[[1], [3]]
>>> list(_slicechunktosize(revlog, [1, 2, 3], 3))
[[1, 2], [3]]
>>> list(_slicechunktosize(revlog, [3, 5], 3))
[[3], [5]]
>>> list(_slicechunktosize(revlog, [3, 4, 5], 3))
[[3], [5]]
>>> list(_slicechunktosize(revlog, [5, 6, 7, 8], 3))
[[5], [6, 7, 8]]
>>> list(_slicechunktosize(revlog, [0, 1, 2, 3, 4, 5, 6, 7, 8], 3))
[[0], [1, 2], [3], [5], [6, 7, 8]]
Case with too large individual chunk (must return valid chunk)
>>> list(_slicechunktosize(revlog, [0, 1], 2))
[[0], [1]]
>>> list(_slicechunktosize(revlog, [1, 3], 1))
[[1], [3]]
>>> list(_slicechunktosize(revlog, [3, 4, 5], 2))
[[3], [5]]
Ni i ( R t segmentspanR t enumeratet nextR t
_trimchunk( R R R" t startrevidxt startdatat endrevidxt iterrevst idxt rt spanR$ ( ( sB /usr/lib64/python2.7/site-packages/mercurial/revlogutils/deltas.pyR � s& 7!
g �?c #@ s� | j } | j � t | � d k r- | Vd St | � } | j | d � } | d k r� t | | � } t � f d � | D� � } n | j } | j } | | k r� | Vd S| }
| r� | t | � } n d } | | k r� | Vd S| d k r| j
rt | � } | j | � n g } t
j | � d }
x� t | � D]� \ } } | | k rq| | � } � | � } n | } | j
} | d k r�q>n |
d k r�| |
} | | k r�t
j | | | f � q�n | | }
q>Wg } t
j | � xk | r_| | k r_t
j | � \ } } t
j | | � |
| 8}
|
d k rV| t |
� } q�d } q�Wd } xB | r�t
j | � } t | | | | � } | r�| Vn | } qiWt | | | � } | r�| Vn d S( s slice revs to reduce the amount of unrelated data to be read from disk.
``revs`` is sliced into groups that should be read in one time.
Assume that revs are sorted.
``deltainfo`` is a _deltainfo instance of a revision that we would append
to the top of the revlog.
The initial chunk is sliced until the overall density (payload/chunks-span
ratio) is above `targetdensity`. No gap smaller than `mingapsize` is
skipped.
>>> revlog = _testrevlog([
... 5, #00 (5)
... 10, #01 (5)
... 12, #02 (2)
... 12, #03 (empty)
... 27, #04 (15)
... 31, #05 (4)
... 31, #06 (empty)
... 42, #07 (11)
... 47, #08 (5)
... 47, #09 (empty)
... 48, #10 (1)
... 51, #11 (3)
... 74, #12 (23)
... 85, #13 (11)
... 86, #14 (1)
... 91, #15 (5)
... ])
>>> list(_slicechunktodensity(revlog, list(range(16))))
[[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]]
>>> list(_slicechunktodensity(revlog, [0, 15]))
[[0], [15]]
>>> list(_slicechunktodensity(revlog, [0, 11, 15]))
[[0], [11], [15]]
>>> list(_slicechunktodensity(revlog, [0, 11, 13, 15]))
[[0], [11, 13, 15]]
>>> list(_slicechunktodensity(revlog, [1, 2, 3, 5, 8, 10, 11, 14]))
[[1, 2], [5, 8, 10, 11], [14]]
>>> list(_slicechunktodensity(revlog, [1, 2, 3, 5, 8, 10, 11, 14],
... mingapsize=20))
[[1, 2, 3, 5, 8, 10, 11], [14]]
>>> list(_slicechunktodensity(revlog, [1, 2, 3, 5, 8, 10, 11, 14],
... targetdensity=0.95))
[[1, 2], [5], [8, 10, 11], [14]]
>>> list(_slicechunktodensity(revlog, [1, 2, 3, 5, 8, 10, 11, 14],
... targetdensity=0.95, mingapsize=12))
[[1, 2], [5, 8, 10, 11], [14]]
i Nc 3@ s | ] } � | � Vq d S( N( ( t .0R0 ( R ( sB /usr/lib64/python2.7/site-packages/mercurial/revlogutils/deltas.pys <genexpr> s g �?i ( R R R R R R' t sumt distancet compresseddeltalent floatt deltalent listt appendt heapqt heapifyR( t heappusht heappopR* ( R R R! t
targetdensityt
mingapsizeR t nextrevt
nextoffsett deltachainspant chainpayloadt readdataR t gapsheapt prevendt iR t revstartt revlent gapsizet indicesheapt
oppgapsizet gapidxt previdxR/ R$ ( ( R sB /usr/lib64/python2.7/site-packages/mercurial/revlogutils/deltas.pyR � sx 5
c C@ s� | j } | d k r$ t | � } n | | d t | � k r� xC | d k r� | | k r� | | | d � d k r� | d 8} qA Wn | | | !S( s� returns revs[startidx:endidx] without empty trailing revs
Doctest Setup
>>> revlog = _testrevlog([
... 5, #0
... 10, #1
... 12, #2
... 12, #3 (empty)
... 17, #4
... 21, #5
... 21, #6 (empty)
... ])
Contiguous cases:
>>> _trimchunk(revlog, [0, 1, 2, 3, 4, 5, 6], 0)
[0, 1, 2, 3, 4, 5]
>>> _trimchunk(revlog, [0, 1, 2, 3, 4, 5, 6], 0, 5)
[0, 1, 2, 3, 4]
>>> _trimchunk(revlog, [0, 1, 2, 3, 4, 5, 6], 0, 4)
[0, 1, 2]
>>> _trimchunk(revlog, [0, 1, 2, 3, 4, 5, 6], 2, 4)
[2]
>>> _trimchunk(revlog, [0, 1, 2, 3, 4, 5, 6], 3)
[3, 4, 5]
>>> _trimchunk(revlog, [0, 1, 2, 3, 4, 5, 6], 3, 5)
[3, 4]
Discontiguous cases:
>>> _trimchunk(revlog, [1, 3, 5, 6], 0)
[1, 3, 5]
>>> _trimchunk(revlog, [1, 3, 5, 6], 0, 2)
[1]
>>> _trimchunk(revlog, [1, 3, 5, 6], 1, 3)
[3, 5]
>>> _trimchunk(revlog, [1, 3, 5, 6], 1)
[3, 5]
i i N( R R R ( R R t startidxt endidxR ( ( sB /usr/lib64/python2.7/site-packages/mercurial/revlogutils/deltas.pyR* _ s & c C@ s� | s
d S| d k rn t | � | d k rn t | � d k rE | j S| j t | � d � } | j | } n | j | d � } | | j | d � S( s� Get the byte span of a segment of revisions
revs is a sorted array of revision numbers
>>> revlog = _testrevlog([
... 5, #0
... 10, #1
... 12, #2
... 12, #3 (empty)
... 17, #4
... ])
>>> segmentspan(revlog, [0, 1, 2, 3, 4])
17
>>> segmentspan(revlog, [0, 4])
17
>>> segmentspan(revlog, [3, 4])
5
>>> segmentspan(revlog, [1, 2, 3,])
7
>>> segmentspan(revlog, [1, 3])
7
i i����i N( R R R7 R R ( R R R! t offsetR ( ( sB /usr/lib64/python2.7/site-packages/mercurial/revlogutils/deltas.pyR' � s "c
C@ s t j d � } | | t j | j | � t | � | � k rK | | } n- | j | d | d t �}
t j |
| � } yv | j | | d d t
�} | \ } } | r� | j | | d | d | �n | t @r� t
j t d � | � � n Wn$ t
j k
r| t @s� qn X| S( s< build full text from a (base, delta) pair and other metadatas >lllt _dft rawt readt p1t p2s node %s is not censored( t structt calcsizeR t replacediffheadert rawsizeR t revisiont Falset patcht
_processflagst Truet checkhashR R t StorageErrorR t CensoredNodeError(
t fhR t baserevt deltaRU RV t flagst expectednodet hlent fulltextt basetextt rest validatehash( ( sB /usr/lib64/python2.7/site-packages/mercurial/revlogutils/deltas.pyt _textfromdelta� s$
t slotst frozent
_deltainfoc B@ sh e Z e j � Z e j � Z e j � Z e j � Z e j � Z e j � Z e j � Z
e j � Z RS( ( R R R t ibR4 R7 R
t baset chainbaset chainlenR5 t
snapshotdepth( ( ( sB /usr/lib64/python2.7/site-packages/mercurial/revlogutils/deltas.pyRp � s c C@ s� | d k r t S| j r� | j } | t k rD | j | � d } n g } x- t | � D] \ } } | j | � sW PqW qW W| | } t | | | � } g | D] } t | | | � ^ q� } t
| � }
n | j }
| j } | d } | j
}
|
s� |
}
n t
|
| � }
| j r1|
| j k r1| j }
n |
|
k rAt S| | j k rTt S| t | j k rkt S| j r�| j | j k r�t S| j d k r�| | j ?| j k r�t S| j r�| j | j � | j k r�t St S( s� Returns True if the given delta is good. Good means that it is within
the disk span, disk size, and chain length bounds that we know to be
performant.i i N( R R\ t
_sparserevlogRr R t _deltachainR( t
issnapshotR& R' R R4 t textlent _maxdeltachainspanR R7 t LIMIT_DELTA2TEXTR5 t _maxchainlenRt Ru R R_ ( R R! t revinfoRr t
deltachainR/ R0 t chunksR t all_spanR4 Ry t
defaultmaxt maxdist( ( sB /usr/lib64/python2.7/site-packages/mercurial/revlogutils/deltas.pyt isgooddeltainfo� sP
"
c c@ s� t | � o | j s d Vd S| j } | j } d } | t } t t g � } t | | | | � }
xt r||
j
| � } | d k r� Pn g } x� | D]� }
xK | j r� |
t k p� |
| k p� | |
� r� | j |
� | |
� }
q� W|
| k r� q� n | j |
� | | j |
� k r'q� n |
t k r9q� n | j
|
� t @rRq� n | j |
� q� W| rg t | � V} qg qg Wd Vd S( s� Provides group of revision to be tested as delta base
This top level function focus on emitting groups with unique and worthwhile
content. See _raw_candidate_groups for details about the group order.
N( R t _storedeltachainsR R t deltaparentR{ t setR t _refinedgroupsR_ t sendt
_generaldeltat addRf R R9 t tuple( R Ry RU RV t
cachedeltat deltalengthR� t goodt deltas_limitt testedt
candidatest
temptativet groupR ( ( sB /usr/lib64/python2.7/site-packages/mercurial/revlogutils/deltas.pyt _candidategroups: sD
c C@ sV | j } | j } x= | j | � D], } | | � r" | | | � j | � q" q" Wd S( s# find snapshot from start_rev to tipN( R� Rx R R9 ( R t cachet start_revR� Rx R ( ( sB /usr/lib64/python2.7/site-packages/mercurial/revlogutils/deltas.pyt _findsnapshotsp s
c
c@ sw d } | rD | j rD | j rD | d f V} | d k rD d Vd Sn x4 t | | | | � D] } | V} | d k rZ PqZ qZ W| j s� d Vd S| d k rn| | | f k rn| j | � rnd } x? | | k r| } | j | � } | t k r� Pn | f V} q� Wt j t
� } t | | | d � d } x@ | | k rj| } t t
d � | | D� � � } | V} q.Wn d Vd S( Ni i c s@ s | ] } | Vq d S( N( ( R2 t c( ( sB /usr/lib64/python2.7/site-packages/mercurial/revlogutils/deltas.pys <genexpr>� s ( R R� t _lazydeltabaset
_rawgroupsRv Rx R� R t collectionst defaultdictR8 R� R� t sorted(
R RU RV R� R� R� t previousRr t snapshotst children( ( sB /usr/lib64/python2.7/site-packages/mercurial/revlogutils/deltas.pyR� x s: - c #@ sX � j } � j } t � � } | d } � f d � } | r� g | | f D] } | t k rJ | ^ qJ }
� j r� t |
� d k r� |
j � |
d f V|
d f Vq� t |
� d k r� |
Vq� n | rC|
rCt j t � } t j t � } g |
D] } | | � ^ q� }
xO |
D]G } x> t
| � D]0 \ } } � j | � sHPn | | j | � q)WqWt
| d � d } t � | | � t � } x |
D] } | j | � q�Wd } x0 � j | | � D] } | | k r�| } Pq�q�W| d k rut | j � � } | | � } xc t
| � D]R \ } } | | k r:q n | | k rJPn � j | � s]Pn | | j | � q Wn d } x� t | j � d t �D]� \ } } t � } x | D] } | j | | � q�W| d k r�g | D] } | | k r�| ^ q�} n t t | � � Vt t | � � Vt
| � } q�Wt | t � Vn | sT| f Vn d S( s� Provides group of revision to be tested as delta base
This lower level function focus on emitting delta theorically interresting
without looking it any practical details.
The group order aims at providing fast or small candidates first.
i c @ s � j | � d S( Ni ( Rw ( R ( R ( sB /usr/lib64/python2.7/site-packages/mercurial/revlogutils/deltas.pyt <lambda>� t i i t reverseN( R� Rv R R t _deltabothparentst sortR� R� R8 R� R( Rx R� t minR� t updateR R R t keysR� t itemsR_ R� ( R RU RV R� t gdeltat sparset currt prevR~ t pt parentsR� t
parents_snapst candidate_chainst chainR/ t st snapfloort all_revst otherR0 t max_deptht floort snapst siblings( ( R sB /usr/lib64/python2.7/site-packages/mercurial/revlogutils/deltas.pyR� � sp
+
%
( t
deltacomputerc B@ s> e Z d � Z d � Z d � Z d � Z d � Z d � Z RS( c C@ s
| | _ d S( N( R ( R R ( ( sB /usr/lib64/python2.7/site-packages/mercurial/revlogutils/deltas.pyR ! s c C@ s� | j } | d d k r! | d S| j } | j } | d } | d } t | | | | | j | j | j | j � } | d <| S( s� Builds a fulltext version of a revision
revinfo: _revisioninfo instance that contains all needed info
fh: file handle to either the .i or the .d revlog file,
depending on whether it is inlined or not
i i N( t btextR R R� Rm RU RV Rf t node( R R} Rc R� R R� Rd Re Ri ( ( sB /usr/lib64/python2.7/site-packages/mercurial/revlogutils/deltas.pyt buildtext$ s
c C@ s� | j } | j | | � } | j | � rX t j | j | � t | � � } | | } n- | j | d | d t �} t j | | � } | S( NRR RS (
R R� t
iscensoredR RY RZ R R[ R_ t textdiff( R Rr R} Rc R t tt headerRe t ptext( ( sB /usr/lib64/python2.7/site-packages/mercurial/revlogutils/deltas.pyt _builddeltadiff9 s !
c C@ s* d } | j r� | j \ } } | } xF | t k rl | | k rl | j j | � d k rl | j j | � } q' W| | k r� | j d } q� n | d k r� | j | | | � } n | j } | j | � \ } }
t | � t |
� } | j | � } | j
t | � d � }
| |
| j | � } | j r5| } n | } | j
| � \ } } | d 7} | | 7} | j } d } | t k r�d } n} | j r| j | � r| j | j � | j | j � } } | | | f k r| j | � rt | j | � d � } qn t | | | |
f | | | | | � S( Ni i ( R R� R R R R� R� t compressR Rs R R R� t
_chaininfoRv Rx R RU RV Rw Rp ( R R} Rr Rc Re t cachebaset cachedifft currentbaseR R� R
R7 Rs RQ t distt deltabaseRt R5 Ru RU RV ( ( sB /usr/lib64/python2.7/site-packages/mercurial/revlogutils/deltas.pyt _builddeltainfoG sF
%! c
C@ s� t | j � } | j | | � } | j j | � } t | d � t | d � } } } | } }
d } d } t | | | | |
| | | � S( Ni i ( R R R� R� Rp (
R Rc R} R� t rawtextR
R5 R7 R� R� Rs Ru Rt ( ( sB /usr/lib64/python2.7/site-packages/mercurial/revlogutils/deltas.pyt _fullsnapshotinfos s &
c C@ s� | j s | j | | � S| j t @r6 | j | | � S| j } | j } | j } | j } d } | j | � | j | � } } t
| j | j | | | � }
t |
� } x� | d k rsg } | d k r� | j | � n xH | D]@ }
| j
| |
| � } t | j | | � r� | j | � q� q� W| rCt | d d � �} n | d k rd|
j | j � } q� t |
� } q� W| d k r�| j | | � } n | S( s� Find an acceptable delta against a candidate revision
revinfo: information about the revision (instance of _revisioninfo)
fh: file handle to either the .i or the .d revlog file,
depending on whether it is inlined or not
Returns the first acceptable candidate revision, as ordered by
_candidategroups
If no suitable deltabase is found, we return delta info for a full
snapshot.
t keyc S@ s | j S( N( R7 ( t x( ( sB /usr/lib64/python2.7/site-packages/mercurial/revlogutils/deltas.pyR� � R� N( Ry R� Rf R R� RU RV R R R R� R) R9 R� R� R� R� Rr ( R R} Rc R� RU RV R R! t p1rt p2rt groupst
candidaterevst nominateddeltast candidaterevt candidatedelta( ( sB /usr/lib64/python2.7/site-packages/mercurial/revlogutils/deltas.pyt
finddeltainfo� s:
( R R R R� R� R� R� R� ( ( ( sB /usr/lib64/python2.7/site-packages/mercurial/revlogutils/deltas.pyR� s ,
(% R t
__future__R R� R: RW R� R t i18nR t constantsR R t
thirdpartyR R� R R R{ t objectR R R& R R R* R' Rm R� R_ Rp R� R� R� R� R� R� ( ( ( sB /usr/lib64/python2.7/site-packages/mercurial/revlogutils/deltas.pyt <module> s4 D M � 5 #
[ 6 3 u