/// <summary>
/// Search program operations implementing the
/// Independent search plan operation (searching of positive application condition)
/// are created and inserted into search program
/// </summary>
private SearchProgramOperation buildIndependent(
SearchProgramOperation insertionPoint,
int currentOperationIndex,
PatternGraph independentPatternGraph)
{
// fill needed elements array for CheckPartialMatchByIndependent
string[] neededElements = ComputeNeededElements(independentPatternGraph);
CheckPartialMatchByIndependent checkIndependent =
new CheckPartialMatchByIndependent(neededElements);
SearchProgramOperation continuationPoint =
insertionPoint.Append(checkIndependent);
checkIndependent.NestedOperationsList =
new SearchProgramList(checkIndependent);
insertionPoint = checkIndependent.NestedOperationsList;
bool enclosingIsNegative = isNegative;
isNegative = false;
PatternGraph enclosingPatternGraph = patternGraphWithNestingPatterns.Peek();
patternGraphWithNestingPatterns.Push(independentPatternGraph);
isoSpaceNeverAboveMaxIsoSpace = patternGraphWithNestingPatterns.Peek().maxIsoSpace < (int)LGSPElemFlags.MAX_ISO_SPACE;
bool parallelizedBak = parallelized;
parallelized &= patternGraphWithNestingPatterns.Peek().parallelizedSchedule != null; // the idpt within a parallelized head may be non-parallelized
int indexOfScheduleBak = indexOfSchedule;
if(parallelized) indexOfSchedule = 0; // the idpt of a parallelized body at index 1 is still only at index 0
string independentNamePrefix = NegativeIndependentNamePrefix(patternGraphWithNestingPatterns.Peek());
bool independentContainsSubpatterns = independentPatternGraph.embeddedGraphsPlusInlined.Length >= 1
|| independentPatternGraph.alternativesPlusInlined.Length >= 1
|| independentPatternGraph.iteratedsPlusInlined.Length >= 1;
InitializeNegativeIndependentMatching initIdpt = new InitializeNegativeIndependentMatching(
independentContainsSubpatterns,
independentNamePrefix,
isoSpaceNeverAboveMaxIsoSpace,
parallelized);
insertionPoint = insertionPoint.Append(initIdpt);
insertionPoint = insertVariableDeclarationsNegIdpt(insertionPoint, independentPatternGraph);
//---------------------------------------------------------------------------
// build independent pattern
insertionPoint = BuildScheduledSearchPlanOperationIntoSearchProgram(
0,
insertionPoint);
//---------------------------------------------------------------------------
FinalizeNegativeIndependentMatching finalize = new FinalizeNegativeIndependentMatching(
isoSpaceNeverAboveMaxIsoSpace, parallelized);
insertionPoint = insertionPoint.Append(finalize);
// independent pattern built by now
// continue at the end of the list handed in
insertionPoint = continuationPoint;
// the matcher program of independent didn't find a match,
// we fell through the loops and reached this point -> abort the matching process / try next candidate
CheckContinueMatchingOfIndependentFailed abortMatching =
new CheckContinueMatchingOfIndependentFailed(checkIndependent, independentPatternGraph.isIterationBreaking);
checkIndependent.CheckIndependentFailed = abortMatching;
insertionPoint = insertionPoint.Append(abortMatching);
patternGraphWithNestingPatterns.Pop();
parallelized = parallelizedBak;
indexOfSchedule = indexOfScheduleBak;
isNegative = enclosingIsNegative;
//---------------------------------------------------------------------------
// build next operation
insertionPoint = BuildScheduledSearchPlanOperationIntoSearchProgram(
currentOperationIndex + 1,
insertionPoint);
//---------------------------------------------------------------------------
return insertionPoint;
}
/// <summary>
/// move outwards from starting point on until operation to continue at is found
/// appending restore isomorphy at insertion point for isomorphy written on the way
/// returns operation to continue at
/// </summary>
private static SearchProgramOperation MoveOutwardsAppendingRemoveIsomorphy(
SearchProgramOperation startingPoint,
ref SearchProgramOperation insertionPoint,
string[] neededElementsForCheckOperation,
SearchProgramOperation outermostOperation,
SearchProgram topLevelSearchProgram)
{
// currently focused operation on our way outwards
SearchProgramOperation op = startingPoint;
// move outwards until operation to continue at is found
bool creationPointOfDominatingElementFound = false;
bool iterationReached = false;
do
{
op = op.Previous;
// insert code to clean up isomorphy information written by candidate acceptance
// in between the operation to continue and the check operation
if (op is AcceptCandidate)
{
AcceptCandidate writeIsomorphy =
op as AcceptCandidate;
AbandonCandidate restoreIsomorphy =
new AbandonCandidate(
writeIsomorphy.PatternElementName,
writeIsomorphy.NegativeIndependentNamePrefix,
writeIsomorphy.IsNode,
writeIsomorphy.NeverAboveMaxIsoSpace,
writeIsomorphy.Parallel,
writeIsomorphy.LockForAllThreads);
insertionPoint = insertionPoint.Append(restoreIsomorphy);
}
// insert code to clean up isomorphy information written by global candidate acceptance
// in between the operation to continue and the check operation
if (op is AcceptCandidateGlobal)
{
AcceptCandidateGlobal writeIsomorphy =
op as AcceptCandidateGlobal;
AbandonCandidateGlobal removeIsomorphy =
new AbandonCandidateGlobal(
writeIsomorphy.PatternElementName,
writeIsomorphy.NegativeIndependentNamePrefix,
writeIsomorphy.IsNode,
writeIsomorphy.NeverAboveMaxIsoSpace,
writeIsomorphy.Parallel);
insertionPoint = insertionPoint.Append(removeIsomorphy);
}
// insert code to clean up isomorphy information written by patternpath candidate acceptance
// in between the operation to continue and the check operation
if (op is AcceptCandidatePatternpath)
{
AcceptCandidatePatternpath writeIsomorphy =
op as AcceptCandidatePatternpath;
AbandonCandidatePatternpath removeIsomorphy =
new AbandonCandidatePatternpath(
writeIsomorphy.PatternElementName,
writeIsomorphy.NegativeIndependentNamePrefix,
writeIsomorphy.IsNode);
insertionPoint = insertionPoint.Append(removeIsomorphy);
}
// insert code to remove iterated pattern acceptance
if (op is AcceptIterated)
{
AcceptIterated acceptIterated =
op as AcceptIterated;
AbandonIterated abandonIterated =
new AbandonIterated();
insertionPoint = insertionPoint.Append(abandonIterated);
}
// insert code to undo subpattern matching initialization if we leave the subpattern matching method
if (op is InitializeSubpatternMatching)
{
InitializeSubpatternMatching initialize =
op as InitializeSubpatternMatching;
FinalizeSubpatternMatching finalize =
new FinalizeSubpatternMatching(initialize.Type);
insertionPoint = insertionPoint.Append(finalize);
}
// insert code to undo negative/independent matching initialization if we leave the negative/independent matching method
if (op is InitializeNegativeIndependentMatching)
{
InitializeNegativeIndependentMatching initialize =
op as InitializeNegativeIndependentMatching;
FinalizeNegativeIndependentMatching finalize =
new FinalizeNegativeIndependentMatching(initialize.NeverAboveMaxIsoSpace, initialize.Parallel);
insertionPoint = insertionPoint.Append(finalize);
}
// determine operation to continue at
// found by looking at the graph elements
// the check operation depends on / is dominated by
// its the first element iteration on our way outwards the search program
// after or at the point of a get element operation
// of some dominating element the check depends on
// (or the outermost operation if no iteration is found until it is reached)
if (op is GetCandidate || op is BothDirectionsIteration)
{
if (creationPointOfDominatingElementFound == false)
{
if (neededElementsForCheckOperation != null)
{
foreach (string dominating in neededElementsForCheckOperation)
{
GetCandidate getCandidate = op as GetCandidate;
BothDirectionsIteration bothDirections = op as BothDirectionsIteration;
if (getCandidate != null && getCandidate.PatternElementName == dominating ||
bothDirections != null && bothDirections.PatternElementName == dominating)
{
creationPointOfDominatingElementFound = true;
iterationReached = false;
break;
}
}
}
else
{
// needed elements == null means everything fits,
// take first element iteration on our way outwards the search program
// (or the outermost operation if no iteration is found until it is reached)
creationPointOfDominatingElementFound = true;
iterationReached = false;
}
}
if (op is GetCandidateByIteration || op is GetCandidateByIterationParallel || op is BothDirectionsIteration)
{
iterationReached = true;
}
}
}while(!(creationPointOfDominatingElementFound && iterationReached) &&
op != outermostOperation);
return(op);
}
/// <summary>
/// Search program operations implementing the
/// Negative search plan operation (searching of negative application condition)
/// are created and inserted into search program
/// </summary>
private SearchProgramOperation buildNegative(
SearchProgramOperation insertionPoint,
int currentOperationIndex,
PatternGraph negativePatternGraph)
{
// fill needed elements array for CheckPartialMatchByNegative
string[] neededElements = ComputeNeededElements(negativePatternGraph);
CheckPartialMatchByNegative checkNegative =
new CheckPartialMatchByNegative(neededElements);
SearchProgramOperation continuationPoint =
insertionPoint.Append(checkNegative);
checkNegative.NestedOperationsList =
new SearchProgramList(checkNegative);
insertionPoint = checkNegative.NestedOperationsList;
bool enclosingIsNegative = isNegative;
bool enclosingIsNestedInNegative = isNestedInNegative;
isNegative = true;
isNestedInNegative = true;
PatternGraph enclosingPatternGraph = patternGraphWithNestingPatterns.Peek();
patternGraphWithNestingPatterns.Push(negativePatternGraph);
isoSpaceNeverAboveMaxIsoSpace = patternGraphWithNestingPatterns.Peek().maxIsoSpace < (int)LGSPElemFlags.MAX_ISO_SPACE;
bool parallelizedBak = parallelized;
parallelized &= patternGraphWithNestingPatterns.Peek().parallelizedSchedule != null; // the neg within a parallelized head may be non-parallelized
int indexOfScheduleBak = indexOfSchedule;
if(parallelized) indexOfSchedule = 0; // the neg of a parallelized body at index 1 is still only at index 0
string negativeIndependentNamePrefix = NegativeIndependentNamePrefix(patternGraphWithNestingPatterns.Peek());
bool negativeContainsSubpatterns = negativePatternGraph.embeddedGraphsPlusInlined.Length >= 1
|| negativePatternGraph.alternativesPlusInlined.Length >= 1
|| negativePatternGraph.iteratedsPlusInlined.Length >= 1;
InitializeNegativeIndependentMatching initNeg = new InitializeNegativeIndependentMatching(
negativeContainsSubpatterns,
negativeIndependentNamePrefix,
isoSpaceNeverAboveMaxIsoSpace,
parallelized);
insertionPoint = insertionPoint.Append(initNeg);
insertionPoint = insertVariableDeclarationsNegIdpt(insertionPoint, negativePatternGraph);
//---------------------------------------------------------------------------
// build negative pattern
insertionPoint = BuildScheduledSearchPlanOperationIntoSearchProgram(
0,
insertionPoint);
//---------------------------------------------------------------------------
FinalizeNegativeIndependentMatching finalize = new FinalizeNegativeIndependentMatching(
isoSpaceNeverAboveMaxIsoSpace, parallelized);
insertionPoint = insertionPoint.Append(finalize);
// negative pattern built by now
// continue at the end of the list handed in
insertionPoint = continuationPoint;
patternGraphWithNestingPatterns.Pop();
parallelized = parallelizedBak;
indexOfSchedule = indexOfScheduleBak;
isNegative = enclosingIsNegative;
isNestedInNegative = enclosingIsNestedInNegative;
//---------------------------------------------------------------------------
// build next operation
insertionPoint = BuildScheduledSearchPlanOperationIntoSearchProgram(
currentOperationIndex + 1,
insertionPoint);
//---------------------------------------------------------------------------
return insertionPoint;
}
