public static IWorkflow Instantiate(IWorkplan workplan, IWorkplanContext context)
        {
            // Prepare variables
            var places      = new Dictionary <long, IPlace>();
            var transitions = new List <ITransition>();

            // Iterate over each step and find its connectors
            foreach (var step in workplan.Steps)
            {
                // Create transition
                var transition = step.CreateInstance(context);

                // Set inputs
                for (var i = 0; i < step.Inputs.Length; i++)
                {
                    transition.Inputs[i] = GetPlace(step.Inputs[i], places);
                }

                // Set outputs
                for (int i = 0; i < step.Outputs.Length; i++)
                {
                    transition.Outputs[i] = GetPlace(step.Outputs[i], places);
                }

                transitions.Add(transition);
            }

            return(new SimpleWorkflow(workplan, places.Values.ToList(), transitions));
        }
        /// <summary>
        /// Instantiate transition from this step
        /// </summary>
        protected override TransitionBase Instantiate(IWorkplanContext context)
        {
            var engine        = Workflow.CreateEngine(Workplan, context);
            var indexResolver = _indexResolver ??= TransitionBase.CreateIndexResolver(OutputDescriptions);
            var transition    = new SubworkflowTransition(engine, indexResolver);

            return(transition);
        }
        /// <summary>
        /// Create the workflow engine for a given workflow instance and add context
        /// </summary>
        private static WorkflowEngine CreateWorkflowEngine(IWorkflow workflow, IWorkplanContext context)
        {
            var engine = new WorkflowEngine {
                Context = context
            };

            engine.Initialize(workflow);
            return(engine);
        }
        ///
        public ITransition CreateInstance(IWorkplanContext context)
        {
            var transition = Instantiate(context);

            transition.Id      = Id;
            transition.Inputs  = new IPlace[Inputs.Length];
            transition.Outputs = new IPlace[Outputs.Length];
            return(transition);
        }
        /// <summary>
        /// Creates a <see cref="TaskTransition{T}"/> for this activity type
        /// </summary>
        protected override TransitionBase Instantiate(IWorkplanContext context)
        {
            if (context.IsDisabled(this))
            {
                return(new NullTransition());
            }

            // Create transition
            var indexResolver = _indexResolver ?? (_indexResolver = TransitionBase.CreateIndexResolver(OutputDescriptions));

            return(new TaskTransition <TActivity>(Parameters, indexResolver));
        }
 ///
 protected override TransitionBase Instantiate(IWorkplanContext context)
 {
     return(new PausableTransition());
 }
 ///
 protected override TransitionBase Instantiate(IWorkplanContext context)
 {
     return(new DummyTransition {
         Context = context, Name = Name
     });
 }
 /// <summary>
 /// Create engine instance from workplan and context. The default factory will be used to instantiate
 /// the workflow.
 /// </summary>
 public static IWorkflowEngine CreateEngine(IWorkplan workplan, IWorkplanContext context)
 {
     return(CreateWorkflowEngine(WorkflowFactory.Instantiate(workplan, context), context));
 }
 ///
 protected override TransitionBase Instantiate(IWorkplanContext context)
 {
     return(null);
 }
 ///
 protected abstract TransitionBase Instantiate(IWorkplanContext context);