RuntimeUtil.cs

Go to the documentation of this file.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.InteropServices;
using System.Text.Json;
 
namespace IKVM.Runtime
{
 
    public static class RuntimeUtil
    {
 
        static JsonElement? runtimeJsonElement;
        static string runtimeIdentifier;
 
        public static bool IsMono { get; } = Type.GetType("Mono.Runtime") != null;
 
        public static bool IsWindows { get; } = RuntimeInformation.IsOSPlatform(OSPlatform.Windows);
 
        public static bool IsLinux { get; } = RuntimeInformation.IsOSPlatform(OSPlatform.Linux);
 
        public static bool IsOSX { get; } = RuntimeInformation.IsOSPlatform(OSPlatform.OSX);
 
        public static string RuntimeIdentifier => runtimeIdentifier ??= GetRuntimeIdentifier();
 
        static string GetRuntimeIdentifier()
        {
            // allow overrides with environment
            if (Environment.GetEnvironmentVariable("DOTNET_RUNTIME_ID") is string rid1 && string.IsNullOrWhiteSpace(rid1) == false)
                if (RuntimeJson.TryGetProperty(rid1, out _))
                    return rid1;
 
#if NETCOREAPP
            if (RuntimeInformation.RuntimeIdentifier is string rid2 && string.IsNullOrWhiteSpace(rid2) == false)
                if (RuntimeJson.TryGetProperty(rid2, out _))
                    return rid2;
#endif
 
            return GetFallbackRuntimeIdentifier();
        }
 
        static string GetFallbackRuntimeIdentifier()
        {
            var arch = RuntimeInformation.ProcessArchitecture switch
            {
                Architecture.X86 => "x86",
                Architecture.X64 => "x64",
                Architecture.Arm => "arm",
                Architecture.Arm64 => "arm64",
                _ => null,
            };
 
            if (IsWindows)
                return $"win-{arch}";
 
            if (IsLinux)
                return $"linux-{arch}";
 
            if (IsOSX)
                return $"osx-{arch}";
 
            return null;
        }
 
        static JsonElement RuntimeJson => runtimeJsonElement ??= GetRuntimeJson();
 
        static JsonElement GetRuntimeJson()
        {
            using var stream = typeof(RuntimeUtil).Assembly.GetManifestResourceStream("runtime.json");
            var g = JsonDocument.Parse(stream);
            return g.RootElement.GetProperty("runtimes");
        }
 
        public static IEnumerable<string> SupportedRuntimeIdentifiers => GetSupportedRuntimeIdentifiers();
 
        static IEnumerable<string> GetSupportedRuntimeIdentifiers()
        {
            return GetRuntimeIdentifierIterator(RuntimeIdentifier).Distinct();
        }
 
        static IEnumerable<string> GetRuntimeIdentifierIterator(string rid)
        {
            if (RuntimeJson.TryGetProperty(rid, out var node) == false)
                yield break;
 
            // initiate a breadth first search across runtime.json from specified RID
            var v = new HashSet<string>();
            var q = new Queue<(string, JsonElement)>();
            v.Add(rid);
            q.Enqueue((rid, node));
 
            // continue until end is reached
            while (q.Count > 0)
            {
                // dequeue next item and yield
                var (thisRid, thisNode) = q.Dequeue();
                yield return thisRid;
 
                // enqueue referenced rids
                if (thisNode.TryGetProperty("#import", out var import))
                    foreach (var imports in import.EnumerateArray())
                        if (imports.GetString() is string nextRid && string.IsNullOrWhiteSpace(nextRid) == false)
                            if (v.Add(nextRid))
                                if (RuntimeJson.TryGetProperty(nextRid, out var nextNode))
                                    q.Enqueue((nextRid, nextNode));
            }
        }
 
    }
 
}