public void Init(IWorkaround workaround)
{
this.workaround = workaround;
bpPosCounter = -1;
cpPosCounter = -1;
highlightSeq = null;
success = false;
choice = false;
sequences = null;
}
public SequenceUnary(Sequence seq, SequenceType seqType) : base(seqType)
{
Seq = seq;
}
public double ChooseRandomNumber(double randomNumber, Sequence seq)
{
return randomNumber;
}
public int ChooseMatch(int matchToApply, IMatches matches, int numFurtherMatchesToApply, Sequence seq)
{
return matchToApply;
}
public void EndOfIteration(bool continueLoop, Sequence seq)
{
EndOfIterationHandler handler = OnEndOfIteration;
if(handler != null) handler(continueLoop, seq);
}
public void EnteringSequence(Sequence seq)
{
EnterSequenceHandler handler = OnEntereringSequence;
if(handler != null) handler(seq);
}
public bool ApplyGraphRewriteSequence(Sequence sequence)
{
PerformanceInfo.Start();
bool res = sequence.Apply(this);
PerformanceInfo.Stop();
return res;
}
public SequenceIterationMinMax(Sequence seq, long min, long max) : base(seq, SequenceType.IterationMinMax)
{
Min = min;
Max = max;
}
public override bool GetLocalVariables(Dictionary<SequenceVariable, SetValueType> variables,
List<SequenceExpressionContainerConstructor> containerConstructors, Sequence target)
{
foreach(SequenceVariable seqVar in InputVariables)
seqVar.GetLocalVariables(variables);
foreach(SequenceVariable seqVar in OutputVariables)
seqVar.GetLocalVariables(variables);
if(Seq.GetLocalVariables(variables, containerConstructors, target))
return true;
return this == target;
}
public SequenceDefinitionInterpreted(String sequenceName,
SequenceVariable[] inputVariables,
SequenceVariable[] outputVariables,
Sequence seq)
: base(SequenceType.SequenceDefinitionInterpreted, sequenceName)
{
InputVariables = inputVariables;
OutputVariables = outputVariables;
Seq = seq;
}
public override bool GetLocalVariables(Dictionary<SequenceVariable, SetValueType> variables,
List<SequenceExpressionContainerConstructor> containerConstructors, Sequence target)
{
Var.GetLocalVariables(variables);
if(Rule.GetLocalVariables(variables, containerConstructors, target))
return true;
if(Seq.GetLocalVariables(variables, containerConstructors, target))
return true;
foreach(SequenceVariable seqVar in VariablesFallingOutOfScopeOnLeavingFor)
variables.Remove(seqVar);
variables.Remove(Var);
return this == target;
}
public SequenceForMatch(SequenceVariable var, Sequence rule, Sequence seq,
List<SequenceVariable> variablesFallingOutOfScopeOnLeavingFor)
: base(seq, SequenceType.ForMatch)
{
Var = var;
Rule = (SequenceRuleCall)rule;
VariablesFallingOutOfScopeOnLeavingFor = variablesFallingOutOfScopeOnLeavingFor;
}
public override bool GetLocalVariables(Dictionary<SequenceVariable, SetValueType> variables,
List<SequenceExpressionContainerConstructor> containerConstructors, Sequence target)
{
if(Left.GetLocalVariables(variables, containerConstructors, target))
return true;
if(Right.GetLocalVariables(variables, containerConstructors, target))
return true;
return this == target;
}
public SequenceBinary(Sequence left, Sequence right, bool random, bool choice, SequenceType seqType)
: base(seqType)
{
Left = left;
Right = right;
this.random = random;
this.choice = choice;
}
public SequenceForFunction(SequenceVariable var, SequenceType sequenceType,
List<SequenceExpression> argExprs, Sequence seq,
List<SequenceVariable> variablesFallingOutOfScopeOnLeavingFor)
: base(seq, sequenceType)
{
Var = var;
ArgExprs = argExprs;
VariablesFallingOutOfScopeOnLeavingFor = variablesFallingOutOfScopeOnLeavingFor;
}
public SequenceNot(Sequence seq) : base(seq, SequenceType.Not) {}
public SequenceIterationMin(Sequence seq, long min) : base(seq, SequenceType.IterationMin)
{
Min = min;
}
public override bool GetLocalVariables(Dictionary<SequenceVariable, SetValueType> variables,
List<SequenceExpressionContainerConstructor> containerConstructors, Sequence target)
{
throw new Exception("GetLocalVariables not supported on compiled sequences");
}
public override bool GetLocalVariables(Dictionary<SequenceVariable, SetValueType> variables,
List<SequenceExpressionContainerConstructor> containerConstructors, Sequence target)
{
ParamBindings.GetLocalVariables(variables, containerConstructors);
return this == target;
}
public SequenceExecuteInSubgraph(SequenceVariable subgraphVar, String attributeName, Sequence seq)
: base(seq, SequenceType.ExecuteInSubgraph)
{
SubgraphVar = subgraphVar;
AttributeName = attributeName;
}
public bool ValidateWithSequence(Sequence seq)
{
SwitchToSubgraph(graph.Clone("clonedGraph"));
bool valid = seq.Apply(this);
ReturnFromSubgraph();
return valid;
}
public override bool GetLocalVariables(Dictionary<SequenceVariable, SetValueType> variables,
List<SequenceExpressionContainerConstructor> containerConstructors, Sequence target)
{
Computation.GetLocalVariables(variables, containerConstructors);
foreach(SequenceVariable seqVar in VariablesFallingOutOfScopeOnLeavingComputation)
variables.Remove(seqVar);
return this == target;
}
public void ExitingSequence(Sequence seq)
{
ExitSequenceHandler handler = OnExitingSequence;
if(handler != null) handler(seq);
}
public SequenceThenRight(Sequence left, Sequence right, bool random, bool choice)
: base(left, right, random, choice, SequenceType.ThenRight)
{
}
public int ChooseDirection(int direction, Sequence seq)
{
return direction;
}
public SequenceLazyAnd(Sequence left, Sequence right, bool random, bool choice)
: base(left, right, random, choice, SequenceType.LazyAnd)
{
}
public int ChooseRandomNumber(int randomNumber, int upperBound, Sequence seq)
{
return randomNumber;
}
public SequenceXor(Sequence left, Sequence right, bool random, bool choice)
: base(left, right, random, choice, SequenceType.Xor)
{
}
public object ChooseValue(string type, Sequence seq)
{
throw new Exception("Can only query the user for a value if a debugger is available");
}
public SequenceStrictAnd(Sequence left, Sequence right, bool random, bool choice)
: base(left, right, random, choice, SequenceType.StrictAnd)
{
}
