// Copyright (c) Corporation for National Research Initiatives
// Implementation of the standard Python list objects
package org.python.core;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.Vector;
/**
* A builtin python list.
*/
public class PyList extends PySequenceList {
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 = "list";
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 = ((PyList) self).seq___ne__(arg0);
if (ret == null)
return Py.NotImplemented;
return ret;
}
}
dict.__setitem__("__ne__", new PyMethodDescr("__ne__", PyList.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 = ((PyList) self).seq___eq__(arg0);
if (ret == null)
return Py.NotImplemented;
return ret;
}
}
dict.__setitem__("__eq__", new PyMethodDescr("__eq__", PyList.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 = ((PyList) self).seq___lt__(arg0);
if (ret == null)
return Py.NotImplemented;
return ret;
}
}
dict.__setitem__("__lt__", new PyMethodDescr("__lt__", PyList.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 = ((PyList) self).seq___le__(arg0);
if (ret == null)
return Py.NotImplemented;
return ret;
}
}
dict.__setitem__("__le__", new PyMethodDescr("__le__", PyList.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 = ((PyList) self).seq___gt__(arg0);
if (ret == null)
return Py.NotImplemented;
return ret;
}
}
dict.__setitem__("__gt__", new PyMethodDescr("__gt__", PyList.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 = ((PyList) self).seq___ge__(arg0);
if (ret == null)
return Py.NotImplemented;
return ret;
}
}
dict.__setitem__("__ge__", new PyMethodDescr("__ge__", PyList.class, 1, 1, new exposed___ge__(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 = ((PyList) self).seq___finditem__(arg0);
if (ret == null) {
throw Py.IndexError("index out of range: " + arg0);
}
return ret;
}
}
dict.__setitem__("__getitem__", new PyMethodDescr("__getitem__", PyList.class, 1, 1, new exposed___getitem__(
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(((PyList) self).object___contains__(arg0));
}
}
dict.__setitem__("__contains__", new PyMethodDescr("__contains__", PyList.class, 1, 1,
new exposed___contains__(null, null)));
class exposed___delitem__ extends PyBuiltinMethodNarrow {
exposed___delitem__(PyObject self, PyBuiltinFunction.Info info) {
super(self, info);
}
public PyBuiltinFunction bind(PyObject self) {
return new exposed___delitem__(self, info);
}
public PyObject __call__(PyObject arg0) {
((PyList) self).seq___delitem__(arg0);
return Py.None;
}
}
dict.__setitem__("__delitem__", new PyMethodDescr("__delitem__", PyList.class, 1, 1, new exposed___delitem__(
null, null)));
class exposed___setitem__ extends PyBuiltinMethodNarrow {
exposed___setitem__(PyObject self, PyBuiltinFunction.Info info) {
super(self, info);
}
public PyBuiltinFunction bind(PyObject self) {
return new exposed___setitem__(self, info);
}
public PyObject __call__(PyObject arg0, PyObject arg1) {
((PyList) self).seq___setitem__(arg0, arg1);
return Py.None;
}
}
dict.__setitem__("__setitem__", new PyMethodDescr("__setitem__", PyList.class, 2, 2, new exposed___setitem__(
null, null)));
class exposed___nonzero__ extends PyBuiltinMethodNarrow {
exposed___nonzero__(PyObject self, PyBuiltinFunction.Info info) {
super(self, info);
}
public PyBuiltinFunction bind(PyObject self) {
return new exposed___nonzero__(self, info);
}
public PyObject __call__() {
return Py.newBoolean(((PyList) self).seq___nonzero__());
}
}
dict.__setitem__("__nonzero__", new PyMethodDescr("__nonzero__", PyList.class, 0, 0, new exposed___nonzero__(
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 ((PyList) self).seq___getslice__(arg0, arg1, arg2);
}
public PyObject __call__(PyObject arg0, PyObject arg1) {
return ((PyList) self).seq___getslice__(arg0, arg1);
}
}
dict.__setitem__("__getslice__", new PyMethodDescr("__getslice__", PyList.class, 2, 3,
new exposed___getslice__(null, null)));
class exposed___delslice__ extends PyBuiltinMethodNarrow {
exposed___delslice__(PyObject self, PyBuiltinFunction.Info info) {
super(self, info);
}
public PyBuiltinFunction bind(PyObject self) {
return new exposed___delslice__(self, info);
}
public PyObject __call__(PyObject arg0, PyObject arg1, PyObject arg2) {
((PyList) self).seq___delslice__(arg0, arg1, arg2);
return Py.None;
}
}
dict.__setitem__("__delslice__", new PyMethodDescr("__delslice__", PyList.class, 3, 3,
new exposed___delslice__(null, null)));
class exposed___setslice__ extends PyBuiltinMethodNarrow {
exposed___setslice__(PyObject self, PyBuiltinFunction.Info info) {
super(self, info);
}
public PyBuiltinFunction bind(PyObject self) {
return new exposed___setslice__(self, info);
}
public PyObject __call__(PyObject arg0, PyObject arg1, PyObject arg2, PyObject arg3) {
((PyList) self).seq___setslice__(arg0, arg1, arg2, arg3);
return Py.None;
}
public PyObject __call__(PyObject arg0, PyObject arg1, PyObject arg2) {
((PyList) self).seq___setslice__(arg0, arg1, arg2);
return Py.None;
}
}
dict.__setitem__("__setslice__", new PyMethodDescr("__setslice__", PyList.class, 3, 4,
new exposed___setslice__(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 = ((PyList) self).list___add__(arg0);
if (ret == null)
return Py.NotImplemented;
return ret;
}
}
dict.__setitem__("__add__", new PyMethodDescr("__add__", PyList.class, 1, 1, new exposed___add__(null, null)));
class exposed___radd__ extends PyBuiltinMethodNarrow {
exposed___radd__(PyObject self, PyBuiltinFunction.Info info) {
super(self, info);
}
public PyBuiltinFunction bind(PyObject self) {
return new exposed___radd__(self, info);
}
public PyObject __call__(PyObject arg0) {
PyObject ret = ((PyList) self).list___radd__(arg0);
if (ret == null)
return Py.NotImplemented;
return ret;
}
}
dict.__setitem__("__radd__",
new PyMethodDescr("__radd__", PyList.class, 1, 1, new exposed___radd__(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 = ((PyList) self).list___mul__(arg0);
if (ret == null)
return Py.NotImplemented;
return ret;
}
}
dict.__setitem__("__mul__", new PyMethodDescr("__mul__", PyList.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 = ((PyList) self).list___rmul__(arg0);
if (ret == null)
return Py.NotImplemented;
return ret;
}
}
dict.__setitem__("__rmul__",
new PyMethodDescr("__rmul__", PyList.class, 1, 1, new exposed___rmul__(null, null)));
class exposed_append extends PyBuiltinMethodNarrow {
exposed_append(PyObject self, PyBuiltinFunction.Info info) {
super(self, info);
}
public PyBuiltinFunction bind(PyObject self) {
return new exposed_append(self, info);
}
public PyObject __call__(PyObject arg0) {
((PyList) self).list_append(arg0);
return Py.None;
}
}
dict.__setitem__("append", new PyMethodDescr("append", PyList.class, 1, 1, new exposed_append(null, null)));
class exposed_count extends PyBuiltinMethodNarrow {
exposed_count(PyObject self, PyBuiltinFunction.Info info) {
super(self, info);
}
public PyBuiltinFunction bind(PyObject self) {
return new exposed_count(self, info);
}
public PyObject __call__(PyObject arg0) {
return Py.newInteger(((PyList) self).list_count(arg0));
}
}
dict.__setitem__("count", new PyMethodDescr("count", PyList.class, 1, 1, new exposed_count(null, null)));
class exposed_extend extends PyBuiltinMethodNarrow {
exposed_extend(PyObject self, PyBuiltinFunction.Info info) {
super(self, info);
}
public PyBuiltinFunction bind(PyObject self) {
return new exposed_extend(self, info);
}
public PyObject __call__(PyObject arg0) {
((PyList) self).list_extend(arg0);
return Py.None;
}
}
dict.__setitem__("extend", new PyMethodDescr("extend", PyList.class, 1, 1, new exposed_extend(null, null)));
class exposed_index extends PyBuiltinMethodNarrow {
exposed_index(PyObject self, PyBuiltinFunction.Info info) {
super(self, info);
}
public PyBuiltinFunction bind(PyObject self) {
return new exposed_index(self, info);
}
public PyObject __call__(PyObject arg0, PyObject arg1, PyObject arg2) {
try {
return Py.newInteger(((PyList) self).list_index(arg0, arg1.asInt(1), arg2.asInt(2)));
} catch (PyObject.ConversionException e) {
String msg;
switch (e.index) {
case 1:
case 2:
msg = "expected an integer";
break;
default:
msg = "xxx";
}
throw Py.TypeError(msg);
}
}
public PyObject __call__(PyObject arg0, PyObject arg1) {
try {
return Py.newInteger(((PyList) self).list_index(arg0, arg1.asInt(1)));
} catch (PyObject.ConversionException e) {
String msg;
switch (e.index) {
case 1:
msg = "expected an integer";
break;
default:
msg = "xxx";
}
throw Py.TypeError(msg);
}
}
public PyObject __call__(PyObject arg0) {
return Py.newInteger(((PyList) self).list_index(arg0));
}
}
dict.__setitem__("index", new PyMethodDescr("index", PyList.class, 1, 3, new exposed_index(null, null)));
class exposed_insert extends PyBuiltinMethodNarrow {
exposed_insert(PyObject self, PyBuiltinFunction.Info info) {
super(self, info);
}
public PyBuiltinFunction bind(PyObject self) {
return new exposed_insert(self, info);
}
public PyObject __call__(PyObject arg0, PyObject arg1) {
try {
((PyList) self).list_insert(arg0.asInt(0), arg1);
return Py.None;
} catch (PyObject.ConversionException e) {
String msg;
switch (e.index) {
case 0:
msg = "expected an integer";
break;
default:
msg = "xxx";
}
throw Py.TypeError(msg);
}
}
}
dict.__setitem__("insert", new PyMethodDescr("insert", PyList.class, 2, 2, new exposed_insert(null, null)));
class exposed_pop extends PyBuiltinMethodNarrow {
exposed_pop(PyObject self, PyBuiltinFunction.Info info) {
super(self, info);
}
public PyBuiltinFunction bind(PyObject self) {
return new exposed_pop(self, info);
}
public PyObject __call__(PyObject arg0) {
try {
return ((PyList) self).list_pop(arg0.asInt(0));
} catch (PyObject.ConversionException e) {
String msg;
switch (e.index) {
case 0:
msg = "expected an integer";
break;
default:
msg = "xxx";
}
throw Py.TypeError(msg);
}
}
public PyObject __call__() {
return ((PyList) self).list_pop();
}
}
dict.__setitem__("pop", new PyMethodDescr("pop", PyList.class, 0, 1, new exposed_pop(null, null)));
class exposed_remove extends PyBuiltinMethodNarrow {
exposed_remove(PyObject self, PyBuiltinFunction.Info info) {
super(self, info);
}
public PyBuiltinFunction bind(PyObject self) {
return new exposed_remove(self, info);
}
public PyObject __call__(PyObject arg0) {
((PyList) self).list_remove(arg0);
return Py.None;
}
}
dict.__setitem__("remove", new PyMethodDescr("remove", PyList.class, 1, 1, new exposed_remove(null, null)));
class exposed_reverse extends PyBuiltinMethodNarrow {
exposed_reverse(PyObject self, PyBuiltinFunction.Info info) {
super(self, info);
}
public PyBuiltinFunction bind(PyObject self) {
return new exposed_reverse(self, info);
}
public PyObject __call__() {
((PyList) self).list_reverse();
return Py.None;
}
}
dict.__setitem__("reverse", new PyMethodDescr("reverse", PyList.class, 0, 0, new exposed_reverse(null, null)));
class exposed_sort extends PyBuiltinMethodNarrow {
exposed_sort(PyObject self, PyBuiltinFunction.Info info) {
super(self, info);
}
public PyBuiltinFunction bind(PyObject self) {
return new exposed_sort(self, info);
}
public PyObject __call__(PyObject arg0) {
((PyList) self).list_sort(arg0);
return Py.None;
}
public PyObject __call__() {
((PyList) self).list_sort();
return Py.None;
}
}
dict.__setitem__("sort", new PyMethodDescr("sort", PyList.class, 0, 1, new exposed_sort(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(((PyList) self).list___len__());
}
}
dict.__setitem__("__len__", new PyMethodDescr("__len__", PyList.class, 0, 0, new exposed___len__(null, null)));
class exposed___iadd__ extends PyBuiltinMethodNarrow {
exposed___iadd__(PyObject self, PyBuiltinFunction.Info info) {
super(self, info);
}
public PyBuiltinFunction bind(PyObject self) {
return new exposed___iadd__(self, info);
}
public PyObject __call__(PyObject arg0) {
return ((PyList) self).list___iadd__(arg0);
}
}
dict.__setitem__("__iadd__",
new PyMethodDescr("__iadd__", PyList.class, 1, 1, new exposed___iadd__(null, null)));
class exposed___imul__ extends PyBuiltinMethodNarrow {
exposed___imul__(PyObject self, PyBuiltinFunction.Info info) {
super(self, info);
}
public PyBuiltinFunction bind(PyObject self) {
return new exposed___imul__(self, info);
}
public PyObject __call__(PyObject arg0) {
return ((PyList) self).list___imul__(arg0);
}
}
dict.__setitem__("__imul__",
new PyMethodDescr("__imul__", PyList.class, 1, 1, new exposed___imul__(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 ((PyList) self).list___reduce__();
}
}
dict.__setitem__("__reduce__", new PyMethodDescr("__reduce__", PyList.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(((PyList) self).list_hashCode());
}
}
dict.__setitem__("__hash__",
new PyMethodDescr("__hash__", PyList.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(((PyList) self).list_toString());
}
}
dict.__setitem__("__repr__",
new PyMethodDescr("__repr__", PyList.class, 0, 0, new exposed___repr__(null, null)));
class exposed___init__ extends PyBuiltinMethod {
exposed___init__(PyObject self, PyBuiltinFunction.Info info) {
super(self, info);
}
public PyBuiltinFunction bind(PyObject self) {
return new exposed___init__(self, info);
}
public PyObject __call__(PyObject[] args) {
return __call__(args, Py.NoKeywords);
}
public PyObject __call__(PyObject[] args, String[] keywords) {
((PyList) self).list_init(args, keywords);
return Py.None;
}
}
dict.__setitem__("__init__", new PyMethodDescr("__init__", PyList.class, -1, -1, new exposed___init__(null,
null)));
dict.__setitem__("__new__", new PyNewWrapper(PyList.class, "__new__", -1, -1) {
public PyObject new_impl(boolean init, PyType subtype, PyObject[] args, String[] keywords) {
PyList newobj;
if (for_type == subtype) {
newobj = new PyList();
if (init)
newobj.list_init(args, keywords);
} else {
newobj = new PyListDerived(subtype);
}
return newobj;
}
});
}
//~ END GENERATED REGION -- DO NOT EDIT SEE gexpose.py
private static final PyType LISTTYPE = PyType.fromClass(PyList.class);
public PyList() {
this(LISTTYPE, Py.EmptyObjects);
}
public PyList(PyType type) {
super(type);
}
public PyList(PyType type, PyObject[] elements) {
super(type, elements);
}
public PyList(PyType type, Collection c) {
super(type, c);
}
// TODO: fix dependency so it can be removed.
// Shouldn't be required (see PyList(Collection c), but test_re.py fails
// without it. Probably used by reflection.
public PyList(Vector v) {
super(LISTTYPE, v);
}
public PyList(PyObject[] elements) {
this(LISTTYPE, elements);
}
public PyList(PyObject o) {
this(LISTTYPE);
PyObject iter = o.__iter__();
for (PyObject item = null; (item = iter.__iternext__()) != null;) {
append(item);
}
}
final void list_init(PyObject[] args, String[] kwds) {
ArgParser ap = new ArgParser("list", args, kwds, new String[] { "sequence" }, 0);
PyObject seq = ap.getPyObject(0, null);
if (seq == null) {
return;
}
if (seq instanceof PySequenceList) {
PySequenceList p = (PySequenceList) seq.__getslice__(Py.None, Py.None, Py.One);
this.list = p.list;
} else {
PyObject iter = seq.__iter__();
for (PyObject item = null; (item = iter.__iternext__()) != null;) {
append(item);
}
}
}
public String safeRepr() throws PyIgnoreMethodTag {
return "'list' object";
}
public int __len__() {
return list___len__();
}
final int list___len__() {
return size();
}
protected PyObject getslice(int start, int stop, int step) {
if (step > 0 && stop < start)
stop = start;
int n = sliceLength(start, stop, step);
PyObject[] newList = new PyObject[n];
PyObject[] array = getArray();
if (step == 1) {
System.arraycopy(array, start, newList, 0, stop - start);
return new PyList(newList);
}
int j = 0;
for (int i = start; j < n; i += step) {
newList[j] = array[i];
j++;
}
return new PyList(newList);
}
protected void del(int i) {
remove(i);
}
protected void delRange(int start, int stop, int step) {
if (step == 1) {
remove(start, stop);
} else if (step > 1) {
for (int i = start; i < stop; i += step) {
remove(i);
i--;
stop--;
}
} else if (step < 0) {
for (int i = start; i >= 0 && i >= stop; i += step) {
remove(i);
}
}
}
protected void set(int i, PyObject value) {
list.pyset(i, value);
}
// protected void setslice(int start, int stop, int step, PyObject value) {
//
// if (step != 1)
// throw Py.ValueError("step size must be 1 for setting list slice");
// if (stop < start)
// stop = start;
//
// if (value instanceof PySequenceList) {
//
// if (value instanceof PyList) {
// PyObject[] otherArray = null;
// PyObject[] array = getArray();
// PySequenceList seqList = (PySequenceList)value;
// otherArray = seqList.getArray();
// if (otherArray == array) {
// otherArray = (PyObject[])otherArray.clone();
// }
// list.replaceSubArray(start, stop, otherArray, 0, seqList.size());
// } else {
// throw Py.TypeError("can only concatenate list (not \"" +
// value.getType() + "\") to list");
// }
// } else {
//
// // also allow java.util.List
// List other = (List)value.__tojava__(List.class);
// if(other != Py.NoConversion) {
// int n = other.size();
// list.ensureCapacity(start + n);
// for(int i=0; i<n; i++) {
// list.add(i+start, other.get(i));
// }
// } else {
// throw Py.TypeError(
// "rhs of setslice must be a sequence or java.util.List");
// }
// }
// }
protected void setslice(int start, int stop, int step, PyObject value) {
if (stop < start)
stop = start;
if (step == 1) {
if (value instanceof PySequence) {
PySequence seq = (PySequence) value;
PyObject[] otherArray = null;
PyObject[] array = getArray();
if (value instanceof PySequenceList) {
PySequenceList seqList = (PySequenceList) value;
otherArray = seqList.getArray();
if (otherArray == array) {
otherArray = (PyObject[]) otherArray.clone();
}
list.replaceSubArray(start, stop, otherArray, 0, seqList.size());
} else {
int n = seq.__len__();
list.ensureCapacity(start + n);
for (int i = 0; i < n; i++) {
list.add(i + start, seq.pyget(i));
}
}
} else if (value instanceof List) {
List other = (List) value.__tojava__(List.class);
if (other != Py.NoConversion && other != null) {
int n = other.size();
list.ensureCapacity(start + n);
for (int i = 0; i < n; i++) {
list.add(i + start, other.get(i));
}
}
} else {
throw Py.TypeError("rhs of setslice must be a sequence or java.util.List");
}
} else if (step > 1) {
if (value instanceof PySequence) {
PySequence seq = (PySequence) value;
int n = seq.__len__();
for (int i = 0, j = 0; i < n; i++, j += step) {
list.pyset(j + start, seq.pyget(i));
}
} else {
throw Py.TypeError("setslice with java.util.List and step != 1 not supported yet.");
}
} else if (step < 0) {
if (value instanceof PySequence) {
PySequence seq = (PySequence) value;
int n = seq.__len__();
if (seq == this) {
PyList newseq = new PyList();
PyObject iter = seq.__iter__();
for (PyObject item = null; (item = iter.__iternext__()) != null;) {
newseq.append(item);
}
seq = newseq;
}
for (int i = 0, j = list.size() - 1; i < n; i++, j += step) {
list.pyset(j, seq.pyget(i));
}
} else {
throw Py.TypeError("setslice with java.util.List and step != 1 not supported yet.");
}
}
}
protected PyObject repeat(int count) {
int l = size();
PyObject[] newList = new PyObject[l * count];
for (int i = 0; i < count; i++) {
System.arraycopy(getArray(), 0, newList, i * l, l);
}
return new PyList(newList);
}
public PyObject __imul__(PyObject o) {
PyObject result = list___imul__(o);
if (result == null) {
// We can't perform an in-place multiplication on o's
// type, so let o try to rmul this list. A new list will
// be created instead of modifying this one, but that's
// preferable to just blowing up on this operation.
result = o.__rmul__(this);
if (result == null) {
throw Py.TypeError(_unsupportedop("*", o));
}
}
return result;
}
final PyObject list___imul__(PyObject o) {
if (!(o instanceof PyInteger || o instanceof PyLong))
return null;
int l = size();
int count = ((PyInteger) o.__int__()).getValue();
int newSize = l * count;
list.ensureCapacity(newSize);
list.setSize(newSize);
//resize(l * count);
PyObject[] array = getArray();
for (int i = 1; i < count; i++) {
System.arraycopy(array, 0, array, i * l, l);
}
return this;
}
final PyObject list___mul__(PyObject o) {
if (!(o instanceof PyInteger || o instanceof PyLong))
return null;
int count = ((PyInteger) o.__int__()).getValue();
return repeat(count);
}
final PyObject list___rmul__(PyObject o) {
if (!(o instanceof PyInteger || o instanceof PyLong))
return null;
int count = ((PyInteger) o.__int__()).getValue();
return repeat(count);
}
public PyObject __add__(PyObject o) {
return list___add__(o);
}
final PyObject list___add__(PyObject o) {
PyList sum = null;
if (o instanceof PyList) {
PyList other = (PyList) o;
int thisLen = size();
int otherLen = other.size();
PyObject[] newList = new PyObject[thisLen + otherLen];
System.arraycopy(getArray(), 0, newList, 0, thisLen);
System.arraycopy(other.getArray(), 0, newList, thisLen, otherLen);
sum = new PyList(newList);
} else if (!(o instanceof PySequenceList)) {
// also support adding java lists (but not PyTuple!)
Object oList = o.__tojava__(List.class);
if (oList != Py.NoConversion && oList != null) {
List otherList = (List) oList;
sum = new PyList();
sum.list_extend(this);
for (Iterator i = otherList.iterator(); i.hasNext();) {
sum.add(i.next());
}
}
}
return sum;
}
public PyObject __radd__(PyObject o) {
return list___radd__(o);
}
final PyObject list___radd__(PyObject o) {
// Support adding java.util.List, but prevent adding PyTuple.
// 'o' should never be a PyList since __add__ is defined.
PyList sum = null;
if (o instanceof PySequence) {
return null;
}
Object oList = o.__tojava__(List.class);
if (oList != Py.NoConversion && oList != null) {
sum = new PyList();
sum.addAll((List) oList);
sum.extend(this);
}
return sum;
}
protected String unsupportedopMessage(String op, PyObject o2) {
if (op.equals("+")) {
return "can only concatenate list (not \"{2}\") to list";
}
return super.unsupportedopMessage(op, o2);
}
public String toString() {
return list_toString();
}
final String list_toString() {
ThreadState ts = Py.getThreadState();
if (!ts.enterRepr(this)) {
return "[...]";
}
StringBuffer buf = new StringBuffer("[");
int length = size();
PyObject[] array = getArray();
for (int i = 0; i < length - 1; i++) {
buf.append((array[i]).__repr__().toString());
buf.append(", ");
}
if (length > 0)
buf.append((array[length - 1]).__repr__().toString());
buf.append("]");
ts.exitRepr(this);
return buf.toString();
}
/**
* Add a single element to the end of list.
*
* @param o the element to add.
*/
public void append(PyObject o) {
list_append(o);
}
final void list_append(PyObject o) {
pyadd(o);
}
/**
* Return the number elements in the list that equals the argument.
*
* @param o the argument to test for. Testing is done with
* the <code>==</code> operator.
*/
public int count(PyObject o) {
return list_count(o);
}
final int list_count(PyObject o) {
int count = 0;
PyObject[] array = getArray();
for (int i = 0, n = size(); i < n; i++) {
if (array[i].equals(o))
count++;
}
return count;
}
/**
* return smallest index where an element in the list equals
* the argument.
*
* @param o the argument to test for. Testing is done with
* the <code>==</code> operator.
*/
public int index(PyObject o) {
return list_index(o, 0, size());
}
public int index(PyObject o, int start) {
return list_index(o, start, size());
}
// CAU: not referenced anywheir, why is this here?
public int index(PyObject o, int start, int stop) {
return list_index(o, start, stop);
}
final int list_index(PyObject o, int start, int stop) {
return _index(o, "list.index(x): x not in list", start, stop);
}
final int list_index(PyObject o, int start) {
return _index(o, "list.index(x): x not in list", start, size());
}
final int list_index(PyObject o) {
return _index(o, "list.index(x): x not in list", 0, size());
}
private int _index(PyObject o, String message, int start, int stop) {
//Follow Python 2.3+ behavior
int validStop = calculateIndex(stop);
int validStart = calculateIndex(start);
PyObject[] array = getArray();
int i = validStart;
for (; i < validStop; i++) {
if (array[i].equals(o))
break;
}
if (i == validStop)
throw Py.ValueError(message);
return i;
}
//This is closely related to fixindex in PySequence, but less strict
//fixindex returns -1 if index += length < 0 or if index >= length
//where this function returns 0 in former case and length in the latter.
//I think both are needed in different cases, but if this method turns
//out to be needed in other sequence subclasses, it should be moved to
//PySequence.
private int calculateIndex(int index) {
int length = size();
if (index < 0) {
index = index += length;
if (index < 0) {
index = 0;
}
} else if (index > length) {
index = length;
}
return index;
}
/**
* Insert the argument element into the list at the specified
* index.
* <br>
* Same as <code>s[index:index] = [o] if index >= 0</code>.
*
* @param index the position where the element will be inserted.
* @param o the element to insert.
*/
public void insert(int index, PyObject o) {
list_insert(index, o);
}
final void list_insert(int index, PyObject o) {
if (index < 0)
index = Math.max(0, size() + index);
if (index > size())
index = size();
list.pyadd(index, o);
}
/**
* Remove the first occurence of the argument from the list.
* The elements arecompared with the <code>==</code> operator.
* <br>
* Same as <code>del s[s.index(x)]</code>
*
* @param o the element to search for and remove.
*/
public void remove(PyObject o) {
list_remove(o);
}
final void list_remove(PyObject o) {
del(_index(o, "list.remove(x): x not in list", 0, size()));
}
/**
* Reverses the items of s in place.
* The reverse() methods modify the list in place for economy
* of space when reversing a large list. It doesn't return the
* reversed list to remind you of this side effect.
*/
public void reverse() {
list_reverse();
}
final void list_reverse() {
PyObject tmp;
int n = size();
PyObject[] array = getArray();
int j = n - 1;
for (int i = 0; i < n / 2; i++, j--) {
tmp = array[i];
array[i] = array[j];
array[j] = tmp;
}
}
/**
* Removes and return the last element in the list.
*/
public PyObject pop() {
return list_pop();
}
final PyObject list_pop() {
return pop(-1);
}
/**
* Removes and return the <code>n</code> indexed element in the
* list.
*
* @param n the index of the element to remove and return.
*/
public PyObject pop(int n) {
return list_pop(n);
}
final PyObject list_pop(int n) {
int length = size();
if (length == 0) {
throw Py.IndexError("pop from empty list");
}
if (n < 0)
n += length;
if (n < 0 || n >= length)
throw Py.IndexError("pop index out of range");
PyObject v = pyget(n);
setslice(n, n + 1, 1, Py.EmptyTuple);
return v;
}
/**
* Append the elements in the argument sequence to the end of the list.
* <br>
* Same as <code>s[len(s):len(s)] = o</code>.
*
* @param o the sequence of items to append to the list.
*/
public void extend(PyObject o) {
list_extend(o);
}
final void list_extend(PyObject o) {
int length = size();
setslice(length, length, 1, o);
}
public PyObject __iadd__(PyObject o) {
return list___iadd__(o);
}
final PyObject list___iadd__(PyObject o) {
extend(fastSequence(o, "argument to += must be a sequence"));
return this;
}
/**
* Sort the items of the list in place. The compare argument is a
* function of two arguments (list items) which should return
* -1, 0 or 1 depending on whether the first argument is
* considered smaller than, equal to, or larger than the second
* argument. Note that this slows the sorting process down
* considerably; e.g. to sort a list in reverse order it is much
* faster to use calls to the methods sort() and reverse() than
* to use the built-in function sort() with a comparison function
* that reverses the ordering of the elements.
*
* @param compare the comparison function.
*/
public synchronized void sort(PyObject compare) {
list_sort(compare);
}
final synchronized void list_sort(PyObject compare) {
MergeState ms = new MergeState(getArray(), size(), compare);
ms.sort();
}
/**
* Sort the items of the list in place. Items is compared with the
* normal relative comparison operators.
*/
public void sort() {
list_sort();
}
final void list_sort() {
list_sort(null);
}
public int hashCode() {
return list_hashCode();
}
final int list_hashCode() {
throw Py.TypeError("unhashable type");
}
/**
* Used for pickling.
*
* @return a tuple of (class, tuple)
*/
public PyObject __reduce__() {
return list___reduce__();
}
final PyObject list___reduce__() {
PyTuple newargs = __getnewargs__();
return new PyTuple(new PyObject[] { getType(), newargs });
}
public PyTuple __getnewargs__() {
return new PyTuple(new PyObject[] { new PyTuple(list.getArray()) });
}
}