GroupElement IBuilder <GroupElement> .Build()
{
Validate();
var childElements = new List <RuleLeftElement>();
foreach (var nestedBuilder in _nestedBuilders)
{
RuleLeftElement childElement = nestedBuilder.Build();
childElements.Add(childElement);
}
GroupElement groupElement;
switch (_groupType)
{
case GroupType.And:
groupElement = new AndElement(childElements);
break;
case GroupType.Or:
groupElement = new OrElement(childElements);
break;
case GroupType.Not:
groupElement = new NotElement(childElements);
break;
case GroupType.Exists:
groupElement = new ExistsElement(childElements);
break;
default:
throw new InvalidOperationException(string.Format("Unrecognized group type. GroupType={0}", _groupType));
}
return(groupElement);
}
protected internal override void VisitNot(Context context, NotElement element)
{
var source = Transform <RuleLeftElement>(context, element.Source);
if (context.IsModified)
{
var newElement = new NotElement(element.Declarations, source);
Result(context, newElement);
}
}
protected internal override void VisitNot(Context context, NotElement element)
{
var source = Transform <RuleElement>(context, element.Source);
if (context.IsModified)
{
var newElement = Element.Not(source);
Result(context, newElement);
}
}
/// <summary>
/// Creates an element that represents a negative existential quantifier.
/// </summary>
/// <param name="source">Source element to apply the negative existential quantifier to.</param>
/// <returns>Created element.</returns>
public static NotElement Not(RuleLeftElement source)
{
if (source == null)
{
throw new ArgumentNullException(nameof(source), "Source element not provided");
}
var element = new NotElement(source);
return(element);
}
protected override void VisitNot(ReteBuilderContext context, NotElement element)
{
BuildSubnet(context, element.ChildElements.Single());
var betaNode = new NotNode(context.BetaSource, context.AlphaSource);
if (context.HasSubnet)
{
betaNode.Conditions.Add(new SubnetCondition());
}
context.BetaSource = BuildBetaMemoryNode(context, betaNode);
context.ResetAlphaSource();
}
public static void ValidateNot(NotElement element)
{
switch (element.Source.ElementType)
{
case ElementType.Pattern:
case ElementType.And:
case ElementType.Or:
break;
default:
throw new ArgumentException($"Invalid source element. ElementType={element.Source.ElementType}");
}
}
private static void setUserControl(SerializableUserControl control, Form1 form1)
{
switch (control.type)
{
case "LogicScheme.SignalBoxes.SignalBoxTrue":
((MyUserControl)form1.userControls[0]).Output.Checked = control.Output;
break;
case "LogicScheme.SignalBoxes.SignalBoxFalse":
((MyUserControl)form1.userControls[1]).Output.Checked = control.Output;
break;
case "LogicScheme.AndElement":
var and = new AndElement();
recoverFields(form1, and, control);
break;
case "LogicScheme.NandElement":
var nand = new NandElement();
recoverFields(form1, nand, control);
break;
case "LogicScheme.OrElement":
var or = new OrElement();
recoverFields(form1, or, control);
break;
case "LogicScheme.NorElement":
var nor = new NorElement();
recoverFields(form1, nor, control);
break;
case "LogicScheme.XorElement":
var xor = new XorElement();
recoverFields(form1, xor, control);
break;
case "LogicScheme.NotElement":
var not = new NotElement();
recoverFields(form1, not, control);
break;
}
}
protected internal virtual void VisitNot(TContext context, NotElement element)
{
element.Source.Accept(context, this);
}
protected override void VisitNot(ReteBuilderContext context, NotElement element)
{
VisitSource(context, element, element.Source);
BuildNotNode(context, element);
}
protected internal virtual void VisitNot(TContext context, NotElement element)
{
VisitGroup(context, element);
}
/// <summary>
/// Adds a negative existential element to the group element.
/// </summary>
/// <param name="element">Element to add.</param>
public void Not(NotElement element)
{
var builder = BuilderAdapter.Create(element);
_nestedBuilders.Add(builder);
}
