org.mule.util.CaseInsensitiveHashMap Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of mule-core
Mule server and core classes
There is a newer version: 3.9.0
/*
 * $Id: CaseInsensitiveHashMap.java 20321 2010-11-24 15:21:24Z dfeist $
 * --------------------------------------------------------------------------------------
 * Copyright (c) MuleSoft, Inc.  All rights reserved.  http://www.mulesoft.com
 *
 * The software in this package is published under the terms of the CPAL v1.0
 * license, a copy of which has been included with this distribution in the
 * LICENSE.txt file.
 */
package org.mule.util;

import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.util.Map;

import org.apache.commons.collections.map.AbstractHashedMap;

/**
 * A case-insensitive Map.
 * 
 * As entries are added to the map, keys hash values are lowercase hash codes of the key.  the
 * Real key case is preserved.
 * 

 * 

 * The keySet() method returns all keys in their original case
 * 

 * Note that CaseInsensitiveMap is not synchronized and is not thread-safe.
 * If you wish to use this map from multiple threads concurrently, you must use
 * appropriate synchronization. The simplest approach is to wrap this map
 * using {@link java.util.Collections#synchronizedMap(Map)}. This class may throw
 * exceptions when accessed by concurrent threads without synchronization.
 *
 * @since 3.0.0
 */
public class CaseInsensitiveHashMap extends AbstractHashedMap implements Serializable
{
    /**
     * Serialisation version
     */
    private static final long serialVersionUID = -7074633917369299456L;

    /**
     * Constructs a new empty map with default size and load factor.
     */
    public CaseInsensitiveHashMap()
    {
        super(DEFAULT_CAPACITY, DEFAULT_LOAD_FACTOR, DEFAULT_THRESHOLD);
    }


    /**
     * Constructs a new, empty map with the specified initial capacity.
     *
     * @param initialCapacity the initial capacity
     * @throws IllegalArgumentException if the initial capacity is less than one
     */
    public CaseInsensitiveHashMap(int initialCapacity) throws IllegalArgumentException
    {
        super(initialCapacity);
    }

    /**
     * Constructs a new, empty map with the specified initial capacity and
     * load factor.
     *
     * @param initialCapacity the initial capacity
     * @param loadFactor      the load factor
     * @throws IllegalArgumentException if the initial capacity is less than one
     * @throws IllegalArgumentException if the load factor is less than zero
     */
    public CaseInsensitiveHashMap(int initialCapacity, float loadFactor) throws IllegalArgumentException
    {
        super(initialCapacity, loadFactor);
    }

    /**
     * Constructor copying elements from another map.
     * 
     * Keys will be converted to lower case strings, which may cause
     * some entries to be removed (if string representation of keys differ
     * only by character case).
     *
     * @param map the map to copy
     * @throws NullPointerException if the map is null
     */
    public CaseInsensitiveHashMap(Map map)
    {
        super(map);
    }

    /**
     * Creates a hash value from the lower case value of the key. The same function will be used when querying
     * a value in the map also
     *
     * @param key the key value to hash
     * @return a hash value for the lower case key
     */
    @Override
    protected int hash(Object key)
    {
        return super.hash(key.toString().toLowerCase());
    }

    /**
     * Overloads the default behaviour to compare the keys without case sensitivity
     *
     * @param key1 the first key
     * @param key2 the key to compare against
     * @return true is the keys match
     */
    @Override
    protected boolean isEqualKey(Object key1, Object key2)
    {
        if (key1 instanceof String && key2 instanceof String)
        {
            return (((String) key1).equalsIgnoreCase((String) key2));
        }
        else
        {
            return super.isEqualKey(key1, key2);
        }
    }

    //-----------------------------------------------------------------------

    /**
     * Clones the map without cloning the keys or values.
     *
     * @return a shallow clone
     */
    @Override
    public Object clone()
    {
        return super.clone();
    }

    /**
     * Write the map out using a custom routine.
     */
    private void writeObject(ObjectOutputStream out) throws IOException
    {
        out.defaultWriteObject();
        doWriteObject(out);
    }

    /**
     * Read the map in using a custom routine.
     */
    private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException
    {
        in.defaultReadObject();
        doReadObject(in);
    }
}