ExprUtil (kind2-java-api 0.3.0 API)

java.lang.Object
- edu.uiowa.cs.clc.kind2.lustre.ExprUtil

```
public class ExprUtil
extends java.lang.Object
```
A utility class for constructing Lustre expressions.

Field Summary

Fields
Modifier and Type Field and Description

static Expr FALSE

static Expr TRUE

Fields
Modifier and Type	Field and Description
`static Expr`	`FALSE`
`static Expr`	`TRUE`

Constructor Summary

Constructors
Constructor and Description

ExprUtil()

Constructors
Constructor and Description
`ExprUtil()`

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static Expr`	`and(Expr... e)` Construct an and expression
`static Expr`	`and(Expr left, Expr right)` Construct an and expression
`static Expr`	`and(java.util.List<Expr> conjuncts)` Construct an and expression
`static Expr`	`array(java.util.List<? extends Expr> elements)` Construct an array expression
`static Expr`	`arrow(Expr left, Expr right)` Construct an arrow expression
`static Expr`	`castInt(Expr expr)` Construct an integer-cast expression
`static Expr`	`castReal(Expr expr)` Construct an real-cast expression
`static Expr`	`divide(Expr left, Expr right)` Construct a divide expression
`static Expr`	`equal(Expr left, Expr right)` Construct an equal expression
`static Expr`	`functionCall(IdExpr name, Expr... args)` Construct a function-call expression
`static Expr`	`functionCall(IdExpr name, java.util.List<Expr> args)` Construct a function-call expression
`static Expr`	`greater(Expr left, Expr right)` Construct a greater-than expression
`static Expr`	`greaterEqual(Expr left, Expr right)` Construct a greater-than-or-equal expression
`static IdExpr`	`id(java.lang.String id)` Construct an id expression
`static Expr`	`implies(Expr left, Expr right)` Construct an imply expression
`static Expr`	`intDivide(Expr left, Expr right)` Construct an integer-divide expression
`static Expr`	`integer(long value)` Construct an integer value expression
`static Expr`	`integer(java.lang.String str)` Construct an integer value expression
`static Expr`	`ite(Expr cond, Expr thenExpr, Expr elseExpr)` Construct an if-then-else expression
`static Expr`	`less(Expr left, Expr right)` Construct a less-than expression
`static Expr`	`lessEqual(Expr left, Expr right)` Construct a less-than-or-equal expression
`static Expr`	`list(java.util.List<? extends Expr> list)` Construct a list expression
`static Expr`	`minus(Expr left, Expr right)` Construct a minus expression
`static Expr`	`mod(Expr left, Expr right)` Construct a mod expression
`static Expr`	`modeRef(java.lang.String... path)` Construct a mode-reference expression
`static Expr`	`multiply(Expr left, Expr right)` Construct a multiply expression
`static Expr`	`negative(Expr expr)` Construct a negative expression
`static Expr`	`nodeCall(IdExpr name, Expr... args)` Construct a node-call expression
`static Expr`	`nodeCall(IdExpr name, java.util.List<Expr> args)` Construct a node-call expression
`static Expr`	`not(Expr expr)` Construct a not expression
`static Expr`	`notEqual(Expr left, Expr right)` Construct a not-equal expression
`static Expr`	`or(Expr... e)` Construct an or expression
`static Expr`	`or(Expr left, Expr right)` Construct an or expression
`static Expr`	`or(java.util.List<Expr> disjuncts)` Construct an or expression
`static Expr`	`plus(Expr left, Expr right)` Construct a plus expression
`static Expr`	`pre(Expr expr)` Construct a pre expression
`static Expr`	`real(java.lang.String str)` Construct a real value expression
`static Expr`	`recordAccess(Expr record, java.lang.String field)` Construct a record-access expression
`static Expr`	`recordLiteral(java.lang.String id, java.util.Map<java.lang.String,Expr> fields)` Construct a record-literal expression
`static Expr`	`xor(Expr... e)` Construct an xor expression
`static Expr`	`xor(Expr left, Expr right)` Construct an xor expression
`static Expr`	`xor(java.util.List<Expr> disjuncts)` Construct an xor expression

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

- Field Detail
  - TRUE
```
public static final Expr TRUE
```
  - FALSE
```
public static final Expr FALSE
```
- Constructor Detail
  - ExprUtil
```
public ExprUtil()
```
- Method Detail
  - and
```
public static Expr and(Expr left,
                       Expr right)
