PySequence (jython-slim 2.7.2 API)

java.lang.Object
- org.python.core.PyObject
- - org.python.core.PySequence

All Implemented Interfaces:

java.io.Serializable

Direct Known Subclasses:

AstList, BaseBytes, Py2kBuffer, PyArray, PyBaseString, PyMemoryView, PySequenceList, PyXRange
```
public abstract class PySequence
extends PyObject
```
The abstract superclass of PyObjects that implements a Sequence. Minimize the work in creating such objects. Method names are designed to make it possible for subclasses of PySequence to implement java.util.List. Subclasses must also implement get, getslice, and repeat methods. Subclasses that are mutable should also implement: set, setslice, del, and delRange.

See Also:

Serialized Form

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`protected class`	`PySequence.DefaultIndexDelegate` Class defining the default behaviour of sequences with respect to slice assignment, etc., which is the one correct for `list`.

Nested classes/interfaces inherited from class org.python.core.PyObject
PyObject.ConversionException

Field Summary

Fields
Modifier and Type	Field and Description
`protected SequenceIndexDelegate`	`delegator` A delegate that handles index checking and manipulation for get, set and del operations on this sequence in the form of a "pluggable behaviour".

Fields inherited from class org.python.core.PyObject
attributes, gcMonitorGlobal, objtype, TYPE

Constructor Summary

Constructors
Modifier	Constructor and Description
`protected`	`PySequence(PyType type)` Construct a PySequence for the given sub-type with the default index behaviour.
`protected`	`PySequence(PyType type, SequenceIndexDelegate behaviour)` Construct a PySequence for the given sub-type with custom index behaviour.

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`__delitem__(PyObject index)` Equivalent to the standard Python __delitem__ method.
`void`	`__delslice__(PyObject start, PyObject stop, PyObject step)`
`PyObject`	`__eq__(PyObject o)` Equivalent to the standard Python __eq__ method.
`PyObject`	`__finditem__(int index)` A variant of the __finditem__ method which accepts a primitive `int` as the key.
`PyObject`	`__finditem__(PyObject index)` Very similar to the standard Python __getitem__ method.
`PyObject`	`__ge__(PyObject o)` Equivalent to the standard Python __ge__ method.
`PyObject`	`__getitem__(PyObject index)` Equivalent to the standard Python __getitem__ method.
`PyObject`	`__getslice__(PyObject start, PyObject stop, PyObject step)`
`PyObject`	`__gt__(PyObject o)` Equivalent to the standard Python __gt__ method.
`PyObject`	`__iter__()` Return an iterator that is used to iterate the element of this sequence.
`PyObject`	`__le__(PyObject o)` Equivalent to the standard Python __le__ method.
`PyObject`	`__lt__(PyObject o)` Equivalent to the standard Python __lt__ method.
`PyObject`	`__ne__(PyObject o)` Equivalent to the standard Python __ne__ method.
`boolean`	`__nonzero__()` Equivalent to the standard Python __nonzero__ method.
`void`	`__setitem__(int index, PyObject value)` A variant of the __setitem__ method which accepts a primitive `int` as the key.
`void`	`__setitem__(PyObject index, PyObject value)` Equivalent to the standard Python __setitem__ method.
`void`	`__setslice__(PyObject start, PyObject stop, PyObject step, PyObject value)`
`java.lang.Object`	`__tojava__(java.lang.Class<?> c)` Equivalent to the Jython __tojava__ method.
`protected int`	`boundToSequence(int index)` Adjusts `index` such that it's ≥0 and ≤ __len__.
`protected static int`	`cmp(PyObject o1, int ol1, PyObject o2, int ol2)` Compare the specified object/length pairs.
`protected void`	`del(int index)` Deletes an element from the sequence (and closes up the gap).
`protected void`	`delRange(int start, int stop)` Deletes a contiguous sub-sequence (and closes up the gap).
`protected void`	`delslice(int start, int stop, int step, int n)` Deletes a simple or extended slice and closes up the gap(s).
`protected static PySequence`	`fastSequence(PyObject seq, java.lang.String msg)` Return a copy of a sequence where the __len__() method is telling the truth.
`protected abstract PyObject`	`getslice(int start, int stop, int step)` Returns a range of elements from the sequence.
`boolean`	`isMappingType()`
`boolean`	`isNumberType()`
`boolean`	`isSequenceType()`
`protected boolean`	`isSubType(PyObject other)` isSubType tailored for PySequence binops.
`protected abstract PyObject`	`pyget(int index)` Returns the element of the sequence at the given index.
`protected void`	`pyset(int index, PyObject value)` Sets the indexed element of the sequence to the given value.
`protected abstract PyObject`	`repeat(int count)` Returns a (concrete subclass of) PySequence that repeats the given sequence, as in the implementation of `__mul__` for strings.
`protected java.lang.String`	`runsupportedopMessage(java.lang.String op, PyObject o2)` Return sequence-specific error messages suitable for substitution.
`protected void`	`setslice(int start, int stop, int step, PyObject value)` Sets the given range of elements according to Python slice assignment semantics.
`protected static int`	`sliceLength(int start, int stop, long step)` Make step a long in case adding the start, stop and step together overflows an int.
`protected java.lang.String`	`unsupportedopMessage(java.lang.String op, PyObject o2)` Return sequence-specific error messages suitable for substitution.

