private StateMachine<string, char> CreateMachine()
{
var machine = new StateMachine<string, char>(off);
Action log = () =>
{
C.WriteLine(this.color, "switched pre {1}: {0}", machine.Id, machine.State);
//Thread.Sleep(1000);
C.WriteLine(this.color, "switched post {1}: {0}", machine.Id, machine.State);
};
machine
.Configure(off)
.Permit(space, on)
.OnEntry(log);
machine
.Configure(on)
.Permit(space, off)
.OnEntry(log);
return machine;
}
private StateMachine<ImportFinancialGuaranteeStatus, Trigger> CreateStateMachine()
{
var stateMachine = new StateMachine<ImportFinancialGuaranteeStatus, Trigger>(() => Status, s => Status = s);
stateMachine.OnTransitioned(OnTransitionAction);
completeTrigger = stateMachine.SetTriggerParameters<DateTime>(Trigger.Complete);
stateMachine.Configure(ImportFinancialGuaranteeStatus.ApplicationReceived)
.Permit(Trigger.Complete, ImportFinancialGuaranteeStatus.ApplicationComplete);
stateMachine.Configure(ImportFinancialGuaranteeStatus.ApplicationComplete)
.OnEntryFrom(completeTrigger, OnComplete)
.Permit(Trigger.Approve, ImportFinancialGuaranteeStatus.Approved)
.Permit(Trigger.Refuse, ImportFinancialGuaranteeStatus.Refused);
stateMachine.Configure(ImportFinancialGuaranteeStatus.Approved)
.Permit(Trigger.Release, ImportFinancialGuaranteeStatus.Released);
return stateMachine;
}
public Download ()
{
State = Bo.State.Waiting;
_machine = new StateMachine<State, Transition>(() => State, s => State = s);
_machine.Configure (Bo.State.Waiting)
.Permit (Transition.Cancel, Bo.State.Finished)
.Permit (Transition.Fail, Bo.State.Error)
.Permit (Transition.Resume, Bo.State.Downloading);
_machine.Configure (Bo.State.Downloading)
.Permit (Transition.Pause, Bo.State.Waiting)
.PermitReentry (Transition.Progress)
.Permit (Transition.Cancel, Bo.State.Finished)
.Permit (Transition.Finish, Bo.State.Finished)
.Permit (Transition.Fail, Bo.State.Error);
_machine.Configure (Bo.State.Finished);
_machine.Configure (Bo.State.Error)
.Permit (Transition.Retry, Bo.State.Waiting)
.Permit (Transition.Cancel, Bo.State.Finished)
.Permit (Transition.Fail, Bo.State.Finished);
}
/* ----------------------------------------
* STATEMACHINE DEFINITION
* ---------------------------------------*/
private void CreateStateMachine()
{
// define strongly typed triggers (events)
_rfqEventServerSendsQuote = _stateMachine.SetTriggerParameters<IQuote>(RfqEvent.ServerNewQuote);
_rfqEventServerSendsExecutionReport = _stateMachine.SetTriggerParameters<IExecutionReport>(RfqEvent.ServerSendsExecutionReport);
_rfqEventServerQuoteError = _stateMachine.SetTriggerParameters<Exception>(RfqEvent.ServerQuoteError);
_rfqEventServerCancellationError = _stateMachine.SetTriggerParameters<Exception>(RfqEvent.ServerCancellationError);
_rfqEventServerExecutionError = _stateMachine.SetTriggerParameters<Exception>(RfqEvent.ServerExecutionError);
_rfqEventUserRequests = _stateMachine.SetTriggerParameters<IQuoteRequest>(RfqEvent.UserRequests);
_rfqEventUserExecutes = _stateMachine.SetTriggerParameters<IExecutionRequest>(RfqEvent.UserExecutes);
_rfqEventUserCancels = _stateMachine.SetTriggerParameters<long>(RfqEvent.UserCancels);
_stateMachine.OnUnhandledTrigger(OnUnhandledTrigger);
_stateMachine.Configure(RfqState.Input)
.OnEntry(LogTransition)
.Permit(RfqEvent.UserRequests, RfqState.Requesting);
_stateMachine.Configure(RfqState.Requesting)
.OnEntry(LogTransition)
.OnEntryFrom(_rfqEventUserRequests, OnEntryRequesting)
.Permit(RfqEvent.ServerNewQuote, RfqState.Quoted)
.Permit(RfqEvent.UserCancels, RfqState.Cancelling)
.Permit(RfqEvent.InternalError, RfqState.Error);
_stateMachine.Configure(RfqState.Quoted)
.OnEntry(LogTransition)
.OnEntryFrom(_rfqEventServerSendsQuote, OnEntryQuoted)
.PermitReentry(RfqEvent.ServerNewQuote)
.Permit(RfqEvent.UserCancels, RfqState.Cancelling)
.Permit(RfqEvent.UserExecutes, RfqState.Executing)
.OnExit(OnExitQuoted);
_stateMachine.Configure(RfqState.Executing)
.OnEntry(LogTransition)
.OnEntryFrom(_rfqEventUserExecutes, OnEntryExecuting)
.Permit(RfqEvent.ServerSendsExecutionReport, RfqState.Done);
_stateMachine.Configure(RfqState.Cancelling)
.OnEntry(LogTransition)
.OnEntryFrom(_rfqEventUserCancels, OnEntryCancelling)
.Permit(RfqEvent.ServerCancelled, RfqState.Cancelled);
_stateMachine.Configure(RfqState.Cancelled)
.OnEntry(LogTransition)
.OnEntry(OnEntryCancelled);
_stateMachine.Configure(RfqState.Done)
.OnEntry(LogTransition)
.OnEntryFrom(_rfqEventServerSendsExecutionReport, OnEntryDone);
_stateMachine.Configure(RfqState.Error)
.OnEntry(LogTransition)
.OnEntryFrom(_rfqEventServerQuoteError, OnEntryError)
.OnEntryFrom(_rfqEventServerExecutionError, OnEntryError);
}
static void Main(string[] args)
{
try
{
string on = "On", off = "Off";
var space = ' ';
var onOffSwitch = new StateMachine<string, char>(off);
onOffSwitch.Configure(off).Permit(space, on);
onOffSwitch.Configure(on).Permit(space, off);
Console.WriteLine("Press <space> to toggle the switch. Any other key will raise an error.");
while (true)
{
Console.WriteLine("Switch is in state: " + onOffSwitch.State);
var pressed = Console.ReadKey(true).KeyChar;
onOffSwitch.Fire(pressed);
}
}
catch (Exception ex)
{
Console.WriteLine("Exception: " + ex.Message);
Console.WriteLine("Press any key to continue...");
Console.ReadKey(true);
}
}
public AudioController()
{
App.Startup();
#region Rpc
_acRpcServer = new AudioControllerRpcServer(this);
_achRpcClient = new AudioControllerHandlerRpcClient();
_audioControllerHandler = _achRpcClient.Service;
#endregion
_stateMachine = BuildStateMachine();
_mediaEnvironment.RegisterDefaultCodecs();
_playModeManager = IoC.Get<IPlayModeManager>();
_mediaPlayer = BackgroundMediaPlayer.Current;
_mediaPlayer.AutoPlay = false;
_mediaPlayer.MediaOpened += mediaPlayer_MediaOpened;
_mediaPlayer.MediaFailed += mediaPlayer_MediaFailed;
_mediaPlayer.MediaEnded += mediaPlayer_MediaEnded;
_playbackSession = _mediaPlayer.PlaybackSession;
_playbackSession.PlaybackStateChanged += playbackSession_PlaybackStateChanged;
_playbackSession.NaturalDurationChanged += playbackSession_NaturalDurationChanged;
_playbackSession.SeekCompleted += playbackSession_SeekCompleted;
_mtService = new MediaTransportService(_mediaPlayer.SystemMediaTransportControls);
_mtService.IsEnabled = _mtService.IsPauseEnabled = _mtService.IsPlayEnabled = true;
_mtService.ButtonPressed += _mtService_ButtonPressed;
NotifyReady();
}
private static StateMachine<ProductStatus, ProductStatus> InitializeStateMachine(ProductStatus initialState)
{
StateMachine<ProductStatus, ProductStatus> productStateMachine =
new StateMachine<ProductStatus, ProductStatus>(initialState);
productStateMachine.Configure(ProductStatus.Draft)
.Permit(ProductStatus.WaitingForApproval, ProductStatus.WaitingForApproval);
productStateMachine.Configure(ProductStatus.WaitingForApproval)
.Permit(ProductStatus.Approved, ProductStatus.Approved)
.Permit(ProductStatus.Cancelled, ProductStatus.Cancelled);
productStateMachine.Configure(ProductStatus.Approved)
.Permit(ProductStatus.Active, ProductStatus.Active)
.Permit(ProductStatus.Passive, ProductStatus.Passive)
.Permit(ProductStatus.Cancelled, ProductStatus.Cancelled);
productStateMachine.Configure(ProductStatus.Active)
.Permit(ProductStatus.Passive, ProductStatus.Passive)
.Permit(ProductStatus.Cancelled, ProductStatus.Cancelled);
productStateMachine.Configure(ProductStatus.Passive)
.Permit(ProductStatus.Active, ProductStatus.Active)
.Permit(ProductStatus.Cancelled, ProductStatus.Cancelled);
// Allow none of the options for AccommodationPropertyStatus.Cancelled;
return productStateMachine;
}
public ImportNotificationAssessment(Guid notificationId)
{
NotificationApplicationId = notificationId;
Dates = new ImportNotificationDates();
Status = ImportNotificationStatus.New;
stateMachine = CreateStateMachine();
}
internal static StateMachine<State, Trigger> GetStateMachine()
{
var machine = new StateMachine<State, Trigger>(State.WaitingForStart);
machine.Configure(State.WaitingForStart)
.Permit(Trigger.DataLinkEscapeRead, State.Started);
machine.Configure(State.Started)
.Permit(Trigger.StartOfTextRead, State.ReadingMessageType)
.Permit(Trigger.UnexpectedCharacter, State.WaitingForStart);
machine.Configure(State.ReadingMessageType)
.Permit(Trigger.MessageTypeRead, State.ReadingMessageLength)
.Permit(Trigger.UnexpectedCharacter, State.WaitingForStart);
machine.Configure(State.ReadingMessageLength)
.Permit(Trigger.MessageLengthRead, State.BuildingMessage);
machine.Configure(State.BuildingMessage)
.Permit(Trigger.MessageTextRead, State.ReadingCheckSum);
machine.Configure(State.ReadingCheckSum)
.Permit(Trigger.CheckSumPassed, State.CheckSumRead)
.Permit(Trigger.CheckSumFailed, State.WaitingForStart);
machine.Configure(State.CheckSumRead)
.Permit(Trigger.DataLinkEscapeRead, State.MessageDone)
.Permit(Trigger.UnexpectedCharacter, State.WaitingForStart);
machine.Configure(State.MessageDone)
.Permit(Trigger.MessageFinished, State.WaitingForStart)
.Permit(Trigger.UnexpectedCharacter, State.WaitingForStart);
return machine;
}
public Bug(string title)
{
_title = title;
var _machine = StateMachine<State, Trigger>.Create(() => _state, s => _state = s);
_assignTrigger = _machine.SetTriggerParameters<string>(Trigger.Assign);
_machine.Configure(State.Open)
.Permit(Trigger.Assign, State.Assigned);
_machine.Configure(State.Assigned)
.SubstateOf(State.Open)
.OnEntryFrom(_assignTrigger, assignee => OnAssigned(assignee))
.PermitReentry(Trigger.Assign)
.Permit(Trigger.Close, State.Closed)
.Permit(Trigger.Defer, State.Deferred)
.OnExit(() => OnDeassigned());
_machine.Configure(State.Deferred)
.OnEntry(() => _assignee = null)
.Permit(Trigger.Assign, State.Assigned);
this._machine = _machine.FinishConfiguration();
}
public MainLogicProcessor()
{
VisionData = new VisionData();
SensorData = new SensorData();
stateMachine = new StateMachine<State, Trigger>(State.LookingForBall);
stateMachine.Configure(State.LookingForBall)
.Permit(Trigger.CameraLockedOnBall, State.ClosingInOnBall)
.Permit(Trigger.BallCaught, State.FindingGoal)
.OnEntry(StopTimer);
stateMachine.Configure(State.ClosingInOnBall)
.Permit(Trigger.CameraLostBall, State.LookingForBall)
.Permit(Trigger.BallCaught, State.FindingGoal)
.Permit(Trigger.Timeout, State.LookingForBall)
.OnEntry(() => StartTimer(10000, Trigger.Timeout))
.OnExit(StopTimer);
stateMachine.Configure(State.FindingGoal)
.Permit(Trigger.CoilgunLaunched, State.LookingForBall)
.Permit(Trigger.BallLost, State.LookingForBall)
.Permit(Trigger.Timeout, State.LookingForBall)
.OnEntry(() => StartTimer(5000, Trigger.Timeout))
.OnExit(StopTimer);
}
/// <summary>
/// Set up the StateMachine for this workflow by adding States and Triggers
/// specified in StateConfigs
/// </summary>
/// <returns>WorkflowProcessor for fluent interface</returns>
public WorkflowProcessor ConfigureStateMachine()
{
Enforce.That(string.IsNullOrEmpty(this.step.State) == false,
"WorkflowProcessor.Confgiure - step.State can not be empty");
this.stateMachine = new StateMachine<string, string>(this.step.State);
// Get a distinct list of states with a trigger from state configuration
// "State => Trigger => TargetState
var states = this.workflow.StateConfigs.AsQueryable()
.Select(x => x.State)
.Distinct()
.Select(x => x)
.ToList();
// Assing triggers to states
states.ForEach(state =>
{
var triggers = this.workflow.StateConfigs.AsQueryable()
.Where(config => config.State == state)
.Select(config => new { Trigger = config.Trigger, TargeState = config.TargetState })
.ToList();
triggers.ForEach(trig =>
{
this.stateMachine.Configure(state).Permit(trig.Trigger, trig.TargeState);
});
});
return this;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="transition">The transition object that was created for the state change</param>
public ReplicationStateTransition(StateMachine<ReplicationState, ReplicationTrigger>.Transition transition)
{
if (transition != null) {
Source = transition.Source;
Destination = transition.Destination;
Trigger = transition.Trigger;
}
}
internal FinancialGuarantee(DateTime receivedDate)
{
CreatedDate = new DateTimeOffset(SystemTime.UtcNow, TimeSpan.Zero);
ReceivedDate = receivedDate;
StatusChangeCollection = new List<FinancialGuaranteeStatusChange>();
stateMachine = CreateStateMachine();
Status = FinancialGuaranteeStatus.ApplicationReceived;
Decision = FinancialGuaranteeDecision.None;
}
public void verify_context_passthrough()
{
var transition = new StateMachine<StateType, TriggerType>.Transition(StateType.New, StateType.UnderReview,
TriggerType.Ignore);
var stateStepInfo = new EntryStateTaskInfo<StateType, TriggerType, TriggerContext>(new TriggerContext { DocumentId = 5 }, transition);
Assert.That(stateStepInfo.Context.DocumentId, Is.EqualTo(5));
}
public ApplicationState(IDepartmentService departmentService, ISettingService settingService,
ICacheService cacheService)
{
_screenState = new StateMachine<AppScreens, AppScreens>(() => ActiveAppScreen, state => ActiveAppScreen = state);
_screenState.OnUnhandledTrigger(HandleTrigger);
_departmentService = departmentService;
_settingService = settingService;
_cacheService = cacheService;
CurrentTicketType = TicketType.Default;
}
public Rfq(IRfqService rfqService, IConcurrencyService concurrencyService)
{
_rfqService = rfqService;
_concurrencyService = concurrencyService;
_stateMachine = new StateMachine<RfqState, RfqEvent>(RfqState.Input);
_rfqUpdateSubject = new BehaviorSubject<RfqUpdate>(new RfqUpdate(RfqState.Input, null, null));
_disposables = new CompositeDisposable(_cancellationSubscription, _executionSubscription, _requestSubscription);
CreateStateMachine();
}
internal Movement(int movementNumber, Guid notificationId, DateTime date, Guid createdBy)
{
Number = movementNumber;
NotificationId = notificationId;
Date = date;
CreatedBy = createdBy.ToString();
Status = MovementStatus.New;
StatusChangeCollection = new List<MovementStatusChange>();
stateMachine = CreateStateMachine();
}
/// <summary>
/// ctor that configures the state machine according to document type.
/// in this scenario, multiple document types exist where a different flow through the state machine for each. the configuration
/// of the flow is handled through metadata.
///
/// injection of the enumerated state steps is done here. and while useful for demonstration purposes, it may also be useful
/// to inject this list from another source. this is especially useful when ambient properties (i.e. user roles) play a role
/// in determining the steps.
/// </summary>
/// <param name="documentType">document type to use for the state machine</param>
/// <param name="stateConfiguration">document type state configuration filtering component</param>
public StateEngine(DocumentType documentType, Func<DocumentType, StateEngineConfiguration> stateConfiguration)
{
var stateMachine = new StateMachine<WorkflowStep, WorkflowTrigger>(WorkflowStep.New);
// here, we'll get the state steps particular to our document type and configure the workflow
var stepCount =
stateConfiguration(documentType).StateSteps.Select(p => ConfigureStateMachine(stateMachine, p)).Count();
Console.WriteLine("Creating the workflow at {0} with {1} steps", DateTime.Now.ToLongTimeString(), stepCount);
_stateMachine = stateMachine;
}
static void Main(string[] args)
{
var phoneCall = new StateMachine<State, Trigger>(State.OffHook);
setVolumeTrigger = phoneCall.SetTriggerParameters<int>(Trigger.SetVolume);
phoneCall.Configure(State.OffHook)
.Permit(Trigger.CallDialed, State.Ringing);
phoneCall.Configure(State.Ringing)
.Permit(Trigger.HungUp, State.OffHook)
.Permit(Trigger.CallConnected, State.Connected);
phoneCall.Configure(State.Connected)
.OnEntry(t => StartCallTimer())
.OnExit(t => StopCallTimer())
.InternalTransition(Trigger.MuteMicrophone, t => OnMute())
.InternalTransition(Trigger.UnmuteMicrophone, t => OnUnmute())
.InternalTransition<int>(setVolumeTrigger, (volume, t) => OnSetVolume(volume))
.Permit(Trigger.LeftMessage, State.OffHook)
.Permit(Trigger.HungUp, State.OffHook)
.Permit(Trigger.PlacedOnHold, State.OnHold);
phoneCall.Configure(State.OnHold)
.SubstateOf(State.Connected)
.Permit(Trigger.TakenOffHold, State.Connected)
.Permit(Trigger.HungUp, State.OffHook)
.Permit(Trigger.PhoneHurledAgainstWall, State.PhoneDestroyed);
Print(phoneCall);
Fire(phoneCall, Trigger.CallDialed);
Print(phoneCall);
Fire(phoneCall, Trigger.CallConnected);
Print(phoneCall);
SetVolume(phoneCall, 2);
Print(phoneCall);
Fire(phoneCall, Trigger.PlacedOnHold);
Print(phoneCall);
Fire(phoneCall, Trigger.MuteMicrophone);
Print(phoneCall);
Fire(phoneCall, Trigger.UnmuteMicrophone);
Print(phoneCall);
Fire(phoneCall, Trigger.TakenOffHold);
Print(phoneCall);
SetVolume(phoneCall, 11);
Print(phoneCall);
Fire(phoneCall, Trigger.HungUp);
Print(phoneCall);
Console.WriteLine("Press any key...");
Console.ReadKey(true);
}
public ApplicationState(IDepartmentService departmentService, ISettingService settingService,
ICacheService cacheService, IExpressionService expressionService, INotificationService notificationService)
{
_screenState = new StateMachine<AppScreens, AppScreens>(() => ActiveAppScreen, state => ActiveAppScreen = state);
_screenState.OnUnhandledTrigger(HandleTrigger);
_departmentService = departmentService;
_settingService = settingService;
_cacheService = cacheService;
_expressionService = expressionService;
_notificationService = notificationService;
SetCurrentDepartment(Department.Default);
CurrentTicketType = TicketType.Default;
_isLandscape = true;
}
private static Lazy<IStateStepConfiguration, IStateStepConfigurationMetadata> ConfigureStateMachine(StateMachine<WorkflowStep, WorkflowTrigger> stateMachine,
Lazy<IStateStepConfiguration, IStateStepConfigurationMetadata> stepConfiguration)
{
var stateConfig = stateMachine.Configure(stepConfiguration.Metadata.WorkflowStep);
foreach (var permission in stepConfiguration.Value.Permissions)
stateConfig.Permit(permission.Key, permission.Value);
stateConfig.OnEntry(
() => Console.WriteLine("Entering {0} Step at {1}", stepConfiguration.Metadata.WorkflowStep,
DateTime.Now.ToLongTimeString()));
return stepConfiguration;
}
public SMWorkflowMachine()
{
stateMachine = new StateMachine<State, Trigger>(State.Idle);
stateMachine.Configure(State.Idle)
.OnEntry(() => { if (OnIdleEntry != null) OnIdleEntry(); })
.OnExit(() => { if (OnIdleExit != null) OnIdleExit(); })
.PermitIf(Trigger.Select, State.SelectDrink , () => { if (GuardClauseFromIdleToSelectDrinkUsingTriggerSelect != null) return GuardClauseFromIdleToSelectDrinkUsingTriggerSelect(); return true; } )
.PermitIf(Trigger.Insert, State.CoinBox , () => { if (GuardClauseFromIdleToCoinBoxUsingTriggerInsert != null) return GuardClauseFromIdleToCoinBoxUsingTriggerInsert(); return true; } )
;
stateMachine.Configure(State.SelectDrink)
.OnEntry(() => { if (OnSelectDrinkEntry != null) OnSelectDrinkEntry(); })
.OnExit(() => { if (OnSelectDrinkExit != null) OnSelectDrinkExit(); })
.PermitIf(Trigger.SelectedDrink, State.SelectedDrink , () => { if (GuardClauseFromSelectDrinkToSelectedDrinkUsingTriggerSelectedDrink != null) return GuardClauseFromSelectDrinkToSelectedDrinkUsingTriggerSelectedDrink(); return true; } )
;
stateMachine.Configure(State.CoinBox)
.OnEntry(() => { if (OnCoinBoxEntry != null) OnCoinBoxEntry(); })
.OnExit(() => { if (OnCoinBoxExit != null) OnCoinBoxExit(); })
.PermitIf(Trigger.RefundMoney, State.MoneyRefunded , () => { if (GuardClauseFromCoinBoxToMoneyRefundedUsingTriggerRefundMoney != null) return GuardClauseFromCoinBoxToMoneyRefundedUsingTriggerRefundMoney(); return true; } )
.PermitIf(Trigger.CheckMoney, State.ControlMoney , () => { if (GuardClauseFromCoinBoxToControlMoneyUsingTriggerCheckMoney != null) return GuardClauseFromCoinBoxToControlMoneyUsingTriggerCheckMoney(); return true; } )
;
stateMachine.Configure(State.ControlMoney)
.OnEntry(() => { if (OnControlMoneyEntry != null) OnControlMoneyEntry(); })
.OnExit(() => { if (OnControlMoneyExit != null) OnControlMoneyExit(); })
.PermitIf(Trigger.Rejected, State.CoinBox , () => { if (GuardClauseFromControlMoneyToCoinBoxUsingTriggerRejected != null) return GuardClauseFromControlMoneyToCoinBoxUsingTriggerRejected(); return true; } )
.PermitIf(Trigger.EnoughMoney, State.ServingDrink , () => { if (GuardClauseFromControlMoneyToServingDrinkUsingTriggerEnoughMoney != null) return GuardClauseFromControlMoneyToServingDrinkUsingTriggerEnoughMoney(); return true; } )
;
stateMachine.Configure(State.SelectedDrink)
.OnEntry(() => { if (OnSelectedDrinkEntry != null) OnSelectedDrinkEntry(); })
.OnExit(() => { if (OnSelectedDrinkExit != null) OnSelectedDrinkExit(); })
.PermitIf(Trigger.DeSelectDrink, State.SelectDrink , () => { if (GuardClauseFromSelectedDrinkToSelectDrinkUsingTriggerDeSelectDrink != null) return GuardClauseFromSelectedDrinkToSelectDrinkUsingTriggerDeSelectDrink(); return true; } )
.PermitIf(Trigger.FoundDrink, State.ServingDrink , () => { if (GuardClauseFromSelectedDrinkToServingDrinkUsingTriggerFoundDrink != null) return GuardClauseFromSelectedDrinkToServingDrinkUsingTriggerFoundDrink(); return true; } )
;
stateMachine.Configure(State.ServingDrink)
.OnEntry(() => { if (OnServingDrinkEntry != null) OnServingDrinkEntry(); })
.OnExit(() => { if (OnServingDrinkExit != null) OnServingDrinkExit(); })
.PermitIf(Trigger.TakeDrink, State.DrinkReady , () => { if (GuardClauseFromServingDrinkToDrinkReadyUsingTriggerTakeDrink != null) return GuardClauseFromServingDrinkToDrinkReadyUsingTriggerTakeDrink(); return true; } )
;
stateMachine.Configure(State.DrinkReady)
.OnEntry(() => { if (OnDrinkReadyEntry != null) OnDrinkReadyEntry(); })
.OnExit(() => { if (OnDrinkReadyExit != null) OnDrinkReadyExit(); })
.PermitIf(Trigger.TakeChange, State.MoneyRefunded , () => { if (GuardClauseFromDrinkReadyToMoneyRefundedUsingTriggerTakeChange != null) return GuardClauseFromDrinkReadyToMoneyRefundedUsingTriggerTakeChange(); return true; } )
;
stateMachine.Configure(State.MoneyRefunded)
.OnEntry(() => { if (OnMoneyRefundedEntry != null) OnMoneyRefundedEntry(); })
.OnExit(() => { if (OnMoneyRefundedExit != null) OnMoneyRefundedExit(); })
.PermitIf(Trigger.RefundMoney, State.Idle , () => { if (GuardClauseFromMoneyRefundedToIdleUsingTriggerRefundMoney != null) return GuardClauseFromMoneyRefundedToIdleUsingTriggerRefundMoney(); return true; } )
;
stateMachine.OnUnhandledTrigger((state, trigger) => { if (OnUnhandledTrigger != null) OnUnhandledTrigger(state, trigger); });
}
private void OnTransition(StateMachine<StoryUpdateFunction, string>.Transition transition)
{
const string tag = "StoryState";
var entity = World.TagManager.GetEntity(tag);
if (entity != null)
{
entity.Tag = null;
entity.Delete();
}
var component = new CoroutineComponent(transition.Destination(this, World), () => entity.Delete());
entity = World.CreateEntity();
entity.AddComponent(component);
entity.Refresh();
entity.Tag = tag;
}
public Story(EntityWorld world)
{
Acts = new List<IStoryAct>(new[] { new ActOne() });
State = new StateMachine<StoryUpdateFunction, string>(Acts[0].Master);
State.OnTransitioned(OnTransition);
for (int i = 0; i < Acts.Count; i++)
{
var act = Acts[i];
act.ConfigureStates(State);
State.Configure(act.Master)
.Permit(Triggers.NextAct, i < Acts.Count - 1 ? (StoryUpdateFunction)Acts[i + 1].Master : EndOfStory);
}
World = world;
State.Fire(ActOne.Triggers.Start);
}
public void ConfigureStates(StateMachine<StoryUpdateFunction, string> state)
{
state.Configure(Master)
.Permit(Triggers.Start, Intro);
state.Configure(Intro)
.SubstateOf(Master)
.Permit(Story.Triggers.NextScene, Tutorial);
state.Configure(Tutorial)
.SubstateOf(Master)
.Permit(Story.Triggers.NextScene, AlienInvasionIntro);
state.Configure(AlienInvasionIntro)
.SubstateOf(Master)
.Permit(Story.Triggers.NextScene, AlienInvasionGameplay);
}
static void Main(string[] args)
{
//var wf1 = new Workflow1();
//wf1.InputValue = 0;
//wf1.
var phoneCall = new StateMachine<State, Trigger>(State.OffHook);
phoneCall.Configure(State.OffHook)
.Permit(Trigger.CallDialed, State.Ringing);
phoneCall.Configure(State.Ringing)
.Permit(Trigger.HungUp, State.OffHook)
.Permit(Trigger.CallConnected, State.Connected);
phoneCall.Configure(State.Connected)
.OnEntry(t => StartCallTimer())
.OnExit(t => StopCallTimer())
.Permit(Trigger.LeftMessage, State.OffHook)
.Permit(Trigger.HungUp, State.OffHook)
.Permit(Trigger.PlacedOnHold, State.OnHold);
phoneCall.Configure(State.OnHold)
.SubstateOf(State.Connected)
.Permit(Trigger.TakenOffHold, State.Connected)
.Permit(Trigger.HungUp, State.OffHook)
.Permit(Trigger.PhoneHurledAgainstWall, State.PhoneDestroyed);
Print(phoneCall);
Fire(phoneCall, Trigger.CallDialed);
Print(phoneCall);
Fire(phoneCall, Trigger.CallConnected);
Print(phoneCall);
Fire(phoneCall, Trigger.PlacedOnHold);
Print(phoneCall);
Fire(phoneCall, Trigger.TakenOffHold);
Print(phoneCall);
Fire(phoneCall, Trigger.HungUp);
Print(phoneCall);
Console.WriteLine("Press any key...");
Console.ReadKey(true);
}
public static StateMachine<RequestState, RequestAction> ForRequest(int requestId)
{
//use request id to get the current state of the request and initialize
var persistedState = GetRequestState(requestId);
var workflow = new StateMachine<RequestState, RequestAction>(persistedState);
//configure requested status
workflow.Configure(RequestState.Created)
.Permit(RequestAction.Suspend, RequestState.Suspended)
.Permit(RequestAction.Cancel, RequestState.Cancelled)
.Permit(RequestAction.Process, RequestState.Assigned);
workflow.Configure(RequestState.Assigned)
.OnEntry(OnBeginHandleAssigned)
.OnExit(OnExitHandleAssigned);
return workflow;
}
public ConnectionContext()
{
State = new StateMachine<HostState, HostCommand>(HostState.Disconnected);
State.Configure(HostState.Disconnected)
.Permit(HostCommand.ConnectionRequested, HostState.Connecting);
State.Configure(HostState.Connecting)
.Permit(HostCommand.ConnectionEstablished, HostState.Connected)
.Permit(HostCommand.ConnectionFailed, HostState.Disconnected);
State.Configure(HostState.Connected)
.Permit(HostCommand.MessageReceived, HostState.Processing);
State.Configure(HostState.Processing)
.Permit(HostCommand.ResponseSent, HostState.Connected);
LastActivity = DateTime.Now;
}
protected Bug()
{
Machine = new StateMachine<States, Triggers>(() => State, s => State = s);
AssignTrigger = Machine.SetTriggerParameters<string>(Triggers.Assign);
Machine.Configure(States.Open)
.Permit(Triggers.Assign, States.Assigned);
Machine.Configure(States.Assigned)
.SubstateOf(States.Open)
.OnEntryFrom(AssignTrigger, OnAssigned)
.PermitReentry(Triggers.Assign)
.Permit(Triggers.Close, States.Closed)
.Permit(Triggers.Defer, States.Deferred)
.OnExit(OnDeassigned);
Machine.Configure(States.Deferred)
.OnEntry(() => Assignee = null)
.Permit(Triggers.Assign, States.Assigned);
}
internal StateConfiguration(StateMachine <TState, TTrigger> machine, StateRepresentation representation, Func <TState, StateRepresentation> lookup)
{
_machine = Enforce.ArgumentNotNull(machine, nameof(machine));
_representation = Enforce.ArgumentNotNull(representation, nameof(representation));
_lookup = Enforce.ArgumentNotNull(lookup, nameof(lookup));
}
