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); }