示例#1
0
        /// <inheritdoc/>
        public override int CompareTo(IVersionFact other)
        {
            switch (other)
            {
            case VersionBase <int> version:
                return(VersionValue.CompareTo(version.VersionValue));

            case VersionBase <long> version:
                return(VersionValue.CompareTo(version.VersionValue));

            case VersionBase <uint> version:
                return(VersionValue.CompareTo(version.VersionValue));

            case VersionBase <ulong> version:
                return(VersionValue.CompareTo(version.VersionValue));

            case FactBase <int> version:
                return(VersionValue.CompareTo(version.Value));

            case FactBase <long> version:
                return(VersionValue.CompareTo(version.Value));

            case FactBase <uint> version:
                return(VersionValue.CompareTo(version.Value));

            case FactBase <ulong> version:
                return(VersionValue.CompareTo(version.Value));

            default:
                throw CreateIncompatibilityVersionException(other);
            }
        }
示例#2
0
        /// <summary>
        /// Checks the value of the version of the <paramref name="fact"/>.
        /// </summary>
        /// <typeparam name="TFact">Type fact.</typeparam>
        /// <param name="fact">Fact.</param>
        /// <param name="version">Version fact.</param>
        /// <returns>Does the version match the fact of the <paramref name="version"/>?</returns>
        public static bool HasVersionParameter <TFact>(this TFact fact, IVersionFact version)
            where TFact : IFact
        {
            var factVersion = fact.FindVersionParameter();

            if (version == null)
            {
                return(factVersion == null);
            }
            if (factVersion == null)
            {
                return(false);
            }

            return(version.CompareTo(factVersion) == 0);
        }
        /// <inheritdoc/>
        public override int CompareTo(IVersionFact other)
        {
            switch (other)
            {
            case MajorMinorPatchVersionBase version:
                return(_version.CompareTo(version._version));

            case FactBase <string> version:
                string pattern = @"^(\*|\d+(\.\d+){0,2}(\.\*)?)$";
                if (!Regex.IsMatch(version.Value, pattern))
                {
                    throw new ArgumentException($"{version} version doesn't match regular expression <{pattern}>.");
                }
                return(_version.CompareTo(new Version(version.Value)));

            default:
                throw CreateIncompatibilityVersionException(other);
            }
        }
示例#4
0
        /// <summary>
        /// Checks if a fact contains a valid version.
        /// </summary>
        /// <typeparam name="TFact">Type fact.</typeparam>
        /// <param name="fact">Fact.</param>
        /// <param name="maxVersion">Max version (optional).</param>
        /// <returns>Whether the version of the fact is within the valid versions?</returns>
        public static bool IsRelevantFactByVersioned <TFact>(this TFact fact, IVersionFact maxVersion)
            where TFact : IFact
        {
            if (maxVersion == null || !fact.IsCalculatedByRule())
            {
                return(true);
            }

            var value = fact.GetParameter(VersionedFactParametersCodes.Version)?.Value;

            if (value == null)
            {
                return(false);
            }
            if (value is IVersionFact factVersion)
            {
                return(maxVersion.CompareTo(factVersion) >= 0);
            }

            return(false);
        }
示例#5
0
        /// <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));
        }
示例#6
0
 public static TFact SetVersionParam <TFact>(this TFact fact, IVersionFact version)
     where TFact : IFact
 {
     fact.AddParameter(new FactParameter(VersionedFactParametersCodes.Version, version));
     return(fact);
 }
示例#7
0
 /// <summary>
 /// Adds a version fact to parameters.
 /// </summary>
 /// <param name="fact">Fact.</param>
 /// <param name="version">Verion fact.</param>
 /// <returns><paramref name="fact"/>.</returns>
 public static IFact AddVerionParameter(this IFact fact, IVersionFact version)
 {
     fact.AddParameter(new FactParameter(VersionedFactParametersCodes.Version, version));
     return(fact);
 }
        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);
        }
示例#9
0
 /// <summary>
 /// Compares the version fact to the <paramref name="other"/>.
 /// </summary>
 /// <param name="other">Version fact for comparison</param>
 /// <returns>1 - more, 0 - equal, -1 less.</returns>
 public abstract int CompareTo(IVersionFact other);
示例#10
0
 /// <summary>
 /// Error creating version incompatibility.
 /// </summary>
 /// <param name="versionedFact"></param>
 /// <returns></returns>
 protected virtual FactFactoryException CreateIncompatibilityVersionException(IVersionFact versionedFact)
 {
     return(CommonHelper.CreateException(ErrorCode.InvalidFactType, $"Unable to compare versions {GetFactType().FactName} and {versionedFact.GetFactType().FactName}."));
 }