private void Prepare (ModelProgram program) {
var actionSymbols = program.ActionSymbols ();
var _states = new Dictionary <SimpleState, int> ();
var _trans = new Dictionary <SimpleState, List <SimpleState>> ();
var frontier = new LinkedList <IState> (new [] { program.InitialState });
var stateIndex = 0;
while (frontier.Count > 0) {
var state = (SimpleState) frontier.First.Value;
frontier.RemoveFirst ();
if (! _states.ContainsKey (state))
_states.Add (state, stateIndex ++);
foreach (var action in actionSymbols.
Where (symbol => program.IsPotentiallyEnabled (state, symbol)).
SelectMany (symbol => program.GetActions (state, symbol))) {
TransitionProperties properties;
var target =
(SimpleState) program.GetTargetState (state, action, Set <string>.EmptySet, out properties);
if (! _trans.ContainsKey (state))
_trans.Add (state, new List <SimpleState> ());
_trans [state].Add (target);
if (! (_states.ContainsKey (target) || frontier.Contains (target)))
frontier.AddFirst (target);
}
}
foreach (var state in _states) {
var list = new List <string> ();
for (var i = 0; i < state.Key.LocationValuesCount; ++ i)
list.Add (string.Format ("{0}={1}", state.Key.GetLocationName (i), state.Key.GetLocationValue (i)));
this.states.Add (state.Value, list);
}
foreach (var transition in _trans) {
this.transitions.Add (_states [transition.Key],
transition.Value.Select (state => _states [state]).ToList ());
}
for (var i = 0; i < stateIndex; ++ i) {
if (! this.transitions.ContainsKey (i))
this.transitions.Add (i, new List <int> ());
}
}
/// <summary>
/// Explores the model associated with this instance.
/// The dictionary stateMap (if not null) is used to record the mapping
/// from generated finite automata states to IStates.
/// Explore(null) is the same as Explore()
/// </summary>
/// <returns>A list of transitions. Each transition is a start state,
/// an action label and an end state.</returns>
public FSM Explore(Dictionary <Term, IState> generatedStateMap)
{
Set <Symbol> actionSymbols = modelProgram.ActionSymbols();
IState initialState = modelProgram.InitialState;
Dictionary <IState, int> states = new Dictionary <IState, int>();
LinkedList <IState> frontier = new LinkedList <IState>();
frontier.AddFirst(initialState);
int nextStateId = 0;
Dictionary <Transition, Transition> transitions = new Dictionary <Transition, Transition>();
while (frontier.Count > 0)
{
IState startState = frontier.First.Value;
frontier.RemoveFirst();
if (!states.ContainsKey(startState))
{
states.Add(startState, nextStateId++);
}
foreach (Symbol actionSymbol in actionSymbols)
{
if (modelProgram.IsPotentiallyEnabled(startState, actionSymbol))
{
IEnumerable <CompoundTerm> actions = modelProgram.GetActions(startState, actionSymbol);
foreach (CompoundTerm action in actions)
{
TransitionProperties transitionProperties;
IState targetState = modelProgram.GetTargetState(startState, action, Set <string> .EmptySet, out transitionProperties);
if (IncludeTransition(startState, action, targetState, transitionProperties.Properties))
{
Transition t = new Transition(startState, action, targetState);
transitions.Add(t, t);
if (!states.ContainsKey(targetState) && !frontier.Contains(targetState))
{
frontier.AddFirst(targetState);
}
}
}
}
}
}
Term automatonInitialState = new Literal(states[initialState]);
Set <Term> automatonStates = Set <Term> .EmptySet;
Set <Term> acceptingStates = Set <Term> .EmptySet;
foreach (KeyValuePair <IState, int> kv in states)
{
Term automatonState = new Literal(kv.Value);
automatonStates = automatonStates.Add(automatonState);
if (modelProgram.IsAccepting(kv.Key))
{
acceptingStates = acceptingStates.Add(automatonState);
}
if (generatedStateMap != null)
{
generatedStateMap[automatonState] = kv.Key;
}
}
Set <Triple <Term, CompoundTerm, Term> > automatonTransitions = Set <Triple <Term, CompoundTerm, Term> > .EmptySet;
foreach (KeyValuePair <Transition, Transition> kv in transitions)
{
Transition t = kv.Key;
automatonTransitions = automatonTransitions.Add(new Triple <Term, CompoundTerm, Term>(new Literal(states[t.startState]),
t.action,
new Literal(states[t.targetState])));
}
return(new FSM(automatonInitialState, automatonStates, automatonTransitions, acceptingStates));
}