ModuleConfiguration.cs

Go to the documentation of this file.

using System;
using System.Collections.Generic;
using System.Collections.Immutable;
using System.Linq;
 
using IKVM.CoreLib.Collections;
 
namespace IKVM.CoreLib.Modules
{
 
    internal class ModuleConfiguration
    {
 
        public static ModuleConfiguration Resolve(IModuleFinder before, ImmutableArray<ModuleConfiguration> parents, IModuleFinder after, ImmutableArray<string> roots)
        {
            if (before is null)
                throw new ArgumentNullException(nameof(before));
            if (after is null)
                throw new ArgumentNullException(nameof(after));
 
            var resolver = new ModuleResolver(before, parents, after);
            resolver.Resolve(roots);
            return new ModuleConfiguration(parents, resolver);
        }
 
        readonly ImmutableArray<ModuleConfiguration> _parents;
        readonly ImmutableDictionary<ResolvedModule, ImmutableHashSet<ResolvedModule>> _graph;
        readonly ImmutableHashSet<ResolvedModule> _modules;
        readonly ImmutableDictionary<string, ResolvedModule> _nameToModule;
        readonly string? _targetPlatform;
 
        ImmutableArray<ModuleConfiguration> _all;
 
        public ModuleConfiguration(ImmutableArray<ModuleConfiguration> parents, ModuleResolver resolver)
        {
            var graph = resolver.Finish(this);
 
            var nameEntries = new KeyValuePair<string, ResolvedModule>[graph.Count];
            var moduleArray = new ResolvedModule[graph.Count];
 
            int i = 0;
            foreach (var resolvedModule in graph.Keys)
            {
                moduleArray[i] = resolvedModule;
                nameEntries[i] = new KeyValuePair<string, ResolvedModule>(resolvedModule.Name, resolvedModule);
                i++;
            }
 
            _parents = parents;
            _graph = graph;
            _modules = moduleArray.ToImmutableHashSet();
            _nameToModule = nameEntries.ToImmutableDictionary();
            _targetPlatform = resolver.TargetPlatform;
        }
 
        public ImmutableArray<ModuleConfiguration> Parents => _parents;
 
        public ImmutableHashSet<ResolvedModule> Modules => _modules;
 
        public string? TargetPlatform => _targetPlatform;
 
        public ModuleConfiguration Resolve(IModuleFinder before, IModuleFinder after, ImmutableArray<string> roots)
        {
            if (before is null)
                throw new ArgumentNullException(nameof(before));
            if (after is null)
                throw new ArgumentNullException(nameof(after));
 
            return Resolve(before, [this], after, roots);
        }
 
        public ResolvedModule? FindModule(string name)
        {
            if (name is null)
                throw new ArgumentNullException(nameof(name));
 
            if (_nameToModule.TryGetValue(name, out var r))
                return r;
 
            if (Parents.IsEmpty == false)
            {
                var all = All();
                for (int i = 1; i < all.Length; i++)
                    if (all[i]._nameToModule.TryGetValue(name, out var r2))
                        return r2;
            }
 
            return null;
        }
 
        internal ImmutableHashSet<ResolvedModule> GetReads(ResolvedModule module)
        {
            return _graph.TryGetValue(module, out var result) ? result : [];
        }
 
        internal ImmutableArray<ModuleConfiguration> All()
        {
            if (_all.IsDefault)
                _all = CalculateAll();
 
            return _all;
        }
 
        ImmutableArray<ModuleConfiguration> CalculateAll()
        {
            var all = ImmutableArray.CreateBuilder<ModuleConfiguration>(1);
 
            var v = new HashSet<ModuleConfiguration>();
            var s = new ArrayDeque<ModuleConfiguration>();
            v.Add(this);
            s.InsertFirst(this);
 
            while (s.IsEmpty == false)
            {
                var layer = s.RemoveFirst();
                all.Add(layer);
 
                // push in reverse order
                for (int i = layer._parents.Length - 1; i >= 0; i--)
                {
                    var parent = layer._parents[i];
                    if (v.Add(parent))
                        s.InsertFirst(parent);
                }
            }
 
            return all.DrainToImmutable();
        }
 
        public override string? ToString()
        {
            return string.Join(", ", _modules.Select(i => i.Name));
        }
 
    }
 
}