public LGSPGraphProcessingEnvironment(LGSPGraph graph, LGSPActions actions)
: base(graph, actions)
{
transactionManager = new LGSPTransactionManager(this);
sequencesManager = new LGSPDeferredSequencesManager();
SetClearVariables(true);
}
public LGSPGraphProcessingEnvironment(LGSPGraph graph, LGSPActions actions)
: base(graph, actions)
{
transactionManager = new LGSPTransactionManager(this);
sequencesManager = new LGSPDeferredSequencesManager();
SetClearVariables(true);
}
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 LGSPGraph 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="newGraph">Returns the new 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 CreateFromSpec(String grgFilename, String statisticsPath,
out LGSPGraph newGraph, out LGSPActions newActions)
{
LGSPGraph graph;
LGSPActions actions;
CreateFromSpec(grgFilename, GetNextGraphName(), statisticsPath, ProcessSpecFlags.UseNoExistingFiles, new List <String>(), false, 0,
out graph, out actions);
newGraph = graph;
newActions = actions;
}
/// <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 static bool ApplyXGRS_huh(GRGEN_LGSP.LGSPGraphProcessingEnvironment procEnv)
{
object x = procEnv.GetVariableValue("x");
GRGEN_LGSP.LGSPGraph graph = procEnv.graph;
GRGEN_LGSP.LGSPActions actions = procEnv.curActions;
object a = procEnv.GetVariableValue("a");
GRGEN_MODEL.N node_a = (GRGEN_MODEL.N)a;
int val_x = (int)x;
// announce change so that debugger can show new value or transaction manager can record it and roll it back
graph.ChangingNodeAttribute(node_a, GRGEN_MODEL.NodeType_N.AttributeType_i, GRGEN_LIBGR.AttributeChangeType.Assign, val_x, null);
node_a.i = val_x;
// add reflexive edge
GRGEN_MODEL.E someEdge = GRGEN_MODEL.E.CreateEdge(graph, node_a, node_a);
// here you could do other nifty things like deleting nodes, retyping graph elements, or calling rules
return(false);
}
/// <summary>
/// Creates a new LGSPGraph or 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.
/// </summary>
/// <param name="grgFilename">Filename of the rule specification file (.grg).</param>
/// <param name="graphName">Name of the new graph.</param>
/// <param name="statisticsPath">Optional path to a file containing the graph statistics to be used for building the matchers.</param>
/// <param name="flags">Specifies how the specification is to be processed; only KeepGeneratedFiles and CompileWithDebug are taken care of!</param>
/// <param name="externalAssemblies">List of external assemblies to reference.</param>
/// <param name="named">Returns a named graph if true otherwise a non-named graph. You must cast the LGSPGraph returned to the inherited LGSPNamedGraph if named=true.</param>
/// <param name="capacity">The initial capacity for the name maps, only used if named (performance optimization, use 0 if unsure).</param>
/// <param name="newGraph">Returns the new 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 CreateFromSpec(String grgFilename, String graphName, String statisticsPath,
ProcessSpecFlags flags, List <String> externalAssemblies, bool named, int capacity,
out LGSPGraph newGraph, out LGSPActions newActions)
{
if (!File.Exists(grgFilename))
{
throw new FileNotFoundException("The rule specification file \"" + grgFilename + "\" does not exist!", grgFilename);
}
String actionsFilename;
String modelFilename;
if (MustGenerate(grgFilename, statisticsPath, flags, out actionsFilename, out modelFilename))
{
LGSPGrGen.ProcessSpecification(grgFilename, statisticsPath, flags, externalAssemblies.ToArray());
}
newGraph = named ? (LGSPNamedGraph)CreateNamedGraph(modelFilename, graphName, "capacity=" + capacity.ToString()) : (LGSPGraph)CreateGraph(modelFilename, graphName);
newActions = LGSPActions.LoadActions(actionsFilename, newGraph);
}
public void InitActionsProfile(LGSPActions actions)
{
if (actions == null)
{
return;
}
if (!actions.Profile)
{
return;
}
perfInfo.ActionProfiles.Clear();
foreach (IAction action in actions.Actions)
{
ActionProfile actionProfile = new ActionProfile();
int branchingFactor = ((LGSPAction)action).patternGraph.branchingFactor;
actionProfile.averagesPerThread = new ProfileAverages[branchingFactor];
for (int i = 0; i < branchingFactor; ++i)
{
actionProfile.averagesPerThread[i] = new ProfileAverages();
}
perfInfo.ActionProfiles.Add(action.PackagePrefixedName, actionProfile);
}
}
/// <summary>
/// Loads a LGSPActions instance from the given file.
/// If the file is a ".cs" file it will be compiled first.
/// </summary>
public static LGSPActions LoadActions(String actionFilename, LGSPGraph graph)
{
Assembly assembly;
String assemblyName;
String extension = Path.GetExtension(actionFilename);
if (extension.Equals(".cs", StringComparison.OrdinalIgnoreCase))
{
CSharpCodeProvider compiler = new CSharpCodeProvider();
CompilerParameters compParams = new CompilerParameters();
compParams.ReferencedAssemblies.Add("System.dll");
compParams.ReferencedAssemblies.Add(Assembly.GetAssembly(typeof(IBackend)).Location);
compParams.ReferencedAssemblies.Add(Assembly.GetAssembly(typeof(LGSPActions)).Location);
compParams.ReferencedAssemblies.Add(graph.modelAssemblyName);
// compParams.GenerateInMemory = true;
compParams.CompilerOptions = "/optimize";
compParams.OutputAssembly = String.Format("lgsp-action-assembly-{0:00000}.dll", actionID++);
CompilerResults compResults = compiler.CompileAssemblyFromFile(compParams, actionFilename);
if (compResults.Errors.HasErrors)
{
String errorMsg = compResults.Errors.Count + " Errors:";
foreach (CompilerError error in compResults.Errors)
{
errorMsg += String.Format("\r\nLine: {0} - {1}", error.Line, error.ErrorText);
}
throw new ArgumentException("Illegal actions C# source code: " + errorMsg);
}
assembly = compResults.CompiledAssembly;
assemblyName = compParams.OutputAssembly;
}
else if (extension.Equals(".dll", StringComparison.OrdinalIgnoreCase))
{
assembly = Assembly.LoadFrom(actionFilename);
assemblyName = actionFilename;
LGSPBackend.Instance.AddAssembly(assembly); // TODO: still needed??
}
else
{
throw new ArgumentException("The action filename must be either a .cs or a .dll filename!");
}
Type actionsType = null;
try
{
foreach (Type type in assembly.GetTypes())
{
if (!type.IsClass || type.IsNotPublic)
{
continue;
}
if (type.BaseType == typeof(LGSPActions))
{
if (actionsType != null)
{
throw new ArgumentException(
"The given action file contains more than one LGSPActions implementation!");
}
actionsType = type;
}
}
}
catch (ReflectionTypeLoadException e)
{
String errorMsg = "";
foreach (Exception ex in e.LoaderExceptions)
{
errorMsg += "- " + ex.Message + Environment.NewLine;
}
if (errorMsg.Length == 0)
{
errorMsg = e.Message;
}
throw new ArgumentException(errorMsg);
}
if (actionsType == null)
{
throw new ArgumentException("The given action file doesn't contain an LGSPActions implementation!");
}
LGSPActions actions = (LGSPActions)Activator.CreateInstance(actionsType, graph, graph.modelAssemblyName, assemblyName);
if (graph.Model.MD5Hash != actions.ModelMD5Hash)
{
throw new ArgumentException("The given action file has been compiled with another model assembly!");
}
return(actions);
}
/// <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 override void Initialize(LGSPGraph graph, LGSPActions actions)
{
SetClearVariables(false);
base.Initialize(graph, actions);
SetClearVariables(true);
}
public LGSPSubactionAndOutputAdditionEnvironment(LGSPGraph graph, LGSPActions actions)
: base(graph, actions)
{
recorder = new Recorder(graph as LGSPNamedGraph, this);
}
public virtual void Initialize(LGSPGraph graph, LGSPActions actions)
{
this.Graph = graph;
this.Actions = actions;
((Recorder)recorder).Initialize(graph as LGSPNamedGraph, this);
}
/// <summary>
/// Creates a new LGSPGraph 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="newGraph">Returns the new 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 CreateFromSpec(String grgFilename, String statisticsPath,
out LGSPGraph newGraph, out LGSPActions newActions)
{
LGSPGraph graph;
LGSPActions actions;
CreateFromSpec(grgFilename, GetNextGraphName(), statisticsPath, ProcessSpecFlags.UseNoExistingFiles, new List<String>(), false, 0,
out graph, out actions);
newGraph = graph;
newActions = actions;
}
public LGSPSubactionAndOutputAdditionEnvironment(LGSPGraph graph, LGSPActions actions)
: base(graph, actions)
{
recorder = new Recorder(graph as LGSPNamedGraph, this);
}
public override void Initialize(LGSPGraph graph, LGSPActions actions)
{
SetClearVariables(false);
base.Initialize(graph, actions);
SetClearVariables(true);
}
public virtual void Initialize(LGSPGraph graph, LGSPActions actions)
{
this.Graph = graph;
this.Actions = actions;
((Recorder)recorder).Initialize(graph as LGSPNamedGraph, this);
}
/// <summary>
/// Creates a new LGSPGraph or 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.
/// </summary>
/// <param name="grgFilename">Filename of the rule specification file (.grg).</param>
/// <param name="graphName">Name of the new graph.</param>
/// <param name="statisticsPath">Optional path to a file containing the graph statistics to be used for building the matchers.</param>
/// <param name="flags">Specifies how the specification is to be processed; only KeepGeneratedFiles and CompileWithDebug are taken care of!</param>
/// <param name="externalAssemblies">List of external assemblies to reference.</param>
/// <param name="named">Returns a named graph if true otherwise a non-named graph. You must cast the LGSPGraph returned to the inherited LGSPNamedGraph if named=true.</param>
/// <param name="capacity">The initial capacity for the name maps, only used if named (performance optimization, use 0 if unsure).</param>
/// <param name="newGraph">Returns the new 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 CreateFromSpec(String grgFilename, String graphName, String statisticsPath,
ProcessSpecFlags flags, List<String> externalAssemblies, bool named, int capacity,
out LGSPGraph newGraph, out LGSPActions newActions)
{
if(!File.Exists(grgFilename))
throw new FileNotFoundException("The rule specification file \"" + grgFilename + "\" does not exist!", grgFilename);
String actionsFilename;
String modelFilename;
if(MustGenerate(grgFilename, statisticsPath, flags, out actionsFilename, out modelFilename))
LGSPGrGen.ProcessSpecification(grgFilename, statisticsPath, flags, externalAssemblies.ToArray());
newGraph = named ? (LGSPNamedGraph)CreateNamedGraph(modelFilename, graphName, "capacity=" + capacity.ToString()) : (LGSPGraph)CreateGraph(modelFilename, graphName);
newActions = LGSPActions.LoadActions(actionsFilename, newGraph);
}