```
    Construct an and expression
    Lustre: <left> and <right>
    
    Parameters:
    
    left - left side of the and expression
    
    right - right side of the and expression
    
    Returns:
    
    the and expression
  - or
```
public static Expr or(Expr left,
                      Expr right)
```
    Construct an or expression
    Lustre: <left> or <right>
    
    Parameters:
    
    left - left side of the or expression
    
    right - right side of the or expression
    
    Returns:
    
    the or expression
  - implies
```
public static Expr implies(Expr left,
                           Expr right)
```
    Construct an imply expression
    Lustre: <left> => <right>
    
    Parameters:
    
    left - left side of the imply expression
    
    right - right side of the imply expression
    
    Returns:
    
    the imply expression
  - xor
```
public static Expr xor(Expr left,
                       Expr right)
```
    Construct an xor expression
    Lustre: <left> xor <right>
    
    Parameters:
    
    left - left side of the xor expression
    
    right - right side of the xor expression
    
    Returns:
    
    the xor expression
  - arrow
```
public static Expr arrow(Expr left,
                         Expr right)
```
    Construct an arrow expression
    Lustre: <left> -> <right>
    
    Parameters:
    
    left - left side of the arrow expression
    
    right - right side of the arrow expression
    
    Returns:
    
    the arrow expression
  - less
```
public static Expr less(Expr left,
                        Expr right)
```
    Construct a less-than expression
    Lustre: <left> < <right>
    
    Parameters:
    
    left - left side of the less-than expression
    
    right - right side of the less-than expression
    
    Returns:
    
    the less-than expression
  - lessEqual
```
public static Expr lessEqual(Expr left,
                             Expr right)
```
    Construct a less-than-or-equal expression
    Lustre: <left> <= <right>
    
    Parameters:
    
    left - left side of the less-than-or-equal expression
    
    right - right side of the less-than-or-equal expression
    
    Returns:
    
    the less-than-or-equal expression
  - greater
```
public static Expr greater(Expr left,
                           Expr right)
```
    Construct a greater-than expression
    Lustre: <left> > <right>
    
    Parameters:
    
    left - left side of the greater-than expression
    
    right - right side of the greater-than expression
    
    Returns:
    
    the greater-than expression
  - greaterEqual
```
public static Expr greaterEqual(Expr left,
                                Expr right)
```
    Construct a greater-than-or-equal expression
    Lustre: <left> >= <right>
    
    Parameters:
    
    left - left side of the greater-than-or-equal expression
    
    right - right side of the greater-than-or-equal expression
    
    Returns:
    
    the greater-than-or-equal expression
  - equal
```
public static Expr equal(Expr left,
                         Expr right)
```
    Construct an equal expression
    Lustre: <left> = <right>
    
    Parameters:
    
    left - left side of the equal expression
    
    right - right side of the equal expression
    
    Returns:
    
    the equal expression
  - notEqual
```
public static Expr notEqual(Expr left,
                            Expr right)
```
    Construct a not-equal expression
    Lustre: <left> <> <right>
    
    Parameters:
    
    left - left side of the not-equal expression
    
    right - right side of the not-equal expression
    
    Returns:
    
    the not-equal expression
  - plus
```
public static Expr plus(Expr left,
                        Expr right)
```
    Construct a plus expression
    Lustre: <left> + <right>
    
    Parameters:
    
    left - left side of the plus expression
    
    right - right side of the plus expression
    
    Returns:
    
    the plus expression
  - minus
```
public static Expr minus(Expr left,
                         Expr right)
```
    Construct a minus expression
    Lustre: <left> - <right>
    
    Parameters:
    
    left - left side of the minus expression
    
    right - right side of the minus expression
    
    Returns:
    
    the minus expression
  - multiply
```
public static Expr multiply(Expr left,
                            Expr right)
