src.org.python.core.PyInstance 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.
// Copyright (c) Corporation for National Research Initiatives
package org.python.core;
import org.python.expose.ExposedMethod;
import org.python.expose.ExposedNew;
import org.python.expose.ExposedType;
import org.python.expose.MethodType;
import org.python.core.finalization.FinalizablePyObject;
import org.python.core.finalization.FinalizeTrigger;
/**
* An instance of a classic Python class.
*/
@ExposedType(name = "instance", isBaseType = false)
public class PyInstance extends PyObject implements FinalizablePyObject, Traverseproc {
public static final PyType TYPE = PyType.fromClass(PyInstance.class);
private static JavaFunc __ensure_finalizer__Function;
// xxx doc, final name
public transient PyClass instclass;
/**
* The namespace of this instance. Contains all instance attributes.
*/
public PyObject __dict__;
public PyInstance() {
super(TYPE);
}
public PyInstance(PyClass iclass, PyObject dict) {
super(TYPE);
instclass = iclass;
if (dict == null) {
dict = new PyStringMap();
}
__dict__ = dict;
}
public PyInstance(PyClass iclass) {
this(iclass, null);
}
@ExposedNew
public static PyObject instance___new__(PyNewWrapper new_, boolean init, PyType subtype,
PyObject[] args, String[] keywords) {
ArgParser ap = new ArgParser("instance", args, keywords, "name", "bases", "dict");
PyClass klass = (PyClass) ap.getPyObjectByType(0, PyClass.TYPE);
PyObject dict = ap.getPyObject(1, Py.None);
if (dict == Py.None) {
dict = null;
} else if (!(dict instanceof AbstractDict)) {
throw Py.TypeError("instance() second arg must be dictionary or None");
}
return new PyInstance(klass, dict);
}
public PyClass fastGetClass() {
return instclass;
}
/* Override serialization behavior */
private void readObject(java.io.ObjectInputStream in)
throws java.io.IOException, ClassNotFoundException {
in.defaultReadObject();
String module = in.readUTF();
String name = in.readUTF();
/* Check for types and missing members here */
//System.out.println("module: "+module+", "+name);
PyObject mod = imp.importName(module.intern(), false);
PyClass pyc = (PyClass) mod.__getattr__(name.intern());
instclass = pyc;
}
private void writeObject(java.io.ObjectOutputStream out)
throws java.io.IOException {
out.defaultWriteObject();
PyObject name = instclass.__findattr__("__module__");
if (!(name instanceof PyString) || name == Py.None) {
throw Py.ValueError("Can't find module for class: " +
instclass.__name__);
}
out.writeUTF(name.toString());
name = instclass.__findattr__("__name__");
if (!(name instanceof PyString) || name == Py.None) {
throw Py.ValueError("Can't find module for class with no name");
}
out.writeUTF(name.toString());
}
@Override
public Object __tojava__(Class c) {
if (c.isInstance(this))
return this;
if (instclass.__tojava__ != null) {
// try {
PyObject ret = instclass.__tojava__.__call__(this, PyType.fromClass(c));
if (ret == Py.None)
return Py.NoConversion;
if (ret != this)
return ret.__tojava__(c);
/*} catch (PyException exc) {
System.err.println("Error in __tojava__ method");
Py.printException(exc);
}*/
}
return Py.NoConversion;
}
public void __init__(PyObject[] args, String[] keywords) {
// Invoke our own init function
PyObject init = instclass.lookup("__init__");
PyObject ret = null;
if (init != null) {
ret = init.__call__(this, args, keywords);
}
if (ret == null) {
if (args.length != 0) {
init = instclass.lookup("__init__");
if (init != null) {
init.__call__(this, args, keywords);
} else {
throw Py.TypeError("this constructor takes no arguments");
}
}
} else if (ret != Py.None) {
throw Py.TypeError("__init__() should return None");
}
}
@Override
public PyObject __findattr_ex__(String name) {
PyObject result = ifindlocal(name);
if (result != null) {
return result;
}
// it wasn't found in the instance, try the class
result = instclass.lookup(name);
if (result != null) {
return result.__get__(this, instclass);
}
return ifindfunction(name);
}
public static void ensureFinalizer(PyObject[] args, String[] kws) {
FinalizeTrigger.ensureFinalizer((PyInstance) args[0]);
}
private static JavaFunc makeFunction__ensure_finalizer__() {
try {
return new JavaFunc(
PyInstance.class.getMethod("ensureFinalizer",
PyObject[].class, String[].class));
} catch (Exception e) {return null;} //cannot happen
}
protected PyObject ifindlocal(String name) {
if (name == "__dict__") return __dict__;
if (name == "__class__") return instclass;
if (name == "__ensure_finalizer__") {
if (__ensure_finalizer__Function == null) {
__ensure_finalizer__Function = makeFunction__ensure_finalizer__();
}
return new PyMethod(__ensure_finalizer__Function, this, instclass);
}
if (__dict__ == null) return null;
return __dict__.__finditem__(name);
}
protected PyObject ifindclass(String name) {
return instclass.lookup(name);
}
protected PyObject ifindfunction(String name) {
PyObject getter = instclass.__getattr__;
if (getter == null)
return null;
return getter.__call__(this, new PyString(name));
}
@Override
public boolean isCallable() {
return __findattr__("__call__") != null;
}
@Override
public boolean isNumberType() {
return __findattr__("__int__") != null || __findattr__("__float__") != null;
}
@Override
public boolean isMappingType() {
return __findattr__("__getitem__") != null;
}
@Override
public boolean isSequenceType() {
return __findattr__("__getitem__") != null;
}
@Override
public boolean isIndex() {
return __findattr__("__index__") != null;
}
@Override
public PyObject invoke(String name) {
PyObject f = ifindlocal(name);
if (f == null) {
f = ifindclass(name);
if (f != null) {
if (f instanceof PyFunction) {
return f.__call__(this);
} else {
f = f.__get__(this, instclass);
}
}
}
if (f == null) f = ifindfunction(name);
if (f == null) noAttributeError(name);
return f.__call__();
}
@Override
public PyObject invoke(String name, PyObject arg1) {
PyObject f = ifindlocal(name);
if (f == null) {
f = ifindclass(name);
if (f != null) {
if (f instanceof PyFunction) {
return f.__call__(this, arg1);
} else {
f = f.__get__(this, instclass);
}
}
}
if (f == null) f = ifindfunction(name);
if (f == null) noAttributeError(name);
return f.__call__(arg1);
}
@Override
public PyObject invoke(String name, PyObject arg1, PyObject arg2) {
PyObject f = ifindlocal(name);
if (f == null) {
f = ifindclass(name);
if (f != null) {
if (f instanceof PyFunction) {
return f.__call__(this, arg1, arg2);
} else {
f = f.__get__(this, instclass);
}
}
}
if (f == null) f = ifindfunction(name);
if (f == null) noAttributeError(name);
return f.__call__(arg1, arg2);
}
@Override
public void noAttributeError(String name) {
throw Py.AttributeError(String.format("%.50s instance has no attribute '%.400s'",
instclass.__name__, name));
}
@Override
public void __setattr__(String name, PyObject value) {
instance___setattr__(name, value);
}
@ExposedMethod
final void instance___setattr__(String name, PyObject value) {
if (name == "__class__") {
if (value instanceof PyClass) {
instclass = (PyClass) value;
if (instclass.__del__ != null &&
!JyAttribute.hasAttr(this, JyAttribute.FINALIZE_TRIGGER_ATTR)) {
FinalizeTrigger.ensureFinalizer(this);
}
} else {
throw Py.TypeError("__class__ must be set to a class");
}
return;
} else if (name == "__dict__") {
__dict__ = value;
return;
}
PyObject setter = instclass.__setattr__;
if (setter != null) {
setter.__call__(this, new PyString(name), value);
} else {
__dict__.__setitem__(name, value);
}
if (name == "__del__" && !JyAttribute.hasAttr(this, JyAttribute.FINALIZE_TRIGGER_ATTR)) {
FinalizeTrigger.ensureFinalizer(this);
}
}
protected void noField(String name, PyObject value) {
__dict__.__setitem__(name, value);
}
protected void unassignableField(String name, PyObject value) {
__dict__.__setitem__(name, value);
}
@Override
public void __delattr__(String name) {
instance___delattr__(name);
}
@ExposedMethod
final void instance___delattr__(String name) {
PyObject deller = instclass.__delattr__;
if (deller != null) {
deller.__call__(this, new PyString(name));
} else {
try {
__dict__.__delitem__(name);
} catch (PyException exc) {
if (exc.match(Py.KeyError))
throw Py.AttributeError("class " + instclass.__name__ +
" has no attribute '" + name + "'");
}
;
}
}
public PyObject invoke_ex(String name, PyObject[] args, String[] keywords) {
PyObject meth = __findattr__(name);
if (meth == null)
return null;
return meth.__call__(args, keywords);
}
public PyObject invoke_ex(String name) {
PyObject meth = __findattr__(name);
if (meth == null)
return null;
return meth.__call__();
}
public PyObject invoke_ex(String name, PyObject arg1) {
PyObject meth = __findattr__(name);
if (meth == null)
return null;
return meth.__call__(arg1);
}
public PyObject invoke_ex(String name, PyObject arg1, PyObject arg2) {
PyObject meth = __findattr__(name);
if (meth == null)
return null;
return meth.__call__(arg1, arg2);
}
@Override
public PyObject __call__(PyObject args[], String keywords[]) {
return instance___call__(args, keywords);
}
@ExposedMethod
final PyObject instance___call__(PyObject args[], String keywords[]) {
return invoke("__call__", args, keywords);
}
@Override
public String toString() {
return __repr__().toString();
}
@Override
public PyString __repr__() {
return instance___repr__();
}
@ExposedMethod
final PyString instance___repr__() {
PyObject ret = invoke_ex("__repr__");
if (ret == null) {
return makeDefaultRepr();
}
if (!(ret instanceof PyString))
throw Py.TypeError("__repr__ method must return a string");
return (PyString) ret;
}
/**
* If a class doesn't define a __repr__ method of its own, the return
* value from this method is used.
*/
protected PyString makeDefaultRepr() {
PyObject mod = instclass.__dict__.__finditem__("__module__");
String modStr = (mod == null || !Py.isInstance(mod, PyString.TYPE)) ? "?" : mod.toString();
return new PyString(String.format("<%s.%s instance at %s>", modStr, instclass.__name__,
Py.idstr(this)));
}
@Override
public PyString __str__() {
return instance___str__();
}
@ExposedMethod
final PyString instance___str__() {
PyObject ret = invoke_ex("__str__");
if (ret == null)
return __repr__();
if (!(ret instanceof PyString))
throw Py.TypeError("__str__ method must return a string");
return (PyString) ret;
}
@Override
public PyUnicode __unicode__() {
return instance___unicode__();
}
@ExposedMethod
final PyUnicode instance___unicode__() {
PyObject ret = invoke_ex("__unicode__");
if (ret == null) {
return super.__unicode__();
} else if (ret instanceof PyUnicode) {
return (PyUnicode) ret;
} else if (ret instanceof PyString) {
return new PyUnicode((PyString) ret);
} else {
throw Py.TypeError("__unicode__ must return unicode or str");
}
}
@Override
public int hashCode() {
PyObject ret;
ret = invoke_ex("__hash__");
if (ret == null) {
if (__findattr__("__eq__") != null || __findattr__("__cmp__") != null) {
throw Py.TypeError("unhashable instance");
}
return super.hashCode();
}
if (ret instanceof PyInteger) {
return ((PyInteger) ret).getValue();
} else if (ret instanceof PyLong) {
return ((PyLong) ret).hashCode();
}
throw Py.TypeError("__hash__() must really return int" + ret.getType());
}
@Override
public int __cmp__(PyObject other) {
return instance___cmp__(other);
}
// special case: does all the work
@ExposedMethod
final int instance___cmp__(PyObject other) {
PyObject[] coerced = this._coerce(other);
PyObject v;
PyObject w;
PyObject ret = null;
if (coerced != null) {
v = coerced[0];
w = coerced[1];
if (!(v instanceof PyInstance) && !(w instanceof PyInstance)) {
return v._cmp(w);
}
} else {
v = this;
w = other;
}
if (v instanceof PyInstance) {
ret = ((PyInstance) v).invoke_ex("__cmp__", w);
if (ret != null) {
if (ret instanceof PyInteger) {
int result = ((PyInteger) ret).getValue();
return result < 0 ? -1 : result > 0 ? 1 : 0;
}
throw Py.TypeError("__cmp__() must return int");
}
}
if (w instanceof PyInstance) {
ret = ((PyInstance) w).invoke_ex("__cmp__", v);
if (ret != null) {
if (ret instanceof PyInteger) {
int result = ((PyInteger) ret).getValue();
return -(result < 0 ? -1 : result > 0 ? 1 : 0);
}
throw Py.TypeError("__cmp__() must return int");
}
}
return -2;
}
private PyObject invoke_ex_richcmp(String name, PyObject o) {
PyObject ret = invoke_ex(name, o);
if (ret == Py.NotImplemented)
return null;
return ret;
}
@Override
public PyObject __lt__(PyObject o) {
return instance___lt__(o);
}
@ExposedMethod
final PyObject instance___lt__(PyObject o) {
return invoke_ex_richcmp("__lt__", o);
}
@Override
public PyObject __le__(PyObject o) {
return instance___le__(o);
}
@ExposedMethod
final PyObject instance___le__(PyObject o) {
return invoke_ex_richcmp("__le__", o);
}
@Override
public PyObject __gt__(PyObject o) {
return instance___gt__(o);
}
@ExposedMethod
final PyObject instance___gt__(PyObject o) {
return invoke_ex_richcmp("__gt__", o);
}
@Override
public PyObject __ge__(PyObject o) {
return instance___ge__(o);
}
@ExposedMethod
final PyObject instance___ge__(PyObject o) {
return invoke_ex_richcmp("__ge__", o);
}
@Override
public PyObject __eq__(PyObject o) {
return instance___eq__(o);
}
@ExposedMethod
final PyObject instance___eq__(PyObject o) {
return invoke_ex_richcmp("__eq__", o);
}
@Override
public PyObject __ne__(PyObject o) {
return instance___ne__(o);
}
@ExposedMethod
final PyObject instance___ne__(PyObject o) {
return invoke_ex_richcmp("__ne__", o);
}
@Override
public boolean __nonzero__() {
return instance___nonzero__();
}
@ExposedMethod
final boolean instance___nonzero__() {
PyObject meth = null;
try {
meth = __findattr__("__nonzero__");
} catch (PyException exc) {
}
if (meth == null) {
try {
meth = __findattr__("__len__");
} catch (PyException exc) {
}
if (meth == null) {
return true;
}
}
PyObject ret = meth.__call__();
return ret.__nonzero__();
}
@Override
public int __len__() {
return instance___len__();
}
@ExposedMethod
final int instance___len__() {
PyObject ret = invoke("__len__");
if (ret instanceof PyInteger)
return ((PyInteger) ret).getValue();
throw Py.TypeError("__len__() should return an int");
}
@Override
public PyObject __finditem__(int key) {
return __finditem__(new PyInteger(key));
}
private PyObject trySlice(String name, PyObject start, PyObject stop) {
return trySlice(name, start, stop, null);
}
private PyObject trySlice(String name, PyObject start, PyObject stop, PyObject extraArg) {
PyObject func = __findattr__(name);
if (func == null) {
return null;
}
PyObject[] indices = PySlice.indices2(this, start, stop);
start = indices[0];
stop = indices[1];
if (extraArg == null) {
return func.__call__(start, stop);
} else {
return func.__call__(start, stop, extraArg);
}
}
@Override
public PyObject __finditem__(PyObject key) {
try {
return invoke("__getitem__", key);
} catch (PyException e) {
if (e.match(Py.IndexError))
return null;
if (e.match(Py.KeyError))
return null;
throw e;
}
}
@Override
public PyObject __getitem__(PyObject key) {
return instance___getitem__(key);
}
@ExposedMethod
final PyObject instance___getitem__(PyObject key) {
return invoke("__getitem__", key);
}
@Override
public void __setitem__(PyObject key, PyObject value) {
instance___setitem__(key, value);
}
@ExposedMethod
final void instance___setitem__(PyObject key, PyObject value) {
invoke("__setitem__", key, value);
}
@Override
public void __delitem__(PyObject key) {
instance___delitem__(key);
}
@ExposedMethod
final void instance___delitem__(PyObject key) {
invoke("__delitem__", key);
}
@Override
public PyObject __getslice__(PyObject start, PyObject stop, PyObject step) {
return instance___getslice__(start, stop, step);
}
@ExposedMethod
final PyObject instance___getslice__(PyObject start, PyObject stop, PyObject step) {
if (step != null) {
return __getitem__(new PySlice(start, stop, step));
}
PyObject ret = trySlice("__getslice__", start, stop);
if (ret != null) {
return ret;
}
return super.__getslice__(start, stop, step);
}
@Override
public void __setslice__(PyObject start, PyObject stop, PyObject step, PyObject value) {
instance___setslice__(start, stop, step, value);
}
@ExposedMethod
final void instance___setslice__(PyObject start, PyObject stop, PyObject step, PyObject value) {
if (step != null) {
__setitem__(new PySlice(start, stop, step), value);
} else if (trySlice("__setslice__", start, stop, value) == null) {
super.__setslice__(start, stop, step, value);
}
}
@Override
public void __delslice__(PyObject start, PyObject stop, PyObject step) {
instance___delslice__(start, stop, step);
}
@ExposedMethod
final void instance___delslice__(PyObject start, PyObject stop, PyObject step) {
if (step != null) {
__delitem__(new PySlice(start, stop, step));
} else if (trySlice("__delslice__", start, stop) == null) {
super.__delslice__(start, stop, step);
}
}
@Override
public PyObject __iter__() {
return instance___iter__();
}
@ExposedMethod
final PyObject instance___iter__() {
PyObject func = __findattr__("__iter__");
if (func != null)
return func.__call__();
func = __findattr__("__getitem__");
if (func == null) {
return super.__iter__();
}
return new PySequenceIter(this);
}
@Override
public PyObject __iternext__() {
PyObject func = __findattr__("next");
if (func != null) {
try {
return func.__call__();
} catch (PyException exc) {
if (exc.match(Py.StopIteration))
return null;
throw exc;
}
}
throw Py.TypeError("instance has no next() method");
}
@Override
public boolean __contains__(PyObject o) {
return instance___contains__(o);
}
@ExposedMethod
final boolean instance___contains__(PyObject o) {
PyObject func = __findattr__("__contains__");
if (func == null)
return super.__contains__(o);
PyObject ret = func.__call__(o);
return ret.__nonzero__();
}
@Override
public Object __coerce_ex__(PyObject o) {
PyObject ret = invoke_ex("__coerce__", o);
if (ret == null || ret == Py.None)
return ret;
if (!(ret instanceof PyTuple))
throw Py.TypeError("coercion should return None or 2-tuple");
return ((PyTuple) ret).getArray();
}
@Override
public PyObject __index__() {
return instance___index__();
}
/**
* Implements the __index__ method by looking it up
* in the instance's dictionary and calling it if it is found.
*/
@ExposedMethod
final PyObject instance___index__() {
PyObject ret;
try {
ret = invoke("__index__");
} catch (PyException pye) {
if (!pye.match(Py.AttributeError)) {
throw pye;
}
throw Py.TypeError("object cannot be interpreted as an index");
}
if (ret instanceof PyInteger || ret instanceof PyLong) {
return ret;
}
throw Py.TypeError(String.format("__index__ returned non-(int,long) (type %s)",
ret.getType().fastGetName()));
}
@Override
public PyObject __format__(PyObject formatSpec) {
return instance___format__(formatSpec);
}
@ExposedMethod
final PyObject instance___format__(PyObject formatSpec) {
PyObject func = __findattr__("__format__");
if (func == null) {
return super.__format__(formatSpec);
}
return func.__call__(formatSpec);
}
// Generated by make_binops.py
// Unary ops
@Override
public PyString __hex__() {
return instance___hex__();
}
/**
* Implements the __hex__ method by looking it up
* in the instance's dictionary and calling it if it is found.
*/
@ExposedMethod
final PyString instance___hex__() {
PyObject ret = invoke("__hex__");
if (ret instanceof PyString)
return (PyString) ret;
throw Py.TypeError("__hex__() should return a string");
}
@Override
public PyString __oct__() {
return instance___oct__();
}
/**
* Implements the __oct__ method by looking it up
* in the instance's dictionary and calling it if it is found.
*/
@ExposedMethod
final PyString instance___oct__() {
PyObject ret = invoke("__oct__");
if (ret instanceof PyString)
return (PyString) ret;
throw Py.TypeError("__oct__() should return a string");
}
@Override
public PyObject __int__() {
return instance___int__();
}
/**
* Implements the __int__ method by looking it up
* in the instance's dictionary and calling it if it is found.
*/
@ExposedMethod
final PyObject instance___int__() {
PyObject ret = invoke("__int__");
if (ret instanceof PyLong || ret instanceof PyInteger)
return ret;
throw Py.TypeError("__int__() should return a int");
}
@Override
public PyFloat __float__() {
return instance___float__();
}
/**
* Implements the __float__ method by looking it up
* in the instance's dictionary and calling it if it is found.
*/
@ExposedMethod
final PyFloat instance___float__() {
PyObject ret = invoke("__float__");
if (ret instanceof PyFloat)
return (PyFloat) ret;
throw Py.TypeError("__float__() should return a float");
}
@Override
public PyObject __long__() {
return instance___long__();
}
/**
* Implements the __long__ method by looking it up
* in the instance's dictionary and calling it if it is found.
*/
@ExposedMethod
final PyObject instance___long__() {
PyObject ret = invoke("__long__");
if (ret instanceof PyLong || ret instanceof PyInteger)
return ret;
throw Py.TypeError("__long__() should return a long");
}
@Override
public PyComplex __complex__() {
return instance___complex__();
}
/**
* Implements the __complex__ method by looking it up
* in the instance's dictionary and calling it if it is found.
*/
@ExposedMethod
final PyComplex instance___complex__() {
PyObject ret = invoke("__complex__");
if (ret instanceof PyComplex)
return (PyComplex) ret;
throw Py.TypeError("__complex__() should return a complex");
}
@Override
public PyObject __pos__() {
return instance___pos__();
}
/**
* Implements the __pos__ method by looking it up
* in the instance's dictionary and calling it if it is found.
*/
@ExposedMethod
public PyObject instance___pos__() {
return invoke("__pos__");
}
@Override
public PyObject __neg__() {
return instance___neg__();
}
/**
* Implements the __neg__ method by looking it up
* in the instance's dictionary and calling it if it is found.
*/
@ExposedMethod
public PyObject instance___neg__() {
return invoke("__neg__");
}
@Override
public PyObject __abs__() {
return instance___abs__();
}
/**
* Implements the __abs__ method by looking it up
* in the instance's dictionary and calling it if it is found.
*/
@ExposedMethod
public PyObject instance___abs__() {
return invoke("__abs__");
}
@Override
public PyObject __invert__() {
return instance___invert__();
}
/**
* Implements the __invert__ method by looking it up
* in the instance's dictionary and calling it if it is found.
*/
@ExposedMethod
public PyObject instance___invert__() {
return invoke("__invert__");
}
// Binary ops
@Override
public PyObject __add__(PyObject o) {
return instance___add__(o);
}
/**
* Implements the __add__ method by looking it up
* in the instance's dictionary and calling it if it is found.
*/
@ExposedMethod(type = MethodType.BINARY)
public PyObject instance___add__(PyObject o) {
Object ctmp = __coerce_ex__(o);
if (ctmp == null || ctmp == Py.None)
return invoke_ex("__add__", o);
else {
PyObject o1 = ((PyObject[]) ctmp)[0];
PyObject o2 = ((PyObject[]) ctmp)[1];
if (this == o1) {
// Prevent recursion if __coerce__ return self
return invoke_ex("__add__", o2);
} else {
return o1._add(o2);
}
}
}
@Override
public PyObject __radd__(PyObject o) {
return instance___radd__(o);
}
/**
* Implements the __radd__ method by looking it up
* in the instance's dictionary and calling it if it is found.
*/
@ExposedMethod(type = MethodType.BINARY)
public PyObject instance___radd__(PyObject o) {
Object ctmp = __coerce_ex__(o);
if (ctmp == null || ctmp == Py.None)
return invoke_ex("__radd__", o);
else {
PyObject o1 = ((PyObject[]) ctmp)[0];
PyObject o2 = ((PyObject[]) ctmp)[1];
if (this == o1) {
// Prevent recursion if __coerce__ return self
return invoke_ex("__radd__", o2);
} else {
return o2._add(o1);
}
}
}
@Override
public PyObject __iadd__(PyObject o) {
return instance___iadd__(o);
}
/**
* Implements the __iadd__ method by looking it up
* in the instance's dictionary and calling it if it is found.
*/
@ExposedMethod(type = MethodType.BINARY)
public PyObject instance___iadd__(PyObject o) {
PyObject ret = invoke_ex("__iadd__", o);
if (ret != null)
return ret;
return super.__iadd__(o);
}
@Override
public PyObject __sub__(PyObject o) {
return instance___sub__(o);
}
/**
* Implements the __sub__ method by looking it up
* in the instance's dictionary and calling it if it is found.
*/
@ExposedMethod(type = MethodType.BINARY)
public PyObject instance___sub__(PyObject o) {
Object ctmp = __coerce_ex__(o);
if (ctmp == null || ctmp == Py.None)
return invoke_ex("__sub__", o);
else {
PyObject o1 = ((PyObject[]) ctmp)[0];
PyObject o2 = ((PyObject[]) ctmp)[1];
if (this == o1) {
// Prevent recursion if __coerce__ return self
return invoke_ex("__sub__", o2);
} else {
return o1._sub(o2);
}
}
}
@Override
public PyObject __rsub__(PyObject o) {
return instance___rsub__(o);
}
/**
* Implements the __rsub__ method by looking it up
* in the instance's dictionary and calling it if it is found.
*/
@ExposedMethod(type = MethodType.BINARY)
public PyObject instance___rsub__(PyObject o) {
Object ctmp = __coerce_ex__(o);
if (ctmp == null || ctmp == Py.None)
return invoke_ex("__rsub__", o);
else {
PyObject o1 = ((PyObject[]) ctmp)[0];
PyObject o2 = ((PyObject[]) ctmp)[1];
if (this == o1) {
// Prevent recursion if __coerce__ return self
return invoke_ex("__rsub__", o2);
} else {
return o2._sub(o1);
}
}
}
@Override
public PyObject __isub__(PyObject o) {
return instance___isub__(o);
}
/**
* Implements the __isub__ method by looking it up
* in the instance's dictionary and calling it if it is found.
*/
@ExposedMethod(type = MethodType.BINARY)
public PyObject instance___isub__(PyObject o) {
PyObject ret = invoke_ex("__isub__", o);
if (ret != null)
return ret;
return super.__isub__(o);
}
@Override
public PyObject __mul__(PyObject o) {
return instance___mul__(o);
}
/**
* Implements the __mul__ method by looking it up
* in the instance's dictionary and calling it if it is found.
*/
@ExposedMethod(type = MethodType.BINARY)
public PyObject instance___mul__(PyObject o) {
Object ctmp = __coerce_ex__(o);
if (ctmp == null || ctmp == Py.None)
return invoke_ex("__mul__", o);
else {
PyObject o1 = ((PyObject[]) ctmp)[0];
PyObject o2 = ((PyObject[]) ctmp)[1];
if (this == o1) {
// Prevent recursion if __coerce__ return self
return invoke_ex("__mul__", o2);
} else {
return o1._mul(o2);
}
}
}
@Override
public PyObject __rmul__(PyObject o) {
return instance___rmul__(o);
}
/**
* Implements the __rmul__ method by looking it up
* in the instance's dictionary and calling it if it is found.
*/
@ExposedMethod(type = MethodType.BINARY)
public PyObject instance___rmul__(PyObject o) {
Object ctmp = __coerce_ex__(o);
if (ctmp == null || ctmp == Py.None)
return invoke_ex("__rmul__", o);
else {
PyObject o1 = ((PyObject[]) ctmp)[0];
PyObject o2 = ((PyObject[]) ctmp)[1];
if (this == o1) {
// Prevent recursion if __coerce__ return self
return invoke_ex("__rmul__", o2);
} else {
return o2._mul(o1);
}
}
}
@Override
public PyObject __imul__(PyObject o) {
return instance___imul__(o);
}
/**
* Implements the __imul__ method by looking it up
* in the instance's dictionary and calling it if it is found.
*/
@ExposedMethod(type = MethodType.BINARY)
public PyObject instance___imul__(PyObject o) {
PyObject ret = invoke_ex("__imul__", o);
if (ret != null)
return ret;
return super.__imul__(o);
}
@Override
public PyObject __div__(PyObject o) {
return instance___div__(o);
}
/**
* Implements the __div__ method by looking it up
* in the instance's dictionary and calling it if it is found.
*/
@ExposedMethod(type = MethodType.BINARY)
public PyObject instance___div__(PyObject o) {
Object ctmp = __coerce_ex__(o);
if (ctmp == null || ctmp == Py.None)
return invoke_ex("__div__", o);
else {
PyObject o1 = ((PyObject[]) ctmp)[0];
PyObject o2 = ((PyObject[]) ctmp)[1];
if (this == o1) {
// Prevent recursion if __coerce__ return self
return invoke_ex("__div__", o2);
} else {
return o1._div(o2);
}
}
}
@Override
public PyObject __rdiv__(PyObject o) {
return instance___rdiv__(o);
}
/**
* Implements the __rdiv__ method by looking it up
* in the instance's dictionary and calling it if it is found.
*/
@ExposedMethod(type = MethodType.BINARY)
public PyObject instance___rdiv__(PyObject o) {
Object ctmp = __coerce_ex__(o);
if (ctmp == null || ctmp == Py.None)
return invoke_ex("__rdiv__", o);
else {
PyObject o1 = ((PyObject[]) ctmp)[0];
PyObject o2 = ((PyObject[]) ctmp)[1];
if (this == o1) {
// Prevent recursion if __coerce__ return self
return invoke_ex("__rdiv__", o2);
} else {
return o2._div(o1);
}
}
}
@Override
public PyObject __idiv__(PyObject o) {
return instance___idiv__(o);
}
/**
* Implements the __idiv__ method by looking it up
* in the instance's dictionary and calling it if it is found.
*/
@ExposedMethod(type = MethodType.BINARY)
public PyObject instance___idiv__(PyObject o) {
PyObject ret = invoke_ex("__idiv__", o);
if (ret != null)
return ret;
return super.__idiv__(o);
}
@Override
public PyObject __floordiv__(PyObject o) {
return instance___floordiv__(o);
}
/**
* Implements the __floordiv__ method by looking it up
* in the instance's dictionary and calling it if it is found.
*/
@ExposedMethod(type = MethodType.BINARY)
public PyObject instance___floordiv__(PyObject o) {
Object ctmp = __coerce_ex__(o);
if (ctmp == null || ctmp == Py.None)
return invoke_ex("__floordiv__", o);
else {
PyObject o1 = ((PyObject[]) ctmp)[0];
PyObject o2 = ((PyObject[]) ctmp)[1];
if (this == o1) {
// Prevent recursion if __coerce__ return self
return invoke_ex("__floordiv__", o2);
} else {
return o1._floordiv(o2);
}
}
}
@Override
public PyObject __rfloordiv__(PyObject o) {
return instance___rfloordiv__(o);
}
/**
* Implements the __rfloordiv__ method by looking it up
* in the instance's dictionary and calling it if it is found.
*/
@ExposedMethod(type = MethodType.BINARY)
public PyObject instance___rfloordiv__(PyObject o) {
Object ctmp = __coerce_ex__(o);
if (ctmp == null || ctmp == Py.None)
return invoke_ex("__rfloordiv__", o);
else {
PyObject o1 = ((PyObject[]) ctmp)[0];
PyObject o2 = ((PyObject[]) ctmp)[1];
if (this == o1) {
// Prevent recursion if __coerce__ return self
return invoke_ex("__rfloordiv__", o2);
} else {
return o2._floordiv(o1);
}
}
}
@Override
public PyObject __ifloordiv__(PyObject o) {
return instance___ifloordiv__(o);
}
/**
* Implements the __ifloordiv__ method by looking it up
* in the instance's dictionary and calling it if it is found.
*/
@ExposedMethod(type = MethodType.BINARY)
public PyObject instance___ifloordiv__(PyObject o) {
PyObject ret = invoke_ex("__ifloordiv__", o);
if (ret != null)
return ret;
return super.__ifloordiv__(o);
}
@Override
public PyObject __truediv__(PyObject o) {
return instance___truediv__(o);
}
/**
* Implements the __truediv__ method by looking it up
* in the instance's dictionary and calling it if it is found.
*/
@ExposedMethod(type = MethodType.BINARY)
public PyObject instance___truediv__(PyObject o) {
Object ctmp = __coerce_ex__(o);
if (ctmp == null || ctmp == Py.None)
return invoke_ex("__truediv__", o);
else {
PyObject o1 = ((PyObject[]) ctmp)[0];
PyObject o2 = ((PyObject[]) ctmp)[1];
if (this == o1) {
// Prevent recursion if __coerce__ return self
return invoke_ex("__truediv__", o2);
} else {
return o1._truediv(o2);
}
}
}
@Override
public PyObject __rtruediv__(PyObject o) {
return instance___rtruediv__(o);
}
/**
* Implements the __rtruediv__ method by looking it up
* in the instance's dictionary and calling it if it is found.
*/
@ExposedMethod(type = MethodType.BINARY)
public PyObject instance___rtruediv__(PyObject o) {
Object ctmp = __coerce_ex__(o);
if (ctmp == null || ctmp == Py.None)
return invoke_ex("__rtruediv__", o);
else {
PyObject o1 = ((PyObject[]) ctmp)[0];
PyObject o2 = ((PyObject[]) ctmp)[1];
if (this == o1) {
// Prevent recursion if __coerce__ return self
return invoke_ex("__rtruediv__", o2);
} else {
return o2._truediv(o1);
}
}
}
@Override
public PyObject __itruediv__(PyObject o) {
return instance___itruediv__(o);
}
/**
* Implements the __itruediv__ method by looking it up
* in the instance's dictionary and calling it if it is found.
*/
@ExposedMethod(type = MethodType.BINARY)
public PyObject instance___itruediv__(PyObject o) {
PyObject ret = invoke_ex("__itruediv__", o);
if (ret != null)
return ret;
return super.__itruediv__(o);
}
@Override
public PyObject __mod__(PyObject o) {
return instance___mod__(o);
}
/**
* Implements the __mod__ method by looking it up
* in the instance's dictionary and calling it if it is found.
*/
@ExposedMethod(type = MethodType.BINARY)
public PyObject instance___mod__(PyObject o) {
Object ctmp = __coerce_ex__(o);
if (ctmp == null || ctmp == Py.None)
return invoke_ex("__mod__", o);
else {
PyObject o1 = ((PyObject[]) ctmp)[0];
PyObject o2 = ((PyObject[]) ctmp)[1];
if (this == o1) {
// Prevent recursion if __coerce__ return self
return invoke_ex("__mod__", o2);
} else {
return o1._mod(o2);
}
}
}
@Override
public PyObject __rmod__(PyObject o) {
return instance___rmod__(o);
}
/**
* Implements the __rmod__ method by looking it up
* in the instance's dictionary and calling it if it is found.
*/
@ExposedMethod(type = MethodType.BINARY)
public PyObject instance___rmod__(PyObject o) {
Object ctmp = __coerce_ex__(o);
if (ctmp == null || ctmp == Py.None)
return invoke_ex("__rmod__", o);
else {
PyObject o1 = ((PyObject[]) ctmp)[0];
PyObject o2 = ((PyObject[]) ctmp)[1];
if (this == o1) {
// Prevent recursion if __coerce__ return self
return invoke_ex("__rmod__", o2);
} else {
return o2._mod(o1);
}
}
}
@Override
public PyObject __imod__(PyObject o) {
return instance___imod__(o);
}
/**
* Implements the __imod__ method by looking it up
* in the instance's dictionary and calling it if it is found.
*/
@ExposedMethod(type = MethodType.BINARY)
public PyObject instance___imod__(PyObject o) {
PyObject ret = invoke_ex("__imod__", o);
if (ret != null)
return ret;
return super.__imod__(o);
}
@Override
public PyObject __divmod__(PyObject o) {
return instance___divmod__(o);
}
/**
* Implements the __divmod__ method by looking it up
* in the instance's dictionary and calling it if it is found.
*/
@ExposedMethod(type = MethodType.BINARY)
public PyObject instance___divmod__(PyObject o) {
Object ctmp = __coerce_ex__(o);
if (ctmp == null || ctmp == Py.None)
return invoke_ex("__divmod__", o);
else {
PyObject o1 = ((PyObject[]) ctmp)[0];
PyObject o2 = ((PyObject[]) ctmp)[1];
if (this == o1) {
// Prevent recursion if __coerce__ return self
return invoke_ex("__divmod__", o2);
} else {
return o1._divmod(o2);
}
}
}
@Override
public PyObject __rdivmod__(PyObject o) {
return instance___rdivmod__(o);
}
/**
* Implements the __rdivmod__ method by looking it up
* in the instance's dictionary and calling it if it is found.
*/
@ExposedMethod(type = MethodType.BINARY)
public PyObject instance___rdivmod__(PyObject o) {
Object ctmp = __coerce_ex__(o);
if (ctmp == null || ctmp == Py.None)
return invoke_ex("__rdivmod__", o);
else {
PyObject o1 = ((PyObject[]) ctmp)[0];
PyObject o2 = ((PyObject[]) ctmp)[1];
if (this == o1) {
// Prevent recursion if __coerce__ return self
return invoke_ex("__rdivmod__", o2);
} else {
return o2._divmod(o1);
}
}
}
@Override
public PyObject __pow__(PyObject o) {
return instance___pow__(o);
}
/**
* Implements the __pow__ method by looking it up
* in the instance's dictionary and calling it if it is found.
*/
@ExposedMethod(type = MethodType.BINARY)
public PyObject instance___pow__(PyObject o) {
Object ctmp = __coerce_ex__(o);
if (ctmp == null || ctmp == Py.None)
return invoke_ex("__pow__", o);
else {
PyObject o1 = ((PyObject[]) ctmp)[0];
PyObject o2 = ((PyObject[]) ctmp)[1];
if (this == o1) {
// Prevent recursion if __coerce__ return self
return invoke_ex("__pow__", o2);
} else {
return o1._pow(o2);
}
}
}
@Override
public PyObject __rpow__(PyObject o) {
return instance___rpow__(o);
}
/**
* Implements the __rpow__ method by looking it up
* in the instance's dictionary and calling it if it is found.
*/
@ExposedMethod(type = MethodType.BINARY)
public PyObject instance___rpow__(PyObject o) {
Object ctmp = __coerce_ex__(o);
if (ctmp == null || ctmp == Py.None)
return invoke_ex("__rpow__", o);
else {
PyObject o1 = ((PyObject[]) ctmp)[0];
PyObject o2 = ((PyObject[]) ctmp)[1];
if (this == o1) {
// Prevent recursion if __coerce__ return self
return invoke_ex("__rpow__", o2);
} else {
return o2._pow(o1);
}
}
}
@Override
public PyObject __ipow__(PyObject o) {
return instance___ipow__(o);
}
/**
* Implements the __ipow__ method by looking it up
* in the instance's dictionary and calling it if it is found.
*/
@ExposedMethod(type = MethodType.BINARY)
public PyObject instance___ipow__(PyObject o) {
PyObject ret = invoke_ex("__ipow__", o);
if (ret != null)
return ret;
return super.__ipow__(o);
}
@Override
public PyObject __lshift__(PyObject o) {
return instance___lshift__(o);
}
/**
* Implements the __lshift__ method by looking it up
* in the instance's dictionary and calling it if it is found.
*/
@ExposedMethod(type = MethodType.BINARY)
public PyObject instance___lshift__(PyObject o) {
Object ctmp = __coerce_ex__(o);
if (ctmp == null || ctmp == Py.None)
return invoke_ex("__lshift__", o);
else {
PyObject o1 = ((PyObject[]) ctmp)[0];
PyObject o2 = ((PyObject[]) ctmp)[1];
if (this == o1) {
// Prevent recursion if __coerce__ return self
return invoke_ex("__lshift__", o2);
} else {
return o1._lshift(o2);
}
}
}
@Override
public PyObject __rlshift__(PyObject o) {
return instance___rlshift__(o);
}
/**
* Implements the __rlshift__ method by looking it up
* in the instance's dictionary and calling it if it is found.
*/
@ExposedMethod(type = MethodType.BINARY)
public PyObject instance___rlshift__(PyObject o) {
Object ctmp = __coerce_ex__(o);
if (ctmp == null || ctmp == Py.None)
return invoke_ex("__rlshift__", o);
else {
PyObject o1 = ((PyObject[]) ctmp)[0];
PyObject o2 = ((PyObject[]) ctmp)[1];
if (this == o1) {
// Prevent recursion if __coerce__ return self
return invoke_ex("__rlshift__", o2);
} else {
return o2._lshift(o1);
}
}
}
@Override
public PyObject __ilshift__(PyObject o) {
return instance___ilshift__(o);
}
/**
* Implements the __ilshift__ method by looking it up
* in the instance's dictionary and calling it if it is found.
*/
@ExposedMethod(type = MethodType.BINARY)
public PyObject instance___ilshift__(PyObject o) {
PyObject ret = invoke_ex("__ilshift__", o);
if (ret != null)
return ret;
return super.__ilshift__(o);
}
@Override
public PyObject __rshift__(PyObject o) {
return instance___rshift__(o);
}
/**
* Implements the __rshift__ method by looking it up
* in the instance's dictionary and calling it if it is found.
*/
@ExposedMethod(type = MethodType.BINARY)
public PyObject instance___rshift__(PyObject o) {
Object ctmp = __coerce_ex__(o);
if (ctmp == null || ctmp == Py.None)
return invoke_ex("__rshift__", o);
else {
PyObject o1 = ((PyObject[]) ctmp)[0];
PyObject o2 = ((PyObject[]) ctmp)[1];
if (this == o1) {
// Prevent recursion if __coerce__ return self
return invoke_ex("__rshift__", o2);
} else {
return o1._rshift(o2);
}
}
}
@Override
public PyObject __rrshift__(PyObject o) {
return instance___rrshift__(o);
}
/**
* Implements the __rrshift__ method by looking it up
* in the instance's dictionary and calling it if it is found.
*/
@ExposedMethod(type = MethodType.BINARY)
public PyObject instance___rrshift__(PyObject o) {
Object ctmp = __coerce_ex__(o);
if (ctmp == null || ctmp == Py.None)
return invoke_ex("__rrshift__", o);
else {
PyObject o1 = ((PyObject[]) ctmp)[0];
PyObject o2 = ((PyObject[]) ctmp)[1];
if (this == o1) {
// Prevent recursion if __coerce__ return self
return invoke_ex("__rrshift__", o2);
} else {
return o2._rshift(o1);
}
}
}
@Override
public PyObject __irshift__(PyObject o) {
return instance___irshift__(o);
}
/**
* Implements the __irshift__ method by looking it up
* in the instance's dictionary and calling it if it is found.
*/
@ExposedMethod(type = MethodType.BINARY)
public PyObject instance___irshift__(PyObject o) {
PyObject ret = invoke_ex("__irshift__", o);
if (ret != null)
return ret;
return super.__irshift__(o);
}
@Override
public PyObject __and__(PyObject o) {
return instance___and__(o);
}
/**
* Implements the __and__ method by looking it up
* in the instance's dictionary and calling it if it is found.
*/
@ExposedMethod(type = MethodType.BINARY)
public PyObject instance___and__(PyObject o) {
Object ctmp = __coerce_ex__(o);
if (ctmp == null || ctmp == Py.None)
return invoke_ex("__and__", o);
else {
PyObject o1 = ((PyObject[]) ctmp)[0];
PyObject o2 = ((PyObject[]) ctmp)[1];
if (this == o1) {
// Prevent recursion if __coerce__ return self
return invoke_ex("__and__", o2);
} else {
return o1._and(o2);
}
}
}
@Override
public PyObject __rand__(PyObject o) {
return instance___rand__(o);
}
/**
* Implements the __rand__ method by looking it up
* in the instance's dictionary and calling it if it is found.
*/
@ExposedMethod(type = MethodType.BINARY)
public PyObject instance___rand__(PyObject o) {
Object ctmp = __coerce_ex__(o);
if (ctmp == null || ctmp == Py.None)
return invoke_ex("__rand__", o);
else {
PyObject o1 = ((PyObject[]) ctmp)[0];
PyObject o2 = ((PyObject[]) ctmp)[1];
if (this == o1) {
// Prevent recursion if __coerce__ return self
return invoke_ex("__rand__", o2);
} else {
return o2._and(o1);
}
}
}
@Override
public PyObject __iand__(PyObject o) {
return instance___iand__(o);
}
/**
* Implements the __iand__ method by looking it up
* in the instance's dictionary and calling it if it is found.
*/
@ExposedMethod(type = MethodType.BINARY)
public PyObject instance___iand__(PyObject o) {
PyObject ret = invoke_ex("__iand__", o);
if (ret != null)
return ret;
return super.__iand__(o);
}
@Override
public PyObject __or__(PyObject o) {
return instance___or__(o);
}
/**
* Implements the __or__ method by looking it up
* in the instance's dictionary and calling it if it is found.
*/
@ExposedMethod(type = MethodType.BINARY)
public PyObject instance___or__(PyObject o) {
Object ctmp = __coerce_ex__(o);
if (ctmp == null || ctmp == Py.None)
return invoke_ex("__or__", o);
else {
PyObject o1 = ((PyObject[]) ctmp)[0];
PyObject o2 = ((PyObject[]) ctmp)[1];
if (this == o1) {
// Prevent recursion if __coerce__ return self
return invoke_ex("__or__", o2);
} else {
return o1._or(o2);
}
}
}
@Override
public PyObject __ror__(PyObject o) {
return instance___ror__(o);
}
/**
* Implements the __ror__ method by looking it up
* in the instance's dictionary and calling it if it is found.
*/
@ExposedMethod(type = MethodType.BINARY)
public PyObject instance___ror__(PyObject o) {
Object ctmp = __coerce_ex__(o);
if (ctmp == null || ctmp == Py.None)
return invoke_ex("__ror__", o);
else {
PyObject o1 = ((PyObject[]) ctmp)[0];
PyObject o2 = ((PyObject[]) ctmp)[1];
if (this == o1) {
// Prevent recursion if __coerce__ return self
return invoke_ex("__ror__", o2);
} else {
return o2._or(o1);
}
}
}
@Override
public PyObject __ior__(PyObject o) {
return instance___ior__(o);
}
/**
* Implements the __ior__ method by looking it up
* in the instance's dictionary and calling it if it is found.
*/
@ExposedMethod(type = MethodType.BINARY)
public PyObject instance___ior__(PyObject o) {
PyObject ret = invoke_ex("__ior__", o);
if (ret != null)
return ret;
return super.__ior__(o);
}
@Override
public PyObject __xor__(PyObject o) {
return instance___xor__(o);
}
/**
* Implements the __xor__ method by looking it up
* in the instance's dictionary and calling it if it is found.
*/
@ExposedMethod(type = MethodType.BINARY)
public PyObject instance___xor__(PyObject o) {
Object ctmp = __coerce_ex__(o);
if (ctmp == null || ctmp == Py.None)
return invoke_ex("__xor__", o);
else {
PyObject o1 = ((PyObject[]) ctmp)[0];
PyObject o2 = ((PyObject[]) ctmp)[1];
if (this == o1) {
// Prevent recursion if __coerce__ return self
return invoke_ex("__xor__", o2);
} else {
return o1._xor(o2);
}
}
}
@Override
public PyObject __rxor__(PyObject o) {
return instance___rxor__(o);
}
/**
* Implements the __rxor__ method by looking it up
* in the instance's dictionary and calling it if it is found.
*/
@ExposedMethod(type = MethodType.BINARY)
public PyObject instance___rxor__(PyObject o) {
Object ctmp = __coerce_ex__(o);
if (ctmp == null || ctmp == Py.None)
return invoke_ex("__rxor__", o);
else {
PyObject o1 = ((PyObject[]) ctmp)[0];
PyObject o2 = ((PyObject[]) ctmp)[1];
if (this == o1) {
// Prevent recursion if __coerce__ return self
return invoke_ex("__rxor__", o2);
} else {
return o2._xor(o1);
}
}
}
@Override
public PyObject __ixor__(PyObject o) {
return instance___ixor__(o);
}
/**
* Implements the __ixor__ method by looking it up
* in the instance's dictionary and calling it if it is found.
*/
@ExposedMethod(type = MethodType.BINARY)
public PyObject instance___ixor__(PyObject o) {
PyObject ret = invoke_ex("__ixor__", o);
if (ret != null)
return ret;
return super.__ixor__(o);
}
@Override
public void __del__() {
try {
PyObject method = __findattr__("__del__");
if (method != null) {
method.__call__();
} else if (instclass.__del__ != null) {
instclass.__del__.__call__(this);
}
} catch (PyException exc) {
// Try to get the right method description.
PyObject method = instclass.__del__;
try {
method = __findattr__("__del__");
} catch (PyException e) {
// nothing we can do
}
Py.writeUnraisable(exc, method);
}
}
/* Traverseproc implementation */
@Override
public int traverse(Visitproc visit, Object arg) {
if (instclass != null) {
int retVal = visit.visit(instclass, arg);
if (retVal != 0) {
return retVal;
}
}
//__dict__ cannot be null
return visit.visit(__dict__, arg);
}
@Override
public boolean refersDirectlyTo(PyObject ob) {
return ob != null && (ob == instclass || ob == __dict__);
}
}