public static void ValidateForAll(ForAllElement element) { if (!element.Patterns.Any()) { throw new InvalidOperationException("At least one FORALL pattern must be specified"); } }
protected internal virtual void VisitForAll(TContext context, ForAllElement element) { element.BasePattern.Accept(context, this); foreach (PatternElement pattern in element.Patterns) { pattern.Accept(context, this); } }
/// <summary> /// Creates an element that represents a universal quantifier. /// Facts that match the <c>basePattern</c> must also match all other <c>patterns</c>. /// </summary> /// <param name="basePattern">Base patterns of the universal quantifier that defines the universe of facts to consider.</param> /// <param name="patterns">Additional patterns of the universal quantifier that the fact matched by the base pattern must also satisfy.</param> /// <returns>Created element.</returns> public static ForAllElement ForAll(PatternElement basePattern, IEnumerable <PatternElement> patterns) { if (basePattern == null) { throw new ArgumentNullException(nameof(basePattern), "Base pattern not provided"); } if (patterns == null) { throw new ArgumentNullException(nameof(patterns), "Patterns not provided"); } var element = new ForAllElement(basePattern, patterns); ElementValidator.ValidateForAll(element); return(element); }
protected internal override void VisitForAll(Context context, ForAllElement element) { var basePattern = Transform <PatternElement>(context, element.BasePattern); var patterns = element.Patterns.Select(x => Transform <PatternElement>(context, x)).ToList(); //forall -> not(base and not(patterns)) var symbolTable = new SymbolTable(element.Declarations); var notBuilder = new NotBuilder(symbolTable); var groupBuilder = notBuilder.Group(GroupType.And); Declaration declaration = basePattern.Declaration; var basePatternBuilder = groupBuilder.Pattern(declaration); foreach (var condition in basePattern.Conditions) { basePatternBuilder.Condition(condition.Expression); } var baseParameter = basePatternBuilder.Declaration.ToParameterExpression(); foreach (var pattern in patterns) { var patternBuilder = groupBuilder .Not() .Pattern(pattern.Declaration); var parameter = patternBuilder.Declaration.ToParameterExpression(); //Join is required to correlate negated patterns with the base pattern patternBuilder.Condition( Expression.Lambda( Expression.ReferenceEqual(baseParameter, parameter), baseParameter, parameter)); foreach (var condition in pattern.Conditions) { patternBuilder.Condition(condition.Expression); } } IBuilder <NotElement> builder = notBuilder; Result(context, builder.Build()); }
/// <summary> /// Creates an element that represents a universal quantifier. /// Facts that match the <c>basePattern</c> must also match all other <c>patterns</c>. /// </summary> /// <param name="basePattern">Base patterns of the universal quantifier that defines the universe of facts to consider.</param> /// <param name="patterns">Additional patterns of the universal quantifier that the fact matched by the base pattern must also satisfy.</param> /// <returns>Created element.</returns> public static ForAllElement ForAll(PatternElement basePattern, IEnumerable <PatternElement> patterns) { if (basePattern == null) { throw new ArgumentNullException(nameof(basePattern), "Base pattern not provided"); } if (patterns == null) { throw new ArgumentNullException(nameof(patterns), "Patterns not provided"); } var forAllElement = new ForAllElement(basePattern, patterns); if (!forAllElement.Patterns.Any()) { throw new InvalidOperationException("At least one FORALL pattern must be specified"); } return(forAllElement); }
protected internal override void VisitForAll(Context context, ForAllElement element) { var basePattern = Transform <PatternElement>(context, element.BasePattern); var patterns = element.Patterns.Select(x => Transform <PatternElement>(context, x)).ToList(); //forall -> not(base and not(patterns)) Declaration baseDeclaration = basePattern.Declaration; var baseParameter = baseDeclaration.ToParameterExpression(); var negatedPatterns = new List <RuleElement>(); foreach (var pattern in patterns) { var parameter = pattern.Declaration.ToParameterExpression(); var expressions = new List <NamedExpressionElement> { Element.Condition( Expression.Lambda( Expression.ReferenceEqual(baseParameter, parameter), baseParameter, parameter)) }; expressions.AddRange(pattern.Expressions); negatedPatterns.Add( Element.Not( Element.Pattern(pattern.Declaration, expressions, pattern.Source) )); } var result = Element.Not( Element.AndGroup( new RuleElement[] { basePattern }.Concat(negatedPatterns))); Result(context, result); }
protected override void VisitForAll(ReteBuilderContext context, ForAllElement element) { throw new InvalidOperationException("ForAll element must be normalized"); }
/// <summary> /// Adds a forall element to the group element. /// </summary> /// <param name="element">Element to add.</param> public void ForAll(ForAllElement element) { var builder = BuilderAdapter.Create(element); _nestedBuilders.Add(builder); }