Added support for output-only pipelines

Author: Visual-Vincent

FluentPipelines/IPipelineStartBuilder.cs

@@ -2,6 +2,34 @@
 
 namespace FluentPipelines
 {
+    /// <summary>
+    /// Defines methods for a builder that constructs the beginning of pipelines with no input data.
+    /// </summary>
+    public interface IPipelineStartBuilder
+    {
+        /// <summary>
+        /// Defines the starting step of the pipeline.
+        /// </summary>
+        /// <typeparam name="TNext">
+        /// The type of data returned from the step.
+        /// This will be passed onto the next step (or returned as the output of the pipeline, if no more steps are added).
+        /// </typeparam>
+        /// <param name="action">A function acting as the first step of the pipeline.</param>
+        /// <returns>A builder that allows you to continue building the rest of the pipeline.</returns>
+        IOutPipelineBuilder<TNext> Start<TNext>(OutPipelineStepDelegate<TNext> action);
+
+        /// <summary>
+        /// Defines the starting step of the pipeline.
+        /// </summary>
+        /// <typeparam name="TNext">
+        /// The type of data returned from the step.
+        /// This will be passed onto the next step (or returned as the output of the pipeline, if no more steps are added).
+        /// </typeparam>
+        /// <param name="step">The first step of the pipeline.</param>
+        /// <returns>A builder that allows you to continue building the rest of the pipeline.</returns>
+        IOutPipelineBuilder<TNext> Start<TNext>(IOutPipelineStep<TNext> step);
+    }
+
     /// <summary>
     /// Defines methods for a builder that constructs the beginning of pipelines taking input data.
     /// </summary>

…pelines/Pipelines/InputOutputPipeline.cs …ntPipelines/InputOutput/InOutPipeline.csFluentPipelines/Pipelines/InputOutputPipeline.cs renamed to FluentPipelines/InputOutput/InOutPipeline.cs FluentPipelines/Pipelines/InputOutputPipeline.cs renamed to FluentPipelines/InputOutput/InOutPipeline.cs

@@ -2,26 +2,26 @@
 using System.Collections.Generic;
 using System.Linq;
 
-namespace FluentPipelines.Pipelines
+namespace FluentPipelines
 {
     /// <summary>
     /// A pipeline that takes <typeparamref name="TInput"/> as input, and returns <typeparamref name="TOutput"/>.
     /// </summary>
     /// <typeparam name="TInput">The type of data used as input to the pipeline.</typeparam>
     /// <typeparam name="TOutput">The type of data returned from the pipeline.</typeparam>
-    public sealed class InputOutputPipeline<TInput, TOutput> : IPipeline<TInput, TOutput>
+    public sealed class InOutPipeline<TInput, TOutput> : IPipeline<TInput, TOutput>
     {
         private readonly PipelineStep[] steps;
 
         /// <summary>
-        /// Initializes a new instance of the <see cref="InputOutputPipeline{TInput, TOutput}"/> class.
+        /// Initializes a new instance of the <see cref="InOutPipeline{TInput, TOutput}"/> class.
         /// </summary>
         /// <param name="steps">
         /// The steps to be executed as part of the pipeline.
         /// It is important that the first step takes <typeparamref name="TInput"/> as input, 
         /// and that the final step returns <typeparamref name="TOutput"/>.
         /// </param>
-        public InputOutputPipeline(IEnumerable<PipelineStep> steps)
+        public InOutPipeline(IEnumerable<PipelineStep> steps)
         {
             if(steps is null)
                 throw new ArgumentNullException(nameof(steps));
@@ -40,20 +40,20 @@ public TOutput Run(TInput input)
     }
 
     /// <summary>
-    /// A static class containing helper methods for <see cref="InputOutputPipeline{TInput, TOutput}"/>.
+    /// A static class containing helper methods for <see cref="InOutPipeline{TInput, TOutput}"/>.
     /// </summary>
     public static class InputOutputPipeline
     {
         /// <summary>
-        /// Creates an <see cref="InputOutputPipeline{TInput, TOutput}"/> from a <see cref="PipelineBuilder{TInput, TOutput}"/>.
+        /// Creates an <see cref="InOutPipeline{TInput, TOutput}"/> from a <see cref="PipelineBuilder{TInput, TOutput}"/>.
         /// </summary>
         /// <typeparam name="TInput">The type of data used as input to the pipeline.</typeparam>
         /// <typeparam name="TOutput">The type of data returned from the pipeline.</typeparam>
         /// <param name="builder">The builder containing the steps to be executed as part of the pipeline.</param>
         /// <returns>The resulting pipeline.</returns>
-        public static InputOutputPipeline<TInput, TOutput> CreateFrom<TInput, TOutput>(PipelineBuilder<TInput, TOutput> builder)
+        public static InOutPipeline<TInput, TOutput> CreateFrom<TInput, TOutput>(PipelineBuilder<TInput, TOutput> builder)
         {
-            return new InputOutputPipeline<TInput, TOutput>(builder.Steps);
+            return new InOutPipeline<TInput, TOutput>(builder.Steps);
         }
     }
 }

FluentPipelines/Output/IOutPipeline.cs

@@ -0,0 +1,17 @@
+using System;
+
+namespace FluentPipelines
+{
+    /// <summary>
+    /// Defines methods for a pipeline that takes no input, and returns <typeparamref name="TOutput"/>.
+    /// </summary>
+    /// <typeparam name="TOutput">The type of data returned from the pipeline.</typeparam>
+    public interface IOutPipeline<TOutput>
+    {
+        /// <summary>
+        /// Runs the pipeline.
+        /// </summary>
+        /// <returns>The result of the pipeline.</returns>
+        TOutput Run();
+    }
+}

FluentPipelines/Output/IOutPipelineBuilder.cs

@@ -0,0 +1,39 @@
+using System;
+
+namespace FluentPipelines
+{
+    /// <summary>
+    /// Defines methods for a builder that constructs pipelines with output data and no input data.
+    /// </summary>
+    /// <typeparam name="TOutput">The type of data returned as the output of the pipeline.</typeparam>
+    public interface IOutPipelineBuilder<TOutput>
+    {
+        /// <summary>
+        /// Compiles all steps and builds a runnable pipeline.
+        /// </summary>
+        /// <returns>The resulting pipeline.</returns>
+        IOutPipeline<TOutput> Build();
+
+        /// <summary>
+        /// Defines the next step of the pipeline.
+        /// </summary>
+        /// <typeparam name="TNext">
+        /// The type of data returned from the step.
+        /// This will be passed onto the next step (or returned as the output of the pipeline, if no more steps are added).
+        /// </typeparam>
+        /// <param name="action">A function acting as the next step of the pipeline, processing the data from the previous step.</param>
+        /// <returns>A builder that allows you to continue building the rest of the pipeline.</returns>
+        IOutPipelineBuilder<TNext> Then<TNext>(PipelineStepDelegate<TOutput, TNext> action);
+
+        /// <summary>
+        /// Defines the next step of the pipeline.
+        /// </summary>
+        /// <typeparam name="TNext">
+        /// The type of data returned from the step.
+        /// This will be passed onto the next step (or returned as the output of the pipeline, if no more steps are added).
+        /// </typeparam>
+        /// <param name="step">The next step of the pipeline, processing the data from the previous step.</param>
+        /// <returns>A builder that allows you to continue building the rest of the pipeline.</returns>
+        IOutPipelineBuilder<TNext> Then<TNext>(IPipelineStep<TOutput, TNext> step);
+    }
+}

FluentPipelines/Output/IOutPipelineStep.cs

@@ -0,0 +1,17 @@
+using System;
+
+namespace FluentPipelines
+{
+    /// <summary>
+    /// Defines methods for a pipeline step with an output and no input.
+    /// </summary>
+    /// <typeparam name="TOutput">The type of data returned from the step.</typeparam>
+    public interface IOutPipelineStep<TOutput>
+    {
+        /// <summary>
+        /// Executes the step.
+        /// </summary>
+        /// <returns>The resulting output data from the step.</returns>
+        TOutput Run();
+    }
+}

FluentPipelines/Output/OutFunctionStep.cs

@@ -0,0 +1,28 @@
+using System;
+
+namespace FluentPipelines
+{
+    /// <summary>
+    /// A pipeline step that executes a delegate method.
+    /// </summary>
+    /// <typeparam name="TOutput">The type of data returned from the step.</typeparam>
+    public class OutFunctionStep<TOutput> : IOutPipelineStep<TOutput>
+    {
+        private readonly OutPipelineStepDelegate<TOutput> function;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="OutFunctionStep{TOutput}"/> class.
+        /// </summary>
+        /// <param name="function">The delegate method to execute.</param>
+        public OutFunctionStep(OutPipelineStepDelegate<TOutput> function)
+        {
+            this.function = function ?? throw new ArgumentNullException(nameof(function));
+        }
+
+        /// <inheritdoc/>
+        public TOutput Run()
+        {
+            return function();
+        }
+    }
+}

FluentPipelines/Output/OutPipeline.cs

@@ -0,0 +1,61 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace FluentPipelines
+{
+    /// <summary>
+    /// A pipeline that takes no input, and returns <typeparamref name="TOutput"/>.
+    /// </summary>
+    /// <typeparam name="TOutput">The type of data returned from the pipeline.</typeparam>
+    public sealed class OutPipeline<TOutput> : IOutPipeline<TOutput>
+    {
+        private readonly OutPipelineStep firstStep;
+        private readonly PipelineStep[] steps;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="OutPipeline{TOutput}"/> class.
+        /// </summary>
+        /// <param name="firstStep">
+        /// The first step to execute.
+        /// <para><b>IMPORTANT:</b> If this is the only step in the pipeline, it must return <typeparamref name="TOutput"/>.</para>
+        /// </param>
+        /// <param name="steps">
+        /// The rest of the steps to be executed as part of the pipeline.
+        /// It is important that the final step returns <typeparamref name="TOutput"/>.
+        /// </param>
+        public OutPipeline(OutPipelineStep firstStep, IEnumerable<PipelineStep> steps)
+        {
+            this.firstStep = firstStep ?? throw new ArgumentNullException(nameof(firstStep));
+            this.steps = steps?.ToArray() ?? Array.Empty<PipelineStep>();
+        }
+
+        /// <inheritdoc/>
+        public TOutput Run()
+        {
+            var output = firstStep.Run();
+
+            if(steps.Length == 0)
+                return (TOutput)output;
+
+            return (TOutput)steps.Execute(output);
+        }
+    }
+
+    /// <summary>
+    /// A static class containing helper methods for <see cref="OutPipeline{TOutput}"/>.
+    /// </summary>
+    public static class OutputPipeline
+    {
+        /// <summary>
+        /// Creates an <see cref="OutPipeline{TOutput}"/> from a <see cref="OutPipelineBuilder{TOutput}"/>.
+        /// </summary>
+        /// <typeparam name="TOutput">The type of data returned from the pipeline.</typeparam>
+        /// <param name="builder">The builder containing the steps to be executed as part of the pipeline.</param>
+        /// <returns>The resulting pipeline.</returns>
+        public static OutPipeline<TOutput> CreateFrom<TOutput>(OutPipelineBuilder<TOutput> builder)
+        {
+            return new OutPipeline<TOutput>(builder.FirstStep, builder.Steps);
+        }
+    }
+}

FluentPipelines/Output/OutPipelineBuilder.cs

@@ -0,0 +1,79 @@
+using System;
+using System.Collections.Generic;
+
+namespace FluentPipelines
+{
+    /// <summary>
+    /// A builder that builds a pipeline with output data and no input data.
+    /// </summary>
+    /// <typeparam name="TOutput">The type of data returned from the pipeline.</typeparam>
+    public class OutPipelineBuilder<TOutput> : IOutPipelineBuilder<TOutput>
+    {
+        /// <summary>
+        /// Gets the first step of the pipeline.
+        /// </summary>
+        protected internal OutPipelineStep FirstStep { get; }
+
+        /// <summary>
+        /// Gets the collection of steps added to the builder, which will be used to construct the pipeline.
+        /// </summary>
+        protected internal List<PipelineStep> Steps { get; }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="OutPipelineBuilder{TOutput}"/> class.
+        /// </summary>
+        /// <param name="firstStep">
+        /// The first step of the pipeline.
+        /// <para><b>IMPORTANT:</b> If this is the only step, it must return <typeparamref name="TOutput"/>, otherwise the built-in pipeline types will not work.</para>
+        /// </param>
+        /// <param name="steps">
+        /// The collection of steps to add to the builder, which will be used to construct the pipeline.
+        /// <para><b>IMPORTANT:</b> The the last step must return <typeparamref name="TOutput"/>, otherwise the built-in pipeline types will not work.</para>
+        /// <para><b>IMPORTANT:</b> <paramref name="steps"/> is taken by reference! The list is NOT copied!</para>
+        /// </param>
+        protected OutPipelineBuilder(OutPipelineStep firstStep, List<PipelineStep> steps)
+        {
+            FirstStep = firstStep ?? throw new ArgumentNullException(nameof(firstStep));
+            Steps = steps ?? throw new ArgumentNullException(nameof(steps));
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="OutPipelineBuilder{TOutput}"/> class.
+        /// </summary>
+        /// <param name="firstStep">The first step of the pipeline, processing the input data.</param>
+        public OutPipelineBuilder(IOutPipelineStep<TOutput> firstStep)
+        {
+            if(firstStep is null)
+                throw new ArgumentNullException(nameof(firstStep));
+
+            FirstStep = new OutPipelineStep<TOutput>(firstStep);
+            Steps = new List<PipelineStep>();
+        }
+
+        /// <inheritdoc/>
+        public virtual IOutPipeline<TOutput> Build()
+        {
+            return new OutPipeline<TOutput>(FirstStep, Steps);
+        }
+
+        /// <inheritdoc/>
+        public virtual IOutPipelineBuilder<TNext> Then<TNext>(PipelineStepDelegate<TOutput, TNext> action)
+        {
+            if(action is null)
+                throw new ArgumentNullException(nameof(action));
+
+            return Then(new FunctionStep<TOutput, TNext>(action));
+        }
+
+        /// <inheritdoc/>
+        public virtual IOutPipelineBuilder<TNext> Then<TNext>(IPipelineStep<TOutput, TNext> step)
+        {
+            if(step is null)
+                throw new ArgumentNullException(nameof(step));
+
+            Steps.Add(new PipelineStep<TOutput, TNext>(step));
+
+            return new OutPipelineBuilder<TNext>(FirstStep, Steps);
+        }
+    }
+}

FluentPipelines/Output/OutPipelineStep.cs

@@ -0,0 +1,53 @@
+using System;
+
+namespace FluentPipelines
+{
+    /// <summary>
+    /// A pipeline step with an output and no input.
+    /// </summary>
+    /// <typeparam name="TOutput">The type of data returned from the step.</typeparam>
+    public sealed class OutPipelineStep<TOutput> : OutPipelineStep
+    {
+        private readonly IOutPipelineStep<TOutput> step;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="OutPipelineStep{TOutput}"/> class.
+        /// </summary>
+        /// <param name="step">The base step to create this generic step from.</param>
+        public OutPipelineStep(IOutPipelineStep<TOutput> step)
+        {
+            this.step = step ?? throw new ArgumentNullException(nameof(step));
+        }
+
+        internal override object Run()
+        {
+            return step.Run();
+        }
+    }
+
+    /// <summary>
+    /// The base class for generic, typeless pipeline steps. Also contains helper methods to create strongly typed generic steps.
+    /// </summary>
+    public class OutPipelineStep
+    {
+        /// <summary>
+        /// Creates a <see cref="OutPipelineStep{TOutput}"/>.
+        /// </summary>
+        /// <typeparam name="TOutput">The type of data returned from the step.</typeparam>
+        /// <param name="step">The base step to create the generic step from.</param>
+        /// <returns>A generic pipeline step.</returns>
+        public static OutPipelineStep<TOutput> Create<TOutput>(IOutPipelineStep<TOutput> step)
+        {
+            return new OutPipelineStep<TOutput>(step);
+        }
+
+        internal OutPipelineStep()
+        {
+        }
+
+        internal virtual object Run()
+        {
+            throw new NotImplementedException();
+        }
+    }
+}