/// <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;
}
