U
    ©€lj›  ã                   @   s    d Z dZddlmZ ddlmZ G dd„ dejƒZG dd„ dejeƒZ	G d	d
„ d
ej
e	ƒZG dd„ deƒZG dd„ deƒZG dd„ deƒZG dd„ deeƒZdS )a�  
Sequence Interfaces

Importing this module does *not* mark any standard classes as
implementing any of these interfaces.

While this module is not deprecated, new code should generally use
:mod:`zope.interface.common.collections`, specifically
:class:`~zope.interface.common.collections.ISequence` and
:class:`~zope.interface.common.collections.IMutableSequence`. This
module is occasionally useful for its fine-grained breakdown of interfaces.

The standard library :class:`list`, :class:`tuple` and
:class:`collections.UserList`, among others, implement ``ISequence``
or ``IMutableSequence`` but *do not* implement any of the interfaces
in this module.
Zrestructuredtexté    )Ú	Interface)Úcollectionsc                   @   s   e Zd ZdZdd„ ZdS )ÚIMinimalSequencea×  Most basic sequence interface.

    All sequences are iterable.  This requires at least one of the
    following:

    - a `__getitem__()` method that takes a single argument; integer
      values starting at 0 must be supported, and `IndexError` should
      be raised for the first index for which there is no value, or

    - an `__iter__()` method that returns an iterator as defined in
      the Python documentation (http://docs.python.org/lib/typeiter.html).

    c                 C   s   dS )z�``x.__getitem__(index) <==> x[index]``

        Declaring this interface does not specify whether `__getitem__`
        supports slice objects.N© ©Úindexr   r   úB/tmp/pip-unpacked-wheel-8v5_7jmu/zope/interface/common/sequence.pyÚ__getitem__4   s    zIMinimalSequence.__getitem__N)Ú__name__Ú
