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);
}
protected MetaDataTreeNode(string data, Type type)
{
this.data = data;
this.type = type;
parent = null;
}
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 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 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 override void insertChild(MetaDataTreeNode node)
{
child.Add(node);
}
public abstract void insertChild(MetaDataTreeNode node);
public abstract void insertChild(MetaDataTreeNode node);
public override void insertChild(MetaDataTreeNode node)
{
child[node.Data] = 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>();
}
