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-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.
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__
unary1: __dir__
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__ \
__format__
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[]) {
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);
}
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);
}