mRemoteNG/mRemoteV1/Tools/Optional.cs

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;

namespace mRemoteNG.Tools
{
    /// <summary>
    /// Represents a type that may or may not have been assigned a value.
    /// A strongly typed collection that contains either 0 or 1 values.
    /// </summary>
    /// <typeparam name="T">The underlying type that may or may not have a value</typeparam>
    public class Optional<T> : IEnumerable<T>, IComparable<Optional<T>>
    {
		private readonly T[] _optional;

        /// <summary>
        /// Create a new empty instance of Optional
        /// </summary>
		public Optional()
		{
			_optional = new T[0];
		}

        /// <summary>
        /// Create a new instance of Optional from the given value.
        /// If the value is null, the Optional will be empty
        /// </summary>
		public Optional(T value)
		{
			_optional = value != null 
				? new[] {value} 
				: new T[0];
		}

        public override string ToString()
        {
            return _optional.Any() ? _optional.First().ToString() : "";
        }

        public static implicit operator Optional<T>(T value)
        {
            return new Optional<T>(value);
        }

        public static Optional<TOut> FromNullable<TOut>(TOut? value) where TOut : struct
        {
            return value.HasValue
                ? new Optional<TOut>(value.Value)
                : new Optional<TOut>();
        }

        /// <summary>
        /// Returns an empty <see cref="Optional{T}"/>
        /// </summary>
        public static Optional<T> Empty => new Optional<T>();

        #region IEnumerable
        IEnumerator IEnumerable.GetEnumerator()
		{
			return GetEnumerator();
		}

		public IEnumerator<T> GetEnumerator()
		{
			return ((IEnumerable<T>)_optional).GetEnumerator();
		}
        #endregion

        #region IComparable
        /// <summary>
        /// Compares this <see cref="Optional{T}"/> to another instance
        /// of the same type. For purposes of comparison, empty Optional
        /// objects are treated like Null and will be valued lower than
        /// an Optional that contains a value. If both Optionals contain
        /// values, the values are compared directly.
        /// </summary>
        /// <param name="other"></param>
        public int CompareTo(Optional<T> other)
        {
            var otherHasAnything = other.Any();
            var thisHasAnything = _optional.Length > 0;

            // both are empty, equivalent value
            if (!thisHasAnything && !otherHasAnything)
                return 0;
            // we are empty, they are greater value
            if (!thisHasAnything)
                return -1;
            // they are empty, we are greater value
            if (!otherHasAnything)
                return 1;
            // neither are empty, compare wrapped objects directly
            if (_optional[0] is IComparable<T>)
                return ((IComparable<T>)_optional[0]).CompareTo(other.First());

            throw new ArgumentException(string.Format(
                "Cannot compare objects. Optional type {0} is not comparable to itself",
                typeof(T).FullName));
        }
        #endregion

        #region Override Equals and GetHashCode

        public override bool Equals(object obj)
	    {
	        if (ReferenceEquals(this, obj))
	            return true;

	        var objAsOptional = obj as Optional<T>;
	        if (objAsOptional != null)
	            return Equals(objAsOptional);

	        if (obj is T)
	            Equals((T)obj);

	        return false;
	    }

	    public bool Equals(Optional<T> other)
	    {
	        var otherObj = other.FirstOrDefault();
	        var thisObj = _optional.FirstOrDefault();
	        if (thisObj == null && otherObj == null)
	            return true;
	        if (thisObj == null)
	            return false;
	        return thisObj.Equals(otherObj);
	    }

	    public override int GetHashCode()
	    {
	        return _optional != null
	            ? _optional.GetHashCode()
	            : 0;
	    }
	    #endregion

	    #region Operators

	    public static bool operator ==(Optional<T> left, Optional<T> right)
	    {
	        return Equals(left, right);
	    }

	    public static bool operator !=(Optional<T> left, Optional<T> right)
	    {
	        return !Equals(left, right);
	    }
	    #endregion
	}
}