public bool RequestEventFire(ITransitionInvoker <TState> transitionInvoker, bool overrideNoThrow)
{
this.EnsureCurrentStateSuitableForTransition();
bool success;
// Try and fire it on the child state machine - see if that works
// If we got to here, this.CurrentState != null
var childStateMachine = this.CurrentState.ChildStateMachine;
if (childStateMachine != null && childStateMachine.RequestEventFire(transitionInvoker, overrideNoThrow: true))
{
success = true;
}
else
{
// No? Invoke it on ourselves
success = transitionInvoker.TryInvoke(this.CurrentState);
if (!success)
{
this.HandleTransitionNotFound(transitionInvoker.Event, throwException: !overrideNoThrow && transitionInvoker.EventFireMethod == EventFireMethod.Fire);
}
}
return(success);
}
private bool ForceTransitionFromUserImpl(ITransitionInvoker <TState> transitionInvoker)
{
transitionInvoker.TryInvoke(this.CurrentState);
return(true);
//this.Kernel.CoordinateTransition(this.CurrentState, toState, @event, false, null);
//return true;
}
public void ForceTransitionFromUser(ITransitionInvoker <TState> transitionInvoker)
{
if (this.Kernel.Synchronizer != null)
{
this.Kernel.Synchronizer.ForceTransition(() => this.InvokeTransition(this.ForceTransitionFromUserImpl, transitionInvoker));
}
else
{
this.InvokeTransition(this.ForceTransitionFromUserImpl, transitionInvoker);
}
}
// invoker: Action which actually triggers the transition. Takes the state to transition from, and returns whether the transition was found
public bool RequestEventFireFromEvent(ITransitionInvoker <TState> transitionInvoker)
{
// TODO: I don't like how many delegates are created here
if (this.Kernel.Synchronizer != null)
{
return(this.Kernel.Synchronizer.FireEvent(() => this.InvokeTransition(this.RequestEventFire, transitionInvoker), transitionInvoker.EventFireMethod));
}
else
{
return(this.InvokeTransition(this.RequestEventFire, transitionInvoker));
}
}
bool IStateMachine <State> .RequestEventFire(ITransitionInvoker <State> transitionInvoker, bool overrideNoThrow)
{
return(this.InnerStateMachine.RequestEventFire(transitionInvoker, overrideNoThrow));
}
public TransitionQueueItem(Func <ITransitionInvoker <TState>, bool> method, ITransitionInvoker <TState> transitionInvoker)
{
this.method = method;
this.transitionInvoker = transitionInvoker;
}
public void EnqueueTransition(Func <ITransitionInvoker <TState>, bool> method, ITransitionInvoker <TState> invoker)
{
this.transitionQueue.Enqueue(new TransitionQueueItem(method, invoker));
}
private bool InvokeTransition(Func <ITransitionInvoker <TState>, bool> method, ITransitionInvoker <TState> transitionInvoker)
{
if (this.Kernel.Fault != null)
{
throw new StateMachineFaultedException(this.Kernel.Fault);
}
if (this.Kernel.ExecutingTransition)
{
this.Kernel.EnqueueTransition(method, transitionInvoker);
return(true);
}
bool success;
try
{
this.Kernel.ExecutingTransition = true;
success = method(transitionInvoker);
}
catch (InternalTransitionFaultException e)
{
var faultInfo = new StateMachineFaultInfo(this.outerStateMachine, e.FaultedComponent, e.InnerException, e.From, e.To, e.Event, e.Group);
this.Kernel.SetFault(faultInfo);
throw new TransitionFailedException(faultInfo);
}
finally
{
this.Kernel.ExecutingTransition = false;
}
this.Kernel.FireQueuedTransitions();
return(success);
}
private bool RequestEventFire(ITransitionInvoker <TState> transitionInvoker)
{
return(this.RequestEventFire(transitionInvoker, overrideNoThrow: false));
}
