ParserResult.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 sealed class TypeInfo
    {
        private TypeInfo(Type current, IEnumerable<Type> choices)
        {
            Current = current;
            Choices = choices;
        }
 
        public Type Current { get; }
 
        public IEnumerable<Type> Choices { get; }
 
        internal static TypeInfo Create(Type current)
        {
            return new TypeInfo(current, Enumerable.Empty<Type>());
        }
 
        internal static TypeInfo Create(Type current, IEnumerable<Type> choices)
        {
            return new TypeInfo(current, choices);
        }
    }
 
    public enum ParserResultType
    {
        Parsed,
 
        NotParsed,
    }
 
    public abstract class ParserResult<T>
    {
        internal ParserResult(IEnumerable<Error> errors, TypeInfo typeInfo)
        {
            Tag = ParserResultType.NotParsed;
            TypeInfo = typeInfo ?? TypeInfo.Create(typeof(T));
            Errors = errors ?? new Error[0];
            Value = default;
        }
 
        internal ParserResult(T value, TypeInfo typeInfo)
        {
            Value = value ?? throw new ArgumentNullException(nameof(value));
            Tag = ParserResultType.Parsed;
            TypeInfo = typeInfo ?? TypeInfo.Create(value.GetType());
            Errors = new Error[0];
        }
 
        public ParserResultType Tag { get; }
 
        public TypeInfo TypeInfo { get; }
 
        public T Value { get; }
 
        public IEnumerable<Error> Errors { get; }
    }
 
    public sealed class Parsed<T> : ParserResult<T>, IEquatable<Parsed<T>>
    {
        internal Parsed(T value, TypeInfo typeInfo)
            : base(value, typeInfo) { }
 
        internal Parsed(T value)
            : this(value, TypeInfo.Create(value.GetType())) { }
 
#region IEquatable<Parsed<T>> Members
 
        public bool Equals(Parsed<T> other)
        {
            if (other == null)
            {
                return false;
            }
 
            return Tag.Equals(other.Tag) && Value.Equals(other.Value);
        }
 
#endregion
 
 
        public override bool Equals(object obj)
        {
            if (obj is Parsed<T> other)
            {
                return Equals(other);
            }
 
            return base.Equals(obj);
        }
 
        public override int GetHashCode()
        {
            return new { Tag, Value }.GetHashCode();
        }
    }
 
    public sealed class NotParsed<T> : ParserResult<T>, IEquatable<NotParsed<T>>
    {
        internal NotParsed(TypeInfo typeInfo, IEnumerable<Error> errors)
            : base(errors, typeInfo) { }
 
#region IEquatable<NotParsed<T>> Members
 
        public bool Equals(NotParsed<T> other)
        {
            if (other == null)
            {
                return false;
            }
 
            return Tag.Equals(other.Tag) && Errors.SequenceEqual(other.Errors);
        }
 
#endregion
 
 
        public override bool Equals(object obj)
        {
            if (obj is NotParsed<T> other)
            {
                return Equals(other);
            }
 
            return base.Equals(obj);
        }
 
        public override int GetHashCode()
        {
            return new { Tag, Errors }.GetHashCode();
        }
    }
}