0001: // Copyright (c) Corporation for National Research Initiatives
0002: package org.python.core;
0003:
0004: import java.text.MessageFormat;
0005: import java.util.ArrayList;
0006: import java.util.Iterator;
0007: import java.util.List;
0008:
0009: /**
0010: * All objects known to the Jython runtime system are represented
0011: * by an instance of the class <code>PyObject</code> or one of
0012: * its subclasses.
0013: *
0014: **/
0015:
0016: public class PyObject implements java.io.Serializable {
0017: //~ BEGIN GENERATED REGION -- DO NOT EDIT SEE gexpose.py
0018: /* type info */
0019:
0020: public static final String exposed_name = "object";
0021:
0022: public static void typeSetup(PyObject dict, PyType.Newstyle marker) {
0023: dict.__setitem__("__class__", new PyGetSetDescr("__class__",
0024: PyObject.class, "getType", "setType", "delType"));
0025: dict.__setitem__("__doc__", new PyGetSetDescr("__doc__",
0026: PyObject.class, "getDoc", null, null));
0027: class exposed___reduce__ extends PyBuiltinMethodNarrow {
0028:
0029: exposed___reduce__(PyObject self,
0030: PyBuiltinFunction.Info info) {
0031: super (self, info);
0032: }
0033:
0034: public PyBuiltinFunction bind(PyObject self) {
0035: return new exposed___reduce__(self, info);
0036: }
0037:
0038: public PyObject __call__() {
0039: return ((PyObject) self).object___reduce__();
0040: }
0041:
0042: }
0043: dict.__setitem__("__reduce__", new PyMethodDescr("__reduce__",
0044: PyObject.class, 0, 0,
0045: new exposed___reduce__(null, null)));
0046: class exposed___str__ extends PyBuiltinMethodNarrow {
0047:
0048: exposed___str__(PyObject self, PyBuiltinFunction.Info info) {
0049: super (self, info);
0050: }
0051:
0052: public PyBuiltinFunction bind(PyObject self) {
0053: return new exposed___str__(self, info);
0054: }
0055:
0056: public PyObject __call__() {
0057: return self.__repr__();
0058: }
0059:
0060: }
0061: dict.__setitem__("__str__", new PyMethodDescr("__str__",
0062: PyObject.class, 0, 0, new exposed___str__(null, null)));
0063: class exposed___getattribute__ extends PyBuiltinMethodNarrow {
0064:
0065: exposed___getattribute__(PyObject self,
0066: PyBuiltinFunction.Info info) {
0067: super (self, info);
0068: }
0069:
0070: public PyBuiltinFunction bind(PyObject self) {
0071: return new exposed___getattribute__(self, info);
0072: }
0073:
0074: public PyObject __call__(PyObject arg0) {
0075: try {
0076: String name = (arg0.asName(0));
0077: PyObject ret = self.object___findattr__(name);
0078: if (ret == null)
0079: self.noAttributeError(name);
0080: return ret;
0081: } catch (PyObject.ConversionException e) {
0082: String msg;
0083: switch (e.index) {
0084: case 0:
0085: msg = "attribute name must be a string";
0086: break;
0087: default:
0088: msg = "xxx";
0089: }
0090: throw Py.TypeError(msg);
0091: }
0092: }
0093:
0094: }
0095: dict.__setitem__("__getattribute__", new PyMethodDescr(
0096: "__getattribute__", PyObject.class, 1, 1,
0097: new exposed___getattribute__(null, null)));
0098: class exposed___setattr__ extends PyBuiltinMethodNarrow {
0099:
0100: exposed___setattr__(PyObject self,
0101: PyBuiltinFunction.Info info) {
0102: super (self, info);
0103: }
0104:
0105: public PyBuiltinFunction bind(PyObject self) {
0106: return new exposed___setattr__(self, info);
0107: }
0108:
0109: public PyObject __call__(PyObject arg0, PyObject arg1) {
0110: try {
0111: ((PyObject) self).object___setattr__(
0112: arg0.asName(0), arg1);
0113: return Py.None;
0114: } catch (PyObject.ConversionException e) {
0115: String msg;
0116: switch (e.index) {
0117: case 0:
0118: msg = "attribute name must be a string";
0119: break;
0120: default:
0121: msg = "xxx";
0122: }
0123: throw Py.TypeError(msg);
0124: }
0125: }
0126:
0127: }
0128: dict.__setitem__("__setattr__", new PyMethodDescr(
0129: "__setattr__", PyObject.class, 2, 2,
0130: new exposed___setattr__(null, null)));
0131: class exposed___delattr__ extends PyBuiltinMethodNarrow {
0132:
0133: exposed___delattr__(PyObject self,
0134: PyBuiltinFunction.Info info) {
0135: super (self, info);
0136: }
0137:
0138: public PyBuiltinFunction bind(PyObject self) {
0139: return new exposed___delattr__(self, info);
0140: }
0141:
0142: public PyObject __call__(PyObject arg0) {
0143: try {
0144: ((PyObject) self)
0145: .object___delattr__(arg0.asName(0));
0146: return Py.None;
0147: } catch (PyObject.ConversionException e) {
0148: String msg;
0149: switch (e.index) {
0150: case 0:
0151: msg = "attribute name must be a string";
0152: break;
0153: default:
0154: msg = "xxx";
0155: }
0156: throw Py.TypeError(msg);
0157: }
0158: }
0159:
0160: }
0161: dict.__setitem__("__delattr__", new PyMethodDescr(
0162: "__delattr__", PyObject.class, 1, 1,
0163: new exposed___delattr__(null, null)));
0164: class exposed___hash__ extends PyBuiltinMethodNarrow {
0165:
0166: exposed___hash__(PyObject self, PyBuiltinFunction.Info info) {
0167: super (self, info);
0168: }
0169:
0170: public PyBuiltinFunction bind(PyObject self) {
0171: return new exposed___hash__(self, info);
0172: }
0173:
0174: public PyObject __call__() {
0175: return new PyInteger(self.object_hashCode());
0176: }
0177:
0178: }
0179: dict
0180: .__setitem__("__hash__", new PyMethodDescr("__hash__",
0181: PyObject.class, 0, 0, new exposed___hash__(
0182: null, null)));
0183: class exposed___repr__ extends PyBuiltinMethodNarrow {
0184:
0185: exposed___repr__(PyObject self, PyBuiltinFunction.Info info) {
0186: super (self, info);
0187: }
0188:
0189: public PyBuiltinFunction bind(PyObject self) {
0190: return new exposed___repr__(self, info);
0191: }
0192:
0193: public PyObject __call__() {
0194: return new PyString(self.object_toString());
0195: }
0196:
0197: }
0198: dict
0199: .__setitem__("__repr__", new PyMethodDescr("__repr__",
0200: PyObject.class, 0, 0, new exposed___repr__(
0201: null, null)));
0202: class exposed___unicode__ extends PyBuiltinMethodNarrow {
0203:
0204: exposed___unicode__(PyObject self,
0205: PyBuiltinFunction.Info info) {
0206: super (self, info);
0207: }
0208:
0209: public PyBuiltinFunction bind(PyObject self) {
0210: return new exposed___unicode__(self, info);
0211: }
0212:
0213: public PyObject __call__() {
0214: return new PyUnicode(self.__str__());
0215: }
0216:
0217: }
0218: dict.__setitem__("__unicode__", new PyMethodDescr(
0219: "__unicode__", PyObject.class, 0, 0,
0220: new exposed___unicode__(null, null)));
0221: class exposed___init__ extends PyBuiltinMethod {
0222:
0223: exposed___init__(PyObject self, PyBuiltinFunction.Info info) {
0224: super (self, info);
0225: }
0226:
0227: public PyBuiltinFunction bind(PyObject self) {
0228: return new exposed___init__(self, info);
0229: }
0230:
0231: public PyObject __call__(PyObject[] args) {
0232: return __call__(args, Py.NoKeywords);
0233: }
0234:
0235: public PyObject __call__(PyObject[] args, String[] keywords) {
0236: ((PyObject) self).object_init(args, keywords);
0237: return Py.None;
0238: }
0239:
0240: }
0241: dict.__setitem__("__init__", new PyMethodDescr("__init__",
0242: PyObject.class, -1, -1,
0243: new exposed___init__(null, null)));
0244: dict.__setitem__("__new__", new PyNewWrapper(PyObject.class,
0245: "__new__", -1, -1) {
0246:
0247: public PyObject new_impl(boolean init, PyType subtype,
0248: PyObject[] args, String[] keywords) {
0249: PyObject newobj;
0250: if (for_type == subtype) {
0251: newobj = new PyObject();
0252: if (init)
0253: newobj.object_init(args, keywords);
0254: } else {
0255: newobj = new PyObjectDerived(subtype);
0256: }
0257: return newobj;
0258: }
0259:
0260: });
0261: }
0262:
0263: //~ END GENERATED REGION -- DO NOT EDIT SEE gexpose.py
0264:
0265: final void object_init(PyObject[] args, String[] keywords) {
0266: // xxx
0267: }
0268:
0269: // getType may become not necessary
0270: private PyType objtype;
0271:
0272: public PyType getType() {
0273: return objtype;
0274: }
0275:
0276: public void setType(PyType type) {
0277: if (getType().layoutAligns(type)
0278: && !type.equals(PyType.fromClass(PyObject.class))) {
0279: this .objtype = type;
0280: } else {
0281: throw Py
0282: .TypeError("Can only assign subtypes of object to __class__ on subclasses of object");
0283: }
0284: }
0285:
0286: public void delType() {
0287: throw Py.TypeError("Can't delete __class__ attribute");
0288: }
0289:
0290: // xxx
0291: public PyObject fastGetClass() {
0292: return objtype;
0293: }
0294:
0295: public PyObject getDoc() {
0296: PyObject d = fastGetDict();
0297: if (d != null) {
0298: PyObject doc = d.__finditem__("__doc__");
0299: if (doc != null) {
0300: return doc;
0301: }
0302: }
0303: return Py.None;
0304: }
0305:
0306: public PyObject(PyType objtype) {
0307: this .objtype = objtype;
0308: }
0309:
0310: // A package private constructor used by PyJavaClass
0311: // xxx will need variants for PyType of PyType and still PyJavaClass of PyJavaClass
0312: PyObject(boolean dummy) {
0313: objtype = (PyType) this ;
0314: }
0315:
0316: /**
0317: * The standard constructor for a <code>PyObject</code>. It will set
0318: * the <code>__class__</code> field to correspond to the specific
0319: * subclass of <code>PyObject</code> being instantiated.
0320: **/
0321: public PyObject() {
0322: // xxx for now no such caching
0323: // PyClass c = getPyClass();
0324: // if (c == null)
0325: // c = PyJavaClass.lookup(getClass());
0326: objtype = PyType.fromClass(getClass());
0327: }
0328:
0329: /* xxx will be replaced.
0330: * This method is provided to efficiently initialize the __class__
0331: * attribute. If the following boilerplate is added to a subclass of
0332: * PyObject, the instantiation time for the object will be greatly
0333: * reduced.
0334: *
0335: * <blockquote><pre>
0336: * // __class__ boilerplate -- see PyObject for details
0337: * public static PyClass __class__;
0338: * protected PyClass getPyClass() { return __class__; }
0339: * </pre></blockquote>
0340: *
0341: * With PyIntegers this leads to a 50% faster instantiation time.
0342: * This replaces the PyObject(PyClass c) constructor which is now
0343: * deprecated.
0344: *
0345: protected PyClass getPyClass() {
0346: return null;
0347: } */
0348:
0349: /**
0350: * Dispatch __init__ behavior
0351: */
0352: public void dispatch__init__(PyType type, PyObject[] args,
0353: String[] keywords) {
0354: }
0355:
0356: /**
0357: * Equivalent to the standard Python __repr__ method. This method
0358: * should not typically need to be overrriden. The easiest way to
0359: * configure the string representation of a <code>PyObject</code> is to
0360: * override the standard Java <code>toString</code> method.
0361: **/
0362: public PyString __repr__() {
0363: return new PyString(toString());
0364: }
0365:
0366: public String toString() {
0367: return object_toString();
0368: }
0369:
0370: final String object_toString() {
0371: if (getType() == null) {
0372: return "unknown object";
0373: }
0374:
0375: String name = getType().getFullName();
0376: if (name == null)
0377: return "unknown object";
0378:
0379: return "<" + name + " object " + Py.idstr(this ) + ">";
0380: }
0381:
0382: public String safeRepr() throws PyIgnoreMethodTag {
0383: if (getType() == null) {
0384: return "unknown object";
0385: }
0386:
0387: String name = getType().getFullName();
0388: if (name == null)
0389: return "unknown object";
0390:
0391: return "'" + name + "' object";
0392: }
0393:
0394: /**
0395: * Equivalent to the standard Python __str__ method. This method
0396: * should not typically need to be overridden. The easiest way to
0397: * configure the string representation of a <code>PyObject</code> is to
0398: * override the standard Java <code>toString</code> method.
0399: **/
0400: public PyString __str__() {
0401: return __repr__();
0402: }
0403:
0404: public PyUnicode __unicode__() {
0405: return new PyUnicode(__str__());
0406: }
0407:
0408: /**
0409: * Equivalent to the standard Python __hash__ method. This method can
0410: * not be overridden. Instead, you should override the standard Java
0411: * <code>hashCode</code> method to return an appropriate hash code for
0412: * the <code>PyObject</code>.
0413: **/
0414: public final PyInteger __hash__() {
0415: return new PyInteger(hashCode());
0416: }
0417:
0418: public int hashCode() {
0419: return object_hashCode();
0420: }
0421:
0422: final int object_hashCode() {
0423: return System.identityHashCode(this );
0424: }
0425:
0426: /**
0427: * Should almost never be overridden.
0428: * If overridden, it is the subclasses responsibility to ensure that
0429: * <code>a.equals(b) == true</code> iff <code>cmp(a,b) == 0</code>
0430: **/
0431: public boolean equals(Object ob_other) {
0432: return (ob_other instanceof PyObject)
0433: && _eq((PyObject) ob_other).__nonzero__();
0434: }
0435:
0436: /**
0437: * Equivalent to the standard Python __nonzero__ method.
0438: * Returns whether of not a given <code>PyObject</code> is
0439: * considered true.
0440: **/
0441: public boolean __nonzero__() {
0442: return true;
0443: }
0444:
0445: /**
0446: * Equivalent to the Jython __tojava__ method.
0447: * Tries to coerce this object to an instance of the requested Java class.
0448: * Returns the special object <code>Py.NoConversion</code>
0449: * if this <code>PyObject</code> can not be converted to the
0450: * desired Java class.
0451: *
0452: * @param c the Class to convert this <code>PyObject</code> to.
0453: **/
0454: public Object __tojava__(Class c) {
0455: if (c.isInstance(this ))
0456: return this ;
0457: return Py.NoConversion;
0458: }
0459:
0460: /**
0461: * The basic method to override when implementing a callable object.
0462: *
0463: * The first len(args)-len(keywords) members of args[] are plain
0464: * arguments. The last len(keywords) arguments are the values of the
0465: * keyword arguments.
0466: *
0467: * @param args all arguments to the function (including
0468: * keyword arguments).
0469: * @param keywords the keywords used for all keyword arguments.
0470: **/
0471: public PyObject __call__(PyObject args[], String keywords[]) {
0472: throw Py.TypeError("call of non-function (" + safeRepr() + ")");
0473: }
0474:
0475: /**
0476: * A variant of the __call__ method with one extra initial argument.
0477: * This variant is used to allow method invocations to be performed
0478: * efficiently.
0479: *
0480: * The default behavior is to invoke <code>__call__(args,
0481: * keywords)</code> with the appropriate arguments. The only reason to
0482: * override this function would be for improved performance.
0483: *
0484: * @param arg1 the first argument to the function.
0485: * @param args the last arguments to the function (including
0486: * keyword arguments).
0487: * @param keywords the keywords used for all keyword arguments.
0488: **/
0489: public PyObject __call__(PyObject arg1, PyObject args[],
0490: String keywords[]) {
0491: PyObject[] newArgs = new PyObject[args.length + 1];
0492: System.arraycopy(args, 0, newArgs, 1, args.length);
0493: newArgs[0] = arg1;
0494: return __call__(newArgs, keywords);
0495: }
0496:
0497: /**
0498: * A variant of the __call__ method when no keywords are passed. The
0499: * default behavior is to invoke <code>__call__(args, keywords)</code>
0500: * with the appropriate arguments. The only reason to override this
0501: * function would be for improved performance.
0502: *
0503: * @param args all arguments to the function.
0504: **/
0505: public PyObject __call__(PyObject args[]) {
0506: return __call__(args, Py.NoKeywords);
0507: }
0508:
0509: /**
0510: * A variant of the __call__ method with no arguments. The default
0511: * behavior is to invoke <code>__call__(args, keywords)</code> with the
0512: * appropriate arguments. The only reason to override this function
0513: * would be for improved performance.
0514: **/
0515: public PyObject __call__() {
0516: return __call__(Py.EmptyObjects, Py.NoKeywords);
0517: }
0518:
0519: /**
0520: * A variant of the __call__ method with one argument. The default
0521: * behavior is to invoke <code>__call__(args, keywords)</code> with the
0522: * appropriate arguments. The only reason to override this function
0523: * would be for improved performance.
0524: *
0525: * @param arg0 the single argument to the function.
0526: **/
0527: public PyObject __call__(PyObject arg0) {
0528: return __call__(new PyObject[] { arg0 }, Py.NoKeywords);
0529: }
0530:
0531: /**
0532: * A variant of the __call__ method with two arguments. The default
0533: * behavior is to invoke <code>__call__(args, keywords)</code> with the
0534: * appropriate arguments. The only reason to override this function
0535: * would be for improved performance.
0536: *
0537: * @param arg0 the first argument to the function.
0538: * @param arg1 the second argument to the function.
0539: **/
0540: public PyObject __call__(PyObject arg0, PyObject arg1) {
0541: return __call__(new PyObject[] { arg0, arg1 }, Py.NoKeywords);
0542: }
0543:
0544: /**
0545: * A variant of the __call__ method with three arguments. The default
0546: * behavior is to invoke <code>__call__(args, keywords)</code> with the
0547: * appropriate arguments. The only reason to override this function
0548: * would be for improved performance.
0549: *
0550: * @param arg0 the first argument to the function.
0551: * @param arg1 the second argument to the function.
0552: * @param arg2 the third argument to the function.
0553: **/
0554: public PyObject __call__(PyObject arg0, PyObject arg1, PyObject arg2) {
0555: return __call__(new PyObject[] { arg0, arg1, arg2 },
0556: Py.NoKeywords);
0557: }
0558:
0559: /**
0560: * A variant of the __call__ method with four arguments. The default
0561: * behavior is to invoke <code>__call__(args, keywords)</code> with the
0562: * appropriate arguments. The only reason to override this function
0563: * would be for improved performance.
0564: *
0565: * @param arg0 the first argument to the function.
0566: * @param arg1 the second argument to the function.
0567: * @param arg2 the third argument to the function.
0568: * @param arg3 the fourth argument to the function.
0569: **/
0570: public PyObject __call__(PyObject arg0, PyObject arg1,
0571: PyObject arg2, PyObject arg3) {
0572: return __call__(new PyObject[] { arg0, arg1, arg2, arg3 },
0573: Py.NoKeywords);
0574: }
0575:
0576: /** @deprecated **/
0577: public PyObject _callextra(PyObject[] args, String[] keywords,
0578: PyObject starargs, PyObject kwargs) {
0579:
0580: int argslen = args.length;
0581:
0582: String name = "";
0583: if (this instanceof PyFunction) {
0584: name = ((PyFunction) this ).__name__ + "() ";
0585: } else {
0586: name = getType().fastGetName() + " ";
0587: }
0588: if (kwargs != null) {
0589: PyObject keys = kwargs.__findattr__("keys");
0590: if (keys == null)
0591: throw Py.TypeError(name
0592: + "argument after ** must be a dictionary");
0593: for (int i = 0; i < keywords.length; i++)
0594: if (kwargs.__finditem__(keywords[i]) != null)
0595: throw Py.TypeError(name
0596: + "got multiple values for "
0597: + "keyword argument '" + keywords[i] + "'");
0598: argslen += kwargs.__len__();
0599: }
0600: List starObjs = null;
0601: if (starargs != null) {
0602: if (starargs.__findattr__("__iter__") != null) {
0603: PyObject iter = starargs.__iter__();
0604: starObjs = new ArrayList();
0605: PyObject cur;
0606: while ((cur = iter.__iternext__()) != null) {
0607: starObjs.add(cur);
0608: }
0609: } else {
0610: try {
0611: int nstar = starargs.__len__();
0612: PyObject cur;
0613: starObjs = new ArrayList(nstar);
0614: for (int i = 0; (cur = starargs.__finditem__(i)) != null
0615: && i < nstar; i++) {
0616: starObjs.add(cur);
0617: }
0618: } catch (PyException e) {
0619: if (Py.matchException(e, Py.AttributeError)) {
0620: throw Py.TypeError(name
0621: + "argument after * must "
0622: + "be a sequence");
0623: }
0624: throw e;
0625: }
0626: }
0627: argslen += starObjs.size();
0628: }
0629: PyObject[] newargs = new PyObject[argslen];
0630: int argidx = args.length - keywords.length;
0631: System.arraycopy(args, 0, newargs, 0, argidx);
0632: if (starObjs != null) {
0633: Iterator it = starObjs.iterator();
0634: while (it.hasNext()) {
0635: newargs[argidx++] = (PyObject) it.next();
0636: }
0637: }
0638: System.arraycopy(args, args.length - keywords.length, newargs,
0639: argidx, keywords.length);
0640: argidx += keywords.length;
0641:
0642: if (kwargs != null) {
0643: String[] newkeywords = new String[keywords.length
0644: + kwargs.__len__()];
0645: System.arraycopy(keywords, 0, newkeywords, 0,
0646: keywords.length);
0647:
0648: PyObject keys = kwargs.invoke("keys");
0649: PyObject key;
0650: for (int i = 0; (key = keys.__finditem__(i)) != null; i++) {
0651: if (!(key instanceof PyString))
0652: throw Py.TypeError(name
0653: + "keywords must be strings");
0654: newkeywords[keywords.length + i] = ((PyString) key)
0655: .internedString();
0656: newargs[argidx++] = kwargs.__finditem__(key);
0657: }
0658: keywords = newkeywords;
0659: }
0660:
0661: if (newargs.length != argidx) {
0662: args = new PyObject[argidx];
0663: System.arraycopy(newargs, 0, args, 0, argidx);
0664: } else
0665: args = newargs;
0666: return __call__(args, keywords);
0667: }
0668:
0669: /* xxx fix these around */
0670:
0671: public boolean isCallable() {
0672: return __findattr__("__call__") != null;
0673: }
0674:
0675: public boolean isMappingType() {
0676: return true;
0677: }
0678:
0679: public boolean isNumberType() {
0680: return true;
0681: }
0682:
0683: public boolean isSequenceType() {
0684: return true;
0685: }
0686:
0687: /* . */
0688:
0689: /* The basic functions to implement a mapping */
0690:
0691: /**
0692: * Equivalent to the standard Python __len__ method.
0693: * Part of the mapping discipline.
0694: *
0695: * @return the length of the object
0696: **/
0697: public int __len__() {
0698: throw Py.AttributeError("__len__");
0699: }
0700:
0701: /**
0702: * Very similar to the standard Python __getitem__ method.
0703: * Instead of throwing a KeyError if the item isn't found,
0704: * this just returns null.
0705: *
0706: * Classes that wish to implement __getitem__ should
0707: * override this method instead (with the appropriate
0708: * semantics.
0709: *
0710: * @param key the key to lookup in this container
0711: *
0712: * @return the value corresponding to key or null if key is not found
0713: **/
0714: public PyObject __finditem__(PyObject key) {
0715: throw Py.AttributeError("__getitem__");
0716: }
0717:
0718: /**
0719: * A variant of the __finditem__ method which accepts a primitive
0720: * <code>int</code> as the key. By default, this method will call
0721: * <code>__finditem__(PyObject key)</code> with the appropriate args.
0722: * The only reason to override this method is for performance.
0723: *
0724: * @param key the key to lookup in this sequence.
0725: * @return the value corresponding to key or null if key is not found.
0726: *
0727: * @see #__finditem__(PyObject)
0728: **/
0729: public PyObject __finditem__(int key) {
0730: return __finditem__(new PyInteger(key));
0731: }
0732:
0733: /**
0734: * A variant of the __finditem__ method which accepts a Java
0735: * <code>String</code> as the key. By default, this method will call
0736: * <code>__finditem__(PyObject key)</code> with the appropriate args.
0737: * The only reason to override this method is for performance.
0738: *
0739: * <b>Warning: key must be an interned string!!!!!!!!</b>
0740: *
0741: * @param key the key to lookup in this sequence -
0742: * <b> must be an interned string </b>.
0743: * @return the value corresponding to key or null if key is not found.
0744: *
0745: * @see #__finditem__(PyObject)
0746: **/
0747: public PyObject __finditem__(String key) {
0748: return __finditem__(new PyString(key));
0749: }
0750:
0751: /**
0752: * Equivalent to the standard Python __getitem__ method.
0753: * This variant takes a primitive <code>int</code> as the key.
0754: * This method should not be overridden.
0755: * Override the <code>__finditem__</code> method instead.
0756: *
0757: * @param key the key to lookup in this container.
0758: * @return the value corresponding to that key.
0759: * @exception Py.KeyError if the key is not found.
0760: *
0761: * @see #__finditem__(int)
0762: **/
0763: public PyObject __getitem__(int key) {
0764: PyObject ret = __finditem__(key);
0765: if (ret == null)
0766: throw Py.KeyError("" + key);
0767: return ret;
0768: }
0769:
0770: /**
0771: * Equivalent to the standard Python __getitem__ method.
0772: * This method should not be overridden.
0773: * Override the <code>__finditem__</code> method instead.
0774: *
0775: * @param key the key to lookup in this container.
0776: * @return the value corresponding to that key.
0777: * @exception Py.KeyError if the key is not found.
0778: *
0779: * @see #__finditem__(PyObject)
0780: **/
0781: public PyObject __getitem__(PyObject key) {
0782: PyObject ret = __finditem__(key);
0783: if (ret == null)
0784: throw Py.KeyError(key.toString());
0785: return ret;
0786: }
0787:
0788: /**
0789: * Equivalent to the standard Python __setitem__ method.
0790: *
0791: * @param key the key whose value will be set
0792: * @param value the value to set this key to
0793: **/
0794: public void __setitem__(PyObject key, PyObject value) {
0795: throw Py.AttributeError("__setitem__");
0796: }
0797:
0798: /**
0799: * A variant of the __setitem__ method which accepts a String
0800: * as the key. <b>This String must be interned</b>.
0801: * By default, this will call
0802: * <code>__setitem__(PyObject key, PyObject value)</code>
0803: * with the appropriate args.
0804: * The only reason to override this method is for performance.
0805: *
0806: * @param key the key whose value will be set -
0807: * <b> must be an interned string </b>.
0808: * @param value the value to set this key to
0809: *
0810: * @see #__setitem__(PyObject, PyObject)
0811: **/
0812: public void __setitem__(String key, PyObject value) {
0813: __setitem__(new PyString(key), value);
0814: }
0815:
0816: /**
0817: * A variant of the __setitem__ method which accepts a primitive
0818: * <code>int</code> as the key.
0819: * By default, this will call
0820: * <code>__setitem__(PyObject key, PyObject value)</code>
0821: * with the appropriate args.
0822: * The only reason to override this method is for performance.
0823: *
0824: * @param key the key whose value will be set
0825: * @param value the value to set this key to
0826: *
0827: * @see #__setitem__(PyObject, PyObject)
0828: **/
0829: public void __setitem__(int key, PyObject value) {
0830: __setitem__(new PyInteger(key), value);
0831: }
0832:
0833: /**
0834: * Equivalent to the standard Python __delitem__ method.
0835: *
0836: * @param key the key to be removed from the container
0837: * @exception Py.KeyError if the key is not found in the container
0838: **/
0839: public void __delitem__(PyObject key) {
0840: throw Py.AttributeError("__delitem__");
0841: }
0842:
0843: /**
0844: * A variant of the __delitem__ method which accepts a String
0845: * as the key. <b>This String must be interned</b>.
0846: * By default, this will call
0847: * <code>__delitem__(PyObject key)</code>
0848: * with the appropriate args.
0849: * The only reason to override this method is for performance.
0850: *
0851: * @param key the key who will be removed -
0852: * <b> must be an interned string </b>.
0853: * @exception Py.KeyError if the key is not found in the container
0854: *
0855: * @see #__delitem__(PyObject)
0856: **/
0857: public void __delitem__(String key) {
0858: __delitem__(new PyString(key));
0859: }
0860:
0861: public PyObject __getslice__(PyObject s_start, PyObject s_stop,
0862: PyObject s_step) {
0863: PySlice s = new PySlice(s_start, s_stop, s_step);
0864: return __getitem__(s);
0865: }
0866:
0867: public void __setslice__(PyObject s_start, PyObject s_stop,
0868: PyObject s_step, PyObject value) {
0869: PySlice s = new PySlice(s_start, s_stop, s_step);
0870: __setitem__(s, value);
0871: }
0872:
0873: public void __delslice__(PyObject s_start, PyObject s_stop,
0874: PyObject s_step) {
0875: PySlice s = new PySlice(s_start, s_stop, s_step);
0876: __delitem__(s);
0877: }
0878:
0879: public PyObject __getslice__(PyObject start, PyObject stop) {
0880: return __getslice__(start, stop, Py.One);
0881: }
0882:
0883: public void __setslice__(PyObject start, PyObject stop,
0884: PyObject value) {
0885: __setslice__(start, stop, Py.One, value);
0886: }
0887:
0888: public void __delslice__(PyObject start, PyObject stop) {
0889: __delslice__(start, stop, Py.One);
0890: }
0891:
0892: /*The basic functions to implement an iterator */
0893:
0894: /**
0895: * Return an iterator that is used to iterate the element of this
0896: * sequence.
0897: * From version 2.2, this method is the primary protocol for looping
0898: * over sequences.
0899: * <p>
0900: * If a PyObject subclass should support iteration based in the
0901: * __finditem__() method, it must supply an implementation of __iter__()
0902: * like this:
0903: * <pre>
0904: * public PyObject __iter__() {
0905: * return new PySequenceIter(this);
0906: * }
0907: * </pre>
0908: *
0909: * When iterating over a python sequence from java code, it should be
0910: * done with code like this:
0911: * <pre>
0912: * PyObject iter = seq.__iter__();
0913: * for (PyObject item; (item = iter.__iternext__()) != null;) {
0914: * // Do somting with item
0915: * }
0916: * </pre>
0917: *
0918: * @since 2.2
0919: */
0920: public PyObject __iter__() {
0921: throw Py.TypeError("iteration over non-sequence");
0922: }
0923:
0924: /**
0925: * Return the next element of the sequence that this is an iterator
0926: * for. Returns null when the end of the sequence is reached.
0927: *
0928: * @since 2.2
0929: */
0930: public PyObject __iternext__() {
0931: return null;
0932: }
0933:
0934: /*The basic functions to implement a namespace*/
0935:
0936: /**
0937: * Very similar to the standard Python __getattr__ method. Instead of
0938: * throwing a AttributeError if the item isn't found, this just returns
0939: * null.
0940: *
0941: * By default, this method will call
0942: * <code>__findattr__(name.internedString)</code> with the appropriate
0943: * args.
0944: *
0945: * Classes that wish to implement __getattr__ should override this method
0946: * instead (with the appropriate semantics.
0947: *
0948: * @param name
0949: * the name to lookup in this namespace
0950: *
0951: * @return the value corresponding to name or null if name is not found
0952: */
0953: public final PyObject __findattr__(PyString name) {
0954: if (name == null) {
0955: return null;
0956: }
0957: return __findattr__(name.internedString());
0958: }
0959:
0960: /**
0961: * A variant of the __findattr__ method which accepts a Java
0962: * <code>String</code> as the name.
0963: *
0964: * <b>Warning: name must be an interned string!</b>
0965: *
0966: * @param name the name to lookup in this namespace
0967: * <b> must be an interned string </b>.
0968: * @return the value corresponding to name or null if name is not found
0969: *
0970: * @see #__findattr__(PyString)
0971: **/
0972: public PyObject __findattr__(String name) { // xxx accelerators/ expose
0973: /*if (getType() == null)
0974: return null;
0975: if (name == "__class__")
0976: return getType();*/
0977: /*PyObject ret = getType().lookup(name, false);
0978: if (ret != null)
0979: return ret._doget(this);
0980: return null;*/
0981:
0982: return object___findattr__(name);
0983: }
0984:
0985: /**
0986: * Equivalent to the standard Python __getattr__ method.
0987: * This method can not be overridden.
0988: * Override the <code>__findattr__</code> method instead.
0989: *
0990: * @param name the name to lookup in this namespace
0991: * @return the value corresponding to name
0992: * @exception Py.AttributeError if the name is not found.
0993: *
0994: * @see #__findattr__(PyString)
0995: **/
0996: public final PyObject __getattr__(PyString name) {
0997: PyObject ret = __findattr__(name);
0998: if (ret == null)
0999: noAttributeError(name.toString());
1000: return ret;
1001: }
1002:
1003: /**
1004: * A variant of the __getattr__ method which accepts a Java
1005: * <code>String</code> as the name.
1006: * This method can not be overridden.
1007: * Override the <code>__findattr__</code> method instead.
1008: *
1009: * <b>Warning: name must be an interned string!!!!!!!!</b>
1010: *
1011: * @param name the name to lookup in this namespace
1012: * <b> must be an interned string </b>.
1013: * @return the value corresponding to name
1014: * @exception Py.AttributeError if the name is not found.
1015: *
1016: * @see #__findattr__(java.lang.String)
1017: **/
1018: public final PyObject __getattr__(String name) {
1019: PyObject ret = __findattr__(name);
1020: if (ret == null)
1021: noAttributeError(name);
1022: return ret;
1023: }
1024:
1025: public void noAttributeError(String name) {
1026: throw Py.AttributeError(safeRepr() + " has no attribute '"
1027: + name + "'");
1028: }
1029:
1030: public void readonlyAttributeError(String name) {
1031: throw Py.AttributeError(safeRepr() + " attribute '" + name
1032: + "' is read-only");
1033: }
1034:
1035: /**
1036: * Equivalent to the standard Python __setattr__ method.
1037: * This method can not be overridden.
1038: *
1039: * @param name the name to lookup in this namespace
1040: * @exception Py.AttributeError if the name is not found.
1041: *
1042: * @see #__setattr__(java.lang.String, PyObject)
1043: **/
1044: public final void __setattr__(PyString name, PyObject value) {
1045: __setattr__(name.internedString(), value);
1046: }
1047:
1048: /**
1049: * A variant of the __setattr__ method which accepts a String
1050: * as the key. <b>This String must be interned</b>.
1051: *
1052: * @param name the name whose value will be set -
1053: * <b> must be an interned string </b>.
1054: * @param value the value to set this name to
1055: *
1056: * @see #__setattr__(PyString, PyObject)
1057: **/
1058: public void __setattr__(String name, PyObject value) {
1059: object___setattr__(name, value);
1060: }
1061:
1062: /**
1063: * Equivalent to the standard Python __delattr__ method.
1064: * This method can not be overridden.
1065: *
1066: * @param name the name to which will be removed
1067: * @exception Py.AttributeError if the name doesn't exist
1068: *
1069: * @see #__delattr__(java.lang.String)
1070: **/
1071: public final void __delattr__(PyString name) {
1072: __delattr__(name.internedString());
1073: }
1074:
1075: /**
1076: * A variant of the __delattr__ method which accepts a String
1077: * as the key. <b>This String must be interned</b>.
1078: * By default, this will call
1079: * <code>__delattr__(PyString name)</code>
1080: * with the appropriate args.
1081: * The only reason to override this method is for performance.
1082: *
1083: * @param name the name which will be removed -
1084: * <b> must be an interned string </b>.
1085: * @exception Py.AttributeError if the name doesn't exist
1086: *
1087: * @see #__delattr__(PyString)
1088: **/
1089: public void __delattr__(String name) {
1090: object___delattr__(name);
1091: }
1092:
1093: // Used by import logic.
1094: protected PyObject impAttr(String name) {
1095: return __findattr__(name);
1096: }
1097:
1098: protected void addKeys(PyDictionary accum, String attr) {
1099: PyObject obj = __findattr__(attr);
1100: if (obj == null)
1101: return;
1102: if (obj instanceof PyList) {
1103: PyObject lst_iter = obj.__iter__();
1104: PyObject name;
1105: for (; (name = lst_iter.__iternext__()) != null;) {
1106: accum.__setitem__(name, Py.None);
1107: }
1108: } else {
1109: accum.update(obj);
1110: }
1111: }
1112:
1113: protected void __rawdir__(PyDictionary accum) {
1114: addKeys(accum, "__dict__");
1115: addKeys(accum, "__methods__");
1116: addKeys(accum, "__members__");
1117: fastGetClass().__rawdir__(accum);
1118: }
1119:
1120: /**
1121: * Equivalent to the standard Python __dir__ method.
1122: *
1123: * @return a list of names defined by this object.
1124: **/
1125: public PyObject __dir__() {
1126: PyDictionary accum = new PyDictionary();
1127: __rawdir__(accum);
1128: PyList ret = accum.keys();
1129: ret.sort();
1130: return ret;
1131: }
1132:
1133: public PyObject _doget(PyObject container) {
1134: return this ;
1135: }
1136:
1137: public PyObject _doget(PyObject container, PyObject wherefound) {
1138: return _doget(container);
1139: }
1140:
1141: public boolean _doset(PyObject container, PyObject value) {
1142: return false;
1143: }
1144:
1145: boolean jtryset(PyObject container, PyObject value) {
1146: return _doset(container, value);
1147: }
1148:
1149: boolean jdontdel() {
1150: return false;
1151: }
1152:
1153: /* Numeric coercion */
1154:
1155: /**
1156: * Implements numeric coercion
1157: *
1158: * @param o the other object involved in the coercion
1159: * @return null if no coercion is possible;
1160: * a single PyObject to use to replace o if this is unchanged;
1161: * or a PyObject[2] consisting of replacements for this and o.
1162: **/
1163: public Object __coerce_ex__(PyObject o) {
1164: return null;
1165: }
1166:
1167: /**
1168: * Implements coerce(this,other), result as PyObject[]
1169: * @param other
1170: * @return PyObject[]
1171: */
1172: PyObject[] _coerce(PyObject other) {
1173: Object result;
1174: if (this .getType() == other.getType()
1175: && !(this instanceof PyInstance)) {
1176: return new PyObject[] { this , other };
1177: }
1178: result = this .__coerce_ex__(other);
1179: if (result != null && result != Py.None) {
1180: if (result instanceof PyObject[]) {
1181: return (PyObject[]) result;
1182: } else {
1183: return new PyObject[] { this , (PyObject) result };
1184: }
1185: }
1186: result = other.__coerce_ex__(this );
1187: if (result != null && result != Py.None) {
1188: if (result instanceof PyObject[]) {
1189: return (PyObject[]) result;
1190: } else {
1191: return new PyObject[] { (PyObject) result, other };
1192: }
1193: }
1194: return null;
1195:
1196: }
1197:
1198: /**
1199: * Equivalent to the standard Python __coerce__ method.
1200: *
1201: * This method can not be overridden.
1202: * To implement __coerce__ functionality, override __coerce_ex__ instead.
1203: *
1204: * @param pyo the other object involved in the coercion.
1205: * @return a tuple of this object and pyo coerced to the same type
1206: * or Py.None if no coercion is possible.
1207: * @see org.python.core.PyObject#__coerce_ex__(org.python.core.PyObject)
1208: **/
1209: public final PyObject __coerce__(PyObject pyo) {
1210: Object o = __coerce_ex__(pyo);
1211: if (o == null)
1212: throw Py.AttributeError("__coerce__");
1213: if (o == Py.None)
1214: return (PyObject) o;
1215: if (o instanceof PyObject[])
1216: return new PyTuple((PyObject[]) o);
1217: else
1218: return new PyTuple(new PyObject[] { this , (PyObject) o });
1219: }
1220:
1221: /* The basic comparision operations */
1222:
1223: /**
1224: * Equivalent to the standard Python __cmp__ method.
1225: *
1226: * @param other the object to compare this with.
1227: * @return -1 if this < 0; 0 if this == o; +1 if this > o; -2 if no
1228: * comparison is implemented
1229: **/
1230: public int __cmp__(PyObject other) {
1231: return -2;
1232: }
1233:
1234: /**
1235: * Equivalent to the standard Python __eq__ method.
1236: *
1237: * @param other the object to compare this with.
1238: * @return the result of the comparison.
1239: **/
1240: public PyObject __eq__(PyObject other) {
1241: return null;
1242: }
1243:
1244: /**
1245: * Equivalent to the standard Python __ne__ method.
1246: *
1247: * @param other the object to compare this with.
1248: * @return the result of the comparison.
1249: **/
1250: public PyObject __ne__(PyObject other) {
1251: return null;
1252: }
1253:
1254: /**
1255: * Equivalent to the standard Python __le__ method.
1256: *
1257: * @param other the object to compare this with.
1258: * @return the result of the comparison.
1259: **/
1260: public PyObject __le__(PyObject other) {
1261: return null;
1262: }
1263:
1264: /**
1265: * Equivalent to the standard Python __lt__ method.
1266: *
1267: * @param other the object to compare this with.
1268: * @return the result of the comparison.
1269: **/
1270: public PyObject __lt__(PyObject other) {
1271: return null;
1272: }
1273:
1274: /**
1275: * Equivalent to the standard Python __ge__ method.
1276: *
1277: * @param other the object to compare this with.
1278: * @return the result of the comparison.
1279: **/
1280: public PyObject __ge__(PyObject other) {
1281: return null;
1282: }
1283:
1284: /**
1285: * Equivalent to the standard Python __gt__ method.
1286: *
1287: * @param other the object to compare this with.
1288: * @return the result of the comparison.
1289: **/
1290: public PyObject __gt__(PyObject other) {
1291: return null;
1292: }
1293:
1294: /**
1295: * Implements cmp(this, other)
1296: *
1297: * @param o the object to compare this with.
1298: * @return -1 if this < 0; 0 if this == o; +1 if this > o
1299: **/
1300: public final int _cmp(PyObject o) {
1301: PyObject token = null;
1302: ThreadState ts = Py.getThreadState();
1303: try {
1304: if (++ts.compareStateNesting > 500) {
1305: if ((token = check_recursion(ts, this , o)) == null)
1306: return 0;
1307: }
1308:
1309: PyObject r;
1310: r = __eq__(o);
1311: if (r != null && r.__nonzero__())
1312: return 0;
1313: r = o.__eq__(this );
1314: if (r != null && r.__nonzero__())
1315: return 0;
1316:
1317: r = __lt__(o);
1318: if (r != null && r.__nonzero__())
1319: return -1;
1320: r = o.__gt__(this );
1321: if (r != null && r.__nonzero__())
1322: return -1;
1323:
1324: r = __gt__(o);
1325: if (r != null && r.__nonzero__())
1326: return 1;
1327: r = o.__lt__(this );
1328: if (r != null && r.__nonzero__())
1329: return 1;
1330:
1331: return _cmp_unsafe(o);
1332: } finally {
1333: delete_token(ts, token);
1334: ts.compareStateNesting--;
1335: }
1336: }
1337:
1338: private PyObject make_pair(PyObject o) {
1339: if (System.identityHashCode(this ) < System.identityHashCode(o))
1340: return new PyIdentityTuple(new PyObject[] { this , o });
1341: else
1342: return new PyIdentityTuple(new PyObject[] { o, this });
1343: }
1344:
1345: private final int _default_cmp(PyObject other) {
1346: int result;
1347: if (this ._is(other).__nonzero__())
1348: return 0;
1349:
1350: /* None is smaller than anything */
1351: if (this == Py.None)
1352: return -1;
1353: if (other == Py.None)
1354: return 1;
1355:
1356: // No rational way to compare these, so ask their classes to compare
1357: PyType this _type = this .getType();
1358: PyType other_type = other.getType();
1359: if (this _type == other_type) {
1360: return Py.id(this ) < Py.id(other) ? -1 : 1;
1361: }
1362: result = this _type.fastGetName().compareTo(
1363: other_type.fastGetName());
1364: if (result == 0)
1365: return Py.id(this _type) < Py.id(other_type) ? -1 : 1;
1366: return result < 0 ? -1 : 1;
1367: }
1368:
1369: private final int _cmp_unsafe(PyObject other) {
1370: // Shortcut for equal objects
1371: if (this == other)
1372: return 0;
1373:
1374: int result;
1375: result = this .__cmp__(other);
1376: if (result != -2)
1377: return result;
1378:
1379: if (!(this instanceof PyInstance)) {
1380: result = other.__cmp__(this );
1381: if (result != -2)
1382: return -result;
1383: }
1384:
1385: return this ._default_cmp(other);
1386: }
1387:
1388: /*
1389: * Like _cmp_unsafe but limited to ==/!= as 0/!=0,
1390: * avoids to invoke Py.id
1391: */
1392: private final int _cmpeq_unsafe(PyObject other) {
1393: // Shortcut for equal objects
1394: if (this == other)
1395: return 0;
1396:
1397: int result;
1398: result = this .__cmp__(other);
1399: if (result != -2)
1400: return result;
1401:
1402: if (!(this instanceof PyInstance)) {
1403: result = other.__cmp__(this );
1404: if (result != -2)
1405: return -result;
1406: }
1407:
1408: return this ._is(other).__nonzero__() ? 0 : 1;
1409: }
1410:
1411: private final static PyObject check_recursion(ThreadState ts,
1412: PyObject o1, PyObject o2) {
1413: PyDictionary stateDict = ts.getCompareStateDict();
1414:
1415: PyObject pair = o1.make_pair(o2);
1416:
1417: if (stateDict.__finditem__(pair) != null)
1418: return null;
1419:
1420: stateDict.__setitem__(pair, pair);
1421: return pair;
1422: }
1423:
1424: private final static void delete_token(ThreadState ts,
1425: PyObject token) {
1426: if (token == null)
1427: return;
1428: PyDictionary stateDict = ts.getCompareStateDict();
1429:
1430: stateDict.__delitem__(token);
1431: }
1432:
1433: /**
1434: * Implements the Python expression <code>this == other</code>.
1435: *
1436: * @param o the object to compare this with.
1437: * @return the result of the comparison
1438: **/
1439: public final PyObject _eq(PyObject o) {
1440: PyObject token = null;
1441: PyType t1 = this .getType();
1442: PyType t2 = o.getType();
1443:
1444: if (t1 != t2 && t2.isSubType(t1)) {
1445: return o._eq(this );
1446: }
1447:
1448: ThreadState ts = Py.getThreadState();
1449: try {
1450: if (++ts.compareStateNesting > 10) {
1451: if ((token = check_recursion(ts, this , o)) == null)
1452: return Py.One;
1453: }
1454: PyObject res = __eq__(o);
1455: if (res != null)
1456: return res;
1457: res = o.__eq__(this );
1458: if (res != null)
1459: return res;
1460: return _cmpeq_unsafe(o) == 0 ? Py.One : Py.Zero;
1461: } catch (PyException e) {
1462: if (Py.matchException(e, Py.AttributeError)) {
1463: return Py.Zero;
1464: }
1465: throw e;
1466: } finally {
1467: delete_token(ts, token);
1468: ts.compareStateNesting--;
1469: }
1470: }
1471:
1472: /**
1473: * Implements the Python expression <code>this != other</code>.
1474: *
1475: * @param o the object to compare this with.
1476: * @return the result of the comparison
1477: **/
1478: public final PyObject _ne(PyObject o) {
1479: PyObject token = null;
1480: PyType t1 = this .getType();
1481: PyType t2 = o.getType();
1482:
1483: if (t1 != t2 && t2.isSubType(t1)) {
1484: return o._ne(this );
1485: }
1486:
1487: ThreadState ts = Py.getThreadState();
1488: try {
1489: if (++ts.compareStateNesting > 10) {
1490: if ((token = check_recursion(ts, this , o)) == null)
1491: return Py.Zero;
1492: }
1493: PyObject res = __ne__(o);
1494: if (res != null)
1495: return res;
1496: res = o.__ne__(this );
1497: if (res != null)
1498: return res;
1499: return _cmpeq_unsafe(o) != 0 ? Py.One : Py.Zero;
1500: } finally {
1501: delete_token(ts, token);
1502: ts.compareStateNesting--;
1503: }
1504: }
1505:
1506: /**
1507: * Implements the Python expression <code>this <= other</code>.
1508: *
1509: * @param o the object to compare this with.
1510: * @return the result of the comparison
1511: **/
1512: public final PyObject _le(PyObject o) {
1513: PyObject token = null;
1514: PyType t1 = this .getType();
1515: PyType t2 = o.getType();
1516:
1517: if (t1 != t2 && t2.isSubType(t1)) {
1518: return o._ge(this );
1519: }
1520:
1521: ThreadState ts = Py.getThreadState();
1522: try {
1523: if (++ts.compareStateNesting > 10) {
1524: if ((token = check_recursion(ts, this , o)) == null)
1525: throw Py.ValueError("can't order recursive values");
1526: }
1527: PyObject res = __le__(o);
1528: if (res != null)
1529: return res;
1530: res = o.__ge__(this );
1531: if (res != null)
1532: return res;
1533: return _cmp_unsafe(o) <= 0 ? Py.One : Py.Zero;
1534: } finally {
1535: delete_token(ts, token);
1536: ts.compareStateNesting--;
1537: }
1538: }
1539:
1540: /**
1541: * Implements the Python expression <code>this < other</code>.
1542: *
1543: * @param o the object to compare this with.
1544: * @return the result of the comparison
1545: **/
1546: public final PyObject _lt(PyObject o) {
1547: PyObject token = null;
1548: PyType t1 = this .getType();
1549: PyType t2 = o.getType();
1550:
1551: if (t1 != t2 && t2.isSubType(t1)) {
1552: return o._gt(this );
1553: }
1554:
1555: ThreadState ts = Py.getThreadState();
1556: try {
1557: if (++ts.compareStateNesting > 10) {
1558: if ((token = check_recursion(ts, this , o)) == null)
1559: throw Py.ValueError("can't order recursive values");
1560: }
1561: PyObject res = __lt__(o);
1562: if (res != null)
1563: return res;
1564: res = o.__gt__(this );
1565: if (res != null)
1566: return res;
1567: return _cmp_unsafe(o) < 0 ? Py.One : Py.Zero;
1568: } finally {
1569: delete_token(ts, token);
1570: ts.compareStateNesting--;
1571: }
1572: }
1573:
1574: /**
1575: * Implements the Python expression <code>this >= other</code>.
1576: *
1577: * @param o the object to compare this with.
1578: * @return the result of the comparison
1579: **/
1580: public final PyObject _ge(PyObject o) {
1581: PyObject token = null;
1582: PyType t1 = this .getType();
1583: PyType t2 = o.getType();
1584:
1585: if (t1 != t2 && t2.isSubType(t1)) {
1586: return o._le(this );
1587: }
1588:
1589: ThreadState ts = Py.getThreadState();
1590: try {
1591: if (++ts.compareStateNesting > 10) {
1592: if ((token = check_recursion(ts, this , o)) == null)
1593: throw Py.ValueError("can't order recursive values");
1594: }
1595: PyObject res = __ge__(o);
1596: if (res != null)
1597: return res;
1598: res = o.__le__(this );
1599: if (res != null)
1600: return res;
1601: return _cmp_unsafe(o) >= 0 ? Py.One : Py.Zero;
1602: } finally {
1603: delete_token(ts, token);
1604: ts.compareStateNesting--;
1605: }
1606: }
1607:
1608: /**
1609: * Implements the Python expression <code>this > other</code>.
1610: *
1611: * @param o the object to compare this with.
1612: * @return the result of the comparison
1613: **/
1614: public final PyObject _gt(PyObject o) {
1615: PyObject token = null;
1616: PyType t1 = this .getType();
1617: PyType t2 = o.getType();
1618:
1619: if (t1 != t2 && t2.isSubType(t1)) {
1620: return o._lt(this );
1621: }
1622:
1623: ThreadState ts = Py.getThreadState();
1624: try {
1625: if (++ts.compareStateNesting > 10) {
1626: if ((token = check_recursion(ts, this , o)) == null)
1627: throw Py.ValueError("can't order recursive values");
1628: }
1629: PyObject res = __gt__(o);
1630: if (res != null)
1631: return res;
1632: res = o.__lt__(this );
1633: if (res != null)
1634: return res;
1635: return _cmp_unsafe(o) > 0 ? Py.One : Py.Zero;
1636: } finally {
1637: delete_token(ts, token);
1638: ts.compareStateNesting--;
1639: }
1640:
1641: }
1642:
1643: /**
1644: * Implements <code>is</code> operator.
1645: *
1646: * @param o the object to compare this with.
1647: * @return the result of the comparison
1648: **/
1649: public PyObject _is(PyObject o) {
1650: return this == o ? Py.One : Py.Zero;
1651: }
1652:
1653: /**
1654: * Implements <code>is not</code> operator.
1655: *
1656: * @param o the object to compare this with.
1657: * @return the result of the comparison
1658: **/
1659: public PyObject _isnot(PyObject o) {
1660: return this != o ? Py.One : Py.Zero;
1661: }
1662:
1663: /**
1664: * Implements <code>in</code> operator.
1665: *
1666: * @param o the container to search for this element.
1667: * @return the result of the search.
1668: **/
1669: public final PyObject _in(PyObject o) {
1670: return Py.newBoolean(o.__contains__(this ));
1671: }
1672:
1673: /**
1674: * Implements <code>not in</code> operator.
1675: *
1676: * @param o the container to search for this element.
1677: * @return the result of the search.
1678: **/
1679: public final PyObject _notin(PyObject o) {
1680: return Py.newBoolean(!o.__contains__(this ));
1681: }
1682:
1683: /**
1684: * Equivalent to the standard Python __contains__ method.
1685: *
1686: * @param o the element to search for in this container.
1687: * @return the result of the search.
1688: **/
1689: public boolean __contains__(PyObject o) {
1690: return object___contains__(o);
1691: }
1692:
1693: final boolean object___contains__(PyObject o) {
1694: PyObject iter = __iter__();
1695: for (PyObject item = null; (item = iter.__iternext__()) != null;) {
1696: if (o._eq(item).__nonzero__())
1697: return true;
1698: }
1699: return false;
1700: }
1701:
1702: /**
1703: * Implements boolean not
1704: *
1705: * @return not this.
1706: **/
1707: public PyObject __not__() {
1708: return __nonzero__() ? Py.Zero : Py.One;
1709: }
1710:
1711: /* The basic numeric operations */
1712:
1713: /**
1714: * Equivalent to the standard Python __hex__ method
1715: * Should only be overridden by numeric objects that can be
1716: * reasonably represented as a hexadecimal string.
1717: *
1718: * @return a string representing this object as a hexadecimal number.
1719: **/
1720: public PyString __hex__() {
1721: throw Py.AttributeError("__hex__");
1722: }
1723:
1724: /**
1725: * Equivalent to the standard Python __oct__ method.
1726: * Should only be overridden by numeric objects that can be
1727: * reasonably represented as an octal string.
1728: *
1729: * @return a string representing this object as an octal number.
1730: **/
1731: public PyString __oct__() {
1732: throw Py.AttributeError("__oct__");
1733: }
1734:
1735: /**
1736: * Equivalent to the standard Python __int__ method.
1737: * Should only be overridden by numeric objects that can be
1738: * reasonably coerced into an integer.
1739: *
1740: * @return an integer corresponding to the value of this object.
1741: **/
1742: public PyObject __int__() {
1743: throw Py.AttributeError("__int__");
1744: }
1745:
1746: /**
1747: * Equivalent to the standard Python __long__ method.
1748: * Should only be overridden by numeric objects that can be
1749: * reasonably coerced into a python long.
1750: *
1751: * @return a PyLong corresponding to the value of this object.
1752: **/
1753: public PyLong __long__() {
1754: throw Py.AttributeError("__long__");
1755: }
1756:
1757: /**
1758: * Equivalent to the standard Python __float__ method.
1759: * Should only be overridden by numeric objects that can be
1760: * reasonably coerced into a python float.
1761: *
1762: * @return a float corresponding to the value of this object.
1763: **/
1764: public PyFloat __float__() {
1765: throw Py.AttributeError("__float__");
1766: }
1767:
1768: /**
1769: * Equivalent to the standard Python __complex__ method.
1770: * Should only be overridden by numeric objects that can be
1771: * reasonably coerced into a python complex number.
1772: *
1773: * @return a complex number corresponding to the value of this object.
1774: **/
1775: public PyComplex __complex__() {
1776: throw Py.AttributeError("__complex__");
1777: }
1778:
1779: /**
1780: * Equivalent to the standard Python __pos__ method.
1781: *
1782: * @return +this.
1783: **/
1784: public PyObject __pos__() {
1785: throw Py.AttributeError("__pos__");
1786: }
1787:
1788: /**
1789: * Equivalent to the standard Python __neg__ method.
1790: *
1791: * @return -this.
1792: **/
1793: public PyObject __neg__() {
1794: throw Py.AttributeError("__neg__");
1795: }
1796:
1797: /**
1798: * Equivalent to the standard Python __abs__ method.
1799: *
1800: * @return abs(this).
1801: **/
1802: public PyObject __abs__() {
1803: throw Py.AttributeError("__abs__");
1804: }
1805:
1806: /**
1807: * Equivalent to the standard Python __invert__ method.
1808: *
1809: * @return ~this.
1810: **/
1811: public PyObject __invert__() {
1812: throw Py.AttributeError("__invert__");
1813: }
1814:
1815: /**
1816: * @param op the String form of the op (e.g. "+")
1817: * @param o2 the right operand
1818: */
1819: protected final String _unsupportedop(String op, PyObject o2) {
1820: Object[] args = { op, getType().fastGetName(),
1821: o2.getType().fastGetName() };
1822: String msg = unsupportedopMessage(op, o2);
1823: if (msg == null) {
1824: msg = o2.runsupportedopMessage(op, o2);
1825: }
1826: if (msg == null) {
1827: msg = "unsupported operand type(s) for {0}: ''{1}'' and ''{2}''";
1828: }
1829: return MessageFormat.format(msg, args);
1830: }
1831:
1832: /**
1833: * Should return an error message suitable for substitution where.
1834: *
1835: * {0} is the op name.
1836: * {1} is the left operand type.
1837: * {2} is the right operand type.
1838: */
1839: protected String unsupportedopMessage(String op, PyObject o2) {
1840: return null;
1841: }
1842:
1843: /**
1844: * Should return an error message suitable for substitution where.
1845: *
1846: * {0} is the op name.
1847: * {1} is the left operand type.
1848: * {2} is the right operand type.
1849: */
1850: protected String runsupportedopMessage(String op, PyObject o2) {
1851: return null;
1852: }
1853:
1854: /**
1855: * Implements the three argument power function.
1856: *
1857: * @param o2 the power to raise this number to.
1858: * @param o3 the modulus to perform this operation in or null if no
1859: * modulo is to be used
1860: * @return this object raised to the given power in the given modulus
1861: **/
1862: public PyObject __pow__(PyObject o2, PyObject o3) {
1863: return null;
1864: }
1865:
1866: private PyObject _binop_rule(PyType t1, PyObject o2, PyType t2,
1867: String left, String right, String op) {
1868: /*
1869: * this is the general rule for binary operation dispatching try first
1870: * __xxx__ with this and then __rxxx__ with o2 unless o2 is an instance
1871: * of subclass of the type of this, and further __xxx__ and __rxxx__ are
1872: * unrelated ( checked here by looking at where in the hierarchy they
1873: * are defined), in that case try them in the reverse order. This is the
1874: * same formulation as used by PyPy, see also
1875: * test_descr.subclass_right_op.
1876: */
1877: PyObject o1 = this ;
1878: PyObject[] where = new PyObject[1];
1879: PyObject where1 = null, where2 = null;
1880: PyObject impl1 = t1.lookup_where(left, where);
1881: where1 = where[0];
1882: PyObject impl2 = t2.lookup_where(right, where);
1883: where2 = where[0];
1884: if (impl2 != null && where1 != where2 && t2.isSubType(t1)) {
1885: PyObject tmp = o1;
1886: o1 = o2;
1887: o2 = tmp;
1888: tmp = impl1;
1889: impl1 = impl2;
1890: impl2 = tmp;
1891: PyType ttmp;
1892: ttmp = t1;
1893: t1 = t2;
1894: t2 = ttmp;
1895: }
1896: PyObject res = null;
1897: if (impl1 != null) {
1898: res = impl1.__get__(o1, t1).__call__(o2);
1899: if (res != Py.NotImplemented) {
1900: return res;
1901: }
1902: }
1903: if (impl2 != null) {
1904: res = impl2.__get__(o2, t2).__call__(o1);
1905: if (res != Py.NotImplemented) {
1906: return res;
1907: }
1908: }
1909: throw Py.TypeError(_unsupportedop(op, o2));
1910: }
1911:
1912: // Generated by make_binops.py (Begin)
1913:
1914: /**
1915: * Equivalent to the standard Python __add__ method
1916: * @param other the object to perform this binary operation with
1917: * (the right-hand operand).
1918: * @return the result of the add, or null if this operation
1919: * is not defined
1920: **/
1921: public PyObject __add__(PyObject other) {
1922: return null;
1923: }
1924:
1925: /**
1926: * Equivalent to the standard Python __radd__ method
1927: * @param other the object to perform this binary operation with
1928: * (the left-hand operand).
1929: * @return the result of the add, or null if this operation
1930: * is not defined.
1931: **/
1932: public PyObject __radd__(PyObject other) {
1933: return null;
1934: }
1935:
1936: /**
1937: * Equivalent to the standard Python __iadd__ method
1938: * @param other the object to perform this binary operation with
1939: * (the right-hand operand).
1940: * @return the result of the add, or null if this operation
1941: * is not defined
1942: **/
1943: public PyObject __iadd__(PyObject other) {
1944: return _add(other);
1945: }
1946:
1947: /**
1948: * Implements the Python expression <code>this + o2</code>
1949: * @param o2 the object to perform this binary operation with.
1950: * @return the result of the add.
1951: * @exception Py.TypeError if this operation can't be performed
1952: * with these operands.
1953: **/
1954: public final PyObject _add(PyObject o2) {
1955: PyType t1 = this .getType();
1956: PyType t2 = o2.getType();
1957: if (t1 == t2 || t1.builtin && t2.builtin) {
1958: return this ._basic_add(o2);
1959: }
1960: return _binop_rule(t1, o2, t2, "__add__", "__radd__", "+");
1961: }
1962:
1963: /**
1964: * Implements the Python expression <code>this + o2</code>
1965: * when this and o2 have the same type or are builtin types.
1966: * @param o2 the object to perform this binary operation with.
1967: * @return the result of the add.
1968: * @exception Py.TypeError if this operation can't be performed
1969: * with these operands.
1970: **/
1971: final PyObject _basic_add(PyObject o2) {
1972: PyObject x = __add__(o2);
1973: if (x != null)
1974: return x;
1975: x = o2.__radd__(this );
1976: if (x != null)
1977: return x;
1978: throw Py.TypeError(_unsupportedop("+", o2));
1979: }
1980:
1981: /**
1982: * Equivalent to the standard Python __sub__ method
1983: * @param other the object to perform this binary operation with
1984: * (the right-hand operand).
1985: * @return the result of the sub, or null if this operation
1986: * is not defined
1987: **/
1988: public PyObject __sub__(PyObject other) {
1989: return null;
1990: }
1991:
1992: /**
1993: * Equivalent to the standard Python __rsub__ method
1994: * @param other the object to perform this binary operation with
1995: * (the left-hand operand).
1996: * @return the result of the sub, or null if this operation
1997: * is not defined.
1998: **/
1999: public PyObject __rsub__(PyObject other) {
2000: return null;
2001: }
2002:
2003: /**
2004: * Equivalent to the standard Python __isub__ method
2005: * @param other the object to perform this binary operation with
2006: * (the right-hand operand).
2007: * @return the result of the sub, or null if this operation
2008: * is not defined
2009: **/
2010: public PyObject __isub__(PyObject other) {
2011: return _sub(other);
2012: }
2013:
2014: /**
2015: * Implements the Python expression <code>this - o2</code>
2016: * @param o2 the object to perform this binary operation with.
2017: * @return the result of the sub.
2018: * @exception Py.TypeError if this operation can't be performed
2019: * with these operands.
2020: **/
2021: public final PyObject _sub(PyObject o2) {
2022: PyType t1 = this .getType();
2023: PyType t2 = o2.getType();
2024: if (t1 == t2 || t1.builtin && t2.builtin) {
2025: return this ._basic_sub(o2);
2026: }
2027: return _binop_rule(t1, o2, t2, "__sub__", "__rsub__", "-");
2028: }
2029:
2030: /**
2031: * Implements the Python expression <code>this - o2</code>
2032: * when this and o2 have the same type or are builtin types.
2033: * @param o2 the object to perform this binary operation with.
2034: * @return the result of the sub.
2035: * @exception Py.TypeError if this operation can't be performed
2036: * with these operands.
2037: **/
2038: final PyObject _basic_sub(PyObject o2) {
2039: PyObject x = __sub__(o2);
2040: if (x != null)
2041: return x;
2042: x = o2.__rsub__(this );
2043: if (x != null)
2044: return x;
2045: throw Py.TypeError(_unsupportedop("-", o2));
2046: }
2047:
2048: /**
2049: * Equivalent to the standard Python __mul__ method
2050: * @param other the object to perform this binary operation with
2051: * (the right-hand operand).
2052: * @return the result of the mul, or null if this operation
2053: * is not defined
2054: **/
2055: public PyObject __mul__(PyObject other) {
2056: return null;
2057: }
2058:
2059: /**
2060: * Equivalent to the standard Python __rmul__ method
2061: * @param other the object to perform this binary operation with
2062: * (the left-hand operand).
2063: * @return the result of the mul, or null if this operation
2064: * is not defined.
2065: **/
2066: public PyObject __rmul__(PyObject other) {
2067: return null;
2068: }
2069:
2070: /**
2071: * Equivalent to the standard Python __imul__ method
2072: * @param other the object to perform this binary operation with
2073: * (the right-hand operand).
2074: * @return the result of the mul, or null if this operation
2075: * is not defined
2076: **/
2077: public PyObject __imul__(PyObject other) {
2078: return _mul(other);
2079: }
2080:
2081: /**
2082: * Implements the Python expression <code>this * o2</code>
2083: * @param o2 the object to perform this binary operation with.
2084: * @return the result of the mul.
2085: * @exception Py.TypeError if this operation can't be performed
2086: * with these operands.
2087: **/
2088: public final PyObject _mul(PyObject o2) {
2089: PyType t1 = this .getType();
2090: PyType t2 = o2.getType();
2091: if (t1 == t2 || t1.builtin && t2.builtin) {
2092: return this ._basic_mul(o2);
2093: }
2094: return _binop_rule(t1, o2, t2, "__mul__", "__rmul__", "*");
2095: }
2096:
2097: /**
2098: * Implements the Python expression <code>this * o2</code>
2099: * when this and o2 have the same type or are builtin types.
2100: * @param o2 the object to perform this binary operation with.
2101: * @return the result of the mul.
2102: * @exception Py.TypeError if this operation can't be performed
2103: * with these operands.
2104: **/
2105: final PyObject _basic_mul(PyObject o2) {
2106: PyObject x = __mul__(o2);
2107: if (x != null)
2108: return x;
2109: x = o2.__rmul__(this );
2110: if (x != null)
2111: return x;
2112: throw Py.TypeError(_unsupportedop("*", o2));
2113: }
2114:
2115: /**
2116: * Equivalent to the standard Python __div__ method
2117: * @param other the object to perform this binary operation with
2118: * (the right-hand operand).
2119: * @return the result of the div, or null if this operation
2120: * is not defined
2121: **/
2122: public PyObject __div__(PyObject other) {
2123: return null;
2124: }
2125:
2126: /**
2127: * Equivalent to the standard Python __rdiv__ method
2128: * @param other the object to perform this binary operation with
2129: * (the left-hand operand).
2130: * @return the result of the div, or null if this operation
2131: * is not defined.
2132: **/
2133: public PyObject __rdiv__(PyObject other) {
2134: return null;
2135: }
2136:
2137: /**
2138: * Equivalent to the standard Python __idiv__ method
2139: * @param other the object to perform this binary operation with
2140: * (the right-hand operand).
2141: * @return the result of the div, or null if this operation
2142: * is not defined
2143: **/
2144: public PyObject __idiv__(PyObject other) {
2145: return _div(other);
2146: }
2147:
2148: /**
2149: * Implements the Python expression <code>this / o2</code>
2150: * @param o2 the object to perform this binary operation with.
2151: * @return the result of the div.
2152: * @exception Py.TypeError if this operation can't be performed
2153: * with these operands.
2154: **/
2155: public final PyObject _div(PyObject o2) {
2156: PyType t1 = this .getType();
2157: PyType t2 = o2.getType();
2158: if (t1 == t2 || t1.builtin && t2.builtin) {
2159: return this ._basic_div(o2);
2160: }
2161: return _binop_rule(t1, o2, t2, "__div__", "__rdiv__", "/");
2162: }
2163:
2164: /**
2165: * Implements the Python expression <code>this / o2</code>
2166: * when this and o2 have the same type or are builtin types.
2167: * @param o2 the object to perform this binary operation with.
2168: * @return the result of the div.
2169: * @exception Py.TypeError if this operation can't be performed
2170: * with these operands.
2171: **/
2172: final PyObject _basic_div(PyObject o2) {
2173: if (Options.Qnew)
2174: return _truediv(o2);
2175: PyObject x = __div__(o2);
2176: if (x != null)
2177: return x;
2178: x = o2.__rdiv__(this );
2179: if (x != null)
2180: return x;
2181: throw Py.TypeError(_unsupportedop("/", o2));
2182: }
2183:
2184: /**
2185: * Equivalent to the standard Python __floordiv__ method
2186: * @param other the object to perform this binary operation with
2187: * (the right-hand operand).
2188: * @return the result of the floordiv, or null if this operation
2189: * is not defined
2190: **/
2191: public PyObject __floordiv__(PyObject other) {
2192: return null;
2193: }
2194:
2195: /**
2196: * Equivalent to the standard Python __rfloordiv__ method
2197: * @param other the object to perform this binary operation with
2198: * (the left-hand operand).
2199: * @return the result of the floordiv, or null if this operation
2200: * is not defined.
2201: **/
2202: public PyObject __rfloordiv__(PyObject other) {
2203: return null;
2204: }
2205:
2206: /**
2207: * Equivalent to the standard Python __ifloordiv__ method
2208: * @param other the object to perform this binary operation with
2209: * (the right-hand operand).
2210: * @return the result of the floordiv, or null if this operation
2211: * is not defined
2212: **/
2213: public PyObject __ifloordiv__(PyObject other) {
2214: return _floordiv(other);
2215: }
2216:
2217: /**
2218: * Implements the Python expression <code>this // o2</code>
2219: * @param o2 the object to perform this binary operation with.
2220: * @return the result of the floordiv.
2221: * @exception Py.TypeError if this operation can't be performed
2222: * with these operands.
2223: **/
2224: public final PyObject _floordiv(PyObject o2) {
2225: PyType t1 = this .getType();
2226: PyType t2 = o2.getType();
2227: if (t1 == t2 || t1.builtin && t2.builtin) {
2228: return this ._basic_floordiv(o2);
2229: }
2230: return _binop_rule(t1, o2, t2, "__floordiv__", "__rfloordiv__",
2231: "//");
2232: }
2233:
2234: /**
2235: * Implements the Python expression <code>this // o2</code>
2236: * when this and o2 have the same type or are builtin types.
2237: * @param o2 the object to perform this binary operation with.
2238: * @return the result of the floordiv.
2239: * @exception Py.TypeError if this operation can't be performed
2240: * with these operands.
2241: **/
2242: final PyObject _basic_floordiv(PyObject o2) {
2243: PyObject x = __floordiv__(o2);
2244: if (x != null)
2245: return x;
2246: x = o2.__rfloordiv__(this );
2247: if (x != null)
2248: return x;
2249: throw Py.TypeError(_unsupportedop("//", o2));
2250: }
2251:
2252: /**
2253: * Equivalent to the standard Python __truediv__ method
2254: * @param other the object to perform this binary operation with
2255: * (the right-hand operand).
2256: * @return the result of the truediv, or null if this operation
2257: * is not defined
2258: **/
2259: public PyObject __truediv__(PyObject other) {
2260: return null;
2261: }
2262:
2263: /**
2264: * Equivalent to the standard Python __rtruediv__ method
2265: * @param other the object to perform this binary operation with
2266: * (the left-hand operand).
2267: * @return the result of the truediv, or null if this operation
2268: * is not defined.
2269: **/
2270: public PyObject __rtruediv__(PyObject other) {
2271: return null;
2272: }
2273:
2274: /**
2275: * Equivalent to the standard Python __itruediv__ method
2276: * @param other the object to perform this binary operation with
2277: * (the right-hand operand).
2278: * @return the result of the truediv, or null if this operation
2279: * is not defined
2280: **/
2281: public PyObject __itruediv__(PyObject other) {
2282: return _truediv(other);
2283: }
2284:
2285: /**
2286: * Implements the Python expression <code>this / o2</code>
2287: * @param o2 the object to perform this binary operation with.
2288: * @return the result of the truediv.
2289: * @exception Py.TypeError if this operation can't be performed
2290: * with these operands.
2291: **/
2292: public final PyObject _truediv(PyObject o2) {
2293: PyType t1 = this .getType();
2294: PyType t2 = o2.getType();
2295: if (t1 == t2 || t1.builtin && t2.builtin) {
2296: return this ._basic_truediv(o2);
2297: }
2298: return _binop_rule(t1, o2, t2, "__truediv__", "__rtruediv__",
2299: "/");
2300: }
2301:
2302: /**
2303: * Implements the Python expression <code>this / o2</code>
2304: * when this and o2 have the same type or are builtin types.
2305: * @param o2 the object to perform this binary operation with.
2306: * @return the result of the truediv.
2307: * @exception Py.TypeError if this operation can't be performed
2308: * with these operands.
2309: **/
2310: final PyObject _basic_truediv(PyObject o2) {
2311: PyObject x = __truediv__(o2);
2312: if (x != null)
2313: return x;
2314: x = o2.__rtruediv__(this );
2315: if (x != null)
2316: return x;
2317: throw Py.TypeError(_unsupportedop("/", o2));
2318: }
2319:
2320: /**
2321: * Equivalent to the standard Python __mod__ method
2322: * @param other the object to perform this binary operation with
2323: * (the right-hand operand).
2324: * @return the result of the mod, or null if this operation
2325: * is not defined
2326: **/
2327: public PyObject __mod__(PyObject other) {
2328: return null;
2329: }
2330:
2331: /**
2332: * Equivalent to the standard Python __rmod__ method
2333: * @param other the object to perform this binary operation with
2334: * (the left-hand operand).
2335: * @return the result of the mod, or null if this operation
2336: * is not defined.
2337: **/
2338: public PyObject __rmod__(PyObject other) {
2339: return null;
2340: }
2341:
2342: /**
2343: * Equivalent to the standard Python __imod__ method
2344: * @param other the object to perform this binary operation with
2345: * (the right-hand operand).
2346: * @return the result of the mod, or null if this operation
2347: * is not defined
2348: **/
2349: public PyObject __imod__(PyObject other) {
2350: return _mod(other);
2351: }
2352:
2353: /**
2354: * Implements the Python expression <code>this % o2</code>
2355: * @param o2 the object to perform this binary operation with.
2356: * @return the result of the mod.
2357: * @exception Py.TypeError if this operation can't be performed
2358: * with these operands.
2359: **/
2360: public final PyObject _mod(PyObject o2) {
2361: PyType t1 = this .getType();
2362: PyType t2 = o2.getType();
2363: if (t1 == t2 || t1.builtin && t2.builtin) {
2364: return this ._basic_mod(o2);
2365: }
2366: return _binop_rule(t1, o2, t2, "__mod__", "__rmod__", "%");
2367: }
2368:
2369: /**
2370: * Implements the Python expression <code>this % o2</code>
2371: * when this and o2 have the same type or are builtin types.
2372: * @param o2 the object to perform this binary operation with.
2373: * @return the result of the mod.
2374: * @exception Py.TypeError if this operation can't be performed
2375: * with these operands.
2376: **/
2377: final PyObject _basic_mod(PyObject o2) {
2378: PyObject x = __mod__(o2);
2379: if (x != null)
2380: return x;
2381: x = o2.__rmod__(this );
2382: if (x != null)
2383: return x;
2384: throw Py.TypeError(_unsupportedop("%", o2));
2385: }
2386:
2387: /**
2388: * Equivalent to the standard Python __divmod__ method
2389: * @param other the object to perform this binary operation with
2390: * (the right-hand operand).
2391: * @return the result of the divmod, or null if this operation
2392: * is not defined
2393: **/
2394: public PyObject __divmod__(PyObject other) {
2395: return null;
2396: }
2397:
2398: /**
2399: * Equivalent to the standard Python __rdivmod__ method
2400: * @param other the object to perform this binary operation with
2401: * (the left-hand operand).
2402: * @return the result of the divmod, or null if this operation
2403: * is not defined.
2404: **/
2405: public PyObject __rdivmod__(PyObject other) {
2406: return null;
2407: }
2408:
2409: /**
2410: * Equivalent to the standard Python __idivmod__ method
2411: * @param other the object to perform this binary operation with
2412: * (the right-hand operand).
2413: * @return the result of the divmod, or null if this operation
2414: * is not defined
2415: **/
2416: public PyObject __idivmod__(PyObject other) {
2417: return _divmod(other);
2418: }
2419:
2420: /**
2421: * Implements the Python expression <code>this divmod o2</code>
2422: * @param o2 the object to perform this binary operation with.
2423: * @return the result of the divmod.
2424: * @exception Py.TypeError if this operation can't be performed
2425: * with these operands.
2426: **/
2427: public final PyObject _divmod(PyObject o2) {
2428: PyType t1 = this .getType();
2429: PyType t2 = o2.getType();
2430: if (t1 == t2 || t1.builtin && t2.builtin) {
2431: return this ._basic_divmod(o2);
2432: }
2433: return _binop_rule(t1, o2, t2, "__divmod__", "__rdivmod__",
2434: "divmod");
2435: }
2436:
2437: /**
2438: * Implements the Python expression <code>this divmod o2</code>
2439: * when this and o2 have the same type or are builtin types.
2440: * @param o2 the object to perform this binary operation with.
2441: * @return the result of the divmod.
2442: * @exception Py.TypeError if this operation can't be performed
2443: * with these operands.
2444: **/
2445: final PyObject _basic_divmod(PyObject o2) {
2446: PyObject x = __divmod__(o2);
2447: if (x != null)
2448: return x;
2449: x = o2.__rdivmod__(this );
2450: if (x != null)
2451: return x;
2452: throw Py.TypeError(_unsupportedop("divmod", o2));
2453: }
2454:
2455: /**
2456: * Equivalent to the standard Python __pow__ method
2457: * @param other the object to perform this binary operation with
2458: * (the right-hand operand).
2459: * @return the result of the pow, or null if this operation
2460: * is not defined
2461: **/
2462: public PyObject __pow__(PyObject other) {
2463: return __pow__(other, null);
2464: }
2465:
2466: /**
2467: * Equivalent to the standard Python __rpow__ method
2468: * @param other the object to perform this binary operation with
2469: * (the left-hand operand).
2470: * @return the result of the pow, or null if this operation
2471: * is not defined.
2472: **/
2473: public PyObject __rpow__(PyObject other) {
2474: return null;
2475: }
2476:
2477: /**
2478: * Equivalent to the standard Python __ipow__ method
2479: * @param other the object to perform this binary operation with
2480: * (the right-hand operand).
2481: * @return the result of the pow, or null if this operation
2482: * is not defined
2483: **/
2484: public PyObject __ipow__(PyObject other) {
2485: return _pow(other);
2486: }
2487:
2488: /**
2489: * Implements the Python expression <code>this ** o2</code>
2490: * @param o2 the object to perform this binary operation with.
2491: * @return the result of the pow.
2492: * @exception Py.TypeError if this operation can't be performed
2493: * with these operands.
2494: **/
2495: public final PyObject _pow(PyObject o2) {
2496: PyType t1 = this .getType();
2497: PyType t2 = o2.getType();
2498: if (t1 == t2 || t1.builtin && t2.builtin) {
2499: return this ._basic_pow(o2);
2500: }
2501: return _binop_rule(t1, o2, t2, "__pow__", "__rpow__", "**");
2502: }
2503:
2504: /**
2505: * Implements the Python expression <code>this ** o2</code>
2506: * when this and o2 have the same type or are builtin types.
2507: * @param o2 the object to perform this binary operation with.
2508: * @return the result of the pow.
2509: * @exception Py.TypeError if this operation can't be performed
2510: * with these operands.
2511: **/
2512: final PyObject _basic_pow(PyObject o2) {
2513: PyObject x = __pow__(o2);
2514: if (x != null)
2515: return x;
2516: x = o2.__rpow__(this );
2517: if (x != null)
2518: return x;
2519: throw Py.TypeError(_unsupportedop("**", o2));
2520: }
2521:
2522: /**
2523: * Equivalent to the standard Python __lshift__ method
2524: * @param other the object to perform this binary operation with
2525: * (the right-hand operand).
2526: * @return the result of the lshift, or null if this operation
2527: * is not defined
2528: **/
2529: public PyObject __lshift__(PyObject other) {
2530: return null;
2531: }
2532:
2533: /**
2534: * Equivalent to the standard Python __rlshift__ method
2535: * @param other the object to perform this binary operation with
2536: * (the left-hand operand).
2537: * @return the result of the lshift, or null if this operation
2538: * is not defined.
2539: **/
2540: public PyObject __rlshift__(PyObject other) {
2541: return null;
2542: }
2543:
2544: /**
2545: * Equivalent to the standard Python __ilshift__ method
2546: * @param other the object to perform this binary operation with
2547: * (the right-hand operand).
2548: * @return the result of the lshift, or null if this operation
2549: * is not defined
2550: **/
2551: public PyObject __ilshift__(PyObject other) {
2552: return _lshift(other);
2553: }
2554:
2555: /**
2556: * Implements the Python expression <code>this << o2</code>
2557: * @param o2 the object to perform this binary operation with.
2558: * @return the result of the lshift.
2559: * @exception Py.TypeError if this operation can't be performed
2560: * with these operands.
2561: **/
2562: public final PyObject _lshift(PyObject o2) {
2563: PyType t1 = this .getType();
2564: PyType t2 = o2.getType();
2565: if (t1 == t2 || t1.builtin && t2.builtin) {
2566: return this ._basic_lshift(o2);
2567: }
2568: return _binop_rule(t1, o2, t2, "__lshift__", "__rlshift__",
2569: "<<");
2570: }
2571:
2572: /**
2573: * Implements the Python expression <code>this << o2</code>
2574: * when this and o2 have the same type or are builtin types.
2575: * @param o2 the object to perform this binary operation with.
2576: * @return the result of the lshift.
2577: * @exception Py.TypeError if this operation can't be performed
2578: * with these operands.
2579: **/
2580: final PyObject _basic_lshift(PyObject o2) {
2581: PyObject x = __lshift__(o2);
2582: if (x != null)
2583: return x;
2584: x = o2.__rlshift__(this );
2585: if (x != null)
2586: return x;
2587: throw Py.TypeError(_unsupportedop("<<", o2));
2588: }
2589:
2590: /**
2591: * Equivalent to the standard Python __rshift__ method
2592: * @param other the object to perform this binary operation with
2593: * (the right-hand operand).
2594: * @return the result of the rshift, or null if this operation
2595: * is not defined
2596: **/
2597: public PyObject __rshift__(PyObject other) {
2598: return null;
2599: }
2600:
2601: /**
2602: * Equivalent to the standard Python __rrshift__ method
2603: * @param other the object to perform this binary operation with
2604: * (the left-hand operand).
2605: * @return the result of the rshift, or null if this operation
2606: * is not defined.
2607: **/
2608: public PyObject __rrshift__(PyObject other) {
2609: return null;
2610: }
2611:
2612: /**
2613: * Equivalent to the standard Python __irshift__ method
2614: * @param other the object to perform this binary operation with
2615: * (the right-hand operand).
2616: * @return the result of the rshift, or null if this operation
2617: * is not defined
2618: **/
2619: public PyObject __irshift__(PyObject other) {
2620: return _rshift(other);
2621: }
2622:
2623: /**
2624: * Implements the Python expression <code>this >> o2</code>
2625: * @param o2 the object to perform this binary operation with.
2626: * @return the result of the rshift.
2627: * @exception Py.TypeError if this operation can't be performed
2628: * with these operands.
2629: **/
2630: public final PyObject _rshift(PyObject o2) {
2631: PyType t1 = this .getType();
2632: PyType t2 = o2.getType();
2633: if (t1 == t2 || t1.builtin && t2.builtin) {
2634: return this ._basic_rshift(o2);
2635: }
2636: return _binop_rule(t1, o2, t2, "__rshift__", "__rrshift__",
2637: ">>");
2638: }
2639:
2640: /**
2641: * Implements the Python expression <code>this >> o2</code>
2642: * when this and o2 have the same type or are builtin types.
2643: * @param o2 the object to perform this binary operation with.
2644: * @return the result of the rshift.
2645: * @exception Py.TypeError if this operation can't be performed
2646: * with these operands.
2647: **/
2648: final PyObject _basic_rshift(PyObject o2) {
2649: PyObject x = __rshift__(o2);
2650: if (x != null)
2651: return x;
2652: x = o2.__rrshift__(this );
2653: if (x != null)
2654: return x;
2655: throw Py.TypeError(_unsupportedop(">>", o2));
2656: }
2657:
2658: /**
2659: * Equivalent to the standard Python __and__ method
2660: * @param other the object to perform this binary operation with
2661: * (the right-hand operand).
2662: * @return the result of the and, or null if this operation
2663: * is not defined
2664: **/
2665: public PyObject __and__(PyObject other) {
2666: return null;
2667: }
2668:
2669: /**
2670: * Equivalent to the standard Python __rand__ method
2671: * @param other the object to perform this binary operation with
2672: * (the left-hand operand).
2673: * @return the result of the and, or null if this operation
2674: * is not defined.
2675: **/
2676: public PyObject __rand__(PyObject other) {
2677: return null;
2678: }
2679:
2680: /**
2681: * Equivalent to the standard Python __iand__ method
2682: * @param other the object to perform this binary operation with
2683: * (the right-hand operand).
2684: * @return the result of the and, or null if this operation
2685: * is not defined
2686: **/
2687: public PyObject __iand__(PyObject other) {
2688: return _and(other);
2689: }
2690:
2691: /**
2692: * Implements the Python expression <code>this & o2</code>
2693: * @param o2 the object to perform this binary operation with.
2694: * @return the result of the and.
2695: * @exception Py.TypeError if this operation can't be performed
2696: * with these operands.
2697: **/
2698: public final PyObject _and(PyObject o2) {
2699: PyType t1 = this .getType();
2700: PyType t2 = o2.getType();
2701: if (t1 == t2 || t1.builtin && t2.builtin) {
2702: return this ._basic_and(o2);
2703: }
2704: return _binop_rule(t1, o2, t2, "__and__", "__rand__", "&");
2705: }
2706:
2707: /**
2708: * Implements the Python expression <code>this & o2</code>
2709: * when this and o2 have the same type or are builtin types.
2710: * @param o2 the object to perform this binary operation with.
2711: * @return the result of the and.
2712: * @exception Py.TypeError if this operation can't be performed
2713: * with these operands.
2714: **/
2715: final PyObject _basic_and(PyObject o2) {
2716: PyObject x = __and__(o2);
2717: if (x != null)
2718: return x;
2719: x = o2.__rand__(this );
2720: if (x != null)
2721: return x;
2722: throw Py.TypeError(_unsupportedop("&", o2));
2723: }
2724:
2725: /**
2726: * Equivalent to the standard Python __or__ method
2727: * @param other the object to perform this binary operation with
2728: * (the right-hand operand).
2729: * @return the result of the or, or null if this operation
2730: * is not defined
2731: **/
2732: public PyObject __or__(PyObject other) {
2733: return null;
2734: }
2735:
2736: /**
2737: * Equivalent to the standard Python __ror__ method
2738: * @param other the object to perform this binary operation with
2739: * (the left-hand operand).
2740: * @return the result of the or, or null if this operation
2741: * is not defined.
2742: **/
2743: public PyObject __ror__(PyObject other) {
2744: return null;
2745: }
2746:
2747: /**
2748: * Equivalent to the standard Python __ior__ method
2749: * @param other the object to perform this binary operation with
2750: * (the right-hand operand).
2751: * @return the result of the or, or null if this operation
2752: * is not defined
2753: **/
2754: public PyObject __ior__(PyObject other) {
2755: return _or(other);
2756: }
2757:
2758: /**
2759: * Implements the Python expression <code>this | o2</code>
2760: * @param o2 the object to perform this binary operation with.
2761: * @return the result of the or.
2762: * @exception Py.TypeError if this operation can't be performed
2763: * with these operands.
2764: **/
2765: public final PyObject _or(PyObject o2) {
2766: PyType t1 = this .getType();
2767: PyType t2 = o2.getType();
2768: if (t1 == t2 || t1.builtin && t2.builtin) {
2769: return this ._basic_or(o2);
2770: }
2771: return _binop_rule(t1, o2, t2, "__or__", "__ror__", "|");
2772: }
2773:
2774: /**
2775: * Implements the Python expression <code>this | o2</code>
2776: * when this and o2 have the same type or are builtin types.
2777: * @param o2 the object to perform this binary operation with.
2778: * @return the result of the or.
2779: * @exception Py.TypeError if this operation can't be performed
2780: * with these operands.
2781: **/
2782: final PyObject _basic_or(PyObject o2) {
2783: PyObject x = __or__(o2);
2784: if (x != null)
2785: return x;
2786: x = o2.__ror__(this );
2787: if (x != null)
2788: return x;
2789: throw Py.TypeError(_unsupportedop("|", o2));
2790: }
2791:
2792: /**
2793: * Equivalent to the standard Python __xor__ method
2794: * @param other the object to perform this binary operation with
2795: * (the right-hand operand).
2796: * @return the result of the xor, or null if this operation
2797: * is not defined
2798: **/
2799: public PyObject __xor__(PyObject other) {
2800: return null;
2801: }
2802:
2803: /**
2804: * Equivalent to the standard Python __rxor__ method
2805: * @param other the object to perform this binary operation with
2806: * (the left-hand operand).
2807: * @return the result of the xor, or null if this operation
2808: * is not defined.
2809: **/
2810: public PyObject __rxor__(PyObject other) {
2811: return null;
2812: }
2813:
2814: /**
2815: * Equivalent to the standard Python __ixor__ method
2816: * @param other the object to perform this binary operation with
2817: * (the right-hand operand).
2818: * @return the result of the xor, or null if this operation
2819: * is not defined
2820: **/
2821: public PyObject __ixor__(PyObject other) {
2822: return _xor(other);
2823: }
2824:
2825: /**
2826: * Implements the Python expression <code>this ^ o2</code>
2827: * @param o2 the object to perform this binary operation with.
2828: * @return the result of the xor.
2829: * @exception Py.TypeError if this operation can't be performed
2830: * with these operands.
2831: **/
2832: public final PyObject _xor(PyObject o2) {
2833: PyType t1 = this .getType();
2834: PyType t2 = o2.getType();
2835: if (t1 == t2 || t1.builtin && t2.builtin) {
2836: return this ._basic_xor(o2);
2837: }
2838: return _binop_rule(t1, o2, t2, "__xor__", "__rxor__", "^");
2839: }
2840:
2841: /**
2842: * Implements the Python expression <code>this ^ o2</code>
2843: * when this and o2 have the same type or are builtin types.
2844: * @param o2 the object to perform this binary operation with.
2845: * @return the result of the xor.
2846: * @exception Py.TypeError if this operation can't be performed
2847: * with these operands.
2848: **/
2849: final PyObject _basic_xor(PyObject o2) {
2850: PyObject x = __xor__(o2);
2851: if (x != null)
2852: return x;
2853: x = o2.__rxor__(this );
2854: if (x != null)
2855: return x;
2856: throw Py.TypeError(_unsupportedop("^", o2));
2857: }
2858:
2859: // Generated by make_binops.py (End)
2860:
2861: /* A convenience function for PyProxy's */
2862: // Possibly add _jcall(), _jcall(Object, ...) as future optimization
2863: /**
2864: * A convenience function for PyProxy's.
2865: * @param args call arguments.
2866: * @exception Throwable
2867: */
2868: public PyObject _jcallexc(Object[] args) throws Throwable {
2869: PyObject[] pargs = new PyObject[args.length];
2870: try {
2871: int n = args.length;
2872: for (int i = 0; i < n; i++)
2873: pargs[i] = Py.java2py(args[i]);
2874: return __call__(pargs);
2875: } catch (PyException e) {
2876: if (e.value instanceof PyJavaInstance) {
2877: Object t = e.value.__tojava__(Throwable.class);
2878: if (t != null && t != Py.NoConversion) {
2879: throw (Throwable) t;
2880: }
2881: } else {
2882: ThreadState ts = Py.getThreadState();
2883: if (ts.frame == null) {
2884: Py.maybeSystemExit(e);
2885: }
2886: if (Options.showPythonProxyExceptions) {
2887: Py.stderr
2888: .println("Exception in Python proxy returning to Java:");
2889: Py.printException(e);
2890: }
2891: }
2892: throw e;
2893: }
2894: }
2895:
2896: public void _jthrow(Throwable t) {
2897: if (t instanceof RuntimeException)
2898: throw (RuntimeException) t;
2899: if (t instanceof Error)
2900: throw (Error) t;
2901: throw Py.JavaError(t);
2902: }
2903:
2904: public PyObject _jcall(Object[] args) {
2905: try {
2906: return _jcallexc(args);
2907: } catch (Throwable t) {
2908: _jthrow(t);
2909: return null;
2910: }
2911: }
2912:
2913: /* Shortcut methods for calling methods from Java */
2914:
2915: /**
2916: * Shortcut for calling a method on a PyObject from Java.
2917: * This form is equivalent to o.__getattr__(name).__call__(args, keywords)
2918: *
2919: * @param name the name of the method to call. This must be an
2920: * interned string!
2921: * @param args an array of the arguments to the call.
2922: * @param keywords the keywords to use in the call.
2923: * @return the result of calling the method name with args and keywords.
2924: **/
2925: public PyObject invoke(String name, PyObject[] args,
2926: String[] keywords) {
2927: PyObject f = __getattr__(name);
2928: return f.__call__(args, keywords);
2929: }
2930:
2931: public PyObject invoke(String name, PyObject[] args) {
2932: PyObject f = __getattr__(name);
2933: return f.__call__(args);
2934: }
2935:
2936: /**
2937: * Shortcut for calling a method on a PyObject with no args.
2938: *
2939: * @param name the name of the method to call. This must be an
2940: * interned string!
2941: * @return the result of calling the method name with no args
2942: **/
2943: public PyObject invoke(String name) {
2944: PyObject f = __getattr__(name);
2945: return f.__call__();
2946: }
2947:
2948: /**
2949: * Shortcut for calling a method on a PyObject with one arg.
2950: *
2951: * @param name the name of the method to call. This must be an
2952: * interned string!
2953: * @param arg1 the one argument of the method.
2954: * @return the result of calling the method name with arg1
2955: **/
2956: public PyObject invoke(String name, PyObject arg1) {
2957: PyObject f = __getattr__(name);
2958: return f.__call__(arg1);
2959: }
2960:
2961: /**
2962: * Shortcut for calling a method on a PyObject with two args.
2963: *
2964: * @param name the name of the method to call. This must be an
2965: * interned string!
2966: * @param arg1 the first argument of the method.
2967: * @param arg2 the second argument of the method.
2968: * @return the result of calling the method name with arg1 and arg2
2969: **/
2970: public PyObject invoke(String name, PyObject arg1, PyObject arg2) {
2971: PyObject f = __getattr__(name);
2972: return f.__call__(arg1, arg2);
2973: }
2974:
2975: /* descriptors and lookup protocols */
2976:
2977: /** xxx implements where meaningful
2978: * @return internal object per instance dict or null
2979: */
2980: public PyObject fastGetDict() {
2981: return null;
2982: }
2983:
2984: /** xxx implements where meaningful
2985: * @return internal object __dict__ or null
2986: */
2987: public PyObject getDict() {
2988: return null;
2989: }
2990:
2991: public void setDict(PyObject newDict) {
2992: // fallback if setDict not implemented in subclass
2993: throw Py
2994: .TypeError("can't set attribute '__dict__' of instance of "
2995: + getType().safeRepr());
2996: }
2997:
2998: public void delDict() {
2999: // fallback to error
3000: throw Py
3001: .TypeError("can't delete attribute '__dict__' of instance of '"
3002: + getType().safeRepr() + "'");
3003: }
3004:
3005: public boolean implements DescrSet() {
3006: return objtype.has_set;
3007: }
3008:
3009: public boolean implements DescrDelete() {
3010: return objtype.has_delete;
3011: }
3012:
3013: public boolean isDataDescr() { // implements either __set__ or __delete__
3014: return objtype.has_set || objtype.has_delete;
3015: }
3016:
3017: // doc & xxx ok this way?
3018: // can return null meaning set-only or throw exception
3019:
3020: // backward comp impls.
3021: public PyObject __get__(PyObject obj, PyObject type) {
3022: return _doget(obj, type);
3023: }
3024:
3025: public void __set__(PyObject obj, PyObject value) {
3026: throw Py
3027: .AttributeError("object internal __set__ impl is abstract");
3028: }
3029:
3030: public void __delete__(PyObject obj) {
3031: throw Py
3032: .AttributeError("object internal __delete__ impl is abstract");
3033: }
3034:
3035: // name must be interned
3036: final PyObject object___findattr__(String name) {
3037:
3038: PyObject descr = objtype.lookup(name);
3039: PyObject res;
3040:
3041: if (descr != null) {
3042: if (descr.isDataDescr()) {
3043: res = descr.__get__(this , objtype);
3044: if (res != null)
3045: return res;
3046: }
3047: }
3048:
3049: PyObject obj_dict = fastGetDict();
3050: if (obj_dict != null) {
3051: res = obj_dict.__finditem__(name);
3052: if (res != null)
3053: return res;
3054: }
3055:
3056: if (descr != null) {
3057: return descr.__get__(this , objtype);
3058: }
3059:
3060: return null;
3061: }
3062:
3063: final void object___setattr__(String name, PyObject value) {
3064: PyObject descr = objtype.lookup(name);
3065:
3066: boolean set = false;
3067:
3068: if (descr != null) {
3069: set = descr.implements DescrSet();
3070: if (set && descr.isDataDescr()) {
3071: descr.__set__(this , value);
3072: return;
3073: }
3074: }
3075:
3076: PyObject obj_dict = fastGetDict();
3077: if (obj_dict != null) {
3078: obj_dict.__setitem__(name, value);
3079: return;
3080: }
3081:
3082: if (set) {
3083: descr.__set__(this , value);
3084: }
3085:
3086: if (descr != null) {
3087: readonlyAttributeError(name);
3088: }
3089:
3090: noAttributeError(name);
3091: }
3092:
3093: final void object___delattr__(String name) {
3094: PyObject descr = objtype.lookup(name);
3095:
3096: boolean delete = false;
3097:
3098: if (descr != null) {
3099: delete = descr.implements DescrDelete();
3100: if (delete && descr.isDataDescr()) {
3101: descr.__delete__(this );
3102: return;
3103: }
3104: }
3105:
3106: PyObject obj_dict = fastGetDict();
3107: if (obj_dict != null) {
3108: try {
3109: obj_dict.__delitem__(name);
3110: } catch (PyException exc) {
3111: if (Py.matchException(exc, Py.KeyError))
3112: noAttributeError(name);
3113: else
3114: throw exc;
3115: }
3116: return;
3117: }
3118:
3119: if (delete) {
3120: descr.__delete__(this );
3121: }
3122:
3123: if (descr != null) {
3124: readonlyAttributeError(name);
3125: }
3126:
3127: noAttributeError(name);
3128: }
3129:
3130: /**
3131: * Used for pickling.
3132: *
3133: * @return a tuple of (class, tuple)
3134: */
3135: public PyObject __reduce__() {
3136: return object___reduce__();
3137: }
3138:
3139: final PyObject object___reduce__() {
3140: PyTuple newargs = __getnewargs__();
3141: return new PyTuple(new PyObject[] { getType(), newargs });
3142: }
3143:
3144: public PyTuple __getnewargs__() {
3145: //default is empty tuple
3146: return new PyTuple();
3147: }
3148:
3149: /* arguments' conversion helpers */
3150:
3151: public static class ConversionException extends Exception {
3152:
3153: public int index;
3154:
3155: public ConversionException(int index) {
3156: this .index = index;
3157: }
3158:
3159: }
3160:
3161: public String asString(int index) throws ConversionException {
3162: throw new ConversionException(index);
3163: }
3164:
3165: public String asStringOrNull(int index) throws ConversionException {
3166: return asString(index);
3167: }
3168:
3169: public String asName(int index) throws ConversionException {
3170: throw new ConversionException(index);
3171: }
3172:
3173: public int asInt(int index) throws ConversionException {
3174: throw new ConversionException(index);
3175: }
3176:
3177: public long asLong(int index) throws ConversionException {
3178: throw new ConversionException(index);
3179: }
3180:
3181: }
3182:
3183: /*
3184: * A very specialized tuple-like class used when detecting cycles during
3185: * object comparisons. This classes is different from an normal tuple
3186: * by hashing and comparing its elements by identity.
3187: */
3188:
3189: class PyIdentityTuple extends PyObject {
3190:
3191: PyObject[] list;
3192:
3193: public PyIdentityTuple(PyObject elements[]) {
3194: list = elements;
3195: }
3196:
3197: public int hashCode() {
3198: int x, y;
3199: int len = list.length;
3200: x = 0x345678;
3201:
3202: for (len--; len >= 0; len--) {
3203: y = System.identityHashCode(list[len]);
3204: x = (x + x + x) ^ y;
3205: }
3206: x ^= list.length;
3207: return x;
3208: }
3209:
3210: public boolean equals(Object o) {
3211: if (!(o instanceof PyIdentityTuple))
3212: return false;
3213: PyIdentityTuple that = (PyIdentityTuple) o;
3214: if (list.length != that.list.length)
3215: return false;
3216: for (int i = 0; i < list.length; i++) {
3217: if (list[i] != that.list[i])
3218: return false;
3219: }
3220: return true;
3221: }
3222:
3223: }
|