IKVM.Tools.Importer.ImportOptionsBinding Class Reference

Inheritance diagram for IKVM.Tools.Importer.ImportOptionsBinding:

Public Member Functions
	ImportOptionsBinding (ImportArgLevel[] nested, ImportOptions parent)
	Initializes a new instance.

Protected Member Functions
override ImportOptions	GetBoundValue (BindingContext context)

Detailed Description

Definition at line 20 of file ImportOptionsBinding.cs.

Constructor & Destructor Documentation

ImportOptionsBinding()

IKVM.Tools.Importer.ImportOptionsBinding.ImportOptionsBinding	(	ImportArgLevel[]	nested,
		ImportOptions	parent )

Initializes a new instance.

Definition at line 32 of file ImportOptionsBinding.cs.

        {
            _levels = nested ?? throw new ArgumentNullException(nameof(nested));
            _parent = parent;
        }

Member Function Documentation

GetBoundValue()

override ImportOptions IKVM.Tools.Importer.ImportOptionsBinding.GetBoundValue ( BindingContext context )

protected

Definition at line 39 of file ImportOptionsBinding.cs.

        {
            var command = (ImportCommand)context.ParseResult.CommandResult.Command;
 
            var options = _parent?.Clone() ?? new ImportOptions();
 
            if (context.ParseResult.GetValueForArgument(command.InputsArgument) is FileInfo[] _inputs)
                options.Inputs = AppendArray(options.Inputs, _inputs);
 
            if (context.ParseResult.GetValueForOption(command.RecurseOption) is string[] _recurse)
                options.Recurse = AppendArray(options.Recurse, _recurse);
 
            if (context.ParseResult.GetValueForOption(command.AssemblyAttributesOption) is FileInfo[] _assemblyAttributes)
                options.AssemblyAttributes = AppendArray(options.AssemblyAttributes, _assemblyAttributes);
 
            if (GetParsedDictionaryValueForOption<string, FileInfo>(context, command.ResourceOption, null) is IReadOnlyDictionary<string, FileInfo> _resources)
                options.Resources = AppendDictionaries(options.Resources, _resources);
 
            if (GetParsedDictionaryValueForOption<string, FileInfo>(context, command.ExternalResourceOption, null) is IReadOnlyDictionary<string, FileInfo> _externalresources)
                options.ExternalResources = AppendDictionaries(options.ExternalResources, _externalresources);
 
            if (context.ParseResult.GetValueForOption(command.OutputOption) is FileInfo _output)
                options.Output = _output;
 
            if (context.ParseResult.GetValueForOption(command.AssemblyNameOption) is string _assemblyName)
                options.AssemblyName = _assemblyName;
 
            if (GetParsedEnumValueForOption(context, command.TargetOption, ImportTarget.Unspecified) is ImportTarget _target and not ImportTarget.Unspecified)
                options.Target = _target;
 
            if (GetParsedEnumValueForOption(context, command.PlatformOption, ImportPlatform.Unspecified) is ImportPlatform _platform and not ImportPlatform.Unspecified)
                options.Platform = _platform;
 
            if (GetParsedEnumValueForOption(context, command.ApartmentOption, ImportApartment.Unspecified) is ImportApartment _apartment and not ImportApartment.Unspecified)
                options.Apartment = _apartment;
 
            if (context.ParseResult.GetValueForOption(command.NoGlobbingOption) is true)
                options.NoGlobbing = true;
 
            if (GetParsedValueForOption<string[]?>(context, command.EnableAssertionsOption, null) is string[] _ea)
                options.EnableAssertions = _ea;
 
            if (GetParsedValueForOption<string[]?>(context, command.DisableAssertionsOption, null) is string[] _da)
                options.DisableAssertions = _da;
 
            if (GetParsedDictionaryValueForOption<string, string>(context, command.PropertiesOption, "") is IReadOnlyDictionary<string, string> _properties)
                options.Properties = AppendDictionaries(options.Properties, _properties);
 
            if (context.ParseResult.GetValueForOption(command.RemoveAssertionsOption) is true)
                options.RemoveAssertions = true;
 
            if (context.ParseResult.GetValueForOption(command.MainClassOption) is string _main)
                options.Main = _main;
 
            if (context.ParseResult.GetValueForOption(command.ReferenceOption) is string[] _references)
                options.References = AppendArray(options.References, _references);
 
            if (context.ParseResult.GetValueForOption(command.NoJNIOption) is true)
                options.NoJNI = true;
 
            if (context.ParseResult.GetValueForOption(command.ExcludeOption) is FileInfo _exclude)
                options.Exclude = _exclude;
 
            if (GetParsedValueForOption<Version?>(context, command.VersionOption, null) is Version _version)
                options.Version = _version;
 
            if (GetParsedValueForOption<Version?>(context, command.FileVersionOption, null) is Version _fileversion)
                options.FileVersion = _fileversion;
 
            if (context.ParseResult.GetValueForOption(command.Win32IconOption) is FileInfo _win32icon)
                options.Win32Icon = _win32icon;
 
            if (context.ParseResult.GetValueForOption(command.Win32ManifestOption) is FileInfo _win32manifest)
                options.Win32Manifest = _win32manifest;
 
            if (context.ParseResult.GetValueForOption(command.KeyFileOption) is FileInfo _keyfile)
                options.KeyFile = _keyfile;
 
            if (context.ParseResult.GetValueForOption(command.KeyOption) is string _keyoption)
                options.Key = _keyoption;
 
            if (context.ParseResult.GetValueForOption(command.DelaySignOption) is true)
                options.DelaySign = true;
 
            if (GetParsedEnumValueForOption(context, command.DebugOption, ImportDebug.None) is ImportDebug _debug and not ImportDebug.None)
                options.Debug = _debug;
 
            if (context.ParseResult.GetValueForOption(command.DeterministicOption) is false)
                options.Deterministic = false;
 
            if (context.ParseResult.GetValueForOption(command.OptimizeOption) is true)
                options.Optimize = true;
 
            if (context.ParseResult.GetValueForOption(command.SourcePathOption) is DirectoryInfo _sourcePath)
                options.SourcePath = _sourcePath;
 
            if (context.ParseResult.GetValueForOption(command.RemapOption) is FileInfo _remap)
                options.Remap = _remap;
 
            if (context.ParseResult.GetValueForOption(command.NoStackTraceInfoOption) is true)
                options.NoStackTraceInfo = true;
 
            if (context.ParseResult.GetValueForOption(command.RemoveUnusedPrivateFieldsOption) is true)
                options.RemoveUnusedPrivateFields = true;
 
            if (context.ParseResult.GetValueForOption(command.CompressResourcesOption) is true)
                options.CompressResources = true;
 
            if (context.ParseResult.GetValueForOption(command.StrictFinalFieldSemanticsOption) is true)
                options.StrictFinalFieldSemantics = true;
 
            if (context.ParseResult.GetValueForOption(command.PrivatePackageOption) is string[] _privatepackages)
                options.PrivatePackages = AppendArray(options.PrivatePackages, _privatepackages);
 
            if (context.ParseResult.GetValueForOption(command.PublicPackageOption) is string[] _publicpackages)
                options.PublicPackages = AppendArray(options.PublicPackages, _publicpackages);
 
            if (context.ParseResult.GetValueForOption(command.NoWarnOption) is Diagnostic[] _nowarn)
                options.NoWarn = options.NoWarn != null ? AppendArray(options.NoWarn, _nowarn) : _nowarn;
 
            if (context.ParseResult.GetValueForOption(command.WarnAsErrorOption) is Diagnostic[] _warnaserror)
                options.WarnAsError = options.WarnAsError != null ? AppendArray(options.WarnAsError, _warnaserror) : _warnaserror;
 
            if (command.RuntimeOption != null)
                if (context.ParseResult.GetValueForOption(command.RuntimeOption) is FileInfo _runtime)
                    options.Runtime = _runtime;
 
            if (context.ParseResult.GetValueForOption(command.ClassLoaderOption) is string _classloader)
                options.ClassLoader = _classloader;
 
            if (command.SharedClassLoaderOption != null)
                if (context.ParseResult.GetValueForOption(command.SharedClassLoaderOption) is true)
                    options.SharedClassLoader = true;
 
            if (context.ParseResult.GetValueForOption(command.BaseAddressOption) is string _baseaddress)
                options.BaseAddress = _baseaddress;
 
            if (context.ParseResult.GetValueForOption(command.FileAlignOption) is string _filealign)
                options.FileAlign = _filealign;
 
            if (context.ParseResult.GetValueForOption(command.NoPeerCrossReferenceOption) is true)
                options.NoPeerCrossReference = true;
 
            if (context.ParseResult.GetValueForOption(command.NoStdLibOption) is true)
                options.NoStdLib = true;
 
            if (context.ParseResult.GetValueForOption(command.LibraryOption) is DirectoryInfo[] _libs)
                options.Libraries = AppendArray(options.Libraries, _libs);
 
            if (context.ParseResult.GetValueForOption(command.NoAutoSerializationOption) is true)
                options.NoAutoSerialization = true;
 
            if (context.ParseResult.GetValueForOption(command.HighEntropyVAOption) is true)
                options.HighEntropyVA = true;
 
            if (context.ParseResult.GetValueForOption(command.ProxyOption) is string[] _proxies)
                options.Proxies = _proxies;
 
            if (context.ParseResult.GetValueForOption(command.AllowNonVirtualCallsOption) is true)
                options.AllowNonVirtualCalls = true;
 
            if (context.ParseResult.GetValueForOption(command.StaticOption) is true)
                options.Static = true;
 
            if (context.ParseResult.GetValueForOption(command.NoJarStubsOption) is true)
                options.NoJarStubs = true;
 
            if (context.ParseResult.GetValueForOption(command.WarningLevel4Option) is true)
                options.WarningLevel4Option = true;
 
            if (context.ParseResult.GetValueForOption(command.NoParameterReflectionOption) is true)
                options.NoParameterReflection = true;
 
            if (command.BootstrapOption != null)
                if (context.ParseResult.GetValueForOption(command.BootstrapOption) is true)
                    options.Bootstrap = true;
 
            if (command.LogOption != null)
                if (context.ParseResult.GetValueForOption(command.LogOption) is string _log)
                    options.Log = _log;
 
            // for each nested level, run a command to capture the options, but otherwise does nothing
            foreach (var level in _levels)
            {
                var nestedCommand = new ImportCommand(false);
                var nestedOptions = new List<ImportOptions>(level.Args.Count);
                nestedCommand.SetHandler(nestedOptions.Add, new ImportOptionsBinding(level.Nested.ToArray(), options));
                new CommandLineBuilder(nestedCommand).Build().Invoke(level.Args.ToArray());
                options.Nested = nestedOptions.ToArray();
            }
 
            return options;
        }

---

The documentation for this class was generated from the following file:

• src/IKVM.Tools.Importer/ImportOptionsBinding.cs