/// <summary>
/// Search program operations implementing the
/// ActionPreset search plan operation
/// are created and inserted into search program
/// </summary>
private SearchProgramOperation buildActionPreset(
SearchProgramOperation insertionPoint,
int currentOperationIndex,
SearchPlanNode target,
IsomorphyInformation isomorphy)
{
bool isNode = target.NodeType == PlanNodeType.Node;
string negativeIndependentNamePrefix = NegativeIndependentNamePrefix(patternGraphWithNestingPatterns.Peek());
Debug.Assert(negativeIndependentNamePrefix == "", "Top-level maybe preset in negative/independent search plan");
Debug.Assert(programType != SearchProgramType.Subpattern, "Maybe preset in subpattern");
Debug.Assert(programType != SearchProgramType.AlternativeCase, "Maybe preset in alternative");
Debug.Assert(programType != SearchProgramType.Iterated, "Maybe preset in iterated");
// get candidate from inputs
GetCandidateByDrawing fromInputs =
new GetCandidateByDrawing(
GetCandidateByDrawingType.FromInputs,
target.PatternElement.Name,
isNode);
insertionPoint = insertionPoint.Append(fromInputs);
// check type of candidate
insertionPoint = decideOnAndInsertCheckType(insertionPoint, target);
// check candidate for isomorphy
if (isomorphy.CheckIsMatchedBit)
{
CheckCandidateForIsomorphy checkIsomorphy =
new CheckCandidateForIsomorphy(
target.PatternElement.Name,
isomorphy.PatternElementsToCheckAgainstAsListOfStrings(),
negativeIndependentNamePrefix,
isNode,
isoSpaceNeverAboveMaxIsoSpace,
isomorphy.Parallel,
isomorphy.LockForAllThreads);
insertionPoint = insertionPoint.Append(checkIsomorphy);
}
// accept candidate (write isomorphy information)
if (isomorphy.SetIsMatchedBit)
{
AcceptCandidate acceptCandidate =
new AcceptCandidate(
target.PatternElement.Name,
negativeIndependentNamePrefix,
isNode,
isoSpaceNeverAboveMaxIsoSpace,
isomorphy.Parallel,
isomorphy.LockForAllThreads);
insertionPoint = insertionPoint.Append(acceptCandidate);
}
// mark element as visited
target.Visited = true;
//---------------------------------------------------------------------------
// build next operation
insertionPoint = BuildScheduledSearchPlanOperationIntoSearchProgram(
currentOperationIndex + 1,
insertionPoint);
//---------------------------------------------------------------------------
// unmark element for possibly following run
target.Visited = false;
// abandon candidate (restore isomorphy information)
if (isomorphy.SetIsMatchedBit)
{ // only if isomorphy information was previously written
AbandonCandidate abandonCandidate =
new AbandonCandidate(
target.PatternElement.Name,
negativeIndependentNamePrefix,
isNode,
isoSpaceNeverAboveMaxIsoSpace,
isomorphy.Parallel,
isomorphy.LockForAllThreads);
insertionPoint = insertionPoint.Append(abandonCandidate);
}
return insertionPoint;
}
/// <summary>
/// Search program operations implementing the
/// ParallelPresetVar search plan operation
/// are created and inserted into search program
/// </summary>
private SearchProgramOperation buildParallelPresetVar(
SearchProgramOperation insertionPoint,
int currentOperationIndex,
PatternVariable target)
{
// get candidate from parallelization preset
GetCandidateByDrawing fromInputs =
new GetCandidateByDrawing(
GetCandidateByDrawingType.FromParallelizationTaskVar,
target.Name,
TypesHelper.TypeName(target.Type));
insertionPoint = insertionPoint.Append(fromInputs);
//---------------------------------------------------------------------------
// build next operation
insertionPoint = BuildScheduledSearchPlanOperationIntoSearchProgram(
currentOperationIndex + 1,
insertionPoint);
//---------------------------------------------------------------------------
return insertionPoint;
}
/// <summary>
/// Inserts code to get an implicit node from an edge
/// </summary>
private SearchProgramOperation insertImplicitNodeFromEdge(
SearchProgramOperation insertionPoint,
SearchPlanEdgeNode edge,
SearchPlanNodeNode currentNode,
ImplicitNodeType nodeType,
out SearchProgramOperation continuationPoint)
{
continuationPoint = null;
GetCandidateByDrawing nodeFromEdge;
if (nodeType == ImplicitNodeType.Source || nodeType == ImplicitNodeType.Target)
{
nodeFromEdge = new GetCandidateByDrawing(
GetCandidateByDrawingType.NodeFromEdge,
currentNode.PatternElement.Name,
TypesHelper.XgrsTypeToCSharpTypeNodeEdge(model.NodeModel.Types[currentNode.PatternElement.TypeID].PackagePrefixedName),
edge.PatternElement.Name,
nodeType);
insertionPoint = insertionPoint.Append(nodeFromEdge);
}
else
{
Debug.Assert(nodeType != ImplicitNodeType.TheOther);
if (currentNodeIsSecondIncidentNodeOfEdge(currentNode, edge))
{
nodeFromEdge = new GetCandidateByDrawing(
GetCandidateByDrawingType.NodeFromEdge,
currentNode.PatternElement.Name,
TypesHelper.XgrsTypeToCSharpTypeNodeEdge(model.NodeModel.Types[currentNode.PatternElement.TypeID].PackagePrefixedName),
edge.PatternElement.Name,
edge.PatternEdgeSource == currentNode ? edge.PatternEdgeTarget.PatternElement.Name
: edge.PatternEdgeSource.PatternElement.Name,
ImplicitNodeType.TheOther);
insertionPoint = insertionPoint.Append(nodeFromEdge);
}
else // edge connects to first incident node
{
if (edge.PatternEdgeSource == edge.PatternEdgeTarget)
{
// reflexive edge without direction iteration as we don't want 2 matches
nodeFromEdge = new GetCandidateByDrawing(
GetCandidateByDrawingType.NodeFromEdge,
currentNode.PatternElement.Name,
TypesHelper.XgrsTypeToCSharpTypeNodeEdge(model.NodeModel.Types[currentNode.PatternElement.TypeID].PackagePrefixedName),
edge.PatternElement.Name,
ImplicitNodeType.Source);
insertionPoint = insertionPoint.Append(nodeFromEdge);
}
else
{
BothDirectionsIteration directionsIteration =
new BothDirectionsIteration(edge.PatternElement.Name);
directionsIteration.NestedOperationsList = new SearchProgramList(directionsIteration);
continuationPoint = insertionPoint.Append(directionsIteration);
insertionPoint = directionsIteration.NestedOperationsList;
nodeFromEdge = new GetCandidateByDrawing(
GetCandidateByDrawingType.NodeFromEdge,
currentNode.PatternElement.Name,
TypesHelper.XgrsTypeToCSharpTypeNodeEdge(model.NodeModel.Types[currentNode.PatternElement.TypeID].PackagePrefixedName),
edge.PatternElement.Name,
ImplicitNodeType.SourceOrTarget);
insertionPoint = insertionPoint.Append(nodeFromEdge);
}
}
}
if (continuationPoint == null)
continuationPoint = insertionPoint;
return insertionPoint;
}
/// <summary>
/// Search program operations implementing the
/// MapWithStorageDependent search plan operation
/// are created and inserted into search program
/// </summary>
private SearchProgramOperation buildMapWithStorageDependent(
SearchProgramOperation insertionPoint,
int currentOperationIndex,
SearchPlanNode source,
SearchPlanNode target,
StorageAccess storage,
StorageAccessIndex index,
IsomorphyInformation isomorphy)
{
bool isNode = target.NodeType == PlanNodeType.Node;
string negativeIndependentNamePrefix = NegativeIndependentNamePrefix(patternGraphWithNestingPatterns.Peek());
// storage muss ein container typ nach graph element sein, index muss ein elementarer typ sein
if(storage.Variable != null && index.Variable != null) ;// das kann hier nicht auftreten;
if(storage.Variable != null && index.GlobalVariable != null) ;// das kann hier nicht auftreten;
if(storage.Variable != null && index.Attribute != null) ;// neu
if(storage.Variable != null && index.GraphElement != null) ;// alt, siehe unten
if(storage.GlobalVariable != null && index.Variable != null) ;// das kann hier nicht auftreten;
if(storage.GlobalVariable != null && index.GlobalVariable != null) ;// das kann hier nicht auftreten;
if(storage.GlobalVariable != null && index.Attribute != null) ;// neu
if(storage.GlobalVariable != null && index.GraphElement != null) ;// neu
if(storage.Attribute != null && index.Variable != null) ;// neu
if(storage.Attribute != null && index.GlobalVariable != null) ;// neu
if(storage.Attribute != null && index.Attribute != null) ;// kann nicht auftreten, 2 abhängigkeiten
if(storage.Attribute != null && index.GraphElement != null) ;// kann nicht auftreten, 2 anhängigkeiten
// get candidate from storage-map, only creates variable to hold it, get is fused with check for map membership
GetCandidateByDrawing elementFromStorage =
new GetCandidateByDrawing(
GetCandidateByDrawingType.MapWithStorage,
target.PatternElement.Name,
source.PatternElement.Name,
storage.Variable.Name,
TypesHelper.GetStorageValueTypeName(storage.Variable.type),
isNode);
insertionPoint = insertionPoint.Append(elementFromStorage);
// check existence of candidate in storage map
CheckCandidateMapWithStorage checkElementInStorage =
new CheckCandidateMapWithStorage(
target.PatternElement.Name,
source.PatternElement.Name,
storage.Variable.Name,
TypesHelper.GetStorageKeyTypeName(storage.Variable.type),
isNode);
insertionPoint = insertionPoint.Append(checkElementInStorage);
// check type of candidate
insertionPoint = decideOnAndInsertCheckType(insertionPoint, target);
// check connectedness of candidate
SearchProgramOperation continuationPointAfterConnectednessCheck;
if(isNode)
{
insertionPoint = decideOnAndInsertCheckConnectednessOfNodeFromLookupOrPickOrMap(
insertionPoint, (SearchPlanNodeNode)target, out continuationPointAfterConnectednessCheck);
}
else
{
insertionPoint = decideOnAndInsertCheckConnectednessOfEdgeFromLookupOrPickOrMap(
insertionPoint, (SearchPlanEdgeNode)target, out continuationPointAfterConnectednessCheck);
}
if(continuationPointAfterConnectednessCheck == insertionPoint)
continuationPointAfterConnectednessCheck = null;
// check candidate for isomorphy
if(isomorphy.CheckIsMatchedBit)
{
CheckCandidateForIsomorphy checkIsomorphy =
new CheckCandidateForIsomorphy(
target.PatternElement.Name,
isomorphy.PatternElementsToCheckAgainstAsListOfStrings(),
negativeIndependentNamePrefix,
isNode,
isoSpaceNeverAboveMaxIsoSpace,
isomorphy.Parallel,
isomorphy.LockForAllThreads);
insertionPoint = insertionPoint.Append(checkIsomorphy);
}
// check candidate for global isomorphy
if(programType == SearchProgramType.Subpattern
|| programType == SearchProgramType.AlternativeCase
|| programType == SearchProgramType.Iterated)
{
if(!isomorphy.TotallyHomomorph)
{
CheckCandidateForIsomorphyGlobal checkIsomorphy =
new CheckCandidateForIsomorphyGlobal(
target.PatternElement.Name,
isomorphy.GloballyHomomorphPatternElementsAsListOfStrings(),
isNode,
isoSpaceNeverAboveMaxIsoSpace,
isomorphy.Parallel);
insertionPoint = insertionPoint.Append(checkIsomorphy);
}
}
// check candidate for pattern path isomorphy
if(patternGraphWithNestingPatterns.Peek().isPatternGraphOnPathFromEnclosingPatternpath)
{
CheckCandidateForIsomorphyPatternPath checkIsomorphy =
new CheckCandidateForIsomorphyPatternPath(
target.PatternElement.Name,
isNode,
patternGraphWithNestingPatterns.Peek().isPatternpathLocked,
getCurrentLastMatchAtPreviousNestingLevel());
insertionPoint = insertionPoint.Append(checkIsomorphy);
}
// accept candidate (write isomorphy information)
if(isomorphy.SetIsMatchedBit)
{
AcceptCandidate acceptCandidate =
new AcceptCandidate(
target.PatternElement.Name,
negativeIndependentNamePrefix,
isNode,
isoSpaceNeverAboveMaxIsoSpace,
isomorphy.Parallel,
isomorphy.LockForAllThreads);
insertionPoint = insertionPoint.Append(acceptCandidate);
}
// mark element as visited
target.Visited = true;
//---------------------------------------------------------------------------
// build next operation
insertionPoint = BuildScheduledSearchPlanOperationIntoSearchProgram(
currentOperationIndex + 1,
insertionPoint);
//---------------------------------------------------------------------------
// unmark element for possibly following run
target.Visited = false;
// abandon candidate (restore isomorphy information)
if(isomorphy.SetIsMatchedBit)
{ // only if isomorphy information was previously written
AbandonCandidate abandonCandidate =
new AbandonCandidate(
target.PatternElement.Name,
negativeIndependentNamePrefix,
isNode,
isoSpaceNeverAboveMaxIsoSpace,
isomorphy.Parallel,
isomorphy.LockForAllThreads);
insertionPoint = insertionPoint.Append(abandonCandidate);
}
if(continuationPointAfterConnectednessCheck != null)
insertionPoint = continuationPointAfterConnectednessCheck;
return insertionPoint;
}
/// <summary>
/// Search program operations implementing the
/// ParallelPreset search plan operation
/// are created and inserted into search program
/// </summary>
private SearchProgramOperation buildParallelPreset(
SearchProgramOperation insertionPoint,
int currentOperationIndex,
SearchPlanNode target)
{
bool isNode = target.NodeType == PlanNodeType.Node;
// get candidate from parallelization preset
GetCandidateByDrawing fromInputs =
new GetCandidateByDrawing(
GetCandidateByDrawingType.FromParallelizationTask,
target.PatternElement.Name,
isNode);
insertionPoint = insertionPoint.Append(fromInputs);
// mark element as visited
target.Visited = true;
//---------------------------------------------------------------------------
// build next operation
insertionPoint = BuildScheduledSearchPlanOperationIntoSearchProgram(
currentOperationIndex + 1,
insertionPoint);
//---------------------------------------------------------------------------
// unmark element for possibly following run
target.Visited = false;
return insertionPoint;
}
/// <summary>
/// Search program operations implementing the
/// Assign search plan operation
/// are created and inserted into search program
/// </summary>
private SearchProgramOperation buildAssign(
SearchProgramOperation insertionPoint,
int currentOperationIndex,
SearchPlanNode source,
SearchPlanNode target,
IsomorphyInformation isomorphy)
{
bool isNode = target.NodeType == PlanNodeType.Node;
string negativeIndependentNamePrefix = NegativeIndependentNamePrefix(patternGraphWithNestingPatterns.Peek());
// get candidate from other element (the cast is simply the following type check)
GetCandidateByDrawing fromOtherElementForAssign =
new GetCandidateByDrawing(
GetCandidateByDrawingType.FromOtherElementForAssign,
target.PatternElement.Name,
source.PatternElement.Name,
isNode);
insertionPoint = insertionPoint.Append(fromOtherElementForAssign);
// check type of candidate
insertionPoint = decideOnAndInsertCheckType(insertionPoint, target);
// check connectedness of candidate
SearchProgramOperation continuationPointAfterConnectednessCheck;
if(isNode)
{
insertionPoint = decideOnAndInsertCheckConnectednessOfNodeFromLookupOrPickOrMap(
insertionPoint, (SearchPlanNodeNode)target, out continuationPointAfterConnectednessCheck);
}
else
{
insertionPoint = decideOnAndInsertCheckConnectednessOfEdgeFromLookupOrPickOrMap(
insertionPoint, (SearchPlanEdgeNode)target, out continuationPointAfterConnectednessCheck);
}
// mark element as visited
target.Visited = true;
//---------------------------------------------------------------------------
// build next operation
insertionPoint = BuildScheduledSearchPlanOperationIntoSearchProgram(
currentOperationIndex + 1,
insertionPoint);
//---------------------------------------------------------------------------
// unmark element for possibly following run
target.Visited = false;
return insertionPoint;
}
/// <summary>
/// Search program operations implementing the
/// Cast search plan operation
/// are created and inserted into search program
/// </summary>
private SearchProgramOperation buildCast(
SearchProgramOperation insertionPoint,
int currentOperationIndex,
SearchPlanNode source,
SearchPlanNode target,
IsomorphyInformation isomorphy)
{
bool isNode = target.NodeType == PlanNodeType.Node;
string negativeIndependentNamePrefix = NegativeIndependentNamePrefix(patternGraphWithNestingPatterns.Peek());
// get candidate from other element (the cast is simply the following type check)
GetCandidateByDrawing fromOtherElementForCast =
new GetCandidateByDrawing(
GetCandidateByDrawingType.FromOtherElementForCast,
target.PatternElement.Name,
source.PatternElement.Name,
isNode);
insertionPoint = insertionPoint.Append(fromOtherElementForCast);
// check type of candidate
insertionPoint = decideOnAndInsertCheckType(insertionPoint, target);
// check connectedness of candidate
SearchProgramOperation continuationPointAfterConnectednessCheck;
if(isNode)
{
insertionPoint = decideOnAndInsertCheckConnectednessOfNodeFromLookupOrPickOrMap(
insertionPoint, (SearchPlanNodeNode)target, out continuationPointAfterConnectednessCheck);
}
else
{
insertionPoint = decideOnAndInsertCheckConnectednessOfEdgeFromLookupOrPickOrMap(
insertionPoint, (SearchPlanEdgeNode)target, out continuationPointAfterConnectednessCheck);
}
// check candidate for isomorphy
if(isomorphy.CheckIsMatchedBit)
{
CheckCandidateForIsomorphy checkIsomorphy =
new CheckCandidateForIsomorphy(
target.PatternElement.Name,
isomorphy.PatternElementsToCheckAgainstAsListOfStrings(),
negativeIndependentNamePrefix,
isNode,
isoSpaceNeverAboveMaxIsoSpace,
isomorphy.Parallel,
isomorphy.LockForAllThreads);
insertionPoint = insertionPoint.Append(checkIsomorphy);
}
// check candidate for global isomorphy
if(programType == SearchProgramType.Subpattern
|| programType == SearchProgramType.AlternativeCase
|| programType == SearchProgramType.Iterated)
{
if(!isomorphy.TotallyHomomorph)
{
CheckCandidateForIsomorphyGlobal checkIsomorphy =
new CheckCandidateForIsomorphyGlobal(
target.PatternElement.Name,
isomorphy.GloballyHomomorphPatternElementsAsListOfStrings(),
isNode,
isoSpaceNeverAboveMaxIsoSpace,
isomorphy.Parallel);
insertionPoint = insertionPoint.Append(checkIsomorphy);
}
}
// check candidate for pattern path isomorphy
if(patternGraphWithNestingPatterns.Peek().isPatternGraphOnPathFromEnclosingPatternpath)
{
CheckCandidateForIsomorphyPatternPath checkIsomorphy =
new CheckCandidateForIsomorphyPatternPath(
target.PatternElement.Name,
isNode,
patternGraphWithNestingPatterns.Peek().isPatternpathLocked,
getCurrentLastMatchAtPreviousNestingLevel());
insertionPoint = insertionPoint.Append(checkIsomorphy);
}
// accept candidate (write isomorphy information)
if(isomorphy.SetIsMatchedBit)
{
AcceptCandidate acceptCandidate =
new AcceptCandidate(
target.PatternElement.Name,
negativeIndependentNamePrefix,
isNode,
isoSpaceNeverAboveMaxIsoSpace,
isomorphy.Parallel,
isomorphy.LockForAllThreads);
insertionPoint = insertionPoint.Append(acceptCandidate);
}
// mark element as visited
target.Visited = true;
//---------------------------------------------------------------------------
// build next operation
insertionPoint = BuildScheduledSearchPlanOperationIntoSearchProgram(
currentOperationIndex + 1,
insertionPoint);
//---------------------------------------------------------------------------
// unmark element for possibly following run
target.Visited = false;
// abandon candidate (restore isomorphy information)
if(isomorphy.SetIsMatchedBit)
{ // only if isomorphy information was previously written
AbandonCandidate abandonCandidate =
new AbandonCandidate(
target.PatternElement.Name,
negativeIndependentNamePrefix,
isNode,
isoSpaceNeverAboveMaxIsoSpace,
isomorphy.Parallel,
isomorphy.LockForAllThreads);
insertionPoint = insertionPoint.Append(abandonCandidate);
}
return insertionPoint;
}
/// <summary>
/// Search program operations implementing the
/// PickByUnique or PickByUniqueDependent search plan operation
/// are created and inserted into search program
/// </summary>
private SearchProgramOperation buildPickByUnique(
SearchProgramOperation insertionPoint,
int currentOperationIndex,
SearchPlanNode target,
UniqueLookup uniqueLookup,
IsomorphyInformation isomorphy)
{
bool isNode = target.NodeType == PlanNodeType.Node;
string negativeIndependentNamePrefix = NegativeIndependentNamePrefix(patternGraphWithNestingPatterns.Peek());
SourceBuilder expression = new SourceBuilder();
uniqueLookup.Expr.Emit(expression);
// get candidate from unique index, only creates variable to hold it, get is fused with check for index membership
GetCandidateByDrawing elementByUnique =
new GetCandidateByDrawing(
GetCandidateByDrawingType.MapByUnique,
target.PatternElement.Name,
expression.ToString(),
isNode);
insertionPoint = insertionPoint.Append(elementByUnique);
// check existence of candidate in unique map
CheckCandidateMapByUnique checkElementInUniqueMap =
new CheckCandidateMapByUnique(
target.PatternElement.Name,
isNode);
insertionPoint = insertionPoint.Append(checkElementInUniqueMap);
// check type of candidate
insertionPoint = decideOnAndInsertCheckType(insertionPoint, target);
// check connectedness of candidate
SearchProgramOperation continuationPointAfterConnectednessCheck;
if(isNode)
{
insertionPoint = decideOnAndInsertCheckConnectednessOfNodeFromLookupOrPickOrMap(
insertionPoint, (SearchPlanNodeNode)target, out continuationPointAfterConnectednessCheck);
}
else
{
insertionPoint = decideOnAndInsertCheckConnectednessOfEdgeFromLookupOrPickOrMap(
insertionPoint, (SearchPlanEdgeNode)target, out continuationPointAfterConnectednessCheck);
}
if(continuationPointAfterConnectednessCheck == insertionPoint)
continuationPointAfterConnectednessCheck = null;
// check candidate for isomorphy
if(isomorphy.CheckIsMatchedBit)
{
CheckCandidateForIsomorphy checkIsomorphy =
new CheckCandidateForIsomorphy(
target.PatternElement.Name,
isomorphy.PatternElementsToCheckAgainstAsListOfStrings(),
negativeIndependentNamePrefix,
isNode,
isoSpaceNeverAboveMaxIsoSpace,
isomorphy.Parallel,
isomorphy.LockForAllThreads);
insertionPoint = insertionPoint.Append(checkIsomorphy);
}
// check candidate for global isomorphy
if(programType == SearchProgramType.Subpattern
|| programType == SearchProgramType.AlternativeCase
|| programType == SearchProgramType.Iterated)
{
if(!isomorphy.TotallyHomomorph)
{
CheckCandidateForIsomorphyGlobal checkIsomorphy =
new CheckCandidateForIsomorphyGlobal(
target.PatternElement.Name,
isomorphy.GloballyHomomorphPatternElementsAsListOfStrings(),
isNode,
isoSpaceNeverAboveMaxIsoSpace,
isomorphy.Parallel);
insertionPoint = insertionPoint.Append(checkIsomorphy);
}
}
// check candidate for pattern path isomorphy
if(patternGraphWithNestingPatterns.Peek().isPatternGraphOnPathFromEnclosingPatternpath)
{
CheckCandidateForIsomorphyPatternPath checkIsomorphy =
new CheckCandidateForIsomorphyPatternPath(
target.PatternElement.Name,
isNode,
patternGraphWithNestingPatterns.Peek().isPatternpathLocked,
getCurrentLastMatchAtPreviousNestingLevel());
insertionPoint = insertionPoint.Append(checkIsomorphy);
}
// accept candidate (write isomorphy information)
if(isomorphy.SetIsMatchedBit)
{
AcceptCandidate acceptCandidate =
new AcceptCandidate(
target.PatternElement.Name,
negativeIndependentNamePrefix,
isNode,
isoSpaceNeverAboveMaxIsoSpace,
isomorphy.Parallel,
isomorphy.LockForAllThreads);
insertionPoint = insertionPoint.Append(acceptCandidate);
}
// mark element as visited
target.Visited = true;
//---------------------------------------------------------------------------
// build next operation
insertionPoint = BuildScheduledSearchPlanOperationIntoSearchProgram(
currentOperationIndex + 1,
insertionPoint);
//---------------------------------------------------------------------------
// unmark element for possibly following run
target.Visited = false;
// abandon candidate (restore isomorphy information)
if(isomorphy.SetIsMatchedBit)
{ // only if isomorphy information was previously written
AbandonCandidate abandonCandidate =
new AbandonCandidate(
target.PatternElement.Name,
negativeIndependentNamePrefix,
isNode,
isoSpaceNeverAboveMaxIsoSpace,
isomorphy.Parallel,
isomorphy.LockForAllThreads);
insertionPoint = insertionPoint.Append(abandonCandidate);
}
if(continuationPointAfterConnectednessCheck != null)
insertionPoint = continuationPointAfterConnectednessCheck;
return insertionPoint;
}
/// <summary>
/// Search program operations implementing the
/// SubPreset search plan operation
/// are created and inserted into search program
/// </summary>
private SearchProgramOperation buildSubPreset(
SearchProgramOperation insertionPoint,
int currentOperationIndex,
SearchPlanNode target,
IsomorphyInformation isomorphy)
{
bool isNode = target.NodeType == PlanNodeType.Node;
string negativeIndependentNamePrefix = NegativeIndependentNamePrefix(patternGraphWithNestingPatterns.Peek());
Debug.Assert(negativeIndependentNamePrefix == "", "Top-level subpattern preset in negative/independent search plan");
// get candidate from inputs
GetCandidateByDrawing fromInputs =
new GetCandidateByDrawing(
GetCandidateByDrawingType.FromSubpatternConnections,
target.PatternElement.Name,
isNode);
insertionPoint = insertionPoint.Append(fromInputs);
// mark element as visited
target.Visited = true;
//---------------------------------------------------------------------------
// build next operation
insertionPoint = BuildScheduledSearchPlanOperationIntoSearchProgram(
currentOperationIndex + 1,
insertionPoint);
//---------------------------------------------------------------------------
// unmark element for possibly following run
target.Visited = false;
return insertionPoint;
}
/// <summary>
/// Search program operations implementing the
/// NegIdptPreset search plan operation
/// are created and inserted into search program
/// </summary>
private SearchProgramOperation buildNegIdptPreset(
SearchProgramOperation insertionPoint,
int currentOperationIndex,
SearchPlanNode target,
IsomorphyInformation isomorphy)
{
bool isNode = target.NodeType == PlanNodeType.Node;
string negativeIndependentNamePrefix = NegativeIndependentNamePrefix(patternGraphWithNestingPatterns.Peek());
Debug.Assert(negativeIndependentNamePrefix != "", "Negative/Independent preset in top-level search plan");
// an inlined independet preset is differently named, must be assigned first
if(target.PatternElement.PresetBecauseOfIndependentInlining)
{
// get candidate from other element (the cast is simply the following type check)
GetCandidateByDrawing inlinedIndependentPreset =
new GetCandidateByDrawing(
GetCandidateByDrawingType.FromOtherElementForAssign,
target.PatternElement.Name,
target.PatternElement.Name + "_inlined_" + patternGraphWithNestingPatterns.Peek().Name,
isNode);
insertionPoint = insertionPoint.Append(inlinedIndependentPreset);
}
// check candidate for isomorphy
if (isomorphy.CheckIsMatchedBit)
{
CheckCandidateForIsomorphy checkIsomorphy =
new CheckCandidateForIsomorphy(
target.PatternElement.Name,
isomorphy.PatternElementsToCheckAgainstAsListOfStrings(),
negativeIndependentNamePrefix,
isNode,
isoSpaceNeverAboveMaxIsoSpace,
isomorphy.Parallel,
isomorphy.LockForAllThreads);
insertionPoint = insertionPoint.Append(checkIsomorphy);
}
// accept candidate (write isomorphy information)
if (isomorphy.SetIsMatchedBit)
{
AcceptCandidate acceptCandidate =
new AcceptCandidate(
target.PatternElement.Name,
negativeIndependentNamePrefix,
isNode,
isoSpaceNeverAboveMaxIsoSpace,
isomorphy.Parallel,
isomorphy.LockForAllThreads);
insertionPoint = insertionPoint.Append(acceptCandidate);
}
// mark element as visited
target.Visited = true;
//---------------------------------------------------------------------------
// build next operation
insertionPoint = BuildScheduledSearchPlanOperationIntoSearchProgram(
currentOperationIndex + 1,
insertionPoint);
//---------------------------------------------------------------------------
// unmark element for possibly following run
target.Visited = false;
// abandon candidate (restore isomorphy information)
if (isomorphy.SetIsMatchedBit)
{ // only if isomorphy information was previously written
AbandonCandidate abandonCandidate =
new AbandonCandidate(
target.PatternElement.Name,
negativeIndependentNamePrefix,
isNode,
isoSpaceNeverAboveMaxIsoSpace,
isomorphy.Parallel,
isomorphy.LockForAllThreads);
insertionPoint = insertionPoint.Append(abandonCandidate);
}
return insertionPoint;
}
