# region Heading

/**************************************************************************************************************/
/*                                                                                                            */
/*  Set.cs                                                                                                    */
/*                                                                                                            */
/*  Implements a Set class                                                                                    */
/*                                                                                                            */
/*  This is free code, use it as you require. It was a good learning exercise for me and I hope it will be    */
/*  for you too. If you modify it please use your own namespace.                                              */
/*                                                                                                            */
/*  If you like it or have suggestions for improvements please let me know at: PIEBALDconsult@aol.com         */
/*                                                                                                            */
/*  Modification history:                                                                                     */
/*  2005-07-05          Sir John E. Boucher     Created                                                       */
/*  2006-11-12          Sir John E. Boucher     Fixed some problems, made generic, and added comments         */
/*  2006-11-13          Sir John E. Boucher     Pretty much a complete rewrite                                */
/*  2006-11-15          Sir John E. Boucher     Reworked again to add ability to specify the Comparer         */
/*                                              and ability to specify parameters for ToString()              */
/*                                                                                                            */
/**************************************************************************************************************/

# endregion

// # define Explicit
// # define ThrowOnNull

namespace BrazilTimestampReconstruction
{
    /** 
    <summary>
        Represents a Set.
    </summary>
    */
    public partial class Set<T> : System.Collections.IEnumerable
    {
        private System.Collections.Generic.Dictionary<T,object> elements =
            new System.Collections.Generic.Dictionary<T,object>() ;
    
# region Constructor

        /**
        <summary>
            Constructs and populates a Set.
        </summary>
        <param name="Items">
            (Optional) Items to add to the new Set.
        </param>
        */
        public Set
        (
            params object[] Items
        )
        {
            Add ( Items ) ;
        }

# endregion

# region Properties

        /**
        <return>
            The number of elements in the Set.
        </return>
        */
        public virtual int
        Cardinality
        {
            get
            {
                return ( this.elements.Count ) ;
            }
        }

        /**
        <return>
            The System.Collections.Generic.IEqualityComparer to use
        </return>
        */
        public virtual System.Collections.Generic.IEqualityComparer<T>
        EqualityComparer
        {
            get
            {
                return ( this.elements.Comparer ) ;
            }
            
            set
            {
                if ( value != EqualityComparer )
                {
                    System.Collections.IEnumerable temp = this.elements.Keys ;

                    this.elements = new System.Collections.Generic.Dictionary<T,object> ( value ) ;

                    this.Add ( temp ) ;
                }
            }
        }
        
# endregion

# region Conversions

        /**
        <summary>
            Converts an item to a Set
        </summary>
        */
# if Explicit        
        public static explicit operator Set<T>
# else
        public static implicit operator Set<T>
# endif
        (
            T Item
        )
        {
            return ( new Set<T> ( Item ) ) ;
        }

        /**
        <summary>
            Converts an array of items to a Set
        </summary>
        */
# if Explicit
        public static explicit operator Set<T>
# else
        public static implicit operator Set<T>
# endif
        (
            T[] Items
        )
        {
            return ( new Set<T> ( Items ) ) ;
        }

        /**
        <summary>
            Converts an array of items to a Set
        </summary>
        */
# if Explicit
        public static explicit operator Set<T>
# else
        public static implicit operator Set<T>
# endif
        (
            System.Array Items
        )
        {
            return ( new Set<T> ( Items ) ) ;
        }

        /**
        <summary>
            Converts a Collection of items to a Set
        </summary>
        */
# if Explicit
        public static explicit operator Set<T>
# else
        public static implicit operator Set<T>
# endif
        (
            System.Collections.CollectionBase Items
        )
        {
            return ( new Set<T> ( Items ) ) ;
        }

        /**
        <summary>
            Converts an ArrayList of items to a Set
        </summary>
        */
# if Explicit
        public static explicit operator Set<T>
# else
        public static implicit operator Set<T>
# endif
        (
            System.Collections.ArrayList Items
        )
        {
            return ( new Set<T> ( Items ) ) ;
        }

# endregion
    
# region Mathematical Operators

        /**
        <summary>
            Union of the two Sets; Set of items that are elements of at least one of the Sets.
        </summary>
        */
        public static Set<T>
        operator +
        (
            Set<T> lhs
        ,
            Set<T> rhs
        )
        {
            return ( new Set<T> ( lhs , rhs ) ) ;
        }

        /**
        <summary>
            Relative complement; items that are elements of the first Set, but not Elements of the second Set.
        </summary>
        */
        public static Set<T>
        operator -
        (
            Set<T> lhs
        ,
            Set<T> rhs
        )
        {
            Set<T> result = new Set<T>() ;
            
            foreach ( T t in lhs )
            {
                if ( !rhs.Contains ( t ) )
                {
                    result.Add ( t ) ;
                }
            }
            
            return ( result ) ;
        }

        /**
        <summary>
            Union of the two Sets; items that are elements of at least one of the Sets.
        </summary>
        */
        public static Set<T>
        operator |
        (
            Set<T> lhs
        ,
            Set<T> rhs
        )
        {
            return ( lhs + rhs ) ;
        }

        /**
        <summary>
            Intersection of the two Sets; items that are elements of both of the Sets.
        </summary>
        */
        public static Set<T>
        operator &
        (
            Set<T> lhs
        ,
            Set<T> rhs
        )
        {
            Set<T> result = new Set<T>() ;

            foreach ( T t in lhs )
            {
                if ( rhs.Contains ( t ) )
                {
                    result.Add ( t ) ;
                }
            }

            return ( result ) ;
        }

