/// <summary> /// /// </summary> /// <param name="function"></param> /// <param name="branch"></param> /// <returns></returns> public IWorkflow <T> Do(Func <T, T> function, IDeclaredOperation branch) { Check.IsNotNull(function, "function"); WorkflowBuilder.AddOperation(function, branch); return(this); }
public override void AddOperation(Func <T, T> function, IDeclaredOperation name) { InitializeDeclaredOperation(name); var operationPair = new OperationDuplex <T>(new FunctionInvoker <T>(function), null); taskList.Tasks.Add(operationPair); }
/// <summary> /// Adds a function into the execution path /// </summary> /// <param name="function">The function to add</param> /// <param name="branch">Branch point to initialize</param> public virtual IStatefulWorkflow <T> Do(Action <T> function, IDeclaredOperation branch) { return(Do(x => { function(x); return x; }, branch)); }
private void AddTransition(object from, object to, IDeclaredOperation op) { AddTransition(from, to); if (_transitions != null) { _allDefinedRefs[op] = to; } }
private void InitializeDeclaredOperation(IDeclaredOperation name) { if (name == null) { throw new ArgumentException("argument hasn't been initialized"); } name.SetTasks((System.Collections.IList)taskList.Tasks); }
/// <summary> /// Check the security gateway to ensure that any potential transitions through the branch point /// are allowed /// </summary> internal virtual void CheckThatTransitionIsAllowed(T entity, IDeclaredOperation to) { if (_gateway != null) { object from = GetOriginalState(entity); object toState = _builder.GetDestinationState(to); CheckThatTransitionIsAllowed(from, toState); } }
/// <summary> /// Called when making decisions /// </summary> /// <param name="branchPoint"></param> public void AnalyzeTransitionPaths(IDeclaredOperation branchPoint) { if (_definedRefs.ContainsKey(branchPoint)) { AddTransition(_nextKey, _definedRefs[branchPoint], branchPoint); } else { if (!_undefinedForwardRefs.ContainsKey(branchPoint)) { _undefinedForwardRefs[branchPoint] = new List <object>(); } _undefinedForwardRefs[branchPoint].Add(_nextKey); } }
/// <summary> /// Called when .Define()'ing points /// </summary> /// <param name="branchPoint"></param> public void CreateDecisionPath(IDeclaredOperation branchPoint) { if (_definedRefs.ContainsKey(branchPoint)) { throw new InvalidOperationException("branch point is already defined. " + "Cannot multiply define branch points"); } _definedRefs[branchPoint] = null; // placeholder _deferredStates.Add(x => _definedRefs[branchPoint] = x); // The real deal if (_undefinedForwardRefs.ContainsKey(branchPoint)) { foreach (var key in _undefinedForwardRefs[branchPoint]) { var placeholder = key; _deferredStates.Add(x => AddTransition(placeholder, x, branchPoint)); } _undefinedForwardRefs.Remove(branchPoint); } }
public virtual IStatefulWorkflow <T> Do(Action <T> function, ICheckConstraint constraint, IDeclaredOperation defineAs) { return(Do(x => { function(x); return x; }, constraint, defineAs)); }
public override void AddOperation(Func <T, T> function, ICheckConstraint constraint, IDeclaredOperation name) { throw new NotImplementedException(); }
public override void AddOperation(Func <T, T> function, IDeclaredOperation name) { throw new Exception(); }
/// <summary> /// /// </summary> /// <param name="function"></param> /// <param name="constraint"></param> /// <param name="name"></param> public abstract void AddOperation(Func <T, T> function, ICheckConstraint constraint, IDeclaredOperation name);
/// <summary> /// Adds a function into the execution path /// </summary> /// <param name="function">The funciton to add</param> /// <param name="constraint">constraint that determines if the operation is executed</param> /// <param name="branchPoint"></param> public virtual IWorkflow <T> Do(Func <T, T> function, ICheckConstraint constraint, IDeclaredOperation branchPoint) { Check.IsNotNull(function, "function"); Check.IsNotNull(constraint, "constraint"); WorkflowBuilder.AddOperation(function, constraint, branchPoint); return(this); }
public object GetDestinationState(IDeclaredOperation to) { return(_allDefinedRefs[to]); }
/// <summary> /// Declare a point that you may wish to branch to later /// </summary> /// <param name="defineAs"></param> /// <returns></returns> public virtual IStatefulWorkflow <T> Define(IDeclaredOperation defineAs) { _builder.Current.Do(x => x, defineAs); _builder.CreateDecisionPath(defineAs); return(this); }
/// <summary> /// Constructor used to define a path /// </summary> /// <param name="condition"></param> /// <param name="branchPoint"></param> public BranchCondition(Func <bool> condition, IDeclaredOperation branchPoint) : base(condition) { BranchPoint = branchPoint; }
public new IStatefulWorkflow <T> Do(Func <T, T> function, ICheckConstraint constraint, IDeclaredOperation branch) { _builder.Current.Do(function, constraint, branch); return(this); }
/// <summary> /// /// </summary> /// <param name="function"></param> /// <param name="name"></param> public abstract void AddOperation(Func <T, T> function, IDeclaredOperation name);
/// <summary> /// Returns a BooleanCheckConstraint that can use a function to evaluate /// </summary> /// <param name="evaluator">The function to use</param> /// <param name="otherwise"></param> /// <returns>BooleanCheckConstraint</returns> public static ICheckConstraint IsTrue(Func <bool> evaluator, IDeclaredOperation otherwise) { return(new BranchCondition(evaluator, otherwise)); }
/// <summary> /// Constructor used to define a path /// </summary> /// <param name="condition"></param> /// <param name="branchPoint"></param> public BranchCondition(Func<bool> condition, IDeclaredOperation branchPoint) : base(condition) { BranchPoint = branchPoint; }