/// <summary>
/// Initializes this machine.
/// </summary>
/// <returns></returns>
private static FiniteStateMachineState <MicroPlannerMessage> Initialize()
{
// generate states.
List <FiniteStateMachineState <MicroPlannerMessage> > states = FiniteStateMachineState <MicroPlannerMessage> .Generate(3);
// state 2 is final.
states[2].Final = true;
// 0
FiniteStateMachineTransition <MicroPlannerMessage> .Generate(states, 0, 0, typeof(MicroPlannerMessageArc));
FiniteStateMachineTransition <MicroPlannerMessage> .Generate(states, 0, 1, typeof(MicroPlannerMessagePoint),
new FiniteStateMachineTransitionCondition <MicroPlannerMessage> .FiniteStateMachineTransitionConditionDelegate(TestRoundaboutEntry));
// 1
FiniteStateMachineTransition <MicroPlannerMessage> .Generate(states, 1, 1, typeof(MicroPlannerMessagePoint),
new FiniteStateMachineTransitionCondition <MicroPlannerMessage> .FiniteStateMachineTransitionConditionDelegate(TestNonRoundaboutExit));
FiniteStateMachineTransition <MicroPlannerMessage> .Generate(states, 1, 1, typeof(MicroPlannerMessageArc),
new FiniteStateMachineTransitionCondition <MicroPlannerMessage> .FiniteStateMachineTransitionConditionDelegate(TestRoundaboutArc));
// 2
FiniteStateMachineTransition <MicroPlannerMessage> .Generate(states, 1, 2, typeof(MicroPlannerMessagePoint),
new FiniteStateMachineTransitionCondition <MicroPlannerMessage> .FiniteStateMachineTransitionConditionDelegate(TestRoundaboutExit));
// return the start automata with intial state.
return(states[0]);
}
/// <summary>
/// Initializes this machine.
/// </summary>
/// <returns></returns>
private static FiniteStateMachineState <MicroPlannerMessage> Initialize()
{
// generate states.
List <FiniteStateMachineState <MicroPlannerMessage> > states = FiniteStateMachineState <MicroPlannerMessage> .Generate(5);
// state 3 is final.
states[4].Final = true;
// 0
FiniteStateMachineTransition <MicroPlannerMessage> .Generate(states, 0, 1, typeof(MicroPlannerMessageArc));
// 1
FiniteStateMachineTransition <MicroPlannerMessage> .Generate(states, 1, 0, typeof(MicroPlannerMessagePoint),
new FiniteStateMachineTransitionCondition <MicroPlannerMessage> .FiniteStateMachineTransitionConditionDelegate(TestNonSignificantTurn));
FiniteStateMachineTransition <MicroPlannerMessage> .Generate(states, 1, 2, typeof(MicroPlannerMessagePoint),
new FiniteStateMachineTransitionCondition <MicroPlannerMessage> .FiniteStateMachineTransitionConditionDelegate(TestSignificantTurn));
// 2
FiniteStateMachineTransition <MicroPlannerMessage> .Generate(states, 2, 3, typeof(MicroPlannerMessageArc),
new FiniteStateMachineTransitionCondition <MicroPlannerMessage> .FiniteStateMachineTransitionConditionDelegate(TestVeryShortArc));
// 3
FiniteStateMachineTransition <MicroPlannerMessage> .Generate(states, 3, 4, typeof(MicroPlannerMessagePoint),
new FiniteStateMachineTransitionCondition <MicroPlannerMessage> .FiniteStateMachineTransitionConditionDelegate(TestSignificantTurn));
// return the start automata with intial state.
return(states[0]);
}
/// <summary>
///
/// </summary>
/// <param name="even"></param>
/// <param name="state"></param>
private void NotifyReset(EventType even, FiniteStateMachineState <EventType> state)
{
if (ResetEvent != null)
{
ResetEvent(even, state);
}
this.RaiseResetEvent(even, state);
}
/// <summary>
/// Notify listeners when a state transition occured.
/// </summary>
/// <param name="even"></param>
/// <param name="state"></param>
private void NotifyStateTransition(EventType even, FiniteStateMachineState <EventType> state)
{
if (StateTransitionEvent != null)
{
StateTransitionEvent(even, state);
}
this.RaiseStateTransitionEvent(even, state);
}
public FiniteStateMachine()
{
this._consumedEvents = (IList <EventType>) new List <EventType>();
FiniteStateMachineState <EventType> stateMachineState = this.BuildStates();
this._initialState = stateMachineState;
this._currentState = stateMachineState;
}
///// <summary>
///// Boolean indicating re-consumption.
///// </summary>
//private bool _reconsuming;
/// <summary>
/// Consumes the given event.
/// </summary>
/// <param name="even"></param>
/// <returns></returns>
public bool Consume(EventType even)
{
FiniteStateMachineState <EventType> old_state = _current_state;
// add to the consumed events.
_consumed_events.Add(even);
// if the type matches on of the outgoing transitions; change state; else revert to initial.
bool succes = false;
bool final = false;
foreach (FiniteStateMachineTransition <EventType> transition in _current_state.Outgoing)
{
if (transition.Match(this, even))
{
succes = true;
_current_state = transition.TargetState;
this.NotifyStateTransition(even, _current_state);
break;
}
}
// revert if unsuccesfull.
if (!succes)
{
if (!_current_state.ConsumeAll)
{
this.NotifyReset(even, _current_state);
//FiniteStateMachineState<EventType> from_state = _current_state;
this.Reset();
//if (!_reconsuming && from_state != _initial_state)
//{
// // event was not consumed and it was not refused in the inital state.
// _reconsuming = true;
// this.Consume(even);
// _reconsuming = false;
//}
}
}
else
{
if (_current_state.Final)
{
final = true;
this.NotifyFinalState(_consumed_events);
this.Reset();
}
}
// notify listeners for a consumed events.
//if (!_reconsuming)
//{
this.NotifyConsumption(even, _current_state, old_state);
//}
return(final);
}
/// <summary>
/// Notify listeners an event was consumed.
/// </summary>
/// <param name="even"></param>
/// <param name="newState"></param>
/// <param name="oldState"></param>
private void NotifyConsumption(EventType even,
FiniteStateMachineState <EventType> newState, FiniteStateMachineState <EventType> oldState)
{
if (ConsumptionEvent != null)
{
ConsumptionEvent(even, newState, oldState);
}
this.RaiseConsumptionEvent(even, newState, oldState);
}
/// <summary>
/// Creates a new finite state machine.
/// </summary>
public FiniteStateMachine(FiniteStateMachineState <EventType> initialState)
{
// create the consumed events list.
_consumedEvents = new List <EventType>();
// set state.
_initialState = initialState;
_currentState = initialState;
}
private void NotifyStateTransition(EventType even, FiniteStateMachineState <EventType> state)
{
// ISSUE: reference to a compiler-generated field
if (this.StateTransitionEvent != null)
{
// ISSUE: reference to a compiler-generated field
this.StateTransitionEvent(even, state);
}
this.RaiseStateTransitionEvent(even, state);
}
private void NotifyConsumption(EventType even, FiniteStateMachineState <EventType> newState, FiniteStateMachineState <EventType> oldState)
{
// ISSUE: reference to a compiler-generated field
if (this.ConsumptionEvent != null)
{
// ISSUE: reference to a compiler-generated field
this.ConsumptionEvent(even, newState, oldState);
}
this.RaiseConsumptionEvent(even, newState, oldState);
}
/// <summary>
/// Creates a new finite state machine.
/// </summary>
public FiniteStateMachine()
{
// create the consumed events list.
_consumedEvents = new List <EventType>();
// set state.
var initialState = this.BuildStates();
_initialState = initialState;
_currentState = initialState;
}
/// <summary>
/// Consumes the given event.
/// </summary>
/// <param name="even">The event.</param>
/// <returns>True if the machine is in a final state.</returns>
public bool Consume(EventType even)
{
var oldState = _currentState;
// add to the consumed events.
_consumedEvents.Add(even);
// if the type matches on of the outgoing transitions; change state; else revert to initial.
bool succes = false;
bool final = false;
foreach (var transition in _currentState.Outgoing)
{
if (transition.Match(this, even))
{
succes = true;
_currentState = transition.TargetState;
this.NotifyStateTransition(even, _currentState);
transition.NotifySuccessfull(even);
break;
}
}
// revert if unsuccesfull.
if (!succes)
{
if (!_currentState.ConsumeAll)
{
this.NotifyReset(even, _currentState);
this.Reset();
}
}
else
{
if (_currentState.Final)
{
final = true;
this.NotifyFinalState(_consumedEvents);
this.Reset();
}
}
this.NotifyConsumption(even, _currentState, oldState);
return(final);
}
/// <summary>
/// Initializes this machine.
/// </summary>
/// <returns></returns>
private static FiniteStateMachineState <MicroPlannerMessage> Initialize()
{
// generate states.
List <FiniteStateMachineState <MicroPlannerMessage> > states = FiniteStateMachineState <MicroPlannerMessage> .Generate(2);
// state 2 is final.
states[1].Final = true;
// 0
FiniteStateMachineTransition <MicroPlannerMessage> .Generate(states, 0, 0, typeof(MicroPlannerMessageArc));
FiniteStateMachineTransition <MicroPlannerMessage> .Generate(states, 0, 0, typeof(MicroPlannerMessagePoint),
new FiniteStateMachineTransitionCondition <MicroPlannerMessage> .FiniteStateMachineTransitionConditionDelegate(TestNonSignificantTurnNonPoi));
FiniteStateMachineTransition <MicroPlannerMessage> .Generate(states, 0, 1, typeof(MicroPlannerMessagePoint),
new FiniteStateMachineTransitionCondition <MicroPlannerMessage> .FiniteStateMachineTransitionConditionDelegate(TestPoi));
// return the start automata with intial state.
return(states[0]);
}
/// <summary>
/// Builds the initial states.
/// </summary>
/// <returns></returns>
protected override FiniteStateMachineState <MicroPlannerMessage> BuildStates()
{
// generate states.
List <FiniteStateMachineState <MicroPlannerMessage> > states = FiniteStateMachineState <MicroPlannerMessage> .Generate(3);
// state 3 is final.
states[2].Final = true;
// 0
FiniteStateMachineTransition <MicroPlannerMessage> .Generate(states, 0, 1, typeof(MicroPlannerMessageArc));
// 1
FiniteStateMachineTransition <MicroPlannerMessage> .Generate(states, 1, 1, typeof(MicroPlannerMessageArc));
FiniteStateMachineTransition <MicroPlannerMessage> .Generate(states, 1, 1, typeof(MicroPlannerMessagePoint),
new FiniteStateMachineTransitionCondition <MicroPlannerMessage> .FiniteStateMachineTransitionConditionDelegate(TestNonSignificantTurnNonPoi));
FiniteStateMachineTransition <MicroPlannerMessage> .Generate(states, 1, 2, typeof(MicroPlannerMessagePoint),
new FiniteStateMachineTransitionCondition <MicroPlannerMessage> .FiniteStateMachineTransitionConditionDelegate(TestPoi));
// return the start automata with intial state.
return(states[0]);
}
public bool Consume(EventType even)
{
FiniteStateMachineState <EventType> currentState = this._currentState;
this._consumedEvents.Add(even);
bool flag1 = false;
bool flag2 = false;
foreach (FiniteStateMachineTransition <EventType> machineTransition in (IEnumerable <FiniteStateMachineTransition <EventType> >) this._currentState.Outgoing)
{
if (machineTransition.Match(this, (object)even))
{
flag1 = true;
this._currentState = machineTransition.TargetState;
this.NotifyStateTransition(even, this._currentState);
machineTransition.NotifySuccessfull((object)even);
break;
}
}
if (!flag1)
{
if (!this._currentState.ConsumeAll)
{
this.NotifyReset(even, this._currentState);
this.Reset();
}
}
else if (this._currentState.Final)
{
flag2 = true;
this.NotifyFinalState(this._consumedEvents);
this.Reset();
}
this.NotifyConsumption(even, this._currentState, currentState);
return(flag2);
}
/// <summary>
/// Resets this machine.
/// </summary>
public void Reset()
{
_consumedEvents.Clear();
_currentState = _initialState;
}
/// <summary>
/// Raizes the state transition event.
/// </summary>
/// <param name="even"></param>
/// <param name="state"></param>
protected virtual void RaiseStateTransitionEvent(EventType even, FiniteStateMachineState <EventType> state)
{
}
public FiniteStateMachine(FiniteStateMachineState <EventType> initialState)
{
this._consumedEvents = (IList <EventType>) new List <EventType>();
this._initialState = initialState;
this._currentState = initialState;
}
/// <summary>
/// Raises the reset event.
/// </summary>
/// <param name="even"></param>
/// <param name="state"></param>
protected virtual void RaiseResetEvent(EventType even, FiniteStateMachineState <EventType> state)
{
}
/// <summary>
/// Raizes the comsumption event.
/// </summary>
/// <param name="even"></param>
/// <param name="newState"></param>
/// <param name="oldState"></param>
protected virtual void RaiseConsumptionEvent(EventType even, FiniteStateMachineState <EventType>
newState, FiniteStateMachineState <EventType> oldState)
{
}
/// <summary>
/// Called when a reset event occured.
/// </summary>
/// <param name="even"></param>
/// <param name="state"></param>
protected override void RaiseResetEvent(MicroPlannerMessage even, FiniteStateMachineState <MicroPlannerMessage> state)
{
this.Planner.ReportReset(this);
}
public void Reset()
{
this._consumedEvents.Clear();
this._currentState = this._initialState;
}
/// <summary>
/// Resets this machine.
/// </summary>
public void Reset()
{
_consumed_events.Clear();
_current_state = _initial_state;
}
/// <summary>
/// Creates a new event machine.
/// </summary>
/// <param name="initial"></param>
/// <param name="planner"></param>
/// <param name="priority"></param>
protected MicroPlannerMachine(FiniteStateMachineState <MicroPlannerMessage> initial, MicroPlanner planner, int priority)
: base(initial)
{
_planner = planner;
_priority = priority;
}
public void AddStateToStack(FiniteStateMachineState state)
{
statesStack.Push(state);
}
