TreeRewriteRule (Jenetics 5.1.0)

java.lang.Object
- io.jenetics.ext.rewriting.TreeRewriteRule<V>

All Implemented Interfaces:

TreeRewriter<V>, Serializable
```
public final class TreeRewriteRule<V>
extends Object
implements TreeRewriter<V>, Serializable
```
Represents a tree rewrite rule. A rewrite rule consists of a match pattern, which must be matched, and a substitution pattern, which is expanded and replaces the variables in the pattern. Some simple arithmetic rewrite rules.
```
 
     add($x,0) -> $x
     mul($x,1) -> $x
 
```
The substitution pattern may only use variables, already defined in the match pattern. So, the creation of the following rewrite rule s would lead to an IllegalArgumentException:
```
 
     add($x,0) -> $y
     mul(0,1) -> mul($x,1)
 
```
Since:

5.0

Version:

5.0

Author:

Franz Wilhelmstötter

See Also:

Tree rewriting systems, Serialized Form

Constructor Summary

Constructors
Constructor and Description
`TreeRewriteRule(TreePattern<V> left, TreePattern<V> right)` Create a new rewrite rule from the given matching (`left`) and replacement (`right`) pattern.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`boolean`	`equals(Object obj)`
`int`	`hashCode()`
`TreePattern<V>`	`left()` Return the rule matching pattern.
`<B> TreeRewriteRule<B>`	`map(Function<? super V,? extends B> mapper)` Maps `this` rewrite rule from type `V` to type `B`.
`static TreeRewriteRule<String>`	`parse(String rule)` Compiles the string representation of a rewrite rule:
`static <V> TreeRewriteRule<V>`	`parse(String rule, Function<? super String,? extends V> mapper)` Compiles the string representation of a rewrite rule:
`int`	`rewrite(TreeNode<V> tree, int limit)` Applies the rewriting to the given (mutable) `tree`.
`TreePattern<V>`	`right()` Return the replacement pattern of the rule.
`String`	`toString()`

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

Methods inherited from interface io.jenetics.ext.rewriting.TreeRewriter
concat, rewrite, rewrite, rewrite

- Constructor Detail
  - TreeRewriteRule
```
public TreeRewriteRule(TreePattern<V> left,
                       TreePattern<V> right)
```
    Create a new rewrite rule from the given matching (left) and replacement (right) pattern.
    
    Parameters:
    
    left - the matching pattern of the rule
    
    right - the substitution pattern
    
    Throws:
    
    NullPointerException - if one of the arguments is null
    
    IllegalArgumentException - if the template pattern uses variables not defined in the matcher pattern
- Method Detail
  - left
```
public TreePattern<V> left()
```
    Return the rule matching pattern.
    
    Returns:
    
    the rule matching pattern
  - right
```
public TreePattern<V> right()
```
    Return the replacement pattern of the rule.
    
    Returns:
    
    the replacement pattern of the rule
  - map
```
public <B> TreeRewriteRule<B> map(Function<? super V,? extends B> mapper)
```
    Maps this rewrite rule from type V to type B.
    
    Type Parameters:
    
    B - the target type
    
    Parameters:
    
    mapper - the type mapper
    
    Returns:
    
    a new rewrite rule for the mapped type
    
    Throws:
    
    NullPointerException - if the mapper is null
  - rewrite
```
public int rewrite(TreeNode<V> tree,
                   int limit)
```
    Description copied from interface: TreeRewriter
    
    Applies the rewriting to the given (mutable) tree. The tree rewrite is done in place. Via the limit parameter, the termination of the tree-rewrite process can be guaranteed.
    
    Specified by:
    
    rewrite in interface TreeRewriter<V>
    
    Parameters:
    
    tree - the tree to be rewritten
    
    limit - the maximal number this rewrite rule is applied to the given tree. This guarantees the termination of the rewrite method.
    
    Returns:
    
    the number of rewrites applied to the input tree
  - hashCode
```
public int hashCode()
```
    Overrides:
    
    hashCode in class Object
  - equals
```
public boolean equals(Object obj)
```
    Overrides:
    
    equals in class Object
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object
  - parse
```
public static <V> TreeRewriteRule<V> parse(String rule,
                                           Function<? super String,? extends V> mapper)
```
    Compiles the string representation of a rewrite rule:
```
 
     add($x,0) -> $x
     mul($x,1) -> $x
 
```
    Type Parameters:
    
    V - the tree node type
    
    Parameters:
    
    rule - the rewrite rule
    
    mapper - the mapper function which converts the node value into the actual type V
    
    Returns:
    
    a new rewrite rule, compiled from the given rule string
    
    Throws:
    
    IllegalArgumentException - if the rewrite rule is invalid
    
    NullPointerException - if on of the arguments is null
  - parse
```
public static TreeRewriteRule<String> parse(String rule)
```
    Compiles the string representation of a rewrite rule:
```
 
     add($x,0) -> $x
     mul($x,1) -> $x
 
```
    Parameters:
    
    rule - the rewrite rule
    
    Returns:
    
    a new rewrite rule, compiled from the given rule string
    
    Throws:
    
    IllegalArgumentException - if the rewrite rule is invalid
    
    NullPointerException - if on of the arguments is null

Class TreeRewriteRule<V>

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface io.jenetics.ext.rewriting.TreeRewriter

Constructor Detail

TreeRewriteRule

Method Detail

left

right

map

rewrite

hashCode

equals

toString

parse

parse