// This Source Code is in the Public Domain per: http://unlicense.org
package org.litesoft.core.util;

import java.util.*;

public class NoEqualsSet<E, C extends Comparable<C>> extends NoEqualsCollection<E, C> implements Set<E>
{
    private final Set<Wrapper<E, C>> mCollection = new HashSet<Wrapper<E, C>>();

    protected NoEqualsSet( NoEqualsHelper<E, C> pHelper )
    {
        super( pHelper );
    }

    public NoEqualsSet( NoEqualsHelper<E, C> pHelper, Collection<? extends E> pInitialEntries )
    {
        this( pHelper );
        if ( pInitialEntries != null )
        {
            E[] zEntries = pInitialEntries.toArray( mHelper.createArray( pInitialEntries.size() ) ); // Snag a copy of the Entries
            for ( E zEntry : zEntries )
            {
                if ( zEntry != null )
                {
                    mCollection.add( wrap( zEntry ) );
                }
            }
        }
    }

    public NoEqualsSet( NoEqualsHelper<E, C> pHelper, E... pInitialEntries )
    {
        this( pHelper, (pInitialEntries != null) ? Arrays.asList( pInitialEntries ) : null );
    }

    @Override
    protected final Collection<Wrapper<E, C>> LLgetCollection()
    {
        return mCollection;
    }

    /**
     * Compares the specified object with this set for equality.
     * <p/>
     * Returns <tt>true</tt> if the specified object is also a set, the two sets
     * have the same size, and every member of the specified set is
     * contained in this set (or equivalently, every member of this set is
     * contained in the specified set).  This definition ensures that the
     * equals method works properly across different implementations of the
     * set interface.
     *
     * @param o object to be compared for equality with this set
     *
     * @return <tt>true</tt> if the specified object is equal to this set
     */
    public final boolean equals( Object o )
    {
        return (o == this) || ((o instanceof Set) && LLequalsNotNull( (Set<?>) o ));
    }

    public final boolean equals( Set<?> them )
    {
        return (them == this) || ((them != null) && LLequalsNotNull( them ));
    }

    private boolean LLequalsNotNull( Set<?> them )
    {
        Object[] theirObjects = them.toArray();
        synchronized ( this )
        {
            if ( LLsize() != theirObjects.length )
            {
                return false;
            }
            if ( theirObjects.length != 0 )
            {
                Wrapper<E, C>[] zWrappers = getWrappedEntries();
                for ( Object zTheirObject : theirObjects )
                {
                    if ( !mHelper.isInstance( zTheirObject ) || !LLobjectIsIn( castNullOK( zTheirObject ), zWrappers ) )
                    {
                        return false;
                    }
                }
            }
        }
        return true;
    }
}