de.unika.ipd.grGen.libGr Namespace

An object representing an action call. To be built by the user and used at API level to carry out multi action calls.

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 representation of a GrGen base object type, i.e. class of internal non-node/edge values.

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 object type registered with GrGen. The bottom type of the external object type hierarchy that is always available is type object (not to be mistaken with type Object, the bottom type of the internal object type hierarchy).

Base class for objects representing a filter call (of an action filter or a match class filter), distinguished into filter calls with arguments and lambda expression filter calls.

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.

An object representing a lambda expression filter call, employing a filter containing a lambda sequence expression on the matches array (stemming from an action or a match class). Built by the sequence parser, may be built by the user at API level (employing the sequence expression parser, or potentially building the sequence expression directly), in order to carry out lambda expression filter calls (currently supported ("package prefixed") filter names: removeIf, assign<match-element-name>).

A description of a GrGen (attribute evaluation) function.

A representation of a GrGen graph element type.

A representation of a GrGen 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.

A representation of a GrGen inheritance type.

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.

A representation of a GrGen object type, i.e. class of internal non-node/edge values.

A compiled sequence construct that allows to match patterns (most also allow to rewrite them). Utilized in begin and end events to tell about the construct that started or ended.

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 representing a lambda expression filter call at compile time (of an action filter or a match class filter). It specifies the filter and optionally a target entity (plus the lambda expression and the per-element variables - in the parent class). 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.

Deprecated...

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.

A representation of a GrGen transient object type, i.e. class of internal non-node/edge values.

The TypesHelper in this file contains code that creates or handles .net / C# types, as name strings or Type objects

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 global variable.

A representation of a GrGen variable type.

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.

helper object to passively report parallel sequence executions about to be begun, comprising esp. the processing environment that was created in order to execute it (in parallel)

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

An interface to IBaseObject (thus IObject, ITransientObject) and IGraphElement (thus INode and IEdge) types, all bearing attributes

A single attribute index.

A helper class for backend independent graph and rule handling.

A GrGen base object (base for values of internal, non-node/edge classes)

A type model for base objects (internal non graph-element values), i.e. classes.

An interface to be implemented by classes that offer callable stateless functions / stateful procedures

A directed GrGen edge

An interface to be implemented by classes whose objects can be compared for deep attribute value equality This excludes structures with shortcuts and cycles (acyclic and cyclic graphs), only classes without further nesting, or lists, or trees are supported.

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, i.e. edge classes.

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.

The global variables shared by the graph processing environments.

An attributed, typed and directed multigraph with multiple inheritance on node and edge types.

A GrGen graph element

A type model for node or edge elements.

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 OnMatchedBeforeFiltering and OnMatchedAfterFiltering events. 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.

Represents a named entity/type that may be contained in a package. (Packages were added late during development, with the constraint to stay compatible, and intentionally as 2nd class citizens, confined to one nesting level, and without explicit object representing them.) ("Overrides" by "new" in inherited interfaces are for comment refinement only.)

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, i.e. node classes.

An interface representing a rule or sequence or procedure or function or filter invocation.

A GrGen object (value of internal, non-node/edge class)

A type model for objects (internal non graph-element values), i.e. classes.

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 sequence construct that allows to match patterns (most also allow to rewrite them). Utilized in begin and end events to tell about the construct that started or ended; to be type checked against the concrete construct as needed, e.g. SequenceExpressionRuleQuery or SequenceMultiRuleAllCall from interpreted sequences, or PatternMatchingConstruct from compiled sequences.

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).

A Sequence Base with a Special flag.

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 GrGen transient object (value of internal, non-node/edge class)

A type model for transient objects (internal non graph-element values), i.e. classes.

An interface to be implemented by classes whose objects are InheritanceType-typed

A type model for nodes or edges or objects or transient objects (of node classes, edge classes, internal classes, internal transient classes).

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 when execution of a pattern matching construct begins.

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 of 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 just before an object 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 execution of a pattern matching construct ends.

Represents a method called when a loop iteration is ended.

Represents a method called directly after a sequence base has been entered (sequence base comprises sequences, sequence computations, sequence expressions).

Represents a method called before a sequence base is left (sequence base comprises sequences, sequence computations, sequence expressions).

Represents a method called after the rewrite step of a rule or multi construct.

Represents a method called after the selected match was rewritten.

Represents a method called directly after sequences have joined (again) their parent thread.

Represents a method called after all requested matches of a multi action or action have been matched, after filtering (single element arrays in case of a single rule/test application).

Represents a method called after all requested matches of a multi action or an action have been matched, before filtering (single element array in case of a single rule/test application).

Represents a method called when a match has been selected for execution.

Represents a method called, when a node has been added.

Represents a method called, when an object has been created.

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 before the selected match is rewritten (comparable to the old BeforeFinishHandler and RewriteNextMatchHandler, now one event, fired per selected match).

Represents a method called after the selected match was rewritten (but before embedded execs/emits are executed).

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 after sequences have been spawned (split off) from their parent thread.

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 call issue.

Specifies the kind of call parameter issue.

Specifies the kind of the name definition.

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 sequence parts: 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 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.