ModuleDescriptor.Builder.cs

Go to the documentation of this file.

using System;
using System.Collections.Generic;
using System.Collections.Immutable;
using System.Diagnostics;
 
using IKVM.ByteCode;
 
namespace IKVM.CoreLib.Modules
{
 
    internal readonly partial struct ModuleDescriptor
    {
 
        public static Builder CreateModule(string name, ModuleFlag modifiers)
        {
            return new Builder(name, modifiers);
        }
 
        public static Builder CreateModule(string name)
        {
            return new Builder(name, false);
        }
 
        public static Builder CreateAutomaticModule(string name)
        {
            return new Builder(name, true);
        }
 
        public class Builder
        {
 
            readonly string _name;
            readonly ModuleFlag _modifiers;
            readonly bool _automatic;
            ModuleVersion _version;
            HashSet<string>? _requiresKeys;
            ImmutableHashSet<ModuleRequires>.Builder? _requires;
            HashSet<string>? _exportsKeys;
            ImmutableHashSet<ModuleExports>.Builder? _exports;
            HashSet<string>? _opensKeys;
            ImmutableHashSet<ModuleOpens>.Builder? _opens;
            ImmutableHashSet<string>.Builder? _uses;
            HashSet<string>? _providesKeys;
            ImmutableHashSet<ModuleProvides>.Builder? _provides;
            ImmutableHashSet<string>.Builder? _packages;
            string? _mainClass;
 
            internal Builder(string name, bool automatic)
            {
                _name = name;
                _modifiers = default;
                _automatic = automatic;
                _version = default;
                Debug.Assert(!IsOpen || !IsAutomatic);
            }
 
            internal Builder(string name, ModuleFlag modifiers)
            {
                _name = name;
                _modifiers = modifiers;
                _automatic = false;
                _version = default;
                Debug.Assert(!IsOpen || !IsAutomatic);
            }
 
            public string Name => _name;
 
            public ModuleFlag Modifiers => _modifiers;
 
            public bool IsAutomatic => _automatic;
 
            public bool IsOpen => (_modifiers & ModuleFlag.Open) != 0;
 
            public Builder Requires(ModuleRequires requires)
            {
                if (_automatic)
                    throw new InvalidOperationException("Automatic modules cannot declare dependences");
                if (_name.Equals(requires.Name))
                    throw new ArgumentException("Dependence on self.");
                if (_requiresKeys != null && _requiresKeys.Contains(requires.Name))
                    throw new InvalidOperationException($"Dependence upon {requires.Name} already declared.");
 
                _requiresKeys ??= new HashSet<string>();
                _requiresKeys.Add(requires.Name);
                _requires ??= ImmutableHashSet.CreateBuilder<ModuleRequires>();
                _requires.Add(requires);
 
                return this;
            }
 
            public Builder Requires(ModuleRequiresFlag modifiers, string name, ModuleVersion version)
            {
                return Requires(new ModuleRequires(modifiers, name, version));
            }
 
            public Builder Requires(ModuleRequiresFlag modifiers, string name, string? version)
            {
                var v = default(ModuleVersion);
                if (version is not null)
                    ModuleVersion.TryParse(version, out v);
 
                return Requires(new ModuleRequires(modifiers, name, v));
            }
 
            public Builder Requires(ModuleRequiresFlag modifiers, string name)
            {
                return Requires(new ModuleRequires(modifiers, name, default));
            }
 
            public Builder Requires(string name)
            {
                return Requires(new ModuleRequires(default, name, default));
            }
 
            public Builder Exports(ModuleExports exports)
            {
                if (_automatic)
                    throw new InvalidOperationException("Automatic modules cannot declare dependences.");
                if (_exportsKeys != null && _exportsKeys.Contains(exports.Source))
                    throw new InvalidOperationException($"Exported package {exports.Source} already declared.");
 
                _exportsKeys ??= new HashSet<string>();
                _exportsKeys.Add(exports.Source);
                _exports ??= ImmutableHashSet.CreateBuilder<ModuleExports>();
                _exports.Add(exports);
 
                return this;
            }
 
            public Builder Exports(ModuleExportsFlag modifiers, string name, ImmutableHashSet<string> targets)
            {
                return Exports(new ModuleExports(modifiers, name, targets));
            }
 
            public Builder Exports(ModuleExportsFlag modifiers, string name)
            {
                return Exports(modifiers, name, []);
            }
 
            public Builder Exports(string name, ImmutableHashSet<string> targets)
            {
                return Exports(default, name, targets);
            }
 
            public Builder Exports(string name)
            {
                return Exports(default, name, []);
            }
 
            public Builder Opens(ModuleOpens opens)
            {
                if (IsOpen || IsAutomatic)
                    throw new InvalidOperationException("Open or automatic modules cannot declare open packages.");
                if (_opensKeys != null && _opensKeys.Contains(opens.Source))
                    throw new InvalidOperationException($"Open package {opens.Source} already declared.");
 
                _opensKeys ??= new HashSet<string>();
                _opensKeys.Add(opens.Source);
                _opens ??= ImmutableHashSet.CreateBuilder<ModuleOpens>();
                _opens.Add(opens);
                _packages ??= ImmutableHashSet.CreateBuilder<string>();
                _packages.Add(opens.Source);
 
                return this;
            }
 
            public Builder Opens(ModuleOpensFlag modifiers, string packageName, ImmutableHashSet<string> targets)
            {
                return Opens(new ModuleOpens(modifiers, packageName, targets));
            }
 
            public Builder Opens(ModuleOpensFlag modifiers, string packageName)
            {
                return Opens(modifiers, packageName, []);
            }
 
            public Builder Opens(string packageName, ImmutableHashSet<string> targets)
            {
                return Opens(default, packageName, targets);
            }
 
            public Builder Opens(string packageName)
            {
                return Opens(default, packageName, []);
            }
 
            public Builder Uses(string service)
            {
                if (service is null)
                    throw new ArgumentNullException(nameof(service));
 
                if (_automatic)
                    throw new InvalidOperationException("Automatic modules cannot declare service dependencies.");
                if (_uses != null && _uses.Contains(service))
                    throw new InvalidOperationException($"Dependence upon service {service} already declared.");
 
                _uses ??= ImmutableHashSet.CreateBuilder<string>();
                _uses.Add(service);
 
                return this;
            }
 
            public Builder Provides(ModuleProvides provides)
            {
                if (_providesKeys != null && _providesKeys.Contains(provides.Service))
                    throw new InvalidOperationException($"Providers of service {provides.Service} already declared.");
 
                _providesKeys ??= new HashSet<string>();
                _providesKeys.Add(provides.Service);
                _provides ??= ImmutableHashSet.CreateBuilder<ModuleProvides>();
                _provides.Add(provides);
 
                _packages ??= ImmutableHashSet.CreateBuilder<string>();
                foreach (var p in provides.Providers)
                    _packages.Add(GetPackageName(p));
 
                return this;
            }
 
            public Builder Provides(string service, ImmutableArray<string> providers)
            {
                return Provides(new ModuleProvides(service, providers));
            }
 
            string GetPackageName(string cn)
            {
                if (cn is null)
                    throw new ArgumentNullException(nameof(cn));
 
                int index = cn.LastIndexOf('.');
                return (index == -1) ? "" : cn[..index];
            }
 
            public Builder Package(string name)
            {
                if (name is null)
                    throw new ArgumentNullException(nameof(name));
 
                _packages ??= ImmutableHashSet.CreateBuilder<string>();
                _packages.Add(name);
                return this;
            }
 
            public Builder Version(ModuleVersion version)
            {
                _version = version;
                return this;
            }
 
            public Builder Version(string value)
            {
                if (value is not null && ModuleVersion.TryParse(value.AsSpan(), out _version))
                    return this;
 
                _version = default;
                return this;
            }
 
            public Builder MainClass(string mainClass)
            {
                var packageName = GetPackageName(mainClass);
                if (string.IsNullOrEmpty(packageName))
                    throw new ArgumentException($"{mainClass}: unnamed package", nameof(mainClass));
 
                _packages ??= ImmutableHashSet.CreateBuilder<string>();
                _packages.Add(packageName);
                _mainClass = mainClass;
 
                return this;
            }
 
            public ModuleDescriptor Build()
            {
                return new ModuleDescriptor(
                    _name,
                    _version,
                    IsAutomatic,
                    _modifiers,
                    _requires?.ToImmutable() ?? [],
                    _exports?.ToImmutable() ?? [],
                    _opens?.ToImmutable() ?? [],
                    _uses?.ToImmutable() ?? [],
                    _provides?.ToImmutable() ?? [],
                    _packages?.ToImmutable() ?? [],
                    _mainClass);
            }
 
        }
 
    }
 
}