BadVersion.cs

Go to the documentation of this file.

using BadScript2.Runtime;
using BadScript2.Runtime.Error;
using BadScript2.Runtime.Interop.Functions;
using BadScript2.Runtime.Objects;
using BadScript2.Runtime.Objects.Native;
using BadScript2.Runtime.Objects.Types;
 
namespace BadScript2.Interop.Common.Versioning;
 
public class BadVersion : BadObject, IBadNative
{
    public static readonly BadClassPrototype
        Prototype = new BadNativeClassPrototype<BadVersion>("Version", VersionCtor);
 
    private static readonly BadClassPrototype s_Prototype;
 
    private readonly BadObjectReference m_ChangeVersion;
 
    private readonly Version m_Version;
 
    static BadVersion()
    {
        s_Prototype = new BadNativeClassPrototype<BadVersion>("Version", VersionCtor);
    }
 
    public BadVersion(Version version)
    {
        m_Version = version;
 
        m_ChangeVersion = BadObjectReference.Make("Version.ChangeVersion",
                                                  (p) => new BadDynamicInteropFunction<string>("ChangeVersion",
                                                       (_, s) => new BadVersion(m_Version.ChangeVersion(s)),
                                                       s_Prototype
                                                      )
                                                 );
    }
 
#region IBadNative Members
 
    public bool Equals(IBadNative other)
    {
        return other is BadVersion v && m_Version.Equals(v.m_Version);
    }
 
    public object Value => m_Version;
 
    public Type Type => typeof(Version);
 
#endregion
 
 
    public override bool HasProperty(string propName, BadScope? caller = null)
    {
        return propName is "Major" or "Minor" or "Build" or "Revision" ||
               base.HasProperty(propName, caller);
    }
 
    public override BadObjectReference GetProperty(string propName, BadScope? caller = null)
    {
        return propName switch
        {
            "Major"         => BadObjectReference.Make("Version.Major", (p) => m_Version.Major),
            "Minor"         => BadObjectReference.Make("Version.Minor", (p) => m_Version.Minor),
            "Build"         => BadObjectReference.Make("Version.Build", (p) => m_Version.Build),
            "Revision"      => BadObjectReference.Make("Version.Revision", (p) => m_Version.Revision),
            "ChangeVersion" => m_ChangeVersion,
            _               => base.GetProperty(propName, caller),
        };
    }
 
    public override BadClassPrototype GetPrototype()
    {
        return s_Prototype;
    }
 
    private static BadObject VersionCtor(BadExecutionContext ctx, BadObject[] args)
    {
        switch (args.Length)
        {
            case 0:
                return new BadVersion(new Version());
            case 1:
                return args[0] is IBadString str
                           ? new BadVersion(new Version(str.Value))
                           : throw BadRuntimeException.Create(ctx.Scope,
                                                              "Version Constructor expects string as argument"
                                                             );
            case >= 2:
            {
                if (args[0] is not IBadNumber major)
                {
                    throw BadRuntimeException.Create(ctx.Scope, "Expected major version to be a number");
                }
 
                if (args[1] is not IBadNumber minor)
                {
                    throw BadRuntimeException.Create(ctx.Scope, "Expected minor version to be a number");
                }
 
                if (args.Length == 2)
                {
                    return new BadVersion(new Version((int)major.Value, (int)minor.Value));
                }
 
                if (args[2] is not IBadNumber build)
                {
                    throw BadRuntimeException.Create(ctx.Scope, "Expected build version to be a number");
                }
 
                if (args.Length == 3)
                {
                    return new BadVersion(new Version((int)major.Value, (int)minor.Value, (int)build.Value));
                }
 
                if (args[3] is not IBadNumber revision)
                {
                    throw BadRuntimeException.Create(ctx.Scope, "Expected revision version to be a number");
                }
 
                if (args.Length == 4)
                {
                    return new BadVersion(new Version((int)major.Value,
                                                      (int)minor.Value,
                                                      (int)build.Value,
                                                      (int)revision.Value
                                                     )
                                         );
                }
 
                break;
            }
        }
 
        throw BadRuntimeException.Create(ctx.Scope, "Invalid Argument Count for Version Constructor");
    }
 
    public override string ToSafeString(List<BadObject> done)
    {
        return m_Version.ToString();
    }
}