]k9-8 ddlmZddlmZmZmZmZddlmZdZGddZ Gdde Z Gd d e Z d Z Gd d e Z Gdde ZGddeZGddeZddZGdde ZGddeZy))getattr)encodingerrorpycompatutil) stringutilcptjt|jj dS)N_)rsysbytestype__name__lstrip)os 6usr/lib/python3.12/site-packages/mercurial/smartset.py _typenamers(   T!W-- . 5 5d ;;ceZdZdZeZdZdZdZdZdZ dZ dZ dZ d Z d Zd Zd Zd ZddZdZdZdZddZdZdZy)abstractsmartsetct)z!True if the smartset is not emptyNotImplementedErrorselfs r __nonzero__zabstractsmartset.__nonzero__ !##rct)zprovide fast membership testingr)rrevs r __contains__zabstractsmartset.__contains__rrct)z:iterate the set in the order it is supposed to be iteratedrrs r__iter__zabstractsmartset.__iter__"rrNct)z/True if the set will iterate in ascending orderrrs r isascendingzabstractsmartset.isascending.rrct)z0True if the set will iterate in descending orderrrs r isdescendingzabstractsmartset.isdescending2rrct)z3True if the set will iterate in topographical orderrrs ristopozabstractsmartset.istopo6rrc|j t|n!|jD]n tdfd|_S)z%return the minimum element in the setarg is an empty sequencecSNvsrz&abstractsmartset.min..C1r)fastascmin ValueErrorrr-s @rr1zabstractsmartset.min:sC << D A\\^$!!<==rc|j t|S|jD]n tdfd|_S)z%return the maximum element in the setr(cSr*r+r,srr.z&abstractsmartset.max..Or/r)fastdescmaxr2r3s @rr7zabstractsmartset.maxFsD == t9 ]]_%!!<==rct)zireturn the first element in the set (user iteration perspective) Return None if the set is emptyrrs rfirstzabstractsmartset.firstR "##rct)zhreturn the last element in the set (user iteration perspective) Return None if the set is emptyrrs rlastzabstractsmartset.lastXr:rct)zkreturn the length of the smartsets This can be expensive on smartset that could be lazy otherwise.rrs r__len__zabstractsmartset.__len__^r:rct)z$reverse the expected iteration orderrrs rreversezabstractsmartset.reversedrrct)z:get the set to iterate in an ascending or descending orderrrr@s rsortzabstractsmartset.sorthrrcbt|tr|S|j|j|dS)z{Returns a new object with the intersection of the two collections. This is part of the mandatory API for smartset.Fcondreprcache) isinstance fullreposetfilterrrothers r__and__zabstractsmartset.__and__ls. e[ )K{{5--U{KKrct||S)ztReturns a new object with the union of the two collections. This is part of the mandatory API for smartset.)addsetrKs r__add__zabstractsmartset.__add__tsdE""rcN|j|jfdd|fdS)z{Returns a new object with the substraction of the two collections. This is part of the mandatory API for smartset.c| Sr*r+)rcs rr.z*abstractsmartset.__sub__..s !A$hrsFrE)rrJ)rrLrTs @r__sub__zabstractsmartset.__sub__zs2   {{ +u)=U  rcv|r+tj|drtj|}t|||S)a1Returns this smartset filtered by condition as a new smartset. `condition` is a callable which takes a revision number and returns a boolean. Optional `condrepr` provides a printable representation of the given `condition`. This is part of the mandatory API for smartset.__code__)r safehasattr cachefunc filteredset)r conditionrFrGs rrJzabstractsmartset.filters3 T%%i<y1I4H55rcd|dks|dkrtjd|j||S)zAReturn new smartset that contains selected elements from this setsnegative index not allowed)rProgrammingError_slice)rstartstops rslicezabstractsmartset.slices2 19q(()FG G{{5$''rcg}t|}t|D]}t|d}|nt||z D]#}t|d}|n|j|%t |d|||fS)Nsslice=%d:%d %r)datarepr)iterrangenextappendbaseset)rr`raysitxys rr_zabstractsmartset._slices $ZuARAyte|$ARAy IIaL % r%6tT$JKKrFNT)r __module__ __qualname__r__bool__rr r0r6r"r$r&r1r7r9r<r>r@rCrMrPrUrJrbr_r+rrrrsv$H$$GH$$$  $ $ $ $$L#   6( Lrrc>eZdZdZddZej dZej dZej dZ dZ dZ dZ ej d Z d ZeZdd Zd Zd ZdZdZdZdZdZfdZdZdZdZej:dZxZS)riaBasic data structure that represents a revset and contains the basic operation that it should be able to perform. Every method in this class should be implemented by any smartset class. This class could be constructed by an (unordered) set, or an (ordered) list-like object. If a set is provided, it'll be sorted lazily. >>> x = [4, 0, 7, 6] >>> y = [5, 6, 7, 3] Construct by a set: >>> xs = baseset(set(x)) >>> ys = baseset(set(y)) >>> [list(i) for i in [xs + ys, xs & ys, xs - ys]] [[0, 4, 6, 7, 3, 5], [6, 7], [0, 4]] >>> [type(i).__name__ for i in [xs + ys, xs & ys, xs - ys]] ['addset', 'baseset', 'baseset'] Construct by a list-like: >>> xs = baseset(x) >>> ys = baseset(i for i in y) >>> [list(i) for i in [xs + ys, xs & ys, xs - ys]] [[4, 0, 7, 6, 5, 3], [7, 6], [4, 0]] >>> [type(i).__name__ for i in [xs + ys, xs & ys, xs - ys]] ['addset', 'filteredset', 'filteredset'] Populate "_set" fields in the lists so set optimization may be used: >>> [1 in xs, 3 in ys] [False, True] Without sort(), results won't be changed: >>> [list(i) for i in [xs + ys, xs & ys, xs - ys]] [[4, 0, 7, 6, 5, 3], [7, 6], [4, 0]] >>> [type(i).__name__ for i in [xs + ys, xs & ys, xs - ys]] ['addset', 'filteredset', 'filteredset'] With sort(), set optimization could be used: >>> xs.sort(reverse=True) >>> [list(i) for i in [xs + ys, xs & ys, xs - ys]] [[7, 6, 4, 0, 5, 3], [7, 6], [4, 0]] >>> [type(i).__name__ for i in [xs + ys, xs & ys, xs - ys]] ['addset', 'baseset', 'baseset'] >>> ys.sort() >>> [list(i) for i in [xs + ys, xs & ys, xs - ys]] [[7, 6, 4, 0, 3, 5], [7, 6], [4, 0]] >>> [type(i).__name__ for i in [xs + ys, xs & ys, xs - ys]] ['addset', 'baseset', 'baseset'] istopo is preserved across set operations >>> xs = baseset(set(x), istopo=True) >>> rs = xs & ys >>> type(rs).__name__ 'baseset' >>> rs._istopo True cd|_||_t|tr||_d|_||_yt|t s t |}||_||_y)z datarepr: a tuple of (format, obj, ...), a function or an object that provides a printable representation of the given data. NT) _ascending_istoporHset_setlist_list _datarepr)rdatardr&s r__init__zbaseset.__init__sV  dC DI"DO "dD)DzDJ!rc,t|jSr*)rwrzrs rrxz baseset._sets4::rcD|jdd}|j|Sr*)rzrC)rasclists r_asclistzbaseset._asclists**Q- rcLd|jvsJt|jS)Nrx)__dict__ryrxrs rrzz baseset._lists$&&&DIIrc|jt|jS|jrt|jSt |jSr*)rurerzrreversedrs rr zbaseset.__iter__s@ ?? " # # __ & &DMM* *rc,t|jSr*)rerrs rr0zbaseset.fastasc sDMM""rc,t|jSr*)rrrs rr6zbaseset.fastdescs &&rc.|jjSr*)rxrrs rrzbaseset.__contains__syy%%%rc*tt|Sr*)boollenrs rrzbaseset.__nonzero__sCIrc4t| |_d|_yNF)rrurvrBs rrCz baseset.sorts"7m+ rc|j"|jjd|_y|j |_d|_yr)rurzr@rvrs rr@zbaseset.reverse s< ?? " JJ    #'//1DO rcrd|jvrt|jSt|jS)Nrz)rrrzrxrs rr>zbaseset.__len__'s* dmm #tzz? "tyy> !rcXt|dkry|jduxr |jS)zyReturns True if the collection is ascending order, False if not. This is part of the mandatory API for smartset.rTNrrurs rr"zbaseset.isascending-s* t9>d*>t>rcZt|dkry|jduxr |j S)zzReturns True if the collection is descending order, False if not. This is part of the mandatory API for smartset.rTNrrs rr$zbaseset.isdescending5s- t9>d*B4??/BBrc8t|dkry|jS)zlIs the collection is in topographical order or not. This is part of the mandatory API for smartset.rT)rrvrs rr&zbaseset.istopo=s t9>||rc|rE|j|jdS|jr|jdS|jdSy)Nr]rurzrrs rr9z baseset.firstEsE &zz!}$}}Q''}}R((rc|rE|j|jdS|jr|jdS|jdSy)Nrr]rrs rr<z baseset.lastOsE &zz"~%}}R((}}Q''rcVt|turvd|jvrhd|jvrZ|jNtt |j ||j |j }|j|_|St tt|||}|S)Nrx)r|r&)r rirrurrxrvsuper)rrLops __class__s r _fastsetopzbaseset._fastsetopYs K7 "%..($--'++WTYY+EJJ7 A ??AL2gt,b1%8Arc&|j|dS)Ns__and__rrKs rrMzbaseset.__and__iuj11rc&|j|dS)Ns__sub__rrKs rrUzbaseset.__sub__lrrcL|j$t|j|||jS|j}|js0t t ||z dt t ||z d}}t||||j}|j|_|S)N)r&r])rurirzrvrr7r)rr`rar|rs rr_zbaseset._sliceos ?? "4::eD1$,,G G}}c$i$.2CD E8I14M4E Dt$T\\ : rcdddd|j}tj|j}|s9|j}|j |j }t j|}dt|||fzS)Nr-+NFTs <%s%s %s>) rur buildreprr{rzrrbytereprr)rdrls r__repr__zbaseset.__repr__{srt4 0 A   0 A*MM!!!$Ay1555r)r+NFrn) r rprq__doc__r}r propertycacherxrrzr r0r6rrrrrCr@r>r"r$r&r9r<rrMrUr_r strmethodr __classcell__rs@rriris9v"$     +#' &&H" ?C 22  6 6rriceZdZdZddfdZdZdZdZedZ ed Z d Z e Z d Z dd Zd ZdZdZdZdZdZej,dZy)rZzDuck type for baseset class which iterates lazily over the revisions in the subset and contains a function which tests for membership in the revset cyror+)rls rr.zfilteredset.s4rNc.||_||_||_y)a! condition: a function that decide whether a revision in the subset belongs to the revset or not. condrepr: a tuple of (format, obj, ...), a function or an object that provides a printable representation of the given condition. N)_subset _condition _condrepr)rsubsetr[rFs rr}zfilteredset.__init__s #!rcD||jvxr|j|Sr*)rrrrls rrzfilteredset.__contains__sDLL 7T__Q%77rc8|j|jSr*) _iterfilterrrs rr zfilteredset.__iter__s --rc#LK|j}|D]}||s |ywr*)r)rrkcondrls rrzfilteredset._iterfilters%AAws$$cDjjyfdS)Nc0jSr*rrkrsrr.z%filteredset.fastasc..t''-r)rr0rrks`@rr0zfilteredset.fastascs \\ ! ! :--rcDjjyfdS)Nc0jSr*rrsrr.z&filteredset.fastdesc..rr)rr6rs`@rr6zfilteredset.fastdescs \\ " " :--rcd}|jr |jnd|jr |jnd|j|jg}|D]}||}n||}n|}|D]}yyNTF)r"r0r$r6)rfast candidates candidaterkrSs rrzfilteredset.__nonzero__s ,,.DLLD!..0DMMd LL MM  $I$ $  BBArc<td|D}t|S)Nc3 K|]}|ywr*r+).0rSs r z&filteredset.__len__..s$t!Ats )rir)rrs rr>zfilteredset.__len__s $t$ $1v rc<|jj|y)Nr@)rrCrBs rrCzfilteredset.sorts '*rc8|jjyr*)rr@rs rr@zfilteredset.reverses rc6|jjSr*)rr"rs rr"zfilteredset.isascendings||''))rc6|jjSr*)rr$rs rr$zfilteredset.isdescendings||((**rc6|jjSr*)rr&rs rr&zfilteredset.istopos||""$$rc|D]}|cSyr*r+rs rr9zfilteredset.firstAHrcd}|jr |j}n|jr |j}||D]}|cSyd}|D]}|Sr*)r"r6r$r0rrkrls rr<zfilteredset.lastsa     B    B >TAHrctj|jg}tj|j }|r|j |dt|dj|fzS)Ns<%s %s>s, ) rrrrrrrhrjoin)rxsrs rrzfilteredset.__repr__sW - .   0 IIaLYt_ejjn===rrn)r rprqrr}rr rpropertyr0r6rrrr>rCr@r"r$r&r9r<rrrr+rrrZrZs *8$ "8. .. .. ,H+*+%  >>rrZc#Kt}|rt}d}d} | t|}| t|}|||}|||k(rd}||k(rd}6#t$r|}|||}n|||D]}|YywxYww)zproduce an ordered iteration from two iterators with the same order The ascending is used to indicated the iteration direction. N)r7r1rg StopIteration) ascendingiter1iter2choiceval1val2nrkvals r _iterorderedrs F D D|E{|E{tT"AGqyqy     JB  JCI s"A87A %A52A84A55A8ceZdZdZddZdZdZeZejdZ dZ dZ e d Ze d Zd Zdd Zd ZdZdZdZdZdZej2dZy)rOa Represent the addition of two sets Wrapper structure for lazily adding two structures without losing much performance on the __contains__ method If the ascending attribute is set, that means the two structures are ordered in either an ascending or descending way. Therefore, we can add them maintaining the order by iterating over both at the same time >>> xs = baseset([0, 3, 2]) >>> ys = baseset([5, 2, 4]) >>> rs = addset(xs, ys) >>> bool(rs), 0 in rs, 1 in rs, 5 in rs, rs.first(), rs.last() (True, True, False, True, 0, 4) >>> rs = addset(xs, baseset([])) >>> bool(rs), 0 in rs, 1 in rs, rs.first(), rs.last() (True, True, False, 0, 2) >>> rs = addset(baseset([]), baseset([])) >>> bool(rs), 0 in rs, rs.first(), rs.last() (False, False, None, None) iterate unsorted: >>> rs = addset(xs, ys) >>> # (use generator because pypy could call len()) >>> list(x for x in rs) # without _genlist [0, 3, 2, 5, 4] >>> assert not rs._genlist >>> len(rs) 5 >>> [x for x in rs] # with _genlist [0, 3, 2, 5, 4] >>> assert rs._genlist iterate ascending: >>> rs = addset(xs, ys, ascending=True) >>> # (use generator because pypy could call len()) >>> list(x for x in rs), list(x for x in rs.fastasc()) # without _asclist ([0, 2, 3, 4, 5], [0, 2, 3, 4, 5]) >>> assert not rs._asclist >>> len(rs) 5 >>> [x for x in rs], [x for x in rs.fastasc()] ([0, 2, 3, 4, 5], [0, 2, 3, 4, 5]) >>> assert rs._asclist iterate descending: >>> rs = addset(xs, ys, ascending=False) >>> # (use generator because pypy could call len()) >>> list(x for x in rs), list(x for x in rs.fastdesc()) # without _asclist ([5, 4, 3, 2, 0], [5, 4, 3, 2, 0]) >>> assert not rs._asclist >>> len(rs) 5 >>> [x for x in rs], [x for x in rs.fastdesc()] ([5, 4, 3, 2, 0], [5, 4, 3, 2, 0]) >>> assert rs._asclist iterate ascending without fastasc: >>> rs = addset(xs, generatorset(ys), ascending=True) >>> assert rs.fastasc is None >>> [x for x in rs] [0, 2, 3, 4, 5] iterate descending without fastdesc: >>> rs = addset(generatorset(xs), ys, ascending=False) >>> assert rs.fastdesc is None >>> [x for x in rs] [5, 4, 3, 2, 0] NcX||_||_d|_||_d|_d|_yr*)_r1_r2_iterru_genlistr)rrevs1revs2rs rr}zaddset.__init__os, #  rc,t|jSr*)rrzrs rr>zaddset.__len__ws4::rcZt|jxst|jSr*)rrrrs rrzaddset.__nonzero__zsDHH~/dhh/rcd|jstt||_|jSr*)rrirers rrzz addset._lists#}}#DJ/DM}}rc<j-jrtjSfd}|Sjjrd}nd}t |}||St j |}|,tt j j }n|}t j|}|,tt jj }n|}tj||S)aIterate over both collections without repeating elements If the ascending attribute is not set, iterate over the first one and then over the second one checking for membership on the first one so we dont yield any duplicates. If the ascending attribute is set, iterate over both collections at the same time, yielding only one value at a time in the given order. c3KjD]}|jj}jD]}||r |ywr*)rrr)rSinr1rs rarbitraryordergenz*addset.__iter__..arbitraryordergensCAG"xx,,A7"s AAAr0r6r) rurre_trysetasclistrrsortedrr)rrattrrkrrs` rr zaddset.__iter__s ?? "}}DMM** %& &  ??DD T4  >4K$' =doo2EFGEGE$' =doo2EFGEGEDOOUE::rcl|j(|jt|j|_yyy)z9populate the _asclist attribute if possible and necessaryN)rrrrs rrzaddset._trysetasclists- == $)>"4==1DM*? $rc|j|j|jjS|jj|j jdfvryfdS)Nc2tdSrorrrsrr.z addset.fastasc..s|D%'57;r)rrr rr0rrrrs @@rr0zaddset.fastascs\  == $==)) )     E5> !;;rc|j|j|jjS|jj|j jdfvryfdS)Nc2tdSrrrsrr.z!addset.fastdesc..s|E57EG !<||jvxs||jvSr*)rrrs rrzaddset.__contains__sDHH}-TXX -rc| |_y)zSort the added set For this we use the cached list with all the generated values and if we know they are ascending or descending we can sort them in a smart way. NrurBs rrCz addset.sorts &+rc:|jduxr |jSr*rrs rr"zaddset.isascendingsd*>t>rc<|jduxr |j Sr*rrs rr$zaddset.isdescendingsd*B4??/BBrcyrr+rs rr&z addset.istoporcv|j|jjy|j |_yr*)rurzr@rs rr@zaddset.reverses* ?? " JJ   "&//1DOrc|D]}|cSyr*r+rs rr9z addset.firstrrcf|j|j}|j|Sr*)r@r9)rrs rr<z addset.lasts$ jjl  rctdddd|j}dt|||j|jfzS)Nrrrrs <%s%s %r, %r>)rurrrrrs rrzaddset.__repr__s7t4 0 A9T?Atxx"JJJrr*rn)r rprqrr}r>rrrrrrzr rrr0r6rrCr"r$r&r@r9r<rrrr+rrrOrO'sEN0H  /;b2 <<==.&?C 2   KKrrOceZdZdZdfd ZddZdZeZdZdZ dZ dZ d Z dd Z d Zd Zd ZdZdZdZej*dZxZS) generatorsetaWrap a generator for lazy iteration Wrapper structure for generators that provides lazy membership and can be iterated more than once. When asked for membership it generates values until either it finds the requested one or has gone through all the elements in the generator >>> xs = generatorset([0, 1, 4], iterasc=True) >>> assert xs.last() == xs.last() >>> xs.last() # cached 4 cR||}n|rt}nt}tt||Sr*)_generatorsetasc_generatorsetdescrr__new__)clsgeniterasctyprs rrzgeneratorset.__new__ s, ?C "C#C\3/44rcX||_d|_i|_g|_d|_d|_y)zM gen: a generator producing the values for the generatorset. NFT)_genr_cacher _finishedru)rrrs rr}zgeneratorset.__init__s.    rcJ|jry|jD]}yyr)r _consumegenrrSs rrzgeneratorset.__nonzero__"s' ==!!#A$rc||jvr|j|S|jD] }||k(s yd|j|<yrrrrrlrs rrzgeneratorset.__contains__.sM  ;;q> !!!#AAv$ Arc|jr |j}n |j}||S|jD]}t |Sr*)rur0r6rrers rr zgeneratorset.__iter__:sI ??BB >4K!!#A $Dzrc|jrt|jS|j|jtt cfd}|S)Nc3xKd} |kr|n |dz }$#t$rYywxYwwNr]r)r)i_len_nextgenlistnextgens rrz#generatorset._iterator..genUsWAtG}$!!*$#Gn,Q )s: +: 7:7:)rrerrrrg)rrr(r)r*r+s @@@@r _iteratorzgeneratorset._iteratorGsK >> & &--""$4 e u rc#LK|j}|jj}|jD]}d||<||||jsPd|_|jdd}|j ||_|j|_|j|_ yywro) rrrhrrrCrr r0rr6)rrGr*itemascs rrzgeneratorset._consumegencs --&&IIDE$K DMJ~~!DN--"C HHJDM<zgeneratorset.__len__rs'!!#A $4==!!rc| |_yr*rrBs rrCzgeneratorset.sortw %+rc(|j |_yr*rrs rr@zgeneratorset.reversez"oo-rc|jSr*rrs rr"zgeneratorset.isascending} rc|j Sr*rrs rr$zgeneratorset.isdescending??""rcyrr+rs rr&zgeneratorset.istopor rc|jr |j}n |j}|%|jD]}|j St |dSr*)rur0r6rr9rgrs rr9zgeneratorset.firstsQ ??BB :%%'(::< BD$rc|jr |j}n |j}|%|jD]}|j St |dSr*)rur6r0rr<rgrs rr<zgeneratorset.lastsQ ??BB :%%'(99; BD$rcFddd|j}dt||fzS)NrrFTs<%s%s>)rurrs rrzgeneratorset.__repr__s) %doo 6IdOQ///rr*rn)r rprqrrr}rrrrr r,rr>rCr@r"r$r&r9r<rrrrrs@rrrst 5 H  8 -" &.#    00rrc.eZdZdZej ZdZy)rz@Special case of generatorset optimized for ascending generators.c||jvr|j|S|jD]}||k(ry||kDsnd|j|<yrr!r"s rrz_generatorsetasc.__contains__W  ;;q> !!!#AAv1u $  ArN)r rprqrrr,r0rr+rrrrsJ$$G rrc.eZdZdZej ZdZy)rzASpecial case of generatorset optimized for descending generators.c||jvr|j|S|jD]}||k(ry||ksnd|j|<yrr!r"s rrz_generatorsetdesc.__contains__r@rN)r rprqrrr,r6rr+rrrrsK%%H rrNc| t|}||k}|s |dz|dz}}t||||jjS)zCreate a spanset that represents a range of repository revisions start: first revision included the set (default to 0) end: first revision excluded (last+1) (default to len(repo)) Spanset will be descending if `end` < `start`. r)r_spanset changelog filteredrevs)repor`endrs rspansetrIsJ {$i I 1Weais E3 4>>+F+F GGrceZdZdZdZddZdZdZdZdZ dZ d Z d Z d Z e Zd Zd ZdZdZdZfdZej,dZxZS)rDa[Duck type for baseset class which represents a range of revisions and can work lazily and without having all the range in memory Note that spanset(x, y) behave almost like range(x, y) except for two notable points: - when x < y it will be automatically descending, - revision filtered with this repoview will be skipped. c<||_||_||_||_yr*)_start_endru _hiddenrevs)rr`rHr hiddenrevss rr}z_spanset.__init__s  #%rc| |_yr*rrBs rrCz _spanset.sortr2rc(|j |_yr*rrs rr@z_spanset.reverser4rcyrr+rs rr&z_spanset.istopor rc#DK|j}|D] }||vs| ywr*)rN)r iterrangerrSs rrz_spanset._iterfilters'   Azs  cZ|jr|jS|jSr*rur0r6rs rr z_spanset.__iter__s! ??<<> !==? "rct|j|j}|jr|j |St |Sr*)rfrLrMrNrrerrTs rr0z_spanset.fastascs:$++tyy1   ##I. .Irct|jdz |jdz d}|jr|j |St |S)Nrr)rfrMrLrNrrerXs rr6z_spanset.fastdescsD$))a-q"=   ##I. .Ircx|j}|j|cxkxr|jkncxr |xr||v Sr*)rNrLrM)rrhiddens rrz_spanset.__contains__s=!! s.TYY.  $sf}5  rc|D]}yyrr+rs rrz_spanset.__nonzero__sArc@|js"t|j|jz Sd}|j}|j}|jD]#}||cxkr|ksn||cxkr|ksn|dz }%t|j|jz |z Sr&)rNabsrMrL)rcountr`rHrs rr>z_spanset.__len__!styy4;;./ /EKKE))C''#&&ES,>3,>QJE(tyy4;;./%7 7rc|jSr*rrs rr"z_spanset.isascending-r6rc|j Sr*rrs rr$z_spanset.isdescending0r8rcl|jr |j}n |j}|D]}|cSyr*rVrs rr9z_spanset.first3s/ ??BBAHrcl|jr |j}n |j}|D]}|cSyr*)rur6r0rs rr<z _spanset.last<s/ ??BBAHrc|jrtt|||S|jrGt |j |z|j}t |j |z|j}nFt|j|z |j }t|j|z |j }t|||j|jSr*) rNrrDr_rur1rLrMr7)rr`rarlrmrs rr_z_spanset._sliceEs   4/t< < ??DKK%'3ADKK$& 2ADII$dkk2ADII%t{{3A1doot/?/?@@rcrddd|j}dt|||j|jfzS)Nrrr=s <%s%s %d:%d>)rurrLrMrs rrz_spanset.__repr__Qs5 %doo 6)D/1dkk499!MMMrrn)r rprqrr}rCr@r&rr r0r6rrrrr>r"r$r9r<r_rrrrrs@rrDrDs|& &.  #     H 8# ANNrrDc(eZdZdZfdZdZxZS)rIza set containing all revisions in the repo This class exists to host special optimization and magic to handle virtual revisions such as "null". cltt| dt|d|jj y)Nr]T)rrIr}rrErF)rrGrs rr}zfullreposet.__init__^s) k4) s4y$ ; ; rctj|dst||jz }|j |j |S)zAs self contains the whole repo, all of the other set should also be in self. Therefore `self & other = other`. This boldly assumes the other contains valid revs only. r"r)rrXrirNrCr$rKs rrMzfullreposet.__and__csG}5 ED$4$445E 4,,. / r)r rprqrr}rMrrs@rrIrIWs  rrI)r]N)rrrrrutilsrrrrirZrrOrrrrIrDrIr+rrrks <MLML``6`6Fu>"u>p"JUK UKpe0#e0P|( ( H uNuNp(r