// Copyright (c) Corporation for National Research Initiatives
package org.python.core;
import java.util.Collection;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import java.util.ArrayList;
import java.util.ListIterator;
/**
* A builtin python tuple.
*/
public class PyTuple extends PySequenceList implements ClassDictInit
{
/** <i>Internal use only. Do not call this method explicit.</i> */
public static void classDictInit(PyObject dict)throws PyIgnoreMethodTag {}
//~ BEGIN GENERATED REGION -- DO NOT EDIT SEE gexpose.py
/* type info */
public static final String exposed_name="tuple";
public static final Class exposed_base=PyObject.class;
public static void typeSetup(PyObject dict,PyType.Newstyle marker) {
class exposed___ne__ extends PyBuiltinMethodNarrow {
exposed___ne__(PyObject self,PyBuiltinFunction.Info info) {
super(self,info);
}
public PyBuiltinFunction bind(PyObject self) {
return new exposed___ne__(self,info);
}
public PyObject __call__(PyObject arg0) {
PyObject ret=((PyTuple)self).tuple___ne__(arg0);
if (ret==null)
return Py.NotImplemented;
return ret;
}
}
dict.__setitem__("__ne__",new PyMethodDescr("__ne__",PyTuple.class,1,1,new exposed___ne__(null,null)));
class exposed___eq__ extends PyBuiltinMethodNarrow {
exposed___eq__(PyObject self,PyBuiltinFunction.Info info) {
super(self,info);
}
public PyBuiltinFunction bind(PyObject self) {
return new exposed___eq__(self,info);
}
public PyObject __call__(PyObject arg0) {
PyObject ret=((PyTuple)self).tuple___eq__(arg0);
if (ret==null)
return Py.NotImplemented;
return ret;
}
}
dict.__setitem__("__eq__",new PyMethodDescr("__eq__",PyTuple.class,1,1,new exposed___eq__(null,null)));
class exposed___lt__ extends PyBuiltinMethodNarrow {
exposed___lt__(PyObject self,PyBuiltinFunction.Info info) {
super(self,info);
}
public PyBuiltinFunction bind(PyObject self) {
return new exposed___lt__(self,info);
}
public PyObject __call__(PyObject arg0) {
PyObject ret=((PyTuple)self).tuple___lt__(arg0);
if (ret==null)
return Py.NotImplemented;
return ret;
}
}
dict.__setitem__("__lt__",new PyMethodDescr("__lt__",PyTuple.class,1,1,new exposed___lt__(null,null)));
class exposed___le__ extends PyBuiltinMethodNarrow {
exposed___le__(PyObject self,PyBuiltinFunction.Info info) {
super(self,info);
}
public PyBuiltinFunction bind(PyObject self) {
return new exposed___le__(self,info);
}
public PyObject __call__(PyObject arg0) {
PyObject ret=((PyTuple)self).tuple___le__(arg0);
if (ret==null)
return Py.NotImplemented;
return ret;
}
}
dict.__setitem__("__le__",new PyMethodDescr("__le__",PyTuple.class,1,1,new exposed___le__(null,null)));
class exposed___gt__ extends PyBuiltinMethodNarrow {
exposed___gt__(PyObject self,PyBuiltinFunction.Info info) {
super(self,info);
}
public PyBuiltinFunction bind(PyObject self) {
return new exposed___gt__(self,info);
}
public PyObject __call__(PyObject arg0) {
PyObject ret=((PyTuple)self).tuple___gt__(arg0);
if (ret==null)
return Py.NotImplemented;
return ret;
}
}
dict.__setitem__("__gt__",new PyMethodDescr("__gt__",PyTuple.class,1,1,new exposed___gt__(null,null)));
class exposed___ge__ extends PyBuiltinMethodNarrow {
exposed___ge__(PyObject self,PyBuiltinFunction.Info info) {
super(self,info);
}
public PyBuiltinFunction bind(PyObject self) {
return new exposed___ge__(self,info);
}
public PyObject __call__(PyObject arg0) {
PyObject ret=((PyTuple)self).tuple___ge__(arg0);
if (ret==null)
return Py.NotImplemented;
return ret;
}
}
dict.__setitem__("__ge__",new PyMethodDescr("__ge__",PyTuple.class,1,1,new exposed___ge__(null,null)));
class exposed___add__ extends PyBuiltinMethodNarrow {
exposed___add__(PyObject self,PyBuiltinFunction.Info info) {
super(self,info);
}
public PyBuiltinFunction bind(PyObject self) {
return new exposed___add__(self,info);
}
public PyObject __call__(PyObject arg0) {
PyObject ret=((PyTuple)self).tuple___add__(arg0);
if (ret==null)
return Py.NotImplemented;
return ret;
}
}
dict.__setitem__("__add__",new PyMethodDescr("__add__",PyTuple.class,1,1,new exposed___add__(null,null)));
class exposed___mul__ extends PyBuiltinMethodNarrow {
exposed___mul__(PyObject self,PyBuiltinFunction.Info info) {
super(self,info);
}
public PyBuiltinFunction bind(PyObject self) {
return new exposed___mul__(self,info);
}
public PyObject __call__(PyObject arg0) {
PyObject ret=((PyTuple)self).tuple___mul__(arg0);
if (ret==null)
return Py.NotImplemented;
return ret;
}
}
dict.__setitem__("__mul__",new PyMethodDescr("__mul__",PyTuple.class,1,1,new exposed___mul__(null,null)));
class exposed___rmul__ extends PyBuiltinMethodNarrow {
exposed___rmul__(PyObject self,PyBuiltinFunction.Info info) {
super(self,info);
}
public PyBuiltinFunction bind(PyObject self) {
return new exposed___rmul__(self,info);
}
public PyObject __call__(PyObject arg0) {
PyObject ret=((PyTuple)self).tuple___rmul__(arg0);
if (ret==null)
return Py.NotImplemented;
return ret;
}
}
dict.__setitem__("__rmul__",new PyMethodDescr("__rmul__",PyTuple.class,1,1,new exposed___rmul__(null,null)));
class exposed___getitem__ extends PyBuiltinMethodNarrow {
exposed___getitem__(PyObject self,PyBuiltinFunction.Info info) {
super(self,info);
}
public PyBuiltinFunction bind(PyObject self) {
return new exposed___getitem__(self,info);
}
public PyObject __call__(PyObject arg0) {
PyObject ret=((PyTuple)self).seq___finditem__(arg0);
if (ret==null) {
throw Py.IndexError("index out of range: "+arg0);
}
return ret;
}
}
dict.__setitem__("__getitem__",new PyMethodDescr("__getitem__",PyTuple.class,1,1,new exposed___getitem__(null,null)));
class exposed___getslice__ extends PyBuiltinMethodNarrow {
exposed___getslice__(PyObject self,PyBuiltinFunction.Info info) {
super(self,info);
}
public PyBuiltinFunction bind(PyObject self) {
return new exposed___getslice__(self,info);
}
public PyObject __call__(PyObject arg0,PyObject arg1,PyObject arg2) {
return((PyTuple)self).seq___getslice__(arg0,arg1,arg2);
}
public PyObject __call__(PyObject arg0,PyObject arg1) {
return((PyTuple)self).seq___getslice__(arg0,arg1);
}
}
dict.__setitem__("__getslice__",new PyMethodDescr("__getslice__",PyTuple.class,2,3,new exposed___getslice__(null,null)));
class exposed___contains__ extends PyBuiltinMethodNarrow {
exposed___contains__(PyObject self,PyBuiltinFunction.Info info) {
super(self,info);
}
public PyBuiltinFunction bind(PyObject self) {
return new exposed___contains__(self,info);
}
public PyObject __call__(PyObject arg0) {
return Py.newBoolean(((PyTuple)self).tuple___contains__(arg0));
}
}
dict.__setitem__("__contains__",new PyMethodDescr("__contains__",PyTuple.class,1,1,new exposed___contains__(null,null)));
class exposed___len__ extends PyBuiltinMethodNarrow {
exposed___len__(PyObject self,PyBuiltinFunction.Info info) {
super(self,info);
}
public PyBuiltinFunction bind(PyObject self) {
return new exposed___len__(self,info);
}
public PyObject __call__() {
return Py.newInteger(((PyTuple)self).tuple___len__());
}
}
dict.__setitem__("__len__",new PyMethodDescr("__len__",PyTuple.class,0,0,new exposed___len__(null,null)));
class exposed___reduce__ extends PyBuiltinMethodNarrow {
exposed___reduce__(PyObject self,PyBuiltinFunction.Info info) {
super(self,info);
}
public PyBuiltinFunction bind(PyObject self) {
return new exposed___reduce__(self,info);
}
public PyObject __call__() {
return((PyTuple)self).tuple___reduce__();
}
}
dict.__setitem__("__reduce__",new PyMethodDescr("__reduce__",PyTuple.class,0,0,new exposed___reduce__(null,null)));
class exposed___hash__ extends PyBuiltinMethodNarrow {
exposed___hash__(PyObject self,PyBuiltinFunction.Info info) {
super(self,info);
}
public PyBuiltinFunction bind(PyObject self) {
return new exposed___hash__(self,info);
}
public PyObject __call__() {
return Py.newInteger(((PyTuple)self).tuple_hashCode());
}
}
dict.__setitem__("__hash__",new PyMethodDescr("__hash__",PyTuple.class,0,0,new exposed___hash__(null,null)));
class exposed___repr__ extends PyBuiltinMethodNarrow {
exposed___repr__(PyObject self,PyBuiltinFunction.Info info) {
super(self,info);
}
public PyBuiltinFunction bind(PyObject self) {
return new exposed___repr__(self,info);
}
public PyObject __call__() {
return new PyString(((PyTuple)self).tuple_toString());
}
}
dict.__setitem__("__repr__",new PyMethodDescr("__repr__",PyTuple.class,0,0,new exposed___repr__(null,null)));
dict.__setitem__("__new__",new PyNewWrapper(PyTuple.class,"__new__",-1,-1) {
public PyObject new_impl(boolean init,PyType subtype,PyObject[]args,String[]keywords) {
return tuple_new(this,init,subtype,args,keywords);
}
});
}
//~ END GENERATED REGION -- DO NOT EDIT SEE gexpose.py
private static final PyType TUPLETYPE = PyType.fromClass(PyTuple.class);
public PyTuple() {
this(TUPLETYPE, Py.EmptyObjects);
}
public PyTuple(PyObject[] elements) {
this(TUPLETYPE, elements);
}
public PyTuple(PyType subtype, PyObject[] elements) {
super(subtype, elements);
}
final static PyObject tuple_new(PyNewWrapper new_, boolean init, PyType subtype,
PyObject[] args, String[] keywords) {
ArgParser ap = new ArgParser("tuple", args, keywords, new String[] { "sequence" }, 0);
PyObject S = ap.getPyObject(0, null);
if (new_.for_type == subtype) {
if (S == null) {
return new PyTuple();
}
if (S instanceof PyTupleDerived) {
return new PyTuple(((PyTuple)S).getArray());
}
if (S instanceof PyTuple) {
return S;
}
PyObject iter = S.__iter__();
// it's not always possible to know the length of the iterable
ArrayList a = new ArrayList(10);
for (PyObject item = null; (item = iter.__iternext__()) != null; ) {
a.add(item);
}
return new PyTuple((PyObject[])a.toArray(new PyObject[a.size()]));
} else {
if (S == null) {
return new PyTupleDerived(subtype, Py.EmptyObjects);
}
PyObject iter = S.__iter__();
// it's not always possible to know the length of the iterable
ArrayList a = new ArrayList(10);
for (PyObject item = null; (item = iter.__iternext__()) != null; ) {
a.add(item);
}
return new PyTupleDerived(subtype, (PyObject[])a.toArray(new PyObject[a.size()]));
}
}
public String safeRepr() throws PyIgnoreMethodTag {
return "'tuple' object";
}
protected PyObject getslice(int start, int stop, int step) {
if (step > 0 && stop < start)
stop = start;
int n = sliceLength(start, stop, step);
PyObject[] newArray = new PyObject[n];
PyObject[] array = getArray();
if (step == 1) {
System.arraycopy(array, start, newArray, 0, stop-start);
return new PyTuple(newArray);
}
int j = 0;
for (int i=start; j<n; i+=step) {
newArray[j] = array[i];
j++;
}
return new PyTuple(newArray);
}
protected PyObject repeat(int count) {
PyObject[] array = getArray();
int l = size();
PyObject[] newArray = new PyObject[l*count];
for (int i=0; i<count; i++) {
System.arraycopy(array, 0, newArray, i*l, l);
}
return new PyTuple(newArray);
}
public int __len__() {
return tuple___len__();
}
final int tuple___len__() {
return size();
}
final boolean tuple___contains__(PyObject o) {
return super.__contains__(o);
}
final PyObject tuple___ne__(PyObject o) {
return super.__ne__(o);
}
final PyObject tuple___eq__(PyObject o) {
return super.__eq__(o);
}
final PyObject tuple___gt__(PyObject o) {
return super.__gt__(o);
}
final PyObject tuple___ge__(PyObject o) {
return super.__ge__(o);
}
final PyObject tuple___lt__(PyObject o) {
return super.__lt__(o);
}
final PyObject tuple___le__(PyObject o) {
return super.__le__(o);
}
public PyObject __add__(PyObject generic_other) {
return tuple___add__(generic_other);
}
final PyObject tuple___add__(PyObject generic_other) {
PyTuple sum = null;
if (generic_other instanceof PyTuple) {
PyTuple otherTuple = (PyTuple)generic_other;
PyObject[] array = getArray();
PyObject[] otherArray = otherTuple.getArray();
int thisLen = size();
int otherLen = otherTuple.size();
PyObject[] newArray = new PyObject[thisLen + otherLen];
System.arraycopy(array, 0, newArray, 0, thisLen);
System.arraycopy(otherArray, 0, newArray, thisLen, otherLen);
sum = new PyTuple(newArray);
}
return sum;
}
final PyObject tuple___mul__(PyObject o) {
if (!(o instanceof PyInteger || o instanceof PyLong))
return null;
int count = ((PyInteger)o.__int__()).getValue();
return repeat(count);
}
final PyObject tuple___rmul__(PyObject o) {
if (!(o instanceof PyInteger || o instanceof PyLong))
return null;
int count = ((PyInteger)o.__int__()).getValue();
return repeat(count);
}
/**
* Used for pickling.
*
* @return a tuple of (class, tuple)
*/
public PyObject __reduce__() {
return tuple___reduce__();
}
final PyObject tuple___reduce__() {
PyTuple newargs = __getnewargs__();
return new PyTuple(new PyObject[]{
getType(), newargs
});
}
public PyTuple __getnewargs__() {
return new PyTuple(new PyObject[]
{new PyList(list.getArray())}
);
}
public int hashCode() {
return tuple_hashCode();
}
final int tuple_hashCode() {
return super.hashCode();
}
private String subobjRepr(PyObject o) {
if (o == null)
return "null";
return o.__repr__().toString();
}
public String toString() {
return tuple_toString();
}
final String tuple_toString() {
StringBuffer buf = new StringBuffer("(");
PyObject[] array = getArray();
int arrayLen = size();
for (int i = 0; i < arrayLen-1; i++) {
buf.append(subobjRepr(array[i]));
buf.append(", ");
}
if (arrayLen > 0)
buf.append(subobjRepr(array[arrayLen-1]));
if (arrayLen == 1)
buf.append(",");
buf.append(")");
return buf.toString();
}
public List subList(int fromIndex, int toIndex) {
return Collections.unmodifiableList(list.subList(fromIndex, toIndex));
}
// Make PyTuple immutable from the collections interfaces by overriding
// all the mutating methods to throw UnsupportedOperationException exception.
// This is how Collections.unmodifiableList() does it.
public Iterator iterator() {
return new Iterator() {
Iterator i = list.iterator();
public void remove() {
throw new UnsupportedOperationException();
}
public boolean hasNext() {
return i.hasNext();
}
public Object next() {
return i.next();
}
};
}
public boolean add(Object o){
throw new UnsupportedOperationException();
}
public boolean remove(Object o) {
throw new UnsupportedOperationException();
}
public boolean addAll(Collection coll) {
throw new UnsupportedOperationException();
}
public boolean removeAll(Collection coll) {
throw new UnsupportedOperationException();
}
public boolean retainAll(Collection coll) {
throw new UnsupportedOperationException();
}
public void clear() {
throw new UnsupportedOperationException();
}
public Object set(int index, Object element) {
throw new UnsupportedOperationException();
}
public void add(int index, Object element) {
throw new UnsupportedOperationException();
}
public Object remove(int index) {
throw new UnsupportedOperationException();
}
public boolean addAll(int index, Collection c) {
throw new UnsupportedOperationException();
}
public ListIterator listIterator() {
return listIterator(0);
}
public ListIterator listIterator(final int index) {
return new ListIterator() {
ListIterator i = list.listIterator(index);
public boolean hasNext() {return i.hasNext();}
public Object next() {return i.next();}
public boolean hasPrevious() {return i.hasPrevious();}
public Object previous() {return i.previous();}
public int nextIndex() {return i.nextIndex();}
public int previousIndex() {return i.previousIndex();}
public void remove() {
throw new UnsupportedOperationException();
}
public void set(Object o) {
throw new UnsupportedOperationException();
}
public void add(Object o) {
throw new UnsupportedOperationException();
}
};
}
protected String unsupportedopMessage(String op, PyObject o2) {
if (op.equals("+")) {
return "can only concatenate tuple (not \"{2}\") to tuple";
}
return super.unsupportedopMessage(op, o2);
}
}