Brummel/MycLib
1
0
Fork 0
Code Issues 1 Pull Requests Actions Packages Projects 1 Releases Wiki Activity

Refactoring

Browse Source
This commit is contained in:
Michael Schimmel
2025-06-02 13:19:13 +02:00
parent 762e7f83e2
commit 48f4c945ce
9 changed files with 98 additions and 402 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Src/Myc.Core.Futures.pas
+1 -1
View File
@@ -37,7 +37,7 @@ constructor TMycInitStateFuncFuture<T>.Create( const ATaskManager: IMycTaskManag
begin
inherited Create;
FDone := TMycLatch.CreateLatch( 1 );
FDone := State.CreateLatch( 1 );
// Subscribe the job execution to AGate.
// The job will run when AGate notifies the subscriber returned by Run.
Src/Myc.Core.Tasks.pas
+3
View File
@@ -95,6 +95,9 @@ type
implementation
uses
Myc.Core.Signals;
type
TMycPendingJob = class(TInterfacedObject, IMycSubscriber)
private
Src/Myc.Signals.pas
+58 -367
View File
@@ -3,211 +3,91 @@ unit Myc.Signals;
interface
uses
System.SysUtils, Myc.Core.Notifier;
System.SysUtils;
type
IMycState = interface;
IMycSubscriber = interface
// Interface for an entity that can be notified by a signal or latch.
// Interface for an entity that can be notified by a State or State.
// Returns true if this subscriber expects further notifications from the source, false otherwise.
function Notify: Boolean;
end;
TMycState = class;
IMycState = interface;
TMycSubscription = record
private
FState: IMycState;
FTag: TMycNotifyList<IMycSubscriber>.TTag; // Tag identifying this subscription within the notifier list.
FTag: Pointer; // Tag identifying this subscription within the notifier list.
function GetState: IMycState;
public
constructor Create(const AState: IMycState; ATag: TMycNotifyList<IMycSubscriber>.TTag);
// Unsubscribes from the associated signal.
constructor Create( const AState: IMycState; ATag: Pointer );
// Unsubscribes from the associated State.
procedure Unsubscribe;
class operator Initialize(out Dest: TMycSubscription);
class operator Initialize( out Dest: TMycSubscription );
property State: IMycState read GetState;
end;
IMycState = interface
// Represents a subscribable state that can be queried.
{$region 'property access'}
{$REGION 'property access'}
function GetIsSet: Boolean;
{$endregion}
// Subscribes a given subscriber to this signal.
function Subscribe(const Subscriber: IMycSubscriber): TMycSubscription;
procedure Unsubscribe(Tag: TMycNotifyList<IMycSubscriber>.TTag);
{$ENDREGION}
// Subscribes a given subscriber to this State.
function Subscribe( Subscriber: IMycSubscriber ): TMycSubscription;
procedure Unsubscribe( Tag: Pointer );
// IsSet is true if the state has been reached or the condition is met.
property IsSet: Boolean read GetIsSet;
end;
TMycState = class abstract( TInterfacedObject, IMycState )
strict private
class var
FNull: IMycState;
class constructor ClassCreate;
protected
function GetIsSet: Boolean; virtual; abstract;
public
function Subscribe(const Subscriber: IMycSubscriber): TMycSubscription; virtual; abstract;
procedure Unsubscribe(Tag: TMycNotifyList<IMycSubscriber>.TTag); virtual; abstract;
property IsSet: Boolean read GetIsSet;
// Provides access to the singleton null latch instance (always set).
class property Null: IMycState read FNull;
end;
// IMycFlag represents a base for signal-like objects that have a binary state (set/not set),
// can be notified (as an IMycSubscriber) to potentially change state,
// and whose state (IMycState) can be queried and subscribed to.
IMycFlag = interface(IMycSubscriber)
{$region 'property access'}
// Provides access to the IMycState interface of the flag.
function GetState: IMycState;
{$endregion}
property State: IMycState read GetState;
end;
// IMycLatch is a specific type of flag that, once set, remains set (non-resettable).
// It typically becomes set when an internal countdown reaches zero.
IMycLatch = interface(IMycFlag)
IMycLatch = interface( IMycSubscriber )
// Provides access to the IMycState interface of the flag.
function GetState: IMycState;
property State: IMycState read GetState;
// Inherits IMycSubscriber and State property from IMycFlag. No new members.
end;
// TMycLatch implements a countdown latch.
// It is initialized with a count. Calls to its Notify method (as an IMycSubscriber)
// decrement this count. When the count reaches zero, the latch transitions to the "set"
// state (IsSet becomes true), notifies its current subscribers once, and then remains set.
TMycLatch = class(TMycState, IMycLatch, IMycFlag)
strict private
FSubscribers: TMycNotifyList<IMycSubscriber>; // List of subscribers waiting for this latch to be set.
class var
FNull: IMycLatch; // Singleton instance of a latch that is always set.
class constructor ClassCreate; // Class constructor to initialize FNull.
private
[volatile] FCount: Integer; // The internal countdown value for the latch.
function GetState: IMycState; // Implementation for IMycLatch.GetState and IMycFlag.GetState.
protected
function GetIsSet: Boolean; override; final; // Implementation for IMycState.GetIsSet.
public
// Creates the latch with an initial count.
// If ACount is 0 or less, the latch is effectively pre-set (delegates to FNull via CreateLatch factory).
constructor Create(ACount: Integer);
destructor Destroy; override;
// Factory method: creates a new countdown latch or returns the Null latch if Count <= 0.
class function CreateLatch(Count: Integer): IMycLatch; static;
// IMycSignal implementation
function Subscribe(const Subscriber: IMycSubscriber): TMycSubscription; override;
procedure Unsubscribe(Tag: TMycNotifyList<IMycSubscriber>.TTag); override;
// IMycSubscriber implementation for TMycLatch itself.
// Decrements the internal count. If the count reaches zero,
// registered subscribers are notified, and the latch becomes permanently set.
function Notify: Boolean;
// Provides access to the singleton null latch instance (always set).
class property Null: IMycLatch read FNull;
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 = interface(IMycFlag)
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.
// Returns true if the flag was actually dirty before this reset, false otherwise.
function Reset: Boolean;
property State: IMycState read GetState;
end;
// TMycDirty implements a resettable "dirty flag".
// It can be explicitly set to dirty (via Notify) or reset to clean (via Reset).
// Subscribers are notified of relevant state changes.
TMycDirty = class(TMycState, IMycFlag, IMycDirty)
strict private
FSubscribers: TMycNotifyList<IMycSubscriber>; // List of subscribers interested in state changes of this dirty flag.
State = record
private
[volatile] FFlag: Boolean; // Internal state: true if dirty/set, false if clean/reset.
function GetState: IMycState; // Implementation for IMycFlag.GetState.
protected
function GetIsSet: Boolean; override; final; // Implementation for IMycState.GetIsSet (true if dirty).
class function GetNull: IMycState; static;
public
// Creates a new dirty flag, initially set to dirty (true).
constructor Create;
destructor Destroy; override;
// Factory method to create a new TMycDirty instance.
class function CreateLatch( Count: Integer ): IMycLatch; static;
class function CreateDirty: IMycDirty; static;
// IMycSignal implementation
function Subscribe(const Subscriber: IMycSubscriber): TMycSubscription; override;
procedure Unsubscribe(Tag: TMycNotifyList<IMycSubscriber>.TTag); override;
// IMycSubscriber implementation for TMycDirty.
// Sets this flag to dirty (true). Notifies subscribers if it transitioned from clean to dirty.
function Notify: Boolean;
// IMycDirty implementation. Resets the flag to clean (false).
function Reset: Boolean;
class function All( const States: TArray<IMycState> ): IMycState; static;
class function Any( const States: TArray<IMycState> ): IMycState; static;
class property Null: IMycState read GetNull;
end;
implementation
uses
System.SyncObjs; // For TInterlocked
type
// TMycNullState implements a "null object" pattern for IMycState.
// This state is always considered "set".
TMycNullState = class(TInterfacedObject, IMycState)
protected
// IMycState
function GetIsSet: Boolean;
function Subscribe(const Subscriber: IMycSubscriber): TMycSubscription;
procedure Unsubscribe(Tag: TMycNotifyList<IMycSubscriber>.TTag);
public
constructor Create;
end;
{ TMycNullState }
constructor TMycNullState.Create;
begin
inherited Create;
end;
function TMycNullState.GetIsSet: Boolean;
begin
Result := true; // Null state is always set.
end;
function TMycNullState.Subscribe(const Subscriber: IMycSubscriber): TMycSubscription;
begin
// Since the state is always set, notify the subscriber immediately.
if Assigned(Subscriber) then
begin
Subscriber.Notify;
end;
// No ongoing subscription is necessary or meaningful for a null state.
Result.Create(Self, nil); // Return an empty subscription.
end;
procedure TMycNullState.Unsubscribe(Tag: TMycNotifyList<IMycSubscriber>.TTag);
begin
// Unsubscribing from a null state has no effect.
end;
Myc.Core.Notifier, Myc.Core.Signals;
{ TMycSubscription }
constructor TMycSubscription.Create(const AState: IMycState; ATag:
TMycNotifyList<IMycSubscriber>.TTag);
constructor TMycSubscription.Create( const AState: IMycState; ATag:
TMycNotifyList<IMycSubscriber>.TTag );
begin
Assert( Assigned(AState) );
Assert( Assigned( AState ) );
FState := AState;
FTag := ATag;
end;
procedure TMycSubscription.Unsubscribe;
begin
FState.Unsubscribe(FTag);
FState.Unsubscribe( FTag );
FState := TMycState.Null;
FTag := nil;
end;
@@ -217,243 +97,54 @@ begin
Result := FState
end;
class operator TMycSubscription.Initialize(out Dest: TMycSubscription);
class operator TMycSubscription.Initialize( out Dest: TMycSubscription );
begin
Dest.FState := TMycState.Null;
Dest.FTag := nil;
end;
{ TMycLatch }
{ State }
constructor TMycLatch.Create(ACount: Integer);
class function State.CreateLatch( Count: Integer ): IMycLatch;
begin
inherited Create;
Assert( ACount >= 0 );
FCount := ACount;
FSubscribers.Create;
Result := TMycLatch.CreateLatch( Count );
end;
class constructor TMycLatch.ClassCreate;
class function State.All( const States: TArray<IMycState> ): IMycState;
var
Latch: IMycLatch;
begin
// Create a singleton null latch instance that is initially (and always) set.
FNull := TMycLatch.Create(0); // Calls the instance constructor
Latch := CreateLatch( Length( States ) );
for var i := 0 to High( States ) do
States[i].Subscribe( Latch );
Result := Latch.State;
end;
destructor TMycLatch.Destroy;
class function State.Any( const States: TArray<IMycState> ): IMycState;
var
Latch: IMycLatch;
begin
FSubscribers.Destroy;
inherited;
end;
class function TMycLatch.CreateLatch(Count: Integer): IMycLatch;
begin
// Factory method: returns a new latch or the shared Null latch if Count <= 0.
if Count > 0 then
Result := TMycLatch.Create(Count) // Instance constructor
if Length( States ) = 0 then
begin
Result := State.Null;
end
else
Result := FNull;
end;
function TMycLatch.Notify: Boolean;
var
currentCountAfterDecrement: Integer;
shouldNotifySubscribers: Boolean;
begin
FSubscribers.Lock;
try
currentCountAfterDecrement := TInterlocked.Decrement(FCount);
if currentCountAfterDecrement < -MaxInt div 2 then
TInterlocked.Increment(FCount); // Defend against extreme underflow.
shouldNotifySubscribers := (currentCountAfterDecrement = 0); // Notify only on transition to zero.
if shouldNotifySubscribers then
begin
FSubscribers.Notify(
function(Subscriber: IMycSubscriber): Boolean
begin
Result := Subscriber.Notify;
end);
end;
// Returns true if the latch has not yet been set by this Notify call (count > 0).
Result := currentCountAfterDecrement > 0;
// If the latch is now set (or was already set), unadvise all subscribers.
// This ensures one-shot notification for the current set of subscribers.
if currentCountAfterDecrement <= 0 then
FSubscribers.UnadviseAll;
finally
FSubscribers.Release;
begin
Latch := CreateLatch( 1 );
for var i := 0 to High( States ) do
States[i].Subscribe( Latch );
Result := Latch.State;
end;
end;
function TMycLatch.GetIsSet: Boolean;
class function State.CreateDirty: IMycDirty;
begin
// The latch is set if its count has reached zero or less.
Result := FCount <= 0;
Result := TMycDirty.CreateDirty;
end;
function TMycLatch.GetState: IMycState;
class function State.GetNull: IMycState;
begin
// TMycLatch itself implements IMycState.
exit(Self);
end;
function TMycLatch.Subscribe(const Subscriber: IMycSubscriber): TMycSubscription;
var
alreadySet: Boolean;
begin
if not Assigned(Subscriber) then
exit;
Subscriber._AddRef; // Manage ref count during this method's logic.
try
FSubscribers.Lock;
try
alreadySet := (FCount <= 0); // Check if latch is already set.
if alreadySet then
begin
// If already set, notify immediately; no persistent subscription needed.
Subscriber.Notify;
end
else
begin
// If not yet set, advise the subscriber.
Result.Create(Self, FSubscribers.Advise(Subscriber));
end;
finally
FSubscribers.Release;
end;
finally
Subscriber._Release;
end;
end;
procedure TMycLatch.Unsubscribe(Tag: TMycNotifyList<IMycSubscriber>.TTag);
begin
if Tag = nil then
exit;
FSubscribers.Lock;
try
FSubscribers.Unadvise(Tag);
finally
FSubscribers.Release;
end;
end;
{ TMycDirty }
constructor TMycDirty.Create;
begin
inherited Create;
FFlag := true; // A new dirty flag is initially considered dirty.
FSubscribers.Create;
end;
class function TMycDirty.CreateDirty: IMycDirty;
begin
// Factory method to create a new TMycDirty instance.
Result := TMycDirty.Create;
end;
destructor TMycDirty.Destroy;
begin
FSubscribers.Destroy; // Clean up the subscriber list.
inherited;
end;
function TMycDirty.Reset: Boolean;
begin
// Sets the flag to false (clean) and returns true if it was previously true (dirty).
Result := TInterlocked.Exchange(FFlag, false);
end;
function TMycDirty.GetIsSet: Boolean;
begin
// IsSet is true if the flag is dirty (FFlag = true).
Result := FFlag;
end;
function TMycDirty.GetState: IMycState;
begin
// TMycDirty itself implements IMycState.
exit(Self);
end;
function TMycDirty.Notify: Boolean;
var
wasPreviouslyClean: Boolean;
begin
FSubscribers.Lock;
try
// Set the flag to true (dirty) and check if it was previously false (clean).
wasPreviouslyClean := not TInterlocked.Exchange(FFlag, true);
if wasPreviouslyClean then // Only notify subscribers if state changed from clean to dirty.
begin
FSubscribers.Notify(
function(Subscriber: IMycSubscriber): Boolean
begin
Result := Subscriber.Notify;
end);
end;
// The return value of this Notify (as an IMycSubscriber) indicates if this
// TMycDirty instance itself would want more notifications if it were subscribed to something.
// Here, it reflects whether a state change to dirty occurred due to this call.
Result := wasPreviouslyClean;
finally
FSubscribers.Release;
end;
end;
function TMycDirty.Subscribe(const Subscriber: IMycSubscriber): TMycSubscription;
begin
if not Assigned(Subscriber) then
exit;
// For TMycDirty, we always add the subscriber and then check if we need to notify immediately.
// Ref counting for the subscriber interface is assumed to be handled by TMycNotifyList.Advise/Unadvise.
// Or, if explicit management is needed like in TMycLatch, it should be added.
// For consistency with TMycLatch, let's add AddRef/Release here too.
Subscriber._AddRef;
try
FSubscribers.Lock;
try
// Add subscriber regardless of current state.
Result.Create(Self, FSubscribers.Advise(Subscriber));
if FFlag then // If currently dirty, notify the new subscriber immediately.
begin
Subscriber.Notify;
end;
finally
FSubscribers.Release;
end;
finally
Subscriber._Release;
end;
end;
procedure TMycDirty.Unsubscribe(Tag: TMycNotifyList<IMycSubscriber>.TTag);
begin
if Tag = nil then
exit;
FSubscribers.Lock;
try
FSubscribers.Unadvise(Tag);
finally
FSubscribers.Release;
end;
end;
class constructor TMycState.ClassCreate;
begin
// Create a singleton null latch instance that is initially (and always) set.
FNull := TMycNullState.Create(); // Calls the instance constructor
Result := TMycState.Null;
end;
end.
Test/MycTests.dpr
+2 -1
View File
@@ -26,7 +26,8 @@ uses
Myc.Futures in '..\Src\Myc.Futures.pas',
TestFutures in 'TestFutures.pas',
Myc.TaskManager in '..\Src\Myc.TaskManager.pas',
Myc.Core.Futures in '..\Src\Myc.Core.Futures.pas';
Myc.Core.Futures in '..\Src\Myc.Core.Futures.pas',
Myc.Core.Signals in '..\Src\Myc.Core.Signals.pas';
{ keep comment here to protect the following conditional from being removed by the IDE when adding a unit }
{$IFNDEF TESTINSIGHT}
Test/MycTests.dproj
+1
View File
@@ -126,6 +126,7 @@ $(PostBuildEvent)]]></PostBuildEvent>
<DCCReference Include="TestFutures.pas"/>
<DCCReference Include="..\Src\Myc.TaskManager.pas"/>
<DCCReference Include="..\Src\Myc.Core.Futures.pas"/>
<DCCReference Include="..\Src\Myc.Core.Signals.pas"/>
<BuildConfiguration Include="Base">
<Key>Base</Key>
</BuildConfiguration>
Test/TestFutures.pas
+8 -8
View File
@@ -94,7 +94,7 @@ const
CExpectedResult = 42;
begin
// Use TMycLatch.Null for an already set init state [cite: 71, 81, 206, 216, 324, 334]
LInitStateAsState := TMycLatch.Null.State; // Get IMycState from IMycLatch [cite: 61, 196, 314]
LInitStateAsState := State.Null;
LFuture := TMycInitStateFuncFuture<Integer>.Create(FTaskFactory, LInitStateAsState,
function: Integer
@@ -120,7 +120,7 @@ var
const
CExpectedResult = 'ChainCompleted';
begin
LInitLatch := TMycLatch.CreateLatch(1); // Create an init state that is not yet set [cite: 77, 212, 330]
LInitLatch := State.CreateLatch(1); // Create an init state that is not yet set [cite: 77, 212, 330]
LFuture := TMycInitStateFuncFuture<string>.Create(FTaskFactory, LInitLatch.State,
function: string
@@ -155,7 +155,7 @@ const
begin
LExpectedExceptionRaisedByFactory := False;
LLocalTaskFactory := TMycTaskFactory.Create;
LInitStateAsState := TMycLatch.Null.State; // Immediate execution
LInitStateAsState := State.Null; // Immediate execution
LFuture := TMycInitStateFuncFuture<Integer>.Create(LLocalTaskFactory, LInitStateAsState,
function: Integer
@@ -208,7 +208,7 @@ var
LFuture: IMycFuture<Integer>;
LInitLatch: IMycLatch;
begin
LInitLatch := TMycLatch.CreateLatch(1);
LInitLatch := State.CreateLatch(1);
LFuture := TMycInitStateFuncFuture<Integer>.Create(FTaskFactory, LInitLatch.State,
function: Integer
@@ -250,7 +250,7 @@ begin
FProcExecutionCount := 0; // Reset for this test
// Gate Latch: MainFuture waits for this latch, which needs 2 notifications.
LGateLatch := TMycLatch.CreateLatch(2); // [cite: 77, 212, 330]
LGateLatch := State.CreateLatch(2); // [cite: 77, 212, 330]
// Create MainFuture, AInitState is the GateLatch's state.
LMainFuture := TMycInitStateFuncFuture<string>.Create(FTaskFactory, LGateLatch.State,
@@ -262,7 +262,7 @@ begin
// Setup Prerequisite Futures
// PrerequisiteFuture1
LInitStateP1 := TMycLatch.CreateLatch(1); // Controllable init state for PF1
LInitStateP1 := State.CreateLatch(1); // Controllable init state for PF1
LPrerequisiteFuture1 := TMycInitStateFuncFuture<Integer>.Create(FTaskFactory, LInitStateP1.State,
function: Integer
begin
@@ -273,7 +273,7 @@ begin
Subscriptions[1] := LPrerequisiteFuture1.Done.Subscribe(LSub1); // Subscribe to PF1's completion [cite: 56, 188, 306]
// PrerequisiteFuture2
LInitStateP2 := TMycLatch.CreateLatch(1); // Controllable init state for PF2
LInitStateP2 := State.CreateLatch(1); // Controllable init state for PF2
LPrerequisiteFuture2 := TMycInitStateFuncFuture<Integer>.Create(FTaskFactory, LInitStateP2.State,
function: Integer
begin
@@ -322,7 +322,7 @@ begin
LFlagFutureBRan := False;
Self.FSharedCounter := 0; // Reset shared counter for this test
LTriggerLatch := TMycLatch.CreateLatch(1); // Single trigger [cite: 77, 212, 330]
LTriggerLatch := State.CreateLatch(1); // Single trigger [cite: 77, 212, 330]
// Future A
LFutureA := TMycInitStateFuncFuture<Integer>.Create(FTaskFactory, LTriggerLatch.State,
Test/TestSignals_Dirty.pas
+2 -2
View File
@@ -105,7 +105,7 @@ end;
function TTestMycDirtyFlag.CreateAndPrepareDirtyFlag(StartDirty: Boolean = True): IMycDirty;
begin
Result := TMycDirty.CreateDirty; // Initially dirty
Result := State.CreateDirty; // Initially dirty
if not StartDirty then
Result.Reset; // Reset to make it clean
Assert.AreEqual(StartDirty, Result.State.IsSet, 'CreateAndPrepareDirtyFlag initial state incorrect.');
@@ -127,7 +127,7 @@ procedure TTestMycDirtyFlag.TestCreate_InitialStateIsDirty;
var
dirtyFlag: IMycDirty;
begin
dirtyFlag := TMycDirty.CreateDirty;
dirtyFlag := State.CreateDirty;
Assert.IsTrue(dirtyFlag.State.IsSet, 'Newly created dirty flag should be IsSet (dirty).');
end;
Test/TestSignals_Latch.pas
+22 -22
View File
@@ -124,7 +124,7 @@ var
latch: IMycLatch;
begin
// TMycLatch.CreateLatch returns TMycLatch.Null if InitialCount <= 0
latch := TMycLatch.CreateLatch(InitialCount);
latch := State.CreateLatch(InitialCount);
Assert.AreEqual(ExpectedIsSet, latch.State.IsSet, 'Latch initial IsSet state mismatch for count ' + IntToStr(InitialCount) + '.');
end;
@@ -133,7 +133,7 @@ var
latch: IMycLatch;
returnedValueFromNotify: Boolean;
begin
latch := TMycLatch.CreateLatch(InitialCount);
latch := State.CreateLatch(InitialCount);
returnedValueFromNotify := latch.Notify; // This is IMycLatch (as IMycSubscriber).Notify
Assert.AreEqual(ExpectedReturn, returnedValueFromNotify, 'Unexpected return value from Latch.Notify call for initial count ' + IntToStr(InitialCount) + '.');
@@ -144,7 +144,7 @@ procedure TTestMycLatch.TestNotify_DecrementsCounter_StateChanges;
var
latch: IMycLatch;
begin
latch := TMycLatch.CreateLatch(1);
latch := State.CreateLatch(1);
Assert.IsFalse(latch.State.IsSet, 'Latch should initially not be set (Count=1).');
latch.Notify; // Count becomes 0
Assert.IsTrue(latch.State.IsSet, 'Latch should be set after Notify (Count became 0).');
@@ -154,7 +154,7 @@ procedure TTestMycLatch.TestNotify_MultipleNotifies_CounterBecomesNegativeAndSta
var
latch: IMycLatch;
begin
latch := TMycLatch.CreateLatch(1);
latch := State.CreateLatch(1);
latch.Notify; // Count becomes 0, IsSet = True
Assert.IsTrue(latch.State.IsSet, 'Latch should be set after first Notify.');
latch.Notify; // Count becomes -1, IsSet should remain True
@@ -169,7 +169,7 @@ var
mockSub: TMockSubscriber;
subscription: TMycSubscription;
begin
latch := TMycLatch.CreateLatch(1);
latch := State.CreateLatch(1);
mockSub := TMockSubscriber.Create;
subscription := latch.State.Subscribe(mockSub); // Subscribing to the Latch's state
@@ -188,7 +188,7 @@ var
mockSub1, mockSub2, mockSub3: TMockSubscriber;
sub1, sub2, sub3: TMycSubscription; // Keep subscriptions in scope
begin
latch := TMycLatch.CreateLatch(1);
latch := State.CreateLatch(1);
mockSub1 := TMockSubscriber.Create;
mockSub2 := TMockSubscriber.Create;
mockSub3 := TMockSubscriber.Create;
@@ -210,7 +210,7 @@ var
mockSub: TMockSubscriber;
subscription: TMycSubscription;
begin
latch := TMycLatch.CreateLatch(2); // Count = 2
latch := State.CreateLatch(2); // Count = 2
mockSub := TMockSubscriber.Create;
subscription := latch.State.Subscribe(mockSub);
@@ -225,7 +225,7 @@ var
mockSub: TMockSubscriber;
subscription: TMycSubscription;
begin
latch := TMycLatch.CreateLatch(1);
latch := State.CreateLatch(1);
mockSub := TMockSubscriber.Create;
subscription := latch.State.Subscribe(mockSub);
@@ -242,7 +242,7 @@ var
mockSub1, mockSub2: TMockSubscriber;
subscription1, subscription2: TMycSubscription;
begin
latch := TMycLatch.CreateLatch(1); // Create with count 1
latch := State.CreateLatch(1); // Create with count 1
mockSub1 := TMockSubscriber.Create;
subscription1 := latch.State.Subscribe(mockSub1); // Subscribe before set
@@ -270,8 +270,8 @@ var
mockSubForB: TMockSubscriber;
subHandle_B_listens_A, subHandle_Mock_listens_B: TMycSubscription;
begin
latchA := TMycLatch.CreateLatch(1);
latchB := TMycLatch.CreateLatch(1); // latchB is an IMycSubscriber
latchA := State.CreateLatch(1);
latchB := State.CreateLatch(1); // latchB is an IMycSubscriber
mockSubForB := TMockSubscriber.Create;
subHandle_Mock_listens_B := latchB.State.Subscribe(mockSubForB);
@@ -295,9 +295,9 @@ var
mockSubForC: TMockSubscriber;
sub_Mock_C, sub_C_B, sub_B_A: TMycSubscription;
begin
latchA := TMycLatch.CreateLatch(1);
latchB := TMycLatch.CreateLatch(1);
latchC := TMycLatch.CreateLatch(1);
latchA := State.CreateLatch(1);
latchB := State.CreateLatch(1);
latchC := State.CreateLatch(1);
mockSubForC := TMockSubscriber.Create;
sub_Mock_C := latchC.State.Subscribe(mockSubForC);
@@ -320,8 +320,8 @@ var
begin
// LatchA needs 2 notifies to become set. LatchB needs 1 notify to become set.
// LatchB subscribes to LatchA. So LatchB will be notified once LatchA becomes set.
latchA := TMycLatch.CreateLatch(2);
latchB := TMycLatch.CreateLatch(1);
latchA := State.CreateLatch(2);
latchB := State.CreateLatch(1);
mockSubForB := TMockSubscriber.Create;
sub_Mock_B := latchB.State.Subscribe(mockSubForB);
@@ -347,7 +347,7 @@ var
mockSub: TMockSubscriber;
subscription: TMycSubscription;
begin
latch := TMycLatch.CreateLatch(0); // Returns TMycLatch.Null which is set.
latch := State.CreateLatch(0); // Returns TMycLatch.Null which is set.
mockSub := TMockSubscriber.Create;
subscription := latch.State.Subscribe(mockSub); // TMycLatch.Subscribe notifies immediately if already set.
@@ -362,7 +362,7 @@ var
mockSub: TMockSubscriber;
subscription: TMycSubscription;
begin
latch := TMycLatch.CreateLatch(1);
latch := State.CreateLatch(1);
mockSub := TMockSubscriber.Create;
subscription := latch.State.Subscribe(mockSub);
@@ -381,7 +381,7 @@ var
mockSub: TMockSubscriber;
subscription: TMycSubscription;
begin
latch := TMycLatch.CreateLatch(3);
latch := State.CreateLatch(3);
latch.Notify; // Count -> 2
latch.Notify; // Count -> 1
@@ -404,7 +404,7 @@ var
mockSub1, mockSub2: TMockSubscriber;
subscription1, subscription2: TMycSubscription;
begin
latch := TMycLatch.CreateLatch(1);
latch := State.CreateLatch(1);
mockSub1 := TMockSubscriber.Create;
mockSub2 := TMockSubscriber.Create;
@@ -432,7 +432,7 @@ var
mockSub: TMockSubscriber;
// 'subscription' will be declared in an inner scope to control its finalization
begin
latch := TMycLatch.CreateLatch(1);
latch := State.CreateLatch(1);
mockSub := TMockSubscriber.Create;
var noException: Boolean := True;
@@ -468,7 +468,7 @@ var
mockSubInitial, mockSubNew: TMockSubscriber;
subscriptionInitial, subscriptionNew: TMycSubscription;
begin
latch := TMycLatch.CreateLatch(1);
latch := State.CreateLatch(1);
mockSubInitial := TMockSubscriber.Create;
subscriptionInitial := latch.State.Subscribe(mockSubInitial);
Test/TestTasks.pas
+1 -1
View File
@@ -8,7 +8,7 @@ uses
System.Classes,
System.SyncObjs,
Myc.Core.Tasks,
Myc.Signals, // Uses TMycLatch.CreateLatch and TMycLatch.Null
Myc.Signals, Myc.Core.Signals,
Myc.Core.Atomic;
type