Methods inherited from class org.python.core.PyObject
__abs__, __add__, __and__, __call__, __call__, __call__, __call__, __call__, __call__, __call__, __call__, __call__, __call__, __call__, __call__, __call__, __call__, __call__, __call__, __cmp__, __coerce__, __coerce_ex__, __complex__, __contains__, __delattr__, __delattr__, __delete__, __delitem__, __delslice__, __dir__, __div__, __divmod__, __ensure_finalizer__, __findattr__, __findattr__, __findattr_ex__, __finditem__, __float__, __floordiv__, __format__, __get__, __getattr__, __getattr__, __getitem__, __getnewargs__, __getslice__, __hash__, __hex__, __iadd__, __iand__, __idiv__, __idivmod__, __ifloordiv__, __ilshift__, __imod__, __imul__, __index__, __int__, __invert__, __ior__, __ipow__, __irshift__, __isub__, __iternext__, __itruediv__, __ixor__, __len__, __long__, __lshift__, __mod__, __mul__, __neg__, __not__, __oct__, __or__, __pos__, __pow__, __pow__, __radd__, __rand__, __rawdir__, __rdiv__, __rdivmod__, __reduce__, __reduce_ex__, __reduce_ex__, __repr__, __rfloordiv__, __rlshift__, __rmod__, __rmul__, __ror__, __rpow__, __rrshift__, __rshift__, __rsub__, __rtruediv__, __rxor__, __set__, __setattr__, __setattr__, __setitem__, __setslice__, __str__, __sub__, __truediv__, __trunc__, __unicode__, __xor__, _add, _and, _callextra, _cmp, _div, _divmod, _doget, _doget, _doset, _eq, _floordiv, _ge, _gt, _iadd, _iand, _idiv, _idivmod, _ifloordiv, _ilshift, _imod, _imul, _in, _ior, _ipow, _irshift, _is, _isnot, _isub, _itruediv, _ixor, _jcall, _jcallexc, _jthrow, _le, _lshift, _lt, _mod, _mul, _ne, _notin, _or, _pow, _rshift, _sub, _truediv, _unsupportedop, _xor, adaptToCoerceTuple, asDouble, asIndex, asIndex, asInt, asInt, asIterable, asLong, asLong, asName, asName, asString, asString, asStringOrNull, asStringOrNull, bit_length, conjugate, delDict, delType, dispatch__init__, equals, fastGetClass, fastGetDict, finalize, getDict, getJavaProxy, getType, hashCode, impAttr, implementsDescrDelete, implementsDescrGet, implementsDescrSet, invoke, invoke, invoke, invoke, invoke, invoke, isCallable, isDataDescr, isIndex, isInteger, mergeClassDict, mergeDictAttr, mergeListAttr, noAttributeError, object___subclasshook__, readonlyAttributeError, setDict, setType, toString

Methods inherited from class java.lang.Object
clone, getClass, notify, notifyAll, wait, wait, wait

- Field Detail
  - delegator
```
protected SequenceIndexDelegate delegator
```
    A delegate that handles index checking and manipulation for get, set and del operations on this sequence in the form of a "pluggable behaviour". Because different types of sequence exhibit subtly different behaviour, there is scope for subclasses to customise the behaviour with their own extension of SequenceIndexDelegate.
- Constructor Detail
  - PySequence
```
protected PySequence(PyType type)
```
    Construct a PySequence for the given sub-type with the default index behaviour.
    
    Parameters:
    
    type - actual (Python) type of sub-class
  - PySequence
