0.13.x

Core/Stateflows.Common/Activities/Classes/ActivityWrapper.cs

@@ -1,9 +1,7 @@
 using System;
 using System.Threading.Tasks;
-using System.Collections.Generic;
 using Stateflows.Activities;
 using Stateflows.Activities.Events;
-using System.Linq;
 
 namespace Stateflows.Common.Activities.Classes
 {
@@ -18,15 +16,23 @@ public ActivityWrapper(IBehavior consumer)
             Behavior = consumer;
         }
 
-        public Task<RequestResult<ExecutionResponse>> ExecuteAsync(Event initializationEvent, IEnumerable<object> inputTokens = null)
-            => Behavior.RequestAsync(new ExecutionRequest()
-            {
-                InitializationEvent = initializationEvent,
-                InputTokens = inputTokens ?? new object[0],
-            });
+        public Task<RequestResult<ExecutionResponse>> ExecuteAsync(Event initializationEvent, Action<IInputContainer> inputBuilder = null)
+        {
+            var request = new ExecutionRequest() { InitializationEvent = initializationEvent };
+
+            inputBuilder?.Invoke(request);
+
+            return Behavior.RequestAsync(request);
+        }
 
-        public Task<RequestResult<ExecutionResponse>> ExecuteAsync(IEnumerable<object> inputTokens = null)
-            => Behavior.RequestAsync(new ExecutionRequest() { InputTokens = inputTokens ?? new object[0] });
+        public Task<RequestResult<ExecutionResponse>> ExecuteAsync(Action<IInputContainer> inputBuilder = null)
+        {
+            var request = new ExecutionRequest();
+
+            inputBuilder?.Invoke(request);
+
+            return Behavior.RequestAsync(request);
+        }
 
         public Task<SendResult> SendAsync<TEvent>(TEvent @event)
             where TEvent : Event, new()

Core/Stateflows.Common/Activities/Events/ExecutionRequest.cs

@@ -1,14 +1,29 @@
-using Newtonsoft.Json;
-using Stateflows.Common;
+using System.Linq;
 using System.Collections.Generic;
+using Newtonsoft.Json;
+using Stateflows.Common;
+using Stateflows.Common.Utilities;
 
 namespace Stateflows.Activities.Events
 {
-    public sealed class ExecutionRequest : Request<ExecutionResponse>
+    public interface IInputContainer
+    {
+        void AddInputToken<TToken>(TToken token);
+
+        void AddInputTokens<TToken>(IEnumerable<TToken> tokens);
+    }
+
+    public sealed class ExecutionRequest : Request<ExecutionResponse>, IInputContainer
     {
         public Event InitializationEvent { get; set; } = new Initialize();
 
         [JsonProperty(TypeNameHandling = TypeNameHandling.None)]
-        public IEnumerable<object> InputTokens { get; set; }
+        public List<TokenHolder> InputTokens { get; set; } = new List<TokenHolder>();
+
+        public void AddInputToken<TToken>(TToken token)
+            => InputTokens.Add(new TokenHolder<TToken>() { Payload = token });
+
+        public void AddInputTokens<TToken>(IEnumerable<TToken> tokens)
+            => InputTokens.AddRange(tokens.Select(token => new TokenHolder<TToken>() { Payload = token }));
     }
 }

Core/Stateflows.Common/Activities/Interfaces/IActivityBehavior.cs

@@ -1,13 +1,13 @@
-using System.Threading.Tasks;
-using System.Collections.Generic;
+using System;
+using System.Threading.Tasks;
 using Stateflows.Common;
 using Stateflows.Activities.Events;
 
 namespace Stateflows.Activities
 {
     public interface IActivityBehavior : IBehavior
     {
-        Task<RequestResult<ExecutionResponse>> ExecuteAsync(Event initializationEvent, IEnumerable<object> inputTokens = null);
-        Task<RequestResult<ExecutionResponse>> ExecuteAsync(IEnumerable<object> inputTokens = null);
+        Task<RequestResult<ExecutionResponse>> ExecuteAsync(Event initializationEvent, Action<IInputContainer> inputBuilder = null);
+        Task<RequestResult<ExecutionResponse>> ExecuteAsync(Action<IInputContainer> inputBuilder = null);
     }
 }

