RuntimeContext.cs

Go to the documentation of this file.

using System;
using System.Collections.Concurrent;
 
using IKVM.CoreLib.Diagnostics;
using IKVM.CoreLib.Symbols;
 
 
 
#if IMPORTER
using IKVM.Tools.Importer;
#endif
 
#if EXPORTER
using IKVM.Tools.Exporter;
#endif
 
#if IMPORTER == false
using IKVM.Runtime.StubGen;
#endif
 
namespace IKVM.Runtime
{
 
    class RuntimeContext
    {
 
        readonly RuntimeContextOptions options;
        readonly IDiagnosticHandler diagnostics;
        readonly ISymbolResolver resolver;
        readonly bool bootstrap;
        readonly ConcurrentDictionary<Type, object> singletons = new();
 
        Types types;
        CoreClasses javaBase;
        AttributeHelper attributeHelper;
        RuntimeClassLoaderFactory classLoaderFactory;
        RuntimeAssemblyClassLoaderFactory assemblyClassLoaderFactory;
        RuntimeManagedJavaTypeFactory managedJavaTypeFactory;
        RuntimeManagedByteCodeJavaTypeFactory managedByteCodeJavaTypeFactory;
        RuntimePrimitiveJavaTypeFactory primitiveJavaTypeFactory;
        RuntimeVerifierJavaTypeFactory verifierJavaTypeFactory;
 
#if IMPORTER == false && EXPORTER == false
        ExceptionHelper exceptionHelper;
#endif
 
#if IMPORTER == false
        StubGenerator stubGenerator;
#endif
 
#if EXPORTER == false
        CodeEmitterFactory codeEmitterFactory;
        DynamicClassLoaderFactory dynamicClassLoaderFactory;
        ByteCodeHelperMethods byteCodeHelperMethods;
        Serialization serialization;
        InterlockedMethods interlockedMethods;
        CompilerFactory compilerFactory;
        MethodAnalyzerFactory methodAnalyzerFactory;
        MethodHandleUtil methodHandleUtil;
        Boxer boxer;
#endif
 
#if IMPORTER
        ProxyGenerator proxyGenerator;
#endif
 
#if IMPORTER || EXPORTER
        StaticCompiler staticCompiler;
        FakeTypes fakeTypes;
#endif
 
#if IMPORTER || EXPORTER
 
        public RuntimeContext(RuntimeContextOptions options, IDiagnosticHandler diagnostics, ISymbolResolver resolver, bool bootstrap, StaticCompiler staticCompiler)
        {
            this.options = options ?? throw new ArgumentNullException(nameof(options));
            this.diagnostics = diagnostics ?? throw new ArgumentNullException(nameof(diagnostics));
            this.resolver = resolver ?? throw new ArgumentNullException(nameof(resolver));
            this.bootstrap = bootstrap;
            this.staticCompiler = staticCompiler;
        }
 
#else
 
        public RuntimeContext(RuntimeContextOptions options, IDiagnosticHandler diagnostics, ISymbolResolver resolver, bool bootstrap)
        {
            this.options = options ?? throw new ArgumentNullException(nameof(options));
            this.diagnostics = diagnostics ?? throw new ArgumentNullException(nameof(diagnostics));
            this.resolver = resolver ?? throw new ArgumentNullException(nameof(resolver));
            this.bootstrap = bootstrap;
        }
 
#endif
 
        public IDiagnosticHandler Diagnostics => diagnostics;
 
        T GetOrCreateSingleton<T>(ref T value, Func<T> create)
        {
            if (value == null)
                lock (this)
                    value ??= create();
 
            return value;
        }
 
        public T GetOrCreateSingleton<T>(Func<T> create) => (T)singletons.GetOrAdd(typeof(T), _ => create());
 
        public RuntimeContextOptions Options => options;
 
        public ISymbolResolver Resolver => resolver;
 
        public bool Bootstrap => bootstrap;
 
        public Types Types => GetOrCreateSingleton(ref types, () => new Types(this));
 
