src.org.python.modules._collections.PyDeque Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of jython-standalone Show documentation
Show all versions of jython-standalone Show documentation
Jython is an implementation of the high-level, dynamic, object-oriented
language Python written in 100% Pure Java, and seamlessly integrated with
the Java platform. It thus allows you to run Python on any Java platform.
package org.python.modules._collections;
import org.python.core.ArgParser;
import org.python.core.PyIterator;
import org.python.core.PyList;
import org.python.core.PyObject;
import org.python.core.PyTuple;
import org.python.core.PyType;
import org.python.core.Py;
import org.python.core.PyException;
import org.python.core.ThreadState;
import org.python.core.Traverseproc;
import org.python.core.Visitproc;
import org.python.expose.ExposedGet;
import org.python.expose.ExposedMethod;
import org.python.expose.ExposedNew;
import org.python.expose.ExposedSet;
import org.python.expose.ExposedType;
import org.python.expose.MethodType;
/**
* PyDeque - This class implements the functionalities of Deque data structure. Deques are a
* generalization of stacks and queues (the name is pronounced 'deck' and is short for 'double-ended
* queue'). Deques support thread-safe, memory efficient appends and pops from either side of the
* deque with approximately the same O(1) performance in either direction.
*
* Though list objects support similar operations, they are optimized for fast fixed-length
* operations and incur O(n) memory movement costs for pop(0) and insert(0, v) operations which
* change both the size and position of the underlying data representation.
*
* collections.deque([iterable[, maxlen]]) - returns a new deque object initialized left-to-right
* (using append()) with data from iterable. If iterable is not specified, the new deque is empty.
* If maxlen is not specified or is None, deques may grow to an arbitrary length. Otherwise, the
* deque is bounded to the specified maximum length. Once a bounded length deque is full, when new
* items are added, a corresponding number of items are discarded from the opposite end.
*/
@ExposedType(name = "collections.deque")
public class PyDeque extends PyObject implements Traverseproc {
public static final PyType TYPE = PyType.fromClass(PyDeque.class);
private long state = 0;
private int size = 0;
private int maxlen = -1;
private Node header = new Node(null, null, null);
public PyDeque() {
this(TYPE);
}
public PyDeque(PyType subType) {
super(subType);
header.left = header.right = header;
}
@ExposedNew
@ExposedMethod
public synchronized final void deque___init__(PyObject[] args, String[] kwds) {
ArgParser ap = new ArgParser("deque", args, kwds, new String[] {"iterable", "maxlen",}, 0);
PyObject maxlenobj = ap.getPyObject(1, null);
if (maxlenobj != null) {
if (maxlenobj == Py.None) {
maxlen = -1;
} else {
maxlen = ap.getInt(1);
if (maxlen < 0) {
throw Py.ValueError("maxlen must be non-negative");
}
}
} else {
maxlen = -1;
}
PyObject iterable = ap.getPyObject(0, null);
if (iterable != null) {
if (size != 0) {
// initializing a deque with an iterator when this deque is not empty means that we discard to empty first
deque_clear();
}
deque_extend(iterable);
}
}
/**
* If maxlen is not specified or is None, deques may grow to an arbitrary length.
* Otherwise, the deque is bounded to the specified maximum length.
*/
@ExposedGet(name = "maxlen")
public PyObject getMaxlen() {
if (maxlen < 0) {
return Py.None;
}
return Py.newInteger(maxlen);
}
@ExposedSet(name = "maxlen")
public void setMaxlen(PyObject o) {
// this has to be here because by default, if not defined,
// the Jython object model raise a TypeError, where we usually expect
// AttributeError here; due to a CPython 2.7 idiosyncracy that has
// since been fixed for 3.x in http://bugs.python.org/issue1687163
throw Py.AttributeError("attribute 'maxlen' of 'collections.deque' objects is not writable");
}
/**
* Add obj to the right side of the deque.
*/
@ExposedMethod
public synchronized final void deque_append(PyObject obj) {
if (maxlen >= 0) {
assert (size <= maxlen);
if (maxlen == 0) {
// do nothing; this deque will always be empty
return;
} else if (size == maxlen) {
deque_popleft();
}
}
addBefore(obj, header);
}
/**
* Add obj to the left side of the deque.
*/
@ExposedMethod
public synchronized final void deque_appendleft(PyObject obj) {
if (maxlen >= 0) {
assert (size <= maxlen);
if (maxlen == 0) {
// do nothing; this deque will always be empty
return;
} else if (size == maxlen) {
deque_pop();
}
}
addBefore(obj, header.right);
}
private Node addBefore(PyObject obj, Node node) {
// should ALWAYS be called inside a synchronized block
Node newNode = new Node(obj, node, node.left);
newNode.left.right = newNode;
newNode.right.left = newNode;
size++;
state++;
return newNode;
}
/**
* Remove all elements from the deque leaving it with length 0.
*/
@ExposedMethod
public synchronized final void deque_clear() {
Node node = header.right;
while (node != header) {
Node right = node.right;
node.left = null;
node.right = null;
node.data = null;
node = right;
state++;
}
header.right = header.left = header;
size = 0;
}
/**
* Extend the right side of the deque by appending elements from the
* iterable argument.
*/
@ExposedMethod
public synchronized final void deque_extend(PyObject iterable) {
// handle case where iterable == this
if (this == iterable) {
deque_extend(new PyList(iterable));
} else {
for (PyObject item : iterable.asIterable()) {
deque_append(item);
}
}
}
/**
* Extend the left side of the deque by appending elements from iterable.
* Note, the series of left appends results in reversing the order of
* elements in the iterable argument.
*/
@ExposedMethod
public synchronized final void deque_extendleft(PyObject iterable) {
// handle case where iterable == this
if (this == iterable) {
deque_extendleft(new PyList(iterable));
} else {
for (PyObject item : iterable.asIterable()) {
deque_appendleft(item);
}
}
}
/**
* Remove and return an element from the right side of the deque. If no
* elements are present, raises an IndexError.
*/
@ExposedMethod
public synchronized final PyObject deque_pop() {
return removeNode(header.left);
}
/**
* Remove and return an element from the left side of the deque. If no
* elements are present, raises an IndexError.
*/
@ExposedMethod
public synchronized final PyObject deque_popleft() {
return removeNode(header.right);
}
private PyObject removeNode(Node node) {
// should ALWAYS be called inside a synchronized block
if (node == header) {
throw Py.IndexError("pop from an empty deque");
}
PyObject obj = node.data;
node.left.right = node.right;
node.right.left = node.left;
node.right = null;
node.left = null;
node.data = null;
size--;
state++;
return obj;
}
/**
* Removed the first occurrence of value. If not found, raises a
* ValueError.
*/
@ExposedMethod
public synchronized final PyObject deque_remove(PyObject value) {
int n = size;
Node tmp = header.right;
boolean match = false;
long startState = state;
for (int i = 0; i < n; i++) {
if (tmp.data.equals(value)) {
match = true;
}
if (startState != state) {
throw Py.IndexError("deque mutated during remove().");
}
if (match) {
return removeNode(tmp);
}
tmp = tmp.right;
}
throw Py.ValueError("deque.remove(x): x not in deque");
}
/**
* Count the number of deque elements equal to x.
*/
@ExposedMethod
public synchronized final PyObject deque_count(PyObject x) {
int n = size;
int count = 0;
Node tmp = header.right;
long startState = state;
for (int i = 0; i < n; i++) {
if (tmp.data.equals(x)) {
count++;
}
if (startState != state) {
throw Py.RuntimeError("deque mutated during count().");
}
tmp = tmp.right;
}
return Py.newInteger(count);
}
/**
* Rotate the deque n steps to the right. If n is negative, rotate to the
* left. Rotating one step to the right is equivalent to: d.appendleft(d.pop()).
*/
@ExposedMethod(defaults = {"1"})
public synchronized final void deque_rotate(int steps) {
if (size == 0) {
return;
}
int halfsize = (size + 1) >> 1;
if (steps > halfsize || steps < -halfsize) {
steps %= size;
if (steps > halfsize) {
steps -= size;
} else if (steps < -halfsize) {
steps += size;
}
}
//rotate right
for (int i = 0; i < steps; i++) {
deque_appendleft(deque_pop());
}
//rotate left
for (int i = 0; i > steps; i--) {
deque_append(deque_popleft());
}
}
/**
* Reverse the elements of the deque in-place and then return None.
* @return Py.None
*/
@ExposedMethod
public synchronized final PyObject deque_reverse() {
Node headerRight = header.right;
Node headerLeft = header.left;
Node node = header.right;
while (node != header) {
Node right = node.right;
Node left = node.left;
node.right = left;
node.left = right;
node = right;
}
header.right = headerLeft;
header.left = headerRight;
state++;
return Py.None;
}
@Override
public String toString() {
return deque_toString();
}
@ExposedMethod(names = "__repr__")
synchronized final String deque_toString() {
ThreadState ts = Py.getThreadState();
if (!ts.enterRepr(this)) {
return "[...]";
}
long startState = state;
StringBuilder buf = new StringBuilder("deque").append("([");
for (Node tmp = header.right; tmp != header; tmp = tmp.right) {
buf.append(tmp.data.__repr__().toString());
if (startState != state) {
throw Py.RuntimeError("deque mutated during iteration.");
}
if (tmp.right != header) {
buf.append(", ");
}
}
buf.append("]");
if (maxlen >= 0) {
buf.append(", maxlen=");
buf.append(maxlen);
}
buf.append(")");
ts.exitRepr(this);
return buf.toString();
}
@Override
public int __len__() {
return deque___len__();
}
@ExposedMethod
synchronized final int deque___len__() {
return size;
}
@Override
public boolean __nonzero__() {
return deque___nonzero__();
}
@ExposedMethod
synchronized final boolean deque___nonzero__() {
return size != 0;
}
@Override
public PyObject __finditem__(PyObject key) {
try {
return deque___getitem__(key);
} catch (PyException pe) {
if (pe.match(Py.KeyError)) {
return null;
}
throw pe;
}
}
@ExposedMethod
synchronized final PyObject deque___getitem__(PyObject index) {
return getNode(index).data;
}
@Override
public void __setitem__(PyObject index, PyObject value) {
deque___setitem__(index, value);
}
@ExposedMethod
synchronized final void deque___setitem__(PyObject index, PyObject value) {
Node node = getNode(index).right;
removeNode(node.left);
addBefore(value, node);
}
@Override
public void __delitem__(PyObject key) {
deque___delitem__(key);
}
@ExposedMethod
synchronized final void deque___delitem__(PyObject key) {
removeNode(getNode(key));
}
private Node getNode(PyObject index) {
// must ALWAYS be called inside a synchronized block
int pos = 0;
if (!index.isIndex()) {
throw Py.TypeError(String.format("sequence index must be integer, not '%.200s'",
index.getType().fastGetName()));
}
pos = index.asIndex(Py.IndexError);
if (pos < 0) {
pos += size;
}
if (pos < 0 || pos >= size) {
throw Py.IndexError("index out of range: " + index);
}
Node tmp = header;
if (pos < (size >> 1)) {
for (int i = 0; i <= pos; i++) {
tmp = tmp.right;
}
} else {
for (int i = size - 1; i >= pos; i--) {
tmp = tmp.left;
}
}
return tmp;
}
@Override
public PyObject __iter__() {
return deque___iter__();
}
@ExposedMethod
final PyObject deque___iter__() {
return new PyDequeIter();
}
@Override
public synchronized PyObject __eq__(PyObject o) {
return deque___eq__(o);
}
@ExposedMethod(type = MethodType.BINARY)
final synchronized PyObject deque___eq__(PyObject o) {
if (!(getType() == o.getType()) && !(getType().isSubType(o.getType()))) {
return null;
}
int tl = __len__();
int ol = o.__len__();
if (tl != ol) {
return Py.False;
}
int i = cmp(this, tl, o, ol);
return (i < 0) ? Py.True : Py.False;
}
@Override
public synchronized PyObject __ne__(PyObject o) {
return deque___ne__(o);
}
@ExposedMethod(type = MethodType.BINARY)
final synchronized PyObject deque___ne__(PyObject o) {
if (!(getType() == o.getType()) && !(getType().isSubType(o.getType()))) {
return null;
}
int tl = __len__();
int ol = o.__len__();
if (tl != ol) {
return Py.True;
}
int i = cmp(this, tl, o, ol);
return (i < 0) ? Py.False : Py.True;
}
@Override
public synchronized PyObject __lt__(PyObject o) {
return deque___lt__(o);
}
@ExposedMethod(type = MethodType.BINARY)
final synchronized PyObject deque___lt__(PyObject o) {
if (!(getType() == o.getType()) && !(getType().isSubType(o.getType()))) {
return null;
}
int i = cmp(this, -1, o, -1);
if (i < 0) {
return (i == -1) ? Py.True : Py.False;
}
return __finditem__(i)._lt(o.__finditem__(i));
}
@Override
public synchronized PyObject __le__(PyObject o) {
return deque___le__(o);
}
@ExposedMethod(type = MethodType.BINARY)
final synchronized PyObject deque___le__(PyObject o) {
if (!(getType() == o.getType()) && !(getType().isSubType(o.getType()))) {
return null;
}
int i = cmp(this, -1, o, -1);
if (i < 0) {
return (i == -1 || i == -2) ? Py.True : Py.False;
}
return __finditem__(i)._le(o.__finditem__(i));
}
@Override
public synchronized PyObject __gt__(PyObject o) {
return deque___gt__(o);
}
@ExposedMethod(type = MethodType.BINARY)
final synchronized PyObject deque___gt__(PyObject o) {
if (!(getType() == o.getType()) && !(getType().isSubType(o.getType()))) {
return null;
}
int i = cmp(this, -1, o, -1);
if (i < 0) {
return (i == -3) ? Py.True : Py.False;
}
return __finditem__(i)._gt(o.__finditem__(i));
}
@Override
public synchronized PyObject __ge__(PyObject o) {
return deque___ge__(o);
}
@ExposedMethod(type = MethodType.BINARY)
final synchronized PyObject deque___ge__(PyObject o) {
if (!(getType() == o.getType()) && !(getType().isSubType(o.getType()))) {
return null;
}
int i = cmp(this, -1, o, -1);
if (i < 0) {
return (i == -3 || i == -2) ? Py.True : Py.False;
}
return __finditem__(i)._ge(o.__finditem__(i));
}
@Override
public synchronized PyObject __iadd__(PyObject o) {
return deque___iadd__(o);
}
@ExposedMethod(type = MethodType.BINARY)
final synchronized PyObject deque___iadd__(PyObject o) {
deque_extend(o);
return this;
}
// Return value >= 0 is the index where the sequences differs.
// -1: reached the end of o1 without a difference
// -2: reached the end of both seqeunces without a difference
// -3: reached the end of o2 without a difference
protected static int cmp(PyObject o1, int ol1, PyObject o2, int ol2) {
if (ol1 < 0) {
ol1 = o1.__len__();
}
if (ol2 < 0) {
ol2 = o2.__len__();
}
for (int i = 0 ; i < ol1 && i < ol2; i++) {
if (!o1.__getitem__(i).equals(o2.__getitem__(i))) {
return i;
}
}
if (ol1 == ol2) {
return -2;
}
return (ol1 < ol2) ? -1 : -3;
}
@Override
public int hashCode() {
return deque_hashCode();
}
@ExposedMethod(names = "__hash__")
final int deque_hashCode() {
throw Py.TypeError("deque objects are unhashable");
}
@Override
public PyObject __reduce__() {
return deque___reduce__();
}
@ExposedMethod
final PyObject deque___reduce__() {
PyObject dict = getDict();
if (dict == null) {
dict = Py.None;
}
return new PyTuple(getType(), Py.EmptyTuple, dict, __iter__());
}
@ExposedMethod
final PyObject deque___copy__() {
PyDeque pd = (PyDeque)this.getType().__call__();
pd.deque_extend(this);
return pd;
}
@Override
public boolean isMappingType() {
return false;
}
@Override
public boolean isSequenceType() {
return true;
}
private static class Node {
private Node left;
private Node right;
private PyObject data;
Node(PyObject data, Node right, Node left) {
this.data = data;
this.right = right;
this.left = left;
}
}
private class PyDequeIter extends PyIterator {
private Node lastReturned = header;
private long startState;
public PyDequeIter() {
startState = state;
}
@Override
public PyObject __iternext__() {
synchronized (PyDeque.this) {
if (startState != state) {
throw Py.RuntimeError("deque changed size during iteration");
}
if (lastReturned.right != header) {
lastReturned = lastReturned.right;
return lastReturned.data;
}
return null;
}
}
/* Traverseproc implementation */
@Override
public int traverse(Visitproc visit, Object arg) {
int retVal = super.traverse(visit, arg);
if (retVal != 0) {
return retVal;
}
/* On first thought one would traverse the circular list
* starting with lastReturned. However due to synchronization
* it is guaranteed that this would traverse the same objects
* as starting with header would do. So we can simply call the
* traverse-method of PyDeque.this.
*/
return PyDeque.this.traverse(visit, arg);
}
@Override
public boolean refersDirectlyTo(PyObject ob) throws UnsupportedOperationException {
if (ob == null) {
return false;
} else if (super.refersDirectlyTo(ob)) {
return true;
} else {
throw new UnsupportedOperationException();
}
}
}
/* Traverseproc implementation */
@Override
public synchronized int traverse(Visitproc visit, Object arg) {
if (header == null) {
return 0;
}
int retVal = 0;
if (header.data != null) {
retVal = visit.visit(header.data, arg);
if (retVal != 0) {
return retVal;
}
}
Node tmp = header.right;
while (tmp != header) {
if (tmp.data != null) {
retVal = visit.visit(tmp.data, arg);
if (retVal != 0) {
return retVal;
}
}
tmp = tmp.right;
}
return retVal;
}
@Override
public boolean refersDirectlyTo(PyObject ob) throws UnsupportedOperationException {
throw new UnsupportedOperationException();
}
}