package org.apidesign.javamonitorflaws;

import java.util.HashMap;

import java.util.Map;

/** Classical caching support class that makes sure there is

 * always one "To" value for each "From" one returned from the {@link #get}

 * method. However it does not prevent multiple threads to call

 * {@link #createItem} multiple times for the same "From" value.

 * <p>

 * In contrast to {@link Cache}, this is correctly synchronized.

 *

 * @author Jaroslav Tulach <jtulach@netbeans.org>

 */

// BEGIN: monitor.pitfalls.CacheOK

public abstract class CacheOK<From,To> {

    private final Object LOCK = new Object();

    private Map<From,To> cache;

    protected abstract To createItem(From f);

    public final To get(From f) {

        To t = inspectValue(f);

        if (t != null) {

            return t;

        }

        To newT = createItem(f);

        return registerValue(f, newT);

    }

    private To inspectValue(From f) {

        synchronized (LOCK) {

            if (cache == null) {

                cache = new HashMap<From, To>();

            }

            return cache.get(f);

        }

    }

    private To registerValue(From f, To newT) {

        synchronized (LOCK) {

            To t = cache.get(f);

            if (t == null) {

                cache.put(f, newT);

                return newT;

            } else {

                return t;

            }

        }

    }

}

// END: monitor.pitfalls.CacheOK