Stateless - StateMachine für Delphi

[Sir Rufo]

Unter GITHUB: A simple library for creating state machines in DELPHI code habe ich einen Delphi-Port von GITHUB: A simple library for creating state machines in C# code veröffentlicht.

Unittests und Beispiele inklusive.

Der Code sollte ab Delphi XE2+ einfach so verwendet werden können.

Hier ein kleines Beispiel

Delphi-Quellcode:

program PhoneCall;

{$APPTYPE CONSOLE}
{$R *.res}

uses
  System.Diagnostics,
  System.SysUtils,
  Stateless;

{$SCOPEDENUMS ON}

type
  State      = ( OffHook, Ringing, Connected, Active, OnHold, PhoneDestroyed );
  Trigger    = ( CallDialed, HungUp, CallConnected, LeftMessage, PlacedOnHold, TakenOffHold, PhoneHurledAgainstWall );
  TPhoneCall = TStateMachine<State, Trigger>;

procedure ConfigurePhoneCall( PhoneCall: TPhoneCall );
var
  LCallTimer: TStopwatch;
begin
  PhoneCall.Configure( State.OffHook )
  {} .Permit( Trigger.CallDialed, State.Ringing );

  PhoneCall.Configure( State.Ringing )
  {} .Permit( Trigger.HungUp, State.OffHook )
  {} .Permit( Trigger.CallConnected, State.Active );

  PhoneCall.Configure( State.Connected )
  {} .Permit( Trigger.HungUp, State.OffHook )
  {} .OnEntry(
    procedure( t: TPhoneCall.TTransition )
    begin
      LCallTimer := TStopwatch.StartNew;
    end )
  {} .OnExit(
    procedure( t: TPhoneCall.TTransition )
    begin
      LCallTimer.Stop;
      WriteLn( 'Duration: ', LCallTimer.ElapsedMilliseconds, 'ms' );
    end );

  PhoneCall.Configure( State.Active )
  {} .SubstateOf( State.Connected )
  {} .Permit( Trigger.LeftMessage, State.OffHook )
  {} .Permit( Trigger.PlacedOnHold, State.OnHold );

  PhoneCall.Configure( State.OnHold )
  {} .SubstateOf( State.Connected )
  {} .Permit( Trigger.TakenOffHold, State.Active )
  {} .Permit( Trigger.PhoneHurledAgainstWall, State.PhoneDestroyed );
end;

procedure Test;
var
  LCall: TPhoneCall;
begin
  LCall := TPhoneCall.Create( State.OffHook );
  try
    ConfigurePhoneCall( LCall );
    WriteLn( LCall.ToString );

    LCall.Fire( Trigger.CallDialed );
    WriteLn( LCall.ToString );

    LCall.Fire( Trigger.CallConnected );
    WriteLn( LCall.ToString );

    LCall.Fire( Trigger.PlacedOnHold );
    WriteLn( LCall.ToString );

    LCall.Fire( Trigger.TakenOffHold );
    WriteLn( LCall.ToString );

    LCall.Fire( Trigger.PlacedOnHold );
    WriteLn( LCall.ToString );

    LCall.Fire( Trigger.HungUp );
    WriteLn( LCall.ToString );

  finally
    LCall.Free;
  end;
end;

begin
  try
    Test;
  except
    on E: Exception do
      WriteLn( E.ClassName, ': ', E.Message );
  end;
  ReadLn;

end.

Und die Ausgabe:

Code:

StateMachine { State = OffHook, PermittedTriggers = { CallDialed } }
StateMachine { State = Ringing, PermittedTriggers = { HungUp, CallConnected } }
StateMachine { State = Active, PermittedTriggers = { PlacedOnHold, LeftMessage, HungUp } }
StateMachine { State = OnHold, PermittedTriggers = { TakenOffHold, PhoneHurledAgainstWall, HungUp } }
StateMachine { State = Active, PermittedTriggers = { PlacedOnHold, LeftMessage, HungUp } }
StateMachine { State = OnHold, PermittedTriggers = { TakenOffHold, PhoneHurledAgainstWall, HungUp } }
Duration: 0ms
StateMachine { State = OffHook, PermittedTriggers = { CallDialed } }

[psycodad]

Danke für die Informationen. Ich glaub ich mach mal einen Prototyp und guck dann was für meine Bedürfnisse am besten erscheint.