Error.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.Collections.Generic;
using System.Linq;
 
namespace CommandLine
{
    public enum ErrorType
    {
        BadFormatTokenError,
 
        MissingValueOptionError,
 
        UnknownOptionError,
 
        MissingRequiredOptionError,
 
        MutuallyExclusiveSetError,
 
        BadFormatConversionError,
 
        SequenceOutOfRangeError,
 
        RepeatedOptionError,
 
        NoVerbSelectedError,
 
        BadVerbSelectedError,
 
        HelpRequestedError,
 
        HelpVerbRequestedError,
 
        VersionRequestedError,
 
        SetValueExceptionError,
 
        InvalidAttributeConfigurationError,
 
        MissingGroupOptionError,
 
        GroupOptionAmbiguityError,
 
        MultipleDefaultVerbsError,
    }
 
    public abstract class Error : IEquatable<Error>
    {
        protected internal Error(ErrorType tag, bool stopsProcessing)
        {
            Tag = tag;
            StopsProcessing = stopsProcessing;
        }
 
        protected internal Error(ErrorType tag)
            : this(tag, false) { }
 
        public ErrorType Tag { get; }
 
        public bool StopsProcessing { get; }
 
#region IEquatable<Error> Members
 
        public bool Equals(Error other)
        {
            if (other == null)
            {
                return false;
            }
 
            return Tag.Equals(other.Tag);
        }
 
#endregion
 
        public override bool Equals(object obj)
        {
            Error other = obj as Error;
 
            if (other != null)
            {
                return Equals(other);
            }
 
            return base.Equals(obj);
        }
 
        public override int GetHashCode()
        {
            return new { Tag, StopsProcessing }.GetHashCode();
        }
    }
 
    public abstract class TokenError : Error, IEquatable<TokenError>
    {
        protected internal TokenError(ErrorType tag, string token)
            : base(tag)
        {
            if (token == null)
            {
                throw new ArgumentNullException("token");
            }
 
            Token = token;
        }
 
        public string Token { get; }
 
#region IEquatable<TokenError> Members
 
        public bool Equals(TokenError other)
        {
            if (other == null)
            {
                return false;
            }
 
            return Tag.Equals(other.Tag) && Token.Equals(other.Token);
        }
 
#endregion
 
        public override bool Equals(object obj)
        {
            TokenError other = obj as TokenError;
 
            if (other != null)
            {
                return Equals(other);
            }
 
            return base.Equals(obj);
        }
 
        public override int GetHashCode()
        {
            return new { Tag, StopsProcessing, Token }.GetHashCode();
        }
    }
 
    public sealed class BadFormatTokenError : TokenError
    {
        internal BadFormatTokenError(string token)
            : base(ErrorType.BadFormatTokenError, token) { }
    }
 
    public abstract class NamedError : Error, IEquatable<NamedError>
    {
        protected internal NamedError(ErrorType tag, NameInfo nameInfo)
            : base(tag)
        {
            NameInfo = nameInfo;
        }
 
        public NameInfo NameInfo { get; }
 
#region IEquatable<NamedError> Members
 
        public bool Equals(NamedError other)
        {
            if (other == null)
            {
                return false;
            }
 
            return Tag.Equals(other.Tag) && NameInfo.Equals(other.NameInfo);
        }
 
#endregion
 
        public override bool Equals(object obj)
        {
            NamedError other = obj as NamedError;
 
            if (other != null)
            {
                return Equals(other);
            }
 
            return base.Equals(obj);
        }
 
        public override int GetHashCode()
        {
            return new { Tag, StopsProcessing, NameInfo }.GetHashCode();
        }
    }
 
    public sealed class MissingValueOptionError : NamedError
    {
        internal MissingValueOptionError(NameInfo nameInfo)
            : base(ErrorType.MissingValueOptionError, nameInfo) { }
    }
 
    public sealed class UnknownOptionError : TokenError
    {
        internal UnknownOptionError(string token)
            : base(ErrorType.UnknownOptionError, token) { }
    }
 
    public sealed class MissingRequiredOptionError : NamedError
    {
        internal MissingRequiredOptionError(NameInfo nameInfo)
            : base(ErrorType.MissingRequiredOptionError, nameInfo) { }
    }
 
