public Operator GetOperator(KindOfOperator kindOfOperator, LocalCodeExecutionContext localCodeExecutionContext, ResolverOptions options)
{
#if DEBUG
//Log($"kindOfOperator = {kindOfOperator}");
#endif
var storage = localCodeExecutionContext.Storage;
var storagesList = GetStoragesList(storage);
#if DEBUG
//Log($"storagesList.Count = {storagesList.Count}");
//foreach(var tmpStorage in storagesList)
//{
// Log($"tmpStorage = {tmpStorage}");
//}
#endif
var inheritanceResolver = _context.DataResolversFactory.GetInheritanceResolver();
var optionsForInheritanceResolver = options.Clone();
optionsForInheritanceResolver.AddSelf = true;
var weightedInheritanceItems = inheritanceResolver.GetWeightedInheritanceItems(localCodeExecutionContext, optionsForInheritanceResolver);
#if DEBUG
//Log($"weightedInheritanceItems = {weightedInheritanceItems.WriteListToString()}");
#endif
var rawList = GetRawList(kindOfOperator, storagesList, weightedInheritanceItems);
#if DEBUG
//Log($"rawList = {rawList.WriteListToString()}");
#endif
var filteredList = Filter(rawList);
#if DEBUG
//Log($"filteredList = {filteredList.WriteListToString()}");
#endif
var targetOp = ChooseTargetItem(filteredList);
return(targetOp);
}
public static string GetSymbol(KindOfOperator kind)
{
switch (kind)
{
case KindOfOperator.Assign:
return("=");
case KindOfOperator.LeftRightStream:
return(">>");
case KindOfOperator.And:
return("AND");
case KindOfOperator.Is:
return("IS");
case KindOfOperator.IsNot:
return("IS NOT");
case KindOfOperator.Point:
return(".");
case KindOfOperator.CallFunction:
return("()");
case KindOfOperator.CallLogicalQuery:
return("CALL");
case KindOfOperator.More:
return(">");
case KindOfOperator.MoreOrEqual:
return(">=");
case KindOfOperator.Less:
return("<");
case KindOfOperator.LessOrEqual:
return("<=");
default:
throw new ArgumentOutOfRangeException(nameof(kind), kind, null);
}
}
//I use operator precedence of C and C++. https://en.wikipedia.org/wiki/Operators_in_C_and_C%2B%2B
public static int GetPriority(KindOfOperator kind)
{
switch (kind)
{
case KindOfOperator.Assign:
return(17);
case KindOfOperator.LeftRightStream:
return(16);
case KindOfOperator.And:
return(14);
case KindOfOperator.Or:
return(15);
case KindOfOperator.Not:
return(3);
case KindOfOperator.Is:
return(10);
case KindOfOperator.IsNot:
return(10);
case KindOfOperator.More:
case KindOfOperator.MoreOrEqual:
case KindOfOperator.Less:
case KindOfOperator.LessOrEqual:
return(9);
case KindOfOperator.Point:
return(2);
case KindOfOperator.CallFunction:
case KindOfOperator.Predicate:
case KindOfOperator.CallLogicalQuery:
return(2);
default:
throw new ArgumentOutOfRangeException(nameof(kind), kind, null);
}
}
private void ProcessUsualBinaryOperator(KindOfOperator kindOfOperator)
{
_lastIsOperator = null;
var node = new BinaryOperatorAstExpression();
node.KindOfOperator = kindOfOperator;
var priority = OperatorsHelper.GetPriority(kindOfOperator);
#if DEBUG
//Log($"priority = {priority}");
#endif
var intermediateNode = new IntermediateAstNode(node, KindOfIntermediateAstNode.BinaryOperator, priority);
AstNodesLinker.SetNode(intermediateNode, _nodePoint);
_state = State.Init;
}
/// <inheritdoc/>
public IList <WeightedInheritanceResultItem <Operator> > GetOperatorsDirectly(KindOfOperator kindOfOperator, IList <WeightedInheritanceItem> weightedInheritanceItems)
{
#if DEBUG
//Log($"kindOfOperator = {kindOfOperator}");
#endif
lock (_lockObj)
{
if (_nonIndexedInfo.ContainsKey(kindOfOperator))
{
var dict = _nonIndexedInfo[kindOfOperator];
var result = new List <WeightedInheritanceResultItem <Operator> >();
foreach (var weightedInheritanceItem in weightedInheritanceItems)
{
var targetHolder = weightedInheritanceItem.SuperName;
if (dict.ContainsKey(targetHolder))
{
var targetList = dict[targetHolder];
foreach (var targetVal in targetList)
{
result.Add(new WeightedInheritanceResultItem <Operator>(targetVal, weightedInheritanceItem));
}
}
}
return(result);
}
return(new List <WeightedInheritanceResultItem <Operator> >());
}
}
private List <WeightedInheritanceResultItemWithStorageInfo <Operator> > GetRawList(KindOfOperator kindOfOperator, List <StorageUsingOptions> storagesList, IList <WeightedInheritanceItem> weightedInheritanceItems)
{
#if DEBUG
//Log($"kindOfOperator = {kindOfOperator}");
#endif
if (!storagesList.Any())
{
return(new List <WeightedInheritanceResultItemWithStorageInfo <Operator> >());
}
var result = new List <WeightedInheritanceResultItemWithStorageInfo <Operator> >();
foreach (var storageItem in storagesList)
{
var operatorsList = storageItem.Storage.OperatorsStorage.GetOperatorsDirectly(kindOfOperator, weightedInheritanceItems);
if (!operatorsList.Any())
{
continue;
}
var distance = storageItem.Priority;
var storage = storageItem.Storage;
foreach (var op in operatorsList)
{
result.Add(new WeightedInheritanceResultItemWithStorageInfo <Operator>(op, distance, storage));
}
}
return(result);
}
/// <inheritdoc/>
protected override ulong CalculateLongHashCode()
{
#if DEBUG
//_gbcLogger.Info($"this = {DebugHelperForRuleInstance.ToString(this)}");
#endif
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:
return(base.CalculateLongHashCode() ^ LongHashCodeWeights.BaseOperatorWeight ^ (ulong)Math.Abs(KindOfOperator.GetHashCode()) ^ Left.GetLongHashCode() ^ Right.GetLongHashCode());
default:
throw new ArgumentOutOfRangeException(nameof(KindOfOperator), KindOfOperator, null);
}
case KindOfLogicalQueryNode.UnaryOperator:
switch (KindOfOperator)
{
case KindOfOperatorOfLogicalQueryNode.Not:
return(base.CalculateLongHashCode() ^ LongHashCodeWeights.BaseOperatorWeight ^ (ulong)Math.Abs(KindOfOperator.GetHashCode()) ^ Left.GetLongHashCode());
default:
throw new ArgumentOutOfRangeException(nameof(KindOfOperator), KindOfOperator, null);
}
case KindOfLogicalQueryNode.Concept:
case KindOfLogicalQueryNode.Entity:
case KindOfLogicalQueryNode.QuestionVar:
case KindOfLogicalQueryNode.LogicalVar:
return(base.CalculateLongHashCode() ^ Name.GetLongHashCode());
case KindOfLogicalQueryNode.Value:
return(base.CalculateLongHashCode() ^ Value.GetLongHashCode());
case KindOfLogicalQueryNode.FuzzyLogicNonNumericSequence:
return(base.CalculateLongHashCode() ^ FuzzyLogicNonNumericSequenceValue.GetLongHashCode());
case KindOfLogicalQueryNode.StubParam:
return(LongHashCodeWeights.StubWeight ^ base.CalculateLongHashCode());
case KindOfLogicalQueryNode.EntityCondition:
case KindOfLogicalQueryNode.EntityRef:
break;
case KindOfLogicalQueryNode.Relation:
{
var result = base.CalculateLongHashCode() ^ LongHashCodeWeights.BaseFunctionWeight ^ Name.GetLongHashCode();
foreach (var param in ParamsList)
{
result ^= LongHashCodeWeights.BaseParamWeight ^ param.GetLongHashCode();
}
return(result);
}
case KindOfLogicalQueryNode.Group:
return(base.CalculateLongHashCode() ^ LongHashCodeWeights.GroupWeight ^ Left.GetLongHashCode());
default:
throw new ArgumentOutOfRangeException(nameof(Kind), Kind, null);
}
throw new NotImplementedException();
}
/// <inheritdoc/>
protected override ulong CalculateLongHashCode()
{
var result = base.CalculateLongHashCode() ^ LongHashCodeWeights.BaseOperatorWeight ^ (ulong)Math.Abs(KindOfOperator.GetHashCode());
return(result);
}
