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.

[Nimral]

Hallo liebe Prascal Freunde,

danke für das Beispiel zur State-Machine, und Hut ab vor der raffinierten Implementation.

Ich hab noch ein Praxisproblem zu lösen.

So lange sich die State-Machine in einem bestimmten State befindet muss der Computer iR irgend etwas tun. Beispiel: nach dem Abnehmen des Phone-Calls muss er einen Audiostream senden um sich zu melden, und dann auf Antwort warten. Kommt keine, wieder auflegen. Meldet sich der Andere, den Audiostream lesen und entscheiden ob das der richtige Gegenüber ist. Wenn nicht, sich entschuldigen und auflegen, sonst: zu labern beginnen. Und so weiter.

Die Aufgabe den oder die Tasks, die zwischen den State-Änderungen etwas tun (den Audiostream sendenempfangen/analysieren, Events triggern) zu verwalten ... wie und wo implementiert man das gemeinhin? Und muss/soll man die State-Machine nicht ebenfalls in einen Task packen, damit sie ihre Trigger auernd empfangen und auswerten kann?

Vielen Dank für deine Zeit,

Armin

[Rollo62]

Sind das nicht alles eigene Zusatz-States?
- Abnehmen des Phone-Calls
- Audiostream senden um sich zu melden
- auf Antwort warten
- Wenn Timeout: Kommt keine Antwort, wieder auflegen.
- Wenn Meldung: Meldet sich der Andere
- Audiostream lesen
- entscheiden ob das der richtige Gegenüber ist.
- Wenn FalscherAnrufer: Wenn nicht, sich entschuldigen und auflegen, sonst: zu labern beginnen.
- entschuldigen
- auflegen
- sonst: zu labern beginnen.

[Nimral]

Hi Rollo,

danke für deine Antwort. Ich habe mich nicht klar genug ausgedrückt: nicht das Definieren zusätzlicher States macht mir Kopfzerbrechen, sondern die Frage wie man den Programmcode strukturiert der die Statewechsel aufruft.

Ich vermute, ein eigener Audio-Task würde Sinn machen, der dann die Events in die State Machine schickt?

Den Task würde ich im onEnter eines States (z.B. onOffHook) erzeugen und starten, und der Task würde laufen und die empfangene Sprache analysieren bis er eine Endebedingung feststellt (z.B. Timeout oder "Tschüss" empfangen). Dann würde er einen State "Hangup" senden, der seinerseits im onEnter den Task terminieren und löschen würde.

Habe ich das in etwa richtig gerafft?

HG, Armin