pyobject.java

无线通信的主要编程软件,是无线通信工作人员的必备工具,关天相关教程我会在后续传上.

     *            with these operands.
     **/
    public final PyObject _mul(PyObject o2) {
        PyObject x = __mul__(o2);
        if (x != null)
            return x;
        x = o2.__rmul__(this);
        if (x != null)
            return x;
        throw Py.TypeError(
                 "__mul__ nor __rmul__ defined for these operands");
    }

    /**
     * Equivalent to the standard Python __div__ method
     * @param     other the object to perform this binary operation with
     *            (the right-hand operand).
     * @return    the result of the div, or null if this operation
     *            is not defined
     **/
    public PyObject __div__(PyObject other) { return null; }

    /**
     * Equivalent to the standard Python __rdiv__ method
     * @param     other the object to perform this binary operation with
     *            (the left-hand operand).
     * @return    the result of the div, or null if this operation
     *            is not defined.
     **/
    public PyObject __rdiv__(PyObject other) { return null; }

    /**
     * Equivalent to the standard Python __idiv__ method
     * @param     other the object to perform this binary operation with
     *            (the right-hand operand).
     * @return    the result of the div, or null if this operation
     *            is not defined
     **/
    public PyObject __idiv__(PyObject other) { return _div(other); }

    /**
     * Implements the Python expression <code>this / other</code>
     * @param     other the object to perform this binary operation with.
     * @return    the result of the div.
     * @exception PyTypeError if this operation can't be performed
     *            with these operands.
     **/
    public final PyObject _div(PyObject o2) {
        if (Options.Qnew)
            return _truediv(o2);
        PyObject x = __div__(o2);
        if (x != null)
            return x;
        x = o2.__rdiv__(this);
        if (x != null)
            return x;
        throw Py.TypeError(
                 "__div__ nor __rdiv__ defined for these operands");
    }

    /**
     * Equivalent to the standard Python __floordiv__ method
     * @param     other the object to perform this binary operation with
     *            (the right-hand operand).
     * @return    the result of the floordiv, or null if this operation
     *            is not defined
     **/
    public PyObject __floordiv__(PyObject other) { return null; }

    /**
     * Equivalent to the standard Python __rfloordiv__ method
     * @param     other the object to perform this binary operation with
     *            (the left-hand operand).
     * @return    the result of the floordiv, or null if this operation
     *            is not defined.
     **/
    public PyObject __rfloordiv__(PyObject other) { return null; }

    /**
     * Equivalent to the standard Python __ifloordiv__ method
     * @param     other the object to perform this binary operation with
     *            (the right-hand operand).
     * @return    the result of the floordiv, or null if this operation
     *            is not defined
     **/
    public PyObject __ifloordiv__(PyObject other) { return _floordiv(other); }

    /**
     * Implements the Python expression <code>this // other</code>
     * @param     other the object to perform this binary operation with.
     * @return    the result of the floordiv.
     * @exception PyTypeError if this operation can't be performed
     *            with these operands.
     **/
    public final PyObject _floordiv(PyObject o2) {
        PyObject x = __floordiv__(o2);
        if (x != null)
            return x;
        x = o2.__rfloordiv__(this);
        if (x != null)
            return x;
        throw Py.TypeError(
                 "__floordiv__ nor __rfloordiv__ defined for these operands");
    }

    /**
     * Equivalent to the standard Python __truediv__ method
     * @param     other the object to perform this binary operation with
     *            (the right-hand operand).
     * @return    the result of the truediv, or null if this operation
     *            is not defined
     **/
    public PyObject __truediv__(PyObject other) { return null; }

    /**
     * Equivalent to the standard Python __rtruediv__ method
     * @param     other the object to perform this binary operation with
     *            (the left-hand operand).
     * @return    the result of the truediv, or null if this operation
     *            is not defined.
     **/
    public PyObject __rtruediv__(PyObject other) { return null; }

    /**
     * Equivalent to the standard Python __itruediv__ method
     * @param     other the object to perform this binary operation with
     *            (the right-hand operand).
     * @return    the result of the truediv, or null if this operation
     *            is not defined
     **/
    public PyObject __itruediv__(PyObject other) { return _truediv(other); }

    /**
     * Implements the Python expression <code>this / other</code>
     * @param     other the object to perform this binary operation with.
     * @return    the result of the truediv.
     * @exception PyTypeError if this operation can't be performed
     *            with these operands.
     **/
    public final PyObject _truediv(PyObject o2) {
        PyObject x = __truediv__(o2);
        if (x != null)
            return x;
        x = o2.__rtruediv__(this);
        if (x != null)
            return x;
        throw Py.TypeError(
                 "__truediv__ nor __rtruediv__ defined for these operands");
    }

    /**
     * Equivalent to the standard Python __mod__ method
     * @param     other the object to perform this binary operation with
     *            (the right-hand operand).
     * @return    the result of the mod, or null if this operation
     *            is not defined
     **/
    public PyObject __mod__(PyObject other) { return null; }

    /**
     * Equivalent to the standard Python __rmod__ method
     * @param     other the object to perform this binary operation with
     *            (the left-hand operand).
     * @return    the result of the mod, or null if this operation
     *            is not defined.
     **/
    public PyObject __rmod__(PyObject other) { return null; }

    /**
     * Equivalent to the standard Python __imod__ method
     * @param     other the object to perform this binary operation with
     *            (the right-hand operand).
     * @return    the result of the mod, or null if this operation
     *            is not defined
     **/
    public PyObject __imod__(PyObject other) { return _mod(other); }

    /**
     * Implements the Python expression <code>this % other</code>
     * @param     other the object to perform this binary operation with.
     * @return    the result of the mod.
     * @exception PyTypeError if this operation can't be performed
     *            with these operands.
     **/
    public final PyObject _mod(PyObject o2) {
        PyObject x = __mod__(o2);
        if (x != null)
            return x;
        x = o2.__rmod__(this);
        if (x != null)
            return x;
        throw Py.TypeError(
                 "__mod__ nor __rmod__ defined for these operands");
    }

    /**
     * Equivalent to the standard Python __divmod__ method
     * @param     other the object to perform this binary operation with
     *            (the right-hand operand).
     * @return    the result of the divmod, or null if this operation
     *            is not defined
     **/
    public PyObject __divmod__(PyObject other) { return null; }

    /**
     * Equivalent to the standard Python __rdivmod__ method
     * @param     other the object to perform this binary operation with
     *            (the left-hand operand).
     * @return    the result of the divmod, or null if this operation
     *            is not defined.
     **/
    public PyObject __rdivmod__(PyObject other) { return null; }

    /**
     * Equivalent to the standard Python __idivmod__ method
     * @param     other the object to perform this binary operation with
     *            (the right-hand operand).
     * @return    the result of the divmod, or null if this operation
     *            is not defined
     **/
    public PyObject __idivmod__(PyObject other) { return _divmod(other); }

    /**
     * Implements the Python expression <code>this divmod other</code>
     * @param     other the object to perform this binary operation with.
     * @return    the result of the divmod.
     * @exception PyTypeError if this operation can't be performed
     *            with these operands.
     **/
    public final PyObject _divmod(PyObject o2) {
        PyObject x = __divmod__(o2);
        if (x != null)
            return x;
        x = o2.__rdivmod__(this);
        if (x != null)
            return x;
        throw Py.TypeError(
                 "__divmod__ nor __rdivmod__ defined for these operands");
    }

    /**
     * Equivalent to the standard Python __pow__ method
     * @param     other the object to perform this binary operation with
     *            (the right-hand operand).
     * @return    the result of the pow, or null if this operation
     *            is not defined
     **/
    public PyObject __pow__(PyObject other) { return __pow__(other, null); }

    /**
     * Equivalent to the standard Python __rpow__ method
     * @param     other the object to perform this binary operation with
     *            (the left-hand operand).
     * @return    the result of the pow, or null if this operation
     *            is not defined.
     **/
    public PyObject __rpow__(PyObject other) { return null; }

    /**
     * Equivalent to the standard Python __ipow__ method
     * @param     other the object to perform this binary operation with
     *            (the right-hand operand).
     * @return    the result of the pow, or null if this operation
     *            is not defined
     **/
    public PyObject __ipow__(PyObject other) { return _pow(other); }

    /**
     * Implements the Python expression <code>this ** other</code>
     * @param     other the object to perform this binary operation with.
     * @return    the result of the pow.
     * @exception PyTypeError if this operation can't be performed
     *            with these operands.
     **/
    public final PyObject _pow(PyObject o2) {
        PyObject x = __pow__(o2);
        if (x != null)
            return x;
        x = o2.__rpow__(this);
        if (x != null)
            return x;
        throw Py.TypeError(
                 "__pow__ nor __rpow__ defined for these operands");
    }

    /**
     * Equivalent to the standard Python __lshift__ method
     * @param     other the object to perform this binary operation with
     *            (the right-hand operand).
     * @return    the result of the lshift, or null if this operation
     *            is not defined
     **/
    public PyObject __lshift__(PyObject other) { return null; }

    /**
     * Equivalent to the standard Python __rlshift__ method
     * @param     other the object to perform this binary operation with
     *            (the left-hand operand).
     * @return    the result of the lshift, or null if this operation
     *            is not defined.
     **/
    public PyObject __rlshift__(PyObject other) { return null; }

    /**
     * Equivalent to the standard Python __ilshift__ method
     * @param     other the object to perform this binary operation with
     *            (the right-hand operand).
     * @return    the result of the lshift, or null if this operation
     *            is not defined
     **/
    public PyObject __ilshift__(PyObject other) { return _lshift(other); }

    /**
     * Implements the Python expression <code>this << other</code>
     * @param     other the object to perform this binary operation with.
     * @return    the result of the lshift.
     * @exception PyTypeError if this operation can't be performed
     *            with these operands.
     **/
    public final PyObject _lshift(PyObject o2) {
        PyObject x = __lshift__(o2);
        if (x != null)
            return x;
        x = o2.__rlshift__(this);
        if (x != null)
            return x;
        throw Py.TypeError(
                 "__lshift__ nor __rlshift__ defined for these operands");
    }

    /**
     * Equivalent to the standard Python __rshift__ method
     * @param     other the object to perform this binary operation with
     *            (the right-hand operand).
     * @return    the result of the rshift, or null if this operation
     *            is not defined
     **/
    public PyObject __rshift__(PyObject other) { return null; }

    /**
     * Equivalent to the standard Python __rrshift__ method
     * @param     other the object to perform this binary operation with
     *            (the left-hand operand).
     * @return    the result of the rshift, or null if this operation
     *            is not defined.
     **/
    public PyObject __rrshift__(PyObject other) { return null; }

    /**
     * Equivalent to the standard Python __irshift__ method
     * @param     other the object to perform this binary operation with
     *            (the right-hand operand).
     * @return    the result of the rshift, or null if this operation
     *            is not defined
     **/
    public PyObject __irshift__(PyObject other) { return _rshift(other); }

    /**
     * Implements the Python expression <code>this >> other</code>
     * @param     other the object to perform this binary operation with.
     * @return    the result of the rshift.
     * @exception PyTypeError if this operation can't be performed
     *            with these operands.
     **/
    public final PyObject _rshift(PyObject o2) {
        PyObject x = __rshift__(o2);
        if (x != null)
            return x;
        x = o2.__rrshift__(this);
        if (x != null)
            return x;
        throw Py.TypeError(
                 "__rshift__ nor __rrshift__ defined for these operands");
    }

    /**
     * Equivalent to the standard Python __and__ method
     * @param     other the object to perform this binary operation with
     *            (the right-hand operand).
     * @return    the result of the and, or null if this operation
     *            is not defined
     **/
    public PyObject __and__(PyObject other) { return null; }

    /**
     * Equivalent to the standard Python __rand__ method
     * @param     other the obje