org.python.modules._io.PyIOBaseDerived Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of jython-slim Show documentation
Show all versions of jython-slim 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.
/* Generated file, do not modify. See jython/src/templates/gderived.py. */
package org.python.modules._io;
import java.io.Serializable;
import org.python.core.*;
import org.python.core.finalization.FinalizeTrigger;
import org.python.core.finalization.FinalizablePyObjectDerived;
public class PyIOBaseDerived extends PyIOBase implements Slotted,FinalizablePyObjectDerived,TraverseprocDerived {
public PyObject getSlot(int index) {
return slots[index];
}
public void setSlot(int index,PyObject value) {
slots[index]=value;
}
private PyObject[]slots;
public void __del_derived__() {
PyType self_type=getType();
PyObject impl=self_type.lookup("__del__");
if (impl!=null) {
impl.__get__(this,self_type).__call__();
}
}
public void __ensure_finalizer__() {
FinalizeTrigger.ensureFinalizer(this);
}
/* TraverseprocDerived implementation */
public int traverseDerived(Visitproc visit,Object arg) {
int retVal;
for(int i=0;i0?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__();
return res.asInt();
}
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);
//CPython does not support instance-acquired finalizers.
//So we don't check for __del__ here.
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) {
PyObject delegate=impl.__get__(this,self_type).__call__(Py.java2py(c));
if (delegate!=this)
return delegate.__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);
}
public PyObject __enter__() {
PyType self_type=getType();
PyObject impl=self_type.lookup("__enter__");
if (impl!=null)
return impl.__get__(this,self_type).__call__();
return super.__enter__();
}
public PyObject fileno() {
PyType self_type=getType();
PyObject impl=self_type.lookup("fileno");
if (impl!=null)
return impl.__get__(this,self_type).__call__();
return super.fileno();
}
// Hand-crafted in _io._IOBase.derived
public long seek(long pos,int whence) {
PyType self_type=getType();
PyObject impl=self_type.lookup("seek");
if (impl!=null) {
return impl.__get__(this,self_type).__call__(Py.newLong(pos),Py.newInteger(whence)).asLong();
} else {
return super.seek(pos,whence);
}
}
public long tell() {
PyType self_type=getType();
PyObject impl=self_type.lookup("tell");
if (impl!=null) {
return impl.__get__(this,self_type).__call__().asLong();
} else {
return super.tell();
}
}
public long truncate(long size) {
PyType self_type=getType();
PyObject impl=self_type.lookup("truncate");
if (impl!=null) {
return impl.__get__(this,self_type).__call__(Py.newLong(size)).asLong();
} else {
return super.truncate(size);
}
}
public long truncate() {
PyType self_type=getType();
PyObject impl=self_type.lookup("truncate");
if (impl!=null) {
return impl.__get__(this,self_type).__call__().asLong();
} else {
return super.truncate();
}
}
public void flush() {
PyType self_type=getType();
PyObject impl=self_type.lookup("flush");
if (impl!=null) {
impl.__get__(this,self_type).__call__();
} else {
super.flush();
}
}
public void close() {
PyType self_type=getType();
PyObject impl=self_type.lookup("close");
if (impl!=null) {
impl.__get__(this,self_type).__call__();
} else {
super.close();
}
}
public boolean seekable() {
PyType self_type=getType();
PyObject impl=self_type.lookup("seekable");
if (impl!=null) {
return impl.__get__(this,self_type).__call__().__nonzero__();
} else {
return super.seekable();
}
}
public void _checkSeekable(String msg) {
PyType self_type=getType();
PyObject impl=self_type.lookup("_checkSeekable");
if (impl!=null) {
PyObject pymsg=msg==null?Py.None:new PyString(msg);
impl.__get__(this,self_type).__call__(pymsg);
} else {
super._checkSeekable(msg);
}
}
public boolean readable() {
PyType self_type=getType();
PyObject impl=self_type.lookup("readable");
if (impl!=null) {
return impl.__get__(this,self_type).__call__().__nonzero__();
} else {
return super.readable();
}
}
public void _checkReadable(String msg) {
PyType self_type=getType();
PyObject impl=self_type.lookup("_checkReadable");
if (impl!=null) {
PyObject pymsg=msg==null?Py.None:new PyString(msg);
impl.__get__(this,self_type).__call__(pymsg);
} else {
super._checkReadable(msg);
}
}
public boolean writable() {
PyType self_type=getType();
PyObject impl=self_type.lookup("writable");
if (impl!=null) {
return impl.__get__(this,self_type).__call__().__nonzero__();
} else {
return super.writable();
}
}
public void _checkWritable(String msg) {
PyType self_type=getType();
PyObject impl=self_type.lookup("_checkWritable");
if (impl!=null) {
PyObject pymsg=msg==null?Py.None:new PyString(msg);
impl.__get__(this,self_type).__call__(pymsg);
} else {
super._checkWritable(msg);
}
}
// Note that closed is a property not a predicate, so no derived method.
public void _checkClosed(String msg) {
PyType self_type=getType();
PyObject impl=self_type.lookup("_checkClosed");
if (impl!=null) {
PyObject pymsg=msg==null?Py.None:new PyString(msg);
impl.__get__(this,self_type).__call__(pymsg);
} else {
super._checkClosed(msg);
}
}
public boolean __exit__(PyObject type,PyObject value,PyObject traceback) {
PyType self_type=getType();
PyObject impl=self_type.lookup("__exit__");
if (impl!=null) {
return impl.__get__(this,self_type).__call__(type,value,traceback).__nonzero__();
} else {
return super.__exit__(type,value,traceback);
}
}
public boolean isatty() {
PyType self_type=getType();
PyObject impl=self_type.lookup("isatty");
if (impl!=null) {
return impl.__get__(this,self_type).__call__().__nonzero__();
} else {
return super.isatty();
}
}
public PyObject readline() {
PyType self_type=getType();
PyObject impl=self_type.lookup("readline");
if (impl!=null) {
return impl.__get__(this,self_type).__call__(Py.None);
} else {
return super.readline();
}
}
public PyObject readline(int limit) {
PyType self_type=getType();
PyObject impl=self_type.lookup("readline");
if (impl!=null) {
return impl.__get__(this,self_type).__call__(Py.newInteger(limit));
} else {
return super.readline(limit);
}
}
public PyObject readlines(PyObject hint) {
PyType self_type=getType();
PyObject impl=self_type.lookup("readlines");
if (impl!=null) {
PyObject res=impl.__get__(this,self_type).__call__(hint);
return res;
} else {
return super.readlines(hint);
}
}
public void writelines(PyObject lines) {
PyType self_type=getType();
PyObject impl=self_type.lookup("writelines");
if (impl!=null) {
impl.__get__(this,self_type).__call__(lines);
} else {
super.writelines(lines);
}
}
}