src.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 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.
/* 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)
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);
}
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);
}
}
}