/// <summary> /// Default-ctor to build an empty validation rule with given name, description and delegate /// </summary> internal RDFOntologyValidationRule(String ruleName, String ruleDescription, RuleDelegate ruleDelegate) { this.RuleName = ruleName; this.RuleDescription = ruleDescription; this.ExecuteRule = ruleDelegate; }
public Rule(Parser parser, RuleType ruleType, Predicate <Parser> lookAhead, RuleDelegate evaluate) { _parser = parser; _ruleType = ruleType; _lookAhead = lookAhead; _evaluate = evaluate; }
public static void FireEvent(RuleDelegate ruleEvent, object sender, RuleEventArgs args) { if (ruleEvent != null) { ruleEvent(sender, args); } }
public Rule(Parser parser, RuleType ruleType, Predicate<Parser> lookAhead, RuleDelegate evaluate) { _parser = parser; _ruleType = ruleType; _lookAhead = lookAhead; _evaluate = evaluate; }
/// <summary> /// We created a delegate to create a flexible behaviour /// </summary> public static void ScenarioOne() { RuleDelegate addDelegate = (x, y) => x + y; RuleDelegate multipleDelegate = (x, y) => x * y; var newOperation = new Calculator(); newOperation.Math(10, 10, multipleDelegate); newOperation.Math(10, 10, addDelegate); }
/// <summary> /// Creates new rule with parameters. /// </summary> /// <param name="templateName">String name of the template.</param> /// <param name="tag">String tag for which the rule will be applied to.</param> /// <param name="ruleDelegate">Rule delegate to be invoked to process the rule.</param> internal Rule(string templateName, string tag, RuleDelegate ruleDelegate) { this.TemplateName = templateName; this.Tag = tag; this.RuleDelegate = ruleDelegate; }
public static Rule Delay(RuleDelegate r) { return new DelayRule(r); }
public void Math(int x, int y, RuleDelegate del) { var result = del(x, y); System.Console.WriteLine(result); }
public virtual object ApplyOnce(object t, RuleDelegate whichRule) { originalAdaptor.ClearChanged(); if (t==null) return null; // Debug.Assert(this.BacktrackingLevel == 0); try { // Share TreeParser object but not parsing-related state // state = new RecognizerSharedState(); input = new CommonTreeNodeStream(originalAdaptor, t); ((CommonTreeNodeStream)input).TokenStream = originalTokenStream; // this.BacktrackingLevel = 1; // Debug.Assert(!this.Failed()); TreeRuleReturnScope r = whichRule((NadirAST)t); // return (r==null ? null : r.Tree); } catch (RecognitionException) { } finally { this.BacktrackingLevel = 0; } return t; }
/////////////////////////////////////////// // // Visitation // /////////////////////////////////////////// public override object ApplyOnce(object t, RuleDelegate whichRule) { object tNew = base.ApplyOnce(t, whichRule); // if (this.Failed() || !this.originalAdaptor.IsChanged()) { this.originalAdaptor.ClearChanged(); return t; } // if (showTransformations) { this.ReportTransformation(t, tNew); } // return tNew; }
/// <summary> /// Constructor. /// </summary> /// <param name="propertyName">The name of the property the rule is based on. This may be blank if the rule is not for any specific property.</param> /// <param name="brokenDescription">A description of the rule that will be shown if the rule is broken.</param> /// <param name="ruleDelegate"></param> public BusinessRule(string propertyName, string brokenDescription, RuleDelegate ruleDelegate) { this.Description = brokenDescription; this.PropertyName = propertyName; this.RuleDelegate = ruleDelegate; }
public static void FireEvent(RuleDelegate ruleEvent, object sender) { FireEvent(ruleEvent, sender, new RuleEventArgs()); }
/// <summary> /// Constructs a <c>DelegatedRule</c> with the given name and that /// applies in the circumstances defines by its <c>Precondition</c>. /// </summary> /// <param name="precondition">A <c>Precondition</c> instance.</param> /// <param name="name">The unique name for the rule.</param> /// <param name="function">The <see cref="RuleDelegate"/> delegate function.</param> public DelegatedRule(Precondition precondition, string name, RuleDelegate function) : base(precondition, name) { this.function = function; }
/// <summary> /// Constructs a <c>DelegatedRule</c> that applies to any document. /// </summary> /// <param name="name">The unique name for the rule.</param> /// <param name="function">The <see cref="RuleDelegate"/> delegate function.</param> public DelegatedRule(string name, RuleDelegate function) : base(name) { this.function = function; }
public static Rule Delay(string name, RuleDelegate r) { return(new RecursiveRule(name, r)); }
public RecursiveRule(string name, RuleDelegate deleg) { Debug.Assert(deleg != null); mName = name; mDeleg = deleg; }
public DelayRule(RuleDelegate deleg) { Trace.Assert(deleg != null); mDeleg = deleg; }
public static Rule Delay(RuleDelegate r) { return(new DelayRule(r)); }
public static Rule Delay(string name, RuleDelegate r) { return new RecursiveRule(name, r); }
public void AddRule(RuleDelegate rule) { this.Rules.Add(rule); }
/// <summary> /// Compute the automata for this cell /// </summary> /// <param name="ruleAppliesFor">The 'neighbor skipping rule' to apply</param> public void ComputeNextState(RuleDelegate ruleAppliesFor, bool randomize) { CellState nextState; for (int x = -1; x <= 1; x++) { for (int y = -1; y <= 1; y++) { // Skip the middle cell (self) if (x == 0 && y == 0) continue; // Apply the skipping rule if (ruleAppliesFor(x, y)) continue; // Obtain this cell's neighbor at offset (x,y) from the grid Cell neighbor = grid.GetNeighborFor(this, x, y); // If any of the cell?s four ... neighbours has // the next state on from the cell nextState = state.nextState + (randomize? rand.Next(-1, 1) : 0); if (nextState == neighbor.state) { tempState = nextState; return; } } } // No rules were met; return the current state tempState = this.state; }
public virtual object ApplyRepeatedly(object t, RuleDelegate whichRule) { bool fChanged = true; while (fChanged && t != null) { t = ApplyOnce(t, whichRule); fChanged = this.originalAdaptor.IsChanged(); } // return t; }
/// <summary> /// Adds new replacement rule to the template set. /// </summary> /// <param name="templateSet">Template set</param> /// <typeparam name="T">Template set class. Should be inherited from <see cref="AbstractTemplateSet"/>.</typeparam> /// <param name="template">Expression that defines template inside the template set. For example: ts => ts.Page.</param> /// <param name="tag">String tag for which the rule will be applied to.</param> /// <param name="rule">Rule that will be executed on specified template. All occurencies of tag will be replaced by returning value of the rule.</param> public static void AddRule <T>(this T templateSet, Expression <Func <T, string> > template, string tag, RuleDelegate rule) where T : AbstractTemplateSet { templateSet.ReplacementRules.Add(new Rule(templateSet.GetTemplateName(template), tag, rule)); }