Refactoring TFuture

Src/Myc.Signals.pas

@@ -7,7 +7,7 @@ uses
 
 type
     IMycSubscriber = interface
-        // Interface for an entity that can be notified by a State or State.
+        // Interface for an entity that can be notified by a TState or TState.
         // Returns true if this subscriber expects further notifications from the source, false otherwise.
         function Notify: Boolean;
     end;
@@ -21,21 +21,21 @@ type
         function GetState: IMycState;
     public
         constructor Create( const AState: IMycState; ATag: Pointer );
-        // Unsubscribes from the associated State.
+        // Unsubscribes from the associated TState.
         procedure Unsubscribe;
         class operator Initialize( out Dest: TMycSubscription );
-        property State: IMycState read GetState;
+        property TState: IMycState read GetState;
     end;
 
     IMycState = interface
-        // Represents a subscribable state that can be queried.
+        // Represents a subscribable TState that can be queried.
         {$REGION 'property access'}
         function GetIsSet: Boolean;
         {$ENDREGION}
-        // Subscribes a given subscriber to this State.
+        // Subscribes a given subscriber to this TState.
         function Subscribe( Subscriber: IMycSubscriber ): TMycSubscription;
         procedure Unsubscribe( Tag: Pointer );
-        // IsSet is true if the state has been reached or the condition is met.
+        // IsSet is true if the TState has been reached or the condition is met.
         property IsSet: Boolean read GetIsSet;
     end;
 
@@ -48,25 +48,29 @@ type
         // Inherits IMycSubscriber and State property from IMycFlag. No new members.
     end;
 
-    // IMycDirty represents a resettable flag, typically indicating if a state is "dirty" (requiring attention) or "clean".
-    // It inherits from IMycFlag, meaning it has a state, can be notified, and subscribed to.
+    // IMycDirty represents a resettable flag, typically indicating if a State is "dirty" (requiring attention) or "clean".
+    // It inherits from IMycFlag, meaning it has a State, can be notified, and subscribed to.
     IMycDirty = interface( IMycSubscriber )
         // Provides access to the IMycState interface of the flag.
         function GetState: IMycState;
-        // Resets the flag to its "clean" (not set / not dirty) state.
+        // Resets the flag to its "clean" (not set / not dirty) State.
         // Returns true if the flag was actually dirty before this reset, false otherwise.
         function Reset: Boolean;
         property State: IMycState read GetState;
     end;
 
-    State = record
+    TState = record
     private
+        FState: IMycState;
         class function GetNull: IMycState; static;
     public
+        constructor Create(const AState: IMycState);
         class function CreateLatch( Count: Integer ): IMycLatch; static;
         class function CreateDirty: IMycDirty; static;
         class function All( const States: TArray<IMycState> ): IMycState; static;
         class function Any( const States: TArray<IMycState> ): IMycState; static;
+        class operator Implicit(const A: IMycState): TState; overload;
+        class operator Implicit(const A: TState): IMycState; overload;
         class property Null: IMycState read GetNull;
     end;
 
@@ -103,14 +107,21 @@ begin
     Dest.FTag := nil;
 end;
 
-{ State }
+{ TState }
 
-class function State.CreateLatch( Count: Integer ): IMycLatch;
+constructor TState.Create(const AState: IMycState);
+begin
+    FState := AState;
+    if not Assigned(FState) then
+        FState := TMycState.Null;
+end;
+
+class function TState.CreateLatch( Count: Integer ): IMycLatch;
 begin
     Result := TMycLatch.CreateLatch( Count );
 end;
 
-class function State.All( const States: TArray<IMycState> ): IMycState;
+class function TState.All( const States: TArray<IMycState> ): IMycState;
 var
     Latch: IMycLatch;
 begin
@@ -120,13 +131,13 @@ begin
     Result := Latch.State;
 end;
 
-class function State.Any( const States: TArray<IMycState> ): IMycState;
+class function TState.Any( const States: TArray<IMycState> ): IMycState;
 var
     Latch: IMycLatch;
 begin
     if Length( States ) = 0 then
     begin
-        Result := State.Null;
+        Result := TState.Null;
     end
     else
     begin
@@ -137,14 +148,24 @@ begin
     end;
 end;
 
-class function State.CreateDirty: IMycDirty;
+class function TState.CreateDirty: IMycDirty;
 begin
     Result := TMycDirty.CreateDirty;
 end;
 
-class function State.GetNull: IMycState;
+class function TState.GetNull: IMycState;
 begin
     Result := TMycState.Null;
 end;
 
+class operator TState.Implicit(const A: TState): IMycState;
+begin
+    Result := A.FState;
+end;
+
+class operator TState.Implicit(const A: IMycState): TState;
+begin
+    Result.Create( A );
+end;
+
 end.