__module__Ú__qualname__Ú__doc__r	   r   r   r   r   r   %   s   r   c                   @   s   e Zd ZdZdS )ÚIFiniteSequencez[
    A sequence of bound size.

    .. versionchanged:: 5.0.0
       Extend ``ISized``
    N©r
   r   r   r   r   r   r   r   r   ;   s   r   c                   @   s`   e Zd ZdZdd„ Zdd„ Zdd„ Zdd	„ Zd
d„ Zdd„ Z	dd„ Z
dd„ Zdd„ Zdd„ ZdS )ÚIReadSequencea.  
    read interface shared by tuple and list

    This interface is similar to
    :class:`~zope.interface.common.collections.ISequence`, but
    requires that all instances be totally ordered. Most users
    should prefer ``ISequence``.

    .. versionchanged:: 5.0.0
       Extend ``IContainer``
    c                 C   s   dS )z'``x.__contains__(item) <==> item in x``Nr   ©Úitemr   r   r   Ú__contains__Q   s    zIReadSequence.__contains__c                 C   s   dS )z"``x.__lt__(other) <==> x < other``Nr   ©Úotherr   r   r   Ú__lt__U   s    zIReadSequence.__lt__c                 C   s   dS )z#``x.__le__(other) <==> x <= other``Nr   r   r   r   r   Ú__le__X   s    zIReadSequence.__le__c                 C   s   dS )z#``x.__eq__(other) <==> x == other``Nr   r   r   r   r   Ú__eq__[   s    zIReadSequence.__eq__c                 C   s   dS )z#``x.__ne__(other) <==> x != other``Nr   r   r   r   r   Ú__ne__^   s    zIReadSequence.__ne__c                 C   s   dS )z"``x.__gt__(other) <==> x > other``Nr   r   r   r   r   Ú__gt__a   s    zIReadSequence.__gt__c                 C   s   dS )z#``x.__ge__(other) <==> x >= other``Nr   r   r   r   r   Ú__ge__d   s    zIReadSequence.__ge__c                 C   s   dS )z#``x.__add__(other) <==> x + other``Nr   r   r   r   r   Ú__add__g   s    zIReadSequence.__add__c                 C   s   dS )z``x.__mul__(n) <==> x * n``Nr   ©Únr   r   r   Ú__mul__j   s    zIReadSequence.__mul__c                 C   s   dS )z``x.__rmul__(n) <==> n * x``Nr   r   r   r   r   Ú__rmul__m   s    zIReadSequence.__rmul__N)r
   r   r   r   r   r   r   r   r   r   r   r   r   r    r   r   r   r   r   D   s   r   c                   @   s    e Zd ZdZdd„ Zdd„ ZdS )ÚIExtendedReadSequencezFull read interface for listsc                 C   s   dS )z%Return number of occurrences of valueNr   r   r   r   r   Úcountt   s    zIExtendedReadSequence.countc                 G   s   dS )zTindex(value, [start, [stop]]) -> int

        Return first index of *value*
        Nr   )r   Úargsr   r   r   r   w   s    zIExtendedReadSequence.indexN)r
   r   r   r   r"   r   r   r   r   r   r!   q   s   r!   c                   @   sd   e Zd ZdZdd„ Zdd„ Zdd„ Zdd	„ Zd
d„ Zddd„Z	dd„ Z
dd„ Zddd„Zdd„ ZdS )ÚIUniqueMemberWriteSequencezAThe write contract for a sequence that may enforce unique membersc                 C   s   dS )z¥``x.__setitem__(index, item) <==> x[index] = item``

        Declaring this interface does not specify whether `__setitem__`
        supports slice objects.
        Nr   ©r   r   r   r   r   Ú__setitem__�   s    z&IUniqueMemberWriteSequence.__setitem__c                 C   s   dS )zœ``x.__delitem__(index) <==> del x[index]``

        Declaring this interface does not specify whether `__delitem__`
        supports slice objects.
        Nr   r   r   r   r   Ú__delitem__ˆ   s    z&IUniqueMemberWriteSequence.__delitem__c                 C   s   dS )z``x.__iadd__(y) <==> x += y``Nr   )Úyr   r   r   Ú__iadd__�   s    z#IUniqueMemberWriteSequence.__iadd__c                 C   s   dS )zAppend item to endNr   r   r   r   r   Úappend’   s    z!IUniqueMemberWriteSequence.appendc                 C   s   dS )zInsert item before indexNr   r%   r   r   r   Úinsert•   s    z!IUniqueMemberWriteSequence.insertéÿÿÿÿc                 C   s   dS )z.Remove and return item at index (default last)Nr   r   r   r   r   Úpop˜   s    zIUniqueMemberWriteSequence.popc                 C   s   dS )z Remove first occurrence of valueNr   r   r   r   r   Úremove›   s    z!IUniqueMemberWriteSequence.removec                   C   s   dS )zReverse *IN PLACE*Nr   r   r   r   r   Úreversež   s    z"IUniqueMemberWriteSequence.reverseNc                 C   s   dS )z3Stable sort *IN PLACE*; `cmpfunc(x, y)` -> -1, 0, 1Nr   )Zcmpfuncr   r   r   Úsort¡   s    zIUniqueMemberWriteSequence.sortc                 C   s   dS )z3Extend list by appending elements from the iterableNr   )Úiterabler   r   r   Úextend¤   s    z!IUniqueMemberWriteSequence.extend)r,   )N)r
   r   r   r   r&   r'   r)   r*   r+   r-   r.   r/   r0   r2   r   r   r   r   r$   ~   s   

r$   c                   @   s   e Zd ZdZdd„ ZdS )ÚIWriteSequencez!Full write contract for sequencesc                 C   s   dS )z``x.__imul__(n) <==> x *= n``Nr   r   r   r   r   Ú__imul__«   s    zIWriteSequence.__imul__N)r
   r   r   r   r4   r   r   r   r   r3   ¨   s   r3   c                   @   s   e Zd ZdZdS )Ú	ISequencea²  
    Full sequence contract.

    New code should prefer
    :class:`~zope.interface.common.collections.IMutableSequence`.

    Compared to that interface, which is implemented by :class:`list`
    (:class:`~zope.interface.common.builtins.IList`), among others,
    this interface is missing the following methods:

        - clear

        - count

        - index

    This interface adds the following methods:

        - sort
    Nr   r   r   r   r   r5   ¯   s   r5   N)r   Z__docformat__Zzope.interfacer   Zzope.interface.commonr   Z	IIterabler   ZISizedr   Z
IContainerr   r!   r$   r3   r5   r   r   r   r   Ú<module>   s   	-*