Uses of Class
de.dante.extex.interpreter.expression.exception.CastException

Packages that use CastException
de.dante.extex.interpreter.expression   
de.dante.extex.interpreter.expression.term   
 

Uses of CastException in de.dante.extex.interpreter.expression
 

Methods in de.dante.extex.interpreter.expression that throw CastException
 EType EType.add(EType t)
          Apply the operation + on the current instance and an additional argument.
 EType EType.and(EType t)
          Apply the operation && on the current instance and an additional argument.
 EType EType.divide(EType t)
          Apply the operation + on the current instance and an additional argument.
 TBoolean EType.eq(EType t)
          Compare the current instance with an another value for equality.
 TBoolean EType.ge(EType t)
          Compare the current instance with an another value for greater or equal.
 TBoolean EType.gt(EType t)
          Compare the current instance with an another value for greater than.
 TBoolean EType.le(EType t)
          Compare the current instance with an another value for less or equal.
 TBoolean EType.lt(EType t)
          Compare the current instance with an another value for less.
 EType EType.multiply(EType t)
          Apply the operation * on the current instance and an additional argument.
 TBoolean EType.ne(EType t)
          Compare the current instance with an another value for not equal.
 EType EType.or(EType t)
          Apply the operation || on the current instance and an additional argument.
 EType EType.set(EType t)
          Assign a new value from an additional argument.
 EType EType.subtract(EType t)
          Apply the operation - on the current instance and an additional argument.
 

Uses of CastException in de.dante.extex.interpreter.expression.term
 

Methods in de.dante.extex.interpreter.expression.term that throw CastException
 EType TGlue.divide(EType t)
           
 TBoolean TGlue.eq(EType t)
           
 TBoolean TGlue.ge(EType t)
           
 TBoolean TGlue.gt(EType t)
           
 TBoolean TGlue.le(EType t)
           
 TBoolean TGlue.lt(EType t)
           
 TBoolean TGlue.ne(EType t)
           
 EType TGlue.set(EType t)
           
 EType TGlue.subtract(EType t)
           
protected static double TDouble.castTerminal(EType t)
          Cast a terminal to a double.
 EType TDouble.add(EType t)
           
 EType TDouble.and(EType t)
           
 EType TDouble.divide(EType t)
           
 TBoolean TDouble.eq(EType t)
           
 TBoolean TDouble.ge(EType t)
           
 TBoolean TDouble.gt(EType t)
           
 TBoolean TDouble.le(EType t)
           
 TBoolean TDouble.lt(EType t)
           
 EType TDouble.multiply(EType t)
           
 TBoolean TDouble.ne(EType t)
           
 EType TDouble.or(EType t)
           
 EType TDouble.set(EType t)
           
 EType TDouble.subtract(EType t)
           
protected static long TCount.castTerminal(EType t)
          Cast a terminal to a double.
 EType TCount.add(EType t)
           
 EType TCount.divide(EType t)
           
 TBoolean TCount.eq(EType t)
           
 TBoolean TCount.ge(EType t)
           
 TBoolean TCount.gt(EType t)
           
 TBoolean TCount.le(EType t)
           
 TBoolean TCount.lt(EType t)
           
 EType TCount.multiply(EType t)
           
 TBoolean TCount.ne(EType t)
           
 EType TCount.or(EType t)
           
 EType TCount.set(EType t)
           
 EType TCount.subtract(EType t)
           
protected static boolean TBoolean.castTerminal(EType t)
          Cast a terminal to a double.
 EType TBoolean.and(EType t)
           
 EType TBoolean.divide(EType t)
           
 EType TBoolean.multiply(EType t)
           
 EType TBoolean.or(EType t)
           
 EType TBoolean.set(EType t)
           
 EType Accumulator.add(EType t)
           
 EType Accumulator.and(EType t)
           
 EType Accumulator.divide(EType t)
           
 TBoolean Accumulator.eq(EType t)
           
 TBoolean Accumulator.ge(EType t)
           
 TBoolean Accumulator.gt(EType t)
           
 TBoolean Accumulator.le(EType t)
           
 TBoolean Accumulator.lt(EType t)
           
 EType Accumulator.multiply(EType t)
           
 TBoolean Accumulator.ne(EType t)
           
 EType Accumulator.or(EType t)
           
 EType Accumulator.subtract(EType t)