        /**
        <summary>
            Exclusive Or of the two Sets; items that are elements of only one of the Sets.
        </summary>
        */
        public static Set<T>
        operator ^
        (
            Set<T> lhs
        ,
            Set<T> rhs
        )
        {
            Set<T> result = new Set<T>() ;

            foreach ( T t in lhs + rhs )
            {
                if ( !lhs.Contains ( t ) || !rhs.Contains ( t ) )
                {
                    result.Add ( t ) ;
                }
            }

            return ( result ) ;
        }

# endregion

# region Comparison Operators

        /**
        <summary>
            Test equality of Sets; True if both Sets have the same elements
        </summary>
        */
        public static bool
        operator ==
        (
            Set<T> lhs
        ,
            Set<T> rhs
        )
        {
            return ( ( lhs.Cardinality == rhs.Cardinality ) && ( lhs.Contains ( rhs ) ) ) ;
        }

        /**
        <summary>
            Test inequality of Sets; True if the Sets do not have the same elements
        </summary>
        */
        public static bool
        operator !=
        (
            Set<T> lhs
        ,
            Set<T> rhs
        )
        {
            return ( !( lhs == rhs ) ) ;
        }

        /**
        <summary>
            Subset; true if the first Set is a subset of (but is not equal to) the second
        </summary>
        */
        public static bool
        operator <
        (
            Set<T> lhs
        ,
            Set<T> rhs
        )
        {
            return ( ( lhs.Cardinality < rhs.Cardinality ) && ( rhs.Contains ( lhs ) ) );
        }

        /**
        <summary>
            Superset; true if the first Set is a superset of (but is not equal to) the second 
        </summary>
        */
        public static bool
        operator >
        (
            Set<T> lhs
        ,
            Set<T> rhs
        )
        {
            return ( rhs < lhs ) ;
        }

        /**
        <summary>
            Subset; true if the first Set is a subset of the second 
        </summary>
        */
        public static bool
        operator <=
        (
            Set<T> lhs
        ,
            Set<T> rhs
        )
        {
            return ( ( lhs.Cardinality <= rhs.Cardinality ) && ( rhs.Contains ( lhs ) ) );
        }

        /**
        <summary>
            Superset; true if the first Set is a superset of the second 
        </summary>
        */
        public static bool
        operator >=
        (
            Set<T> lhs
        ,
            Set<T> rhs
        )
        {
            return ( rhs <= lhs ) ;
        }
 
# endregion

# region Overrides

        /**
        <summary>
            Enumerator for the elements of the Set
        </summary>
        */
        public virtual System.Collections.IEnumerator
        GetEnumerator
        (
        )
        {
            return ( this.elements.Keys.GetEnumerator() ) ;
        }
        
        /**
        <summary>
            Yada yada yada
        </summary>
        */
        public override bool
        Equals
        (
            object rhs
        )
        {
            return ((rhs.GetType() == typeof(Set<T>)) && (this == (Set<T>)rhs));
        }

        /**
        <summary>
            Yada yada yada
        </summary>
        */
        public override int
        GetHashCode
        (
        )
        {
            return ( this.elements.GetHashCode() ) ;
        }

# endregion

# region Operations

        /**
        <summary>
            Attempts to add Items to the Set
        </summary>
        */
        public virtual Set<T>
        Add
        (
            params object[] Items 
        )
        {
            foreach ( object i in Items )
            {
                if ( i is T )
                {
                    if ( !this.elements.ContainsKey ( (T) i ) )
                    {
                        this.elements.Add ( (T) i , null ) ;
                    }
                }
                else
                {
                    if ( i is System.Collections.IEnumerable )
                    {
                        foreach ( object o in (System.Collections.IEnumerable) i )
                        {
                            Add ( o ) ;
                        }
                    }
                    else
                    {
                        if ( i == null )
                        {
/* If ThrowOnNull is defined, nulls in the data will cause an exception to be thrown, otherwise they are ignored */
# if ThrowOnNull
                            throw ( new System.NullReferenceException ( "The Set may not contain null" ) ) ;
# endif
                        }
                        else
                        {
                            throw ( new System.InvalidOperationException ( i.ToString() + " is not a " + typeof(T).ToString() ) ) ;
                        }
                    }
                }
            }
            
            return ( this ) ;
        }

        /**
        <summary>
            Attempts to remove Items from the Set
        </summary>
        */
        public virtual Set<T>
        Remove
        (
            params object[] Items
        )
        {
            foreach ( object i in Items )
            {
                if ( i is T )
                {
                    this.elements.Remove ( (T) i ) ;
                }
                else
                {
                    if ( i is System.Collections.IEnumerable )
                    {
                        foreach ( object o in (System.Collections.IEnumerable) i )
                        {
                            Remove ( o ) ;
                        }
                    }
                }
            }
            
            return ( this ) ;
        }

        /**
        <summary>
            Returns true if the Set contains the Item(s)
        </summary>
        */
        public virtual bool
        Contains
        (
            params object[] Items
        )
        {
            bool result = true ;

            foreach ( object i in Items )
            {
                if ( i is T )
                {
                    if ( !this.elements.ContainsKey ( (T) i ) )
                    {
                        result = false ;
                        
                        break ;
                    }
                }
                else
                {
                    if ( i is System.Collections.IEnumerable )
                    {
                        foreach ( object o in (System.Collections.IEnumerable) i )
                        {
                            if ( !Contains ( o ) )
                            {
                                result = false ;
                                
                                break ;
                            }
                        }
                    }
                }
            }
                                    
            return ( result ) ;
        }

        /**
        <summary>
            Removes all elements from the Set
        </summary>
        */
        public virtual Set<T>
        Clear
        (
        )
        {
            this.elements.Clear() ;
            return ( this ) ;
        }

# endregion

    }
}