Builder (Groovy CPS Execution 1.1 API)

java.lang.Object
- com.cloudbees.groovy.cps.Builder

```
public class Builder
extends Object
```
Builder pattern for constructing Blocks into a tree. For example, to build a Block that represents "1+1", you'd call plus(one(),one())

Author:

Kohsuke Kawaguchi

Constructor Summary

Constructors
Constructor and Description

Builder(MethodLocation loc)

Constructors
Constructor and Description
`Builder(MethodLocation loc)`

Method Summary

Methods
Modifier and Type	Method and Description
`LValueBlock`	`array(int line, Block lhs, Block index)`
`Block`	`assert_(Block cond, Block msg, String sourceText)`
`Block`	`assert_(Block cond, String sourceText)`
`Block`	`assign(int line, LValueBlock lhs, Block rhs)`
`LValueBlock`	`attribute(int line, Block lhs, Block property)`
`Block`	`bitwiseAnd(int line, Block lhs, Block rhs)`
`Block`	`bitwiseAndEqual(int line, LValueBlock lhs, Block rhs)`
`Block`	`bitwiseNegation(int line, Block b)`
`Block`	`bitwiseOr(int line, Block lhs, Block rhs)`
`Block`	`bitwiseOrEqual(int line, LValueBlock lhs, Block rhs)`
`Block`	`bitwiseXor(int line, Block lhs, Block rhs)`
`Block`	`bitwiseXorEqual(int line, LValueBlock lhs, Block rhs)`
`Block`	`block(Block... bodies)` { ...
`Block`	`break_(String label)`
`CaseExpression`	`case_(int line, Block matcher, Block body)`
`Block`	`cast(int line, Block block, Class type, boolean coerce)` Cast to type.
`Block`	`closure(List<String> parameters, Block body)`
`Block`	`compareEqual(int line, Block lhs, Block rhs)`
`Block`	`compareNotEqual(int line, Block lhs, Block rhs)`
`Block`	`compareTo(int line, Block lhs, Block rhs)`
`Block`	`constant(Object o)`
`Block`	`continue_(String label)`
`Block`	`declareVariable(Class type, String name)`
`Block`	`declareVariable(int line, Class type, String name, Block init)`
`Block`	`div(int line, Block lhs, Block rhs)`
`Block`	`divEqual(int line, LValueBlock lhs, Block rhs)`
`Block`	`doWhile(String label, Block body, Block cond)`
`Block`	`elvisOp(Block cond, Block falseExp)` x ?: y
`Block`	`false_()`
`Block`	`findRegex(int line, Block lhs, Block rhs)` lhs =~ rhs
`Block`	`forInLoop(int line, String label, Class type, String variable, Block collection, Block body)` for (x in col) { ...
`Block`	`forLoop(String label, Block e1, Block e2, Block e3, Block body)` for (e1; e2; e3) { ...
`Block`	`functionCall(int line, Block lhs, Block name, Block... argExps)`
`Block`	`functionCall(int line, Block lhs, String name, Block... argExps)` LHS.name(...)
`Block`	`greaterThan(int line, Block lhs, Block rhs)`
`Block`	`greaterThanEqual(int line, Block lhs, Block rhs)`
`Block`	`gstring(int line, Block listOfValues, Block listOfStrings)` "Foo bar zot ${x}" kind of string
`Block`	`if_(Block cond, Block then)`
`Block`	`if_(Block cond, Block then, Block els)` if (...) { ...
`Block`	`instanceOf(int line, Block value, Block type)`
`Block`	`intdiv(int line, Block lhs, Block rhs)`
`Block`	`intdivEqual(int line, LValueBlock lhs, Block rhs)`
`Block`	`isCase(int line, Block lhs, Block rhs)` lhs in rhs
`Block`	`leftShift(int line, Block lhs, Block rhs)` lhs << rhs
`Block`	`leftShiftEqual(int line, LValueBlock lhs, Block rhs)` lhs <<= rhs
`Block`	`lessThan(int line, Block lhs, Block rhs)`
`Block`	`lessThanEqual(int line, Block lhs, Block rhs)`
`Block`	`list(Block... args)` [a,b,c,d] that creates a List.
`LValueBlock`	`localVariable(String name)`
`Block`	`localVariableAssignOp(int line, String name, String operator, Block rhs)` Assignment operator to a local variable, such as "x += 3"
`Block`	`logicalAnd(int line, Block lhs, Block rhs)` lhs && rhs
`Block`	`logicalOr(int line, Block lhs, Block rhs)` lhs \|\| rhs
`Block`	`map(Block... blocks)` Map literal: [ a:b, c:d, e:f ] ...
`Block`	`map(List<Block> blocks)`
`Block`	`matchRegex(int line, Block lhs, Block rhs)` lhs ==~ rhs
`Block`	`minus(int line, Block lhs, Block rhs)`
`Block`	`minusEqual(int line, LValueBlock lhs, Block rhs)`
`Block`	`mod(int line, Block lhs, Block rhs)`
`Block`	`modEqual(int line, LValueBlock lhs, Block rhs)`
`Block`	`multiply(int line, Block lhs, Block rhs)`
`Block`	`multiplyEqual(int line, LValueBlock lhs, Block rhs)`
`Block`	`new_(int line, Block type, Block... argExps)`
`Block`	`new_(int line, Class type, Block... argExps)` Object instantiation.
`Block`	`newArray(int line, Class type, Block... argExps)` Array instantiation like `new String[1][5]`
`Block`	`noop()`
`Block`	`not(int line, Block b)` !b
`Block`	`null_()`
`Block`	`one()`
`Block`	`plus(int line, Block lhs, Block rhs)`
`Block`	`plusEqual(int line, LValueBlock lhs, Block rhs)`
`Block`	`postfixDec(int line, LValueBlock body)` x--
`Block`	`postfixInc(int line, LValueBlock body)` x++
`Block`	`power(int line, Block lhs, Block rhs)`
`Block`	`powerEqual(int line, LValueBlock lhs, Block rhs)`
`Block`	`prefixDec(int line, LValueBlock body)` --x
`Block`	`prefixInc(int line, LValueBlock body)` ++x
`LValueBlock`	`property(int line, Block lhs, Block property)`
`LValueBlock`	`property(int line, Block lhs, String property)`
`Block`	`range(int line, Block from, Block to, boolean inclusive)` x..y or x..<y to crete a range
`Block`	`return_(Block exp)` return exp;
`Block`	`rightShift(int line, Block lhs, Block rhs)` lhs >> rhs
`Block`	`rightShiftEqual(int line, LValueBlock lhs, Block rhs)` lhs >>= rhs
`Block`	`rightShiftUnsigned(int line, Block lhs, Block rhs)` lhs >>> rhs
`Block`	`rightShiftUnsignedEqual(int line, LValueBlock lhs, Block rhs)` lhs >>>= rhs
`Block`	`sequence(Block... bodies)` Like `block(Block...)` but it doesn't create a new scope.
`Block`	`sequence(Block b)`
`Block`	`sequence(Block exp1, Block exp2)`
`Block`	`setLocalVariable(int line, String name, Block rhs)`
`Block`	`setProperty(int line, Block lhs, Block property, Block rhs)`
`Block`	`setProperty(int line, Block lhs, String property, Block rhs)`
`Block`	`staticCall(int line, Class lhs, String name, Block... argExps)`
`LValueBlock`	`staticField(int line, Class type, String name)`
`Block`	`switch_(String label, Block switchExp, Block defaultStmt, CaseExpression... caseExps)`
`Block`	`ternaryOp(Block cond, Block trueExp, Block falseExp)`
`Block`	`this_()`
`Block`	`throw_(int line, Block exp)` throw exp;
`Block`	`true_()`
`Block`	`tryCatch(Block body, Block finally_, CatchExpression... catches)`
`Block`	`tryCatch(Block body, List<CatchExpression> catches)` try { ...
`Block`	`tryCatch(Block body, List<CatchExpression> catches, Block finally_)`
`Block`	`two()`
`Block`	`unaryMinus(int line, Block lhs)`
`Block`	`unaryPlus(int line, Block lhs)`
`Block`	`while_(String label, Block cond, Block body)`
`Object`	`with(groovy.lang.Closure c)` Evaluate the given closure by passing this object as an argument.
`Block`	`zero()`

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

Constructor Detail
- Builder
```
public Builder(MethodLocation loc)
```

Method Detail

with
```
public Object with(groovy.lang.Closure c)
```
Evaluate the given closure by passing this object as an argument. Used to bind literal Builder to a local variable.

null_
```
public Block null_()
```

noop
```
public Block noop()
```

constant
```
public Block constant(Object o)
```

zero
```
public Block zero()
```

one
```
public Block one()
```

two
```
public Block two()
```

true_
```
public Block true_()
```

false_
```
public Block false_()
```

block
```
public Block block(Block... bodies)
```
{ ... }

sequence
```
public Block sequence(Block... bodies)
```
Like block(Block...) but it doesn't create a new scope.

sequence

public Block sequence(Block exp1,
             Block exp2)

sequence
```
public Block sequence(Block b)
```

closure

public Block closure(List<String> parameters,
            Block body)

localVariable

public LValueBlock localVariable(String name)

setLocalVariable

public Block setLocalVariable(int line,
                     String name,
                     Block rhs)

declareVariable

public Block declareVariable(Class type,
                    String name)

declareVariable

public Block declareVariable(int line,
                    Class type,
                    String name,
                    Block init)

this_
```
public Block this_()
```

localVariableAssignOp

public Block localVariableAssignOp(int line,
                          String name,
                          String operator,
                          Block rhs)

Assignment operator to a local variable, such as "x += 3"

if_

public Block if_(Block cond,
        Block then,
        Block els)

if (...) { ... } else { ... }

if_

public Block if_(Block cond,
        Block then)

forLoop

public Block forLoop(String label,
            Block e1,
            Block e2,
            Block e3,
            Block body)

for (e1; e2; e3) { ... }

forInLoop

public Block forInLoop(int line,
              String label,
              Class type,
              String variable,
              Block collection,
              Block body)

for (x in col) { ... }

break_
```
public Block break_(String label)
```

continue_
```
public Block continue_(String label)
```

while_

public Block while_(String label,
           Block cond,
           Block body)

doWhile

public Block doWhile(String label,
            Block body,
            Block cond)

tryCatch

public Block tryCatch(Block body,
             Block finally_,
             CatchExpression... catches)

tryCatch

public Block tryCatch(Block body,
             List<CatchExpression> catches)

try { ... } catch (T v) { ... } catch (T v) { ... }

tryCatch

public Block tryCatch(Block body,
             List<CatchExpression> catches,
             Block finally_)

throw_

public Block throw_(int line,
           Block exp)

throw exp;

map
```
public Block map(Block... blocks)
```
Map literal: [ a:b, c:d, e:f ] ... We expect arguments to be multiple of two.

map
```
public Block map(List<Block> blocks)
```

staticCall

public Block staticCall(int line,
               Class lhs,
               String name,
               Block... argExps)

plus

public Block plus(int line,
         Block lhs,
         Block rhs)

plusEqual

public Block plusEqual(int line,
              LValueBlock lhs,
              Block rhs)

minus

public Block minus(int line,
          Block lhs,
          Block rhs)

minusEqual

public Block minusEqual(int line,
               LValueBlock lhs,
               Block rhs)

multiply

public Block multiply(int line,
             Block lhs,
             Block rhs)

multiplyEqual

public Block multiplyEqual(int line,
                  LValueBlock lhs,
                  Block rhs)

div

public Block div(int line,
        Block lhs,
        Block rhs)

divEqual

public Block divEqual(int line,
             LValueBlock lhs,
             Block rhs)

intdiv

public Block intdiv(int line,
           Block lhs,
           Block rhs)

intdivEqual

public Block intdivEqual(int line,
                LValueBlock lhs,
                Block rhs)

mod

public Block mod(int line,
        Block lhs,
        Block rhs)

modEqual

public Block modEqual(int line,
             LValueBlock lhs,
             Block rhs)

power

public Block power(int line,
          Block lhs,
          Block rhs)

powerEqual

public Block powerEqual(int line,
               LValueBlock lhs,
               Block rhs)

unaryMinus

public Block unaryMinus(int line,
               Block lhs)

unaryPlus

public Block unaryPlus(int line,
              Block lhs)

ternaryOp

public Block ternaryOp(Block cond,
              Block trueExp,
              Block falseExp)

elvisOp

public Block elvisOp(Block cond,
            Block falseExp)

x ?: y

compareEqual

public Block compareEqual(int line,
                 Block lhs,
                 Block rhs)

compareNotEqual

public Block compareNotEqual(int line,
                    Block lhs,
                    Block rhs)

compareTo

public Block compareTo(int line,
              Block lhs,
              Block rhs)

lessThan

public Block lessThan(int line,
             Block lhs,
             Block rhs)

lessThanEqual

public Block lessThanEqual(int line,
                  Block lhs,
                  Block rhs)

greaterThan

public Block greaterThan(int line,
                Block lhs,
                Block rhs)

greaterThanEqual

public Block greaterThanEqual(int line,
                     Block lhs,
                     Block rhs)

findRegex

public Block findRegex(int line,
              Block lhs,
              Block rhs)

lhs =~ rhs

matchRegex

public Block matchRegex(int line,
               Block lhs,
               Block rhs)

lhs ==~ rhs

isCase

public Block isCase(int line,
           Block lhs,
           Block rhs)

lhs in rhs

logicalAnd

public Block logicalAnd(int line,
               Block lhs,
               Block rhs)

lhs && rhs

logicalOr

public Block logicalOr(int line,
              Block lhs,
              Block rhs)

lhs || rhs

leftShift

public Block leftShift(int line,
              Block lhs,
              Block rhs)

lhs << rhs

leftShiftEqual

public Block leftShiftEqual(int line,
                   LValueBlock lhs,
                   Block rhs)

lhs <<= rhs

rightShift

public Block rightShift(int line,
               Block lhs,
               Block rhs)

lhs >> rhs

rightShiftEqual

public Block rightShiftEqual(int line,
                    LValueBlock lhs,
                    Block rhs)

lhs >>= rhs

rightShiftUnsigned

public Block rightShiftUnsigned(int line,
                       Block lhs,
                       Block rhs)

lhs >>> rhs

rightShiftUnsignedEqual

public Block rightShiftUnsignedEqual(int line,
                            LValueBlock lhs,
                            Block rhs)

lhs >>>= rhs

not

public Block not(int line,
        Block b)

bitwiseAnd

public Block bitwiseAnd(int line,
               Block lhs,
               Block rhs)

bitwiseAndEqual

public Block bitwiseAndEqual(int line,
                    LValueBlock lhs,
                    Block rhs)

bitwiseOr

public Block bitwiseOr(int line,
              Block lhs,
              Block rhs)

bitwiseOrEqual

public Block bitwiseOrEqual(int line,
                   LValueBlock lhs,
                   Block rhs)

bitwiseXor

public Block bitwiseXor(int line,
               Block lhs,
               Block rhs)

bitwiseXorEqual

public Block bitwiseXorEqual(int line,
                    LValueBlock lhs,
                    Block rhs)

bitwiseNegation

public Block bitwiseNegation(int line,
                    Block b)

prefixInc

public Block prefixInc(int line,
              LValueBlock body)

++x

prefixDec

public Block prefixDec(int line,
              LValueBlock body)

--x

postfixInc

public Block postfixInc(int line,
               LValueBlock body)

x++

postfixDec

public Block postfixDec(int line,
               LValueBlock body)

x--

cast

public Block cast(int line,
         Block block,
         Class type,
         boolean coerce)

Cast to type.

Parameters:: coerce - True for "exp as type" cast. false for "(type)exp" cast.

instanceOf

public Block instanceOf(int line,
               Block value,
               Block type)

functionCall

public Block functionCall(int line,
                 Block lhs,
                 String name,
                 Block... argExps)

LHS.name(...)

functionCall

public Block functionCall(int line,
                 Block lhs,
                 Block name,
                 Block... argExps)

assign

public Block assign(int line,
           LValueBlock lhs,
           Block rhs)

property

public LValueBlock property(int line,
                   Block lhs,
                   String property)

property

public LValueBlock property(int line,
                   Block lhs,
                   Block property)

array

public LValueBlock array(int line,
                Block lhs,
                Block index)

attribute

public LValueBlock attribute(int line,
                    Block lhs,
                    Block property)

staticField

public LValueBlock staticField(int line,
                      Class type,
                      String name)

setProperty

public Block setProperty(int line,
                Block lhs,
                String property,
                Block rhs)

setProperty

public Block setProperty(int line,
                Block lhs,
                Block property,
                Block rhs)

new_

public Block new_(int line,
         Class type,
         Block... argExps)

Object instantiation.

new_

public Block new_(int line,
         Block type,
         Block... argExps)

newArray

public Block newArray(int line,
             Class type,
             Block... argExps)

Array instantiation like new String[1][5]

return_
```
public Block return_(Block exp)
```
return exp;

list
```
public Block list(Block... args)
```
[a,b,c,d] that creates a List.

range

public Block range(int line,
          Block from,
          Block to,
          boolean inclusive)

x..y or x..<y to crete a range

assert_

public Block assert_(Block cond,
            Block msg,
            String sourceText)

assert_

public Block assert_(Block cond,
            String sourceText)

gstring

public Block gstring(int line,
            Block listOfValues,
            Block listOfStrings)

"Foo bar zot ${x}" kind of string

switch_

public Block switch_(String label,
            Block switchExp,
            Block defaultStmt,
            CaseExpression... caseExps)

See Also:: case_(int, Block, Block)

case_

public CaseExpression case_(int line,
                   Block matcher,
                   Block body)

Class Builder

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

Builder

Method Detail

with

null_

noop

constant

zero

one

two

true_

false_

block

sequence

sequence

sequence

closure

localVariable

setLocalVariable

declareVariable

declareVariable

this_

localVariableAssignOp

if_

if_

forLoop

forInLoop

break_

continue_

while_

doWhile

tryCatch

tryCatch

tryCatch

throw_

map

map

staticCall

plus

plusEqual

minus

minusEqual

multiply

multiplyEqual

div

divEqual

intdiv

intdivEqual

mod

modEqual

power

powerEqual

unaryMinus

unaryPlus

ternaryOp

elvisOp

compareEqual

compareNotEqual

compareTo

lessThan

lessThanEqual

greaterThan

greaterThanEqual

findRegex

matchRegex

isCase

logicalAnd

logicalOr

leftShift

leftShiftEqual

rightShift

rightShiftEqual

rightShiftUnsigned

rightShiftUnsignedEqual

not

bitwiseAnd