/// <summary>
/// Clones the instance using special context and returns cloned instance.
/// </summary>
/// <param name="context">Special context for providing references continuity.</param>
/// <returns>Cloned instance.</returns>
public CodeEntity Clone(Dictionary <object, object> context)
{
if (context.ContainsKey(this))
{
return((CodeEntity)context[this]);
}
var result = new CodeEntity();
context[this] = result;
result.Kind = Kind;
result.Name = Name?.Clone(context);
result.InheritanceItems = InheritanceItems?.Select(p => p.Clone(context)).ToList();
result.RuleInstance = RuleInstance?.Clone(context);
result.InlineTrigger = InlineTrigger?.Clone(context);
result.Operator = Operator?.Clone(context);
result.Channel = Channel?.Clone(context);
result.LinguisticVariable = LinguisticVariable?.Clone(context);
result.NamedFunction = NamedFunction?.Clone(context);
result.CodeFile = CodeFile;
result.ParentCodeEntity = ParentCodeEntity;
result.SubItems = SubItems?.Select(p => p.Clone(context)).ToList();
result.AppendAnnotations(this, context);
return(result);
}
/// <inheritdoc/>
public override void DiscoverAllAnnotations(IList <RuleInstance> result)
{
base.DiscoverAllAnnotations(result);
Name?.DiscoverAllAnnotations(result);
if (!InheritanceItems.IsNullOrEmpty())
{
foreach (var item in InheritanceItems)
{
item.DiscoverAllAnnotations(result);
}
}
RuleInstance?.DiscoverAllAnnotations(result);
InlineTrigger?.DiscoverAllAnnotations(result);
Operator?.DiscoverAllAnnotations(result);
Channel?.DiscoverAllAnnotations(result);
NamedFunction?.DiscoverAllAnnotations(result);
if (!SubItems.IsNullOrEmpty())
{
foreach (var item in SubItems)
{
item.DiscoverAllAnnotations(result);
}
}
}
public void PrepareDirty(RuleInstance ruleInstance)
{
var contextOfConvertingExpressionNode = new ContextOfConvertingExpressionNode();
Expression.PrepareDirty(contextOfConvertingExpressionNode, ruleInstance, this);
HasQuestionVars = contextOfConvertingExpressionNode.HasQuestionVars;
HasVars = contextOfConvertingExpressionNode.HasVars;
#if DEBUG
//_gbcLogger.Info($"HasVars = {HasVars}");
#endif
RelationsDict = contextOfConvertingExpressionNode.RelationsList.GroupBy(p => p.Name).ToDictionary(p => p.Key, p => (IList <LogicalQueryNode>)p.ToList());
}
private void PrepareDirty()
{
if (Name == null || Name.IsEmpty)
{
Name = NameHelper.CreateRuleOrFactName();
}
if (Kind == KindOfRuleInstance.Undefined)
{
if (SecondaryParts.IsNullOrEmpty())
{
Kind = KindOfRuleInstance.Fact;
}
else
{
Kind = KindOfRuleInstance.Rule;
}
}
if (IsSource)
{
Normalized = ConvertorToNormalized.Convert(this);
Normalized.PrepareDirty();
#if DEBUG
//_gbcLogger.Info($"Normalized = {DebugHelperForRuleInstance.ToString(Normalized)}");
#endif
}
else
{
CalculateUsedKeys();
PrimaryPart?.PrepareDirty(this);
if (!SecondaryParts.IsNullOrEmpty())
{
foreach (var item in SecondaryParts)
{
item.PrepareDirty(this);
}
}
Normalized = this;
}
_commonPersistIndexedLogicalData.NSetIndexedRuleInstanceToIndexData(Normalized);
}
/// <summary>
/// Clones the instance using special context and returns cloned instance.
/// </summary>
/// <param name="context">Special context for providing references continuity.</param>
/// <returns>Cloned instance.</returns>
public RuleInstance Clone(Dictionary <object, object> context)
{
if (context.ContainsKey(this))
{
return((RuleInstance)context[this]);
}
var result = new RuleInstance();
context[this] = result;
result.IsSource = IsSource;
result.Name = Name.Clone(context);
result.Kind = Kind;
result.PrimaryPart = PrimaryPart.Clone(context);
result.SecondaryParts = SecondaryParts?.Select(p => p.Clone(context)).ToList();
UsedKeysList = UsedKeysList.ToList();
result.AppendAnnotations(this, context);
return(result);
}
/// <inheritdoc/> void ILogicalStorage.Remove(RuleInstance ruleInstance) => throw new NotImplementedException();
/// <inheritdoc/> void ILogicalStorage.Append(RuleInstance ruleInstance, bool isPrimary) => throw new NotImplementedException();
//public bool HasQuestionVars
//{
// get
// {
// if(IsQuestion)
// {
// return true;
// }
// if(Left != null && Left.HasQuestionVars)
// {
// return true;
// }
// if(Right != null && Right.HasQuestionVars)
// {
// return true;
// }
// if (ParamsList != null && ParamsList.Any(p => p.HasQuestionVars))
// {
// return true;
// }
// return false;
// }
//}
public void PrepareDirty(ContextOfConvertingExpressionNode contextOfConvertingExpressionNode, RuleInstance ruleInstance, BaseRulePart rulePart)
{
#if DEBUG
//_gbcLogger.Info($"this = {this}");
//_gbcLogger.Info($"contextOfConvertingExpressionNode = {contextOfConvertingExpressionNode}");
#endif
RuleInstance = ruleInstance;
RulePart = rulePart;
switch (Kind)
{
case KindOfLogicalQueryNode.BinaryOperator:
switch (KindOfOperator)
{
case KindOfOperatorOfLogicalQueryNode.And:
case KindOfOperatorOfLogicalQueryNode.Or:
case KindOfOperatorOfLogicalQueryNode.Is:
case KindOfOperatorOfLogicalQueryNode.IsNot:
case KindOfOperatorOfLogicalQueryNode.More:
case KindOfOperatorOfLogicalQueryNode.MoreOrEqual:
case KindOfOperatorOfLogicalQueryNode.Less:
case KindOfOperatorOfLogicalQueryNode.LessOrEqual:
Left.PrepareDirty(contextOfConvertingExpressionNode, ruleInstance, rulePart);
Right.PrepareDirty(contextOfConvertingExpressionNode, ruleInstance, rulePart);
break;
default:
throw new ArgumentOutOfRangeException(nameof(KindOfOperator), KindOfOperator, null);
}
break;
case KindOfLogicalQueryNode.UnaryOperator:
switch (KindOfOperator)
{
case KindOfOperatorOfLogicalQueryNode.Not:
Left.PrepareDirty(contextOfConvertingExpressionNode, ruleInstance, rulePart);
break;
default:
throw new ArgumentOutOfRangeException(nameof(KindOfOperator), KindOfOperator, null);
}
break;
case KindOfLogicalQueryNode.Concept:
case KindOfLogicalQueryNode.Entity:
case KindOfLogicalQueryNode.QuestionVar:
Name.CheckDirty();
break;
case KindOfLogicalQueryNode.LogicalVar:
contextOfConvertingExpressionNode.HasVars = true;
Name.CheckDirty();
break;
case KindOfLogicalQueryNode.Value:
case KindOfLogicalQueryNode.StubParam:
case KindOfLogicalQueryNode.EntityCondition:
case KindOfLogicalQueryNode.EntityRef:
break;
case KindOfLogicalQueryNode.FuzzyLogicNonNumericSequence:
FuzzyLogicNonNumericSequenceValue.CheckDirty();
break;
case KindOfLogicalQueryNode.Relation:
Name.CheckDirty();
if (Name.KindOfName == KindOfName.LogicalVar)
{
IsQuestion = true;
}
FillRelationParams(ParamsList, contextOfConvertingExpressionNode);
break;
case KindOfLogicalQueryNode.Group:
Left.PrepareDirty(contextOfConvertingExpressionNode, ruleInstance, rulePart);
break;
default:
throw new ArgumentOutOfRangeException(nameof(Kind), Kind, null);
}
#if DEBUG
//_gbcLogger.Info($"contextOfConvertingExpressionNode (after) = {contextOfConvertingExpressionNode}");
#endif
}
public RuleInstanceValue(RuleInstance ruleInstance)
{
RuleInstance = ruleInstance;
}
public ErrorValue(RuleInstance ruleInstance)
{
RuleInstance = ruleInstance;
}
