public static List<CoalescedTreeNode> CreateRootTree(out CoalescedTreeNode root) { root = new CoalescedTreeNode(AlwaysTrueCondition.Instance); List<CoalescedTreeNode> list = new List<CoalescedTreeNode>(); list.Add(root); return list; }
protected override void MergeToCoalescedTreeNode(CoalescedTreeNode parent, List<CoalescedTreeNode> children) { List<Condition> conditions = new List<Condition>(_conditions); CoalescedTreeNode localParent = parent; while(conditions.Count > 0) { bool found = false; foreach(CoalescedTreeNode child in localParent.ConditionAxis) { if(conditions.Contains(child.Condition)) { conditions.Remove(child.Condition); localParent = child; found = true; } } if(!found) { CoalescedTreeNode node = new CoalescedTreeNode(conditions[conditions.Count - 1]); conditions.RemoveAt(conditions.Count - 1); localParent.ConditionAxis.Add(node); localParent = node; } } children.Add(localParent); }
protected override void MergeToCoalescedTreeNode(CoalescedTreeNode parent, List <CoalescedTreeNode> children) { List <Condition> conditions = new List <Condition>(_conditions); CoalescedTreeNode localParent = parent; while (conditions.Count > 0) { bool found = false; foreach (CoalescedTreeNode child in localParent.ConditionAxis) { if (conditions.Contains(child.Condition)) { conditions.Remove(child.Condition); localParent = child; found = true; } } if (!found) { CoalescedTreeNode node = new CoalescedTreeNode(conditions[conditions.Count - 1]); conditions.RemoveAt(conditions.Count - 1); localParent.ConditionAxis.Add(node); localParent = node; } } children.Add(localParent); }
public List <CoalescedTreeNode> MergeToCoalescedTree() { List <CoalescedTreeNode> res = new List <CoalescedTreeNode>(); CoalescedTreeNode sentinel = new CoalescedTreeNode(AlwaysTrueCondition.Instance); MergeToCoalescedTreeNode(sentinel, res); return(res); }
public static List <CoalescedTreeNode> CreateRootTree(out CoalescedTreeNode root) { root = new CoalescedTreeNode(AlwaysTrueCondition.Instance); List <CoalescedTreeNode> list = new List <CoalescedTreeNode>(); list.Add(root); return(list); }
protected virtual void MergeToCoalescedTreeNode(CoalescedTreeNode parent, List <CoalescedTreeNode> children) { CoalescedTreeNode child; if (!TryGetExistingNode(parent, this, out child)) { child = new CoalescedTreeNode(this); parent.ConditionAxis.Add(child); } children.Add(child); }
protected bool TryGetExistingNode(CoalescedTreeNode parent, Condition condition, out CoalescedTreeNode node) { foreach (CoalescedTreeNode child in parent.ConditionAxis) { if (Equals(child.Condition)) { node = child; return(true); } } node = null; return(false); }
public bool CouldMergeToCoalescedTree(CoalescedTreeNode node) { if (node == null) { throw new ArgumentNullException("node"); } if (node.Condition.Equals(AlwaysTrueCondition.Instance)) { return(true); } return(CouldMergeToCoalescedTreeNode(node.Condition)); }
protected override void MergeToCoalescedTreeNode(CoalescedTreeNode parent, List <CoalescedTreeNode> children) { foreach (Condition condition in _conditions) { CoalescedTreeNode child; if (!TryGetExistingNode(parent, condition, out child)) { child = new CoalescedTreeNode(condition); parent.ConditionAxis.Add(child); } children.Add(child); } }
protected override void MergeToCoalescedTreeNode(CoalescedTreeNode parent, List <CoalescedTreeNode> children) { children.Add(parent); }
public override void MergeToCoalescedTree(MathIdentifier patternId, List <CoalescedTreeNode> parents) { if (_children.Count == 0) { base.MergeToCoalescedTree(patternId, parents); } else { // Merge Conditions & Groups -> "node"-List List <CoalescedTreeNode> nodes = Condition.MergeToCoalescedTree(parents); MergeGroupToCoalescedTree(patternId, nodes); // children: find matching pattern or create one AlwaysTrueCondition atc = AlwaysTrueCondition.Instance; foreach (CoalescedTreeNode node in nodes) { // check all patterns the current node already has List <CoalescedChildPattern> nodePatterns = node.PatternAxis; bool nodeMatch = false; foreach (CoalescedChildPattern pattern in nodePatterns) { // check all nodes of the current pattern whether they match. List <CoalescedTreeNode> patternChildren = pattern.ChildrenAxis; if (patternChildren.Count != _children.Count) { continue; } bool patternMatch = true; for (int i = 0; i < _children.Count; i++) { if (!_children[i].Condition.CouldMergeToCoalescedTree(patternChildren[i])) { patternMatch = false; break; } } if (patternMatch) { // we found a matching pattern. merge our tree pattern to this pattern. nodeMatch = true; for (int i = 0; i < _children.Count; i++) { List <CoalescedTreeNode> list = new List <CoalescedTreeNode>(); list.Add(patternChildren[i]); _children[i].MergeToCoalescedTree(patternId, list); } } } if (!nodeMatch) { // we didn't find a matching pattern. build a new such pattern. CoalescedChildPattern pattern = new CoalescedChildPattern(); for (int i = 0; i < _children.Count; i++) { CoalescedTreeNode parent = new CoalescedTreeNode(AlwaysTrueCondition.Instance); pattern.AddChild(parent); List <CoalescedTreeNode> list = new List <CoalescedTreeNode>(); list.Add(parent); _children[i].MergeToCoalescedTree(patternId, list); } node.PatternAxis.Add(pattern); } } } }
public void AddChild(CoalescedTreeNode node) { _childAxis.Add(node); }
protected override void MergeToCoalescedTreeNode(CoalescedTreeNode parent, List<CoalescedTreeNode> children) { children.Add(parent); }