Core/Stateflows.Common/Events/Event.cs

@@ -17,15 +17,15 @@ public class Event
         public virtual string Name => GetType().GetEventName();
     }
 
-    //public class Event<TPayload> : Event
-    //{
-    //    public Event()
-    //    {
-    //        Payload = default;
-    //    }
-
-    //    public TPayload Payload { get; set; }
-    //}
+    public class Event<TPayload> : Event
+    {
+        public Event()
+        {
+            Payload = default;
+        }
+
+        public TPayload Payload { get; set; }
+    }
 
     public static class EventInfo<TEvent>
         where TEvent : Event, new()

Core/Stateflows.Common/Interfaces/IBehavior.cs

@@ -20,6 +20,9 @@ Task<RequestResult<CompoundResponse>> SendCompoundAsync(params Event[] events)
         Task<RequestResult<TResponse>> RequestAsync<TResponse>(Request<TResponse> request)
             where TResponse : Response, new();
 
+        Task<RequestResult<FinalizationResponse>> FinalizeAsync()
+            => RequestAsync(new FinalizationRequest());
+
         Task<RequestResult<ResetResponse>> ResetAsync(ResetMode resetMode = ResetMode.Full)
             => RequestAsync(new ResetRequest() { Mode = resetMode });
 

Core/Stateflows.Common/Utilities/StateflowsJsonConverter.cs

@@ -36,6 +36,10 @@ public static T CloneObject<T>(T value)
             where T : class
             => DeserializeObject(SerializePolymorphicObject(value)) as T;
 
+        [DebuggerStepThrough]
+        public static T Clone<T>(T value)
+            => (T)DeserializeObject(SerializePolymorphicObject(value));
+
         /// <summary>
         /// Serializes the specified object to a JSON string.
         /// </summary>

Core/Stateflows.Testing/StateMachines/Sequence/ExecutionSequenceObserver.cs

@@ -71,7 +71,7 @@ Task IStateMachineObserver.AfterTransitionEffectAsync(ITransitionContext<Event>
             return Task.CompletedTask;
         }
 
