SelectExpressionNode (QDL root module 1.5.6 API)

java.lang.Object
- edu.uiuc.ncsa.qdl.expressions.ExpressionImpl
- - edu.uiuc.ncsa.qdl.expressions.SelectExpressionNode

All Implemented Interfaces:

ExpressionNode, ExpressionInterface, HasResultInterface, Statement, Serializable
```
public class SelectExpressionNode
extends ExpressionImpl
```
An expression for switches. The contract is this:
```
     switch.¿case.:default
 
```
Where
- switch. - a boolean list with at most one true element
- case. - a list of expressions. Only the true element of switch. is evaluated
- default - value to return if all of the switch. elements are false
Since this is an expression is returns a value -- always.
Created by Jeff Gaynor
on 6/30/23 at 2:13 PM
See Also:

Serialized Form

Field Summary
- Fields inherited from class edu.uiuc.ncsa.qdl.expressions.ExpressionImpl
  arguments, result, valence
- Fields inherited from interface edu.uiuc.ncsa.qdl.statements.ExpressionInterface
  ALL_INDICES_NODE, ALT_IF_NODE, ASSIGNMENT_NODE, CLOSED_SLICE_NODE, COMPARISON_DYAD_NODE, CONSTANT_NODE, DYAD_NODE, DYADIC_FUNCTION_REFERENCE_NODE, EXPRESSION_STEM_NODE, EXPRESSION_STEM2_NODE, FUNCTION_REFERENCE_NODE, LAMBDA_DEFINITION_NODE, LIST_NODE, MODULE_NODE, MONAD_NODE, NILAD_NODE, OPEN_SLICE_NODE, PARENTHESIZED_NODE, PARSE_EXPRESSION_BLOCK_NODE, PARSE_STATEMENT_BLOCK_NODE, POLYAD_NODE, QDL_NULL_NODE, SELECT_NODE, SET_NODE, STEM_ENTRY_NODE, STEM_EXTRACTION_NODE, STEM_NODE, UNKNOWN_NODE, VARIABLE_NODE

Constructor Summary

Constructors
Constructor Description

SelectExpressionNode()

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`Object`	`evaluate(State state)`
`ArrayList<ExpressionInterface>`	`getArguments()`
`ExpressionInterface`	`getCASE()`
`ExpressionInterface`	`getDEFAULT()`
`int`	`getNodeType()`	QDL is not strongly typed but Java is, so each node type should have a unique integer and conditionals should use that, not the instanceof operator.
`ExpressionInterface`	`getSWITCH()`
`ExpressionInterface`	`makeCopy()`
`protected Object`	`NEWevaluate(State state)`
`protected Object`	`OLDevaluate(State state)`
`void`	`setCASE(ExpressionInterface x)`
`void`	`setDEFAULT(ExpressionInterface x)`
`void`	`setSWITCH(ExpressionInterface x)`

Methods inherited from class edu.uiuc.ncsa.qdl.expressions.ExpressionImpl
evalArg, evalLastArg, evaluatedArgs, getAlias, getArgAt, getArgCount, getEvaluatedArgs, getLastArg, getOperatorType, getResult, getResultType, getSourceCode, getTokenPosition, hasAlias, hasEvaluatedArgs, hasTokenPosition, isEvaluated, isSizeQuery, setAlias, setArguments, setEvaluated, setEvaluatedArgs, setOperatorType, setResult, setResultType, setSizeQuery, setSourceCode, setTokenPosition, toString

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

- Constructor Detail
  - SelectExpressionNode
```
public SelectExpressionNode()
```
- Method Detail
  - getSWITCH
```
public ExpressionInterface getSWITCH()
```
  - setSWITCH
```
public void setSWITCH(ExpressionInterface x)
```
  - getCASE
```
public ExpressionInterface getCASE()
```
  - setCASE
```
public void setCASE(ExpressionInterface x)
```
  - getDEFAULT
```
public ExpressionInterface getDEFAULT()
```
  - setDEFAULT
```
public void setDEFAULT(ExpressionInterface x)
```
  - makeCopy
```
public ExpressionInterface makeCopy()
```
  - getArguments
```
public ArrayList<ExpressionInterface> getArguments()
```
    Specified by:
    
    getArguments in interface ExpressionNode
    
    Overrides:
    
    getArguments in class ExpressionImpl
  - evaluate
```
public Object evaluate(State state)
```
  - NEWevaluate
```
protected Object NEWevaluate(State state)
```
  - OLDevaluate
```
protected Object OLDevaluate(State state)
```
  - getNodeType
```
public int getNodeType()
```
    Description copied from interface: ExpressionInterface
    
    QDL is not strongly typed but Java is, so each node type should have a unique integer and conditionals should use that, not the instanceof operator. This allows for efficient programming with switch statements rather than a bevy of conditionals (potentially each of which gets done even if the correct case has been handled).
    
    Returns: