Hibernate example source code file (IdentityMap.java)

This example Hibernate source code file (IdentityMap.java) is included in the DevDaily.com "Java Source Code Warehouse" project. The intent of this project is to help you "Learn Java by Example" ^TM.

Java - Hibernate tags/keywords

entry, identitykey, identitykey, identitymap, identitymap, identitymapentry, io, iterator, k, map, override, override, suppresswarnings, util, v, v

The Hibernate IdentityMap.java source code

/*
 * Hibernate, Relational Persistence for Idiomatic Java
 *
 * Copyright (c) 2008, Red Hat Middleware LLC or third-party contributors as
 * indicated by the @author tags or express copyright attribution
 * statements applied by the authors.  All third-party contributions are
 * distributed under license by Red Hat Middleware LLC.
 *
 * This copyrighted material is made available to anyone wishing to use, modify,
 * copy, or redistribute it subject to the terms and conditions of the GNU
 * Lesser General Public License, as published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
 * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License
 * for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this distribution; if not, write to:
 * Free Software Foundation, Inc.
 * 51 Franklin Street, Fifth Floor
 * Boston, MA  02110-1301  USA
 *
 */
package org.hibernate.internal.util.collections;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;

/**
 * A <tt>Map where keys are compared by object identity,
 * rather than <tt>equals().
 */
public final class IdentityMap<K,V> implements Map {

	private final Map<IdentityKey map;
	@SuppressWarnings( {"unchecked"})
	private transient Entry<IdentityKey[] entryArray = new Entry[0];
	private transient boolean dirty = false;

	/**
	 * Return a new instance of this class, with an undefined
	 * iteration order.
	 *
	 * @param size The size of the map
	 * @return Map
	 */
	public static <K,V> IdentityMap instantiate(int size) {
		return new IdentityMap<K,V>( new HashMap,V>( size ) );
	}

	/**
	 * Return a new instance of this class, with iteration
	 * order defined as the order in which entries were added
	 *
	 * @param size The size of the map to create
	 * @return The map
	 */
	public static <K,V> IdentityMap instantiateSequenced(int size) {
		return new IdentityMap<K,V>( new LinkedHashMap,V>( size ) );
	}

	/**
	 * Private ctor used in serialization.
	 *
	 * @param underlyingMap The delegate map.
	 */
	private IdentityMap(Map<IdentityKey underlyingMap) {
		map = underlyingMap;
		dirty = true;
	}

	/**
	 * Return the map entries (as instances of <tt>Map.Entry in a collection that
	 * is safe from concurrent modification). ie. we may safely add new instances to
	 * the underlying <tt>Map during iteration of the entries().
	 *
	 * @param map The map of entries
	 * @return Collection
	 */
	public static Map.Entry[] concurrentEntries(Map map) {
		return ( (IdentityMap) map ).entryArray();
	}

	public static List entries(Map map) {
		return ( (IdentityMap) map ).entryList();
	}

	public static Iterator keyIterator(Map map) {
		return ( (IdentityMap) map ).keyIterator();
	}

	public Iterator keyIterator() {
		return new KeyIterator( map.keySet().iterator() );
	}

	public static final class IdentityMapEntry<K,V> implements java.util.Map.Entry {
		private K key;
		private V value;

		IdentityMapEntry(K key, V value) {
			this.key=key;
			this.value=value;
		}

		public K getKey() {
			return key;
		}

		public V getValue() {
			return value;
		}

		public V setValue(V value) {
			V result = this.value;
			this.value = value;
			return result;
		}
	}

	public static final class IdentityKey<K> implements Serializable {
		private K key;

		IdentityKey(K key) {
			this.key=key;
		}

		@SuppressWarnings( {"EqualsWhichDoesntCheckParameterClass"})
		@Override
        public boolean equals(Object other) {
			return key == ( (IdentityKey) other ).key;
		}

		@Override
        public int hashCode() {
			return System.identityHashCode(key);
		}

		@Override
        public String toString() {
			return key.toString();
		}

		public K getRealKey() {
			return key;
		}
	}

