protected MetaDataTreeNode(string data, Type type) { this.data = data; this.type = type; parent = null; }
public MetaDataTreeNode intersection(MetaDataTreeNode tree) { MetaDataTreeNode result = null; if (this.Equals(tree)) { result = MetaDataTreeNodeFactory.copy(tree); foreach (MetaDataTreeNode a in Child) { foreach (MetaDataTreeNode b in tree.Child) { MetaDataTreeNode intersection = a.intersection(b); if (intersection != null) { intersection.Parent = result; result.insertChild(intersection); break; } } } } return(result); }
public override bool hasChild(MetaDataTreeNode node) { foreach (MetaDataTreeNode c in child) { return(c.Equals(node)); } return(false); }
/// <summary> /// Check if this node contains the child node at this level (non-recursive) /// </summary> /// <param name="node"></param> /// <returns></returns> public virtual bool hasChild(MetaDataTreeNode node) { foreach (MetaDataTreeNode c in Child) { if (c.Equals(node)) { return(true); } } return(false); }
public virtual int getChildIndex(MetaDataTreeNode node) { for (int i = 0; i < Count; i++) { if (node == child[i]) { return(i); } } return(-1); }
public override bool hasChild(MetaDataTreeNode node) { MetaDataTreeNode found = child[node.Data]; if (found == null) { return(false); } else { return(found.Equals(node)); } }
public static MetaDataTreeNode copy(MetaDataTreeNode node) { switch (node.NodeType) { case MetaDataTreeNode.Type.ARRAY: { return (new MetaDataTreeArray(node.Data)); } case MetaDataTreeNode.Type.NAMESPACE: { return (new MetaDataTreeNameSpaceNode(node.Data)); } case MetaDataTreeNode.Type.STRUCT: { return (new MetaDataTreeStructNode(node.Data)); } case MetaDataTreeNode.Type.PROPERTY: { return (new MetaDataTreeProperty(node.Data)); } case MetaDataTreeNode.Type.VALUE: { return (new MetaDataTreeValue(node.Data)); } case MetaDataTreeNode.Type.LANGUAGE: { return (new MetaDataTreeLanguage(node.Data)); } default: { Debug.Assert(false); break; } } return (null); }
/// <summary> /// Check if this node contains the child node at this level (non-recursive) /// </summary> /// <param name="node"></param> /// <returns></returns> public virtual bool hasChild(MetaDataTreeNode node) { foreach (MetaDataTreeNode c in Child) { if (c.Equals(node)) { return (true); } } return (false); }
public MetaDataTreeModel(List<MetaDataTreeNode> metaData) { if (metaData.Count == 0) { root = null; return; } root = metaData[0]; for (int i = 1; i < metaData.Count; i++) { if (root == null) break; root = root.intersection(metaData[i]); } }
public virtual void insertChild(string indexStr, MetaDataTreeNode node) { int index = nameToIndex(indexStr); if (index < Count) { child[index] = node; } else if (index == Count) { child.Add(node); } else if (index > Count) { Debug.Assert(false); } }
public static MetaDataTreeNode create(string data, MetaDataTreeNode.Type type) { switch (type) { case MetaDataTreeNode.Type.ARRAY: { return (new MetaDataTreeArray(data)); } case MetaDataTreeNode.Type.NAMESPACE: { return (new MetaDataTreeNameSpaceNode(data)); } case MetaDataTreeNode.Type.STRUCT: { return (new MetaDataTreeStructNode(data)); } case MetaDataTreeNode.Type.PROPERTY: { return (new MetaDataTreeProperty(data)); } case MetaDataTreeNode.Type.VALUE: { return (new MetaDataTreeValue(data)); } default: { Debug.Assert(false); break; } } return (null); }
public static MetaDataTreeNode copy(MetaDataTreeNode node) { switch (node.NodeType) { case MetaDataTreeNode.Type.ARRAY: { return(new MetaDataTreeArray(node.Data)); } case MetaDataTreeNode.Type.NAMESPACE: { return(new MetaDataTreeNameSpaceNode(node.Data)); } case MetaDataTreeNode.Type.STRUCT: { return(new MetaDataTreeStructNode(node.Data)); } case MetaDataTreeNode.Type.PROPERTY: { return(new MetaDataTreeProperty(node.Data)); } case MetaDataTreeNode.Type.VALUE: { return(new MetaDataTreeValue(node.Data)); } case MetaDataTreeNode.Type.LANGUAGE: { return(new MetaDataTreeLanguage(node.Data)); } default: { Debug.Assert(false); break; } } return(null); }
public virtual MetaDataTreeNode getNode(string path) { string head = ""; string tail = ""; for (int i = 0; i < path.Length; i++) { if (path[i] == '[' || path[i] == ':' || path[i] == '/') { if (i != 0) { tail = path.Substring(i); break; } else if (path[i] == '[') { head += path[i]; } } else { head += path[i]; } } MetaDataTreeNode node = getChild(head); if (node == null) { return(null); } else { if (string.IsNullOrEmpty(tail)) { return(node); } else { return(node = node.getNode(tail)); } } }
public override bool Equals(System.Object obj) { if (!(obj is MetaDataTreeNode)) { return(false); } MetaDataTreeNode node = (MetaDataTreeNode)(obj); if (node.NodeType != NodeType) { return(false); } if (node.Data.Equals(Data)) { return(true); } return(false); }
public override bool hasChild(MetaDataTreeNode node) { MetaDataTreeNode found = child[node.Data]; if (found == null) return (false); else return (found.Equals(node)); }
public override void insertChild(MetaDataTreeNode node) { child.Add(node); }
public virtual int getChildIndex(MetaDataTreeNode node) { for (int i = 0; i < Count; i++) { if (node == child[i]) return (i); } return (-1); }
public override void insertChild(MetaDataTreeNode node) { child[node.Data] = node; }
protected MetaDataTreeArray(string data, MetaDataTreeNode.Type type) : base(data, type) { child = new List<MetaDataTreeNode>(); }
public void insertNode(string name, string value) { string head = ""; string tail = ""; MetaDataTreeNode.Type type = MetaDataTreeNode.Type.ARRAY; for (int i = 0; i < name.Length; i++) { if (name[i] == '[' || name[i] == ':' || name[i] == '/') { if (i != 0) { tail = name.Substring(i); if (name[i] == '[') { type = MetaDataTreeNode.Type.ARRAY; } else if (name[i] == ':') { type = MetaDataTreeNode.Type.NAMESPACE; } else if (name[i] == '/') { type = MetaDataTreeNode.Type.STRUCT; } break; } else if (name[i] == '[') { head += name[i]; } } else { head += name[i]; } } MetaDataTreeNode node = getChild(head); if (node == null) { if (string.IsNullOrEmpty(tail)) { node = new MetaDataTreeValue(value); if (this.NodeType == Type.ARRAY) { node.parent = this; insertChild(node); } else { MetaDataTreeProperty prop = new MetaDataTreeProperty(head); prop.parent = this; node.parent = prop; prop.insertChild(node); insertChild(prop); } } else { if (this.NodeType == Type.ARRAY) { node = MetaDataTreeNodeFactory.create("", type); } else { node = MetaDataTreeNodeFactory.create(head, type); } node.parent = this; insertChild(node); node.insertNode(tail, value); } } else { if (string.IsNullOrEmpty(tail)) { if (node.type == Type.VALUE) { node.Data = value; } else { MetaDataTreeProperty prop = (MetaDataTreeProperty)(node); prop.Value = value; } } else { if (node.type == type) { node.insertNode(tail, value); } else { MetaDataTreeLanguage lang = new MetaDataTreeLanguage(value); MetaDataTreeArray arr = (MetaDataTreeArray)(node); arr.insertChild("[1]", lang); } } } }
public override bool hasChild(MetaDataTreeNode node) { foreach (MetaDataTreeNode c in child) { return (c.Equals(node)); } return (false); }
public MetaDataTreeNode intersection(MetaDataTreeNode tree) { MetaDataTreeNode result = null; if (this.Equals(tree)) { result = MetaDataTreeNodeFactory.copy(tree); foreach (MetaDataTreeNode a in Child) { foreach (MetaDataTreeNode b in tree.Child) { MetaDataTreeNode intersection = a.intersection(b); if (intersection != null) { intersection.Parent = result; result.insertChild(intersection); break; } } } } return (result); }
public abstract void insertChild(MetaDataTreeNode node);
public virtual bool hasNode(string path) { MetaDataTreeNode node = getNode(path); return(node == null ? false : true); }
List<MetaDataNameValue> nodeChildrenToPathValue(MetaDataTreeNode node) { List<MetaDataNameValue> items = new List<MetaDataNameValue>(); foreach(MetaDataTreeNode n in node.Child) { MetaDataNameValue item = new MetaDataNameValue(); item.Name = n.ToString(); item.Node = n; item.IconPath = "pack://application:,,,/Resources/Icons/prop.ico"; if (n.NodeType == MetaDataTreeNode.Type.NAMESPACE) { item.IconPath = "pack://application:,,,/Resources/Icons/namespace.ico"; item.NodeType = "Namespace"; } else if (n.NodeType == MetaDataTreeNode.Type.ARRAY) { item.IconPath = "pack://application:,,,/Resources/Icons/array.ico"; item.NodeType = "Array"; } else if (n.NodeType == MetaDataTreeNode.Type.PROPERTY) { MetaDataTreeProperty prop = (MetaDataTreeProperty)n; if (String.IsNullOrEmpty(prop.Value)) continue; item.Name = FormatMetaData.formatPropertyName(prop.ToString()); item.Value = FormatMetaData.formatPropertyValue(prop.Path, prop.Value); item.NodeType = "Property"; } else if (n.NodeType == MetaDataTreeNode.Type.VALUE) { if (n.Parent.NodeType == MetaDataTreeNode.Type.PROPERTY) continue; item.Name = ""; item.Value = FormatMetaData.formatPropertyValue(n.Path, n.Data); item.IconPath = "pack://application:,,,/Resources/Icons/constprop.ico"; item.NodeType = "Value"; } else if (n.NodeType == MetaDataTreeNode.Type.LANGUAGE) { item.Name = "Language"; item.Value = n.ToString(); item.NodeType = "Language"; item.IconPath = "pack://application:,,,/Resources/Icons/language.ico"; } if(n.Parent != null && n.Parent.NodeType == MetaDataTreeNode.Type.ARRAY) { MetaDataTreeArray arr = (MetaDataTreeArray)(n.Parent); item.Value = FormatMetaData.formatPropertyValue(n.Path, n.Data); item.IconPath = "pack://application:,,,/Resources/Icons/constprop.ico"; item.NodeType = "Value"; int i = arr.getChildIndex(n); item.Name = "[" + Convert.ToString(i) + "] " + item.Name; } items.Add(item); } return(items); }
protected MetaDataTreeDictionaryNode(string data, MetaDataTreeNode.Type type) : base(data, type) { child = new Dictionary<string, MetaDataTreeNode>(); }