Name

adams.flow.control.Block


Synopsis

Blocks the propagation of tokens if the condition evaluates to 'true', therefore acts like the 'continue' control statement.
In case of integer or double tokens that arrive at the input, these can be accessed in the expression via 'X'.

The following grammar is used for evaluating the boolean expressions (depends on the selected condition):

expr_list ::= '=' expr_list expr_part | expr_part ;
expr_part ::= expr ;

expr ::= ( expr )

# data types
              | number
              | string
              | boolean
              | date

# constants
              | true
              | false
              | pi
              | e
              | now()
              | today()

# negating numeric value
              | -expr

# comparisons
              | expr < expr
              | expr <= expr
              | expr > expr
              | expr >= expr
              | expr = expr
              | expr != expr (or: expr <> expr)

# boolean operations
              | ! expr (or: not expr)
              | expr & expr (or: expr and expr)
              | expr | expr (or: expr or expr)
              | if[else] ( expr , expr (if true) , expr (if false) )
              | ifmissing ( variable , expr (default value if variable is missing) )
              | has ( variable )
              | isNaN ( expr )

# arithmetics
              | expr + expr
              | expr - expr
              | expr * expr
              | expr / expr
              | expr ^ expr (power of)
              | expr % expr (modulo)
              ;

# numeric functions
              | abs ( expr )
              | sqrt ( expr )
              | cbrt ( expr )
              | log ( expr )
              | log10 ( expr )
              | exp ( expr )
              | sin ( expr )
              | sinh ( expr )
              | cos ( expr )
              | cosh ( expr )
              | tan ( expr )
              | tanh ( expr )
              | atan ( expr )
              | atan2 ( exprY , exprX )
              | hypot ( exprX , exprY )
              | signum ( expr )
              | rint ( expr )
              | floor ( expr )
              | pow[er] ( expr , expr )
              | ceil ( expr )
              | min ( expr1 , expr2 )
              | max ( expr1 , expr2 )
              | rand () (unseeded double, 0-1)
              | rand ( seed ) (seeded double, 0-1)
              | randint ( bound ) (unseeded int from 0 to bound-1)
              | randint ( seed, bound ) (seeded int from 0 to bound-1)
              | year ( expr )
              | month ( expr )
              | day ( expr )
              | hour ( expr )
              | minute ( expr )
              | second ( expr )
              | weekday ( expr )
              | weeknum ( expr )

# string functions
              | substr ( expr , start [, end] )
              | left ( expr , len )
              | mid ( expr , start , len )
              | right ( expr , len )
              | rept ( expr , count )
              | concatenate ( expr1 , expr2 [, expr3-5] )
              | lower[case] ( expr )
              | upper[case] ( expr )
              | trim ( expr )
              | matches ( expr , regexp )
              | trim ( expr )
              | len[gth] ( str )
              | find ( search , expr [, pos] ) (find 'search' in 'expr', return 1-based position)
              | contains ( str , find ) (checks whether 'str' string contains 'find' string)
              | startswith ( str , find ) (checks whether 'str' string starts with 'find' string)
              | endswith ( str , find ) (checks whether 'str' string ends with 'find' string)
              | replace ( str , pos , len , newstr )
              | replaceall ( str , regexp , replace ) (applies regular expression to 'str' and replaces all matches with 'replace')
              | substitute ( str , find , replace [, occurrences] )
              | str ( expr )
              | str ( expr , numdecimals )
              | str ( expr , decimalformat )
              | ext ( file_str ) (extracts extension from file)
              | replaceext ( file_str, ext_str ) (replaces the extension of the file with the new one)

# array functions
              | len[gth] ( array )
              | get ( array , index )
              ;

Notes:
- Variables are either all alphanumeric and _, starting with uppercase letter (e.g., "ABc_12"),
  any character apart from "]" enclosed by "[" and "]" (e.g., "[Hello World]") or
  enclosed by single quotes (e.g., "'Hello World'").
- 'start' and 'end' for function 'substr' are indices that start at 1.
- 'index' for function 'get' starts at 1.
- Index 'end' for function 'substr' is excluded (like Java's 'String.substring(int,int)' method)
- Line comments start with '#'
- Semi-colons (';') or commas (',') can be used as separator in the formulas,
  e.g., 'pow(2,2)' is equivalent to 'pow(2;2)'
- dates have to be of format 'yyyy-MM-dd' or 'yyyy-MM-dd HH:mm:ss'
- times have to be of format 'HH:mm:ss' or 'yyyy-MM-dd HH:mm:ss'
- the characters in square brackets in function names are optional:
  e.g. 'len("abc")' is the same as 'length("abc")'
- 'str' uses java.text.DecimalFormat when supplying a format string

A lot of the functions have been modeled after LibreOffice:
  https://help.libreoffice.org/Calc/Functions_by_Category

Additional functions:
- env(String): String
First argument is the name of the environment variable to retrieve.
The result is the value of the environment variable.

Additional procedures:
- println(...)
One or more arguments are printed as comma-separated list to stdout.
If no argument is provided, a simple line feed is output.


Additional information

Flow input/output:
- input: adams.flow.core.Unknown
- output: adams.flow.core.Unknown


Options