public RuleType Convert(string name, NodeBase rootCondition, List<NodeBase> actionList)
{
RuleType rule = new RuleType();
rule.AddName(new Altova.Types.SchemaString(name));
//this first node is the condition. Called traverse twice to create the two expressions
LogicalExpression expression = CreateLogical(rootCondition);
rule.AddCondition(expression);
foreach (NodeBase node in actionList)
{
if ((node.m_NodeType == NodeType.SETVARIABLE) || (node.m_NodeType == NodeType.CALLSCRIPT))
{
XMLRules.ActionType action = MakeAction(node);
if (action != null)
rule.AddAction(action);
else
Debug.LogError("Error saving an action node");
}
}
rule.AddPriority(new Altova.Types.SchemaLong(100L));
return rule;
}
public override bool CheckChild(NodeBase child)
{
bool result = false;
if (m_Children.Contains (child))
result = false;
return result;
}
public void RemoveNode(NodeBase node)
{
foreach(NodeEdge edgeToRemove in m_NodeEdges)
{
if (edgeToRemove.CheckForEdge(node))
break;
}
m_RemoveNodeList.Add(node);
}
public bool CheckForEdge(NodeBase node)
{
bool result = false;
if(m_FromNode == node || m_ToNode == node)
{
RemoveEdgeFunction();
result = true;
}
return result;
}
public bool GetChildAt(int index, out NodeBase node)
{
node = null;
if (index >= m_Children.Count)
return false;
node = m_Children[index];
return true;
}
public override bool CheckChild(NodeBase child)
{
bool result = false;
if (CheckForCycles(this, child))
return false;
if ((child.m_NodeType == NodeType.ARITHMETIC) ||
(child.m_NodeType == NodeType.VARIABLE) || (child.m_NodeType == NodeType.CONSTANT))
result = true;
return result;
}
// Use the number of leaf nodes of a tree as an estimate of its width at the base.
int CountLeafNodes(NodeBase node)
{
int count = 0;
if (node.m_Children.Count == 0)
count++;
else
foreach (NodeBase child in node.m_Children)
{
count += CountLeafNodes(child);
}
return count;
}
public bool CheckForCycles(NodeBase parent, NodeBase child)
{
if (parent.m_Children.Contains(child))
return true;
bool result = false;
foreach (NodeBase node in parent.m_Children)
{
if (result = CheckForCycles (node, child))
break;
}
return result;
}
void LayoutTree(NodeBase node, float posx, float posy)
{
node.m_Window.x = posx;
node.m_Window.y = posy;
float dx = 0;
int leafNodes = CountLeafNodes(node);
dx = leafNodes * 75 / 2;
if (node.m_Children.Count >= 1)
LayoutTree(node.m_Children[0], posx - dx, posy + 200);
if (node.m_Children.Count == 2)
LayoutTree(node.m_Children[1], posx + dx, posy + 200);
}
XMLRules.ActionType MakeAction(NodeBase node)
{
if (node.m_NodeType == NodeType.SETVARIABLE)
{
SetNode setNode = (SetNode)node;
if (m_State != null)
{
Variable variable;
if (setNode.m_Children.Count >= 1)
{
if (m_State.GetVariable(setNode.m_VariableName, out variable))
{
ArithmeticExpression value = CreateArithmeticExpression(setNode.m_Children[0]);
return m_RuleMaker.MakeStateChangeAction(setNode.m_VariableName, variable.m_Type, value);
}
else
{
Debug.LogError("Invalid assignment: variable " + setNode.m_VariableName + " not found");
}
}
else
{
Debug.LogError("Invalid assignment: no value was specified");
}
}
}
else if (node.m_NodeType == NodeType.CALLSCRIPT)
{
CallNode callNode = (CallNode)node;
return m_RuleMaker.MakeCallScriptAction(callNode);
}
return null;
}
ArithmeticExpression CreateArithmetic(NodeBase node)
{
ArithmeticExpression lhs = CreateArithmeticExpression(node.m_Children[0]);
ArithmeticExpression rhs = CreateArithmeticExpression(node.m_Children[1]);
return m_RuleMaker.MakeArithmeticSubExperssion(((ArithmeticNode)node).GetOperator(), lhs, rhs);
}
LogicalExpression CreateRelationalExpression(NodeBase node)
{
ArithmeticExpression lhs = CreateArithmeticExpression(node.m_Children[0]);
ArithmeticExpression rhs = CreateArithmeticExpression(node.m_Children[1]);
return m_RuleMaker.MakeRelationalExperssion(((RelationalNode)node).GetOperator(), lhs, rhs);
}
LogicalExpression CreateLogicalExpression(NodeBase node)
{
LogicalExpression expression = null;
LogicalNode logicalNode = (LogicalNode)node;
if (logicalNode.m_LogicalType == LogicalOperatorType.NOT)
{
LogicalExpression rhs = CreateLogical(node.m_Children[0]);
expression = m_RuleMaker.MakeLogical(rhs);
}
else
{
switch (node.m_NodeType)
{
case NodeType.RELATIONAL:
{
ArithmeticExpression lhs = CreateArithmeticExpression(node.m_Children[0]);
ArithmeticExpression rhs = CreateArithmeticExpression(node.m_Children[1]);
expression = m_RuleMaker.MakeRelationalExperssion(((RelationalNode)node).GetOperator(), lhs, rhs);
}
break;
case NodeType.LOGICAL:
{
LogicalExpression lhs = CreateLogical(node.m_Children[0]);
LogicalExpression rhs = CreateLogical(node.m_Children[1]);
expression = m_RuleMaker.MakeLogical(((LogicalNode)node).GetOperator(), lhs, rhs);
}
break;
}
}
return expression;
}
public override bool CheckChild(NodeBase child)
{
bool result = false;
return result;
}
public void AddChild(NodeBase node) { m_Children.Add(node); }
void BuildNodeList(NodeBase rootNode, ref List<NodeBase> nodeList)
{
nodeList.Add(rootNode);
foreach (NodeBase node in rootNode.m_Children)
{
BuildNodeList(node, ref nodeList);
}
}
public void RemoveChild(NodeBase node) { m_Children.Remove(node);}
ArithmeticExpression CreateArithmeticExpression(NodeBase node)
{
ArithmeticExpression expression = null;
switch (node.m_NodeType)
{
case NodeType.ARITHMETIC:
expression = CreateArithmetic(node);
break;
case NodeType.CONSTANT:
{
Value value = m_RuleMaker.MakeConstant(((ConstantNode)node).m_ConstantType, ((ConstantNode)node).m_ConstantValue);
expression = m_RuleMaker.MakeArithmeticExperssion(value);
}
break;
case NodeType.VARIABLE:
{
Value value = m_RuleMaker.MakeVariable(((VariableNode)node).m_VariableName, ((VariableNode)node).m_VariableType);
expression = m_RuleMaker.MakeArithmeticExperssion(value);
}
break;
}
return expression;
}
public override bool CheckChild(NodeBase child)
{
bool result = false;
return(result);
}
NodeBase CreateLogicalNode(LogicalExpression exp)
{
NodeBase node = null;
if (exp.HasUnary())
{
node = new LogicalNode(m_Container);
((LogicalNode)node).m_LogicalType = LogicalOperatorType.NOT;
node.AddChild(CreateLogicalNode(exp.GetUnary().GetLogicalExpression()));
}
else if (exp.HasRelational())
{
node = new RelationalNode(m_Container);
RelationalOperator op = exp.GetRelational().GetRelationalOperator();
if (op.HasEquals())
{
((RelationalNode)node).m_RelationType = RelationType.EQUAL;
}
else if (op.HasGreaterThan())
{
((RelationalNode)node).m_RelationType = RelationType.GREATERTHAN;
}
else if (op.HasGreaterThanOrEquals())
{
((RelationalNode)node).m_RelationType = RelationType.GREATERTHANOREQUAL;
}
else if (op.HasLessThan())
{
((RelationalNode)node).m_RelationType = RelationType.LESSTHAN;
}
else if (op.HasLessThanOrEquals())
{
((RelationalNode)node).m_RelationType = RelationType.LESSTHANOREQUAL;
}
else if (op.HasNotEquals())
{
((RelationalNode)node).m_RelationType = RelationType.NOTEQUAL;
}
node.AddChild(CreateArithmeticNode(exp.GetRelational().GetLHSArithmeticExpression()));
node.AddChild(CreateArithmeticNode(exp.GetRelational().GetRHSArithmeticExpression()));
}
else if (exp.HasLogical())
{
node = new LogicalNode(m_Container);
if (exp.GetLogical().GetLogicalOperator().HasAnd())
{
((LogicalNode)node).m_LogicalType = LogicalOperatorType.AND;
}
else
{
((LogicalNode)node).m_LogicalType = LogicalOperatorType.OR;
}
node.AddChild(CreateLogicalNode(exp.GetLogical().GetLHSLogicalExpression()));
node.AddChild(CreateLogicalNode(exp.GetLogical().GetRHSLogicalExpression()));
}
else if (exp.HasValue())
{
if (exp.GetValue().HasConstant())
{
node = new ConstantNode(m_Container);
((ConstantNode)node).m_ConstantValue = exp.GetValue().GetConstant().GetBoolean().Value;
((ConstantNode)node).m_ConstantType = VariableType.BOOLEAN;
}
else
{
node = new VariableNode(m_Container);
((VariableNode)node).m_VariableName = exp.GetValue().GetVariable().GetName().Value;
((VariableNode)node).m_VariableType = VariableType.BOOLEAN;
}
}
return(node);
}
public NodeEdge (NodeBase from, NodeBase to)
{
m_FromNode = from;
m_ToNode = to;
m_ConnectWidth = m_FromNode.m_Children.IndexOf(m_ToNode);
}
LogicalExpression CreateLogical(NodeBase node)
{
LogicalExpression expression = null;
switch (node.m_NodeType)
{
case NodeType.RELATIONAL:
expression = CreateRelationalExpression(node);
break;
case NodeType.LOGICAL:
expression = CreateLogicalExpression(node);
break;
case NodeType.CONSTANT:
{
Value value = m_RuleMaker.MakeConstant(((ConstantNode)node).m_ConstantType, ((ConstantNode)node).m_ConstantValue);
expression = m_RuleMaker.MakeLogical(value);
}
break;
case NodeType.VARIABLE:
{
Value value = m_RuleMaker.MakeVariable(((VariableNode)node).m_VariableName, ((VariableNode)node).m_VariableType);
expression = m_RuleMaker.MakeLogical(value);
}
break;
}
return expression;
}
public abstract bool CheckChild (NodeBase child);