```
protected PySequence(PyType type,
                     SequenceIndexDelegate behaviour)
```
    Construct a PySequence for the given sub-type with custom index behaviour. In practice, restrictions on the construction of inner classes will mean null has to be passed and the actual delegator assigned later.
    
    Parameters:
    
    type - actual (Python) type of sub-class
    
    behaviour - specific index behaviour (or null)
- Method Detail
  - pyget
```
protected abstract PyObject pyget(int index)
```
    Returns the element of the sequence at the given index. This is an extension point called by PySequence in its implementation of __getitem__(org.python.core.PyObject) It is guaranteed by PySequence that when it calls pyget(int) the index is within the bounds of the array. Any other clients must make the same guarantee.
    
    Parameters:
    
    index - index of element to return.
    
    Returns:
    
    the element at the given position in the list.
  - getslice
```
protected abstract PyObject getslice(int start,
                                     int stop,
                                     int step)
```
    Returns a range of elements from the sequence.
    
    Parameters:
    
    start - the position of the first element.
    
    stop - one more than the position of the last element.
    
    step - the step size.
    
    Returns:
    
    a sequence corresponding the the given range of elements.
  - repeat
```
protected abstract PyObject repeat(int count)
```
    Returns a (concrete subclass of) PySequence that repeats the given sequence, as in the implementation of __mul__ for strings.
    
    Parameters:
    
    count - the number of times to repeat the sequence.
    
    Returns:
    
    this sequence repeated count times.
  - pyset
```
protected void pyset(int index,
                     PyObject value)
```
    Sets the indexed element of the sequence to the given value. This is an extension point called by PySequence in its implementation of __setitem__(int, org.python.core.PyObject) It is guaranteed by PySequence that when it calls pyset(int) the index is within the bounds of the array. Any other clients must make the same guarantee.
    
    Parameters:
    
    index - index of the element to set.
    
    value - the value to set this element to.
  - setslice
```
protected void setslice(int start,
                        int stop,
                        int step,
                        PyObject value)
```
    Sets the given range of elements according to Python slice assignment semantics. If the step size is one, it is a simple slice and the operation is equivalent to deleting that slice, then inserting the value at that position, regarding the value as a sequence (if possible) or as a single element if it is not a sequence. If the step size is not one, but start==stop, it is equivalent to insertion at that point. If the step size is not one, and start!=stop, the slice defines a certain number of elements to be replaced, and the value must be a sequence of exactly that many elements (or convertible to such a sequence).
    
    Parameters:
    
    start - the position of the first element.
    
    stop - one more than the position of the last element.
    
    step - the step size.
    
    value - an object consistent with the slice assignment
  - del
```
protected void del(int index)
```
    Deletes an element from the sequence (and closes up the gap).
    
    Parameters:
    
    index - index of the element to delete.
  - delRange
```
protected void delRange(int start,
                        int stop)
```
    Deletes a contiguous sub-sequence (and closes up the gap).
    
    Parameters:
    
    start - the position of the first element.
    
    stop - one more than the position of the last element.
  - delslice
```
protected void delslice(int start,
                        int stop,
                        int step,
                        int n)
```
    Deletes a simple or extended slice and closes up the gap(s). The slice parameters [start:stop:step] mean what they would in Python, after application of the "end-relative" rules for negative numbers and None. The count n is as supplied by PySlice.indicesEx(int). This method is unsafe in that slice parameters are assumed correct.
    
    Parameters:
    
    start - the position of the first element.
    
    stop - beyond the position of the last element (not necessarily just beyond).
    
    step - from one element to the next (positive or negative)
    
    n - number of elements to delete
  - __nonzero__
```
public boolean __nonzero__()
```
    Description copied from class: PyObject
    
    Equivalent to the standard Python __nonzero__ method. Returns whether of not a given PyObject is considered true.
    
    Overrides:
    
    __nonzero__ in class PyObject
  - __iter__
```
public PyObject __iter__()
```
    Description copied from class: PyObject
    Return an iterator that is used to iterate the element of this sequence. From version 2.2, this method is the primary protocol for looping over sequences.
    If a PyObject subclass should support iteration based in the __finditem__() method, it must supply an implementation of __iter__() like this:
```
 public PyObject __iter__() {
     return new PySequenceIter(this);
 }
 
```
    When iterating over a python sequence from java code, it should be done with code like this:
```
 for (PyObject item : seq.asIterable()) {
     // Do something with item
 }
 
```
    Overrides:
    
    __iter__ in class PyObject
  - __eq__
