/** * The RelOps interface defines how each type responds to relational * operators. Most (all?) types will not have sensible responses to all of * the relational operators (e.g. DInt won't know how to match a regular * expression but DString will). For those operators that are nonsensical a * class should throw InvalidOperatorException. */ public boolean equal(BaseType bt) throws InvalidOperatorException, RegExpException, SBHException { return (Operator.op(EQUAL, this, bt)); }
public boolean evaluate() throws DAP2ServerSideException { if (!constant || !defined) { defined = true; value = function.evaluate(children); } return value; }
/** * The RelOps interface defines how each type responds to relational * operators. Most (all?) types will not have sensible responses to all of * the relational operators (e.g. DSequence won't know how to match a regular * expression but DString will). For those operators that are nonsensical a * class should throw InvalidOperatorException. */ public boolean equal(BaseType bt) throws InvalidOperatorException, RegExpException, SBHException { throw new InvalidOperatorException("Equals (=) operator does not work with the type SDSequence!"); }
/** * Generates a clause representing a simple value, * such as "var1" or "19". * * @see ValueClause */ public SubClause newValueClause(BaseType value, boolean constant) throws DAP2ServerSideException { return new ValueClause(value, constant); }
/** * Add a dimension to the array. Same as <code>appendDim(size, * null)</code>. * * @param size the size of the desired new dimension. * @see DArray#appendDim(int, String) */ public final void appendDim(int size) { this.appendDim(size, null); }
/** * Generates a clause which which compares subclauses, using one of the * relative operators supported by the Operator class. */ public TopLevelClause newRelOpClause(int operator, SubClause lhs, List rhs) throws DAP2ServerSideException { return new RelOpClause(operator, lhs, rhs); }
/** * Generates a clause representing a remote value, referenced by a URL. * Note that dereferencing is not currently supported, and the default * implementation of this clause type throws an exception when it is * evaluated. * * @see DereferenceClause */ public SubClause newDereferenceClause(String url) throws DAP2ServerSideException { return new DereferenceClause(url); }
/** * Print the constrained <code>DDS</code> on the given * <code>PrintWriter</code>. * * @param pw the <code>PrintWriter</code> to use for output. * @opendap.ddx.experimental */ public void printConstrainedXML(PrintWriter pw) { printXML(pw, "", true); } }
void walk(ServerArrayMethods sam, int index) throws InvalidDimensionException, SBHException { sam.setProjection(index, (int) start, (int) stride, (int) stop); } }
/** * The RelOps interface defines how each type responds to relational * operators. Most (all?) types will not have sensible responses to all of * the relational operators (e.g. DInt won't know how to match a regular * expression but DString will). For those operators that are nonsensical a * class should throw InvalidOperatorException. */ public boolean equal(BaseType bt) throws InvalidOperatorException, RegExpException, SBHException { return (Operator.op(EQUAL, this, bt)); }
/** * The RelOps interface defines how each type responds to relational * operators. Most (all?) types will not have sensible responses to all * of the relational operators (e.g. DArray won't know how to match a * regular expression but DString will). For those operators that are * nonsensical a class should throw InvalidOperatorException. */ public boolean equal(BaseType bt) throws InvalidOperatorException, RegExpException, SBHException { throw new InvalidOperatorException("Equals (=) operator does not work with the type SDArray!"); }
/** * The RelOps interface defines how each type responds to relational * operators. Most (all?) types will not have sensible responses to all of * the relational operators (e.g. DInt won't know how to match a regular * expression but DString will). For those operators that are nonsensical a * class should throw InvalidOperatorException. */ public boolean equal(BaseType bt) throws InvalidOperatorException, RegExpException, SBHException { return (Operator.op(EQUAL, this, bt)); }
/** * The RelOps interface defines how each type responds to relational * operators. Most (all?) types will not have sensible responses to all of * the relational operators (e.g. DGrid won't know how to match a regular * expression but DString will). For those operators that are nonsensical a * class should throw InvalidOperatorException. */ public boolean equal(BaseType bt) throws InvalidOperatorException, RegExpException, SBHException { throw new InvalidOperatorException("Equals (=) operator does not work with the type SDGrid!"); }
/** * The RelOps interface defines how each type responds to relational * operators. Most (all?) types will not have sensible responses to all of * the relational operators (e.g. DByte won't know how to match a regular * expression but DString will). For those operators that are nonsensical a * class should throw InvalidOperatorException. */ public boolean equal(BaseType bt) throws InvalidOperatorException, RegExpException, SBHException { return (Operator.op(EQUAL, this, bt)); }
/** * The RelOps interface defines how each type responds to relational * operators. Most (all?) types will not have sensible responses to all of * the relational operators (e.g. DList won't know how to match a regular * expression but DString will). For those operators that are nonsensical a * class should throw InvalidOperatorException. */ public boolean equal(BaseType bt) throws InvalidOperatorException, RegExpException, SBHException { throw new InvalidOperatorException("Equals (=) operator does not work with the type SDList!"); }
/** * The RelOps interface defines how each type responds to relational * operators. Most (all?) types will not have sensible responses to all of * the relational operators (e.g. DInt won't know how to match a regular * expression but DString will). For those operators that are nonsensical a * class should throw InvalidOperatorException. */ public boolean equal(BaseType bt) throws InvalidOperatorException, RegExpException, SBHException { return (Operator.op(EQUAL, this, bt)); }
/** * The RelOps interface defines how each type responds to relational * operators. Most (all?) types will not have sensible responses to all of * the relational operators (e.g. DInt won't know how to match a regular * expression but DString will). For those operators that are nonsensical a * class should throw InvalidOperatorException. */ public boolean equal(BaseType bt) throws InvalidOperatorException, RegExpException, SBHException { return (Operator.op(EQUAL, this, bt)); }
/** * The RelOps interface defines how each type responds to relational * operators. Most (all?) types will not have sensible responses to all of * the relational operators (e.g. DInt won't know how to match a regular * expression but DString will). For those operators that are nonsensical a * class should throw InvalidOperatorException. */ public boolean equal(BaseType bt) throws InvalidOperatorException, RegExpException, SBHException { return (Operator.op(EQUAL, this, bt)); }
/** * The RelOps interface defines how each type responds to relational * operators. Most (all?) types will not have sensible responses to all of * the relational operators (e.g. DInt won't know how to match a regular * expression but DString will). For those operators that are nonsensical a * class should throw InvalidOperatorException. */ public boolean equal(BaseType bt) throws InvalidOperatorException, RegExpException, SBHException { return (Operator.op(EQUAL, this, bt)); }
/** * The RelOps interface defines how each type responds to relational * operators. Most (all?) types will not have sensible responses to all of * the relational operators (e.g. DInt won't know how to match a regular * expression but DString will). For those operators that are nonsensical a * class should throw InvalidOperatorException. */ public boolean equal(BaseType bt) throws InvalidOperatorException, RegExpException, SBHException { return (Operator.op(EQUAL, this, bt)); }