org.eclipse.viatra.transformation.runtime.emf.transformation.batch

## Class BatchTransformationStatements

- java.lang.Object
- - org.eclipse.viatra.transformation.runtime.emf.transformation.batch.BatchTransformationStatements

-     public class BatchTransformationStatements
      extends java.lang.Object

  Utility class for simple rule usage

- - ### Method Summary

    All Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `<Match extends IPatternMatch> int` | `countAllCurrent(BatchTransformationRule<Match,?> rule)` Returns the number of current activations of the rule.
    `<Match extends IPatternMatch> int` | `countAllCurrent(BatchTransformationRule<Match,?> rule, EventFilter<? super Match> filter)` Returns the number of current activations of the rule.
    `<Match extends IPatternMatch> int` | `countAllCurrent(BatchTransformationRule<Match,?> rule, org.eclipse.xtext.xbase.lib.Pair<java.lang.String,?>... parameterFilter)` Returns the number of current activations of the rule.
    `<Match extends IPatternMatch> boolean` | `disposeRule(RuleSpecification<Match> ruleSpecification)`
    `<Match extends IPatternMatch> boolean` | `disposeRule(RuleSpecification<Match> ruleSpecification, EventFilter<? super Match> filter)`
    `void` | `disposeRules(BatchTransformationRuleGroup rules)`
    `<Match extends IPatternMatch> void` | `fireAllCurrent(BatchTransformationRule<Match,?> rule)` Executes the selected rule with the selected filter on its current match set of the precondition.
    `<Match extends IPatternMatch> void` | `fireAllCurrent(BatchTransformationRule<Match,?> rule, EventFilter<? super Match> filter)` Executes the selected rule with the selected filter on its current match set of the precondition.
    `<Match extends IPatternMatch> void` | `fireAllCurrent(BatchTransformationRule<Match,?> rule, org.eclipse.xtext.xbase.lib.Pair<java.lang.String,?>... parameterFilter)` Executes the selected rule with the selected filter on its current match set of the precondition.
    `<Match extends IPatternMatch> void` | `fireOne(BatchTransformationRule<Match,?> rule)` Selects and fires an activation of the selected rule with no corresponding filter.
    `<Match extends IPatternMatch> void` | `fireOne(BatchTransformationRule<Match,?> rule, EventFilter<? super Match> filter)` Selects and fires an activation of the selected rule with a corresponding filter.
    `<Match extends IPatternMatch> void` | `fireOne(BatchTransformationRule<Match,?> rule, org.eclipse.xtext.xbase.lib.Pair<java.lang.String,?>... parameterFilter)` Selects and fires an activation of the selected rule with a corresponding filter
    `<Match extends IPatternMatch> void` | `fireUntil(BatchTransformationRule<Match,?> rule, com.google.common.base.Predicate<Match> breakCondition)` Executes the selected rule with the selected filter as long as there are possible matches of its preconditions and the break condition is not fulfilled.
    `<Match extends IPatternMatch> void` | `fireUntil(BatchTransformationRule<Match,?> rule, com.google.common.base.Predicate<Match> breakCondition, EventFilter<? super Match> filter)` Executes the selected rule with the selected filter as long as there are possible matches of its precondition and the break condition is not fulfilled.
    `<Match extends IPatternMatch> void` | `fireUntil(BatchTransformationRule<Match,?> rule, com.google.common.base.Predicate<Match> breakCondition, org.eclipse.xtext.xbase.lib.Pair<java.lang.String,?>... filterParameters)` Executes the selected rule with the selected filter as long as there are possible matches of its precondition and the break condition is not fulfilled.
    `void` | `fireUntil(BatchTransformationRuleGroup rules, com.google.common.base.Predicate<IPatternMatch> breakCondition)` Executes the selected rules with the selected filter as long as there are possible matches of any of their preconditions and the break condition is not fulfilled.
    `<Match extends IPatternMatch> void` | `fireWhilePossible(BatchTransformationRule<Match,?> rule)` Executes the selected rule with the selected filter as long as there are possible matches of its precondition.
    `<Match extends IPatternMatch> void` | `fireWhilePossible(BatchTransformationRule<Match,?> rule, EventFilter<? super Match> filter)` Executes the selected rule with the selected filter as long as there are possible matches of its preconditions.
    `void` | `fireWhilePossible(BatchTransformationRuleGroup rules)` Executes the selected rules with the selected filter as long as there are possible matches of any of their preconditions.
    `<Match extends IPatternMatch> boolean` | `registerRule(RuleSpecification<Match> ruleSpecification)`
    `<Match extends IPatternMatch> boolean` | `registerRule(RuleSpecification<Match> ruleSpecification, EventFilter<? super Match> filter)`
    `void` | `registerRules(BatchTransformationRuleGroup rules)`

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- - ### Method Detail

    - #### fireUntil

          public <Match extends IPatternMatch> void fireUntil(BatchTransformationRule<Match,?> rule,
                                                              com.google.common.base.Predicate<Match> breakCondition)

      Executes the selected rule with the selected filter as long as there are possible matches of its preconditions and the break condition is not fulfilled. The matches are executed one-by-one, in case of conflicts only one of the conflicting matches will cause an execution.

    - #### fireUntil

          public <Match extends IPatternMatch> void fireUntil(BatchTransformationRule<Match,?> rule,
                                                              com.google.common.base.Predicate<Match> breakCondition,
                                                              org.eclipse.xtext.xbase.lib.Pair<java.lang.String,?>... filterParameters)

      Executes the selected rule with the selected filter as long as there are possible matches of its precondition and the break condition is not fulfilled. The matches are executed one-by-one, in case of conflicts only one of the conflicting matches will cause an execution.

    - #### fireUntil

          public <Match extends IPatternMatch> void fireUntil(BatchTransformationRule<Match,?> rule,
                                                              com.google.common.base.Predicate<Match> breakCondition,
                                                              EventFilter<? super Match> filter)

      Executes the selected rule with the selected filter as long as there are possible matches of its precondition and the break condition is not fulfilled. The matches are executed one-by-one, in case of conflicts only one of the conflicting matches will cause an execution.

    - #### fireUntil

          public void fireUntil(BatchTransformationRuleGroup rules,
                                com.google.common.base.Predicate<IPatternMatch> breakCondition)

      Executes the selected rules with the selected filter as long as there are possible matches of any of their preconditions and the break condition is not fulfilled. The matches are executed one-by-one, in case of conflicts only one of the conflicting matches will cause an execution.

    - #### fireWhilePossible

          public <Match extends IPatternMatch> void fireWhilePossible(BatchTransformationRule<Match,?> rule)

      Executes the selected rule with the selected filter as long as there are possible matches of its precondition. The matches are executed one-by-one, in case of conflicts only one of the conflicting matches will cause an execution.

    - #### fireWhilePossible

          public <Match extends IPatternMatch> void fireWhilePossible(BatchTransformationRule<Match,?> rule,
                                                                      EventFilter<? super Match> filter)

      Executes the selected rule with the selected filter as long as there are possible matches of its preconditions. The matches are executed one-by-one, in case of conflicts only one of the conflicting matches will cause an execution.

    - #### fireWhilePossible

          public void fireWhilePossible(BatchTransformationRuleGroup rules)

      Executes the selected rules with the selected filter as long as there are possible matches of any of their preconditions. The matches are executed one-by-one, in case of conflicts only one of the conflicting matches will cause an execution.

    - #### fireAllCurrent

          public <Match extends IPatternMatch> void fireAllCurrent(BatchTransformationRule<Match,?> rule)

      Executes the selected rule with the selected filter on its current match set of the precondition.

    - #### fireAllCurrent

          public <Match extends IPatternMatch> void fireAllCurrent(BatchTransformationRule<Match,?> rule,
                                                                   org.eclipse.xtext.xbase.lib.Pair<java.lang.String,?>... parameterFilter)

      Executes the selected rule with the selected filter on its current match set of the precondition.

    - #### fireAllCurrent

          public <Match extends IPatternMatch> void fireAllCurrent(BatchTransformationRule<Match,?> rule,
                                                                   EventFilter<? super Match> filter)

      Executes the selected rule with the selected filter on its current match set of the precondition.

    - #### registerRule

          public <Match extends IPatternMatch> boolean registerRule(RuleSpecification<Match> ruleSpecification)

    - #### registerRule

          public <Match extends IPatternMatch> boolean registerRule(RuleSpecification<Match> ruleSpecification,
                                                                    EventFilter<? super Match> filter)

    - #### registerRules

          public void registerRules(BatchTransformationRuleGroup rules)

    - #### countAllCurrent

          public <Match extends IPatternMatch> int countAllCurrent(BatchTransformationRule<Match,?> rule)

      Returns the number of current activations of the rule.
      Since:
        1.5

    - #### countAllCurrent

          public <Match extends IPatternMatch> int countAllCurrent(BatchTransformationRule<Match,?> rule,
                                                                   org.eclipse.xtext.xbase.lib.Pair<java.lang.String,?>... parameterFilter)

      Returns the number of current activations of the rule.
      Since:
        1.5

    - #### countAllCurrent

          public <Match extends IPatternMatch> int countAllCurrent(BatchTransformationRule<Match,?> rule,
                                                                   EventFilter<? super Match> filter)

      Returns the number of current activations of the rule.
      Since:
        1.5

    - #### disposeRule

          public <Match extends IPatternMatch> boolean disposeRule(RuleSpecification<Match> ruleSpecification)

    - #### disposeRule

          public <Match extends IPatternMatch> boolean disposeRule(RuleSpecification<Match> ruleSpecification,
                                                                   EventFilter<? super Match> filter)

    - #### disposeRules

          public void disposeRules(BatchTransformationRuleGroup rules)

    - #### fireOne

          public <Match extends IPatternMatch> void fireOne(BatchTransformationRule<Match,?> rule)

      Selects and fires an activation of the selected rule with no corresponding filter.

      Warning: the selection criteria is not specified - it is neither random nor controllable

    - #### fireOne

          public <Match extends IPatternMatch> void fireOne(BatchTransformationRule<Match,?> rule,
                                                            org.eclipse.xtext.xbase.lib.Pair<java.lang.String,?>... parameterFilter)

      Selects and fires an activation of the selected rule with a corresponding filter

      Warning: the selection criteria is not specified - it is neither random nor controllable

    - #### fireOne

          public <Match extends IPatternMatch> void fireOne(BatchTransformationRule<Match,?> rule,
                                                            EventFilter<? super Match> filter)

      Selects and fires an activation of the selected rule with a corresponding filter.

      Warning: the selection criteria is not specified - it is neither random nor controllable