```
public PyObject __eq__(PyObject o)
```
    Description copied from class: PyObject
    
    Equivalent to the standard Python __eq__ method.
    
    Overrides:
    
    __eq__ in class PyObject
    
    Parameters:
    
    o - the object to compare this with.
    
    Returns:
    
    the result of the comparison.
  - __ne__
```
public PyObject __ne__(PyObject o)
```
    Description copied from class: PyObject
    
    Equivalent to the standard Python __ne__ method.
    
    Overrides:
    
    __ne__ in class PyObject
    
    Parameters:
    
    o - the object to compare this with.
    
    Returns:
    
    the result of the comparison.
  - __lt__
```
public PyObject __lt__(PyObject o)
```
    Description copied from class: PyObject
    
    Equivalent to the standard Python __lt__ method.
    
    Overrides:
    
    __lt__ in class PyObject
    
    Parameters:
    
    o - the object to compare this with.
    
    Returns:
    
    the result of the comparison.
  - __le__
```
public PyObject __le__(PyObject o)
```
    Description copied from class: PyObject
    
    Equivalent to the standard Python __le__ method.
    
    Overrides:
    
    __le__ in class PyObject
    
    Parameters:
    
    o - the object to compare this with.
    
    Returns:
    
    the result of the comparison.
  - __gt__
```
public PyObject __gt__(PyObject o)
```
    Description copied from class: PyObject
    
    Equivalent to the standard Python __gt__ method.
    
    Overrides:
    
    __gt__ in class PyObject
    
    Parameters:
    
    o - the object to compare this with.
    
    Returns:
    
    the result of the comparison.
  - __ge__
```
public PyObject __ge__(PyObject o)
```
    Description copied from class: PyObject
    
    Equivalent to the standard Python __ge__ method.
    
    Overrides:
    
    __ge__ in class PyObject
    
    Parameters:
    
    o - the object to compare this with.
    
    Returns:
    
    the result of the comparison.
  - isSubType
```
protected boolean isSubType(PyObject other)
```
    isSubType tailored for PySequence binops.
    
    Parameters:
    
    other - PyObject
    
    Returns:
    
    true if subclass of other
  - cmp
```
protected static int cmp(PyObject o1,
                         int ol1,
                         PyObject o2,
                         int ol2)
```
    Compare the specified object/length pairs.
    
    Returns:
    
    value ≥ 0 is the index where the sequences differs. -1: reached the end of o1 without a difference -2: reached the end of both sequences without a difference -3: reached the end of o2 without a difference
  - fastSequence
```
protected static PySequence fastSequence(PyObject seq,
                                         java.lang.String msg)
```
    Return a copy of a sequence where the __len__() method is telling the truth.
  - sliceLength
```
protected static final int sliceLength(int start,
                                       int stop,
                                       long step)
```
    Make step a long in case adding the start, stop and step together overflows an int.
  - boundToSequence
```
protected int boundToSequence(int index)
```
    Adjusts index such that it's ≥0 and ≤ __len__. If index starts off negative, it's treated as an index from the end of the sequence going back to the start.
  - __finditem__
```
public PyObject __finditem__(int index)
```
    Description copied from class: PyObject
    
    A variant of the __finditem__ method which accepts a primitive int as the key. By default, this method will call __finditem__(PyObject key) with the appropriate args. The only reason to override this method is for performance.
    
    Overrides:
    
    __finditem__ in class PyObject
    
    Parameters:
    
    index - the key to lookup in this sequence.
    
    Returns:
    
    the value corresponding to key or null if key is not found.
    
    See Also:
    
    PyObject.__finditem__(PyObject)
  - __finditem__
```
public PyObject __finditem__(PyObject index)
```
    Description copied from class: PyObject
    
    Very similar to the standard Python __getitem__ method. Instead of throwing a KeyError if the item isn't found, this just returns null. Classes that wish to implement __getitem__ should override this method instead (with the appropriate semantics.
    
    Overrides:
    
    __finditem__ in class PyObject
    
    Parameters:
    
    index - the key to lookup in this container
    
    Returns:
    
    the value corresponding to key or null if key is not found
  - __getitem__
```
public PyObject __getitem__(PyObject index)
```
    Description copied from class: PyObject
    
    Equivalent to the standard Python __getitem__ method. This method should not be overridden. Override the __finditem__ method instead.
    
    Overrides:
    
    __getitem__ in class PyObject
    
    Parameters:
    
    index - the key to lookup in this container.
    
    Returns:
    
    the value corresponding to that key.
    
    See Also:
    
    PyObject.__finditem__(PyObject)
  - isMappingType