-        Task IStateMachineObserver.AfterTransitionGuardAsync(IGuardContext<Event> context, bool guardResult)
+        Task IStateMachineObserver.AfterTransitionGuardAsync(ITransitionContext<Event> context, bool guardResult)
         {
             SequenceBuilder.TransitionGuard(context.Event.Name, context.SourceState.Name, context.TargetState?.Name);
 

Core/Stateflows.Transport.Common/Stateflows.Common.Transport.csproj

@@ -35,8 +35,4 @@
     <PackageReference Include="Microsoft.Extensions.Hosting.Abstractions" Version="8.0.0" />
   </ItemGroup>
 
-  <ItemGroup>
-    <ProjectReference Include="..\Stateflows.Common\Stateflows.Common.csproj" />
-  </ItemGroup>
-
 </Project>

Core/Stateflows/Activities/ActivitiesDependencyInjection.cs

@@ -1,16 +1,16 @@
-using System.Diagnostics;
+using System;
+using System.Diagnostics;
 using System.Collections.Generic;
 using Microsoft.Extensions.DependencyInjection;
+using Stateflows.Common;
 using Stateflows.Common.Interfaces;
 using Stateflows.Common.Registration.Interfaces;
 using Stateflows.Activities.Engine;
+using Stateflows.Activities.Context;
 using Stateflows.Activities.Registration;
 using Stateflows.Activities.EventHandlers;
 using Stateflows.Activities.Registration.Builders;
 using Stateflows.Activities.Registration.Interfaces;
-using System;
-using Stateflows.Activities.Context;
-using Stateflows.Activities.Context.Interfaces;
 
 namespace Stateflows.Activities
 {
@@ -48,6 +48,7 @@ private static ActivitiesRegister EnsureActivitiesServices(this IStateflowsBuild
                     .AddSingleton<IActivityEventHandler, SubscriptionHandler>()
                     .AddSingleton<IActivityEventHandler, UnsubscriptionHandler>()
                     .AddSingleton<IActivityEventHandler, NotificationsHandler>()
+                    .AddSingleton<IActivityEventHandler, SetGlobalValuesHandler>()
                     .AddTransient(provider =>
                         ContextHolder.ActivityContext.Value ??
                         throw new InvalidOperationException($"No service for type '{typeof(IActivityContext).FullName}' is available in this context.")

Core/Stateflows/Activities/Classes/IterativeActivityNode.cs

@@ -1,6 +1,6 @@
 namespace Stateflows.Activities
 {
-    public sealed class IterativeActivityNode<TToken> : IBaseStructuredActivityNode
+    public sealed class IterativeActivityNode<TToken> : IStructuredActivityNode
     {
         public static string Name => ActivityNode<IterativeActivityNode<TToken>>.Name;
     }

Core/Stateflows/Activities/Classes/ParalellActivityNode.cs

@@ -1,6 +1,6 @@
 namespace Stateflows.Activities
 {
-    public sealed class ParallelActivityNode<TToken> : IBaseStructuredActivityNode
+    public sealed class ParallelActivityNode<TToken> : IStructuredActivityNode
     {
         public static string Name => ActivityNode<ParallelActivityNode<TToken>>.Name;
     }

Core/Stateflows/Activities/Classes/StructuredActivityNode.cs

@@ -1,6 +1,6 @@
 namespace Stateflows.Activities
 {
-    public sealed class StructuredActivityNode : ActivityNode, IBaseStructuredActivityNode
+    public sealed class StructuredActivityNode : ActivityNode, IStructuredActivityNode
     {
         public static string Name => ActivityNode<StructuredActivityNode>.Name;
     }

Core/Stateflows/Activities/Context/Classes/ActivityInitializationContext.cs

@@ -2,6 +2,10 @@
 using Stateflows.Activities.Engine;
 using Stateflows.Activities.Context.Interfaces;
 using Stateflows.Activities.Inspection.Interfaces;
+using System.Collections.Generic;
+using Stateflows.Activities.Extensions;
+using System.Linq;
+using Stateflows.Utils;
 
 namespace Stateflows.Activities.Context.Classes
 {
@@ -11,34 +15,44 @@ internal class ActivityInitializationContext<TInitializationEvent> :
         IRootContext
         where TInitializationEvent : Event, new()
     {
-        public ActivityInitializationContext(RootContext context, NodeScope nodeScope, TInitializationEvent initializationEvent)
+        public ActivityInitializationContext(RootContext context, NodeScope nodeScope, TInitializationEvent initializationEvent, List<TokenHolder> inputTokens)
             : base(context, nodeScope)
         {
             InitializationEvent = initializationEvent;
+            InputTokens = inputTokens ?? new List<TokenHolder>();
         }
 
-        public ActivityInitializationContext(BaseContext context, TInitializationEvent initializationEvent)
+        public ActivityInitializationContext(BaseContext context, TInitializationEvent initializationEvent, List<TokenHolder> inputTokens)
             : base(context)
         {
             InitializationEvent = initializationEvent;
+            InputTokens = inputTokens ?? new List<TokenHolder>();
         }
 
         IActivityContext IActivityActionContext.Activity => Activity;
 
         public TInitializationEvent InitializationEvent { get; }
+
+        public List<TokenHolder> InputTokens;
+
+        public void Output<TToken>(TToken token)
+            => OutputRange(new TToken[] { token });
+
+        public void OutputRange<TToken>(IEnumerable<TToken> tokens)
+            => InputTokens.AddRange(tokens.Select(token => token.ToTokenHolder()).ToArray());
     }
 
     internal class ActivityInitializationContext :
         ActivityInitializationContext<Event>,
         IActivityInitializationInspectionContext,
         IRootContext
     {
-        public ActivityInitializationContext(BaseContext context, Event initializationEvent)
-            : base(context, initializationEvent)
+        public ActivityInitializationContext(BaseContext context, Event initializationEvent, List<TokenHolder> inputTokens)
+            : base(context, initializationEvent, inputTokens)
         { }
 
-        public ActivityInitializationContext(RootContext context, NodeScope nodeScope, Event initializationEvent)
-            : base(context, nodeScope, initializationEvent)
+        public ActivityInitializationContext(RootContext context, NodeScope nodeScope, Event initializationEvent, List<TokenHolder> inputTokens)
+            : base(context, nodeScope, initializationEvent, inputTokens)
         { }
 
         IActivityInspectionContext IActivityInitializationInspectionContext.Activity => Activity;

Core/Stateflows/Activities/Context/ContextHolder.cs

@@ -1,5 +1,5 @@
 using System.Threading;
-using Stateflows.Activities.Context.Interfaces;
+using Stateflows.Common;
 
 namespace Stateflows.Activities.Context
 {

Core/Stateflows/Activities/Context/Interfaces/IActionContext.cs

@@ -3,7 +3,7 @@
     public interface ITypedActionContext : IActivityNodeContext
     { }
 
-    public interface IActionContext : ITypedActionContext, IInput, IOutput
+    public interface IActionContext : ITypedActionContext, IInput, IActionOutput
     { }
 
     public interface IActionContext<out TToken> : IActionContext, ITokenContext<TToken>

Core/Stateflows/Activities/Context/Interfaces/IOutput.cs → Core/Stateflows/Activities/Context/Interfaces/IActionOutput.cs

@@ -7,7 +7,10 @@ public interface IOutput
         void Output<TToken>(TToken token);
 
         void OutputRange<TToken>(IEnumerable<TToken> tokens);
+    }
 
+    public interface IActionOutput : IOutput
+    {
         void PassTokensOfTypeOn<TToken>();
 
         void PassAllTokensOn();

Core/Stateflows/Activities/Context/Interfaces/IActivityFlowContext.cs

@@ -1,18 +1,5 @@
-using System;
-
-namespace Stateflows.Activities.Context.Interfaces
+namespace Stateflows.Activities.Context.Interfaces
 {
-    public interface IFlowContext
-    {
-        ISourceNodeContext SourceNode { get; }
-
-        INodeContext TargetNode { get; }
-
-        Type TokenType { get; }
-
-        int Weight { get; }
-    }
-
     public interface IIncomingFlowContext : IFlowContext
     {
         bool Activated { get; }

Core/Stateflows/Activities/Context/Interfaces/IActivityInitializationContext.cs

@@ -2,7 +2,7 @@
 
 namespace Stateflows.Activities.Context.Interfaces
 {
-    public interface IActivityInitializationContext<out TInitializationRequest> : IActivityActionContext
+    public interface IActivityInitializationContext<out TInitializationRequest> : IActivityActionContext, IOutput
         where TInitializationRequest : Event
     {
         TInitializationRequest InitializationEvent { get; }

Core/Stateflows/Activities/Context/Interfaces/IExceptionHandlerContext.cs

@@ -2,14 +2,7 @@
 
 namespace Stateflows.Activities.Context.Interfaces
 {
-    public interface IExceptionContext
-    {
-        INodeContext ProtectedNode { get; }
-
-        INodeContext NodeOfOrigin { get; }
-    }
-
-    public interface IExceptionHandlerContext<out TException> : IExceptionContext, IActivityNodeContext, IOutput
+    public interface IExceptionHandlerContext<out TException> : IExceptionContext, IActivityNodeContext, IActionOutput
         where TException : Exception
     {
         TException Exception { get; }