private List <double[]> extractEdgeInfos(String transitionLabel, String[][] edgeInfoTemplates)
{
List <double[]> edgeInfos = new List <double[]>(1);
transitionLabel = transitionLabel.Trim(new char[] { '[', ']' }); // for hidden events
String[] labels = transitionLabel.Split('.');
Int32 index = mapTranslabelIndex.get(labels[0]);
if (0 == index)
{
index = transitionLabelIndex++;
mapTranslabelIndex.put(labels[0], index);
}
edgeInfos.Add(new double[] { index });
double[] values = new double[labels.Length - 1];
for (int i = 1; i < labels.Length; i++)
{
values[i - 1] = double.Parse(labels[i]);
}
edgeInfos.Add(values);
return(edgeInfos);
}
public void parse(List <object[]> nodesData, List <string[]> edgesData, List <List <double[]> > nodesInfo, List <List <double[]> > edgesInfo, DictionaryJ <string, GraphDataConfiguration> graphDataConfigs)
{
try
{
DictionaryJ <String, object[]> nodesMap = new DictionaryJ <String, object[]>();
foreach (Edge edge in Graph.Edges)
{
String sourceNodeId = edge.SourceNode.LabelText;
String targetNodeId = edge.TargetNode.LabelText;
object[] sourceNodeData; // length=4 [1:type, 2:id, 3;label, 4:additionalinfo]
if (!string.IsNullOrEmpty(edge.LabelText) && !nodesMap.ContainsKey(sourceNodeId))
{
EventStepSim userData = edge.SourceNode.UserData as EventStepSim;
sourceNodeData = new object[4];
sourceNodeData[0] = "REGULAR";
sourceNodeData[1] = sourceNodeId;
sourceNodeData[2] = String.Format("[{0}] {1}", sourceNodeId, userData.ToString());
PAT.GenericDiff.graph.Graph configGraph = configGraphBuilder.execute(this.side, userData.Config, sourceNodeId);
sourceNodeData[3] = configGraph;
nodesData.Add(sourceNodeData);
nodesInfo.Add(extractNodeInfos(userData.Config.GlobalEnv, configGraph, graphDataConfigs["REGULAR"].elementInfoTemplates));
nodesMap.put(sourceNodeId, sourceNodeData);
}
object[] targetNodeData; // length=4 [1:type, 2:id, 3;label, 4:additionalinfo]
if (!nodesMap.ContainsKey(targetNodeId))
{
EventStepSim userData = edge.TargetNode.UserData as EventStepSim;
targetNodeData = new object[4];
targetNodeData[0] = !string.IsNullOrEmpty(edge.LabelText) ? "REGULAR" : "INIT";
targetNodeData[1] = targetNodeId;
targetNodeData[2] = String.Format("[{0}] {1}", targetNodeId, userData.ToString());
PAT.GenericDiff.graph.Graph configGraph = configGraphBuilder.execute(this.side, userData.Config, targetNodeId);
targetNodeData[3] = configGraph;
nodesData.Add(targetNodeData);
nodesInfo.Add(extractNodeInfos(userData.Config.GlobalEnv, configGraph, graphDataConfigs[!string.IsNullOrEmpty(edge.LabelText) ? "REGULAR" : "INIT"].elementInfoTemplates));
nodesMap.put(targetNodeId, targetNodeData);
}
if (!string.IsNullOrEmpty(edge.LabelText))
{
String[] edgeData = new String[5];
edgeData[0] = "TRANSITION";
edgeData[1] = edge.LabelText;
edgeData[2] = sourceNodeId;
edgeData[3] = targetNodeId;
edgesData.Add(edgeData);
edgesInfo.Add(extractEdgeInfos(edge.LabelText, graphDataConfigs["TRANSITION"].elementInfoTemplates));
}
}
}
catch (Exception e)
{
//e.printStackTrace();
}
if (!compareConfigGraph)
{
if (compareParameterizedSystem)
{
adjustNodeInfosForParameterizedSystems(nodesInfo, graphDataConfigs);
}
else
{
adjustNodeInfosRegular(nodesInfo, graphDataConfigs);
}
}
}
private List <double[]> extractNodeInfos(Valuation globalVars, PAT.GenericDiff.graph.Graph configGraph, String[][] nodeInfoTemplates)
{
List <double[]> nodeInfos = new List <double[]>(nodeInfoTemplates.Length);
for (int i = 0; i < nodeInfoTemplates.Length; i++)
{
nodeInfos.Add(null);
}
if (globalVars != null)
{
if (globalVars.Variables != null)
{
foreach (StringDictionaryEntryWithKey <ExpressionValue> pair in globalVars.Variables._entries)
{
if (pair != null)
{
string varName = pair.Key;
int i = 0;
int j = 0;
for (; i < nodeInfoTemplates.Length; i++)
{
String[] keys = nodeInfoTemplates[i];
for (j = 0; j < keys.Length; j++)
{
if (keys[j].Equals(varName))
{
break;
}
}
if (j < keys.Length)
{
break;
}
}
if (i < nodeInfoTemplates.Length)
{
double value = Double.NaN;
ExpressionValue varValue = pair.Value;
if (varValue is RecordValue)
{
// todo: xingzc. need to get array length and values in the array
RecordValue array = varValue as RecordValue;
ExpressionValue[] values = array.Associations;
nodeInfos[i] = new double[values.Length];
for (int valueIndex = 0; valueIndex < values.Length; valueIndex++)
{
if (values[valueIndex] is IntConstant)
{
nodeInfos[i][valueIndex] = (values[valueIndex] as IntConstant).Value;
}
else if (values[valueIndex] is BoolConstant)
{
nodeInfos[i][valueIndex] = (values[valueIndex] as BoolConstant).Value ? 1.0 : 0.0;
}
else
{
// todo: xingzc. process other primitive types
}
}
}
else if (false)
{
// todo: xingzc. process other complex data type
}
else
{
if (varValue is IntConstant)
{
value = (varValue as IntConstant).Value;
}
else if (varValue is BoolConstant)
{
value = (varValue as BoolConstant).Value ? 1.0 : 0.0;
}
else
{
// todo: xingzc. process other primitive types
}
if (nodeInfos[i] == null)
{
nodeInfos[i] = new double[nodeInfoTemplates[i].Length];
}
if (!Double.IsNaN(value))
{
nodeInfos[i][j] = value;
}
}
}
}
}
}
}
if (!compareConfigGraph)
{
DictionaryJ <int, int[]> mapLabelindexCount = new DictionaryJ <int, int[]>();
List <String> nodeLabels = configGraph.getNodelabels();
foreach (String nodeLabel in nodeLabels)
{
int index = CSPConfigurationParser.mapLabelIndex.get(nodeLabel);
if (0 != index) // index should not be 0 according to the way to build configGraph
{
int[] count = mapLabelindexCount.get(index);
if (null == count)
{
count = new int[1];
mapLabelindexCount.put(index, count);
}
int[] labelIndexCount = CSPConfigurationParser.mapLabelIndexCount.get(index); // shold never be null
if (labelIndexCount != null)
{
count[0] = count[0] + labelIndexCount[0];
}
else
{
count[0]++;
}
}
}
int infoIndex = 0;
double[] labelindexCount = new double[mapLabelindexCount.Count * 2];
foreach (int labelindex in mapLabelindexCount.Keys)
{
int[] count = mapLabelindexCount.get(labelindex);
if (null != count) // count should not be null
{
labelindexCount[infoIndex] = labelindex;
labelindexCount[infoIndex + 1] = count[0];
}
infoIndex = infoIndex + 2;
}
nodeInfos[nodeInfoTemplates.Length - 1] = labelindexCount;
}
return(nodeInfos);
}
protected Graph createGraph(Side side, Parser parser, DictionaryJ <String, GraphDataConfiguration> graphDataConfigs, String graphName)
{
Graph graph = new Graph(graphName);
List <String[]> nodesData = new List <String[]>();
List <String[]> edgesData = new List <String[]>();
List <List <double[]> > nodesInfo = new List <List <double[]> >();
List <List <double[]> > edgesInfo = new List <List <double[]> >();
parser.parse(nodesData, edgesData, nodesInfo, edgesInfo, graphDataConfigs);
if (nodesData.Count != nodesInfo.Count)
{
throw new IncomparableException(nodesData.Count, nodesInfo.Count);
}
if (edgesData.Count != edgesInfo.Count)
{
throw new IncomparableException(edgesData.Count, edgesInfo.Count);
}
DictionaryJ <String, GraphNode> nodes = new DictionaryJ <String, GraphNode>();
for (int nodeIndex = 0; nodeIndex < nodesData.Count; nodeIndex++)
{
String[] nodeData = nodesData[nodeIndex];
String label = nodeData[2] != null ? nodeData[2] : nodeData[1];
GraphNode node;
if (graphCreationParameters.createQualifiedGraphNode)
{
node = new QualifiedGraphNode(label, nodeData[0], side, diffParameters.noPairupIdenticalNodesWithOthers);
}
else
{
node = new ConcreteGraphNode(label, nodeData[0], side, diffParameters.noPairupIdenticalNodesWithOthers);
}
((AbstractGraphElement)node).setAdditionalInfo(nodeData[3]);
List <double[]> nodeInfos = nodesInfo[nodeIndex];
GraphDataConfiguration nodeConfig = graphDataConfigs.get(nodeData[0]);
if (nodeInfos.Count != nodeConfig.elementInfoTemplates.Length)
{
throw new IncomparableException(nodeInfos.Count, nodeConfig.elementInfoTemplates.Length);
}
if (nodeInfos.Count > 0)
{
InfoDescriptor[] descriptors = new InfoDescriptor[nodeInfos.Count];
for (int infoIndex = 0; infoIndex < nodeInfos.Count; infoIndex++)
{
double[] characteristicVector = nodeInfos[infoIndex];
DistanceCalculatorKind calculatorkind = (DistanceCalculatorKind)Enum.Parse(typeof(DistanceCalculatorKind), nodeConfig.elementInfoCalculatorKind[infoIndex][0]);
if (nodeConfig.elementInfoCalculatorKind[infoIndex][1].Equals("vector")) // VectorBasedLeafInfoDescriptor
{
double[] noneVector = nodeConfig.elementInfoNone[infoIndex];
if (characteristicVector.Length != noneVector.Length)
{
throw new IncomparableException(characteristicVector.Length, noneVector.Length);
}
descriptors[infoIndex] = VectorBasedLeafInfoDescriptor.create(characteristicVector, noneVector, calculatorkind);
}
else if (nodeConfig.elementInfoCalculatorKind[infoIndex][1].Equals("set")) // SetBasedLeafInfoDescriptor
{
descriptors[infoIndex] = new SetBasedLeafInfoDescriptor(characteristicVector, calculatorkind);
}
else
{
descriptors[infoIndex] = null; // should not happen. this column is ignore.
}
}
((ConcreteGraphNode)node).attachInfoDescriptor(new CompositeInfoDescriptor(descriptors));
}
if (graphCreationParameters.encapsulateInMatchedGraphNode)
{
node = new MatchedGraphNode((ConcreteGraphNode)node, diffParameters.noPairupIdenticalNodesWithOthers);
}
nodes.put(nodeData[1], node);
}
List <GraphEdge> edges = new List <GraphEdge>(edgesData.Count);
for (int edgeIndex = 0; edgeIndex < edgesData.Count; edgeIndex++)
{
String[] edgeData = edgesData[edgeIndex];
GraphNode source = nodes.get(edgeData[2]);
GraphNode target = nodes.get(edgeData[3]);
if (source == null || target == null)
{
continue;
}
ConcreteGraphEdge edge = new ConcreteGraphEdge(edgeData[1], edgeData[0], source, target);
edge.setAdditionalInfo(edgeData[4]);
List <double[]> edgeInfos = edgesInfo[edgeIndex];
GraphDataConfiguration edgeConfig = graphDataConfigs.get(edgeData[0]);
if (edgeInfos.Count != edgeConfig.elementInfoTemplates.Length)
{
throw new IncomparableException(edgeInfos.Count, edgeConfig.elementInfoTemplates.Length);
}
if (edgeInfos.Count > 0)
{
InfoDescriptor[] descriptors = new InfoDescriptor[edgeInfos.Count];
for (int infoIndex = 0; infoIndex < edgeInfos.Count; infoIndex++)
{
double[] characteristicVector = edgeInfos[infoIndex];
DistanceCalculatorKind calculatorkind = (DistanceCalculatorKind)Enum.Parse(typeof(DistanceCalculatorKind), edgeConfig.elementInfoCalculatorKind[infoIndex][0]);
if (edgeConfig.elementInfoCalculatorKind[infoIndex][1].Equals("vector")) // VectorBasedLeafInfoDescriptor
{
double[] noneVector = edgeConfig.elementInfoNone[infoIndex];
if (characteristicVector.Length != noneVector.Length)
{
throw new IncomparableException(characteristicVector.Length, noneVector.Length);
}
descriptors[infoIndex] = VectorBasedLeafInfoDescriptor.create(characteristicVector, noneVector, calculatorkind);
}
else if (edgeConfig.elementInfoCalculatorKind[infoIndex][1].Equals("set"))
{ // SetBasedLeafInfoDescriptor
descriptors[infoIndex] = new SetBasedLeafInfoDescriptor(characteristicVector, calculatorkind);
}
else // should not happen. this InfoDescriptor column is ignored
{
descriptors[infoIndex] = null;
}
}
edge.attachInfoDescriptor(new CompositeInfoDescriptor(descriptors));
}
edges.Add(edge);
// TODO Should find a better way
if (graphCreationParameters.createQualifiedGraphNode && graphCreationParameters.containmentRelation.Equals(edgeData[0]))
{
QualifiedGraphNode node;
if (graphCreationParameters.encapsulateInMatchedGraphNode)
{
node = (QualifiedGraphNode)((MatchedGraphNode)target).getNode();
}
else
{
node = (QualifiedGraphNode)target;
}
node.setParent(source);
}
}
//for(Iterator<GraphNode> iter = nodes.values().iterator(); iter.hasNext();) {
foreach (KeyValuePair <string, GraphNode> pair in nodes)
{
graph.addNode(pair.Value);
}
foreach (GraphEdge list in edges)
{
graph.addEdge(list);
}
//for(Iterator<Set<GraphNode>> iter = graph.getNodes().iterator(); iter.hasNext();) {
foreach (HashSet <GraphNode> nodesSet in graph.getNodes())
{
foreach (GraphNode node in nodesSet)
{
if (!node.hasBackwardEdges() && !node.hasForwardEdges())
{
//todo:liuyang
//nodesIter.remove();
}
}
if (nodesSet.Count == 0)
{
//todo:liuyang
//iter.remove();
}
}
return(graph);
}