```
public boolean isMappingType()
                      throws PyIgnoreMethodTag
```
    Overrides:
    
    isMappingType in class PyObject
    
    Throws:
    
    PyIgnoreMethodTag
  - isNumberType
```
public boolean isNumberType()
                     throws PyIgnoreMethodTag
```
    Overrides:
    
    isNumberType in class PyObject
    
    Throws:
    
    PyIgnoreMethodTag
  - __getslice__
```
public PyObject __getslice__(PyObject start,
                             PyObject stop,
                             PyObject step)
```
    Overrides:
    
    __getslice__ in class PyObject
  - __setslice__
```
public void __setslice__(PyObject start,
                         PyObject stop,
                         PyObject step,
                         PyObject value)
```
    Overrides:
    
    __setslice__ in class PyObject
  - __delslice__
```
public void __delslice__(PyObject start,
                         PyObject stop,
                         PyObject step)
```
    Overrides:
    
    __delslice__ in class PyObject
  - __setitem__
```
public void __setitem__(int index,
                        PyObject value)
```
    Description copied from class: PyObject
    
    A variant of the __setitem__ method which accepts a primitive int as the key. By default, this will call __setitem__(PyObject key, PyObject value) with the appropriate args. The only reason to override this method is for performance.
    
    Overrides:
    
    __setitem__ in class PyObject
    
    Parameters:
    
    index - the key whose value will be set
    
    value - the value to set this key to
    
    See Also:
    
    PyObject.__setitem__(PyObject, PyObject)
  - __setitem__
```
public void __setitem__(PyObject index,
                        PyObject value)
```
    Description copied from class: PyObject
    
    Equivalent to the standard Python __setitem__ method.
    
    Overrides:
    
    __setitem__ in class PyObject
    
    Parameters:
    
    index - the key whose value will be set
    
    value - the value to set this key to
  - __delitem__
```
public void __delitem__(PyObject index)
```
    Description copied from class: PyObject
    
    Equivalent to the standard Python __delitem__ method.
    
    Overrides:
    
    __delitem__ in class PyObject
    
    Parameters:
    
    index - the key to be removed from the container
  - __tojava__
```
public java.lang.Object __tojava__(java.lang.Class<?> c)
                            throws PyIgnoreMethodTag
```
    Description copied from class: PyObject
    
    Equivalent to the Jython __tojava__ method. Tries to coerce this object to an instance of the requested Java class. Returns the special object Py.NoConversion if this PyObject can not be converted to the desired Java class.
    
    Overrides:
    
    __tojava__ in class PyObject
    
    Parameters:
    
    c - the Class to convert this PyObject to.
    
    Throws:
    
    PyIgnoreMethodTag
  - unsupportedopMessage
```
protected java.lang.String unsupportedopMessage(java.lang.String op,
                                                PyObject o2)
```
    Return sequence-specific error messages suitable for substitution. {0} is the op name. {1} is the left operand type. {2} is the right operand type.
    
    Overrides:
    
    unsupportedopMessage in class PyObject
  - runsupportedopMessage
```
protected java.lang.String runsupportedopMessage(java.lang.String op,
                                                 PyObject o2)
```
    Return sequence-specific error messages suitable for substitution. {0} is the op name. {1} is the left operand type. {2} is the right operand type.
    
    Overrides:
    
    runsupportedopMessage in class PyObject
  - isSequenceType
```
public boolean isSequenceType()
```
    Overrides:
    
    isSequenceType in class PyObject

Class PySequence

Nested Class Summary

Nested classes/interfaces inherited from class org.python.core.PyObject

Field Summary

Fields inherited from class org.python.core.PyObject

Constructor Summary

Method Summary

Methods inherited from class org.python.core.PyObject

Methods inherited from class java.lang.Object

Field Detail

delegator

Constructor Detail

PySequence

PySequence

Method Detail

pyget

getslice

repeat

pyset

setslice

del

delRange

delslice

__nonzero__

__iter__

__eq__

__ne__

__lt__

__le__

__gt__

__ge__

isSubType

cmp

fastSequence

sliceLength

boundToSequence

__finditem__

__finditem__

__getitem__

isMappingType

isNumberType

__getslice__

__setslice__

__delslice__

__setitem__

__setitem__

__delitem__

__tojava__

unsupportedopMessage

runsupportedopMessage

isSequenceType

nonzero

iter

eq

ne

lt

le

gt

ge

finditem

finditem

getitem

getslice

setslice

delslice

setitem

setitem

delitem

tojava