```
    Construct a multiply expression
    Lustre: <left> * <right>
    
    Parameters:
    
    left - left side of the multiply expression
    
    right - right side of the multiply expression
    
    Returns:
    
    the multiply expression
  - mod
```
public static Expr mod(Expr left,
                       Expr right)
```
    Construct a mod expression
    Lustre: <left> mod <right>
    
    Parameters:
    
    left - left side of the mod expression
    
    right - right side of the mod expression
    
    Returns:
    
    the mod expression
  - intDivide
```
public static Expr intDivide(Expr left,
                             Expr right)
```
    Construct an integer-divide expression
    Lustre: <left> div <right>
    
    Parameters:
    
    left - left side of the integer-divide expression
    
    right - right side of the integer-divide expression
    
    Returns:
    
    the integer-divide expression
  - divide
```
public static Expr divide(Expr left,
                          Expr right)
```
    Construct a divide expression
    Lustre: <left> / <right>
    
    Parameters:
    
    left - left side of the divide expression
    
    right - right side of the divide expression
    
    Returns:
    
    the divide expression
  - negative
```
public static Expr negative(Expr expr)
```
    Construct a negative expression
    Lustre: -<expr>
    
    Parameters:
    
    expr - expression to get the negative value of
    
    Returns:
    
    the negative expression
  - not
```
public static Expr not(Expr expr)
```
    Construct a not expression
    Lustre: not <expr>
    
    Parameters:
    
    expr - expression to negate
    
    Returns:
    
    the not expression
  - pre
```
public static Expr pre(Expr expr)
```
    Construct a pre expression
    Lustre: pre <expr>
    
    Parameters:
    
    expr - expression to get the previous value of
    
    Returns:
    
    the pre expression
  - id
```
public static IdExpr id(java.lang.String id)
```
    Construct an id expression
    Lustre: <expr>
    
    Parameters:
    
    id - identifier for component, variable, or constant
    
    Returns:
    
    the id expression
  - real
```
public static Expr real(java.lang.String str)
```
    Construct a real value expression
    Lustre: <str>
    
    Parameters:
    
    str - a floating point number
    
    Returns:
    
    the real value expression
  - integer
```
public static Expr integer(java.lang.String str)
```
    Construct an integer value expression
    Lustre: <str>
    
    Parameters:
    
    str - an integer number
    
    Returns:
    
    the integer value expression
  - integer
```
public static Expr integer(long value)
```
    Construct an integer value expression
    Lustre: <i>
    
    Parameters:
    
    value - an integer number
    
    Returns:
    
    the integer value expression
  - modeRef
```
public static Expr modeRef(java.lang.String... path)
```
    Construct a mode-reference expression
    Lustre: <path>
    
    Parameters:
    
    path - path to mode
    
    Returns:
    
    the mode-reference expression
  - functionCall
```
public static Expr functionCall(IdExpr name,
                                java.util.List<Expr> args)
```
    Construct a function-call expression
    Lustre: <name>(<args[0]>, <args[1]>, ...)
    
    Parameters:
    
    name - name of the function
    
    args - a list of argument expressions
    
    Returns:
    
    the function-call expression
  - functionCall
```
public static Expr functionCall(IdExpr name,
                                Expr... args)
```
    Construct a function-call expression
    Lustre: <name>(<args[0]>, <args[1]>, ...)
    
    Parameters:
    
    name - name of the function
    
    args - an array of argument expressions
    
    Returns:
    
    the function-call expression
  - nodeCall
```
public static Expr nodeCall(IdExpr name,
                            java.util.List<Expr> args)
```
    Construct a node-call expression
    Lustre: <name>(<args[0]>, <args[1]>, ...)
    
    Parameters:
    
    name - name of the node
    
    args - a list of argument expressions
    
    Returns:
    
    the node-call expression
  - nodeCall
```
public static Expr nodeCall(IdExpr name,
                            Expr... args)
