private bool MergeOrGroups(Context context, OrElement element, IList <RuleLeftElement> childElements)
{
if (!childElements.OfType <OrElement>().Any())
{
return(false);
}
var newChildElements = new List <RuleLeftElement>();
foreach (var childElement in childElements)
{
var childOrElement = childElement as OrElement;
if (childOrElement != null)
{
newChildElements.AddRange(childOrElement.ChildElements);
}
else
{
newChildElements.Add(childElement);
}
}
var orElement = new OrElement(element.Declarations, newChildElements);
Result(context, orElement);
return(true);
}
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);
}
/// <summary>
/// Creates a left-hand side group element that combines contained elements using an OR operator.
/// </summary>
/// <param name="childElements">Child elements contained in the group.</param>
/// <returns>Created element.</returns>
/// <see cref="RuleElement"/>
public static OrElement OrGroup(IEnumerable <RuleElement> childElements)
{
if (childElements == null)
{
throw new ArgumentNullException(nameof(childElements), "Child elements not provided");
}
var element = new OrElement(childElements);
ElementValidator.ValidateGroup(element);
return(element);
}
protected internal override void VisitOr(Context context, OrElement element)
{
var childElements = element.ChildElements.Select(x => Transform <RuleLeftElement>(context, x)).ToList();
if (CollapseSingleGroup(context, childElements))
{
return;
}
if (context.IsModified)
{
var newElement = new OrElement(element.Declarations, childElements);
Result(context, newElement);
}
}
/// <summary>
/// Creates a left-hand side group element that combines contained elements using an OR operator.
/// </summary>
/// <param name="childElements">Child elements contained in the group.</param>
/// <returns>Created element.</returns>
/// <see cref="RuleLeftElement"/>
public static OrElement OrGroup(IEnumerable <RuleLeftElement> childElements)
{
if (childElements == null)
{
throw new ArgumentNullException(nameof(childElements), "Child elements not provided");
}
var element = new OrElement(childElements);
if (!element.ChildElements.Any())
{
throw new InvalidOperationException("Group element AND requires at least one child element");
}
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 VisitOr(Context context, OrElement element)
{
var childElements = element.ChildElements.Select(x => Transform <RuleElement>(context, x)).ToList();
if (CollapseSingleGroup(context, childElements))
{
return;
}
if (MergeOrGroups(context, element, childElements))
{
return;
}
if (context.IsModified)
{
var newElement = Element.OrGroup(childElements);
Result(context, newElement);
}
}
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;
}
}
private bool MergeOrGroups(Context context, OrElement element, IList <RuleElement> childElements)
{
if (!childElements.OfType <OrElement>().Any())
{
return(false);
}
var newChildElements = new List <RuleElement>();
foreach (var childElement in childElements)
{
if (childElement is OrElement childOrElement)
{
newChildElements.AddRange(childOrElement.ChildElements);
}
else
{
newChildElements.Add(childElement);
}
}
var orElement = Element.OrGroup(newChildElements);
Result(context, orElement);
return(true);
}
protected internal virtual void VisitOr(TContext context, OrElement element)
{
VisitGroup(context, element);
}
protected override void VisitOr(ReteBuilderContext context, OrElement element)
{
throw new InvalidOperationException("Group Or element must be normalized");
}
protected override void VisitOr(ReteBuilderContext context, OrElement element)
{
throw new NotSupportedException("Group Or conditions are not supported");
}