    public sealed class MutuallyExclusiveSetError : NamedError
    {
        internal MutuallyExclusiveSetError(NameInfo nameInfo, string setName)
            : base(ErrorType.MutuallyExclusiveSetError, nameInfo)
        {
            SetName = setName;
        }
 
        public string SetName { get; }
    }
 
    public sealed class BadFormatConversionError : NamedError
    {
        internal BadFormatConversionError(NameInfo nameInfo)
            : base(ErrorType.BadFormatConversionError, nameInfo) { }
    }
 
    public sealed class SequenceOutOfRangeError : NamedError
    {
        internal SequenceOutOfRangeError(NameInfo nameInfo)
            : base(ErrorType.SequenceOutOfRangeError, nameInfo) { }
    }
 
    public sealed class RepeatedOptionError : NamedError
    {
        internal RepeatedOptionError(NameInfo nameInfo)
            : base(ErrorType.RepeatedOptionError, nameInfo) { }
    }
 
    public sealed class BadVerbSelectedError : TokenError
    {
        internal BadVerbSelectedError(string token)
            : base(ErrorType.BadVerbSelectedError, token) { }
    }
 
    public sealed class HelpRequestedError : Error
    {
        internal HelpRequestedError()
            : base(ErrorType.HelpRequestedError, true) { }
    }
 
    public sealed class HelpVerbRequestedError : Error
    {
        internal HelpVerbRequestedError(string verb, Type type, bool matched)
            : base(ErrorType.HelpVerbRequestedError, true)
        {
            Verb = verb;
            Type = type;
            Matched = matched;
        }
 
        public string Verb { get; }
 
        public Type Type { get; }
 
        public bool Matched { get; }
    }
 
    public sealed class NoVerbSelectedError : Error
    {
        internal NoVerbSelectedError()
            : base(ErrorType.NoVerbSelectedError) { }
    }
 
    public sealed class VersionRequestedError : Error
    {
        internal VersionRequestedError()
            : base(ErrorType.VersionRequestedError, true) { }
    }
 
    public sealed class SetValueExceptionError : NamedError
    {
        internal SetValueExceptionError(NameInfo nameInfo, Exception exception, object value)
            : base(ErrorType.SetValueExceptionError, nameInfo)
        {
            Exception = exception;
            Value = value;
        }
 
        public Exception Exception { get; }
 
        public object Value { get; }
    }
 
    public sealed class InvalidAttributeConfigurationError : Error
    {
        public const string ErrorMessage =
            "Check if Option or Value attribute values are set properly for the given type.";
 
        internal InvalidAttributeConfigurationError()
            : base(ErrorType.InvalidAttributeConfigurationError, true) { }
    }
 
    public sealed class MissingGroupOptionError : Error, IEquatable<Error>, IEquatable<MissingGroupOptionError>
    {
        public const string ErrorMessage = "At least one option in a group must have value.";
 
        internal MissingGroupOptionError(string group, IEnumerable<NameInfo> names)
            : base(ErrorType.MissingGroupOptionError)
        {
            Group = group;
            Names = names;
        }
 
        public string Group { get; }
 
        public IEnumerable<NameInfo> Names { get; }
 
#region IEquatable<Error> Members
 
        public new bool Equals(Error obj)
        {
            MissingGroupOptionError other = obj as MissingGroupOptionError;
 
            if (other != null)
            {
                return Equals(other);
            }
 
            return base.Equals(obj);
        }
 
#endregion
 
#region IEquatable<MissingGroupOptionError> Members
 
        public bool Equals(MissingGroupOptionError other)
        {
            if (other == null)
            {
                return false;
            }
 
            return Group.Equals(other.Group) && Names.SequenceEqual(other.Names);
        }
 
#endregion
    }
 
    public sealed class GroupOptionAmbiguityError : NamedError
    {
        public NameInfo Option;
 
        internal GroupOptionAmbiguityError(NameInfo option)
            : base(ErrorType.GroupOptionAmbiguityError, option)
        {
            Option = option;
        }
    }
 
    public sealed class MultipleDefaultVerbsError : Error
    {
        public const string ErrorMessage = "More than one default verb is not allowed.";
 
        internal MultipleDefaultVerbsError()
            : base(ErrorType.MultipleDefaultVerbsError) { }
    }
}