        public CoreClasses JavaBase => GetOrCreateSingleton(ref javaBase, () => new CoreClasses(this));
 
        public AttributeHelper AttributeHelper => GetOrCreateSingleton(ref attributeHelper, () => new AttributeHelper(this));
 
        public RuntimePrimitiveJavaTypeFactory PrimitiveJavaTypeFactory => GetOrCreateSingleton(ref primitiveJavaTypeFactory, () => new RuntimePrimitiveJavaTypeFactory(this));
 
        public RuntimeVerifierJavaTypeFactory VerifierJavaTypeFactory => GetOrCreateSingleton(ref verifierJavaTypeFactory, () => new RuntimeVerifierJavaTypeFactory(this));
 
#if IMPORTER == false
 
        public StubGenerator StubGenerator => GetOrCreateSingleton(ref stubGenerator, () => new StubGenerator(this));
 
#endif
 
#if EXPORTER == false
 
        public CodeEmitterFactory CodeEmitterFactory => GetOrCreateSingleton(ref codeEmitterFactory, () => new CodeEmitterFactory(this));
 
        public DynamicClassLoaderFactory DynamicClassLoaderFactory => GetOrCreateSingleton(ref dynamicClassLoaderFactory, () => new DynamicClassLoaderFactory(this));
 
        public ByteCodeHelperMethods ByteCodeHelperMethods => GetOrCreateSingleton(ref byteCodeHelperMethods, () => new ByteCodeHelperMethods(this));
 
        public Serialization Serialization => GetOrCreateSingleton(ref serialization, () => new Serialization(this));
 
        public CompilerFactory CompilerFactory => GetOrCreateSingleton(ref compilerFactory, () => new CompilerFactory(this, bootstrap));
 
        public InterlockedMethods InterlockedMethods => GetOrCreateSingleton(ref interlockedMethods, () => new InterlockedMethods(this));
 
        public MethodAnalyzerFactory MethodAnalyzerFactory => GetOrCreateSingleton(ref methodAnalyzerFactory, () => new MethodAnalyzerFactory(this));
 
        public MethodHandleUtil MethodHandleUtil => GetOrCreateSingleton(ref methodHandleUtil, () => new MethodHandleUtil(this));
 
        public Boxer Boxer => GetOrCreateSingleton(ref boxer, () => new Boxer(this));
 
#endif
 
#if IMPORTER == false && EXPORTER == false
 
        public ExceptionHelper ExceptionHelper => GetOrCreateSingleton(ref exceptionHelper, () => new ExceptionHelper(this));
 
#endif
 
        public RuntimeClassLoaderFactory ClassLoaderFactory => GetOrCreateSingleton(ref classLoaderFactory, () => new RuntimeClassLoaderFactory(this));
 
        public RuntimeAssemblyClassLoaderFactory AssemblyClassLoaderFactory => GetOrCreateSingleton(ref assemblyClassLoaderFactory, () => new RuntimeAssemblyClassLoaderFactory(this));
 
        public RuntimeManagedJavaTypeFactory ManagedJavaTypeFactory => GetOrCreateSingleton(ref managedJavaTypeFactory, () => new RuntimeManagedJavaTypeFactory(this));
 
        public RuntimeManagedByteCodeJavaTypeFactory ManagedByteCodeJavaTypeFactory => GetOrCreateSingleton(ref managedByteCodeJavaTypeFactory, () => new RuntimeManagedByteCodeJavaTypeFactory(this));
 
#if IMPORTER || EXPORTER
 
        public StaticCompiler StaticCompiler => staticCompiler;
 
        public FakeTypes FakeTypes => GetOrCreateSingleton(ref fakeTypes, () => new FakeTypes(this));
 
#endif
 
#if IMPORTER
 
        public ProxyGenerator ProxyGenerator => GetOrCreateSingleton(ref proxyGenerator, () => new ProxyGenerator(this));
 
#endif
 
    }
 
}