public StateFluentBuilder(IBuilderFactory factory, TOuterBuilder outerBuilder, Action <IState> builtAction)
{
_factory = factory ?? throw new ArgumentNullException(nameof(factory));
_builder = factory.CreateStateBuilder(null);
_outerBuilder = outerBuilder;
_builtAction = builtAction;
}
public StateBuilder(IStateBuilder parent, object stateId, IStateBuilderContext context)
{
Parent = parent;
Id = stateId;
Context = context;
substates = new List<IBaseStateBuilder>();
secondPassActions = new List<Action<State>>();
}
/// <inheritdoc/>
public virtual StateDefinition AddState(Func <IStateBuilderFactory, IStateBuilder> stateSetup)
{
if (stateSetup == null)
{
throw new ArgumentNullException(nameof(stateSetup));
}
IStateBuilder builder = stateSetup(new StateBuilderFactory(this));
return(this.AddState(builder.Build()));
}
public TransitionBuilder(IStateBuilder stateBuilder, object eventId)
{
this.eventId = eventId;
this.stateBuilder = stateBuilder;
stateBuilder.AddSecondPassAction(s =>
{
s.AddTransition(CreateTransition());
});
}
private static void AddTimeout(IStateBuilder builder, int timeoutInMilliseconds)
{
if (!builder.Context.HasPlugIn<TimerPlugin>())
builder.Context.AddPlugIn(new TimerPlugin());
if (!builder.Context.HasPlugIn<TimeoutPlugin>())
builder.Context.AddPlugIn(new TimeoutPlugin());
builder.AddSecondPassAction(s =>
{
var timerPlugin = builder.Context.GetPlugIn<TimerPlugin>();
var timeoutPlugin = builder.Context.GetPlugIn<TimeoutPlugin>();
var timeout = new TimeoutEvent(timeoutInMilliseconds, s, timeoutPlugin.PostTimeout);
timerPlugin.AddTimer(timeout);
});
}
public virtual IStateBuilder CreateStateBuilder(object stateId, IStateBuilder parent)
{
return new StateBuilder(parent, stateId, Context);
}
public void Configure(IStateBuilder <TesTSubject> builder)
{
builder
.On <Test1Action>().Handle <Test1ActionHandler>()
.On <Test2Action>().Handle <Test2ActionHandler>();
}
public TransitionBuilder(IStateBuilder stateBuilder, object eventId, object targetStateId)
: this(stateBuilder, eventId)
{
this.targetStateId = targetStateId;
}
/// <summary>
/// Adds a valid next state to this state.
/// </summary>
/// <param name="message">The transition message.</param>
/// <param name="nextState">The valid next state.</param>
/// <returns>The transition builder.</returns>
public IStateTransitionBuilder <TState, TTransition, TPayload> AddValidTransition(TTransition message, IStateBuilder <TState, TTransition, TPayload> nextState)
{
if (this.nextStates.ContainsKey(message))
{
throw new ArgumentException($"Cannot add duplicate transition from {this.State} -> {((StateBuilder<TState, TTransition, TPayload>)nextState).State}. with transition {message}.");
}
var transition = new StateTransitionBuilder <TState, TTransition, TPayload>(message, this.stateMachine, this, (StateBuilder <TState, TTransition, TPayload>)nextState);
this.nextStates.Add(message, transition);
return(transition);
}
public static IBaseStateBuilder CreateDeepHistoryBuilder(IStateBuilder parent)
{
return new HistoryStateBuilder(parent, HistoryState.GetDeepState);
}
public static IBaseStateBuilder CreateShallowHistoryBuilder(IStateBuilder parent)
{
return new HistoryStateBuilder(parent, HistoryState.GetShallowState);
}
protected HistoryStateBuilder(IStateBuilder parent, HistoryState.HistoryFetchStrategy historyStrategy)
{
this.id = new HistoryStateId(parent.Id);
this.historyStrategy = historyStrategy;
}
internal ActionBuilder(ConcurrentDictionary <string, Func <IServiceProvider, object> > actions, IStateBuilder <TSubject> builder)
{
this.actions = actions;
this.builder = builder;
}
/// <summary>
/// Adds a valid next state to this state.
/// </summary>
/// <param name="message">The message.</param>
/// <param name="nextState">The valid next state.</param>
/// <returns>This.</returns>
public IStateTransitionBuilder <TState, TTransition, TPayload> AddValidTransition(TTransition message, IStateBuilder <TState, TTransition, TPayload> nextState)
{
return(this.StartState.AddValidTransition(message, nextState));
}
public static IStateBuilder <T, TParent> Concrete <T, TParent>(this IStateBuilder <T, TParent> builder, object concreteState)
where T : AbstractState, new()
{
if (concreteState == null)
{
return(builder);
}
var info = ConcreteStateDeclarations.ResolveStateInfo(concreteState.GetType());
bool isEntered = false;
return(builder
///
/// Awake State
.Awake(state =>
{
if (info.Awake != null && concreteState != null)
{
info.Awake.Invoke(concreteState, null);
}
})
///
/// Destroy State
.Destroy(state =>
{
if (info.OnDestroy != null && concreteState != null)
{
info.OnDestroy.Invoke(concreteState, null);
}
})
///
/// Enter State
.Enter(state =>
{
isEntered = true;
if (info.OnEnter != null && concreteState != null)
{
info.OnEnter.Invoke(concreteState, null);
}
})
///
/// Exit State
.Exit(state =>
{
if (isEntered)
{
isEntered = false;
if (info.OnExit != null && concreteState != null)
{
info.OnExit.Invoke(concreteState, null);
}
}
})
///
/// Update State
.Update((state, deltaTime) =>
{
if (info.Update != null && concreteState != null)
{
info.Update.Invoke(concreteState, null);
}
}));
}
