inc

Increments or decrements the value found in a process variable or
a workitem field.

One points to a var or a field in these various ways :

              sequence do
                inc :var => 'counter'
                inc :field => 'counter'
                inc 'v:counter'
                inc 'f:counter'
              end
            

‘inc’ and ‘dec’ work with two types of values : numbers (the default) and
arrays.

numbers

The vanilla case of inc/dec is increasing/decreasing a value by 1.

              dec :var => 'x'
            

will decrease the value in variable ‘x’ by 1.

inc/dec works with two kind of numbers, integers and floats.

If the target var or field is not set, it will be assumed to be at zero.

The default increment is 1 (or 1.0 for floats). It can be changed by
passing a value to the inc/dec expression.

              inc 'v:x', :val => 3
              inc 'v:y', :val => 2.4
            
            

arrays

inc/dec can be used to push/pop elements in arrays held in process variables
or workitem fields.

This fragment of process definition

              sequence do
                set 'v:x' => %w[ a b c d ]
                repeat do
                  dec 'v:x', :pos => 'head'
                  _break :unless => '${__result__}'
                  participant '${__result__}'
                end
              end
            

is equivalent to

              iterator :on => 'a, b, c, d', :to_var => 'x' do
                participant '${v:x}'
              end
            

More details : the inc expression expects a value and it will place it
at the end of the current array. The :pos or :position attribute can
be set to ‘head’ to let the inc expression place the value at the head
of the array.

              set 'v:x' => [ 'alfred', 'bryan' ]
              set 'v:customer_name' => 'charles'
            
              inc 'v:x', :val => '${v:customer_name}'
                # the variable 'x' now holds [ 'alfred', 'bryan', 'charles' ]
              inc 'v:y', :val => '${v:customer_name}', :pos => 'head'
                # the variable 'x' now holds [ 'charles', 'alfred', 'bryan', 'charles' ]
            

The ‘dec’ / ‘decrement’ variant of the expression will remove the tail
value (by default) of the array, or the head value if :pos is set to ‘head’.

It’s also possible to remove a specific value by passing it to ‘dec’ :

              set 'v:x' => [ 'alfred', 'bryan', 'carl' ]
              dec 'v:x', :val => 'bryan'
                # the variable 'x' now holds [ 'alfred', 'carl' ]
            

‘dec’ places the removed value in workitem field ‘result’. This trick
was used in the above iterator example.

A specific variable or field can be specified via the :to_var / :to_field
attributes :

              dec 'v:x', :to_v => 'a'
              participant :ref => '${v:a}'
            
            

nested value

(Since ruote 2.3.0)

If nested expressions are provided the result workitem field is
used for inc.

              inc 'v:x' do
                set '__result__' => 3
              end
            

will increase the value of the variable x by 3.

push and pop

push and pop are aliases for inc and dec respectively. There is a major
difference though: they’ll force the target value into an array.

              sequence do
                set 'v:x' => 2
                push 'v:x' => 3
              end
            

will result in a variable x holding [ 2, 3 ] as value.

Likewise,

              pop 'v:x'
            

will force a value of [] into the variable x if it wasn’t previously set
or its value was not an array with more than one element.