/// <summary>
/// Copy constructor.
/// </summary>
/// <param name="dataSource">The LGSPNamedGraph object to get the data from</param>
/// <param name="newName">Name of the copied graph.</param>
/// <param name="oldToNewMap">A map of the old elements to the new elements after cloning.</param>
public LGSPNamedGraph(LGSPNamedGraph dataSource, String newName, out IDictionary <IGraphElement, IGraphElement> oldToNewMap)
: base(dataSource, newName, out oldToNewMap)
{
NameToElem = new Dictionary <String, IGraphElement>(dataSource.NumNodes + dataSource.NumEdges);
ElemToName = new Dictionary <IGraphElement, String>(dataSource.NumNodes + dataSource.NumEdges);
CopyNames(dataSource, oldToNewMap);
}
public void AddEdge(IEdge edge, String varName, String elemName)
{
LGSPNamedGraph namedGraph = (LGSPNamedGraph)graph;
namedGraph.AddEdge(edge, elemName);
SetVariableValue(varName, edge);
}
public void AddNode(INode node, String varName, String elemName)
{
LGSPNamedGraph namedGraph = (LGSPNamedGraph)graph;
namedGraph.AddNode(node, elemName);
SetVariableValue(varName, node);
}
public IEdge AddEdge(EdgeType edgeType, INode source, INode target, String varName, String elemName)
{
LGSPNamedGraph namedGraph = (LGSPNamedGraph)graph;
IEdge edge = namedGraph.AddEdge(edgeType, source, target, elemName);
SetVariableValue(varName, edge);
return(edge);
}
public INode AddNode(NodeType nodeType, String varName, String elemName)
{
LGSPNamedGraph namedGraph = (LGSPNamedGraph)graph;
INode node = namedGraph.AddNode(nodeType, elemName);
SetVariableValue(varName, node);
return(node);
}
public LGSPActionExecutionEnvironment(LGSPGraph graph, LGSPActions actions)
{
// TODO: evt. IGraph + BaseActions und dann hier cast auf LGSP, mal gucken was an Schnittstelle besser paßt
this.usedGraphs = new Stack <LGSPGraph>();
this.usedGraphs.Push(graph);
this.namedGraphOnTop = graph as LGSPNamedGraph;
this.curActions = actions;
InitActionsProfile(actions);
}
public LGSPActionExecutionEnvironment(LGSPGraph graph, LGSPActions actions)
{
usedGraphs = new Stack <LGSPGraph>();
usedGraphs.Push(graph);
namedGraphOnTop = graph as LGSPNamedGraph;
curActions = actions;
InitActionsProfile(actions);
customCommandsToDescriptions = new Dictionary <string, string>();
FillCustomCommandDescriptions();
}
/// <summary>
/// Creates a new LGSPNamedGraph and LGSPActions instance from the specified specification file.
/// If the according dlls do not exist or are out of date, the needed processing steps are performed automatically.
/// A name for the graph is automatically generated.
/// </summary>
/// <param name="grgFilename">Filename of the rule specification file (.grg).</param>
/// <param name="statisticsPath">Optional path to a file containing the graph statistics to be used for building the matchers.</param>
/// <param name="capacity">The initial capacity for the name maps (performance optimization, use 0 if unsure).</param>
/// <param name="newGraph">Returns the new named graph.</param>
/// <param name="newActions">Returns the new BaseActions object.</param>
/// <exception cref="System.IO.FileNotFoundException">Thrown, when a needed specification file does not exist.</exception>
/// <exception cref="System.Exception">Thrown, when something goes wrong.</exception>
public void CreateNamedFromSpec(String grgFilename, String statisticsPath, int capacity,
out LGSPNamedGraph newGraph, out LGSPActions newActions)
{
LGSPGraph graph;
LGSPActions actions;
CreateFromSpec(grgFilename, GetNextGraphName(), statisticsPath, ProcessSpecFlags.UseNoExistingFiles, new List <String>(), true, capacity,
out graph, out actions);
newGraph = (LGSPNamedGraph)graph;
newActions = actions;
}
public void DoUndo(IGraphProcessingEnvironment procEnv)
{
String name;
if (procEnv.Graph is LGSPNamedGraph && ((LGSPNamedGraph)procEnv.Graph).ElemToName.TryGetValue(_newElem, out name))
{
LGSPNamedGraph lgspGraph = (LGSPNamedGraph)procEnv.Graph;
if (_newElem is INode)
{
LGSPNode newNode = (LGSPNode)_newElem;
LGSPNode oldNode = (LGSPNode)_oldElem;
lgspGraph.ElemToName[oldNode] = name;
lgspGraph.RetypingNode(newNode, oldNode); // this will switch the variables
lgspGraph.ReplaceNode(newNode, oldNode);
lgspGraph.ElemToName.Remove(newNode);
lgspGraph.NameToElem[name] = oldNode;
}
else
{
LGSPEdge newEdge = (LGSPEdge)_newElem;
LGSPEdge oldEdge = (LGSPEdge)_oldElem;
lgspGraph.ElemToName[oldEdge] = name;
lgspGraph.RetypingEdge(newEdge, oldEdge); // this will switch the variables
lgspGraph.ReplaceEdge(newEdge, oldEdge);
lgspGraph.ElemToName.Remove(newEdge);
lgspGraph.NameToElem[name] = oldEdge;
}
}
else
{
LGSPGraph lgspGraph = (LGSPGraph)procEnv.Graph;
if (_newElem is INode)
{
LGSPNode newNode = (LGSPNode)_newElem;
LGSPNode oldNode = (LGSPNode)_oldElem;
lgspGraph.RetypingNode(newNode, oldNode); // this will switch the variables
lgspGraph.ReplaceNode(newNode, oldNode);
}
else
{
LGSPEdge newEdge = (LGSPEdge)_newElem;
LGSPEdge oldEdge = (LGSPEdge)_oldElem;
lgspGraph.RetypingEdge(newEdge, oldEdge); // this will switch the variables
lgspGraph.ReplaceEdge(newEdge, oldEdge);
}
}
}
public static GRGEN_MODEL.@Node CreateNode(GRGEN_LGSP.LGSPNamedGraph graph, string nodeName)
{
GRGEN_MODEL.@Node node;
if (poolLevel == 0)
{
node = new GRGEN_MODEL.@Node();
}
else
{
node = pool[--poolLevel];
node.lgspInhead = null;
node.lgspOuthead = null;
node.lgspFlags &= ~(uint)GRGEN_LGSP.LGSPElemFlags.HAS_VARIABLES;
// implicit initialization, container creation of Node
}
graph.AddNode(node, nodeName);
return(node);
}
public static GRGEN_MODEL.@UEdge CreateEdge(GRGEN_LGSP.LGSPNamedGraph graph, GRGEN_LGSP.LGSPNode source, GRGEN_LGSP.LGSPNode target, string edgeName)
{
GRGEN_MODEL.@UEdge edge;
if (poolLevel == 0)
{
edge = new GRGEN_MODEL.@UEdge(source, target);
}
else
{
edge = pool[--poolLevel];
edge.lgspFlags &= ~(uint)GRGEN_LGSP.LGSPElemFlags.HAS_VARIABLES;
edge.lgspSource = source;
edge.lgspTarget = target;
// implicit initialization, container creation of UEdge
}
graph.AddEdge(edge, edgeName);
return(edge);
}
/// <summary>
/// Copy constructor helper.
/// </summary>
/// <param name="dataSource">The LGSPNamedGraph object to get the data from</param>
/// <param name="oldToNewMap">A map of the old elements to the new elements after cloning.</param>
private void CopyNames(LGSPNamedGraph dataSource, IDictionary <IGraphElement, IGraphElement> oldToNewMap)
{
foreach (INode node in dataSource.Nodes)
{
NameToElem[dataSource.GetElementName(node)] = oldToNewMap[node];
ElemToName[oldToNewMap[node]] = dataSource.GetElementName(node);
}
foreach (IEdge edge in dataSource.Edges)
{
NameToElem[dataSource.GetElementName(edge)] = oldToNewMap[edge];
ElemToName[oldToNewMap[edge]] = dataSource.GetElementName(edge);
}
/* TODO: remove when cloning of graph variables was implemented
* foreach(KeyValuePair<IGraphElement, LinkedList<Variable>> kvp in dataSource.ElementMap)
* {
* IGraphElement newElem = oldToNewMap[kvp.Key];
* foreach(Variable var in kvp.Value)
* SetVariableValue(var.Name, newElem);
* }*/
}
/// <summary>
/// Copy constructor helper.
/// </summary>
/// <param name="dataSource">The LGSPNamedGraph object to get the data from</param>
/// <param name="oldToNewMap">A map of the old elements to the new elements after cloning.</param>
private void CopyNames(LGSPNamedGraph dataSource, IDictionary<IGraphElement, IGraphElement> oldToNewMap)
{
foreach(INode node in dataSource.Nodes)
{
NameToElem[dataSource.GetElementName(node)] = oldToNewMap[node];
ElemToName[oldToNewMap[node]] = dataSource.GetElementName(node);
}
foreach(IEdge edge in dataSource.Edges)
{
NameToElem[dataSource.GetElementName(edge)] = oldToNewMap[edge];
ElemToName[oldToNewMap[edge]] = dataSource.GetElementName(edge);
}
/* TODO: remove when cloning of graph variables was implemented
* foreach(KeyValuePair<IGraphElement, LinkedList<Variable>> kvp in dataSource.ElementMap)
{
IGraphElement newElem = oldToNewMap[kvp.Key];
foreach(Variable var in kvp.Value)
SetVariableValue(var.Name, newElem);
}*/
}
/// <summary>
/// Copy constructor.
/// </summary>
/// <param name="dataSource">The LGSPNamedGraph object to get the data from</param>
/// <param name="newName">Name of the copied graph.</param>
public LGSPNamedGraph(LGSPNamedGraph dataSource, String newName)
: base(dataSource, newName, out tmpOldToNewMap)
{
NameToElem = new Dictionary<String, IGraphElement>(dataSource.NumNodes + dataSource.NumEdges);
ElemToName = new Dictionary<IGraphElement, String>(dataSource.NumNodes + dataSource.NumEdges);
CopyNames(dataSource, tmpOldToNewMap);
tmpOldToNewMap = null;
}
/// <summary>
/// Creates a new LGSPNamedGraph and LGSPActions instance from the specified specification file.
/// If the according dlls do not exist or are out of date, the needed processing steps are performed automatically.
/// A name for the graph is automatically generated.
/// </summary>
/// <param name="grgFilename">Filename of the rule specification file (.grg).</param>
/// <param name="statisticsPath">Optional path to a file containing the graph statistics to be used for building the matchers.</param>
/// <param name="capacity">The initial capacity for the name maps (performance optimization, use 0 if unsure).</param>
/// <param name="newGraph">Returns the new named graph.</param>
/// <param name="newActions">Returns the new BaseActions object.</param>
/// <exception cref="System.IO.FileNotFoundException">Thrown, when a needed specification file does not exist.</exception>
/// <exception cref="System.Exception">Thrown, when something goes wrong.</exception>
public void CreateNamedFromSpec(String grgFilename, String statisticsPath, int capacity,
out LGSPNamedGraph newGraph, out LGSPActions newActions)
{
LGSPGraph graph;
LGSPActions actions;
CreateFromSpec(grgFilename, GetNextGraphName(), statisticsPath, ProcessSpecFlags.UseNoExistingFiles, new List<String>(), true, capacity,
out graph, out actions);
newGraph = (LGSPNamedGraph)graph;
newActions = actions;
}