	public int size() {
		return map.size();
	}

	public boolean isEmpty() {
		return map.isEmpty();
	}

	@Override
	@SuppressWarnings( {"unchecked"})
	public boolean containsKey(Object key) {
		IdentityKey k = new IdentityKey(key);
		return map.containsKey(k);
	}

	@Override
	public boolean containsValue(Object val) {
		return map.containsValue(val);
	}

	@Override
	@SuppressWarnings( {"unchecked"})
	public V get(Object key) {
		return map.get( new IdentityKey(key) );
	}

	@Override
	public V put(K key, V value) {
		dirty = true;
		return map.put( new IdentityKey<K>(key), value );
	}

	@Override
	@SuppressWarnings( {"unchecked"})
	public V remove(Object key) {
		dirty = true;
		return map.remove( new IdentityKey(key) );
	}

	@Override
	public void putAll(Map<? extends K, ? extends V> otherMap) {
		for ( Entry<? extends K, ? extends V> entry : otherMap.entrySet() ) {
			put( entry.getKey(), entry.getValue() );
		}
	}

	@Override
	public void clear() {
		dirty = true;
		entryArray = null;
		map.clear();
	}

	@Override
	public Set<K> keySet() {
		// would need an IdentitySet for this!
		throw new UnsupportedOperationException();
	}

	@Override
	public Collection<V> values() {
		return map.values();
	}

	@Override
	public Set<Entry entrySet() {
		Set<Entry set = new HashSet>( map.size() );
		for ( Entry<IdentityKey entry : map.entrySet() ) {
			set.add( new IdentityMapEntry<K,V>( entry.getKey().getRealKey(), entry.getValue() ) );
		}
		return set;
	}

	public List<Entry entryList() {
		ArrayList<Entry list = new ArrayList>( map.size() );
		for ( Entry<IdentityKey entry : map.entrySet() ) {
			list.add( new IdentityMapEntry<K,V>( entry.getKey().getRealKey(), entry.getValue() ) );
		}
		return list;
	}

	@SuppressWarnings( {"unchecked"})
	public Map.Entry[] entryArray() {
		if (dirty) {
			entryArray = new Map.Entry[ map.size() ];
			Iterator itr = map.entrySet().iterator();
			int i=0;
			while ( itr.hasNext() ) {
				Map.Entry me = (Map.Entry) itr.next();
				entryArray[i++] = new IdentityMapEntry( ( (IdentityKey) me.getKey() ).key, me.getValue() );
			}
			dirty = false;
		}
		return entryArray;
	}

	/**
	 * Workaround for a JDK 1.4.1 bug where <tt>IdentityHashMaps are not
	 * correctly deserialized.
	 *
	 * @param map The map to serialize
	 * @return Object
	 */
	public static Object serialize(Map map) {
		return ( (IdentityMap) map ).map;
	}

	/**
	 * Workaround for a JDK 1.4.1 bug where <tt>IdentityHashMaps are not
	 * correctly deserialized.
	 *
	 * @param o the serialized map data
	 * @return The deserialized map
	 */
	@SuppressWarnings( {"unchecked"})
	public static <K,V> Map deserialize(Object o) {
		return new IdentityMap<K,V>( (Map,V>) o );
	}
	
	@Override
    public String toString() {
		return map.toString();
	}

	public static <K,V> IdentityMap invert(IdentityMap map) {
		IdentityMap<V,K> result = instantiate( map.size() );
		for ( Entry<K, V> entry : map.entrySet() ) {
			result.put( entry.getValue(), entry.getKey() );
		}
		return result;
	}

	static final class KeyIterator<K> implements Iterator {
		private final Iterator<IdentityKey identityKeyIterator;

		private KeyIterator(Iterator<IdentityKey iterator) {
			identityKeyIterator = iterator;
		}

		public boolean hasNext() {
			return identityKeyIterator.hasNext();
		}

		public K next() {
			return identityKeyIterator.next().getRealKey();
		}

		public void remove() {
			throw new UnsupportedOperationException();
		}

	}

}