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