/*

  Copyright 2004-2008 Paul R. Holser, Jr.  All rights reserved.

  Licensed under the Academic Free License version 3.0

  */

 package jaggregate;

 import java.io.IOException;

 import java.io.ObjectInputStream;

 import java.io.ObjectOutputStream;

 import java.io.Serializable;

 import static jaggregate.IdentityDictionary.*;

 import static jaggregate.IdentitySet.*;

 /**

  * A bag for which <dfn>equivalence</dfn> is defined by {@code ==}.

  *

  * @param <E> a restriction on the types of elements that may be included in the bag

  *

  * @author <a href="mailto:pholser@alumni.rice.edu">Paul Holser</a>

  * @version $Id: IdentityBag.java,v 1.4 2008/05/07 06:00:48 pholser Exp $

  */

 public class IdentityBag<E> extends AbstractBag<E> implements Serializable {

     private static final long serialVersionUID = -1L;

     /**

      * Creates an empty bag.

      */

     public IdentityBag() {

         // empty on purpose

     }

     /**

      * Creates a bag containing the elements in the given collection.

      *

      * @param elements elements to add to the new bag

      * @throws NullPointerException if {@code elements} is {@code null}

      */

     public IdentityBag( Collection<? extends E> elements ) {

         super( elements );

     }

     /**

      * Creates a bag containing the elements in the given array.

      *

      * @param elements elements to add to the new bag

      * @throws NullPointerException if {@code elements} is {@code null}

      */

     public IdentityBag( E... elements ) {

         super( elements );

     }

     /**

      * Creates a bag containing the elements in the given iterable object.

      *

      * @param elements elements to add to the new bag

      * @throws NullPointerException if {@code elements} is {@code null}

      */

     public IdentityBag( Iterable<? extends E> elements ) {

         super( elements );

     }

     /**

      * Creates an empty bag.

      *

      * @param <T> the type of elements allowed in the new bag

      * @return a new empty bag

      */

     public static <T> IdentityBag<T> emptyIdentityBag() {

         return new IdentityBag<T>();

     }

     /**

      * Creates a bag containing the elements in the given collection.

      *

      * @param <T> the type of elements allowed in the new bag

      * @param elements elements to add to the new bag

      * @return the new bag

      * @throws NullPointerException if {@code elements} is {@code null}

      */

     public static <T> IdentityBag<T> identityBagFrom( Collection<? extends T> elements ) {

         return new IdentityBag<T>( elements );

     }

     /**

      * Creates a bag containing the elements in the given array.

      *

      * @param <T> the type of elements allowed in the new bag

      * @param elements elements to add to the new bag

      * @return the new bag

      * @throws NullPointerException if {@code elements} is {@code null}

      */

     public static <T> IdentityBag<T> identityBagFrom( T[] elements ) {

         return new IdentityBag<T>( elements );

     }

     /**

      * Creates a bag containing the given elements.

      *

      * @param <T> the type of elements allowed in the new bag

      * @param newElement first new element to add

      * @param restOfNewElements remainder of the elements to add

      * @return the new bag

      * @throws NullPointerException if {@code restOfNewElements} is {@code null}

      * @throws IllegalArgumentException if any of the new elements is found to violate

      * restrictions on the characteristics of valid elements

      * @see #addAll(Collection)

      */

     public static <T> IdentityBag<T> identityBagWith( T newElement,

         T... restOfNewElements ) {

         IdentityBag<T> newBag = identityBagFrom( restOfNewElements );

         newBag.add( newElement );

         return newBag;

     }

     /**

      * Creates a bag containing the elements given by an iterable object.

      *

      * @param <T> the type of elements allowed in the new bag

      * @param elements elements to add to the new bag

      * @return the new bag

      * @throws NullPointerException if {@code elements} is {@code null}

      */

     public static <T> IdentityBag<T> identityBagFrom( Iterable<? extends T> elements ) {

         return new IdentityBag<T>( elements );

     }

     /**

      * {@inheritDoc}

      * <p/>

      * Answers self.

      */

     @Override

     public IdentityBag<E> toIdentityBag() {

         return this;

     }

     /**

      * {@inheritDoc}

      *

      * @return a bag of results

      */

     @Override

     public <R> IdentityBag<R> collect(

         UnaryFunctor<? super E, ? extends R> transformer ) {

         return (IdentityBag<R>) super.collect( transformer );

     }

     /**

      * {@inheritDoc}

      *

      * @return a bag of rejects

      */

     @Override

     public IdentityBag<E> reject( UnaryCondition<? super E> discriminator ) {

         return (IdentityBag<E>) super.reject( discriminator );

     }

     /**

      * {@inheritDoc}

      *

      * @return a bag of selections

      */

     @Override

     public IdentityBag<E> select( UnaryCondition<? super E> discriminator ) {

         return (IdentityBag<E>) super.select( discriminator );

     }

     /**

      * {@inheritDoc}

      */

     @Override

     protected Class<? extends AbstractBag> getImplementationClass() {

         return IdentityBag.class;

     }

     /**

      * {@inheritDoc}

      */

     @Override

     protected AbstractDictionary<E, Integer> newEmptyStorage() {

         return emptyIdentityDictionary();

     }

     /**

      * {@inheritDoc}

      */

     @Override

     protected IdentityBag<E> newEmptyExtensibleCollection() {

         return newEmptyExtensibleResultCollection();

     }

     /**

      * {@inheritDoc}

      */

     @Override

     protected <R> IdentityBag<R> newEmptyExtensibleResultCollection() {

         return emptyIdentityBag();

     }

     /**

      * {@inheritDoc}

      */

     @Override

     protected <T> IdentitySet<T> newEmptySet() {

         return emptyIdentitySet();

     }

     /**

      * {@inheritDoc}

      */

     @Override

     protected String asString( E anElement ) {

         return Objects.identityToString( anElement );

     }

     private void writeObject( ObjectOutputStream output ) throws IOException {

         serializeTo( output );

     }

     private void readObject( ObjectInputStream input )

         throws IOException, ClassNotFoundException {

         deserializeFrom( input );

     }

 }