/*

  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.IdentityBag.*;

 import static jaggregate.IdentitySet.*;

 import static jaggregate.Objects.*;

 import static jaggregate.internal.EquivalenceTester.*;

 /**

  * Represents an unordered collection whose <dfn>elements</dfn> can be accessed using an

  * explicitly assigned external <dfn>key</dfn>.  <dfn>Key equivalence</dfn> is defined by

  * {@code ==}.

  *

  * @param <K> a restriction on the types of the keys that may be contained in the

  * dictionary

  * @param <V> a restriction on the types of the values that may be contained in the

  * dictionary

  *

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

  * @version $Id: IdentityDictionary.java,v 1.5 2008/10/03 19:01:23 pholser Exp $

  */

 public class IdentityDictionary<K, V> extends AbstractDictionaryImpl<K, V>

     implements Serializable {

     private static final long serialVersionUID = -1L;

     /**

      * Creates an empty dictionary.

      */

     public IdentityDictionary() {

         super( OBJECT_IDENTITIES );

     }

     /**

      * Creates a dictionary that contains the given associations.

      *

      * @param associations the associations to add to the new dictionary

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

      */

     public IdentityDictionary(

         AbstractDictionary<? extends K, ? extends V> associations ) {

         super( associations, OBJECT_IDENTITIES );

     }

     /**

      * Creates a dictionary that contains the given associations.

      *

      * @param associations the associations to add to the new dictionary

      * @throws NullPointerException if {@code associations} is {@code null}, or if

      * any of the elements of {@code associations} is {@code null}

      */

     public IdentityDictionary( Pair<? extends K, ? extends V>... associations ) {

         super( OBJECT_IDENTITIES );

         for ( Pair<? extends K, ? extends V> each : associations )

             putAt( each.key(), each.value() );

     }

     /**

      * Creates an empty dictionary.

      *

      * @param <T> the type of keys allowed in the new dictionary

      * @param <U> the type of values allowed in the new dictionary

      * @return a new empty dictionary

      */

     public static <T, U> IdentityDictionary<T, U> emptyIdentityDictionary() {

         return new IdentityDictionary<T, U>();

     }

     /**

      * Creates a dictionary that contains the given associations.

      *

      * @param <T> the type of keys allowed in the new dictionary

      * @param <U> the type of values allowed in the new dictionary

      * @param associations the associations to add to the new dictionary

      * @return the new dictionary

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

      */

     public static <T, U> IdentityDictionary<T, U> identityDictionaryFrom(

         AbstractDictionary<? extends T, ? extends U> associations ) {

         return new IdentityDictionary<T, U>( associations );

     }

     /**

      * Creates a dictionary that contains the given associations.

      *

      * @param <T> the type of keys allowed in the new dictionary

      * @param <U> the type of values allowed in the new dictionary

      * @param associations the associations to add to the new dictionary

      * @return the new dictionary

      * @throws NullPointerException if {@code associations} is {@code null}, or if

      * any of the elements of {@code associations} is {@code null}

      */

     public static <T, U> IdentityDictionary<T, U> identityDictionaryFrom(

         Pair<? extends T, ? extends U>[] associations ) {

         return new IdentityDictionary<T, U>( associations );

     }

     /**

      * Creates a dictionary that contains the given associations.

      *

      * @param <T> the type of keys allowed in the new dictionary

      * @param <U> the type of values allowed in the new dictionary

      * @param firstAssociation an association to add to the new dictionary

      * @param restOfAssociations other associations to add to the new dictionary

      * @return the new dictionary

      * @throws NullPointerException if {@code firstAssociation} is {@code null},

      * {@code associations} is {@code null}, or if any of the elements of

      * {@code associations} is {@code null}

      */

     public static <T, U> IdentityDictionary<T, U> identityDictionaryWith(

         Pair<? extends T, ? extends U> firstAssociation,

         Pair<? extends T, ? extends U>... restOfAssociations ) {

         IdentityDictionary<T, U> dictionary =

             identityDictionaryFrom( restOfAssociations );

         dictionary.putAt( firstAssociation.key(), firstAssociation.value() );

         return dictionary;

     }

     /**

      * {@inheritDoc}

      */

     @Override

     public <R> IdentityBag<R> collect(

         UnaryFunctor<? super Pair<K, V>, ? extends R> transformer ) {

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

     }

     /**

      * {@inheritDoc}

      */

     @Override

     public <R> IdentityDictionary<K, R> collectValues(

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

         return (IdentityDictionary<K, R>) super.collectValues( transformer );

     }

     /**

      * {@inheritDoc}

      */

     @Override

     public IdentityDictionary<K, V> reject(

         UnaryCondition<? super Pair<K, V>> discriminator ) {

         return (IdentityDictionary<K, V>) super.reject( discriminator );

     }

     /**

      * {@inheritDoc}

      */

     @Override

     public IdentityDictionary<K, V> rejectValues(

         UnaryCondition<? super V> discriminator ) {

         return (IdentityDictionary<K, V>) super.rejectValues( discriminator );

     }

     /**

      * {@inheritDoc}

      */

     @Override

     public IdentityDictionary<K, V> select(

         UnaryCondition<? super Pair<K, V>> discriminator ) {

         return (IdentityDictionary<K, V>) super.select( discriminator );

     }

     /**

      * {@inheritDoc}

      */

     @Override

     public IdentityDictionary<K, V> selectValues(

         UnaryCondition<? super V> discriminator ) {

         return (IdentityDictionary<K, V>) super.selectValues( discriminator );

     }

     /**

      * {@inheritDoc}

      *

      * @throws UnsupportedOperationException since it makes no sense -- identities of

      * pairs?

      */

     @Override

     public boolean retainAll( Collection<? extends Pair<K, V>> keepers ) {

         throw new UnsupportedOperationException(

             "pairs have no identity, can't retain them in IdentityDictionary" );

     }

     /**

      * {@inheritDoc}

      */

     @Override

     protected Class<? extends AbstractDictionary> getImplementationClass() {

         return IdentityDictionary.class;

     }

     /**

      * {@inheritDoc}

      */

     @Override

     protected <T, U> IdentityDictionary<T, U> newEmptyDictionary() {

         return emptyIdentityDictionary();

     }

     /**

      * {@inheritDoc}

      */

     @Override

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

         return emptyIdentityBag();

     }

     /**

      * {@inheritDoc}

      */

     @Override

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

         return emptyIdentitySet();

     }

     /**

      * {@inheritDoc}

      */

     @Override

     protected String asString( Object keyOrValue ) {

         return identityToString( keyOrValue );

     }

     private void writeObject( ObjectOutputStream output ) throws IOException {

         serializeTo( output );

     }

     private void readObject( ObjectInputStream input )

         throws IOException, ClassNotFoundException {

         deserializeFrom( input, OBJECT_IDENTITIES );

     }

 }