public NessDefinition <Tness, Tdecorated> AddCondition(string name, IConditionOf <Arg <Tness> > condition)
{
var item = NessCondition <Tness> .New(name, condition);
this.ConditionStore.SaveItem(item);
return(this);
}
public NessCondition(string id, IConditionOf <Arg <Tness> > condition)
{
Condition.Requires(id).IsNotNullOrEmpty();
Condition.Requires(condition).IsNotNull();
this.Id = id;
this.Conditional = condition;
}
public static IForwardMovingTokenizer <T> HasImplementation <T>(this IForwardMovingTokenizer <T> decorated,
Func <ForwardMovingTokenizingCursor <T>, ForwardMovingTokenizingCursor <T> > tokenizingStrategy,
IConditionOf <ForwardMovingTokenizingCursor <T> > canHandleCondition = null)
{
Condition.Requires(decorated).IsNotNull();
return(new HasImplementationTokenizerDecoration <T>(decorated, tokenizingStrategy, canHandleCondition));
}
public static Polyface IsConditionalExpirable(this Polyface root, IConditionOf<Polyface> expiry)
{
Condition.Requires(root).IsNotNull();
var composited = new NaturalConditionalExpirable(expiry.WithValue(root.AsNaturalValue()));
root.Is(composited);
return root;
}
public HasImplementationTokenizerDecoration(IForwardMovingTokenizer <T> decorated,
Func <ForwardMovingTokenizingCursor <T>, ForwardMovingTokenizingCursor <T> > tokenizingStrategy,
IConditionOf <ForwardMovingTokenizingCursor <T> > canHandleCondition = null)
: base(decorated.HasValidation(canHandleCondition))
{
Condition.Requires(tokenizingStrategy).IsNotNull();
this.TokenizingStrategy = tokenizingStrategy;
}
public static Polyface IsConditionalExpirable(this Polyface root, IConditionOf <Polyface> expiry)
{
Condition.Requires(root).IsNotNull();
var composited = new NaturalConditionalExpirable(expiry.WithValue(root.AsNaturalValue()));
root.Is(composited);
return(root);
}
public ContextualCondition(IConditionOf <T> decorated, T context)
: base(decorated)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
this.Context = context;
}
public FluentStateTransitionBehaviour <TContext> TriggeredWhen(IConditionOf <TContext> triggerCondition, Func <TContext, object[]> argFactory)
{
Condition.Requires(triggerCondition).IsNotNull();
Condition.Requires(argFactory).IsNotNull();
FluentStateTransitionTrigger <TContext> trigger = new FluentStateTransitionTrigger <TContext>(triggerCondition, argFactory);
this.Trigger = trigger;
return(this);
}
public bool?Evaluate()
{
bool?rv = null;
//get the value to apply
var val = this.Context.GetValue();
//clone the condition if we can
if (this.Decorated is ICloneableCondition)
{
ICloneableCondition cloneCond = (ICloneableCondition)this.Decorated;
IConditionOf <T> clone = (IConditionOf <T>)cloneCond.Clone();
rv = clone.Evaluate(val);
}
rv = this.Decorated.Evaluate(val);
return(rv);
}
/// <summary>
/// fluent And
/// </summary>
/// <param name="cond"></param>
/// <param name="conds"></param>
/// <returns></returns>
public static IConditionOf <T> And <T>(this IConditionOf <T> cond, params IConditionOf <T>[] conds)
{
if (conds == null || conds.Length == 0)
{
return(cond);
}
List <IConditionOf <T> > newConds = new List <IConditionOf <T> >();
//if THIS is null, don't include it in the return condition
if (cond != null)
{
newConds.Add(cond);
}
newConds.AddRange(conds);
return(new AndOf <T>(newConds.ToArray()));
}
public ValidatingTokenizerDecoration(IForwardMovingTokenizer <T> decorated,
IConditionOf <ForwardMovingTokenizingCursor <T> > canHandleCondition = null)
: base(decorated)
{
//ensure no more than 1 selfdirected decoration is possible per stack
//checking for this is a bit subtle. at this point in the decoration process
// SetDecorated has been called by the base ctor, which puts ValidatingTokenizerDecoration
// as the topmost decoration. So any AS call will return this, as it walks to topmost first.
//We need to check beneath this layer rather, and do an ASBelow call or we will always kack
var validator = decorated.AsBelow <ValidatingTokenizerDecoration <T> >();
if (validator != null)
{
throw new InvalidOperationException("already self-directed");
}
if (canHandleCondition == null)
{
////default implementation is to do the base parse
//this.CanTokenizeCondition = StrategizedConditionOf<ForwardMovingTokenizingCursor<T>>.New(cursor =>
//{
// int newPosition;
// IToken<T> newToken;
// IForwardMovingTokenizer<T> newTokenizer;
// return base.Parse(cursor.Source, cursor.CurrentPosition, cursor.State, cursor.CurrentToken,
// out newPosition,
// out newToken,
// out newTokenizer);
//});
}
else
{
this.CanTokenizeCondition = canHandleCondition;
}
}
public static NessCondition <Tness> New(string id, IConditionOf <Arg <Tness> > condition)
{
return(new NessCondition <Tness>(id, condition));
}
public FluentStateTransitionTrigger(IConditionOf <TContext> triggerCondition,
Func <TContext, object[]> transitionFunctionArgumentFactory)
{
this.TriggerCondition = triggerCondition;
this.TriggerArgumentFactory = transitionFunctionArgumentFactory;
}
public Trigger <TContext> TriggeredWhen(IConditionOf <TContext> triggerCondition)
{
Condition.Requires(triggerCondition).IsNotNull();
this.TriggerCondition = triggerCondition;
return(this);
}
public DecoratedConditionOfBase(IConditionOf <T> decorated)
: base(decorated)
{
}
public static WithValueConditionOfDecoration <T> New(IConditionOf <T> decorated, IValueOf <T> context)
{
return(new WithValueConditionOfDecoration <T>(decorated, context));
}
public static HasImplementationTokenizerDecoration <T> New(IForwardMovingTokenizer <T> decorated,
Func <ForwardMovingTokenizingCursor <T>, ForwardMovingTokenizingCursor <T> > tokenizingStrategy,
IConditionOf <ForwardMovingTokenizingCursor <T> > canHandleCondition = null)
{
return(new HasImplementationTokenizerDecoration <T>(decorated, tokenizingStrategy, canHandleCondition));
}
public static ValidatingTokenizerDecoration <T> New(IForwardMovingTokenizer <T> decorated, IConditionOf <ForwardMovingTokenizingCursor <T> > canHandleCondition = null)
{
return(new ValidatingTokenizerDecoration <T>(decorated, canHandleCondition));
}
/// <summary>
/// decorates with self direction. if stack already has this decoration, just ands the condition
/// </summary>
/// <param name="decorated"></param>
/// <param name="canHandleStrategy"></param>
/// <returns></returns>
public static IForwardMovingTokenizer <T> HasValidation <T>(this IForwardMovingTokenizer <T> decorated, IConditionOf <ForwardMovingTokenizingCursor <T> > canHandleCondition = null)
{
Condition.Requires(decorated).IsNotNull();
/**NOTE:
* We search for the same decoration in order to prevent a duplication of decoration.
* We MUST ALWAYS return the outermost decoration!!!!!!
* This would naturally happen if we do a simple decoration.
* If we don't return outermost then we can cause layers to disappear.
*/
//if we have a self direction decoration in the stack we return that
var dec = decorated.As <ValidatingTokenizerDecoration <T> >(true);
if (dec != null)
{
if (canHandleCondition != null)
{
dec.CanTokenizeCondition = dec.CanTokenizeCondition.And(canHandleCondition);
}
var outer = dec.GetOuterDecorator() as IForwardMovingTokenizer <T>;
return(outer);
}
return(new ValidatingTokenizerDecoration <T>(decorated, canHandleCondition));
}
/// <summary>
/// Converts a ConditionOf into an ICondition by providing an argument valueOf
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="condOf"></param>
/// <param name="val"></param>
/// <returns></returns>
public static WithValueConditionOfDecoration <T> WithValue <T>(this IConditionOf <T> condOf, IValueOf <T> val)
{
Condition.Requires(condOf).IsNotNull();
return(WithValueConditionOfDecoration <T> .New(condOf, val));
}
public override IDecorationOf <IConditionOf <T> > ApplyThisDecorationTo(IConditionOf <T> thing)
{
return(new WithValueConditionOfDecoration <T>(thing, this.Context));
}
public static ContextualCondition <T> AddContext <T>(this IConditionOf <T> thing, T context)
{
Condition.Requires(thing).IsNotNull();
return(new ContextualCondition <T>(thing, context));
}
public WithValueConditionOfDecoration(IConditionOf <T> decorated, IValueOf <T> context)
: base(decorated)
{
Condition.Requires(context).IsNotNull();
this.Context = context;
}
