public GroupElement[] transform(final GroupElement cloned, Map<String, Class<?>> globals)
throws InvalidPatternException {
// moved cloned to up
// final GroupElement cloned = (GroupElement) and.clone();
boolean hasNamedConsequenceAndIsStream = processTree(cloned);
cloned.pack();
GroupElement[] ands;
// is top element an AND?
if (cloned.isAnd()) {
// Yes, so just return it
ands = new GroupElement[] {cloned};
} else if (cloned.isOr()) {
// it is an OR, so each child is an AND branch
ands = splitOr(cloned);
} else {
// no, so just wrap into an AND
final GroupElement wrapper = GroupElementFactory.newAndInstance();
wrapper.addChild(cloned);
ands = new GroupElement[] {wrapper};
}
for (GroupElement and : ands) {
// fix the cloned declarations
this.fixClonedDeclarations(and, globals);
and.setRoot(true);
}
return hasNamedConsequenceAndIsStream ? processNamedConsequences(ands) : ands;
}
public GroupElement[] transform(final GroupElement cloned) throws InvalidPatternException {
// moved cloned to up
// final GroupElement cloned = (GroupElement) and.clone();
processTree(cloned);
cloned.pack();
GroupElement[] ands;
// is top element an AND?
if (cloned.isAnd()) {
// Yes, so just return it
ands = new GroupElement[] {cloned};
} else if (cloned.isOr()) {
// it is an OR, so each child is an AND branch
ands = splitOr(cloned);
} else {
// no, so just wrap into an AND
final GroupElement wrapper = GroupElementFactory.newAndInstance();
wrapper.addChild(cloned);
ands = new GroupElement[] {wrapper};
}
for (int i = 0; i < ands.length; i++) {
// fix the cloned declarations
this.fixClonedDeclarations(ands[i]);
ands[i].setRoot(true);
}
return ands;
}
/**
* Traverses a Tree, during the process it transforms Or nodes moving the upwards and it removes
* duplicate logic statement, this does not include Not nodes.
*
* <p>Traversal involves three levels the graph for each iteration. The first level is the current
* node, this node will not be transformed, instead what we are interested in are the children of
* the current node (called the parent nodes) and the children of those parents (call the child
* nodes).
*/
private void processTree(final GroupElement ce, boolean[] result) throws InvalidPatternException {
boolean hasChildOr = false;
// first we elimininate any redundancy
ce.pack();
for (Object child : ce.getChildren().toArray()) {
if (child instanceof GroupElement) {
final GroupElement group = (GroupElement) child;
processTree(group, result);
if ((group.isOr() || group.isAnd()) && group.getType() == ce.getType()) {
group.pack(ce);
} else if (group.isOr()) {
hasChildOr = true;
}
} else if (child instanceof NamedConsequence) {
result[0] = true;
} else if (child instanceof Pattern && ((Pattern) child).getObjectType().isEvent()) {
result[1] = true;
}
}
if (hasChildOr) {
applyOrTransformation(ce);
}
}
/**
* Traverses a Tree, during the process it transforms Or nodes moving the upwards and it removes
* duplicate logic statement, this does not include Not nodes.
*
* <p>Traversal involves three levels the graph for each iteration. The first level is the current
* node, this node will not be transformed, instead what we are interested in are the children of
* the current node (called the parent nodes) and the children of those parents (call the child
* nodes).
*
* @param ce
*/
protected void processTree(final GroupElement ce) throws InvalidPatternException {
boolean hasChildOr = false;
// first we elimininate any redundancy
ce.pack();
Object[] children = (Object[]) ce.getChildren().toArray();
for (Object aChildren : children) {
if (aChildren instanceof GroupElement) {
final GroupElement child = (GroupElement) aChildren;
processTree(child);
if ((child.isOr() || child.isAnd()) && child.getType() == ce.getType()) {
child.pack(ce);
} else if (child.isOr()) {
hasChildOr = true;
}
}
}
if (hasChildOr) {
applyOrTransformation(ce);
}
}