package de.unihd.dbs.uima.annotator.heideltime.resources;

import java.util.Collection;

import java.util.HashMap;

import java.util.HashSet;

import java.util.Iterator;

import java.util.Map;

import java.util.Set;

import java.util.regex.Pattern;

/**

 * Implements a HashMap extended with regular expression keys and caching functionality.

 *

 * @author Julian Zell

 *

 */

public class RegexHashMap<T> implements Map<String, T> {

    private HashMap<String, T> container = new HashMap<String, T>();

    private HashMap<String, T> cache = new HashMap<String, T>();

    /**

     * clears both the container and the cache hashmaps

     */

    public void clear() {

        container.clear();

        cache.clear();

    }

    /**

     * checks whether the cache or container contain a specific key, then evaluates the

     * container's keys as regexes and checks whether they match the specific key.

     */

    public boolean containsKey(Object key) {

        // the key is a direct hit from our cache

        if(cache.containsKey(key))

            return true;

        // the key is a direct hit from our hashmap

        if(container.containsKey(key))

            return true;

        // check if the requested key is a matching string of a regex key from our container

        Iterator<String> regexKeys = container.keySet().iterator();

        while(regexKeys.hasNext()) {

            if(Pattern.matches(regexKeys.next(), (String) key))

                return true;

        }

        // if the three previous tests yield no result, the key does not exist

        return false;

    }

    /**

     * checks whether a specific value is container within either container or cache

     */

    public boolean containsValue(Object value) {

        // the value is a direct hit from our cache

        if(cache.containsValue(value))

            return true;

        // the value is a direct hit from our hashmap

        if(container.containsValue(value))

            return true;

        // otherwise, the value isn't within this object

        return false;

    }

    /**

     * returns a merged entryset containing within both the container and cache entrysets

     */

    public Set<Entry<String, T>> entrySet() {

        // prepare the container

        HashSet<Entry<String, T>> set = new HashSet<Entry<String, T>>();

        // add the set from our container

        set.addAll(container.entrySet());

        // add the set from our cache

        set.addAll(cache.entrySet());

        return set;

    }

    /**

     * checks whether the requested key has a direct match in either cache or container, and if it

     * doesn't, also evaluates the container's keyset as regexes to match against the input key and

     * if any of those methods yield a value, returns that value

     * if a value is found doing regex evaluation, use that regex-key's match as a non-regex

     * key with the regex's value to form a new entry in the cache.

     */

    public T get(Object key) {

        // output for requested key null is the value null; normal Map behavior

        if(key == null) return null;

        T result = null;

        if((result = cache.get(key)) != null) {

            // if the requested key maps to a value in the cache

            return result;

        } else if((result = container.get(key)) != null) {

            // if the requested key maps to a value in the container

            return result;

        } else {

            // check if the requested key is a matching string of a regex key from our container

            Iterator<Entry<String, T>> regexKeys = container.entrySet().iterator();

            while(regexKeys.hasNext()) {

                // prepare current entry

                Entry<String, T> entry = regexKeys.next();

                // check if the key is a regex matching the input key

                if(Pattern.matches(entry.getKey(), (String) key)) {

                    putCache((String) key, entry.getValue());

                    return entry.getValue();

                }

            }

        }

        // no value for the given key was found in any of container/cache/regexkey-container

        return null;

    }

    /**

     * checks whether both container and cache are empty

     */

    public boolean isEmpty() {

        return container.isEmpty() && cache.isEmpty();

    }

    /**

     * returns the keysets of both the container and cache hashmaps

     */

    public Set<String> keySet() {

        // prepare container

        HashSet<String> set = new HashSet<String>();

        // add container keys

        set.addAll(container.keySet());

        // add cache keys

        set.addAll(cache.keySet());

        return set;

    }

    /**

     * associates a key with a value in the container hashmap

     */

    public T put(String key, T value) {

        return container.put(key, value);

    }

    /**

     * associates a key with a value in the cache hashmap.

     * @param key Key to map from

     * @param value Value to map to

     * @return previous value associated with the key, or null if unassociated before

     */

    public T putCache(String key, T value) {

        return cache.put(key, value);

    }

    /**

     * adds a map to the container

     */

    public void putAll(Map<? extends String, ? extends T> m) {

        container.putAll(m);

    }

    /**

     * removes a specific key's association from the container

     */

    public T remove(Object key) {

        return container.remove(key);

    }

    /**

     * returns the combined size of container and cache

     */

    public int size() {

        return container.size() + cache.size();

    }

    /**

     * returns the combined collection of both the values of the container as well as

     * the cache.

     */

    public Collection<T> values() {

        // prepare set

        HashSet<T> set = new HashSet<T>();

        // add all container values

        set.addAll(container.values());

        // add all cache values

        set.addAll(cache.values());

        return set;

    }

}

package org.apache.regexp.collections;

import java.util.HashMap;

import java.util.Iterator;

import org.apache.regexp.RE;

import org.apache.regexp.RESyntaxException;

/**

 * This map implementation uses a hashmap as the underlying storage.

 * Note that the keySet() method will return a set of regular expressions rather than actual keys.

 * The put() method uses a regexp as a key.

 * The get() method gets any value that matches one of the regexps.  If there is more than one matching regexp, the first one

 * encountered is returned - and hence could be indeterminate!

 *

 * @author Manik Surtani

 *

 */

public class RegexpKeyedMap extends HashMap

{

    public Object put(Object key, Object value)

    {

        if (key instanceof String)

            return super.put(key, value);

        else

            throw new RuntimeException("RegexpKeyedMap - only accepts Strings as keys.");

    }

    /**

     * The key passed in should always be a String.  The map will return the first element whose key, treated as a regular expression, matches the key passed in

     * NOTE: It is possible for this map to have more than one return value, for example, if a key is passed into get() which matches more than one regexp.

     *

     * E.g., consider the following keys in the map - '[A-Za-z]*' and 'Hello'.  Passing in 'Hello' as a key to the get() method would match either of the regexps,

     * and whichever apears first in the map (which is indeterminate) will be returned.

     *

     */

    public Object get(Object key)

    {

        Iterator regexps = keySet().iterator();

        String keyString;

        Object result = null;

        String stringToMatch = cleanKey( key );

        while (regexps.hasNext())

        {

            keyString = regexps.next().toString();

            try

            {

                RE regexp = new RE(keyString);

                if (regexp.match(stringToMatch))

                {

                    result = super.get(keyString);

                    break;

                }

            }

            catch (RESyntaxException e)

            {

                // invalid regexp.  ignore?

            }

        }

        return result;

    }

    /**

     * Strip any 'dirty' chars from the key we are searching for,

     * otherwise we end up with funny results from the RE

     *

     * @param obj

     * @return

     */

    private String cleanKey( Object obj )

    {

        String retVal = obj.toString();

        // remove any '^' from start of key - prevents the RE from matching !?!?

        return ( retVal.charAt(0) == '^' )  ? retVal.substring(1) : retVal;

    }

}