private LogicalQueryNode CreateLogicalQueryNodeByStrongIdentifierValue(StrongIdentifierValue value)
{
var node = new LogicalQueryNode();
var kindOfName = value.KindOfName;
switch (kindOfName)
{
case KindOfName.Concept:
node.Kind = KindOfLogicalQueryNode.Concept;
break;
case KindOfName.Entity:
node.Kind = KindOfLogicalQueryNode.Entity;
break;
case KindOfName.LogicalVar:
node.Kind = KindOfLogicalQueryNode.LogicalVar;
break;
default:
throw new UnexpectedTokenException(_currToken);
}
node.Name = value;
return(node);
}
public IList <BaseRulePart> GetIndexedRulePartOfFactsByKeyOfRelation(StrongIdentifierValue name)
{
#if DEBUG
//Log($"key = {key}");
//Log($"_entityDictionary.GetName(key) = {_entityDictionary.GetName(key)}");
//Log($"_entityDictionary = {_entityDictionary.GetDbgStr()}");
//Log($"IndexedRulePartsOfFactsDict.Count = {IndexedRulePartsOfFactsDict.Count}");
//foreach (var tmpItem in IndexedRulePartsOfFactsDict)
//{
// Log($"tmpItem.Key = {tmpItem.Key}");
// foreach(var a in tmpItem.Value)
// {
// var dbgStr = DebugHelperForRuleInstance.BaseRulePartToString(a.OriginRulePart);
// Log($"dbgStr = {dbgStr}");
// }
//}
#endif
if (IndexedRulePartsOfFactsDict.ContainsKey(name))
{
return(IndexedRulePartsOfFactsDict[name]);
}
return(null);
}
/// <inheritdoc/>
public IList <WeightedInheritanceResultItem <Channel> > GetChannelsDirectly(StrongIdentifierValue name, IList <WeightedInheritanceItem> weightedInheritanceItems)
{
lock (_lockObj)
{
#if DEBUG
//Log($"name = {name}");
#endif
if (_nonIndexedInfo.ContainsKey(name))
{
var dict = _nonIndexedInfo[name];
var result = new List <WeightedInheritanceResultItem <Channel> >();
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 <Channel>(targetVal, weightedInheritanceItem));
}
}
}
return(result);
}
return(new List <WeightedInheritanceResultItem <Channel> >());
}
}
private Value GetUsualVarValue(StrongIdentifierValue varName, LocalCodeExecutionContext localCodeExecutionContext, ResolverOptions options)
{
#if DEBUG
//Log($"varName = {varName}");
#endif
var storage = localCodeExecutionContext.Storage;
var storagesList = GetStoragesList(storage);
#if DEBUG
//Log($"storagesList.Count = {storagesList.Count}");
#endif
foreach (var storageItem in storagesList)
{
#if DEBUG
//Log($"storageItem.Key = {storageItem.Key}; storageItem.Value.Kind = '{storageItem.Value.Kind}'");
#endif
var targetValue = storageItem.Storage.VarStorage.GetValueDirectly(varName);
#if DEBUG
//Log($"targetValue = {targetValue}");
#endif
if (targetValue != null)
{
return(targetValue);
}
}
return(new NullValue());
}
public bool Equals(StrongIdentifierValue name, NumberValue value, ReasonOfFuzzyLogicResolving reason, LocalCodeExecutionContext localCodeExecutionContext, ResolverOptions options)
{
#if DEBUG
//Log($"name = {name}");
//Log($"value = {value}");
#endif
var targetItem = GetTargetFuzzyLogicNonNumericValue(name, value, reason, localCodeExecutionContext, options);
#if DEBUG
//Log($"targetItem = {targetItem}");
#endif
if (targetItem == null)
{
return(false);
}
var fuzzyValue = targetItem.Handler.SystemCall(value);
#if DEBUG
//Log($"fuzzyValue = {fuzzyValue}");
#endif
return(FuzzyNumericValueToSystemBool(fuzzyValue));
}
private void CallHost(StrongIdentifierValue methodName,
KindOfFunctionParameters kindOfParameters, Dictionary <StrongIdentifierValue, Value> namedParameters, List <Value> positionedParameters,
bool isSync)
{
#if DEBUG
//Log($"methodName = {methodName}");
//Log($"kindOfParameters = {kindOfParameters}");
//Log($"namedParameters = {namedParameters.WriteDict_1_ToString()}");
//Log($"positionedParameters = {positionedParameters.WriteListToString()}");
//Log($"isSync = {isSync}");
#endif
var command = new Command();
command.Name = methodName;
switch (kindOfParameters)
{
case KindOfFunctionParameters.NoParameters:
break;
case KindOfFunctionParameters.NamedParameters:
command.ParamsDict = namedParameters.ToDictionary(p => p.Key, p => p.Value);
break;
case KindOfFunctionParameters.PositionedParameters:
command.ParamsList = positionedParameters.ToList();
break;
default:
throw new ArgumentOutOfRangeException(nameof(kindOfParameters), kindOfParameters, null);
}
#if DEBUG
//Log($"command = {command}");
#endif
var processCreatingResult = _hostListener.CreateProcess(command);
#if DEBUG
//Log($"processCreatingResult = {processCreatingResult}");
#endif
if (processCreatingResult.IsSuccessful)
{
var processInfo = processCreatingResult.Process;
processInfo.ParentProcessInfo = _currentCodeFrame.ProcessInfo;
_instancesStorage.AppendAndTryStartProcessInfo(processInfo);
if (isSync)
{
ProcessInfoHelper.Wait(processInfo);
}
_currentCodeFrame.CurrentPosition++;
return;
}
throw new NotImplementedException();
}
private static string StrongIdentifierValueToString(StrongIdentifierValue value)
{
var sb = new StringBuilder(value.NameValue);
sb.Append(AnnotatedItemToString(value));
return(sb.ToString());
}
public NumberValue Resolve(StrongIdentifierValue name, ReasonOfFuzzyLogicResolving reason, LocalCodeExecutionContext localCodeExecutionContext, ResolverOptions options)
{
#if DEBUG
//Log($"name = {name}");
//Log($"reason = {reason}");
#endif
var targetItem = GetTargetFuzzyLogicNonNumericValue(name, null, reason, localCodeExecutionContext, options);
#if DEBUG
//Log($"targetItem = {targetItem}");
#endif
if (targetItem == null)
{
return(new NumberValue(null));
}
var fuzzyValue = targetItem.Handler.Defuzzificate();
#if DEBUG
//Log($"fuzzyValue = {fuzzyValue}");
#endif
return(fuzzyValue);
}
private void NAppendValue(FuzzyLogicNonNumericValue value, StrongIdentifierValue holder)
{
#if DEBUG
//Log($"value = {value}");
#endif
var name = value.Name;
if (_valuesDict.ContainsKey(name))
{
var dict = _valuesDict[name];
if (dict.ContainsKey(holder))
{
var targetList = dict[holder];
#if DEBUG
//Log($"dict[holder].Count = {dict[holder].Count}");
//Log($"targetList = {targetList.WriteListToString()}");
#endif
var targetLongConditionalHashCode = value.GetLongConditionalHashCode();
#if DEBUG
//Log($"targetLongConditionalHashCode = {targetLongConditionalHashCode}");
#endif
var itemsWithTheSameLongConditionalHashCodeList = targetList.Where(p => p.GetLongConditionalHashCode() == targetLongConditionalHashCode).ToList();
#if DEBUG
//Log($"itemsWithTheSameLongConditionalHashCodeList = {itemsWithTheSameLongConditionalHashCodeList.WriteListToString()}");
#endif
foreach (var itemWithTheSameLongConditionalHashCode in itemsWithTheSameLongConditionalHashCodeList)
{
targetList.Remove(itemWithTheSameLongConditionalHashCode);
}
targetList.Add(value);
}
else
{
dict[holder] = new List <FuzzyLogicNonNumericValue>()
{
value
};
}
}
else
{
var dict = new Dictionary <StrongIdentifierValue, List <FuzzyLogicNonNumericValue> >();
dict[holder] = new List <FuzzyLogicNonNumericValue>()
{
value
};
_valuesDict[name] = dict;
}
}
/// <inheritdoc/>
public IList <BaseRulePart> GetIndexedRulePartOfFactsByKeyOfRelation(StrongIdentifierValue name)
{
lock (_lockObj)
{
#if DEBUG
//LogInstance.Log($"key = {key}");
#endif
return(_commonPersistIndexedLogicalData.GetIndexedRulePartOfFactsByKeyOfRelation(name));
}
}
private WeightedInheritanceItem GetSelfWeightedInheritanceItem(StrongIdentifierValue subName)
{
var item = new WeightedInheritanceItem();
item.SuperName = subName;
item.Rank = 1F;
item.Distance = SelfDistance;
item.IsSelf = true;
return(item);
}
private WeightedInheritanceItem GetTopTypeWeightedInheritanceItem(StrongIdentifierValue subName)
{
var topTypeName = _context.CommonNamesStorage.DefaultHolder;
var item = new WeightedInheritanceItem();
item.SuperName = topTypeName;
item.Rank = 0.1F;
item.Distance = TopTypeDistance;
return(item);
}
/// <inheritdoc/>
public FuzzyLogicOperator GetDefaultOperator(StrongIdentifierValue name)
{
lock (_lockObj)
{
if (_defaultOperatorsDict.ContainsKey(name))
{
return(_defaultOperatorsDict[name]);
}
return(null);
}
}
/// <inheritdoc/>
public void SetValue(StrongIdentifierValue varName, Value value)
{
lock (_lockObj)
{
#if DEBUG
//Log($"varName = {varName}");
//Log($"value = {value}");
#endif
_variables[varName] = value;
}
}
public void NameHelper_Tests_Case_Empty()
{
var name = new StrongIdentifierValue();
Assert.AreEqual(name.IsEmpty, true);
Assert.AreEqual(name.NameValue, string.Empty);
Assert.AreEqual(name.NormalizedNameValue, string.Empty);
Assert.AreEqual(name.KindOfName, KindOfName.Unknown);
Assert.AreEqual(name.KindOfValue, KindOfValue.StrongIdentifierValue);
Assert.AreEqual(name.IsStrongIdentifierValue, true);
Assert.AreEqual(name.AsStrongIdentifierValue, name);
}
public Value GetVarValue(StrongIdentifierValue varName, LocalCodeExecutionContext localCodeExecutionContext, ResolverOptions options)
{
#if DEBUG
//Log($"varName = {varName}");
#endif
if (varName.KindOfName == KindOfName.SystemVar)
{
return(GetSystemVarValue(varName, localCodeExecutionContext, options));
}
return(GetUsualVarValue(varName, localCodeExecutionContext, options));
}
public IList <WeightedInheritanceItem> GetWeightedInheritanceItems(StrongIdentifierValue subName, LocalCodeExecutionContext localCodeExecutionContext, ResolverOptions options)
{
#if DEBUG
//Log($"localCodeExecutionContext = {localCodeExecutionContext}");
#endif
var storage = localCodeExecutionContext.Storage;
var storagesList = GetStoragesList(storage);
#if DEBUG
//Log($"storagesList.Count = {storagesList.Count}");
//foreach (var tmpStorage in storagesList)
//{
// Log($"tmpStorage.Storage = {tmpStorage.Storage}");
//}
#endif
var rawResult = new Dictionary <StrongIdentifierValue, WeightedInheritanceItem>();
if (options == null || options.SkipRealSearching == false)
{
GetWeightedInheritanceItemsBySubName(subName, localCodeExecutionContext, rawResult, 1, 0, storagesList);
}
#if DEBUG
//Log($"rawResult.Count = {rawResult.Count}");
//foreach (var resultItem in rawResult)
//{
// Log($"resultItem.Key = {resultItem.Key}");
// Log($"resultItem.Value.Rank = {resultItem.Value.Rank}");
// Log($"resultItem.Value.Distance = {resultItem.Value.Distance}");
//}
#endif
var result = rawResult.Select(p => p.Value).ToList();
if (options.AddTopType)
{
result.Add(GetTopTypeWeightedInheritanceItem(subName));
}
if (options.AddSelf)
{
result.Add(GetSelfWeightedInheritanceItem(subName));
}
return(OrderAndDistinct(result, localCodeExecutionContext, options));
}
/// <inheritdoc/>
public Value GetSystemValueDirectly(StrongIdentifierValue varName)
{
lock (_lockObj)
{
#if DEBUG
//Log($"varName = {varName}");
#endif
if (_systemVariables.ContainsKey(varName))
{
return(_systemVariables[varName]);
}
return(null);
}
}
public void LoadFromSourceCode()
{
WorldName = NameHelper.CreateName(StandardNamesConstants.WorldTypeName);
AppName = NameHelper.CreateName(StandardNamesConstants.AppTypeName);
ClassName = NameHelper.CreateName(StandardNamesConstants.ClassTypeName);
DefaultHolder = new StrongIdentifierValue();
SelfSystemVarName = NameHelper.CreateName(StandardNamesConstants.SelfSystemVarName);
HostSystemVarName = NameHelper.CreateName(StandardNamesConstants.HostSystemVarName);
SelfName = NameHelper.CreateName(_context.Id);
}
public Channel GetChannel(StrongIdentifierValue name, LocalCodeExecutionContext localCodeExecutionContext, ResolverOptions options)
{
#if DEBUG
//Log($"name = {name}");
#endif
var storage = localCodeExecutionContext.Storage;
var storagesList = GetStoragesList(storage);
#if DEBUG
//Log($"storagesList.Count = {storagesList.Count}");
//foreach (var tmpStorage in storagesList)
//{
// Log($"tmpStorage.Key = {tmpStorage.Key}; tmpStorage.Value.Kind = '{tmpStorage.Value.Kind}'");
//}
#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(name, storagesList, weightedInheritanceItems);
#if DEBUG
//Log($"rawList = {rawList.WriteListToString()}");
#endif
var filteredList = Filter(rawList);
#if DEBUG
//Log($"filteredList = {filteredList.WriteListToString()}");
#endif
var targetChannel = ChooseTargetItem(filteredList);
return(targetChannel);
}
private void StartProcessingFuzzyLogicNonNumericSequenceValue(StrongIdentifierValue value)
{
_fuzzyLogicNonNumericSequenceValue = new FuzzyLogicNonNumericSequenceValue();
var node = new LogicalQueryNode();
node.Kind = KindOfLogicalQueryNode.FuzzyLogicNonNumericSequence;
node.FuzzyLogicNonNumericSequenceValue = _fuzzyLogicNonNumericSequenceValue;
_fuzzyLogicNonNumericSequenceValue.AddIdentifier(value);
var intermediateNode = new IntermediateAstNode(node);
AstNodesLinker.SetNode(intermediateNode, _nodePoint);
_state = State.GotFuzzyLogicNonNumericSequenceItem;
}
private void ProcessConceptOrQuestionVar(StrongIdentifierValue value)
{
#if DEBUG
//Log($"value = {value}");
#endif
var node = CreateLogicalQueryNodeByStrongIdentifierValue(value);
#if DEBUG
//Log($"node = {node}");
#endif
var intermediateNode = new IntermediateAstNode(node);
AstNodesLinker.SetNode(intermediateNode, _nodePoint);
_state = State.GotConcept;
}
/// <inheritdoc/>
public void ProcessChangeInheritance(StrongIdentifierValue subName, StrongIdentifierValue superName)
{
lock (_lockObj)
{
#if DEBUG
//Log($"subName = {subName}");
//Log($"superName = {superName}");
if (subName.NameValue == "app")
{
throw new NotImplementedException();
}
//Log("Next");
#endif
if (_foundInheritanceKeysList.Any())
{
//var subNameKey = subName.GetIndexed(_context).NameKey;
//var superNameKey = superName.GetIndexed(_context).NameKey;
#if DEBUG
//Log($"subNameKey = {subNameKey}");
//Log($"superNameKey = {superNameKey}");
#endif
if (subName != _selfName && !_foundInheritanceKeysList.Contains(subName))
{
Recalculate();
return;
}
if (superName != _selfName && !_foundInheritanceKeysList.Contains(superName))
{
Recalculate();
return;
}
return;
}
Recalculate();
}
}
public InstanceInfo(StrongIdentifierValue name, IEngineContext context, IStorage parentStorage)
: base(context.Logger)
{
Name = name;
_context = context;
_localCodeExecutionContext = new LocalCodeExecutionContext();
var localStorageSettings = RealStorageSettingsHelper.Create(context, parentStorage);
_storage = new LocalStorage(localStorageSettings);
_localCodeExecutionContext.Storage = _storage;
_localCodeExecutionContext.Holder = Name;
#if DEBUG
//Log($"_localCodeExecutionContext = {_localCodeExecutionContext}");
#endif
_triggersResolver = new TriggersResolver(context);
}
public Value GetInheritanceRank(StrongIdentifierValue subName, StrongIdentifierValue superName, LocalCodeExecutionContext localCodeExecutionContext, ResolverOptions options)
{
#if DEBUG
//Log($"subName = {subName}");
//Log($"superName = {superName}");
#endif
var weightedInheritanceItemsList = GetWeightedInheritanceItems(subName, localCodeExecutionContext, options);
#if DEBUG
//Log($"weightedInheritanceItemsList = {weightedInheritanceItemsList.WriteListToString()}");
#endif
if (!weightedInheritanceItemsList.Any())
{
var result = new LogicalValue(0);
return(result);
}
var targetWeightedInheritanceItemsList = weightedInheritanceItemsList.Where(p => p.SuperName.Equals(superName)).ToList();
#if DEBUG
//Log($"targetWeightedInheritanceItemsList = {targetWeightedInheritanceItemsList.WriteListToString()}");
#endif
if (!targetWeightedInheritanceItemsList.Any())
{
var result = new LogicalValue(0);
return(result);
}
if (targetWeightedInheritanceItemsList.Count == 1)
{
var result = new LogicalValue(targetWeightedInheritanceItemsList.First().Rank);
return(result);
}
throw new NotImplementedException();
}
private void ProcessPredicate(StrongIdentifierValue name)
{
var node = new LogicalQueryNode();
_lastLogicalQueryNode = node;
node.Kind = KindOfLogicalQueryNode.Relation;
node.Name = name;
node.ParamsList = new List <LogicalQueryNode>();
var priority = OperatorsHelper.GetPriority(KindOfOperator.Predicate);
#if DEBUG
//Log($"priority = {priority}");
#endif
var intermediateNode = new IntermediateAstNode(node, KindOfIntermediateAstNode.UnaryOperator, priority);
AstNodesLinker.SetNode(intermediateNode, _nodePoint);
_state = State.WaitForPredicateParameter;
}
private void CallStrongIdentifierValue(StrongIdentifierValue methodName,
KindOfFunctionParameters kindOfParameters, Dictionary <StrongIdentifierValue, Value> namedParameters, List <Value> positionedParameters,
bool isSync)
{
#if DEBUG
//Log($"methodName = {methodName}");
//Log($"kindOfParameters = {kindOfParameters}");
//Log($"namedParameters = {namedParameters.WriteDict_1_ToString()}");
//Log($"positionedParameters = {positionedParameters.WriteListToString()}");
//Log($"isSync = {isSync}");
#endif
NamedFunction method = null;
switch (kindOfParameters)
{
case KindOfFunctionParameters.NoParameters:
method = _methodsResolver.Resolve(methodName, _currentCodeFrame.LocalContext);
break;
case KindOfFunctionParameters.NamedParameters:
method = _methodsResolver.Resolve(methodName, namedParameters, _currentCodeFrame.LocalContext);
break;
case KindOfFunctionParameters.PositionedParameters:
method = _methodsResolver.Resolve(methodName, positionedParameters, _currentCodeFrame.LocalContext);
break;
default:
throw new ArgumentOutOfRangeException(nameof(kindOfParameters), kindOfParameters, null);
}
#if DEBUG
//Log($"method = {method}");
#endif
CallExecutable(method, kindOfParameters, namedParameters, positionedParameters, isSync);
}
public NumberValue Resolve(StrongIdentifierValue name, ReasonOfFuzzyLogicResolving reason, LocalCodeExecutionContext localCodeExecutionContext)
{
return(Resolve(name, reason, localCodeExecutionContext, _defaultOptions));
}
public NumberValue Resolve(StrongIdentifierValue name, LocalCodeExecutionContext localCodeExecutionContext)
{
return(Resolve(name, null, localCodeExecutionContext, _defaultOptions));
}
private List <WeightedInheritanceResultItemWithStorageInfo <FuzzyLogicNonNumericValue> > GetRawList(StrongIdentifierValue name, List <StorageUsingOptions> storagesList, IList <WeightedInheritanceItem> weightedInheritanceItems)
{
#if DEBUG
//Log($"name = {name}");
#endif
if (!storagesList.Any())
{
return(new List <WeightedInheritanceResultItemWithStorageInfo <FuzzyLogicNonNumericValue> >());
}
var result = new List <WeightedInheritanceResultItemWithStorageInfo <FuzzyLogicNonNumericValue> >();
foreach (var storageItem in storagesList)
{
var itemsList = storageItem.Storage.FuzzyLogicStorage.GetNonNumericValuesDirectly(name, weightedInheritanceItems);
if (!itemsList.Any())
{
continue;
}
var distance = storageItem.Priority;
var storage = storageItem.Storage;
foreach (var item in itemsList)
{
result.Add(new WeightedInheritanceResultItemWithStorageInfo <FuzzyLogicNonNumericValue>(item, distance, storage));
}
}
return(result);
}
