/// <summary> /// Processes the new <paramref name="transitions" /> discovered by the <paramref name="worker " /> within the traversal /// <paramref name="context" />. Only transitions with <see cref="CandidateTransition.IsValid" /> set to <c>true</c> are /// actually new. /// </summary> /// <param name="context">The context of the model traversal.</param> /// <param name="worker">The worker that found the transition.</param> /// <param name="sourceState">The index of the transition's source state.</param> /// <param name="transitions">The new transitions that should be processed.</param> /// <param name="transitionCount">The actual number of valid transitions.</param> /// <param name="areInitialTransitions"> /// Indicates whether the transitions are an initial transitions not starting in any valid source state. /// </param> public void ProcessTransitions(TraversalContext context, Worker worker, int sourceState, TransitionCollection transitions, int transitionCount, bool areInitialTransitions) { // Note, other threads might access _markovChain at the same time CheckIfTransitionsCanBeProcessed(transitionCount); AddTransitions(sourceState, areInitialTransitions, transitions); }
public override TraversalBranch Next(PathExpander expander, TraversalContext context) { if (_relationships == null) { ExpandRelationships(expander); } while (_relationships.MoveNext()) { Relationship relationship = _relationships.Current; if (relationship.Equals(_howIGotHere)) { context.UnnecessaryRelationshipTraversed(); continue; } _expandedCount++; Node node = relationship.GetOtherNode(_source); // TODO maybe an unnecessary instantiation. Instead pass in this+node+relationship to uniqueness check TraversalBranch next = NewNextBranch(node, relationship); if (context.IsUnique(next)) { context.RelationshipTraversed(); next.Initialize(expander, context); return(next); } else { context.UnnecessaryRelationshipTraversed(); } } ResetRelationships(); return(null); }
/// <summary> /// Initializes a new instance. /// </summary> /// <param name="createModel">Creates the model that should be checked.</param> /// <param name="output">The callback that should be used to output messages.</param> /// <param name="configuration">The analysis configuration that should be used.</param> internal ModelTraverser(Func<AnalysisModel> createModel, Action<string> output, AnalysisConfiguration configuration) { Requires.NotNull(createModel, nameof(createModel)); Requires.NotNull(output, nameof(output)); TransitionCollection.ValidateTransitionSizes(); var tasks = new Task[configuration.CpuCount]; var stacks = new StateStack[configuration.CpuCount]; _loadBalancer = new LoadBalancer(stacks); Context = new TraversalContext(_loadBalancer, configuration, output); _workers = new Worker[configuration.CpuCount]; for (var i = 0; i < configuration.CpuCount; ++i) { var index = i; tasks[i] = Task.Factory.StartNew(() => { stacks[index] = new StateStack(configuration.StackCapacity); _workers[index] = new Worker(index, Context, stacks[index], createModel()); }); } Task.WaitAll(tasks); _states = new StateStorage(_workers[0].Model.StateVectorSize, configuration.StateCapacity); Context.States = _states; }
internal AsOneStartBranch(TraversalContext context, IEnumerable <Node> nodes, InitialBranchState initialState, UniquenessFactory uniqueness) { this._context = context; this._initialState = initialState; this._uniqueness = uniqueness; this._branches = ToBranches(nodes); }
public override TraversalBranch Next(TraversalContext metadata) { TraversalBranch result = null; while (result == null) { if (_current == null) { _current = _superNodes.RemoveFirst(); if (_current == null) { return(null); } } else if (_current.expanded() > 0 && _current.expanded() % _threshold == 0) { _superNodes.AddLast(_current); _current = _current.parent(); continue; } TraversalBranch next = _current.next(_expander, metadata); if (next == null) { _current = _current.parent(); continue; } _current = next; result = _current; } return(result); }
/// <summary> /// Embed evaluated once formulas into the state as observers. /// </summary> /// <param name="context">The context of the model traversal.</param> /// <param name="worker">The worker that found the transition.</param> /// <param name="transitions">The transitions that should be checked.</param> /// <param name="sourceState">The source state of the transitions.</param> /// <param name="sourceStateIndex">The unique index of the transition's source state.</param> /// <param name="isInitial">Indicates whether the transitions are initial transitions not starting in any valid source state.</param> public void ModifyTransitions(TraversalContext context, Worker worker, TransitionCollection transitions, byte *sourceState, int sourceStateIndex, bool isInitial) { foreach (CandidateTransition *transition in transitions) { ConvertTransition(transition); } }
public override void PostProcess(TraversalContext context) { if (context.TranslucencyGrantor == this && !sPreviousFlagValue) { context.TranslucencyGrantor = null; context.ExternalMaterialFlags &= ~TraversalContext.MaterialFlags.Translucent; } }
/// <summary> /// Optionally modifies the <paramref name="transitions" />, changing any of their values. However, no new transitions can be /// added; transitions can be removed by setting their <see cref="CandidateTransition.IsValid" /> flag to <c>false</c>. /// During subsequent traversal steps, only valid transitions and target states reached by at least one valid transition /// are considered. /// </summary> /// <param name="context">The context of the model traversal.</param> /// <param name="worker">The worker that found the transition.</param> /// <param name="transitions">The transitions that should be checked.</param> /// <param name="sourceState">The source state of the transitions.</param> /// <param name="sourceStateIndex">The unique index of the transition's source state.</param> /// <param name="isInitial">Indicates whether the transitions are initial transitions not starting in any valid source state.</param> public void ModifyTransitions(TraversalContext <TExecutableModel> context, Worker <TExecutableModel> worker, TransitionCollection transitions, byte *sourceState, int sourceStateIndex, bool isInitial) { foreach (CandidateTransition *transition in transitions) { transition->Flags = TransitionFlags.SetIsValidIffCondition(transition->Flags, transition->ActivatedFaults.GetIntersection(_suppressedFaults).IsEmpty); } }
/// <summary> /// Optionally modifies the <paramref name="transitions" />, changing any of their values. However, no new transitions can be /// added; transitions can be removed by setting their <see cref="CandidateTransition.IsValid" /> flag to <c>false</c>. /// During subsequent traversal steps, only valid transitions and target states reached by at least one valid transition /// are considered. /// </summary> /// <param name="context">The context of the model traversal.</param> /// <param name="worker">The worker that found the transition.</param> /// <param name="transitions">The transitions that should be checked.</param> /// <param name="sourceState">The source state of the transitions.</param> /// <param name="sourceStateIndex">The unique index of the transition's source state.</param> /// <param name="isInitial">Indicates whether the transitions are initial transitions not starting in any valid source state.</param> public void ModifyTransitions(TraversalContext context, Worker worker, TransitionCollection transitions, byte *sourceState, int sourceStateIndex, bool isInitial) { _transitions = transitions; _useHash = transitions.Count >= UseHashLimit; CreateSortedTransitionIndexes(); IterateThroughAllTransitionsInSortedOrder(); }
public override void Process(TraversalContext context) { if (context.TranslucencyGrantor == null) { sPreviousFlagValue = (context.ExternalMaterialFlags & TraversalContext.MaterialFlags.Translucent) > 0; context.TranslucencyGrantor = this; context.ExternalMaterialFlags |= TraversalContext.MaterialFlags.Translucent; } }
/// <summary> /// Processes the new <paramref name="transition" /> discovered by the <paramref name="worker " /> within the traversal /// <paramref name="context" />. /// </summary> /// <param name="context">The context of the model traversal.</param> /// <param name="worker">The worker that found the transition.</param> /// <param name="transition">The new transition that should be processed.</param> /// <param name="isInitialTransition"> /// Indicates whether the transition is an initial transition not starting in any valid source state. /// </param> public unsafe void ProcessTransition(TraversalContext context, Worker worker, Transition* transition, bool isInitialTransition) { if (transition->Formulas[_formulaIndex]) return; context.FormulaIsValid = false; context.LoadBalancer.Terminate(); worker.CreateCounterExample(endsWithException: false, addAdditionalState: false); }
public override TraversalBranch Next(TraversalContext metadata) { if (_sourceIterator == null) { _sourceIterator = GatherSourceIterator(metadata); } //JAVA TO C# CONVERTER TODO TASK: Java iterators are only converted within the context of 'while' and 'for' loops: return(_sourceIterator.hasNext() ? _sourceIterator.next() : null); }
/// <summary> /// Processes the new <paramref name="transitions" /> discovered by the <paramref name="worker " /> within the traversal /// <paramref name="context" />. Only transitions with <see cref="CandidateTransition.IsValid" /> set to <c>true</c> are /// actually new. /// </summary> /// <param name="context">The context of the model traversal.</param> /// <param name="worker">The worker that found the transition.</param> /// <param name="sourceState">The index of the transition's source state.</param> /// <param name="transitions">The new transitions that should be processed.</param> /// <param name="transitionCount">The actual number of valid transitions.</param> /// <param name="areInitialTransitions"> /// Indicates whether the transitions are an initial transitions not starting in any valid source state. /// </param> public void ProcessTransitions(TraversalContext context, Worker worker, int sourceState, TransitionCollection transitions, int transitionCount, bool areInitialTransitions) { if (transitionCount == 0) { throw new InvalidOperationException( "Deadlock state detected, i.e., there are no outgoing transitions for " + "the last state in the generated counter example. Try relaxing state constraints."); } }
/// <summary> /// Embed evaluated once formulas into the state as observers. /// </summary> /// <param name="context">The context of the model traversal.</param> /// <param name="worker">The worker that found the transition.</param> /// <param name="transitions">The transitions that should be checked.</param> /// <param name="sourceState">The source state of the transitions.</param> /// <param name="sourceStateIndex">The unique index of the transition's source state.</param> /// <param name="isInitial">Indicates whether the transitions are initial transitions not starting in any valid source state.</param> public void ModifyTransitions(TraversalContext context, Worker worker, TransitionCollection transitions, byte *sourceState, int sourceStateIndex, bool isInitial) { var currentEnrichment = isInitial ? 0 : *(int *)(sourceState + ExtraBytesOffset); foreach (CandidateTransition *transition in transitions) { ConvertTransition(currentEnrichment, transition); } }
/// <summary> /// Processes the new <paramref name="transition" /> discovered by the <paramref name="worker " /> within the traversal /// <paramref name="context" />. /// </summary> /// <param name="context">The context of the model traversal.</param> /// <param name="worker">The worker that found the transition.</param> /// <param name="transition">The new transition that should be processed.</param> /// <param name="isInitialTransition"> /// Indicates whether the transition is an initial transition not starting in any valid source state. /// </param> public unsafe void ProcessTransition(TraversalContext context, Worker worker, Transition *transition, bool isInitialTransition) { if (_evaluator(transition->Formulas)) { return; } context.FormulaIsValid = false; context.LoadBalancer.Terminate(); worker.CreateCounterExample(endsWithException: false, addAdditionalState: false); }
public override TraversalBranch Next(PathExpander expander, TraversalContext metadata) { //JAVA TO C# CONVERTER TODO TASK: Java iterators are only converted within the context of 'while' and 'for' loops: if (_branches.hasNext()) { _expanded++; //JAVA TO C# CONVERTER TODO TASK: Java iterators are only converted within the context of 'while' and 'for' loops: return(_branches.next().next(expander, metadata)); } return(null); }
public override TraversalBranch Next(TraversalContext metadata) { // Exhaust current if not already exhausted while (true) { TraversalBranch next = Current.next(Expander, metadata); if (next == null) { break; } long endNodeId = next.EndNode().Id; Visit <P> stay = Visits[endNodeId]; D cost = outerInstance.CalculateValue(next); P newPriority = outerInstance.AddPriority(next, CurrentAggregatedValue, cost); bool newStay = stay == null; if (newStay) { stay = new Visit <P>(newPriority); Visits[endNodeId] = stay; } if (newStay || !outerInstance.interest.CanBeRuledOut(stay.VisitCount, newPriority, stay.Cost)) { if (outerInstance.interest.Comparator().Compare(newPriority, stay.Cost) < 0) { stay.Cost = newPriority; } Queue.put(next, newPriority); } } do { // Pop the top from priorityMap Entry <TraversalBranch, P> entry = Queue.pop(); if (entry != null) { Current = entry.Entity; Visit <P> stay = Visits[Current.endNode().Id]; stay.VisitCount++; if (outerInstance.interest.StillInteresting(stay.VisitCount)) { CurrentAggregatedValue = entry.Priority; return(Current); } } else { return(null); } } while (true); }
/// <summary> /// Processes the new <paramref name="transition" /> discovered by the <paramref name="worker " /> within the traversal /// <paramref name="context" />. /// </summary> /// <param name="context">The context of the model traversal.</param> /// <param name="worker">The worker that found the transition.</param> /// <param name="transition">The new transition that should be processed.</param> /// <param name="isInitialTransition"> /// Indicates whether the transition is an initial transition not starting in any valid source state. /// </param> public unsafe void ProcessTransition(TraversalContext <TExecutableModel> context, Worker <TExecutableModel> worker, Transition *transition, bool isInitialTransition) { if (transition->Formulas[_formulaIndex]) { return; } context.FormulaIsValid = false; context.LoadBalancer.Terminate(); worker.CreateCounterExample(endsWithException: false, addAdditionalState: false); }
/// <summary> /// Processes the new <paramref name="transitions" /> discovered by the <paramref name="worker " /> within the traversal /// <paramref name="context" />. Only transitions with <see cref="CandidateTransition.IsValid" /> set to <c>true</c> are /// actually new. /// </summary> /// <param name="context">The context of the model traversal.</param> /// <param name="worker">The worker that found the transition.</param> /// <param name="sourceState">The index of the transition's source state.</param> /// <param name="transitions">The new transitions that should be processed.</param> /// <param name="transitionCount">The actual number of valid transitions.</param> /// <param name="areInitialTransitions"> /// Indicates whether the transitions are an initial transitions not starting in any valid source state. /// </param> public void ProcessTransitions(TraversalContext context, Worker worker, int sourceState, TransitionCollection transitions, int transitionCount, bool areInitialTransitions) { // Note, other threads might access _ltmdp at the same time CheckIfTransitionsCanBeProcessed(transitionCount); AddTransitions(transitions); var stepgraph = (LtmdpStepGraph)transitions.StructuralInformation; CheckIfStepGraphCanBeProcessed(stepgraph); AddStepGraph(stepgraph, sourceState, areInitialTransitions); }
/// <summary> /// Processes the new <paramref name="transitions" /> discovered by the <paramref name="worker " /> within the traversal /// <paramref name="context" />. Only transitions with <see cref="CandidateTransition.IsValid" /> set to <c>true</c> are /// actually new. /// </summary> /// <param name="context">The context of the model traversal.</param> /// <param name="worker">The worker that found the transition.</param> /// <param name="sourceState">The index of the transition's source state.</param> /// <param name="transitions">The new transitions that should be processed.</param> /// <param name="transitionCount">The actual number of valid transitions.</param> /// <param name="areInitialTransitions"> /// Indicates whether the transitions are an initial transitions not starting in any valid source state. /// </param> public void ProcessTransitions(TraversalContext <TExecutableModel> context, Worker <TExecutableModel> worker, int sourceState, TransitionCollection transitions, int transitionCount, bool areInitialTransitions) { // Note, other threads might access _markovChain at the same time CheckIfTransitionsCanBeProcessed(transitionCount); foreach (var transition in transitions) { var probTransition = (LtmcTransition *)transition; CheckIfTransitionIsValid(probTransition); AddTransitionToTransitionChain(sourceState, areInitialTransitions, probTransition); } }
/// <summary> /// Optionally modifies the <paramref name="transitions" />, changing any of their values. However, no new transitions can be /// added; transitions can be removed by setting their <see cref="CandidateTransition.IsValid" /> flag to <c>false</c>. /// During subsequent traversal steps, only valid transitions and target states reached by at least one valid transition /// are considered. /// </summary> /// <param name="context">The context of the model traversal.</param> /// <param name="transitions">The transitions that should be checked.</param> /// <param name="sourceState">The source state of the transitions.</param> /// <param name="sourceStateIndex">The unique index of the transition's source state.</param> /// <param name="isInitial">Indicates whether the transitions are initial transitions not starting in any valid source state.</param> public void ModifyTransitions(TraversalContext context, TransitionCollection transitions, byte* sourceState, int sourceStateIndex, bool isInitial) { // The fault order state is encoded into the first four bytes of the state vector (must be four bytes as required by // RuntimeModel's state header field) var state = isInitial ? State.NeitherFaultActivated : *(State*)sourceState; foreach (CandidateTransition* transition in transitions) { var activatedFaults = transition->ActivatedFaults; var isValid = true; var nextState = state; switch (state) { case State.NeitherFaultActivated: if (activatedFaults.Contains(_firstFault) && activatedFaults.Contains(_secondFault)) { if (_forceSimultaneous) nextState = State.BothFaultsActivated; else isValid = false; } else if (activatedFaults.Contains(_firstFault)) { if (_forceSimultaneous) isValid = false; else nextState = State.FirstFaultActivated; } else if (activatedFaults.Contains(_secondFault)) isValid = false; break; case State.FirstFaultActivated: if (activatedFaults.Contains(_secondFault)) nextState = State.BothFaultsActivated; break; case State.BothFaultsActivated: break; default: Assert.NotReached("Unexpected state value."); break; } transition->IsValid = isValid; *(State*)transition->TargetState = nextState; } }
private IEnumerator <TraversalBranch> GatherSourceIterator(TraversalContext metadata) { LinkedList <TraversalBranch> queue = new LinkedList <TraversalBranch>(); queue.AddLast(_current.next(_expander, metadata)); while (true) { IList <TraversalBranch> level = GatherOneLevel(queue, metadata); if (level.Count == 0) { break; } queue.addAll(0, level); } return(queue.GetEnumerator()); }
public override TraversalBranch Next(TraversalContext metadata) { TraversalBranch branch = NextBranchFromCurrentSelector(metadata, false); Entry state = StateForCurrentSelector; AtomicInteger previousDepth = state.Depth; if (branch != null && branch.Length() == previousDepth.get()) { // Same depth as previous branch returned from this side. return(branch); } if (branch != null) { _totalDepth.set(CurrentSide(), branch.Length()); } if ((_stopDescentOnResult && (metadata.NumberOfPathsReturned > 0)) || (_totalDepth.get() > (_maxDepth + 1))) { NextSelector(); return(null); } if (branch != null) { previousDepth.set(branch.Length()); state.Branch = branch; } BranchSelector otherSelector = NextSelector(); Entry otherState = StateForCurrentSelector; TraversalBranch otherBranch = otherState.Branch; if (otherBranch != null) { otherState.Branch = null; return(otherBranch); } otherBranch = otherSelector.Next(metadata); if (otherBranch != null) { return(otherBranch); } else { return(branch); } }
public override TraversalBranch Next(TraversalContext metadata) { TraversalBranch branch = NextBranchFromNextSelector(metadata, true); int? previousDepth = StateForCurrentSelector; if (branch != null && branch.Length() == previousDepth.Value) { return(branch); } else { if (branch != null) { StateForCurrentSelector = branch.Length(); } } return(branch); }
/// <summary> /// Initializes a new instance. /// </summary> /// <param name="context">The context of the traversal process.</param> /// <param name="transitionSizeInBytes">The size of a transition in bytes.</param> /// <param name="model">The runtime model the state graph is generated for.</param> /// <param name="createModel"> /// The factory function that should be used to create instances of the <see cref="RuntimeModel" /> /// the state graph is generated for. /// </param> internal StateGraph(TraversalContext context, int transitionSizeInBytes, TExecutableModel model, CoupledExecutableModelCreator <TExecutableModel> createModel) { Requires.NotNull(context, nameof(context)); TransitionSize = transitionSizeInBytes; RuntimeModel = model; RuntimeModelCreator = createModel; _stateStorage = context.States; _transitionCapacity = context.ModelCapacity.MemoryLimitTransitions.Value; _transitionsBuffer.Resize(_transitionCapacity, zeroMemory: false); _stateMapBuffer.Resize(context.ModelCapacity.NumberOfStates * sizeof(TransitionRange), zeroMemory: false); _transitions = _transitionsBuffer.Pointer; _stateMap = (TransitionRange *)_stateMapBuffer.Pointer; }
/// <summary> /// Initializes a new instance. /// </summary> /// <param name="context">The context of the traversal process.</param> /// <param name="stateFormulas">The state formulas that can be evaluated over the generated state graph.</param> /// <param name="transitionSizeInBytes">The size of a transition in bytes.</param> /// <param name="model">The runtime model the state graph is generated for.</param> /// <param name="createModel"> /// The factory function that should be used to create instances of the <see cref="RuntimeModel" /> /// the state graph is generated for. /// </param> internal StateGraph(TraversalContext context, Formula[] stateFormulas, int transitionSizeInBytes, RuntimeModel model, Func<RuntimeModel> createModel) { Requires.NotNull(context, nameof(context)); StateFormulas = stateFormulas; TransitionSize = transitionSizeInBytes; RuntimeModel = model; RuntimeModelCreator = createModel; _stateStorage = context.States; _transitionCapacity = context.Configuration.TransitionCapacity; _transitionsBuffer.Resize(TransitionSize * _transitionCapacity, zeroMemory: false); _stateMapBuffer.Resize(context.Configuration.StateCapacity * sizeof(TransitionRange), zeroMemory: false); _transitions = _transitionsBuffer.Pointer; _stateMap = (TransitionRange*)_stateMapBuffer.Pointer; }
public override TraversalBranch Next(TraversalContext metadata) { TraversalBranch result = null; while (result == null) { if (_current == null) { return(null); } TraversalBranch next = _current.next(_expander, metadata); if (next == null) { _current = _current.parent(); continue; } _current = next; result = _current; } return(result); }
public override TraversalBranch Next(TraversalContext metadata) { TraversalBranch result = null; while (result == null) { TraversalBranch next = _current.next(_expander, metadata); if (next != null) { _queue.AddLast(next); result = next; } else { _current = _queue.RemoveFirst(); if (_current == null) { return(null); } } } return(result); }
/// <summary> /// Optionally modifies the <paramref name="transitions" />, changing any of their values. However, no new transitions can be /// added; transitions can be removed by setting their <see cref="CandidateTransition.IsValid" /> flag to <c>false</c>. /// During subsequent traversal steps, only valid transitions and target states reached by at least one valid transition /// are considered. /// </summary> /// <param name="context">The context of the model traversal.</param> /// <param name="worker">The worker that found the transition.</param> /// <param name="transitions">The transitions that should be checked.</param> /// <param name="sourceState">The source state of the transitions.</param> /// <param name="sourceStateIndex">The unique index of the transition's source state.</param> /// <param name="isInitial">Indicates whether the transitions are initial transitions not starting in any valid source state.</param> public void ModifyTransitions(TraversalContext <TExecutableModel> context, Worker <TExecutableModel> worker, TransitionCollection transitions, byte *sourceState, int sourceStateIndex, bool isInitial) { // The fault order state is encoded into the first four bytes of the state vector (must be four bytes as required by // RuntimeModel's state header field) var state = isInitial ? State.NeitherFaultActivated : *(State *)sourceState; foreach (CandidateTransition *transition in transitions) { var activatedFaults = transition->ActivatedFaults; var isValid = true; var nextState = state; switch (state) { case State.NeitherFaultActivated: if (activatedFaults.Contains(_firstFault) && activatedFaults.Contains(_secondFault)) { if (_forceSimultaneous) { nextState = State.BothFaultsActivated; } else { isValid = false; } } else if (activatedFaults.Contains(_firstFault)) { if (_forceSimultaneous) { isValid = false; } else { nextState = State.FirstFaultActivated; } } else if (activatedFaults.Contains(_secondFault)) { isValid = false; } break; case State.FirstFaultActivated: if (activatedFaults.Contains(_secondFault)) { nextState = State.BothFaultsActivated; } break; case State.BothFaultsActivated: break; default: Assert.NotReached("Unexpected state value."); break; } transition->Flags = TransitionFlags.SetIsValidIffCondition(transition->Flags, isValid); *(State *)transition->TargetStatePointer = nextState; } }
protected internal virtual void Evaluate(TraversalContext context) { Evaluation = context.Evaluate(this, null); }
//JAVA TO C# CONVERTER WARNING: 'final' parameters are ignored unless the option to convert to C# 7.2 'in' parameters is selected: //ORIGINAL LINE: public void initialize(final org.neo4j.graphdb.PathExpander expander, org.neo4j.graphdb.traversal.TraversalContext metadata) public override void Initialize(PathExpander expander, TraversalContext metadata) { Evaluate(metadata); }
/// <summary> /// Processes the new <paramref name="transitions" /> discovered by the <paramref name="worker " /> within the traversal /// <paramref name="context" />. Only transitions with <see cref="CandidateTransition.IsValid" /> set to <c>true</c> are /// actually new. /// </summary> /// <param name="context">The context of the model traversal.</param> /// <param name="worker">The worker that found the transition.</param> /// <param name="sourceState">The index of the transition's source state.</param> /// <param name="transitions">The new transitions that should be processed.</param> /// <param name="transitionCount">The actual number of valid transitions.</param> /// <param name="areInitialTransitions"> /// Indicates whether the transitions are an initial transitions not starting in any valid source state. /// </param> public void ProcessTransitions(TraversalContext context, Worker worker, int sourceState, TransitionCollection transitions, int transitionCount, bool areInitialTransitions) { _stateGraph.AddStateInfo(sourceState, areInitialTransitions, transitions, transitionCount); }
/// <summary> /// Optionally modifies the <paramref name="transitions" />, changing any of their values. However, no new transitions can be /// added; transitions can be removed by setting their <see cref="CandidateTransition.IsValid" /> flag to <c>false</c>. /// During subsequent traversal steps, only valid transitions and target states reached by at least one valid transition /// are considered. /// </summary> /// <param name="context">The context of the model traversal.</param> /// <param name="transitions">The transitions that should be checked.</param> /// <param name="sourceState">The source state of the transitions.</param> /// <param name="sourceStateIndex">The unique index of the transition's source state.</param> /// <param name="isInitial">Indicates whether the transitions are initial transitions not starting in any valid source state.</param> public void ModifyTransitions(TraversalContext context, TransitionCollection transitions, byte* sourceState, int sourceStateIndex, bool isInitial) { foreach (CandidateTransition* transition in transitions) transition->IsValid = transition->ActivatedFaults.GetIntersection(_suppressedFaults).IsEmpty; }
public TraversalBranch next(TraversalContext metadata) { throw new System.NotSupportedException(); }
private IList <TraversalBranch> GatherOneLevel(IList <TraversalBranch> queue, TraversalContext metadata) { IList <TraversalBranch> level = new LinkedList <TraversalBranch>(); int?depth = null; foreach (TraversalBranch source in queue) { if (depth == null) { depth = source.Length(); } else if (source.Length() != depth.Value) { break; } while (true) { TraversalBranch next = source.Next(_expander, metadata); if (next == null) { break; } level.Add(next); } } return(level); }