| Server IP : 162.144.4.212 / Your IP : 216.73.216.108 Web Server : Apache System : Linux gator2125.hostgator.com 5.14.0-162.23.1.9991722448259.nf.el9.x86_64 #1 SMP PREEMPT_DYNAMIC Wed Jul 31 18:11:45 UTC 2024 x86_64 User : cozeellc ( 2980) PHP Version : 8.3.31 Disable Function : NONE MySQL : OFF | cURL : ON | WGET : ON | Perl : ON | Python : OFF | Sudo : ON | Pkexec : ON Directory : /lib64/python3.9/site-packages/mercurial/__pycache__/ |
Upload File : |
a
�+�b�� � @ s� d dl mZ ddlmZ ddlmZmZmZmZ ddlm Z dd� Z
G dd � d e �Z G d
d � d e �Z
G d d
� d
e �Zdd� ZG dd� de �ZG dd� de �ZG dd� de�ZG dd� de�Zd dd�ZG dd � d e �ZG d d � d e�ZdS ) � )�absolute_import� )�getattr)�encoding�error�pycompat�util)�
stringutilc C s t �t| �j��d�S )N� _)r Zsysbytes�type�__name__�lstrip)�o� r �8/usr/lib64/python3.9/site-packages/mercurial/smartset.py� _typename s r c @ s� e Zd Zdd� ZeZdd� Zdd� ZdZdZdd � Z d
d � Z
d d
� Z dd� Z dd� Z
dd� Zdd� Zdd� Zdd� Zd*dd �Zd d � Zd d � Zd!d"� Zd+d$d%�Zd&d'� Zd(d)� ZdS ),�abstractsmartsetc C s
t � �dS )z!True if the smartset is not emptyN��NotImplementedError��selfr r r � __nonzero__ s z abstractsmartset.__nonzero__c C s
t � �dS )z provide fast membership testingNr )r �revr r r � __contains__ s z abstractsmartset.__contains__c C s
t � �dS )z:iterate the set in the order it is supposed to be iteratedNr r r r r �__iter__# s zabstractsmartset.__iter__Nc C s
t � �dS )z/True if the set will iterate in ascending orderNr r r r r � isascending/ s z abstractsmartset.isascendingc C s
t � �dS )z0True if the set will iterate in descending orderNr r r r r � isdescending3 s z abstractsmartset.isdescendingc C s
t � �dS )z3True if the set will iterate in topographical orderNr r r r r �istopo7 s zabstractsmartset.istopoc s@ | j du rt| �� n| � � D ]� q.q td��� fdd�| _� S )z%return the minimum element in the setN� arg is an empty sequencec s � S �Nr r ��vr r �<lambda>D � z&abstractsmartset.min.<locals>.<lambda>)�fastasc�min�
ValueErrorr r r r r% ; s
zabstractsmartset.minc s> | j du rt| �S | � � D ]� q,qtd��� fdd�| _� S )z%return the maximum element in the setNr c s � S r r r r r r r" P r# z&abstractsmartset.max.<locals>.<lambda>)�fastdesc�maxr& r r r r r( G s
zabstractsmartset.maxc C s
t � �dS )zireturn the first element in the set (user iteration perspective)
Return None if the set is emptyNr r r r r �firstS s zabstractsmartset.firstc C s
t � �dS )zhreturn the last element in the set (user iteration perspective)
Return None if the set is emptyNr r r r r �lastY s zabstractsmartset.lastc C s
t � �dS )zkreturn the length of the smartsets
This can be expensive on smartset that could be lazy otherwise.Nr r r r r �__len___ s zabstractsmartset.__len__c C s
t � �dS )z$reverse the expected iteration orderNr r r r r �reversee s zabstractsmartset.reverseFc C s
t � �dS )z:get the set to iterate in an ascending or descending orderNr �r r, r r r �sorti s zabstractsmartset.sortc C s t |t�r| S | j|j|dd�S )z{Returns a new object with the intersection of the two collections.
This is part of the mandatory API for smartset.F��condrepr�cache)�
isinstance� fullreposet�filterr �r �otherr r r �__and__m s
zabstractsmartset.__and__c C s
t | |�S )ztReturns a new object with the union of the two collections.
This is part of the mandatory API for smartset.)�addsetr5 r r r �__add__u s zabstractsmartset.__add__c s" |j � | j� fdd�d|fdd�S )z{Returns a new object with the substraction of the two collections.
This is part of the mandatory API for smartset.c s
� | � S r r )�r��cr r r" � r# z*abstractsmartset.__sub__.<locals>.<lambda>s <not %r>Fr/ )r r4 r5 r r; r �__sub__{ s �zabstractsmartset.__sub__Tc C s& |rt �|d�rt �|�}t| ||�S )a1 Returns 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.s __code__)r � safehasattrZ cachefunc� filteredset)r � conditionr0 r1 r r r r4 � s
zabstractsmartset.filterc C s& |dk s|dk rt �d��| �||�S )zAReturn new smartset that contains selected elements from this setr s negative index not allowed)r ZProgrammingError�_slice)r �start�stopr r r �slice� s
zabstractsmartset.slicec C sz g }t | �}t�|�D ]}t|d �}|d u r q2qt�|| �D ]$}t|d �}|d u rZ qf|�|� q@t|d||| fd�S )Ns slice=%d:%d %r)�datarepr)�iterr �xrange�next�append�baseset)r rB rC Zys�it�x�yr r r rA � s
zabstractsmartset._slice)F)NT)r �
__module__� __qualname__r �__bool__r r r$ r' r r r r% r( r) r* r+ r, r. r7 r9 r= r4 rD rA r r r r r s,
r c s� e Zd ZdZd1dd�Zejdd� �Zejd d
� �Zejd d � �Z d
d� Z
dd� Z dd� Z ejdd� �Z
dd� ZeZd2dd�Zdd� Zdd � Zd d � Zd d � Zd!d"� Zd#d$� Zd%d&� Z� fd'd(�Zd)d*� Zd+d,� Zd-d.� Ze j d/d0� �Z � Z S )3rJ a� Basic 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
r NFc C sF d| _ || _t|t�r$|| _d| _ nt|t�s6t|�}|| _|| _dS )z�
datarepr: a tuple of (format, obj, ...), a function or an object that
provides a printable representation of the given data.
NT)�
_ascending�_istopor2 �set�_set�list�_list� _datarepr)r �datarE r r r r �__init__� s
zbaseset.__init__c C s
t | j�S r )rS rV r r r r rT � s z baseset._setc C s | j d d � }|�� |S r )rV r. )r Zasclistr r r �_asclist� s zbaseset._asclistc C s d| j v sJ �t| j�S )NrT )�__dict__rU rT r r r r rV s z
baseset._listc C s2 | j d u rt| j�S | j r$t| j�S t| j�S d S r )rQ rF rV rZ �reversedr r r r r s
zbaseset.__iter__c C s
t | j�S r )rF rZ r r r r r$ s zbaseset.fastascc C s
t | j�S r )r\ rZ r r r r r' s zbaseset.fastdescc C s | j jS r )rT r r r r r r s zbaseset.__contains__c C s t t| ��S r )�bool�lenr r r r r s zbaseset.__nonzero__c C s t |� | _d| _d S �NF)r] rQ rR r- r r r r. s z baseset.sortc C s* | j d u r| j�� n
| j | _ d| _d S r_ )rQ rV r, rR r r r r r, ! s
zbaseset.reversec C s" d| j v rt| j�S t| j�S d S )NrV )r[ r^ rV rT r r r r r+ ( s
zbaseset.__len__c C s t | �dkrdS | jduo | jS )zyReturns True if the collection is ascending order, False if not.
This is part of the mandatory API for smartset.r TN�r^ rQ r r r r r . s zbaseset.isascendingc C s" t | �dkrdS | jduo | j S )zzReturns True if the collection is descending order, False if not.
This is part of the mandatory API for smartset.r TNr` r r r r r 6 s zbaseset.isdescendingc C s t | �dkrdS | jS )zlIs the collection is in topographical order or not.
This is part of the mandatory API for smartset.r T)r^ rR r r r r r > s zbaseset.istopoc C s6 | r2| j d u r| jd S | j r(| jd S | jd S d S )Nr ����rQ rV rZ r r r r r) F s
z
baseset.firstc C s6 | r2| j d u r| jd S | j r(| jd S | jd S d S )Nra r rb r r r r r* P s
z baseset.lastc sh t |�tu rPd|jv rPd| jv rP| jd urPtt| j|�|j�| jd�}| j|_nttt| �|�|�}|S )NrT )rX r )r rJ r[ rQ r rT rR �super)r r6 �op�s�� __class__r r �
_fastsetopZ s
�����
zbaseset._fastsetopc C s | � |d�S )Ns __and__�rh r5 r r r r7 j s zbaseset.__and__c C s | � |d�S )Ns __sub__ri r5 r r r r= m s zbaseset.__sub__c C sv | j d u r"t| j||� | jd�S | j}| j sTtt|�| d�tt|�| d� }}t|||� | jd�}| j |_ |S )N)r r )rQ rJ rV rR rZ r( r^ )r rB rC rX re r r r rA p s
&zbaseset._slicec C sT dddd�| j }t�| j�}|sB| j}| j d ur8| j}t�|�}dt| �||f S )Nr# � -� +�NFTs <%s%s %s>) rQ r � buildreprrW rV rZ r �bytereprr )r �dre �lr r r �__repr__| s
zbaseset.__repr__)r NF)F) r rN rO �__doc__rY r �
propertycacherT rZ rV r r$ r' r r rP r. r, r+ r r r r) r* rh r7 r= rA r � strmethodrq �
__classcell__r r rf r rJ � s: ;
rJ c @ s� e Zd ZdZdd� dfdd�Zdd� Zd d
� Zd d � Zed
d� �Z edd� �Z
dd� Z e Z dd� Z
d&dd�Zdd� Zdd� Zd d � Zd d � Zd d!� Zd"d#� Zejd$d%� �ZdS )'r? z�Duck type for baseset class which iterates lazily over the revisions in
the subset and contains a function which tests for membership in the
revset
c C s dS �NTr )rL r r r r" � r# zfilteredset.<lambda>Nc C s || _ || _|| _dS )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)r Zsubsetr@ r0 r r r rY � s zfilteredset.__init__c C s || j v o| �|�S r )rw rx �r rL r r r r � s zfilteredset.__contains__c C s | � | j�S r )� _iterfilterrw r r r r r � s zfilteredset.__iter__c c s" | j }|D ]}||�r
|V q
d S r )rx )r rK ZcondrL r r r r{ � s zfilteredset._iterfilterc s" �j j� � d u rd S � �fdd�S )Nc s �� � � �S r �r{ r �rK r r r r" � r# z%filteredset.fastasc.<locals>.<lambda>)rw r$ r r r} r r$ � s zfilteredset.fastascc s" �j j� � d u rd S � �fdd�S )Nc s �� � � �S r r| r r} r r r" � r# z&filteredset.fastdesc.<locals>.<lambda>)rw r' r r r} r r' � s zfilteredset.fastdescc C sp d }| � � r| jnd | �� r"| jnd | j| jg}|D ]}|d ur4|} qJq4|d urZ|� }n| }|D ]} dS dS �NTF)r r$ r r' )r ZfastZ
candidates� candidaterK r: r r r r � s �zfilteredset.__nonzero__c C s t dd� | D ��}t|�S )Nc s s | ]
}|V qd S r r )�.0r: r r r � <genexpr>� r# z&filteredset.__len__.<locals>.<genexpr>)rJ r^ )r rp r r r r+ � s zfilteredset.__len__Fc C s | j j|d� d S )N�r, )rw r. r- r r r r. � s zfilteredset.sortc C s | j �� d S r )rw r, r r r r r, � s zfilteredset.reversec C s
| j �� S r )rw r r r r r r � s zfilteredset.isascendingc C s
| j �� S r )rw r r r r r r � s zfilteredset.isdescendingc C s
| j �� S r )rw r r r r r r � s zfilteredset.istopoc C s | D ]
}| S d S r r rz r r r r) � s zfilteredset.firstc C sV d }| � � r| j}n| �� r"| j}|d ur@|� D ]
}| S d S d }| D ]}qH|S d S r )r r' r r$ �r rK rL r r r r* � s
zfilteredset.lastc C s> t �| j�g}t�| j�}|r(|�|� dt| �d�|�f S )Ns <%s %s>s , ) r rn rw r rm ry rI r �join)r Zxsre r r r rq � s
zfilteredset.__repr__)F)r rN rO rr rY r r r{ �propertyr$ r' r rP r+ r. r, r r r r) r* r rt rq r r r r r? � s*
r? c c s� t }| r t}d}d}zN|du r&t|�}|du r6t|�}|||�}|V ||krRd}||krd}qW nH ty� |}|dur�|V |}n|dur�|V |D ]
}|V q�Y n0 dS )z�produce an ordered iteration from two iterators with the same order
The ascending is used to indicated the iteration direction.
N)r( r% rH �
StopIteration) � ascending�iter1�iter2�choiceZval1Zval2�nrK �valr r r � _iterordered s2
r� c @ s� e Zd ZdZd&dd�Zdd� Zdd� ZeZej d d
� �Z
d d � Z d
d� Z e
dd� �Ze
dd� �Zdd� Zd'dd�Zdd� Zdd� Zd d � Zd d � Zd d!� Zd"d#� Zejd$d%� �ZdS )(r8 a 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]
Nc C s( || _ || _d | _|| _d | _d | _d S r )�_r1�_r2Z_iterrQ �_genlistrZ )r Zrevs1Zrevs2r� r r r rY p s zaddset.__init__c C s
t | j�S r )r^ rV r r r r r+ x s zaddset.__len__c C s t | j�pt | j�S r )r] r� r� r r r r r { s zaddset.__nonzero__c C s | j stt| ��| _ | j S r )r� rJ rF r r r r rV � s z addset._listc s� � j du r,� jrt� j�S � fdd�}|� S � �� � j r@d}nd}t� |�}|dur\|� S t� j|�}|du r�tt� j� j d��}n|� }t� j|�}|du r�tt� j� j d��}n|� }t� j ||�S )a� Iterate 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.
Nc 3 s8 � j D ]
} | V q� j j}� jD ]} || �s | V q d S r )r� r r� )r: Zinr1r r r �arbitraryordergen� s
z*addset.__iter__.<locals>.arbitraryordergens fastascs fastdescr� ) rQ r� rF �_trysetasclistr r� �sortedr� r� )r r� �attrrK r� r� r r r r � s*
zaddset.__iter__c C s$ | j dur | jdu r t| j �| _dS )z9populate the _asclist attribute if possible and necessaryN)r� rZ r� r r r r r� � s zaddset._trysetasclistc sH | � � | jd ur| jjS | jj� | jj�d � �fv r:d S � �fdd�S )Nc s t d� � �� �S rv �r� r �r� r� r r r" � r# z addset.fastasc.<locals>.<lambda>)r� rZ r r� r$ r� r r r� r r$ � s
zaddset.fastascc sH | � � | jd ur| jjS | jj� | jj�d � �fv r:d S � �fdd�S )Nc s t d� � �� �S r_ r� r r� r r r" � r# z!addset.fastdesc.<locals>.<lambda>)r� rZ � __reversed__r� r' r� r r r� r r' � s
zaddset.fastdescc C s || j v p|| jv S r )r� r� rz r r r r � s zaddset.__contains__Fc C s | | _ dS )z�Sort 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.
N�rQ r- r r r r. � s z addset.sortc C s | j d uo| j S r r� r r r r r � s zaddset.isascendingc C s | j d uo| j S r r� r r r r r � s zaddset.isdescendingc C s dS r_ r r r r r r � s z
addset.istopoc C s$ | j d u r| j�� n
| j | _ d S r )rQ rV r, r r r r r, � s
zaddset.reversec C s | D ]
}| S d S r r rz r r r r) � s z addset.firstc C s | � � | �� }| � � |S r )r, r) )r r� r r r r* � s z addset.lastc C s* dddd�| j }dt| �|| j| jf S )Nr# rj rk rl s
<%s%s %r, %r>)rQ r r� r� �r ro r r r rq � s zaddset.__repr__)N)F)r rN rO rr rY r+ r rP r rs rV r r� r� r$ r' r r. r r r r, r) r* r rt rq r r r r r8 ( s. G
1
r8 c s� e Zd ZdZd$� fdd� Zd%dd�Zdd� ZeZd d
� Zd d � Z d
d� Z
dd� Z dd� Z d&dd�Z
dd� Zdd� Zdd� Zd d � Zd d � Zd d!� Zejd"d#� �Z� ZS )'� generatorseta� Wrap 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
Nc s, |d u r| }n|rt }nt}tt| ��|�S r )�_generatorsetasc�_generatorsetdescrc r� �__new__)�cls�gen�iterasc�typrf r r r� s zgeneratorset.__new__c C s( || _ d| _i | _g | _d| _d| _dS )zM
gen: a generator producing the values for the generatorset.
NFT)�_genrZ �_cacher� � _finishedrQ )r r� r� r r r rY s zgeneratorset.__init__c C s | j r
dS | �� D ]} dS dS r~ )r� � _consumegen�r r: r r r r # s
zgeneratorset.__nonzero__c C s> || j v r| j | S | �� D ]}||kr dS q d| j |< dS r~ �r� r� �r rL rp r r r r / s
zgeneratorset.__contains__c C s8 | j r| j}n| j}|d ur"|� S | �� D ]}q*t| �S r )rQ r$ r' r� rF r� r r r r ; s zgeneratorset.__iter__c s@ | j rt| j�S | j�| �� �tt � �� ���fdd�}|� S )Nc 3 sN d} | � ��k r �| V n$z���V W n t y> Y d S 0 | d7 } qd S �Nr r )r� )�i��_lenZ_next�genlistZnextgenr r r� V s z#generatorset._iterator.<locals>.gen)r� rF r� r� r^ rH )r r� r r� r � _iteratorH s
zgeneratorset._iteratorc c sl | j }| jj}| jD ]}d||< ||� |V q| jshd| _| jd d � }|�� || _|j| _|j | _
d S rv ) r� r� rI r� r� r. rZ r r$ r� r' )r r1 r� �itemZascr r r r� d s
zgeneratorset._consumegenc C s | � � D ]}qt| j�S r )r� r^ r� rz r r r r+ s s zgeneratorset.__len__Fc C s | | _ d S r r� r- r r r r. x s zgeneratorset.sortc C s | j | _ d S r r� r r r r r, { s zgeneratorset.reversec C s | j S r r� r r r r r ~ s zgeneratorset.isascendingc C s | j S r r� r r r r r � s zgeneratorset.isdescendingc C s dS r_ r r r r r r � s zgeneratorset.istopoc C s> | j r| j}n| j}|d u r2| �� D ]}q$| �� S t|� d �S r )rQ r$ r' r� r) rH r� r r r r) � s zgeneratorset.firstc C s> | j r| j}n| j}|d u r2| �� D ]}q$| �� S t|� d �S r )rQ r' r$ r� r* rH r� r r r r* � s zgeneratorset.lastc C s ddd�| j }dt| �|f S )Nrj rk �FTs <%s%s>)rQ r r� r r r rq � s zgeneratorset.__repr__)N)N)F)r rN rO rr r� rY r rP r r r� r� r+ r. r, r r r r) r* r rt rq ru r r rf r r� s&
r� c @ s e Zd ZdZejZdd� ZdS )r� z@Special case of generatorset optimized for ascending generators.c C sJ || j v r| j | S | �� D ] }||kr. dS ||kr q<q d| j |< dS r~ r� r� r r r r � s
z _generatorsetasc.__contains__N)r rN rO rr r� r� r$ r r r r r r� � s r� c @ s e Zd ZdZejZdd� ZdS )r� zASpecial case of generatorset optimized for descending generators.c C sJ || j v r| j | S | �� D ] }||kr. dS ||k r q<q d| j |< dS r~ r� r� r r r r � s
z _generatorsetdesc.__contains__N)r rN rO rr r� r� r' r r r r r r� � s r� Nc C s@ |du rt | �}||k}|s.|d |d }}t|||| jj�S )z�Create 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`.
Nr )r^ �_spanset� changelog� filteredrevs)�reporB �endr� r r r �spanset� s r� c s� e Zd ZdZdd� Zd%dd�Zdd� Zd d
� Zd d � Zd
d� Z dd� Z
dd� Z dd� Z dd� Z
e
Zdd� Zdd� Zdd � Zd d � Zd d � Z� fd!d"�Zejd#d$� �Z� ZS )&r� a\ 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 xrange(x, y) except for two
notable points:
- when x < y it will be automatically descending,
- revision filtered with this repoview will be skipped.
c C s || _ || _|| _|| _d S r )�_start�_endrQ � _hiddenrevs)r rB r� r� Z
hiddenrevsr r r rY � s z_spanset.__init__Fc C s | | _ d S r r� r- r r r r. � s z
_spanset.sortc C s | j | _ d S r r� r r r r r, � s z_spanset.reversec C s dS r_ r r r r r r � s z_spanset.istopoc c s" | j }|D ]}||vr
|V q
d S r )r� )r � iterrangere r: r r r r{ � s z_spanset._iterfilterc C s | j r| �� S | �� S d S r �rQ r$ r' r r r r r s z_spanset.__iter__c C s( t �| j| j�}| jr | �|�S t|�S r )r rG r� r� r� r{ rF �r r� r r r r$ s
z_spanset.fastascc C s2 t �| jd | jd d�}| jr*| �|�S t|�S )Nr ra )r rG r� r� r� r{ rF r� r r r r' s
z_spanset.fastdescc C s0 | j }| j| ko | jk n o.|o,||v S r )r� r� r� )r r Zhiddenr r r r s
�z_spanset.__contains__c C s | D ]} dS dS r~ r r� r r r r s z_spanset.__nonzero__c C s� | j st| j| j �S d}| j}| j}| j D ]:}|| k rD|ks^n || krZ|k r,n q,|d7 }q,t| j| j �| S d S r� )r� �absr� r� )r �countrB r� r r r r r+ " s
.
z_spanset.__len__c C s | j S r r� r r r r r . s z_spanset.isascendingc C s | j S r r� r r r r r 1 s z_spanset.isdescendingc C s* | j r| j}n| j}|� D ]
}| S d S r r� r� r r r r) 4 s
z_spanset.firstc C s* | j r| j}n| j}|� D ]
}| S d S r )rQ r' r$ r� r r r r* = s
z
_spanset.lastc sz | j rtt| ��||�S | jrDt| j| | j�}t| j| | j�}n$t| j| | j�}t| j| | j�}t||| j| j �S r ) r� rc r� rA rQ r% r� r� r( )r rB rC rL rM rf r r rA F s z_spanset._slicec C s( ddd�| j }dt| �|| j| jf S )Nrj rk r� s <%s%s %d:%d>)rQ r r� r� r� r r r rq R s z_spanset.__repr__)F)r rN rO rr rY r. r, r r{ r r$ r' r r rP r+ r r r) r* rA r rt rq ru r r rf r r� � s(
r� c s( e Zd ZdZ� fdd�Zdd� Z� ZS )r3 z�a set containing all revisions in the repo
This class exists to host special optimization and magic to handle virtual
revisions such as "null".
c s" t t| ��dt|�d|jj� d S )Nr T)rc r3 rY r^ r� r� )r r� rf r r rY _ s
�zfullreposet.__init__c C s. t �|d�st|| j �}|j| �� d� |S )z�As 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.
s isascendingr� )r r> rJ r� r. r r5 r r r r7 d s zfullreposet.__and__)r rN rO rr rY r7 ru r r rf r r3 X s r3 )r N)Z
__future__r r r � r r r Zutilsr r �objectr rJ r? r� r8 r� r� r� r� r� r3 r r r r �<module> s& dx% Y )
x