/// <summary> /// The method returns instances of all versions used in the rules. /// </summary> /// <returns></returns> private List <IVersionFact> GetAllVersion(IWantActionContext <WantAction, FactContainer> context) { return(new List <IVersionFact> { new Version2019(), new Version2020(), }); }
protected IEnumerable <IFact> GetPriorityFacts(IWantActionContext <WantAction, FactContainer> context) { return(new List <IFact> { new Priority1(), new Priority2(), }); }
public void Initialize() { Context = GetWantActionContext( GetWantAction((FactResult _) => { }), new FactContainer { new Priority1(), new Priority2(), }); }
public void Initialize() { Rule = GetFactRule((Priority1 p, Fact1 f) => new FactResult(f.Value + p)); NodeInfo = new NodeByFactRuleInfo <FactRule> { BuildFailedConditions = new List <IBuildConditionFact>(), Rule = Rule, BuildSuccessConditions = new List <IBuildConditionFact>(), RuntimeConditions = new List <IRuntimeConditionFact>(), }; Node = new NodeByFactRule <FactRule> { Childs = new List <NodeByFactRule <FactRule> >(), Info = NodeInfo, Parent = null, }; Context = GetWantActionContext( GetWantAction((FactResult result) => { }), new FactContainer { new Priority1(), new Priority2(), }); }
/// <inheritdoc/> public virtual bool TryGetRelatedRules <TFactRule, TWantAction, TFactContainer>(IWantActionContext <TWantAction, TFactContainer> context, out IFactRuleCollection <TFactRule> relatedRules) where TFactRule : IFactRule where TWantAction : IWantAction where TFactContainer : IFactContainer { relatedRules = null; if (_relatedRules is IFactRuleCollection <TFactRule> result) { relatedRules = result; return(true); } if (_getRelatedRulesFunc is Func <TFactRule, IFactRuleCollection <TFactRule>, IWantActionContext <TWantAction, TFactContainer>, IFactRuleCollection <TFactRule> > getRelatedRulesFunc && _rules is IFactRuleCollection <TFactRule> rules && _rule is TFactRule rule) { relatedRules = getRelatedRulesFunc(rule, rules, context); _relatedRules = relatedRules; return(true); } return(false); }
/// <inheritdoc/> /// <remarks>Additionally checks version compatibility.</remarks> public override bool CanExtractFact <TFactWork, TWantAction, TFactContainer>(IFactType factType, TFactWork factWork, IWantActionContext <TWantAction, TFactContainer> context) { if (factType.IsFactType <ISpecialFact>()) { return(base.CanExtractFact(factType, factWork, context)); } List <IFact> facts = context .Container .WhereFactsByFactType(factType, context.Cache) .ToList(); if (facts.Count == 0) { return(false); } var maxVersion = context.WantAction.InputFactTypes.GetVersionFact(context); if (maxVersion == null) { return(true); } return(facts.Exists(fact => fact.IsRelevantFactByVersioned(maxVersion))); }
/// <summary> /// Synchronize the tree level with years ready for calculation. /// </summary> /// <typeparam name="TFactRule"></typeparam> /// <typeparam name="TWantAction"></typeparam> /// <typeparam name="TFactContainer"></typeparam> /// <param name="treeLevel">Tree level.</param> /// <param name="finishedNodes">Nodes by which the rule can already be calculated. Key - node info, value - node</param> /// <param name="context">Context.</param> private void SyncTreeLevelAndFinishedNodes <TFactRule, TWantAction, TFactContainer>(List <NodeByFactRule <TFactRule> > treeLevel, Dictionary <NodeByFactRuleInfo <TFactRule>, NodeByFactRule <TFactRule> > finishedNodes, IWantActionContext <TWantAction, TFactContainer> context) where TFactRule : IFactRule where TWantAction : IWantAction where TFactContainer : IFactContainer { foreach (var finishedNode in finishedNodes) { List <NodeByFactRule <TFactRule> > parentNodes = treeLevel .Where(node => node.Info.Rule.EqualsWork(finishedNode.Key.Rule, context.WantAction, context.Container)) .Select(node => node.Parent) .Distinct() .ToList(); foreach (NodeByFactRule <TFactRule> parentNode in parentNodes) { if (parentNode == null) { continue; } for (int i = parentNode.Childs.Count - 1; i >= 0; i--) { NodeByFactRule <TFactRule> childNode = parentNode.Childs[i]; if (!childNode.Info.Rule.OutputFactType.EqualsFactType(finishedNode.Key.Rule.OutputFactType)) { continue; } parentNode.Childs.Remove(childNode); int indexNodeInTreeLevel = treeLevel.IndexOf(childNode); if (indexNodeInTreeLevel != -1) { treeLevel.RemoveAt(indexNodeInTreeLevel); } } if (parentNode == finishedNode.Value.Parent) { parentNode.Childs.Add(finishedNode.Value); } else { parentNode.Childs.Add(finishedNode.Value.Copy(parentNode)); } } } }
public override bool Condition <TFactWork, TFactRule, TWantAction, TFactContainer>(TFactWork factWork, IWantActionContext <TWantAction, TFactContainer> context, Func <IWantActionContext <TWantAction, TFactContainer>, IFactRuleCollection <TFactRule> > getCompatibleRules) { throw new NotImplementedException(); }
/// <summary> /// Compares rules based on priority facts. /// </summary> /// <typeparam name="TFactRule">Type rule.</typeparam> /// <typeparam name="TWantAction">Type wantAction.</typeparam> /// <typeparam name="TFactContainer">Type fact container.</typeparam> /// <param name="x">First rule.</param> /// <param name="y">Second rule.</param> /// <param name="context">Context.</param> /// <returns> /// 1 - <paramref name="x"/> rule is greater than the <paramref name="y"/>, /// 0 - <paramref name="x"/> rule is equal than the <paramref name="y"/>, /// -1 - <paramref name="x"/> rule is less than the <paramref name="y"/>. /// </returns> public static int CompareByPriority <TFactRule, TWantAction, TFactContainer>(this TFactRule x, TFactRule y, IWantActionContext <TWantAction, TFactContainer> context) where TFactRule : IFactRule where TWantAction : IWantAction where TFactContainer : IFactContainer { var xPriorityType = x.InputFactTypes?.SingleOrDefault(type => type.IsFactType <IPriorityFact>()); var yPriorityType = y.InputFactTypes?.SingleOrDefault(type => type.IsFactType <IPriorityFact>()); if (xPriorityType == null) { return(yPriorityType == null ? 0 : -1); } if (yPriorityType == null) { return(1); } IPriorityFact xPriority = context.Container.FirstPriorityFactByFactType(xPriorityType, context.Cache); IPriorityFact yPriority = context.Container.FirstPriorityFactByFactType(yPriorityType, context.Cache); return(xPriority.CompareTo(yPriority)); }
/// <summary> /// Compares rules based on version facts. /// </summary> /// <typeparam name="TFactRule">Type rule.</typeparam> /// <typeparam name="TWantAction">Type wantAction.</typeparam> /// <typeparam name="TFactContainer">Type fact container.</typeparam> /// <param name="x">First rule.</param> /// <param name="y">Second rule.</param> /// <param name="context">Context.</param> /// <returns> /// 1 - <paramref name="x"/> rule is greater than the <paramref name="y"/>, /// 0 - <paramref name="x"/> rule is equal than the <paramref name="y"/>, /// -1 - <paramref name="x"/> rule is less than the <paramref name="y"/>. /// </returns> public static int CompareByVersion <TFactRule, TWantAction, TFactContainer>(this TFactRule x, TFactRule y, IWantActionContext <TWantAction, TFactContainer> context) where TFactRule : IFactRule where TWantAction : IWantAction where TFactContainer : IFactContainer { var xVersionType = x.InputFactTypes?.SingleOrDefault(type => type.IsFactType <IVersionFact>()); var yVersionType = y.InputFactTypes?.SingleOrDefault(type => type.IsFactType <IVersionFact>()); if (xVersionType == null) { return(yVersionType == null ? 0 : 1); } if (yVersionType == null) { return(-1); } IVersionFact xVersion = context.Container.FirstVersionFactByFactType(xVersionType, context.Cache); IVersionFact yVersion = context.Container.FirstVersionFactByFactType(yVersionType, context.Cache); return(xVersion.CompareTo(yVersion)); }
/// <summary> /// Calculates the fact asynchronously and adds the priority fact to the parameters. /// </summary> /// <typeparam name="TFactRule">Type rule.</typeparam> /// <typeparam name="TWantAction">Type wantAction.</typeparam> /// <typeparam name="TFactContainer">Type fact container.</typeparam> /// <param name="node">Node containing information about the calculation rule.</param> /// <param name="context">Context</param> /// <returns>Fact.</returns> public override async ValueTask <IFact> CalculateFactAsync <TFactRule, TWantAction, TFactContainer>(NodeByFactRule <TFactRule> node, IWantActionContext <TWantAction, TFactContainer> context) { IPriorityFact priority = node.Info.Rule.GetPriorityFact(context); return((await base.CalculateFactAsync(node, context).ConfigureAwait(false)).AddPriorityParameter(priority)); }
/// <inheritdoc/> public override async ValueTask <IFact> CalculateFactAsync <TFactRule, TWantAction, TFactContainer>(NodeByFactRule <TFactRule> node, IWantActionContext <TWantAction, TFactContainer> context) { var fact = await base.CalculateFactAsync(node, context).ConfigureAwait(false); WriteLog(() => $"FactFactory | FactRule\n{node.Info.Rule}\nInput facts: {string.Join(", ", GetRequireFacts(node.Info.Rule, context))}\nResult: {fact}"); return(fact); }
/// <inheritdoc/> public override IFact CalculateFact <TFactRule, TWantAction, TFactContainer>(NodeByFactRule <TFactRule> node, IWantActionContext <TWantAction, TFactContainer> context) { var fact = base.CalculateFact(node, context); WriteLog(() => $"FactFactory | FactRule\n{node.Info.Rule}\nInput facts: {string.Join(", ", GetRequireFacts(node.Info.Rule, context))}\nResult: {fact}"); return(fact); }
public override bool Condition <TFactWork, TFactRule, TWantAction, TFactContainer>(TFactWork factWork, IWantActionContext <TWantAction, TFactContainer> context, Func <IWantActionContext <TWantAction, TFactContainer>, IFactRuleCollection <TFactRule> > getCompatibleRules) { return(context.Container.Contains <OtherFact>()); }
/// <inheritdoc/> protected override IEnumerable <IFact> GetDefaultFacts(IWantActionContext <WantAction, VersionedFactContainer> context) { return(_provider.GetDefaultFacts()); }
/// <inheritdoc/> /// <remarks>Additionally checks version compatibility.</remarks> public override IFactRuleCollection <TFactRule> GetCompatibleRules <TFactWork, TFactRule, TWantAction, TFactContainer>(TFactWork target, IFactRuleCollection <TFactRule> factRules, IWantActionContext <TWantAction, TFactContainer> context) { var result = base.GetCompatibleRules(target, factRules, context); var maxVersion = context.WantAction.InputFactTypes.GetVersionFact(context); if (maxVersion == null) { return(result); } return(result.FindAll(rule => rule.CompatibleRule(maxVersion, context))); }
/// <summary> /// Compares rules by priority and base attribute /// (<see cref="SingleEntityOperationsFacade.CompareFactRules{TFactRule, TWantAction, TFactContainer}(TFactRule, TFactRule, IWantActionContext{TWantAction, TFactContainer})"/>). /// </summary> /// <typeparam name="TFactRule">Type rule.</typeparam> /// <typeparam name="TWantAction">Type wantAction.</typeparam> /// <typeparam name="TFactContainer">Type fact container.</typeparam> /// <param name="x">First rule.</param> /// <param name="y">Secon role.</param> /// <param name="context">Context.</param> /// <returns> /// 1 - <paramref name="x"/> rule is greater than the <paramref name="y"/>, /// 0 - <paramref name="x"/> rule is equal than the <paramref name="y"/>, /// -1 - <paramref name="x"/> rule is less than the <paramref name="y"/>. /// </returns> public override int CompareFactRules <TFactRule, TWantAction, TFactContainer>(TFactRule x, TFactRule y, IWantActionContext <TWantAction, TFactContainer> context) { int priorityResult = x.CompareByPriority(y, context); return(priorityResult != 0 ? priorityResult : x.CompareTo(y)); }
/// <summary> /// Checks if a <typeparamref name="TFact"/> fact cannot be retrieved from a container. /// </summary> /// <inheritdoc/> public override bool Condition <TFactWork, TFactRule, TWantAction, TFactContainer>(TFactWork factWork, IWantActionContext <TWantAction, TFactContainer> context, Func <IWantActionContext <TWantAction, TFactContainer>, IFactRuleCollection <TFactRule> > getCompatibleRules) { return(!context.SingleEntity.CanExtractFact(GetFactType <TFact>(), factWork, context)); }
/// <summary> /// Calculates the fact and adds the priority fact to the parameters. /// </summary> /// <typeparam name="TFactRule">Type rule.</typeparam> /// <typeparam name="TWantAction">Type wantAction.</typeparam> /// <typeparam name="TFactContainer">Type fact container.</typeparam> /// <param name="node">Node containing information about the calculation rule.</param> /// <param name="context">Context</param> /// <returns>Fact.</returns> public override IFact CalculateFact <TFactRule, TWantAction, TFactContainer>(NodeByFactRule <TFactRule> node, IWantActionContext <TWantAction, TFactContainer> context) { IPriorityFact priority = node.Info.Rule.GetPriorityFact(context); return(base .CalculateFact(node, context) .AddPriorityParameter(priority)); }
protected override IEnumerable <IFact> GetDefaultFacts(IWantActionContext <GetcuReone.FactFactory.Entities.WantAction, Container> context) { return(DefaultFacts); }
/// <inheritdoc/> protected override IEnumerable <IFact> GetDefaultFacts(IWantActionContext <WantAction, FactContainer> context) { return(_getDefaultFactsFunc?.Invoke(context)); }
internal static IVersionFact GetVersionFact <TWantAction, TFactContainer>(this IEnumerable <IFactType> factTypes, IWantActionContext <TWantAction, TFactContainer> context) where TWantAction : IWantAction where TFactContainer : IFactContainer { IFactType versionType = factTypes.SingleOrDefault(type => type.IsFactType <IVersionFact>()); return(versionType != null ? (IVersionFact)context.Container.First(fact => context.Cache.GetFactType(fact).EqualsFactType(versionType)) : null); }
internal static IPriorityFact GetPriorityFact <TFactWork, TWantAction, TFactContainer>(this TFactWork factWork, IWantActionContext <TWantAction, TFactContainer> context) where TFactWork : IFactWork where TWantAction : IWantAction where TFactContainer : IFactContainer { var priorityType = factWork.InputFactTypes?.FirstOrDefault(type => type.IsFactType <IPriorityFact>()); return(priorityType != null ? context.Container.FirstPriorityFactByFactType(priorityType, context.Cache) : null); }
internal static bool CompatibleRule <TFactRule, TWantAction, TFactContainer>(this TFactRule factRule, IVersionFact maxVersion, IWantActionContext <TWantAction, TFactContainer> context) where TFactRule : IFactRule where TWantAction : IWantAction where TFactContainer : IFactContainer { var version = factRule.InputFactTypes.GetVersionFact(context); if (version == null) { return(false); } return(maxVersion.CompareTo(version) >= 0); }
/// <summary> /// Checks if a tree can be built for the fact. /// </summary> /// <inheritdoc/> public override bool Condition <TFactWork, TFactRule, TWantAction, TFactContainer>(TFactWork factWork, IWantActionContext <TWantAction, TFactContainer> context, Func <IWantActionContext <TWantAction, TFactContainer>, IFactRuleCollection <TFactRule> > getCompatibleRules) { return(ConditionHelper.CanDeriveFact( this, GetFactType <TFact>(), factWork, getCompatibleRules(context), context)); }
/// <inheritdoc/> /// <remarks>Additionally checks version compatibility.</remarks> public override int CompareFactRules <TFactRule, TWantAction, TFactContainer>(TFactRule x, TFactRule y, IWantActionContext <TWantAction, TFactContainer> context) { int resultByPriority = x.CompareByPriority(y, context); if (resultByPriority != 0) { return(resultByPriority); } int resultByVersion = x.CompareByVersion(y, context); if (resultByVersion != 0) { return(resultByVersion); } return(x.CompareTo(y)); }
/// <inheritdoc/> public abstract bool Condition <TFactWork, TFactRule, TWantAction, TFactContainer>(TFactWork factWork, IWantActionContext <TWantAction, TFactContainer> context, Func <IWantActionContext <TWantAction, TFactContainer>, IFactRuleCollection <TFactRule> > getCompatibleRules) where TFactWork : IFactWork where TFactRule : IFactRule where TWantAction : IWantAction where TFactContainer : IFactContainer;
internal static IFactRuleCollection <TFactRule> GetCompatibleRulesEx <TFactWork, TFactRule, TWantAction, TFactContainer>(this TFactWork target, IFactRuleCollection <TFactRule> rules, IWantActionContext <TWantAction, TFactContainer> context) where TFactWork : IFactWork where TFactRule : IFactRule where TWantAction : IWantAction where TFactContainer : IFactContainer { return(context.SingleEntity.GetCompatibleRules(target, rules, context)); }
internal static Dictionary <NodeByFactRuleInfo <TFactRule>, NodeByFactRule <TFactRule> > GetCompatibleFinishedNodes <TFactRule, TWantAction, TFactContainer>(this NodeByFactRuleInfo <TFactRule> nodeInfo, Dictionary <NodeByFactRuleInfo <TFactRule>, NodeByFactRule <TFactRule> > finishedNodes, IWantActionContext <TWantAction, TFactContainer> context) where TFactRule : IFactRule where TWantAction : IWantAction where TFactContainer : IFactContainer { return(finishedNodes .Where(finishedNode => context.SingleEntity.CompatibleRule(nodeInfo.Rule, finishedNode.Key.Rule, context)) .ToDictionary(finishedNode => finishedNode.Key, finishedNode => finishedNode.Value)); }
/// <inheritdoc/> /// <remarks>Additionally checks version compatibility.</remarks> public override bool CompatibleRule <TFactWork, TFactRule, TWantAction, TFactContainer>(TFactWork target, TFactRule rule, IWantActionContext <TWantAction, TFactContainer> context) { if (!base.CompatibleRule(target, rule, context)) { return(false); } var maxVersion = context.WantAction.InputFactTypes.GetVersionFact(context); if (maxVersion == null) { return(true); } var ruleVersion = rule.InputFactTypes.GetVersionFact(context); return(ruleVersion != null ? maxVersion.CompareTo(ruleVersion) >= 0 : false); }