public static void TestCaseBook()
{
// 1. Create a graph
CGraph mgraph = CGraph.CreateGraph();
CGraphNode u = mgraph.CreateGraphNode <CGraphNode>("u");
CGraphNode v = mgraph.CreateGraphNode <CGraphNode>("v");
CGraphNode w = mgraph.CreateGraphNode <CGraphNode>("w");
CGraphNode x = mgraph.CreateGraphNode <CGraphNode>("x");
CGraphNode y = mgraph.CreateGraphNode <CGraphNode>("y");
CGraphNode z = mgraph.CreateGraphNode <CGraphNode>("z");
mgraph.AddGraphEdge <CGraphEdge, CGraphNode>(u, v, GraphType.GT_DIRECTED);
mgraph.AddGraphEdge <CGraphEdge, CGraphNode>(u, x, GraphType.GT_DIRECTED);
mgraph.AddGraphEdge <CGraphEdge, CGraphNode>(x, v, GraphType.GT_DIRECTED);
mgraph.AddGraphEdge <CGraphEdge, CGraphNode>(v, y, GraphType.GT_DIRECTED);
mgraph.AddGraphEdge <CGraphEdge, CGraphNode>(y, x, GraphType.GT_DIRECTED);
mgraph.AddGraphEdge <CGraphEdge, CGraphNode>(w, y, GraphType.GT_DIRECTED);
mgraph.AddGraphEdge <CGraphEdge, CGraphNode>(w, z, GraphType.GT_DIRECTED);
mgraph.AddGraphEdge <CGraphEdge, CGraphNode>(z, z, GraphType.GT_DIRECTED);
DepthFirstSearch dfs = new DepthFirstSearch(mgraph);
dfs.Run();
DepthFirstSearchQueryInfo info = new DepthFirstSearchQueryInfo(mgraph, dfs);
CIt_GraphNodes it = new CIt_GraphNodes(mgraph);
for (it.Begin(); !it.End(); it.Next())
{
Console.WriteLine("Node {0}: arrival ({1}) - departure ({2})",
it.M_CurrentItem.M_Label, info.Arrival(it.M_CurrentItem), info.Departure(it.M_CurrentItem));
}
}
public CGraphNode CreateGraphNode(List <CGraphNode> nodeSet)
{
// Every original graph node must participate in only one
// condensed graph node
foreach (CGraphNode node in nodeSet)
{
if (m_Mappings.IsOriginalNodeContained(node))
{
throw new Exception("Every original graph node must participate in only one condensed graph node");
}
}
CGraphNode newnode = CreateGraphNode();
m_Mappings.SetDerivedToOriginalNodeMappings(newnode, nodeSet);
//m_condensedNodeMappings[newnode] = nodeSet;
foreach (CGraphNode node in nodeSet)
{
if (m_Mappings.IsOriginalNodeContained(node))
{
m_Mappings.SetOriginalToDerivedNode(node, newnode);
}
else
{
throw new Exception("Node participates in more than 1 condensed nodes");
}
}
return(newnode);
}
public override FA VisitRegexpbasicSet(CASTElement currentNode)
{
CRegexpbasicSet setNode = currentNode as CRegexpbasicSet;
FAGraphQueryInfo FAInfo;
//Create FA
m_NFA = new FA();
FAInfo = new FAGraphQueryInfo(m_NFA, FA.m_FAINFOKEY);
CGraphNode init = m_NFA.CreateGraphNode <CGraphNode>();
CGraphNode final = m_NFA.CreateGraphNode <CGraphNode>();
m_NFA.M_Initial = init;
m_NFA.SetFinalState(final);
m_NFA.M_Alphabet.AddSet(setNode.MSet);
CGraphEdge newEdge = m_NFA.AddGraphEdge <CGraphEdge, CGraphNode>(init, final, GraphType.GT_DIRECTED);
FAInfo.Info(newEdge).M_TransitionCharSet = setNode.MSet;
//4.Pass FA to the predecessor
m_NFA.PrefixGraphElementLabels(m_currentRegularExpression.M_StatementID, GraphElementType.ET_NODE);
m_ReportingServices.ExctractThompsonStep(m_NFA, @"../Debug/BasicSet_" + setNode.MSet.ToString() + ".dot");
m_ReportingServices.AddThompsonStepToReporting(m_NFA);
return(m_NFA);
}
/// <summary>
/// Dijkstra寻路入口
/// </summary>
/// <param name="graph">整张图的数据</param>
/// <param name="start">开始节点id</param>
/// <param name="end">结束节点id</param>
/// <returns></returns>
public bool FindPath(List <CGraphNode> graph, int start, int end)
{
CGraphNode startNode = graph[start];
CGraphNode endNode = graph[end];
return(FindPath(startNode, endNode));
}
protected FAInfo UpdateClosureInformation(FA synth, FA currentFA, CGraph.CMergeGraphOperation mergeOperation)
{
FAInfo closureOperandInfo = synth.GetFAInfo(); // get access to the closure operand FA
FAInfo currentFAInfo = currentFA.GetFAInfo(); // get access to the current FA info
foreach (FALoop faLoop in closureOperandInfo.MLoopsInFa.Values)
{
FALoop newloop = new FALoop();
CGraphNode entry = faLoop.MEntryNode;
newloop.MEntryNode = mergeOperation.GetMirrorNode(entry);
CGraphNode exit = faLoop.MExitNode;
newloop.MExitNode = mergeOperation.GetMirrorNode(exit);
foreach (CGraphNode cGraphNode in faLoop.MParticipatingNodes)
{
newloop.MParticipatingNodes.Add(mergeOperation.GetMirrorNode(cGraphNode));
}
FALoop.ClosureType closureType = faLoop.MClosureType;
Range <int> clsrng = faLoop.MClosureRange;
if (clsrng != null)
{
newloop.MClosureRange = new Range <int>(clsrng);
}
newloop.MClosureType = faLoop.MClosureType;
newloop.MLoopSerial = faLoop.MLoopSerial;
currentFAInfo.AddFALoop(newloop);
}
return(currentFAInfo);
}
public override FA VisitRange(CASTElement currentNode)
{
CRange rangeNode = currentNode as CRange;
FAGraphQueryInfo FAInfo;
//1.Create FA
m_NFA = new FA();
FAInfo = new FAGraphQueryInfo(m_NFA, FA.m_FAINFOKEY);
//2.Create nodes initial-final
CGraphNode init = m_NFA.CreateGraphNode <CGraphNode>();
CGraphNode final = m_NFA.CreateGraphNode <CGraphNode>();
m_NFA.M_Initial = init;
m_NFA.SetFinalState(final);
m_NFA.M_Alphabet.AddRange(rangeNode.MRange);
//3.Draw the edge including the character
CGraphEdge newEdge = m_NFA.AddGraphEdge <CGraphEdge, CGraphNode>(init, final, GraphType.GT_DIRECTED);
FAInfo.Info(newEdge).M_TransitionCharSet = (CCharRangeSet)rangeNode.MRange;
newEdge.SetLabel(rangeNode.MRange.ToString());
m_ReportingServices.ExctractThompsonStep(m_NFA, @"../Debug/Range_" + rangeNode.MRange.ToString() + ".dot");
m_ReportingServices.AddThompsonStepToReporting(m_NFA);
//4.Pass FA to the predecessor
return(m_NFA);
}
internal FA Synthesize(CCharRangeSet set)
{
FAGraphQueryInfo FAInfo;
m_currentFA = new FA();
m_ThompsonInfo = new ThompsonInfo(m_currentFA, m_ThompsonInfoKey);
FAInfo = new FAGraphQueryInfo(m_currentFA, FA.m_FAINFOKEY);
//2.Create nodes initial-final
CGraphNode init = m_currentFA.CreateGraphNode <CGraphNode>();
CGraphNode final = m_currentFA.CreateGraphNode <CGraphNode>();
m_ThompsonInfo.InitNodeInfo(init, new ThompsonNodeFAInfo());
m_ThompsonInfo.InitNodeInfo(final, new ThompsonNodeFAInfo());
m_currentFA.M_Initial = init;
m_currentFA.SetFinalState(final);
m_currentFA.M_Alphabet.AddSet(set);
//3.Draw the edge including the character
CGraphEdge newEdge = m_currentFA.AddGraphEdge <CGraphEdge, CGraphNode>(init, final, GraphType.GT_DIRECTED);
FAInfo.Info(newEdge).M_TransitionCharSet = set;
return(m_currentFA);
}
internal FA SynthesizeOneOrNone(FA synth)
{
FA tempFA = new FA();
//2.Merge graph
CGraph.CMergeGraphOperation merged = tempFA.Merge(synth, CGraph.CMergeGraphOperation.MergeOptions.MO_DEFAULT);
merged.MergeGraphInfo(synth, GraphElementType.ET_EDGE, FA.m_FAINFOKEY);
merged.MergeGraphInfo(synth, GraphElementType.ET_GRAPH, FA.m_FAINFOKEY);
merged.MergeGraphInfo(synth, GraphElementType.ET_NODE, FA.m_FAINFOKEY);
CGraphNode il = tempFA.CreateGraphNode <CGraphNode>();
tempFA.AddGraphEdge <CGraphEdge, CGraphNode>(il, merged.GetMirrorNode(synth.M_Initial), GraphType.GT_DIRECTED);
CGraphNode fl = tempFA.CreateGraphNode <CGraphNode>();
tempFA.AddGraphEdge <CGraphEdge, CGraphNode>(merged.GetMirrorNode(synth.GetFinalStates()[0]), fl, GraphType.GT_DIRECTED);
//4.Create the initial and the final node
tempFA.M_Initial = il;
tempFA.SetFinalState(fl);
tempFA.UpdateAlphabet();
tempFA.AddGraphEdge <CGraphEdge, CGraphNode>(il, fl, GraphType.GT_DIRECTED);
//7.Return result
return(tempFA);
}
internal FA Synthesize(FA l, FA r)
{
FA tempFA = new FA();
//2.Merge left graph
CGraph.CMergeGraphOperation lmerge = tempFA.Merge(l, CGraph.CMergeGraphOperation.MergeOptions.MO_DEFAULT);
lmerge.MergeGraphInfo(l, GraphElementType.ET_EDGE, FA.m_FAINFOKEY);
lmerge.MergeGraphInfo(l, GraphElementType.ET_GRAPH, FA.m_FAINFOKEY);
lmerge.MergeGraphInfo(l, GraphElementType.ET_NODE, FA.m_FAINFOKEY);
CGraphNode il = lmerge.GetMirrorNode(l.M_Initial);
CGraphNode fl = lmerge.GetMirrorNode(l.GetFinalStates()[0]);
//3.Merge right graph
CGraph.CMergeGraphOperation rmerge = tempFA.Merge(r, CGraph.CMergeGraphOperation.MergeOptions.MO_DEFAULT);
rmerge.MergeGraphInfo(r, GraphElementType.ET_EDGE, FA.m_FAINFOKEY);
rmerge.MergeGraphInfo(r, GraphElementType.ET_GRAPH, FA.m_FAINFOKEY);
rmerge.MergeGraphInfo(r, GraphElementType.ET_NODE, FA.m_FAINFOKEY);
CGraphNode ir = rmerge.GetMirrorNode(r.M_Initial);
CGraphNode fr = rmerge.GetMirrorNode(r.GetFinalStates()[0]);
//4.Create the initial and the final node
tempFA.M_Initial = il;
tempFA.SetFinalState(fr);
tempFA.AddGraphEdge <CGraphEdge, CGraphNode>(fl, ir, GraphType.GT_DIRECTED);
//7.Return result
return(tempFA);
}
protected void Relax(CGraphNode source, CGraphNode target)
{
int currentDistance;
if (Distance(source) != null)
{
currentDistance = (int)Distance(source) + Weight(source, target);
if (Distance(target) != null)
{
if (Distance(target) > currentDistance)
{
SetDistance(target, currentDistance);
SetPredecessor(target, source);
}
}
else
{
SetDistance(target, currentDistance);
SetPredecessor(target, source);
}
}
else
{
#if DEBUG
currentDistance = Weight(source, target);
#endif
}
#if DEBUG
Console.WriteLine("Relax: {0} --> {1} CurrentDistance={2}, Distance={3}, Weight={4}",
source.M_Label, target.M_Label, currentDistance, Distance(target), Weight(source, target));
#endif
}
public BreadthFirstSearch(CGraphNode mSource, CGraph mGraph)
{
m_source = mSource;
m_graph = mGraph;
m_BFSData = new BreadthFirstSearchQueryInfo(mGraph, this);
m_Q = new Queue <CGraphNode>();
m_nodeVisitList = new List <CGraphNode>();
}
public BellmanFord(CGraph graph, CGraphNode source, int graphWeightsKey)
{
mGraph = graph;
m_source = source;
this[m_PATHINFO] = m_outputShortestPathsInfo = new BellmanFordQueryInfo(graph, this);
m_inputGraphWeightInfo = new CGraphQueryInfo <object, int, object>(graph, graphWeightsKey);
m_outputShortestPathsInfo.CreateInfo(m_shortestPaths);
}
internal FA Sythesize(FA l, FA r, CGraph.CMergeGraphOperation.MergeOptions options)
{
//1.Create FA
m_currentFA = new FA();
m_ThompsonInfo = new ThompsonInfo(m_currentFA, m_ThompsonInfoKey);
//2.Merge left graph
CGraph.CMergeGraphOperation lmerge = m_currentFA.Merge(l, options);
//Console.WriteLine(l.ToString());
lmerge.MergeGraphInfo(l, GraphElementType.ET_EDGE, FA.m_FAINFOKEY);
lmerge.MergeGraphInfo(l, GraphElementType.ET_GRAPH, FA.m_FAINFOKEY);
lmerge.MergeGraphInfo(l, GraphElementType.ET_NODE, FA.m_FAINFOKEY);
lmerge.MergeGraphInfo(l, GraphElementType.ET_EDGE, m_ThompsonInfoKey);
lmerge.MergeGraphInfo(l, GraphElementType.ET_GRAPH, m_ThompsonInfoKey);
lmerge.MergeGraphInfo(l, GraphElementType.ET_NODE, m_ThompsonInfoKey);
CGraphNode il = lmerge.GetMirrorNode(l.M_Initial);
CGraphNode fl = lmerge.GetMirrorNode(l.GetFinalStates()[0]);
//3.Merge right graph
CGraph.CMergeGraphOperation rmerge = m_currentFA.Merge(r, options);
rmerge.MergeGraphInfo(r, GraphElementType.ET_EDGE, FA.m_FAINFOKEY);
rmerge.MergeGraphInfo(r, GraphElementType.ET_GRAPH, FA.m_FAINFOKEY);
rmerge.MergeGraphInfo(r, GraphElementType.ET_NODE, FA.m_FAINFOKEY);
rmerge.MergeGraphInfo(r, GraphElementType.ET_EDGE, m_ThompsonInfoKey);
rmerge.MergeGraphInfo(r, GraphElementType.ET_GRAPH, m_ThompsonInfoKey);
rmerge.MergeGraphInfo(r, GraphElementType.ET_NODE, m_ThompsonInfoKey);
CGraphNode ir = rmerge.GetMirrorNode(r.M_Initial);
CGraphNode fr = rmerge.GetMirrorNode(r.GetFinalStates()[0]);
//4.Create the initial and the final node
CGraphNode FAinit = m_currentFA.CreateGraphNode <CGraphNode>();
CGraphNode FAfinal = m_currentFA.CreateGraphNode <CGraphNode>();
m_ThompsonInfo.InitNodeInfo(FAinit, new ThompsonNodeFAInfo());
m_ThompsonInfo.InitNodeInfo(FAfinal, new ThompsonNodeFAInfo());
m_currentFA.M_Initial = FAinit;
m_currentFA.SetFinalState(FAfinal);
m_currentFA.UpdateAlphabet();
m_currentFA.AddGraphEdge <CGraphEdge, CGraphNode>(FAinit, il, GraphType.GT_DIRECTED);
m_currentFA.AddGraphEdge <CGraphEdge, CGraphNode>(FAinit, ir, GraphType.GT_DIRECTED);
m_currentFA.AddGraphEdge <CGraphEdge, CGraphNode>(fr, FAfinal, GraphType.GT_DIRECTED);
m_currentFA.AddGraphEdge <CGraphEdge, CGraphNode>(fl, FAfinal, GraphType.GT_DIRECTED);
// Update closure information from operand closure
// Update closure information from operand closure
UpdateClosureInformation(l, m_currentFA, lmerge);
UpdateClosureInformation(r, m_currentFA, rmerge);
//7.Return result
return(m_currentFA);
}
public override object VisitChildren(CGraphNode node)
{
CIt_Successors it = new CIt_Successors(node);
for (it.Begin(); !it.End(); it.Next())
{
Visit(it.M_CurrentItem);
}
return(null);
}
public void FindAllPairsShortestPaths()
{
CIt_GraphNodes itn = new CIt_GraphNodes(mGraph);
for (itn.Begin(); !itn.End(); itn.Next())
{
m_source = itn.M_CurrentItem;
Run();
}
}
/// <summary>
/// Adds a node in the specified existing condensed node if it doesn't already
/// exists in the condensed node
/// </summary>
/// <param name="condensedNode"></param>
/// <param name="node"></param>
/// <returns></returns>
public CGraphNode AddNodeToCondensedNode(CGraphNode condensedNode, CGraphNode node)
{
if (Contains(condensedNode) != GraphElementType.ET_NA &&
!CondensedNodeContains(condensedNode, node))
{
m_condensedNodeMappings[condensedNode].Add(node);
m_nodeMappings[node] = condensedNode;
return(node);
}
return(null);
}
/// <summary>
/// Checks to find existing NFA configurations mapped to
/// existing DFA states with the given set of NFA nodes.
/// If it finds equivalent configuration it returns the
/// corresponding DFA state
/// </summary>
/// <param name="q">NFA nodes set</param>
/// <returns>null or the corresponding DFA state</returns>
public CGraphNode GetDFANode(HashSet <CGraphNode> q)
{
CGraphNode DFAnode = null;
foreach (CGraphNode dfanode in m_mappings.Keys)
{
if (m_mappings[dfanode].SetEquals(q))
{
DFAnode = dfanode;
}
}
return(DFAnode);
}
/// <summary>
/// 寻路start 和 end, 因为GraphNode本身包含图结构的数据
/// 所以我们没必要传如所有的GraphNode数据了
/// </summary>
/// <param name="start">开始节点</param>
/// <param name="end">结束节点</param>
/// <returns></returns>
public bool FindPath(CGraphNode start, CGraphNode end)
{
m_open.Clear();
m_closed.Clear();
m_startNode = start;
m_endNode = end;
m_startNode.G = 0;
bool result = Search();
return(result);
}
public bool ContainsInitialState(HashSet <CGraphNode> q)
{
CGraphNode initiaNFAState = m_NFA.M_Initial;
foreach (CGraphNode node in q)
{
if (initiaNFAState == node)
{
return(true);
}
}
return(false);
}
/// <summary>
/// Creates a unique dfa node for a given configuration
/// The method assures that the configuration-dfa node mapping
/// is unique
/// </summary>
/// <param name="q">The q.</param>
/// <returns></returns>
public CGraphNode CreateDFANode(HashSet <CGraphNode> q)
{
CGraphNode DFAnode = null;
HashSet <string> prefixes = new HashSet <string>();
string prefix = "";
//check if q configuration corresponds to a DFA state
DFAnode = GetDFANode(q);
//if not create a new DFA node
if (DFAnode == null)
{
DFAnode = m_DFA.CreateGraphNode <CGraphNode>();
foreach (CGraphNode node in q)
{
if (!prefixes.Contains(m_NFAStateInfo.Info(node).M_NodeLabelPrefix))
{
prefixes.Add(m_NFAStateInfo.Info(node).M_NodeLabelPrefix);
m_DFAStateInfo.Info(DFAnode).M_NodeLabelPrefix = m_NFAStateInfo.Info(node).M_NodeLabelPrefix;
}
foreach (uint lineDependency in m_NFAStateInfo.Info(node).M_LineDependencies)
{
m_DFA.SetFANodeLineDependency(lineDependency, DFAnode);
}
}
foreach (string s in prefixes)
{
prefix += s;
}
m_DFA.PrefixElementLabel(prefix, DFAnode);
if (ContainsFinalState(q))
{
m_DFA.SetFinalState(DFAnode);
}
if (ContainsInitialState(q))
{
m_DFA.M_Initial = DFAnode;
}
m_mappings[DFAnode] = q;
}
//else return the existing DFA node
return(DFAnode);
}
public static void TestCaseBook()
{
// 1. Create a graph
CGraph mgraph = CGraph.CreateGraph();
CGraphNode r = mgraph.CreateGraphNode <CGraphNode>("r");
CGraphNode s = mgraph.CreateGraphNode <CGraphNode>("s");
CGraphNode t = mgraph.CreateGraphNode <CGraphNode>("t");
CGraphNode u = mgraph.CreateGraphNode <CGraphNode>("u");
CGraphNode v = mgraph.CreateGraphNode <CGraphNode>("v");
CGraphNode w = mgraph.CreateGraphNode <CGraphNode>("w");
CGraphNode x = mgraph.CreateGraphNode <CGraphNode>("x");
CGraphNode y = mgraph.CreateGraphNode <CGraphNode>("y");
mgraph.AddGraphEdge <CGraphEdge, CGraphNode>(r, s, GraphType.GT_UNDIRECTED);
mgraph.AddGraphEdge <CGraphEdge, CGraphNode>(r, v, GraphType.GT_UNDIRECTED);
mgraph.AddGraphEdge <CGraphEdge, CGraphNode>(s, w, GraphType.GT_UNDIRECTED);
mgraph.AddGraphEdge <CGraphEdge, CGraphNode>(w, t, GraphType.GT_UNDIRECTED);
mgraph.AddGraphEdge <CGraphEdge, CGraphNode>(w, x, GraphType.GT_UNDIRECTED);
mgraph.AddGraphEdge <CGraphEdge, CGraphNode>(t, x, GraphType.GT_UNDIRECTED);
mgraph.AddGraphEdge <CGraphEdge, CGraphNode>(t, u, GraphType.GT_UNDIRECTED);
mgraph.AddGraphEdge <CGraphEdge, CGraphNode>(x, u, GraphType.GT_UNDIRECTED);
mgraph.AddGraphEdge <CGraphEdge, CGraphNode>(x, y, GraphType.GT_UNDIRECTED);
// 2. Create Algorithm
BreadthFirstSearch bfs = new BreadthFirstSearch(s, mgraph);
// 2. Associate weights with the edges of the graph
CGraphQueryInfo <int, int, int> bfsData = new CGraphQueryInfo <int, int, int>(mgraph, bfs);
bfs.Run();
Console.WriteLine("Printing BFS Results with Source Node : {0}", s.M_Label);
foreach (CGraphNode node in bfs.BFSNodes())
{
Console.WriteLine("Node {0} distance: {1}", node.M_Label, bfs.Distance(node));
}
// Testing BreadthFirstSearchQueryInfo
BreadthFirstSearchQueryInfo bfsInfo = new BreadthFirstSearchQueryInfo(mgraph, bfs);
Console.WriteLine("Printing BFS Results with Source Node : {0}", s.M_Label);
foreach (CGraphNode node in bfsInfo.BFSNodes())
{
Console.WriteLine("Node {0} distance: {1}", node.M_Label, bfs.Distance(node));
}
}
//寻路的具体算法
private bool Search()
{
CGraphNode node = m_startNode;
while (node != m_endNode)
{
for (int i = 0; i < node.NeighbourCount; i++)
{
CGraphNode.Neighbour neighbour = node.Neighbours[i];
CGraphNode test = neighbour.node;
if (test == node)
{
continue;
}
if (IsClosed(test))
{
continue;
}
float g = node.G + neighbour.cost;
if (IsOpen(test))
{
if (test.G > g)
{
test.FillValue(g, node);
}
}
else
{
test.FillValue(g, node);
m_open.Push(test);
}
}
m_closed.Add(node);
if (m_open.Count == 0)
{
return(false);
}
node = m_open.Pop();
}
BuildPath();
return(true);
}
/// <summary>
/// Returns the information of the edge between the given source
/// and target nodes of the source graph. If the information is
/// not there it returns null instead of dropping an exception
/// </summary>
/// <param name="source">The source.</param>
/// <param name="target">The target.</param>
/// <param name="key">The key that will extract the information from the specified node's dictionary.If
/// null is given then the current Query Info object is used as a key</param>
/// <returns></returns>
public override IE Info(CGraphNode source, CGraphNode target, bool checkOwnership = true)
{
if (!checkOwnership)
{
return((IE)m_graph.Edge(source, target)[m_infoKey]);
}
else
{
if (source.M_OwnerGraph == m_graph && target.M_OwnerGraph == m_graph)
{
return((IE)m_graph.Edge(source, target)[m_infoKey]);
}
else
{
throw new Exception("The given edge does not belong to the graph");
}
}
}
public override IN TempInfo(CGraphNode node, bool checkOwnership = true)
{
if (!checkOwnership)
{
return((IN)node[node]);
}
else
{
if (node.M_OwnerGraph == m_graph)
{
return((IN)node[node]);
}
else
{
throw new Exception("The given node does not belong to the graph");
}
}
}
public override void CreateTempInfo(CGraphNode node, IN info, bool checkOwnership = true)
{
if (!checkOwnership)
{
node[node] = info;
}
else
{
if (node.M_OwnerGraph == m_graph)
{
node[node] = info;
}
else
{
throw new Exception("The given node does not belong to the graph");
}
}
}
/// <summary>
/// Stores the information at the specified edge of the source graph. If information already
/// exists, it is overwritten
/// </summary>
/// <param name="source">The source node.</param>
/// <param name="target">The target node.</param>
/// <param name="info">The information.</param>
/// <param name="key">The key that will extract the information from the specified node's dictionary. If
/// null is given then the current Query Info object is used as a key</param>
public override void CreateInfo(CGraphNode source, CGraphNode target, IE info, bool checkOwnership = true)
{
if (!checkOwnership)
{
m_graph.Edge(source, target)[m_infoKey] = info;
}
else
{
if (source.M_OwnerGraph == m_graph && target.M_OwnerGraph == m_graph)
{
m_graph.Edge(source, target)[m_infoKey] = info;
}
else
{
throw new Exception("The given edge does not belong to the graph");
}
}
}
internal FA Synthesize(FA l, FA r)
{
FA m_currentFA = new FA();
m_ThompsonInfo = new ThompsonInfo(m_currentFA, m_ThompsonInfoKey);
//2.Merge left graph
CGraph.CMergeGraphOperation lmerge = m_currentFA.Merge(l, CGraph.CMergeGraphOperation.MergeOptions.MO_DEFAULT);
lmerge.MergeGraphInfo(l, GraphElementType.ET_EDGE, FA.m_FAINFOKEY);
lmerge.MergeGraphInfo(l, GraphElementType.ET_GRAPH, FA.m_FAINFOKEY);
lmerge.MergeGraphInfo(l, GraphElementType.ET_NODE, FA.m_FAINFOKEY);
lmerge.MergeGraphInfo(l, GraphElementType.ET_EDGE, m_ThompsonInfoKey);
lmerge.MergeGraphInfo(l, GraphElementType.ET_GRAPH, m_ThompsonInfoKey);
lmerge.MergeGraphInfo(l, GraphElementType.ET_NODE, m_ThompsonInfoKey);
CGraphNode il = lmerge.GetMirrorNode(l.M_Initial);
CGraphNode fl = lmerge.GetMirrorNode(l.GetFinalStates()[0]);
//3.Merge right graph
CGraph.CMergeGraphOperation rmerge = m_currentFA.Merge(r, CGraph.CMergeGraphOperation.MergeOptions.MO_DEFAULT);
rmerge.MergeGraphInfo(r, GraphElementType.ET_EDGE, FA.m_FAINFOKEY);
rmerge.MergeGraphInfo(r, GraphElementType.ET_GRAPH, FA.m_FAINFOKEY);
rmerge.MergeGraphInfo(r, GraphElementType.ET_NODE, FA.m_FAINFOKEY);
rmerge.MergeGraphInfo(r, GraphElementType.ET_EDGE, m_ThompsonInfoKey);
rmerge.MergeGraphInfo(r, GraphElementType.ET_GRAPH, m_ThompsonInfoKey);
rmerge.MergeGraphInfo(r, GraphElementType.ET_NODE, m_ThompsonInfoKey);
CGraphNode ir = rmerge.GetMirrorNode(r.M_Initial);
CGraphNode fr = rmerge.GetMirrorNode(r.GetFinalStates()[0]);
//4.Create the initial and the final node
m_currentFA.M_Initial = il;
m_currentFA.SetFinalState(fr);
m_currentFA.AddGraphEdge <CGraphEdge, CGraphNode>(fl, ir, GraphType.GT_DIRECTED);
// Update closure information from operand closure
UpdateClosureInformation(l, m_currentFA, lmerge);
UpdateClosureInformation(r, m_currentFA, rmerge);
//7.Return result
return(m_currentFA);
}
private void BuildPath()
{
m_path.Clear();
CGraphNode node = m_endNode;
m_path.Push(node);
while (node != m_startNode)
{
node = node.Parent;
m_path.Push(node);
}
/* remove the first node which indeed is start node */
if (m_path.Count > 0)
{
m_path.Pop();
}
}
public override int Visit(CGraphNode node)
{
m_time++;
SetArrival(node, m_time);
SetColor(node, NodeColor.NC_GRAY);
CIt_Successors si = new CIt_Successors(node);
for (si.Begin(); !si.End(); si.Next())
{
if (Color(si.M_CurrentItem) == NodeColor.NC_WHITE)
{
Visit(si.M_CurrentItem);
}
}
SetColor(node, NodeColor.NC_BLACK);
m_time++;
SetDeparture(node, m_time);
return(0);
}
// Works only for the initial DFA's nodes
public CGraphNode GetTargetNodeConfiguration(CGraphNode node, Int32 character)
{
if (m_DFA.IsANodeOfGraph(node))
{
CGraphNode target = m_DFA.GetTransitionTarget(node, character);
if (target != null)
{
return(GetNodeConfiguration(target) as CGraphNode);
}
else
{
return(null);
}
}
else
{
return(null);
}
}
