public AwaitableStateConfiguration <TState, TTrigger> PermitReentry <TArgument>(
ParameterizedTrigger <TTrigger, TArgument> trigger,
Action <Transition <TState, TTrigger>, TArgument> onTriggerAction)
{
return(Helper.Permit(this, null, trigger.Trigger,
CurrentStateRepresentation.State, onTriggerAction, AwaitableTransitionFlag.None));
}
public AwaitableStateConfiguration <TState, TTrigger> PermitIf <TArgument>(Func <Task <bool> > predicate,
ParameterizedTrigger <TTrigger, TArgument> trigger,
TState resultingState, Action <Transition <TState, TTrigger>, TArgument> onTriggerAction)
{
return(Helper.Permit(this, predicate, trigger.Trigger,
resultingState, onTriggerAction, AwaitableTransitionFlag.TriggerPredicateReturnsTask));
}
public async Task FireAsync <TArgument>(ParameterizedTrigger <TTrigger, TArgument> parameterizedTrigger,
TArgument argument)
{
if (Monitor.TryEnter())
{
try
{
if (!IsEnabled)
{
return;
}
await FireInternalAsync(parameterizedTrigger, argument).ConfigureAwait(false);
}
finally
{
Monitor.Exit();
}
}
else
{
if (IsEnabled)
{
throw new InvalidOperationException(
"State cannot be changed while in transition. Use the AsyncStateMachine instead, if these semantics are required.");
}
}
}
public AwaitableStateConfiguration <TState, TTrigger> Permit <TArgument>(
ParameterizedTrigger <TTrigger, TArgument> trigger, TState resultingState,
Func <Transition <TState, TTrigger>, TArgument, Task> onTriggerAction)
{
return(Helper.Permit(this, null, trigger.Trigger,
resultingState, onTriggerAction, AwaitableTransitionFlag.TriggerActionReturnsTask));
}
public virtual Task FireAsync <TArgument>(ParameterizedTrigger <TTrigger, TArgument> parameterizedTrigger,
TArgument argument)
{
return(!IsEnabled
? TaskHelpers.CompletedTask
: AwaitableExecutionHelper.FireCoreAsync(parameterizedTrigger, argument, this));
}
public Task FireAsync <TArgument>(ParameterizedTrigger <TTrigger, TArgument> parameterizedTrigger,
TArgument argument)
{
return(!IsEnabled
? Task.FromResult(false)
: RunOnScheduler(() => machine.FireInternalAsync(parameterizedTrigger, argument)));
}
public StateConfiguration <TState, TTrigger> PermitDynamic <TArgument>(
ParameterizedTrigger <TTrigger, TArgument> trigger,
Func <DynamicState <TState> > targetStatePredicate,
Action <Transition <TState, TTrigger>, TArgument> onEntryAction)
{
return(Helper.PermitDynamic(this, trigger, targetStatePredicate, onEntryAction));
}
public StateConfiguration <TState, TTrigger> PermitReentry <TArgument>(
ParameterizedTrigger <TTrigger, TArgument> trigger,
Action <Transition <TState, TTrigger>, TArgument> onEntryAction)
{
return(Helper.Permit(this, null, trigger, CurrentStateRepresentation.State,
onEntryAction));
}
public Task FireAsync <TArgument>(ParameterizedTrigger <TTrigger, TArgument> parameterizedTrigger,
TArgument argument)
{
if (IsEnabled)
{
var tcs = new TaskCompletionSource <bool>();
Action action = () => dispatcher.Execute(async() =>
{
await machine.FireAsync(parameterizedTrigger, argument);
tcs.SetResult(true);
if (!isInQueue)
{
RunFromQueueIfNotEmpty();
}
});
if (isRunning || isPaused)
{
lock (actionsQueue)
{
actionsQueue = actionsQueue.Enqueue(action);
queueCount++;
}
return(tcs.Task);
}
isRunning = true;
action();
return(tcs.Task);
}
return(TaskCache.FalseTask);
}
public StateSpecifier OnEntryFrom <TArg0>(ParameterizedTrigger <TArg0> trigger,
Action <TArg0, StateTransition> entryAction)
{
_specification.AddEntryAction(trigger.Trigger, (t, args) => entryAction(
ParameterPackager.Unpack <TArg0>(args, 0), t));
return(this);
}
internal static StateConfiguration <TState, TTrigger> Permit <TArgument, TState, TTrigger>(
StateConfiguration <TState, TTrigger> config, Func <bool> predicate,
ParameterizedTrigger <TTrigger, TArgument> trigger, TState resultingState,
Action <Transition <TState, TTrigger>, TArgument> onTriggerAction)
{
return(PermitCore(config, predicate, trigger.Trigger, resultingState, onTriggerAction));
}
internal static StateConfiguration <TState, TTrigger> PermitDynamic <TArgument, TState, TTrigger>(
StateConfiguration <TState, TTrigger> config, ParameterizedTrigger <TTrigger, TArgument> trigger,
Func <TArgument, DynamicState <TState> > targetStatePredicate,
Action <Transition <TState, TTrigger>, TArgument> onTriggerAction)
{
return(PermitDynamicCore(config, trigger.Trigger, targetStatePredicate, onTriggerAction));
}
public ParameterizedTrigger <TArg0, TArg1, TArg2> SetTriggerParameters <TArg0, TArg1, TArg2>(TTriggerType trigger)
{
var specification = new ParameterizedTrigger <TArg0, TArg1, TArg2>(trigger);
SaveTriggerSpecification(specification);
return(specification);
}
public AwaitableStateConfiguration <TState, TTrigger> PermitDynamic <TArgument>(
ParameterizedTrigger <TTrigger, TArgument> trigger,
Func <Task <DynamicState <TState> > > targetStateFunc,
Func <Transition <TState, TTrigger>, TArgument, Task> onTriggerAction)
{
return(PermitDynamic(trigger, a => targetStateFunc(), onTriggerAction));
}
public override async Task FireAsync <TArgument>(ParameterizedTrigger <TTrigger, TArgument> parameterizedTrigger,
TArgument argument)
{
if (!IsEnabled)
{
return;
}
var flag = true;
m_queueMonitor.Enter();
if (m_monitor.TryEnter())
{
// Try to execute inline if the process queue is empty.
if (m_queueCount == 0)
{
m_queueMonitor.Exit();
flag = false;
try { await base.FireAsync(parameterizedTrigger, argument); }
finally
{
m_queueMonitor.Enter();
if (m_queueCount > 0)
{
m_queueMonitor.Exit();
var _ = StartQueueIfNecessaryAsync(true);
// Should not exit monitor here. Its handled by the process queue.
}
else
{
m_queueMonitor.Exit();
m_monitor.Exit();
}
}
}
}
if (flag)
{
// Fast path was not taken. Queue up the delgates.
var tcs = new TaskCompletionSource <bool>();
m_actionsQueue = m_actionsQueue.Enqueue(async() =>
{
try
{
await base.FireAsync(parameterizedTrigger, argument);
tcs.TrySetResult(true);
}
catch (Exception ex) {
tcs.TrySetException(ex);
}
});
m_queueCount++;
m_queueMonitor.Exit();
var _ = StartQueueIfNecessaryAsync();
await tcs.Task;
}
}
public StateConfigurationHelper <TState, TTrigger> PermitReentry <TArgument>(
ParameterizedTrigger <TTrigger, TArgument> trigger, Action <TArgument> onEntryAction)
{
Contract.Requires(trigger != null);
Contract.Assume(currentStateRepresentation.State != null);
return(PermitInternal(null, trigger, currentStateRepresentation.State, onEntryAction));
}
public AwaitableStateConfiguration <TState, TTrigger> PermitDynamic <TArgument>(
ParameterizedTrigger <TTrigger, TArgument> trigger,
Func <DynamicState <TState> > targetStateFunc,
Action <Transition <TState, TTrigger>, TArgument> onTriggerAction)
{
return(Helper.PermitDynamic(this, trigger.Trigger, targetStateFunc,
onTriggerAction, AwaitableTransitionFlag.DynamicState));
}
public override void Fire <TArgument>(ParameterizedTrigger <TTrigger, TArgument> parameterizedTrigger,
TArgument argument)
{
lock (syncRoot)
{
base.Fire(parameterizedTrigger, argument);
}
}
public StateConfigurationHelper <TState, TTrigger> PermitIf <TArgument>(Func <bool> predicate,
ParameterizedTrigger <TTrigger, TArgument> trigger,
TState resultingState, Action <TArgument> onEntryAction)
{
Contract.Requires(trigger != null);
Contract.Requires(resultingState != null);
return(PermitInternal(predicate, trigger, resultingState, onEntryAction));
}
public AwaitableStateConfigurationHelper <TState, TTrigger> PermitReentry <TArgument>(
ParameterizedTrigger <TTrigger, TArgument> trigger,
Func <TArgument, Task> onEntryAsyncAction)
{
Contract.Requires(trigger != null);
Contract.Assume(currentStateRepresentation.State != null);
return(PermitInternalTriggerAsync(null, trigger, currentStateRepresentation.State, onEntryAsyncAction));
}
public AwaitableStateConfigurationHelper <TState, TTrigger> Permit <TArgument>(
ParameterizedTrigger <TTrigger, TArgument> trigger, TState resultingState,
Func <TArgument, Task> onEntryAsyncAction)
{
Contract.Requires(trigger != null);
Contract.Requires(resultingState != null);
return(PermitInternalTriggerAsync(null, trigger, resultingState, onEntryAsyncAction));
}
public AwaitableStateConfigurationHelper <TState, TTrigger> PermitReentryIf <TArgument>(
Func <Task <bool> > predicate,
ParameterizedTrigger <TTrigger, TArgument> trigger, Action <TArgument> onEntryAction)
{
Contract.Requires(trigger != null);
Contract.Assume(currentStateRepresentation.State != null);
return(PermitInternalPredicateAsync(predicate, trigger, currentStateRepresentation.State, onEntryAction));
}
public StateSpecifier PermitIf <TArg0>(ParameterizedTrigger <TArg0> trigger,
Func <TArg0, TStateType> destinationStateSelector, Func <bool> guard)
{
return(PermitIfInternal(
trigger.Trigger,
args => destinationStateSelector(
ParameterPackager.Unpack <TArg0>(args, 0)),
guard));
}
public static AwaitableStateConfiguration <TState, TTrigger> PermitReentryIf <TArgument, TState, TTrigger>(
this AwaitableStateConfiguration <TState, TTrigger> config, Func <Task <bool> > predicate,
ParameterizedTrigger <TTrigger, TArgument> trigger,
Action <TArgument> onTriggerAction)
{
Contract.Requires <ArgumentNullException>(onTriggerAction != null, nameof(onTriggerAction));
return(config.PermitReentryIf(predicate, trigger, (t, a) => onTriggerAction(a)));
}
public static AwaitableStateConfiguration <TState, TTrigger> PermitIf <TArgument, TState, TTrigger>(
this AwaitableStateConfiguration <TState, TTrigger> config, Func <bool> predicate,
ParameterizedTrigger <TTrigger, TArgument> trigger,
TState resultingState, Action <TArgument> onTriggerAction)
{
Contract.NotNull(onTriggerAction != null, nameof(onTriggerAction));
return(config.PermitIf(predicate, trigger, resultingState, (t, a) => onTriggerAction(a)));
}
public static StateConfiguration <TState, TTrigger> PermitReentry <TArgument, TState, TTrigger>(
this StateConfiguration <TState, TTrigger> config,
ParameterizedTrigger <TTrigger, TArgument> trigger, Action <TArgument> onTriggerAction)
{
Contract.NotNull(onTriggerAction != null, nameof(onTriggerAction));
return(config.PermitReentry(trigger,
(t, a) => onTriggerAction(a)));
}
public static AwaitableStateConfiguration <TState, TTrigger> PermitDynamic <TArgument, TState, TTrigger>(
this AwaitableStateConfiguration <TState, TTrigger> config, ParameterizedTrigger <TTrigger, TArgument> trigger,
Func <TArgument, DynamicState <TState> > targetStateFunc,
Func <TArgument, Task> onTriggerAction)
{
Contract.NotNull(onTriggerAction != null, nameof(onTriggerAction));
return(config.PermitDynamic(trigger, targetStateFunc, (t, a) => onTriggerAction(a)));
}
public virtual void Fire <TArgument>(ParameterizedTrigger <TTrigger, TArgument> parameterizedTrigger,
TArgument argument)
{
if (!IsEnabled)
{
return;
}
ExecutionHelper.FireCore(parameterizedTrigger, argument, this);
}
private void SaveTriggerSpecification(ParameterizedTrigger trigger)
{
if (_triggerSpecification.ContainsKey(trigger.Trigger))
{
throw new InvalidOperationException(
string.Format("trigger {0} already has been specified", trigger));
}
_triggerSpecification.Add(trigger.Trigger, trigger);
}
public static StateConfiguration <TState, TTrigger> PermitDynamic <TArgument, TState, TTrigger>(
this StateConfiguration <TState, TTrigger> config,
ParameterizedTrigger <TTrigger, TArgument> trigger,
Func <DynamicState <TState> > targetStatePredicate,
Action <TArgument> onTriggerAction)
{
Contract.Requires <ArgumentNullException>(onTriggerAction != null, nameof(onTriggerAction));
return(config.PermitDynamic(trigger, targetStatePredicate,
(t, a) => onTriggerAction(a)));
}
