public void Visit(Action <GeneNode> function) { function.Invoke(this); if (Transitions != null && Transitions.Any()) { Transitions.ForEach(d => d.Node.Visit(function)); } }
/// <summary> /// Adds the transition. /// </summary> /// <param name="source"> The source. </param> /// <param name="target"> The target. </param> /// <param name="domainEvent"> The domain event. </param> public void AddTransition(int source, int target, string domainEvent) { var eventData = domainEvent.Split(new[] { ";" }, 0); var isInternal = States.Single(x => x.Value.Name == States[target].Name).Value.IsInternalState(); if (isInternal) { var xgmlTransition = new Transition { Event = eventData[0], Source = States[source].Name, Target = string.Format("PendientePublicar {0}", States[target].Name), Weight = eventData.Length > 1 ? int.Parse(eventData[1]) : 1000 }; Logger.Debug(string.Format("Adding Transition: {0} -> {1} => {2}", xgmlTransition.Source, xgmlTransition.Target, xgmlTransition.Event)); Transitions.Add(xgmlTransition); if (!Transitions.Any(x => x.Event == "InternalDomainEvent" && x.Source == string.Format("PendientePublicar {0}", States[target].Name) && x.Target == States[target].Name)) { xgmlTransition = new Transition { Event = "InternalDomainEvent", Source = string.Format("PendientePublicar {0}", States[target].Name), Target = States[target].Name, Weight = eventData.Length > 1 ? int.Parse(eventData[1]) : 1000 }; Logger.Debug(string.Format("Adding Transition: {0} -> {1} => {2}", xgmlTransition.Source, xgmlTransition.Target, xgmlTransition.Event)); Transitions.Add(xgmlTransition); } } else { var xgmlTransition = new Transition { Event = eventData[0], Source = States[source].Name, Target = States[target].Name, Weight = eventData.Length > 1 ? int.Parse(eventData[1]) : 1000 }; Logger.Debug(string.Format("Adding Transition: {0} -> {1} => {2}", xgmlTransition.Source, xgmlTransition.Target, xgmlTransition.Event)); Transitions.Add(xgmlTransition); } }
public void AddTransition(string condition, State nextState) { Transitions.Add(Transition.Parse(condition, this, nextState)); if (AmountOfTapes == 0) { AmountOfTapes = Transitions.First().AmountOfTapes; return; } if (Transitions.Any(c => c.AmountOfTapes != AmountOfTapes)) { throw new ArgumentException("The amounts of tapes required differs among the conditions."); } }
public bool IsLoopFixedPoint() { if (Transitions == null || !Transitions.Any()) { return(true); } var nextCondition = Transitions.First().Node.CurrentCondition; return(CurrentCondition.Count == nextCondition.Count && CurrentCondition.All(a => nextCondition.ContainsKey(a.Key) && nextCondition[a.Key] == a.Value) && Transitions.First().Node.IsLoopFixedPoint()); }
public Guard(string name, GuardType gtype, ICondition c) : base(name, c) { if (Transitions.Any()) { Type = GuardType.TRANSITION; } else if (gtype == GuardType.Undefined) { Type = GuardType.ENTER; } else { Type = gtype; } }
public SimulationControllerBase(bool load = false, string path = "./model.json", Func <TGroup> generator = null, SimulationStrategy strategy = SimulationStrategy.Plane) { if (load) { switch (strategy) { case SimulationStrategy.None: { Frames = new SimulationNoMemoryFrameController <State>(); break; } case SimulationStrategy.Plane: { Frames = new SimulationPlaneFrameController <State>(path); break; } case SimulationStrategy.Diffs: { Frames = new SimulationDiffFrameController <State>(path); break; } default: throw new ArgumentOutOfRangeException(nameof(strategy), strategy, null); } state = Load(); } else { if (generator != null) { state.TopGroup = generator(); } else { throw new Exception("Bad generator"); } state.RefreshMarks(); state.TimeStep = state.TopGroup.SetGlobatTransitionTimeScales(); var fat = state.TopGroup.Descriptor.SubGroups.Values .Traverse(g => g.Value.Descriptor.SubGroups.Values) .SelectMany(g => g.Value.Descriptor.Transitions) .Select(pair => pair.Value).ToList(); fat.AddRange(state.TopGroup.Descriptor.Transitions.Values); Transitions = fat.OrderBy( x => { if (x.Attributes.Any(a => a is PrioretyAttribute)) { var pa = (PrioretyAttribute)x.Attributes.First(a => a is PrioretyAttribute); return(pa.Priorety); } return(0); } ) .ToList(); if (Transitions .Any(descriptor => !descriptor.Value.CheckActionFunctions())) { throw new Exception("Bad Action routing detected"); } switch (strategy) { case SimulationStrategy.None: { Frames = new SimulationNoMemoryFrameController <State>(); break; } case SimulationStrategy.Plane: { Frames = new SimulationPlaneFrameController <State>(path, false); break; } case SimulationStrategy.Diffs: { Frames = new SimulationDiffFrameController <State>(path, false); break; } default: throw new ArgumentOutOfRangeException(nameof(strategy), strategy, null); } Frames.SaveState(state); } }
public void Transition(string token) { // First check that we have that token defined if (!Tokens.Contains(token)) { throw new ArgumentOutOfRangeException(nameof(token), token, "Given token is not defined."); } // And that we have a transition for this token if (!Transitions.Any(t => t.Token == token && t.From == CurrentState)) { throw new ArgumentOutOfRangeException(nameof(token), token, $"No transition exists for {CurrentState} + {token}."); } // Get list of possible transitions... var possible = Transitions.Where(t => t.From == CurrentState && t.Token == token).ToList(); // Check validity of transition do { var transition = possible.MinBy(t => { if (t.TransitionMode != Mode.Pop) { return(0); } var distanceTo = Stack.IndexOf((T)t.To); return(distanceTo == -1 ? int.MaxValue : distanceTo); }); switch (transition.TransitionMode) { case Mode.Pop: var pop = Stack.IndexOf((T)transition.To); if (pop == -1) { possible.Remove(transition); continue; } for (var i = 0; i < pop; i++) { Stack.RemoveAt(0); } break; case Mode.Push: transition = Transitions.First(t => t.Token == token && t.From == CurrentState); Stack.Insert(0, (T)transition.To); break; case Mode.PushPop: transition = Transitions.First(t => t.Token == token && t.From == CurrentState); if (Stack.Count > 0) { Stack.RemoveAt(0); } Stack.Insert(0, (T)transition.To); break; } CurrentState?.Enter(); Transitioned?.Invoke(transition); return; } while (Transitions.Count > 0); }
public bool CanStep(List <TuringTape> read) { return(Transitions.Any(c => c.IsMatch(read))); }
/// <summary> /// Return an IEnumerable of PDAResults after applying this PDA to the /// given input. /// </summary> public IEnumerable <PDAResult> MatchResults(string input) { // Catch empty initial string, which trivially matches an empty // stack acceptance PDA. if (input == "") { return(new List <PDAResult> { new PDAResult(0, 0, true) }); } // If there are no transitions that can move on the initial // configuration, or can remove items from the stack, fail quickly. if (!Transitions.Any(t => t.StackHead == '_' && t.OldState == StartState && t.InputChar == input[0]) || !Transitions.Any(t => t.StackReplace.Length == 0)) { return(new List <PDAResult> { new PDAResult(0, 0, false) }); } // HashSet to remove duplicate results. var resultList = new HashSet <PDAResult>(); var stateList = new List <PDARunState> { new PDARunState(input, 0, "", StartState) }; while (stateList.Count() > 0) { // HashSet to remove duplicate states. var newStateList = new HashSet <PDARunState>(); foreach (var state in stateList) { // Obtain the list of states reachable from this state. var nextStates = FindNextStates(state).ToList(); // No further states, so fail. if (nextStates.Count == 0) { resultList.Add(new PDAResult(state.MatchedSoFar, state.Stack.Length, false)); continue; } foreach (var nextState in nextStates) { // Check for accept/reject state with acceptance by // empty stack. if (nextState.Failure || nextState.Input == "" && nextState.Stack.Length == 0) { resultList.Add(new PDAResult(nextState.MatchedSoFar, nextState.Stack.Count(), !nextState.Failure)); } else { newStateList.Add(nextState); } } } stateList = newStateList.ToList(); } return(resultList.AsEnumerable()); }
/// <summary> /// Gets or sets the initial state. /// </summary> /// <value> The initial state. </value> public List <IState> GetInitialStates( ) { List <IState> initialStates = new List <IState> ( ); if (Transitions.Count == 1) { initialStates.Add((Transitions [0]).From); return(initialStates); } try { initialStates.AddRange(States.Where(state => state.Extended != null && state.Extended.GetValue <bool> (State.IsInitial))); } catch { // Temporary hack -- for supporting existing flows that don't have extensions registered yet. initialStates.AddRange(from trans in Transitions where (trans.To != null && trans.To.Count != 0 && trans.From != null) where !Transitions.Any(transition => transition.To.Contains(trans.From)) select trans.From); } if (initialStates.Count == 0) { throw new CyclicStateMapException( ); } return(initialStates); }