public AbstractLattice(XmlNode modelXml)
{
if (modelXml != null)
{
_root = new AbstractTreeLatticeNode(modelXml.Name,AbstractTreeNodeType.Element);
XmlNode x = modelXml.SelectSingleNode("text()");
if (x != null)
{
if (!String.IsNullOrEmpty(x.InnerText))
{
_root.addValue(x.InnerText);
}
}
foreach (XmlAttribute at in modelXml.Attributes)//read attributes
{
AbstractTreeLatticeNode attnode = _root.addChild(at.Name, AbstractTreeNodeType.Attribute, -1);
attnode.Values.Add(at.Value);
}
foreach (XmlNode xn in modelXml.ChildNodes)
if (xn.NodeType != XmlNodeType.Text)
processXmlNodes(xn);
prepare();
}
}
public AbstractTreeLatticeNode(String nodeName, AbstractTreeLatticeNode nodeParent, AbstractTreeNodeType type, int ruleInd)
{
Name = nodeName;
parent = nodeParent;
ruleIndex = ruleInd;
isMatched = false;
Type = type;
_valueType = null;//set it to null till values are added
}
/// <summary>
/// Check all node types against each other
/// </summary>
/// <param name="s">Source Abstract tree lattice node</param>
/// <param name="t">Target abstract tree lattice node</param>
/// <returns></returns>
private double checkTypes(AbstractTreeLatticeNode s, AbstractTreeLatticeNode t)
{
if (string.IsNullOrEmpty(s.ValueType) || string.IsNullOrEmpty(t.ValueType))
return 0;
if (s.ValueType.Equals(t.ValueType))
return 1;
return 0;
}
/// <summary>
/// Check all node values against each other
/// </summary>
/// <param name="s">Source Abstract tree lattice node</param>
/// <param name="t">Target abstract tree lattice node</param>
/// <returns></returns>
private double checkNames(AbstractTreeLatticeNode s, AbstractTreeLatticeNode t)
{
int heu = 0;
if (s.Name.Equals(t.Name))
heu++;
//heu = 1;
if (s.Name.ToLower().Contains(t.Name.ToLower()))
heu++;
//heu = 1;
if (t.Name.ToLower().Contains(s.Name.ToLower()))
heu++;
//heu = 1;
return heu;
}
public AbstractLattice(AbstractTreeLatticeNode node)
{
if (node != null)
{
_root = node.duplicate();
/*_root = new AbstractTreeLatticeNode(node.Name);
foreach (string s in node.Values)
_root.Values.Add(s);
foreach (AbstractTreeLatticeNode n in node.Children)
_root.Children.Add(n.duplicate());
*/
prepare();
}
else
MessageBox.Show("Initiation failed, Node is Null");
}
private double checkNames(AbstractTreeLatticeNode s, AbstractTreeLatticeNode t)
{
//return computeLevenshteinDistance(s.Name.ToLower(), t.Name.ToLower());
int heu = 0;
if (s.Name.Equals(t.Name))
heu++;
//heu = 1;
if (s.Name.ToLower().Contains(t.Name.ToLower()))
heu++;
//heu = 1;
if (t.Name.ToLower().Contains(s.Name.ToLower()))
heu++;
//heu = 1;
return heu;
}
public AbstractTreeLatticeNode(string nodeName, AbstractTreeLatticeNode nodeParent, AbstractTreeNodeType type)
: this(nodeName, nodeParent, type, -1)
{
}
internal AbstractTreeLatticeNode find(AbstractTreeLatticeNode toFind)
{
if (this.Name.Equals(toFind.Name) && this.Address.Equals(toFind.Address) && this.Type == toFind.Type)
return this;
else
foreach (AbstractTreeLatticeNode c in Children)
{
AbstractTreeLatticeNode yes = c.find(toFind);
if (yes != null)
return yes;
}
return null;
}
/// <summary>
/// Duplicate node, keep node names and children names, No values, No rule indexes and all isMatched are false
/// </summary>
/// <returns></returns>
public AbstractTreeLatticeNode duplicate()
{
AbstractTreeLatticeNode newNode = new AbstractTreeLatticeNode(this.Name, this.Type);
foreach (string s in this.Values)
newNode.Values.Add(s);
foreach (AbstractTreeLatticeNode child in this.Children)
newNode.Children.Add(child.duplicate());
return newNode;
}
public AbstractTreeLatticeNode addChild(string s, AbstractTreeNodeType t, int rIndex)
{
bool check = false;
foreach (AbstractTreeLatticeNode c in _children)
if (c.Name.Equals(s) && c.Type == t)
{
check = true;
break;
}
if (!check)
{
AbstractTreeLatticeNode a = new AbstractTreeLatticeNode(s, this, t, rIndex);
_children.Add(a);
return a;
}
else
return null;
}
public void processVisual_TreeNodeDrop(TreeNodeViewModel treeN, String FullAddress)
{
//set header for template XSLT
templateVM.HeaderNode = treeN; // I do not think these will be used, they have been used in visualiser to check and set visualfunction abstraction
//set address Id for template XSLT
templateVM.TemplateAddress = FullAddress; // I do not think these will be used
AbstractTreeLatticeNode matchingNode = (ParentWindow as Visualiser).sourceASTL.getAbstractNodeAtAddress(FullAddress);
//define correspondence
if (matchingNode != null)//if you have found the node
{
if (matchingNode.ruleIndex == -1)
{
sourceLatticeNodeToMatch = matchingNode;
}
else if (matchingNode.parent != null)
{
//create a duplicate****************************** duplicate not implemented yet
sourceLatticeNodeToMatch = matchingNode.duplicate();
matchingNode.parent.Children.Add(sourceLatticeNodeToMatch);
}
sourceLatticeNodeToMatch.isMatched = true;
sourceLatticeNodeToMatch.ruleIndex = RULEINDEX;//assign an index for current rule
//assign same rule index for this.abstractTree
this.abstractTree.Root.ruleIndex = sourceLatticeNodeToMatch.ruleIndex;
this.abstractTree.Root.isMatched = true;
//increment index for other correspondences
RULEINDEX++;
//go for reverse, the top part will be obsolete
//this.abstractTreeReverse = new AbstractLattice(matchingNode);//might not need abstract tree for reverse, as one way suggestion will eb shown
this.ReverseData = matchingNode.ToXML();// treeNode.ToXML();//matchingNode might have worked as well but the signature problems might get in the way
this.templateVMR.TemplateName = this.Data.Name;
}
//suggester initiation
AbstractLattice sourceAST = new AbstractLattice(matchingNode);
this.abstractTree.prepare();
SuggesterConfig config = new SuggesterConfig();
config.UseNameSimSuggester = true;
config.UseTypeSimSuggester = true;
config.UseIsoRankSimSuggester = true;
config.UseValueSimSuggester = true;
config.UseStructSimSuggester = true;
(ParentWindow as Visualiser).visualiserSuggester = new Suggester(sourceAST, this.abstractTree, config);
(ParentWindow as Visualiser).updateSuggestions((ParentWindow as Visualiser).visualiserSuggester.getSuggestionsAsStrings((ParentWindow as Visualiser).visualiserSuggester.imFeelingLucky()));
//log event
(ParentWindow as Visualiser).logger.log("\"" + FullAddress + "\" was dropped on \"" + this.VEName + "\"", ReportIcon.OK);
(ParentWindow as Visualiser).ReportStatusBar.ShowStatus("Mapping " + treeN.Name + " to " + this.Data.Name, ReportIcon.Info);
}
/// <summary>
/// Check all node values against each other
/// </summary>
/// <param name="s">Source Abstract tree lattice node</param>
/// <param name="t">Target abstract tree lattice node</param>
/// <returns></returns>
private double checkValues(AbstractTreeLatticeNode s, AbstractTreeLatticeNode t)
{
double heuTotal = 0;
int count = 0;//for normalisation
foreach (String sv in s.Values)
foreach (String tv in t.Values)
{
int heu = 0;
if (sv.Equals(tv))
heu++;
//heu = 1;
if (sv.ToLower().Contains(tv.ToLower()))
heu++;
//heu = 1;
if (tv.ToLower().Contains(sv.ToLower()))
heu++;
//heu = 1;
if (heu > 0)
{
count++;
heuTotal += heu; // / 3; //do not do local normalisation
}
}
if (count > 0)
return heuTotal / count;//normalise the values
else
return 0;
}
public void addConcept(string[] val, int ruleIndex)
{
AbstractTreeLatticeNode temp = null;
AbstractTreeLatticeNode temp2 = null;
int i = 0;
temp = searchNodeInTree(val[i]);
temp2 = temp;
i++;
while (i < val.Length & temp != null)//find first node in tree
{
temp2 = temp;
temp = temp.searchNode(val[i]);
i++;
}
if (temp != null)
temp2 = temp;
if (temp2 == null) //could not find a match from start
{
if (_root != null)
MessageBox.Show("Error in assigning rules to root");
else //first branch to be added
{
if (val[0].StartsWith("@"))//this will not happen
_root = new AbstractTreeLatticeNode(val[0].Replace("@",""), AbstractTreeNodeType.Attribute);
else
_root = new AbstractTreeLatticeNode(val[0], AbstractTreeNodeType.Element);
string[] val2 = new string[val.Length - 1];
for (int j = 1; j < val.Length; j++)//shift values
val2[j - 1] = val[j];
_root.addChild(val2, ruleIndex);
}
}
else //partial matches exist
{
if (temp != null) //exact match
{
//temp2.Name = ruleIndex.ToString(); //update rule value of the match
//MessageBox.Show("repeated pattern");
temp.ruleIndex = ruleIndex;//30/8/2011
}
else
{
String[] newVal = new String[val.Length - (i - 1)];
for (int k = 0; k < newVal.Length; k++)
newVal[k] = val[k + (i - 1)];
temp2.addChild(newVal, ruleIndex);
}
}
}
public string findRelativeAddress(AbstractTreeLatticeNode top, AbstractTreeLatticeNode low)
{
//check for types of low and top
if (top.findInChildrenByName(low.Name) != null)
{
string lowAddress = low.Address;
string diff = lowAddress.Substring(lowAddress.IndexOf(top.Address) + 1 + top.Address.Length);//diff includes low.Name
//MessageBox.Show("top:" + top.Address +"\nlow: "+low.Address+ "\nrelative address: "+diff);
return diff;
}
else
{
MessageBox.Show("Element: " + low.Name + " is not child of: " + top.Name, "Error", MessageBoxButton.OK, MessageBoxImage.Error);
return null;
}
}
private void createGraphFromAbstractTreeNode(BidirectionalGraph<AbstractTreeLatticeNode, Edge<AbstractTreeLatticeNode>> g, AbstractTreeLatticeNode n)
{
//create the vertex
g.AddVertex(n);
//Call for childs
if (n.Children.Count > 0)
{
//create childs and edges
foreach (AbstractTreeLatticeNode tNode in n.Children)
{
createGraphFromAbstractTreeNode(g, tNode);
Edge<AbstractTreeLatticeNode> edge = new Edge<AbstractTreeLatticeNode>(n, tNode);
g.AddEdge(edge);
}
}
}
/// <summary>
/// Reads XML node and creates a tree lattice based on it.
/// </summary>
/// <param name="modelFile"></param>
public void processXmlData(XmlNode x1)
{
//detach x1 from its parent
XmlNode xnode = x1.Clone();
_root = new AbstractTreeLatticeNode(xnode.Name,AbstractTreeNodeType.Element);
//MessageBox.Show(Root.Name);
XmlNode x = xnode.SelectSingleNode("text()");
if (x != null)
{
if (!String.IsNullOrEmpty(x.InnerText))
{
_root.addValue(x.InnerText);
}
}
foreach (XmlAttribute at in xnode.Attributes)//read attributes
{
AbstractTreeLatticeNode attnode = _root.addChild(at.Name, AbstractTreeNodeType.Attribute, -1);
attnode.Values.Add(at.Value);
}
foreach (XmlNode xn in xnode.ChildNodes)
if (xn.NodeType != XmlNodeType.Text)
processXmlNodes(xn);
}
/// <summary>
/// Reads XML model example file and creates a tree lattice based on it.
/// </summary>
/// <param name="modelFile"></param>
public void processModelFile(String modelFile)
{
//Test = new Collection<AbstractTreeLatticeNode>();
XmlDocument xdoc = new XmlDocument();
xdoc.Load(modelFile);
_root = new AbstractTreeLatticeNode(xdoc.DocumentElement.Name,AbstractTreeNodeType.Element);
//MessageBox.Show(Root.Name);
XmlNode x = xdoc.DocumentElement.SelectSingleNode("text()");
if (x != null)
{
if (!String.IsNullOrEmpty(x.InnerText))
{
_root.addValue(x.InnerText);
}
}
foreach (XmlAttribute at in xdoc.DocumentElement.Attributes)//read attributes
{
AbstractTreeLatticeNode attnode = _root.addChild(at.Name, AbstractTreeNodeType.Attribute, -1);
attnode.Values.Add(at.Value);
}
foreach (XmlNode xn in xdoc.DocumentElement.ChildNodes)
if (xn.NodeType != XmlNodeType.Text)
processXmlNodes(xn);
//MessageBox.Show("lattice should now be complete\n\n"+ Root.printTreeNode());
//Test.Add(_root);
}
public AbstractLattice()
{
_root = null;
}
