| | Class | Description |
|---|
 | Alternative |
An alternative is a pattern graph element containing subpatterns
of which one must get successfully matched so that the entire pattern gets matched successfully.
|
| Alternatives_Enumerable |
enumerable returning enumerator over submatches due to alternatives
|
| Alternatives_Enumerator |
enumerator over submatches due to alternatives
|
| ConnectednessCheck | |
| Edges_Enumerable |
enumerable returning enumerator over edges in match
|
| Edges_Enumerator |
enumerator over edges in match
|
| EmbeddedGraphs_Enumerable |
enumerable returning enumerator over submatches due to subpatterns
|
| EmbeddedGraphs_Enumerator |
enumerator over submatches due to subpatterns
|
| FilterGenerator |
The C#-part responsible for generating the post-matches filters.
|
| FoundMatch |
A helper class containing a match found by iteration plan execution
|
| GlobalVariableAccess |
Representation of a global variable accessed from within a pattern (match from storage constructs)
|
| GraphMatchingState |
Helper class with stuff needed for IsIsomorph checking of graphs
|
| GraphStatisticsParserSerializer |
A class for serializing and parsing the statistics from a graph (cf. LGSPGraphStatistics)
|
| Independents_Enumerable |
enumerable returning enumerator over submatches due to independents
|
| Independents_Enumerator |
enumerator over submatches due to independents
|
| IndexAccess |
Base class for index accesses, used to bind a pattern element from an index.
|
| IndexAccessAscending |
Representation of an index access, accessed by enumerating ascendingly.
|
| IndexAccessDescending |
Representation of an index access, accessed by enumerating descendingly.
|
| IndexAccessEquality |
Representation of an index access, accessed by enumerating equal keys.
|
| InterpretationPlan |
Base class of the interpretation plan data structure,
which consists of a linked list of matching operations
(Benefits compared to scheduled search plan:
- stores matched graph elements
- connectedness checking with bidirectional matching is complicated enough it should be computed statically before execution)
The interpretation plan is only used in isomorphy checking.
|
| InterpretationPlanBothDirections |
Interpretation plan operation that iterates both directions,
needed for matching bidirectional edges in both directions
|
| InterpretationPlanBuilder |
A class for building the interpretation plan data structure from a scheduled search plan
|
| InterpretationPlanCheckCondition |
Interpretation plan operation that checks the AreAttribuesEqual condition
|
| InterpretationPlanCheckConnectednessSource |
Interpretation plan operation that checks the source node of an edge to be identical to a given node
|
| InterpretationPlanCheckConnectednessSourceOrTarget |
Interpretation plan operation that checks the source or target node of an edge to be identical to a given node,
depending on the current direction to be matched
|
| InterpretationPlanCheckConnectednessTarget |
Interpretation plan operation that checks the target node of an edge to be identical to a given node
|
| InterpretationPlanCheckConnectednessTheOther |
Interpretation plan operation that checks the source or target node of an edge to be identical to a given node,
depending on the other node already matched
|
| InterpretationPlanDirectionVariable |
An interpretation plan operation that stores a direction decision
|
| InterpretationPlanEdgeMatcher |
An interpretation plan operation that matches an edge
|
| InterpretationPlanImplicitSource |
Interpretation plan operation that retrieves the source node of an edge
|
| InterpretationPlanImplicitSourceOrTarget |
Interpretation plan operation that retrieves the source or target node of an edge
depending on the current direction to be matched
|
| InterpretationPlanImplicitTarget |
Interpretation plan operation that retrieves the target node of an edge
|
| InterpretationPlanImplicitTheOther |
Interpretation plan operation that retrieves the source or target node of an edge
depending on the other node already matched
|
| InterpretationPlanIncoming |
Interpretation plan operation that retrieves an incoming edge from a source node
|
| InterpretationPlanIncomingOrOutgoing |
Interpretation plan operation that retrieves an edge to be matched bidirectionally from a source node
|
| InterpretationPlanLookupEdge |
Interpretation plan operation that looks up an edge in the graph
|
| InterpretationPlanLookupNode |
Interpretation plan operation that looks up a node in the graph
|
| InterpretationPlanMatchComplete |
Interpretation plan operation that completes a match;
no own functionality, it just succeeds when execution reaches it
|
| InterpretationPlanNodeMatcher |
An interpretation plan operation that matches a node
|
| InterpretationPlanOutgoing |
Interpretation plan operation that retrieves an outgoing edge from a source node
|
| InterpretationPlanStart |
Interpretation plan operation that works as an anchor for an interpretation plan without own functionality
|
| IsomorphyInformation | |
| Iterated |
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
|
| Iterateds_Enumerable |
enumerable returning enumerator over submatches due to iterateds,
with every submatch being a list of matches of the iterated-pattern
|
| Iterateds_Enumerator |
enumerator over submatches due to iterateds,
with every submatch being a list of matches of the iterated-pattern
|
| LGSPAction |
An object representing an executable rule of the LGSPBackend.
|
| LGSPActionExecutionEnvironment |
An implementation of the IGraphProcessingEnvironment, to be used with LGSPGraphs.
|
| LGSPActions |
A container of rules also managing some parts of rule application with sequences.
Abstract base class with empty actions, the derived classes fill the actions dictionary.
|
| LGSPBackend |
A helper class for backend independent graph and rule handling.
|
| LGSPDeferredSequencesManager |
A class for managing deferred sequence execution.
|
| LGSPEdge |
Class implementing edges in the libGr search plan backend
|
| LGSPEdgeHead |
Special head edge of the lists containing all the edges of one type
|
| LGSPEmbeddedSequenceClosure |
A closure for an exec statement in an alternative, iterated or subpattern,
containing the entities needed for the exec execution.
These exec are executed at the end of the rule which directly or indirectly used them,
long after the alternative/iterated/subpattern modification containing them has been applied.
The real stuff depends on the xgrs and is generated, implementing this abstract class.
|
| LGSPFilter |
A description of a filter of a rule or match class
|
| LGSPFilterAutoGenerated |
A description of an auto-generated filter of a rule or match class
|
| LGSPFilterAutoSupplied |
A description of an auto-supplied filter of a rule or match class.
|
| LGSPFilterFunction |
A description of a filter function of a rule or match class
|
| LGSPGlobalVariables |
An implementation of the IGlobalVariables, to be used with LGSPGraphProcessingEnvironments.
|
| LGSPGraph |
An implementation of the IGraph interface.
|
| LGSPGraphModel |
A model of a GrGen graph, base class from implementation.
Defines a thin layer above IGraphModel, enriched with index creating functionality, the real stuff is generated.
It allows the generic LGSPGraph to create and bind the index set when it is configured with the graph model.
|
| LGSPGraphProcessingEnvironment |
An implementation of the IGraphProcessingEnvironment, to be used with LGSPGraphs.
|
| LGSPGraphStatistics |
A class for analyzing a graph and storing the statistics about the graph
|
| LGSPGrGen |
The C#-part of the GrGen.NET frontend.
It is responsible for generating initial actions with static search plans.
(and compiling the XGRSs of the exec statements vie LGSPSequenceGenerator)
|
| LGSPMatcherGenerator |
Class generating matcher programs out of rules.
A PatternGraphAnalyzer must run before the matcher generator is used,
so that the analysis data is written the pattern graphs of the matching patterns to generate code for.
|
| LGSPMatchesListMatch, MatchInterface |
An object representing a (possibly empty) set of matches in a graph before the rewrite has been applied.
It is returned by IAction.Match() and given to the OnMatched, OnPreMatched, OnFinishing and OnFinished event.
Generic to be instantiated with the exact interface and the exact implementation type of the match object
Every generated Action contains a LGSPMatchesList,
the matches contain one LGSPMatchesList per iterated pattern.
A matches list stores the matches found by the last application of the action,
the matches objects within the list are recycled by the next application of the action,
only their content gets updated.
The purpose of this list is to act as a memory manager
to save new/garbage collection cycles and improve cache footprint.
Additionally this list is used for storing the results of an iteration in the matches objects, Producer being null in this case.
Then it is just used as a container for already allocated elements.
|
| LGSPMatchingPattern |
A description of a GrGen matching pattern, that's a subpattern/subrule or the base for some rule.
|
| LGSPNamedGraph |
An implementation of the INamedGraph interface.
|
| LGSPNode |
Class implementing nodes in the libGr search plan backend
|
| LGSPNodeHead |
Special head node of the lists containing all the nodes of one type
|
| LGSPObject |
Class implementing objects in the libGr search plan backend (values of internal non-node/edge classes)
|
| LGSPRuleAndMatchingPatterns |
Class which instantiates and stores all the rule and subpattern representations ready for iteration
|
| LGSPRulePattern |
A description of a GrGen rule.
|
| LGSPSequenceGenerator |
The C#-part responsible for compiling the XGRSs of the exec statements.
|
| LGSPSubactionAndOutputAdditionEnvironment |
An implementation of the ISubactionAndOutputAdditionEnvironment, to be used with LGSPGraphs.
|
| LGSPSubpatternAction |
Abstract base class for generated subpattern matching actions
each object of an inheriting class represents a subpattern matching tasks
which might be stored on the open tasks stack and executed later on.
In addition to user-specified subpatterns, alternatives are mapped to subpattern actions, too.
|
| LGSPTransactionManager |
A class for managing graph transactions.
|
| LGSPTransientObject |
Class implementing transient objects in the libGr search plan backend (values of internal non-node/edge classes)
|
| LGSPUndoAttributeChanged | |
| LGSPUndoElemAdded | |
| LGSPUndoElemRedirecting | |
| LGSPUndoElemRemoved | |
| LGSPUndoElemRetyped | |
| LGSPUndoGraphChange | |
| LGSPUndoSettingVisited | |
| LGSPUndoTransactionStarted | |
| LGSPUndoVisitedAlloc | |
| LGSPUndoVisitedFree | |
| LGSPUniquenessEnsurer |
A class ensuring unique ids for nodes and edges with a minimum amount of gaps.
Gets instantiated in case support for unique nodes/edges was declared in the model.
|
| LGSPUniquenessIndex |
A class ensuring unique ids for nodes and edges with a minimum amount of gaps,
and allowing to access them by their unique id, similar to an index (and esp. the name map).
Gets instantiated in case support for unique nodes/edges was declared in the model,
and support for accessing nodes/edges by a unique id.
|
| MatchListElementT |
Element of invasively linked list of T, and Match
|
| NameLookup |
Representation of a name map lookup.
|
| NeededEntitiesEmitter |
Class for emitting the needed entities of a sequence, in a pre-run before emitting the real code (by the SequenceGenerator).
|
| Nodes_Enumerable |
enumerable returning enumerator over nodes in match
|
| Nodes_Enumerator |
enumerator over nodes in match
|
| PairS, T | |
| PatternCondition |
Representation of some condition which must be true for the pattern containing it to be matched
|
| PatternEdge |
A pattern edge of a rule pattern.
|
| PatternElement |
An element of a rule pattern.
|
| PatternGraph |
Representation of the pattern to search for,
containing nested alternative, iterated, negative, and independent-patterns,
plus references to the rules of the used subpatterns.
Accessible via IPatternGraph as meta information to the user about the matching action.
Skeleton data structure for the matcher generation pipeline which stores intermediate results here,
which saves us from representing the nesting structure again and again in the pipeline's data structures
|
| PatternGraphAnalyzer |
Class analyzing the pattern graphs of the matching patterns to generate code for,
storing computed nesting and inter-pattern-relationships locally in the pattern graphs,
ready to be used by the (local intra-pattern) code generator
(to generate code more easily, to generate better code).
|
| PatternGraphEmbedding |
Embedding of a subpattern into it's containing pattern
|
| PatternNode |
A pattern node of a rule pattern.
|
| PatternpathIsomorphyChecker |
Class containing global functions for checking whether node/edge is matched on patternpath
|
| PatternVariable |
A pattern variable of a rule pattern.
|
| PatternYielding |
Representation of some yielding (a list of elementary yieldings, to be executed after matching completed)
|
| PlanEdge |
A plan edge represents a matching operation and its costs.
|
| PlanGraph |
The plan graph data structure for the MSA-algorithm.
|
| PlanGraphGenerator |
Class for generating a plan graph out of a pattern graph.
|
| PlanNode |
Element of the plan graph representing a node or edge within the pattern graph or a root node.
|
| PlanPseudoNode |
Common base class for the PlanNodes and PlanSuperNodes,
used for uniform access to the derived nodes within the minimum spanning arborescent computation.
|
| PlanSuperNode |
Element of the plan graph representing a strongly connected component within the pattern graph.
Hierachically nested.
|
| PriorityQueueT | |
| QualificationAccess |
Representation of an owner.attribute qualification
|
| ScheduledSearchPlan |
The scheduled search plan is a list of search operations,
plus the information which nodes/edges are homomorph
|
| ScheduleDumper | |
| ScheduleEnricher |
Class enriching schedules with homomorphy information,
merging negative and independent schedules into the main schedule,
and parallelizing schedules.
|
| ScheduleExplainer | |
| SearchOperation |
Search operation with information about homomorphic mapping.
Element of the scheduled search plan.
|
| SearchPlanEdge |
A search plan edge represents a matching operation and its costs.
|
| SearchPlanEdgeNode |
Element of the search plan graph representing an edge within the pattern graph.
|
| SearchPlanGraph |
The search plan graph data structure for scheduling.
|
| SearchPlanGraphGeneratorAndScheduler |
Class for generating a search plan graph out of a plan graph and for creating a schedule out of it.
|
| SearchPlanNode |
Element of the search plan graph representing an element within the pattern graph or a root node.
|
| SearchPlanNodeNode |
Element of the search plan graph representing a node within the pattern graph.
|
| SequenceComputationGenerator |
The sequence computation generator contains code to generate sequence computations;
it is in use by the sequence generator.
|
| SequenceComputationGeneratorHelper |
The sequence computation generator helper contains code for (sequence/sequence computation) result variable handling.
|
| SequenceContainerConstructorEmitter |
The C#-part responsible for emitting the container constructor expressions that appear in an exec statement, in a post-run after generating the sequence.
|
| SequenceExpressionGenerator |
The sequence expression generator contains code to generate a sequence expression,
it is in use by the sequence computation generator and the sequence generator,
and also called by the sequence generator helper.
|
| SequenceExpressionGeneratorHelper |
The sequence expression generator helper generates the code for the sequence expression operators,
in case the (result) type is known statically (same semantics as calling the SequenceExpressionExecutionHelper, but faster due to statically known types).
|
| SequenceGenerator |
The sequence generator contains code to generate sequences, the sequence trees to be more precise,
it is used by the lgsp sequence generator driver, emitting sequence heads and surrounding code.
|
| SequenceGeneratorHelper |
The sequence generator helper contains miscellaneous code in use by the
sequence generator, sequence computation generator, and sequence expression generator.
It esp. contains parameter type information and code for parameter building, as well as type computation, variable access and constant generation.
|
| SimpleGraphCanonizer | |
| SourceBuilder |
Pretty printing helper class for source code generation
|
| StorageAccess |
Representation of a storage access, used to bind a pattern element.
|
| StorageAccessIndex |
Representation of a storage access index, used to bind a pattern element.
|
| ThreadPool |
A thread pool for parallel sequence execution
|
| UniqueLookup |
Representation of a unique index lookup.
|
| Variables_Enumerable |
enumerable returning enumerator over variables in match
|
| Variables_Enumerator |
enumerator over variables in match
|
| WorkerPool |
A thread pool of workers for parallelized pattern matching
|
Classes
