Operator (TSL2 Framework Operation 2.4.12 API)

java.lang.Object
- de.tsl2.nano.util.parser.Parser<INPUT>
- - de.tsl2.nano.util.operation.Operator<INPUT,OUTPUT>

Type Parameters:

INPUT - type of input to extract operations from

OUTPUT - type of output as result.

All Implemented Interfaces:

IParser<INPUT>

Direct Known Subclasses:

SOperator
```
public abstract class Operator<INPUT,OUTPUT>
extends Parser<INPUT>
```
Base class to execute any operation with terms having two operands and one operator. it is like a primitive parser using regular expressions. may be used to implement equation-solvers etc.
TODO: support for one-operand-operation (the second has a default value. e.g.: -10 = 0 - 10.
Use:
create an expression of type INPUT. create an Operator instance holding a converter (INPUT <==> OUTPUT) and provide values contained in your expression.
Example:
```
 if your operator is a numeric operator with INPUT type String and OUTPUT type Number:
 values.put("x1", 1);
 value.put("x2, 2);
 operator.eval("(x1 + x2) + 5") ==> (Number)8.
 
```
Version:

$Revision$

Author:

Thomas Schneider

Field Summary

Fields
Modifier and Type	Field and Description
`static String`	`KEY_BEGIN` begin of eclosing a term (e.g. brackets)
`static String`	`KEY_BETWEEN` operation for: min max
`static String`	`KEY_CONCAT`
`static String`	`KEY_EMPTY` key word for an empty expression
`static String`	`KEY_END` end of eclosing a term (e.g. brackets)
`static String`	`KEY_HIGH_OPERATION` for numeric operations we need a classification of operations (like square root, pow, ...)
`static String`	`KEY_OPERAND` expression for first or second operand
`static String`	`KEY_OPERATION`
`static String`	`KEY_RESULT` key word to store the the result inside the value map
`static String`	`KEY_TERM` operand1 + operation + operand2
`static String`	`KEY_TERM_ENCLOSED` enclosing a term with brackets

Constructor Summary

Constructors
Constructor and Description
`Operator()`
`Operator(Class<? extends INPUT> inputClass, IConverter<INPUT,OUTPUT> converter, Map<INPUT,OUTPUT> values)` constructor

Method Summary

All Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method and Description
`protected void`	`addOperation(INPUT operator, IAction<OUTPUT> operation)` helper to define an operation-definition
`protected void`	`addValue(INPUT key, OUTPUT value)` addValue
`protected abstract void`	`createOperations()` define all possible operations. see `operationDefs`. should set value for `KEY_OPERATION` in `syntax`, too!
`protected abstract Map<String,INPUT>`	`createSyntax()` default implementation. please override
`protected abstract void`	`createTermSyntax()` defines the syntax of a term with given set of operators
`protected INPUT`	`encloseInBrackets(INPUT expression)` searches for not enclosed terms with a `KEY_HIGH_OPERATION` to enclose it.
`OUTPUT`	`eval(INPUT expression)` eval
`OUTPUT`	`eval(INPUT expression, Map<INPUT,OUTPUT> v)` delegates to `eval(Object)` filling the given values to `values`.
`protected OUTPUT`	`getValue(Object key)` gets a value - usable to fill values from value map. overwrite this method to do more...
`Map<INPUT,OUTPUT>`	`getValues()` getValues
`protected OUTPUT`	`newOperand(INPUT expr)`
`protected OUTPUT`	`operate(INPUT term, Map<INPUT,OUTPUT> values)` main function to extract operation elements and to execute the operation.
`void`	`reset()` resets stored values - to do the next operation
`protected boolean`	`resultEstablished()` used to do a break if result already available
`protected INPUT`	`syntax(String key)` syntax
`String`	`toString()`

Methods inherited from class de.tsl2.nano.util.parser.Parser
extract, isEmpty, unwrap, wrap

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Methods inherited from interface de.tsl2.nano.util.parser.IParser
concat, extract, replace, subElement, subEnclosing, trim

- Field Detail
  - KEY_BEGIN
```
public static final String KEY_BEGIN
```
    begin of eclosing a term (e.g. brackets)
    
    See Also:
    
    Constant Field Values
  - KEY_END
```
public static final String KEY_END
```
    end of eclosing a term (e.g. brackets)
    
    See Also:
    
    Constant Field Values
  - KEY_TERM
```
public static final String KEY_TERM
```
    operand1 + operation + operand2
    
    See Also:
    
    Constant Field Values
  - KEY_TERM_ENCLOSED
```
public static final String KEY_TERM_ENCLOSED
```
    enclosing a term with brackets
    
    See Also:
    
    Constant Field Values
  - KEY_BETWEEN
```
public static final String KEY_BETWEEN
```
    operation for: min max
    
    See Also:
    
    Constant Field Values
  - KEY_CONCAT
```
public static final String KEY_CONCAT
```
    See Also:
    
    Constant Field Values
  - KEY_OPERATION
```
public static final String KEY_OPERATION
```
    See Also:
    
    Constant Field Values
  - KEY_HIGH_OPERATION
```
public static final String KEY_HIGH_OPERATION
```
    for numeric operations we need a classification of operations (like square root, pow, ...)
    
    See Also:
    
    Constant Field Values
  - KEY_OPERAND
```
public static final String KEY_OPERAND
```
    expression for first or second operand
    
    See Also:
    
    Constant Field Values
  - KEY_EMPTY
```
public static final String KEY_EMPTY
```
    key word for an empty expression
    
    See Also:
    
    Constant Field Values
  - KEY_RESULT
```
public static final String KEY_RESULT
```
    key word to store the the result inside the value map
    
    See Also:
    
    Constant Field Values
- Constructor Detail
  - Operator
```
public Operator()
```
  - Operator
```
public Operator(Class<? extends INPUT> inputClass,
                IConverter<INPUT,OUTPUT> converter,
                Map<INPUT,OUTPUT> values)
```
    constructor
    
    Parameters:
    
    inputClass - class of INPUT. technical workaround - see inputType.
    
    converter - see converter
    
    values - see values
- Method Detail
  - createSyntax
```
protected abstract Map<String,INPUT> createSyntax()
```
    default implementation. please override
    
    Returns:
    
    map containing needed syntax. see syntax(String).
  - syntax
```
protected final INPUT syntax(String key)
```
    syntax
    
    Parameters:
    
    key - syntax key to find
    
    Returns:
    
    syntax element
  - createOperations
```
protected abstract void createOperations()
```
    define all possible operations. see operationDefs. should set value for KEY_OPERATION in syntax, too!
  - createTermSyntax
```
protected abstract void createTermSyntax()
```
    defines the syntax of a term with given set of operators
  - addOperation
```
protected void addOperation(INPUT operator,
                            IAction<OUTPUT> operation)
```
    helper to define an operation-definition
    
    Parameters:
    
    operator - operator
    
    operation - operation to be executed
  - resultEstablished
```
protected boolean resultEstablished()
```
    used to do a break if result already available
    
    Returns:
    
    true, if result already available
  - getValues
```
public Map<INPUT,OUTPUT> getValues()
```
    getValues
    
    Returns:
    
    values
  - reset
```
public void reset()
```
    resets stored values - to do the next operation
  - eval
```
public OUTPUT eval(INPUT expression,
                   Map<INPUT,OUTPUT> v)
```
    delegates to eval(Object) filling the given values to values.
  - eval
```
public OUTPUT eval(INPUT expression)
```
    eval
    
    Parameters:
    
    expression -
    
    Returns:
  - getValue
```
protected OUTPUT getValue(Object key)
```
    gets a value - usable to fill values from value map. overwrite this method to do more...
    
    Parameters:
    
    key - values key
    
    Returns:
    
    value
  - addValue
```
protected void addValue(INPUT key,
                        OUTPUT value)
```
    addValue
    
    Parameters:
    
    key -
    
    value -
  - encloseInBrackets
```
protected INPUT encloseInBrackets(INPUT expression)
```
    searches for not enclosed terms with a KEY_HIGH_OPERATION to enclose it. Needed for math-operations like multiply, divide and pow
    
    Parameters:
    
    expression - to inspect
    
    Returns:
    
    expression with enclosed high-operations
  - operate
```
protected OUTPUT operate(INPUT term,
                         Map<INPUT,OUTPUT> values)
```
    main function to extract operation elements and to execute the operation.
    
    Parameters:
    
    term - term to analyse and execute
    
    values - pre-defined values
    
    Returns:
    
    result of operation
  - newOperand
```
protected OUTPUT newOperand(INPUT expr)
```
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object

Class Operator<INPUT,OUTPUT>

Field Summary

Constructor Summary

Method Summary

Methods inherited from class de.tsl2.nano.util.parser.Parser

Methods inherited from class java.lang.Object

Methods inherited from interface de.tsl2.nano.util.parser.IParser

Field Detail

KEY_BEGIN

KEY_END

KEY_TERM

KEY_TERM_ENCLOSED

KEY_BETWEEN

KEY_CONCAT

KEY_OPERATION

KEY_HIGH_OPERATION

KEY_OPERAND

KEY_EMPTY

KEY_RESULT

Constructor Detail

Operator

Operator

Method Detail

createSyntax

syntax

createOperations

createTermSyntax

addOperation

resultEstablished

getValues

reset

eval

eval

getValue

addValue

encloseInBrackets

operate

newOperand

toString