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);
}
GroupElement IBuilder <GroupElement> .Build()
{
Validate();
var childElements = new List <RuleLeftElement>();
foreach (var nestedBuilder in _nestedBuilders)
{
var builder = (IBuilder <RuleLeftElement>)nestedBuilder;
RuleLeftElement childElement = builder.Build();
childElements.Add(childElement);
}
GroupElement groupElement;
switch (_groupType)
{
case GroupType.And:
groupElement = new AndElement(Scope.VisibleDeclarations, childElements);
break;
case GroupType.Or:
groupElement = new OrElement(Scope.VisibleDeclarations, childElements);
break;
default:
throw new InvalidOperationException($"Unrecognized group type. GroupType={_groupType}");
}
return(groupElement);
}
protected override void VisitAnd(ReteBuilderContext context, AndElement element)
{
foreach (var childElement in element.ChildElements)
{
if (context.AlphaSource != null)
{
BuildJoinNode(context, childElement);
}
Visit(context, childElement);
}
}
/// <summary>
/// Creates a left-hand side group element that combines contained elements using an AND operator.
/// </summary>
/// <param name="childElements">Child elements contained in the group.</param>
/// <returns>Created element.</returns>
/// <see cref="RuleElement"/>
public static AndElement AndGroup(IEnumerable <RuleElement> childElements)
{
if (childElements == null)
{
throw new ArgumentNullException(nameof(childElements), "Child elements not provided");
}
var element = new AndElement(childElements);
ElementValidator.ValidateGroup(element);
ElementValidator.ValidateUniqueDeclarations(element.ChildElements);
return(element);
}
protected override void VisitAnd(ReteBuilderContext context, AndElement element)
{
context.BetaSource = BuildDummyNode();
foreach (var childElement in element.ChildElements)
{
Visit(context, childElement);
if (context.AlphaSource != null)
{
var betaNode = BuildJoinNode(context);
context.BetaSource = BuildBetaMemoryNode(context, betaNode);
}
}
}
/// <summary>
/// Creates a left-hand side group element that combines contained elements using an AND operator.
/// </summary>
/// <param name="childElements">Child elements contained in the group.</param>
/// <returns>Created element.</returns>
/// <see cref="RuleLeftElement"/>
public static AndElement AndGroup(IEnumerable <RuleLeftElement> childElements)
{
if (childElements == null)
{
throw new ArgumentNullException(nameof(childElements), "Child elements not provided");
}
var element = new AndElement(childElements);
if (!element.ChildElements.Any())
{
throw new InvalidOperationException("Group element AND requires at least one child element");
}
ElementValidator.ValidateUniqueDeclarations(element.ChildElements);
return(element);
}
private bool SplitOrGroup(Context context, AndElement element, IList <RuleLeftElement> childElements)
{
if (!childElements.OfType <OrElement>().Any())
{
return(false);
}
var groups = new List <IList <RuleLeftElement> >();
groups.Add(new List <RuleLeftElement>());
ExpandOrElements(groups, childElements, 0);
var andElements = groups.Select(x => new AndElement(element.Declarations, x)).ToList();
var orElement = new OrElement(element.Declarations, andElements);
Result(context, orElement);
return(true);
}
protected internal override void VisitAnd(Context context, AndElement element)
{
var childElements = element.ChildElements.Select(x => Transform <RuleLeftElement>(context, x)).ToList();
if (CollapseSingleGroup(context, childElements))
{
return;
}
if (SplitOrGroup(context, element, childElements))
{
return;
}
if (context.IsModified)
{
var newElement = new AndElement(element.Declarations, childElements);
Result(context, newElement);
}
}
private bool SplitOrGroup(Context context, AndElement element, IList <RuleElement> childElements)
{
if (!childElements.OfType <OrElement>().Any())
{
return(false);
}
var groups = new List <IList <RuleElement> >();
groups.Add(new List <RuleElement>());
ExpandOrElements(groups, childElements, 0);
var andElements = groups.Select(Element.AndGroup).ToList();
var orElement = Element.OrGroup(andElements);
Result(context, orElement);
return(true);
}
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 VisitAnd(TContext context, AndElement element)
{
VisitGroup(context, element);
}
