PySuper.java

package org.python.core;

public class PySuper extends PyObject implements PyType.Newstyle {
    //~ BEGIN GENERATED REGION -- DO NOT EDIT SEE gexpose.py
    /* type info */

    public static final String exposed_name="super";

    public static void typeSetup(PyObject dict,PyType.Newstyle marker) {
        dict.__setitem__("__thisclass__",new PyGetSetDescr("__thisclass__",PySuper.class,"getThisClass",null,null));
        dict.__setitem__("__self__",new PyGetSetDescr("__self__",PySuper.class,"getSelf",null,null));
        dict.__setitem__("__self_class__",new PyGetSetDescr("__self_class__",PySuper.class,"getSelfClass",null,null));
        class exposed___getattribute__ extends PyBuiltinMethodNarrow {

            exposed___getattribute__(PyObject self,PyBuiltinFunction.Info info) {
                super(self,info);
            }

            public PyBuiltinFunction bind(PyObject self) {
                return new exposed___getattribute__(self,info);
            }

            public PyObject __call__(PyObject arg0) {
                try {
                    String name=(arg0.asName(0));
                    PyObject ret=((PySuper)self).super___findattr__(name);
                    if (ret==null)
                        ((PySuper)self).noAttributeError(name);
                    return ret;
                } catch (PyObject.ConversionException e) {
                    String msg;
                    switch (e.index) {
                    case 0:
                        msg="attribute name must be a string";
                        break;
                    default:
                        msg="xxx";
                    }
                    throw Py.TypeError(msg);
                }
            }

        }
        dict.__setitem__("__getattribute__",new PyMethodDescr("__getattribute__",PySuper.class,1,1,new exposed___getattribute__(null,null)));
        class exposed___get__ extends PyBuiltinMethodNarrow {

            exposed___get__(PyObject self,PyBuiltinFunction.Info info) {
                super(self,info);
            }

            public PyBuiltinFunction bind(PyObject self) {
                return new exposed___get__(self,info);
            }

            public PyObject __call__(PyObject arg0,PyObject arg1) {
                PyObject obj=(arg0==Py.None)?null:arg1;
                PyObject type=(arg1==Py.None)?null:arg0;
                return((PySuper)self).super___get__(obj,type);
            }

            public PyObject __call__(PyObject arg0) {
                PyObject obj=(arg0==Py.None)?null:(null);
                PyObject type=((null)==Py.None)?null:arg0;
                return((PySuper)self).super___get__(obj,type);
            }

        }
        dict.__setitem__("__get__",new PyMethodDescr("__get__",PySuper.class,1,2,new exposed___get__(null,null)));
        class exposed___init__ extends PyBuiltinMethod {

            exposed___init__(PyObject self,PyBuiltinFunction.Info info) {
                super(self,info);
            }

            public PyBuiltinFunction bind(PyObject self) {
                return new exposed___init__(self,info);
            }

            public PyObject __call__(PyObject[]args) {
                return __call__(args,Py.NoKeywords);
            }

            public PyObject __call__(PyObject[]args,String[]keywords) {
                ((PySuper)self).super_init(args,keywords);
                return Py.None;
            }

        }
        dict.__setitem__("__init__",new PyMethodDescr("__init__",PySuper.class,-1,-1,new exposed___init__(null,null)));
        dict.__setitem__("__new__",new PyNewWrapper(PySuper.class,"__new__",-1,-1) {

                                                                                       public PyObject new_impl(boolean init,PyType subtype,PyObject[]args,String[]keywords) {
                                                                                           PySuper newobj;
                                                                                           if (for_type==subtype) {
                                                                                               newobj=new PySuper();
                                                                                               if (init)
                                                                                                   newobj.super_init(args,keywords);
                                                                                           } else {
                                                                                               newobj=new PySuperDerived(subtype);
                                                                                           }
                                                                                           return newobj;
                                                                                       }

                                                                                   });
    }
    //~ END GENERATED REGION -- DO NOT EDIT SEE gexpose.py

    private static final PyType SUPERTYPE = PyType.fromClass(PySuper.class);
   
    protected PyType thisClass;
    protected PyObject self;
    protected PyType selfClass;

    private PyType supercheck(PyType type,PyObject obj) {
        if (obj instanceof PyType && ((PyType)obj).isSubType(type)) {
            return (PyType)obj;
        }
        PyType obj_type = obj.getType();
        if (obj_type.isSubType(type))
            return obj_type;
        throw Py.TypeError("super(type, obj): "+
                "obj must be an instance or subtype of type");
    }
    
    public void super_init(PyObject[] args, String[] keywords) {
        if (keywords.length != 0
                || !PyBuiltinFunction.DefaultInfo.check(args.length, 1, 2)) {
            throw PyBuiltinFunction.DefaultInfo.unexpectedCall(args.length,
                    keywords.length != 0, "super", 1, 2);
        }
        if (!(args[0] instanceof PyType)) {
            throw Py.TypeError("super: argument 1 must be type");
        }
        PyType type = (PyType)args[0];
        PyObject obj = null;
        PyType obj_type = null;
        if (args.length == 2 && args[1] != Py.None)
            obj = args[1];
        if (obj != null) {
            obj_type = supercheck(type, obj);
        }
        this.thisClass = type;
        this.self = obj;
        this.selfClass = obj_type;
    }
    
    public PySuper() {
        this(SUPERTYPE);
    }

    public PySuper(PyType subType) {
        super(subType);
    }
    
    public PyObject getSelf() {
        return self;
    }
    public PyType getSelfClass() {
        return selfClass;
    }
    public PyType getThisClass() {
        return thisClass;
    }
    
    public PyObject __findattr__(String name) {
        return super___findattr__(name);
    }

    final PyObject super___findattr__(String name) {
        if (selfClass != null && name != "__class__") {
            PyObject descr = selfClass.super_lookup(thisClass, name);
            return descr.__get__(selfClass == self ? null : self, selfClass);
        }
        return super.__findattr__(name);
    }

    public PyObject __get__(PyObject obj, PyObject type) {
        return super___get__(obj,type);
    }

    final PyObject super___get__(PyObject obj, PyObject type) { //xxx subtype case!
        if (obj == null || obj == Py.None || self != null)
            return this;
        PyType obj_type = supercheck(this.thisClass, obj);
        PySuper newsuper = new PySuper();
        newsuper.thisClass = this.thisClass;
        newsuper.self = obj;
        newsuper.selfClass = obj_type;
        return newsuper;
    }

}