ParserSettings.cs

Go to the documentation of this file.

// Copyright 2005-2015 Giacomo Stelluti Scala & Contributors. All rights reserved. See License.md in the project root for license information.
 
using System;
using System.Globalization;
using System.IO;
 
using CommandLine.Infrastructure;
 
using CSharpx;
 
namespace CommandLine
{
    public class ParserSettings : IDisposable
    {
        public const int DefaultMaximumLength = 80; // default console width
        private Maybe<bool> allowMultiInstance;
        private bool autoHelp;
        private bool autoVersion;
        private bool caseInsensitiveEnumValues;
        private bool caseSensitive;
 
        private bool disposed;
        private Maybe<bool> enableDashDash;
        private bool getoptMode;
        private TextWriter helpWriter;
        private bool ignoreUnknownArguments;
        private CultureInfo parsingCulture;
        private Maybe<bool> posixlyCorrect;
 
        public ParserSettings(int? maxDisplayWidth = null)
        {
            caseSensitive = true;
            caseInsensitiveEnumValues = false;
            autoHelp = true;
            autoVersion = true;
            parsingCulture = CultureInfo.InvariantCulture;
            MaximumDisplayWidth = maxDisplayWidth ?? GetWindowWidth();
            getoptMode = false;
            enableDashDash = Maybe.Nothing<bool>();
            allowMultiInstance = Maybe.Nothing<bool>();
            posixlyCorrect = Maybe.Nothing<bool>();
        }
 
        public bool CaseSensitive
        {
            get => caseSensitive;
            set => PopsicleSetter.Set(Consumed, ref caseSensitive, value);
        }
 
        public bool CaseInsensitiveEnumValues
        {
            get => caseInsensitiveEnumValues;
            set => PopsicleSetter.Set(Consumed, ref caseInsensitiveEnumValues, value);
        }
 
        public CultureInfo ParsingCulture
        {
            get => parsingCulture;
            set
            {
                if (value == null)
                {
                    throw new ArgumentNullException("value");
                }
 
                PopsicleSetter.Set(Consumed, ref parsingCulture, value);
            }
        }
 
        public TextWriter HelpWriter
        {
            get => helpWriter;
            set => PopsicleSetter.Set(Consumed, ref helpWriter, value);
        }
 
        public bool IgnoreUnknownArguments
        {
            get => ignoreUnknownArguments;
            set => PopsicleSetter.Set(Consumed, ref ignoreUnknownArguments, value);
        }
 
        public bool AutoHelp
        {
            get => autoHelp;
            set => PopsicleSetter.Set(Consumed, ref autoHelp, value);
        }
 
        public bool AutoVersion
        {
            get => autoVersion;
            set => PopsicleSetter.Set(Consumed, ref autoVersion, value);
        }
 
        public bool EnableDashDash
        {
            get => enableDashDash.MatchJust(out bool value) ? value : getoptMode;
            set => PopsicleSetter.Set(Consumed, ref enableDashDash, Maybe.Just(value));
        }
 
        public int MaximumDisplayWidth { get; set; }
 
        public bool AllowMultiInstance
        {
            get => allowMultiInstance.MatchJust(out bool value) ? value : getoptMode;
            set => PopsicleSetter.Set(Consumed, ref allowMultiInstance, Maybe.Just(value));
        }
 
        public bool GetoptMode
        {
            get => getoptMode;
            set => PopsicleSetter.Set(Consumed, ref getoptMode, value);
        }
 
        public bool PosixlyCorrect
        {
            get => posixlyCorrect.MapValueOrDefault(val => val,
                                                    () => Environment.GetEnvironmentVariable("POSIXLY_CORRECT")
                                                                     .ToBooleanLoose()
                                                   );
            set => PopsicleSetter.Set(Consumed, ref posixlyCorrect, Maybe.Just(value));
        }
 
        internal StringComparer NameComparer => CaseSensitive
                                                    ? StringComparer.Ordinal
                                                    : StringComparer.OrdinalIgnoreCase;
 
        internal bool Consumed { get; set; }
 
#region IDisposable Members
 
        public void Dispose()
        {
            Dispose(true);
 
            GC.SuppressFinalize(this);
        }
 
#endregion
 
        public static ParserSettings CreateDefault(int? maxDisplayWidth = null)
        {
            return new ParserSettings(maxDisplayWidth);
        }
 
        private int GetWindowWidth()
        {
#if !NET40
            if (Console.IsOutputRedirected)
            {
                return DefaultMaximumLength;
            }
#endif
            int width = 1;
 
            try
            {
                width = Console.WindowWidth;
 
                if (width < 1)
                {
                    width = DefaultMaximumLength;
                }
            }
            catch (Exception e) when (e is IOException ||
                                      e is PlatformNotSupportedException ||
                                      e is ArgumentOutOfRangeException)
            {
                width = DefaultMaximumLength;
            }
 
            return width;
        }
 
        ~ParserSettings()
        {
            Dispose(false);
        }
 
        private void Dispose(bool disposing)
        {
            if (disposed)
            {
                return;
            }
 
            if (disposing)
            {
                // Do not dispose HelpWriter. It is the caller's responsibility.
 
                disposed = true;
            }
        }
    }
}