src.templates.object.derived Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of jython Show documentation
Show all versions of jython 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.
base_class: PyObject
want_dict: true
ctr:
unary1: __str__ string
unary1: __repr__ string
unary1: __hex__ string
unary1: __oct__ string
unary1: __float__ float
unary1: __complex__ complex
unary1: __pos__
unary1: __neg__
unary1: __abs__
unary1: __invert__
unary1: __reduce__
binary: __add__ __radd__ \
__sub__ __rsub__ \
__mul__ __rmul__ \
__div__ __rdiv__ \
__floordiv__ __rfloordiv__ \
__truediv__ __rtruediv__ \
__mod__ __rmod__ \
__divmod__ __rdivmod__ \
__rpow__ \
__lshift__ __rlshift__ \
__rshift__ __rrshift__ \
__and__ __rand__ \
__or__ __ror__ \
__xor__ __rxor__ \
__lt__ __le__ __gt__ __ge__ __eq__ __ne__
ibinary: __iadd__ \
__isub__ \
__imul__ \
__idiv__ \
__ifloordiv__ \
__itruediv__ \
__imod__ \
__ipow__ \
__ilshift__ \
__irshift__ \
__iand__ \
__ior__ \
__ixor__
rest:
public PyObject __int__() {
PyType self_type=getType();
PyObject impl=self_type.lookup("__int__");
if (impl!=null) {
PyObject res=impl.__get__(this,self_type).__call__();
if (res instanceof PyInteger || res instanceof PyLong)
return res;
throw Py.TypeError("__int__"+" should return an integer");
}
return super.__int__();
}
public PyObject __long__() {
PyType self_type=getType();
PyObject impl=self_type.lookup("__long__");
if (impl!=null) {
PyObject res=impl.__get__(this,self_type).__call__();
if (res instanceof PyLong || res instanceof PyInteger)
return res;
throw Py.TypeError("__long__"+" returned non-"+"long"+" (type "+res.getType().fastGetName()+")");
}
return super.__long__();
}
public int hashCode() {
PyType self_type = getType();
PyObject impl = self_type.lookup("__hash__");
if (impl != null) {
PyObject res = impl.__get__(this, self_type).__call__();
if (res instanceof PyInteger) {
return ((PyInteger) res).getValue();
} else if (res instanceof PyLong) {
return ((PyLong) res).getValue().intValue();
}
throw Py.TypeError("__hash__ should return a int");
}
if (self_type.lookup("__eq__") != null || self_type.lookup("__cmp__") != null) {
throw Py.TypeError(String.format("unhashable type: '%.200s'", getType().fastGetName()));
}
return super.hashCode();
}
public PyUnicode __unicode__() {
PyType self_type=getType();
PyObject impl=self_type.lookup("__unicode__");
if (impl!=null) {
PyObject res=impl.__get__(this,self_type).__call__();
if (res instanceof PyUnicode)
return(PyUnicode)res;
if (res instanceof PyString)
return new PyUnicode((PyString)res);
throw Py.TypeError("__unicode__"+" should return a "+"unicode");
}
return super.__unicode__();
}
public int __cmp__(PyObject other) {
PyType self_type=getType();
PyObject[] where_type = new PyObject[1];
PyObject impl = self_type.lookup_where("__cmp__", where_type);
// Full Compatibility with CPython __cmp__:
// If the derived type don't override __cmp__, the
// *internal* super().__cmp__ should be called, not the
// exposed one. The difference is that the exposed __cmp__
// throws a TypeError if the argument is an instance of the same type.
if (impl == null || where_type[0] == TYPE || Py.isSubClass(TYPE, where_type[0])) {
return super.__cmp__(other);
}
PyObject res = impl.__get__(this,self_type).__call__(other);
if (res == Py.NotImplemented) {
return -2;
}
int c = res.asInt();
return c < 0 ? -1 : c > 0 ? 1 : 0;
}
public boolean __nonzero__() {
PyType self_type = getType();
PyObject impl = self_type.lookup("__nonzero__");
if (impl == null) {
impl = self_type.lookup("__len__");
if (impl == null)
return super.__nonzero__();
}
PyObject o = impl.__get__(this,self_type).__call__();
Class c = o.getClass();
if (c != PyInteger.class && c != PyBoolean.class) {
throw Py.TypeError(String.format("__nonzero__ should return bool or int, returned %s",
self_type.getName()));
}
return o.__nonzero__();
}
public boolean __contains__(PyObject o) {
PyType self_type = getType();
PyObject impl = self_type.lookup("__contains__");
if (impl == null)
return super.__contains__(o);
return impl.__get__(this,self_type).__call__(o).__nonzero__();
}
public int __len__() {
PyType self_type = getType();
PyObject impl = self_type.lookup("__len__");
if (impl != null) {
PyObject res = impl.__get__(this,self_type).__call__();
if (res instanceof PyInteger)
return ((PyInteger)res).getValue();
throw Py.TypeError("__len__ should return a int");
}
return super.__len__();
}
public PyObject __iter__() {
PyType self_type = getType();
PyObject impl = self_type.lookup("__iter__");
if (impl != null)
return impl.__get__(this,self_type).__call__();
impl = self_type.lookup("__getitem__");
if (impl == null)
return super.__iter__();
return new PySequenceIter(this);
}
public PyObject __iternext__() {
PyType self_type = getType();
PyObject impl = self_type.lookup("next");
if (impl != null) {
try {
return impl.__get__(this,self_type).__call__();
} catch (PyException exc) {
if (exc.match(Py.StopIteration))
return null;
throw exc;
}
}
return super.__iternext__(); // ???
}
public PyObject __finditem__(PyObject key) { // ???
PyType self_type = getType();
PyObject impl = self_type.lookup("__getitem__");
if (impl != null)
try {
return impl.__get__(this,self_type).__call__(key);
} catch (PyException exc) {
if (exc.match(Py.LookupError))
return null;
throw exc;
}
return super.__finditem__(key);
}
public PyObject __finditem__(int key) {
PyType self_type = getType();
PyObject impl = self_type.lookup("__getitem__");
if (impl != null)
try {
return impl.__get__(this,self_type).__call__(new PyInteger(key));
} catch (PyException exc) {
if (exc.match(Py.LookupError))
return null;
throw exc;
}
return super.__finditem__(key);
}
public PyObject __getitem__(PyObject key) {
// Same as __finditem__, without swallowing LookupErrors. This allows
// __getitem__ implementations written in Python to raise custom
// exceptions (such as subclasses of KeyError).
//
// We are forced to duplicate the code, instead of defining __finditem__
// in terms of __getitem__. That's because PyObject defines __getitem__
// in terms of __finditem__. Therefore, we would end with an infinite
// loop when self_type.lookup("__getitem__") returns null:
//
// __getitem__ -> super.__getitem__ -> __finditem__ -> __getitem__
//
// By duplicating the (short) lookup and call code, we are safe, because
// the call chains will be:
//
// __finditem__ -> super.__finditem__
//
// __getitem__ -> super.__getitem__ -> __finditem__ -> super.__finditem__
PyType self_type=getType();
PyObject impl=self_type.lookup("__getitem__");
if (impl!=null)
return impl.__get__(this,self_type).__call__(key);
return super.__getitem__(key);
}
public void __setitem__(PyObject key, PyObject value) { // ???
PyType self_type = getType();
PyObject impl = self_type.lookup("__setitem__");
if (impl != null) {
impl.__get__(this,self_type).__call__(key,value);
return;
}
super.__setitem__(key,value);
}
public PyObject __getslice__(PyObject start, PyObject stop, PyObject step) { // ???
if (step != null) {
return __getitem__(new PySlice(start, stop, step));
}
PyType self_type=getType();
PyObject impl=self_type.lookup("__getslice__");
if (impl!=null) {
PyObject[] indices = PySlice.indices2(this, start, stop);
return impl.__get__(this,self_type).__call__(indices[0], indices[1]);
}
return super.__getslice__(start,stop,step);
}
public void __setslice__(PyObject start, PyObject stop, PyObject step, PyObject value) {
if (step != null) {
__setitem__(new PySlice(start, stop, step), value);
return;
}
PyType self_type=getType();
PyObject impl=self_type.lookup("__setslice__");
if (impl!=null) {
PyObject[] indices = PySlice.indices2(this, start, stop);
impl.__get__(this,self_type).__call__(indices[0], indices[1], value);
return;
}
super.__setslice__(start,stop,step,value);
}
public void __delslice__(PyObject start,PyObject stop,PyObject step) {
if (step != null) {
__delitem__(new PySlice(start, stop, step));
return;
}
PyType self_type=getType();
PyObject impl=self_type.lookup("__delslice__");
if (impl!=null) {
PyObject[] indices = PySlice.indices2(this, start, stop);
impl.__get__(this,self_type).__call__(indices[0], indices[1]);
return;
}
super.__delslice__(start,stop,step);
}
public void __delitem__(PyObject key) { // ???
PyType self_type = getType();
PyObject impl = self_type.lookup("__delitem__");
if (impl != null) {
impl.__get__(this,self_type).__call__(key);
return;
}
super.__delitem__(key);
}
public PyObject __call__(PyObject args[], String keywords[]) {
ThreadState ts = Py.getThreadState();
if (ts.recursion_depth++ > ts.systemState.getrecursionlimit())
throw Py.RuntimeError("maximum __call__ recursion depth exceeded");
try {
PyType self_type = getType();
PyObject impl = self_type.lookup("__call__");
if (impl != null)
return impl.__get__(this,self_type).__call__(args,keywords);
return super.__call__(args,keywords);
} finally {
--ts.recursion_depth;
}
}
public PyObject __findattr_ex__(String name) {
return Deriveds.__findattr_ex__(this, name);
}
public void __setattr__(String name,PyObject value) {
PyType self_type = getType();
PyObject impl = self_type.lookup("__setattr__");
if (impl != null) {
impl.__get__(this,self_type).__call__(PyString.fromInterned(name),value);
return;
}
super.__setattr__(name,value);
}
public void __delattr__(String name) {
PyType self_type = getType();
PyObject impl = self_type.lookup("__delattr__");
if (impl != null) {
impl.__get__(this,self_type).__call__(PyString.fromInterned(name));
return;
}
super.__delattr__(name);
}
public PyObject __get__(PyObject obj, PyObject type) {
PyType self_type = getType();
PyObject impl = self_type.lookup("__get__");
if (impl != null) {
if (obj == null) obj = Py.None;
if (type == null) type = Py.None;
return impl.__get__(this, self_type).__call__(obj, type);
}
return super.__get__(obj, type);
}
public void __set__(PyObject obj, PyObject value) {
PyType self_type = getType();
PyObject impl = self_type.lookup("__set__");
if (impl != null) {
impl.__get__(this, self_type).__call__(obj, value);
return;
}
super.__set__(obj, value);
}
public void __delete__(PyObject obj) {
PyType self_type = getType();
PyObject impl = self_type.lookup("__delete__");
if (impl != null) {
impl.__get__(this, self_type).__call__(obj);
return;
}
super.__delete__(obj);
}
public PyObject __pow__(PyObject other, PyObject modulo) {
PyType self_type=getType();
PyObject impl=self_type.lookup("__pow__");
if (impl!=null) {
PyObject res;
if (modulo == null) {
res=impl.__get__(this,self_type).__call__(other);
} else {
res=impl.__get__(this,self_type).__call__(other, modulo);
}
if (res==Py.NotImplemented)
return null;
return res;
}
return super.__pow__(other, modulo);
}
public void dispatch__init__(PyObject[] args, String[] keywords) {
Deriveds.dispatch__init__(this, args, keywords);
}
public PyObject __index__() {
PyType self_type=getType();
PyObject impl=self_type.lookup("__index__");
if (impl!=null) {
PyObject res=impl.__get__(this,self_type).__call__();
if (res instanceof PyInteger || res instanceof PyLong) {
return res;
}
throw Py.TypeError(String.format("__index__ returned non-(int,long) (type %s)",
res.getType().fastGetName()));
}
return super.__index__();
}
public Object __tojava__(Class c) {
// If we are not being asked by the "default" conversion to java, then
// we can provide this as the result, as long as it is a instance of the
// specified class. Without this, derived.__tojava__(PyObject.class)
// would broke. (And that's not pure speculation: PyReflectedFunction's
// ReflectedArgs asks for things like that).
if ((c != Object.class) && (c != Serializable.class) && (c.isInstance(this))) {
return this;
}
// Otherwise, we call the derived __tojava__, if it exists:
PyType self_type=getType();
PyObject impl=self_type.lookup("__tojava__");
if (impl!=null)
return impl.__get__(this,self_type).__call__(Py.java2py(c)).__tojava__(Object.class);
return super.__tojava__(c);
}
public Object __coerce_ex__(PyObject o) {
PyType self_type=getType();
PyObject impl=self_type.lookup("__coerce__");
if (impl!=null) {
PyObject res=impl.__get__(this,self_type).__call__(o);
if (res == Py.NotImplemented)
return Py.None;
if (!(res instanceof PyTuple))
throw Py.TypeError("__coerce__ didn't return a 2-tuple");
return ((PyTuple)res).getArray();
}
return super.__coerce_ex__(o);
}