For sequence handling, contains the names of the different kinds of actions (plus a bit further information)
A class for collecting an action profile, accumulating per-action statistics, over all applications of the corresponding rule or test
For sequence handling, contains type information (plus a bit further information) about the different kinds of actions
An assignment target object with references to used sequence computations.
The description of a single attribute index.
Describes a GrGen attribute.
A partial implementation of the interface to the actions.
A partial implementation of the IGraph interface. Adding some methods implemented over the IGraph interface (some convenience stuff).
A proxy simulating an always compliant user for choices during sequence execution, always returns the suggested choice. Used for sequence execution without debugger.
Represents a sequence definition.
Class implementing a Double Ended Queue. Items can be added and removed in O(1) at the beginning and at the end, and accessed at an arbitrary index in O(1). Implemented by a ring buffer that is doubled in size (and the old content copied) when necessary (so insert is only amortized O(1)).
A VCG graph dumper.
A description of how to dump a graph.
A representation of a GrGen edge type.
Represents an XGRS used in an exec statement.
A description of a GrGen enum type.
A description of a GrGen enum member.
Represents a sequence definition implemented externally.
A representation of an external type registered with GrGen. The bottom type of the external type hierarchy that is always available is type object.
An object representing a filter call (of an action filter or a match class filter). To be built by the user and used at API level to carry out filter calls.
A description of a GrGen (attribute evaluation) function.
A representation of a GrGen graph element type.
Exports graphs in GRG format, i.e. as GrGen rules.
Specifies which nodes are grouped by this group node type.
Exports graphs to the GRS format.
Imports graphs from files in GRS format. Implementation note: this is a boring hand written lexer and parser, needed because the lexer/parser generated by CSharpCC that was replaced by it fired a multitude of "LookaheadSuccess"-exceptions, wreaking havoc on performance.
Exports graphs to the GXL format.
Imports graphs from the GXL format.
The description of a single incidence count index.
The description of a single index, base for all kinds of index descriptions. (You must typecheck and cast to the concrete description type for more information).
Represents an info tag.
An object that allows to filter the matches obtained from multiple actions (based on shared pattern elements contained in a match class), (potentially employed by the multi rule all call or multi backtracking sequences).
A helper class used in flattening an array of Matches objects (containing Match objects) to an array of Match objects, and handling an array of Match objects (as it is used by the multi rule all call and multi backtracking language constructs).
A representation of a GrGen node type.
An object accumulating information about needed time, number of found matches and number of performed rewrites.
Import and export support for graphs.
A description of a GrGen (attribute evaluation) procedure.
A class for collecting average information, for profiling, per thread that was used in matching (so in case of a normal single threaded action the values characterize the action)
A class for recording changes (and their causes) applied to a graph into a file, so that they can get replayed.
A sequence object with references to child sequences. A sequence is basically a rule application or a computation, or an operator combining them.
A sequence which assigns something to a destination variable.
The common base of sequence, sequence computation, and sequence expression objects, with some common infrastructure.
A sequence consisting of a binary operator and two sequences. Decision on order of execution by random, by user choice possible.
A sequence binary expression object with references to the left and right child sequence expressions.
Environment for sequence type checking (with/giving access to model and action signatures). Abstract base class, there are two concrete subclasses, one for interpreted, one for compiled sequences.
Environment for sequence type checking (with/giving access to model and action signatures). Concrete subclass for compiled sequences.
Environment for sequence type checking (with/giving access to model and action signatures). Concrete subclass for interpreted sequences.
A sequence computation object with references to child sequence computations. The computations are basically: visited flags management, container manipulation, assignments and special functions; they may or may not return values. They do change things, in contrast to the side-effect free sequence expressions.
A sequence computation on a container object (resulting from a variable or a method call; yielding a container object again)
A sequence representing a sequence definition. It must be applied with a different method than the other sequences because it requires the parameter information.
A sequence representing a compiled sequence definition. The generated subclass contains the method implementing the real sequence, and ApplyImpl calling that method mapping SequenceInvocationParameterBindings to the exact parameters of that method.
An sequence representing an interpreted sequence definition. Like the other sequences it can be directly interpreted (but with a different apply method), in contrast to the others it always must be the root sequence.
A dummy sequence to be used in contexts where a sequence is needed formally but not available (null-element/guard).
A sequence expression object with references to child sequence expressions. A sequence expression is a side effect free computation returning a value (a query).
A sequence expression over a container object (resulting from a variable or a method call)
The sequence expression execution helper selects and executes the correct version of an operator based on the target and argument types. It is employed at runtime for sequence operator implementation, or at compile time in case the type is not known statically.
The sequence expression type helper contains code for operator type balancing, i.e. determining the correct version(/implementation) of an operator. It is used in type checking, and implementation selection (esp. meaning apropriate casting of the arguments), at runtime (SequenceExpressionExecutionHelper) as well as compile time (SequenceExpressionGeneratorHelper).
A sequence representing a filter call at compile time (of an action filter or a match class filter). It specifies the filter and potential arguments. Only used internally for code generation.
A sequence consisting of a list of subsequences. Decision on order of execution always by random, by user choice possible.
A sequence consisting of a list of subsequences in the form of rule calls. First all the contained rules are matched, then they get rewritten.
A sequence consisting of a list of subsequences. Decision on order of execution always by random, by user choice possible.
An exception thrown by SequenceParser, describing the error, e.g. which rule caused the problem and how it was used
A sequence consisting of a list of subsequences in the form of rule calls (and inherited rule all and count rule all calls). Decision on order of execution by random, by user choice possible. First all the contained rules are matched, then they get rewritten
A Sequence with a Special flag
A sequence consisting of a unary operator and another sequence.
A variable declared/used within a sequence, might be a sequence-local variable or a reference to a graph-global variable. It is first stored within the symbol table belonging to the sequence on sequence parsing, after parsing only on the heap, with references from the sequence AST pointing to it.
Set class only used by the dumping code. The value of this class is questionable...
A dummy type used as value type for dictionaries representing sets.
class of symbol table containing the variables declared in the sequence variables might be implicitely(graph-global) or explicitely(sequence-local) declared
A class which contains the AreSymmetric function to check to matches of a pattern for being symmetric, i.e. to be matches of a pattern which is automorph to itself.
The Über-Statistical-Estimator implementing a staged, present leaning, truncated average. Staged similar to the remedian for efficient computation in case of a large number of samples, present leaning with weights to get a preference for more current values, going into the direction of a sliding average, truncated average to achieve resilience against outliers (compared to the average), and to not underestimate the volume (compared to the median in case about half of the values are small).
A representation of a GrGen connection assertion. Used by BaseGraph.Validate().
A named graph-global variable.
A VCG graph dumper.
Exports graphs to the XMI format (assuming a matching ecore exists).
A description of an error, found during the validation process.
Describes a range with a minimum and a maximum value. Currently not used, was added for G# (integration of graph rewriting/GrGen into C# compiler) - TODO/potential use: ranges in validation, maybe loops
An interface representing a filter invocation.
An interface representing a function invocation.
An object representing an executable rule.
An object representing an executable rule. The core functions used by the sequences/GrGen itself, the IAction interface contains a lot more convenience helper functions for direct rule application that could be used from own code (and are a bit faster due to missing debug events).
An environment for the execution of actions (without embedded sequences). Holds a reference to the current graph.
The interface to the actions (the "generic" interface, using strings and objects).
An alternative is a pattern graph element containing subpatterns of which one must get successfully matched so that the entire pattern gets matched successfully
A single attribute index.
A helper class for backend independent graph and rule handling.
A directed GrGen edge
Interface of a Double Ended Queue. (Why is there none in the .NET collection library?)
A dumper for output of graphs.
A GrGen edge (arbitrary direction)
A type model for edges.
A description of a filter of a rule or match class
A description of an auto-generated filter
A description of an auto-supplied filter
A description of a filter function
An object representing an executable function.
An attributed, typed and directed multigraph with multiple inheritance on node and edge types.
A GrGen graph element
A model of a GrGen graph.
An environment for the advanced processing of graphs and the execution of sequences. With global variables, (sub)graph switching, and transaction management.
A single incidence count index.
Base class for a single index, the different kinds of indices. (You must typecheck and cast to the concrete index type for more information).
The index set applied on a graph.
An iterated is a pattern graph element containing the subpattern to be matched iteratively and the information how much matches are needed for success and how much matches to obtain at most
Base class of classes representing matches. One exact match class is generated per pattern.
An object representing the shared elements from the patterns of several actions. (Match classes allow via their Filterer implementation part to filter the matches obtained from multiple actions (potentially employed by the multi rule all call or multi backtracking sequences)).
An object representing a (possibly empty) set of matches in a graph before the rewrite has been applied. If it is a match of an action, it is returned by IAction.Match() and given to the OnMatched event. Otherwise it's the match of an iterated-pattern, and the producing action is null.
An object representing a (possibly empty) set of matches in a graph before the rewrite has been applied, capable of handing out enumerators of exact match interface type.
A description of a GrGen matching pattern, that's a subpattern/subrule or the base for some rule.
An named IGraph (which is an attributed, typed and directed multigraph with multiple inheritance on node and edge types), with a unique name assigned to each node and edge; allowing to access an element by name and a name by element.
A GrGen node
A type model for nodes.
An interface representing a rule or sequence or procedure or function or filter invocation.
A pattern edge of a rule pattern.
An element of a rule pattern.
A pattern graph.
Embedding of a subpattern into it's containing pattern
A pattern node of a rule pattern.
A pattern variable of a rule pattern.
An object representing an executable procedure.
An interface for recording changes (and their causes) applied to a graph into a file, so that they can get replayed.
A description of a GrGen rule.
An object representing an executable sequence. Implemented by SequenceDefinitionInterpreted inheriting from SequenceDefinition, in the Sequences file, for sequences registered at runtime, and by the generated class inheriting from SequenceDefinitionCompiled inheriting from SequenceDefinition, for sequences already available at compile time. Embedded execs are employed directly by their rules, have only an EmbeddedSequenceInfo as representation (without capability of getting called, this occurs only directly in the generated code).
An environment extending basic action execution with subaction debugging, plus subgraph nesting, and output -- for one textual emits, and for the other graph change recording.
An interface for managing graph transactions.
A type model for node or edge elements.
An undirected GrGen edge
An interface for undo items of the transaction manager. Allows to register own ones for external types, will be called on rollback.
Base class for uniqueness handlers, only needed as a kind of handle on libGr level, to transfer real implementation objects.
A proxy querying or simulating a user for choices during sequence execution TODO: general user proxy, not just for sequence execution
An interface representing a method function invocation (both runtime and compile time).
An interface representing a method procedure invocation (both runtime and compile time).
An interface representing a procedure invocation.
An interface representing a rule invocation.
An interface representing a sequence invocation (of a defined thus named thus callable sequence).
A Sequence with a random decision which might be interactively overriden by a user choice.
Represents a method called after the rewrite step of a rule.
Represents a method called after all requested matches of an action have been matched.
Represents a method called before the rewrite step of an action, when at least one match has been found.
Represents a method called after an edge attribute was changed (for debugging, omitted in case of nodebugevents).
Represents a method called after a node attribute was changed (for debugging, omitted in case nodebugevents).
Represents a method called just before an edge attribute is changed, with exact information about the change to occur, to allow rollback of changes, in case a transaction is underway.
Represents a method called just before a node attribute is changed, with exact information about the change to occur, to allow rollback of changes, in case a transaction is underway.
Represents a method called before a graph is cleared.
Represents a method called by the user to emit debugging information, not halting execution. (Stored on the debug traces stack, removed when its directly nesting debug enter is exited.)
Represents a method called directly after a computation has been entered (for tracing/debugging purpose). Applying user-defined computation borders, or e.g. auto-generated rule eval or procedure call borders; but not interpreted sequences, they receive dedicated treatement in the graph processing environment, are debugged directly.
Represents a method called directly before a computation is left (for tracing/debugging purpose). Applying user-defined computation borders, or e.g. auto-generated rule eval or procedure call borders; but not interpreted sequences, they receive dedicated treatement in the graph processing environment, are debugged directly.
Represents a method called by the user to halt execution, emitting some debugging information.
Represents a method called by the user to highlight some elements in the graph, halting execution.
Represents a method called, when an edge has been added.
Represents a method called when a loop iteration is ended.
Represents a method called directly after a sequence has been entered.
Represents a method called before a sequence is left.
Represents a method called, when a node has been added.
Represents a method called before an edge is redirected (i.e. will be removed soon and added again immediately thereafter).
Represents a method called before a edge is removed.
Represents a method called before all edges of a node are removed.
Represents a method called before a node is removed.
Represents a method called directly after graph processing returned back (from a previous switch). (To the main graph, or a subgraph previously switched to. Graph processing means rule and sequence execution.)
Represents a method called before an edge is retyped.
Represents a method called before a node is retyped.
Represents a method called during rewriting a set of matches before the next match is rewritten. It is not fired before rewriting the first match.
Delegate-type called shortly before elements are added to the graph, with the names of the elements added.
Represents a method called before a visited flag is set to a new value.
Represents a method called directly before graph processing switches to a subgraph. (Graph processing means rule and sequence execution. Not called when the main graph is replaced.)
Represents a method called, when a visited flag was allocated.
Represents a method called, when a visited flag was freed.
Specifies the assignment target type (the lhs expression).
The changes which might occur to graph element attributes.
Specifies the kind of a GrGen attribute.
Specifies the type of a connection assertion error.
Specifies the kind of directedness for an EdgeType
Specifies how an IMatches object should be dumped.
The supported group modes.
Flags which determine, how the specification file should be processed.
The possible scope opening types
Specifies the actual subtype of a sequence computation. A new expression type -> you must add the corresponding class down below and adapt the lgspSequenceGenerator.
States of executing sequences: not (yet) executed, execution underway, successful execution, fail execution
Specifies the actual subtype of a sequence expression. A new expression type -> you must add the corresponding class down below and adapt the lgspSequenceGenerator.
Specifies the kind of sequence parser error.
Specifies the actual subtype used for a Sequence. A new sequence type -> you must add the corresponding class down below, and adapt the lgspSequenceGenerator and the Debugger.
The different graph validation modes
Specifies flags how the graph should be displayed by a graph layouter.