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);
}