```
    Construct a node-call expression
    Lustre: <name>(<args[0]>, <args[1]>, ...)
    
    Parameters:
    
    name - name of the node
    
    args - an array of argument expressions
    
    Returns:
    
    the node-call expression
  - castInt
```
public static Expr castInt(Expr expr)
```
    Construct an integer-cast expression
    Lustre: int <expr>
    
    Parameters:
    
    expr - expression to cast to integer
    
    Returns:
    
    the integer-cast expression
  - castReal
```
public static Expr castReal(Expr expr)
```
    Construct an real-cast expression
    Lustre: real <expr>
    
    Parameters:
    
    expr - expression to cast to real
    
    Returns:
    
    the real-cast expression
  - and
```
public static Expr and(java.util.List<Expr> conjuncts)
```
    Construct an and expression
    Lustre: <conjuncts[0]> and <conjuncts[1]> and ...
    
    Parameters:
    
    conjuncts - a list of conjuncts
    
    Returns:
    
    the and expression
  - and
```
public static Expr and(Expr... e)
```
    Construct an and expression
    Lustre: <e[0]> and <e[1]> and ...
    
    Parameters:
    
    e - an array of conjuncts
    
    Returns:
    
    the and expression
  - or
```
public static Expr or(java.util.List<Expr> disjuncts)
```
    Construct an or expression
    Lustre: <disjuncts[0]> or <disjuncts[1]> or ...
    
    Parameters:
    
    disjuncts - a list of disjuncts
    
    Returns:
    
    the or expression
  - or
```
public static Expr or(Expr... e)
```
    Construct an or expression
    Lustre: <e[0]> or <e[1]> or ...
    
    Parameters:
    
    e - an array of disjuncts
    
    Returns:
    
    the or expression
  - xor
```
public static Expr xor(java.util.List<Expr> disjuncts)
```
    Construct an xor expression
    Lustre: <disjuncts[0]> xor <disjuncts[1]> xor ...
    
    Parameters:
    
    disjuncts - a list of disjuncts
    
    Returns:
    
    the xor expression
  - xor
```
public static Expr xor(Expr... e)
```
    Construct an xor expression
    Lustre: <e[0]> xor <e[1]> xor ...
    
    Parameters:
    
    e - an array of disjuncts
    
    Returns:
    
    the xor expression
  - ite
```
public static Expr ite(Expr cond,
                       Expr thenExpr,
                       Expr elseExpr)
```
    Construct an if-then-else expression
    Lustre: if <cond> then <thenExpr> else <elseExpr>
    
    Parameters:
    
    cond - condition part of the if-then-else expression
    
    thenExpr - then part of the if-then-else expression
    
    elseExpr - else part of the if-then-else expression
    
    Returns:
    
    the if-then-else expression
  - list
```
public static Expr list(java.util.List<? extends Expr> list)
```
    Construct a list expression
    Lustre: (<list[0]>, <list[1]>, ...)
    
    Parameters:
    
    list - a list of sub-expressions
    
    Returns:
    
    the list expressions
  - recordLiteral
```
public static Expr recordLiteral(java.lang.String id,
                                 java.util.Map<java.lang.String,Expr> fields)
```
    Construct a record-literal expression
    Lustre: id {<fields[0].key> = <fields[0].value>, ...}
    
    Parameters:
    
    id - record type name
    
    fields - a map from fields to values
    
    Returns:
    
    the record-literal expression
  - array
```
public static Expr array(java.util.List<? extends Expr> elements)
```
    Construct an array expression
    Lustre: [<elements[0]>, <elements[1]>, ...
    
    Parameters:
    
    elements - a list of sub-expression elements
    
    Returns:
    
    the array expression
  - recordAccess
```
public static Expr recordAccess(Expr record,
                                java.lang.String field)
```
    Construct a record-access expression
    Lustre: <record>.<field>
    
    Parameters:
    
    record - record of the field to access
    
    field - field to access
    
    Returns:
    
    the record-access expression

Class ExprUtil

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

TRUE

FALSE

Constructor Detail

ExprUtil

Method Detail

and

or

implies

xor

arrow

less

lessEqual

greater

greaterEqual

equal

notEqual

plus

minus

multiply

mod

intDivide

divide

negative

not

pre

id

real

integer

integer

modeRef

functionCall

functionCall

nodeCall

nodeCall

castInt

castReal

and

and

or

or

xor

xor

ite

list

recordLiteral

array

recordAccess