Dépôt officiel du code source de l'ERP OpenConcerto

/*

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.

 *

 * Copyright 2011 OpenConcerto, by ILM Informatique. All rights reserved.

 *

 * The contents of this file are subject to the terms of the GNU General Public License Version 3

 * only ("GPL"). You may not use this file except in compliance with the License. You can obtain a

 * copy of the License at http://www.gnu.org/licenses/gpl-3.0.html See the License for the specific

 * language governing permissions and limitations under the License.

 *

 * When distributing the software, include this License Header Notice in each file.

 */

 package org.openconcerto.utils.cache;

import org.openconcerto.utils.Log;

import org.openconcerto.utils.cache.CacheItem.RemovalType;

import org.openconcerto.utils.cache.CacheResult.State;

import org.openconcerto.utils.cc.IClosure;

import java.beans.PropertyChangeEvent;

import java.beans.PropertyChangeListener;

import java.beans.PropertyChangeSupport;

import java.util.ArrayList;

import java.util.Collections;

import java.util.HashMap;

import java.util.HashSet;

import java.util.LinkedHashMap;

import java.util.List;

import java.util.Map;

import java.util.Set;

import java.util.concurrent.TimeUnit;

import java.util.logging.Level;

import net.jcip.annotations.GuardedBy;

/**

 * To keep results computed from some data. The results will be automatically invalidated after some

 * period of time or when the data is modified.

 *

 * @author Sylvain CUAZ

 * @param <K> key type, eg String.

 * @param <V> value type, eg List of SQLRow.

 * @param <D> source data type, eg SQLTable.

 */

public class ICache<K, V, D> {

    private static final Level LEVEL = Level.FINEST;

    public static final String ITEMS_CHANGED = "itemsChanged";

    public static final String ITEM_ADDED = "itemAdded";

    public static final String ITEM_REMOVED = "itemRemoved";

    private final ICacheSupport<D> supp;

    // linked to fifo, ATTN the values in this map can be invalid since clear() is called without

    // the lock on CacheValue

    @GuardedBy("this")

    private final LinkedHashMap<K, CacheItem<K, V, D>> cache;

    @GuardedBy("this")

    private final Map<K, CacheItem<K, V, D>> running;

    private final int delay;

    private final int size;

    private final String name;

    private ICache<K, V, D> parent;

    private final PropertyChangeSupport propSupp = new PropertyChangeSupport(this);

    public ICache() {

        this(60);

    }

    public ICache(int delay) {

        this(delay, -1);

    }

    public ICache(int delay, int size) {

        this(delay, size, null);

    }

    /**

     * Creates a cache with the given parameters.

     *

     * @param delay the delay in seconds before a key is cleared.

     * @param size the maximum size of the cache, negative means no limit.

     * @param name name of this cache and associated thread.

     * @throws IllegalArgumentException if size is 0.

     */

    public ICache(int delay, int size, String name) {

        this(null, delay, size, name);

    }

    public ICache(final ICacheSupport<D> supp, int delay, int size, String name) {

        this.supp = supp == null ? createSupp(getCacheSuppName(name)) : supp;

        this.running = new HashMap<K, CacheItem<K, V, D>>();

        this.delay = delay;

        if (size == 0)

            throw new IllegalArgumentException("0 size");

        this.size = size;

        this.cache = new LinkedHashMap<K, CacheItem<K, V, D>>(size < 0 ? 64 : size);

        this.name = name;

        this.parent = null;

    }

    protected ICacheSupport<D> createSupp(final String name) {

        return new ICacheSupport<D>(name);

    }

    protected String getCacheSuppName(final String cacheName) {

        return cacheName;

    }

    public final ICacheSupport<D> getSupp() {

        return this.supp;

    }

    public final int getMaximumSize() {

        return this.size;

    }

    public final String getName() {

        return this.name;

    }

    /**

     * Allow to continue the search for a key in another instance.

     *

     * @param parent the cache to search when a key isn't found in this.

     */

    public final synchronized void setParent(final ICache<K, V, D> parent) {

        ICache<K, V, D> current = parent;

        while (current != null) {

            if (current == this)

                throw new IllegalArgumentException("Cycle detected, cannot set parent to " + parent);

            current = current.getParent();

        }

        this.parent = parent;

    }

    public final synchronized ICache<K, V, D> getParent() {

        return this.parent;

    }

    /**

     * If <code>sel</code> is in cache returns its value, else if key is running block until the key

     * is put (or the current thread is interrupted). Then if a {@link #setParent(ICache) parent}

     * has been set, use it. Otherwise the key is not in cache so return a CacheResult of state

     * {@link State#NOT_IN_CACHE}.

     *

     * @param sel the key we're getting the value for.

     * @return a CacheResult with the appropriate state.

     */

    public final CacheResult<V> get(K sel) {

        return this.get(sel, true);

    }

    private final CacheResult<V> get(K sel, final boolean checkRunning) {

        ICache<K, V, D> parent = null;

        synchronized (this) {

            final CacheResult<V> localRes = this.cache.containsKey(sel) ? this.cache.get(sel).getResult() : CacheResult.<V> getNotInCache();

            if (localRes.getState() == State.VALID) {

                log("IN cache", sel);

                return localRes;

            } else if (checkRunning && isRunning(sel)) {

                log("RUNNING", sel);

                try {

                    this.wait();

                } catch (InterruptedException e) {

                    // return sinon thread ne peut sortir que lorsque sel sera fini

                    return CacheResult.getInterrupted();

                }

                return this.get(sel);

            } else if (this.parent != null) {

                log("CALLING parent", sel);

                parent = this.parent;

            } else {

                log("NOT in cache", sel);

                return CacheResult.getNotInCache();

            }

        }

        // don't call our parent with our lock

        return parent.get(sel, false);

    }

    /**

     * Tell this cache that we're in process of getting the value for key, so if someone else ask

     * have them wait. ATTN after calling this method you MUST call put() or removeRunning(),

     * otherwise get() will always block for <code>key</code>.

     *

     * @param val the value that will receive the result.

     * @return <code>true</code> if the value was added, <code>false</code> if the key was already

     *         running.

     * @see #put(Object, Object, Set)

     * @see #removeRunning(Object)

     */

    private final synchronized boolean addRunning(final CacheItem<K, V, D> val) {

        if (!this.isRunning(val.getKey())) {

            // ATTN this can invalidate val

            val.addToWatchers();

            if (val.getRemovalType() == null) {

                this.running.put(val.getKey(), val);

                return true;

            }

        }

        return false;

    }

    // return null if the item wasn't added to this

    final CacheItem<K, V, D> getRunningValFromRes(final CacheResult<V> cacheRes) {

        if (cacheRes.getState() != CacheResult.State.NOT_IN_CACHE)

            throw new IllegalArgumentException("Wrong state : " + cacheRes.getState());

        if (cacheRes.getVal() == null) {

            // happens when check() is called and ICacheSupport is dead, i.e. this.running was not

            // modified and CacheResult.getNotInCache() was returned

            assert cacheRes == CacheResult.getNotInCache();

        } else {

            if (cacheRes.getVal().getCache() != this)

                throw new IllegalArgumentException("Not running in this cache");

            assert cacheRes.getVal().getState() == CacheItem.State.RUNNING || cacheRes.getVal().getState() == CacheItem.State.INVALID;

        }

        @SuppressWarnings("unchecked")

        final CacheItem<K, V, D> res = (CacheItem<K, V, D>) cacheRes.getVal();

        return res;

    }

    public final synchronized void removeRunning(final CacheResult<V> res) {

        removeRunning(getRunningValFromRes(res));

    }

    private final synchronized boolean removeRunning(final CacheItem<K, V, D> val) {

        if (val == null)

            return false;

        final K key = val.getKey();

        final boolean removed;

        if (this.running.get(key) == val) {

            this.removeRunning(key);

            removed = true;

        } else {

            // either val wasn't created in this cache or another value was already put in this

            // cache

            removed = val.setRemovalType(RemovalType.EXPLICIT);

        }

        assert val.getRemovalType() != null;

        return removed;

    }

    private final synchronized void removeRunning(K key) {

        final CacheItem<K, V, D> removed = this.running.remove(key);

        if (removed != null) {

            // if the removed value isn't in us (this happens if put() is called without passing the

            // value returned by check()), kill it so that it stops listening to its data

            if (this.cache.get(key) != removed)

                removed.setRemovalType(RemovalType.EXPLICIT);

            this.notifyAll();

        }

    }

    public final synchronized boolean isRunning(K sel) {

        return this.running.containsKey(sel);

    }

    public final synchronized Set<K> getRunning() {

        return Collections.unmodifiableSet(new HashSet<K>(this.running.keySet()));

    }

    /**

     * Check if key is in cache, in that case returns the value otherwise adds key to running and

     * returns <code>NOT_IN_CACHE</code>.

     *

     * @param key the key to be checked.

     * @return the associated value, never <code>null</code>.

     * @see #addRunning(Object)

     * @see #removeRunning(CacheResult)

     * @see #put(CacheResult, Object, long)

     */

    public final CacheResult<V> check(K key) {

        return this.check(key, Collections.<D> emptySet());

    }

    public final CacheResult<V> check(K key, final Set<? extends D> data) {

        return this.check(key, true, true, data);

    }

    public final CacheResult<V> check(K key, final boolean readCache, final boolean willWriteToCache, final Set<? extends D> data) {

        return this.check(key, readCache, willWriteToCache, data, this.delay * 1000);

    }

    public final synchronized CacheResult<V> check(K key, final boolean readCache, final boolean willWriteToCache, final Set<? extends D> data, final long timeout) {

        final CacheResult<V> l = readCache ? this.get(key) : CacheResult.<V> getNotInCache();

        if (willWriteToCache && l.getState() == State.NOT_IN_CACHE) {

            final CacheItem<K, V, D> val = new CacheItem<K, V, D>(this, key, data);

            if (this.addRunning(val)) {

                val.addTimeout(timeout, TimeUnit.MILLISECONDS);

                return new CacheResult<V>(val);

            } else {

                // val was never referenced so it will be garbage collected

                assert !val.getState().isActive() : "active value : " + val;

            }

        }

        return l;

    }

    /**

     * Put a result which doesn't depend on variable data in this cache.

     *

     * @param sel the key.

     * @param res the result associated with <code>sel</code>.

     * @return the item that was created.

     */

    public final CacheItem<K, V, D> put(K sel, V res) {

        return this.put(sel, res, Collections.<D> emptySet());

    }

    /**

     * Put a result in this cache.

     *

     * @param sel the key.

     * @param res the result associated with <code>sel</code>.

     * @param data the data from which <code>res</code> is computed.

     * @return the item that was created.

     */

    public final CacheItem<K, V, D> put(K sel, V res, Set<? extends D> data) {

        return this.put(sel, res, data, this.delay * 1000);

    }

    public final CacheItem<K, V, D> put(K sel, V res, Set<? extends D> data, final long timeoutDelay) {

        return this.put(sel, true, res, data, timeoutDelay);

    }

    private final CacheItem<K, V, D> put(K key, final boolean allowReplace, V res, Set<? extends D> data, final long timeoutDelay) {

        final CacheItem<K, V, D> item = new CacheItem<K, V, D>(this, key, res, data);

        item.addTimeout(timeoutDelay, TimeUnit.MILLISECONDS);

        item.addToWatchers();

        return put(item, allowReplace);

    }

    /**

     * Assign a value to a {@link CacheItem.State#RUNNING} item.

     *

     * @param cacheRes an instance obtained from <code>check()</code>.

     * @param val the value to store.

     * @return the item that was added, <code>null</code> if none was added.

     * @see #check(Object, boolean, boolean, Set)

     */

    public final CacheItem<K, V, D> put(CacheResult<V> cacheRes, V val) {

        final CacheItem<K, V, D> item = getRunningValFromRes(cacheRes);

        if (item == null)

            return null;

        item.setValue(val);

        return put(item, true);

    }

    private final CacheItem<K, V, D> put(final CacheItem<K, V, D> val, final boolean allowReplace) {

        final K sel = val.getKey();

        synchronized (this) {

            final CacheItem.State valState = val.getState();

            if (!valState.isActive())

                return null;

            else if (valState != CacheItem.State.VALID)

                throw new IllegalStateException("Non valid : " + val);

            final boolean replacing = this.cache.containsKey(sel) && this.cache.get(sel).getRemovalType() == null;

            if (!allowReplace && replacing)

                return null;

            if (!replacing && this.size > 0 && this.cache.size() == this.size)

                this.cache.values().iterator().next().setRemovalType(RemovalType.SIZE_LIMIT);

            final CacheItem<K, V, D> prev = this.cache.put(sel, val);

            if (replacing)

                prev.setRemovalType(RemovalType.DATA_CHANGE);

            assert this.size <= 0 || this.cache.size() <= this.size;

            this.removeRunning(sel);

        }

        this.propSupp.firePropertyChange(new Event<K, V, D>(this, ITEMS_CHANGED, null, null));

        this.propSupp.firePropertyChange(this.createItemEvent(ITEM_ADDED, null, val));

        return val;

    }

    /**

     * Get the remaining time before the passed key will be removed.

     *

     * @param key the key.

     * @return the remaining milliseconds before the removal, negative if the passed key isn't in

     *         this.

     * @see #getRemovalTime(Object)

     */

    public final long getRemainingTime(K key) {

        final CacheItem<K, V, D> val;

        synchronized (this) {

            val = this.cache.get(key);

        }

        if (val == null)

            return -1;

        return val.getRemainingTimeoutDelay();

    }

    public final void putAll(final ICache<K, V, D> otherCache, final boolean allowReplace) {

        if (otherCache == this)

            return;

        if (otherCache.getSupp() != this.getSupp())

            Log.get().warning("Since both caches don't share watchers, some early events might not be notified to this cache");

        final List<CacheItem<K, V, D>> oItems = new ArrayList<CacheItem<K, V, D>>();

        synchronized (otherCache) {

            oItems.addAll(otherCache.cache.values());

        }

        for (final CacheItem<K, V, D> oItem : oItems) {

            final CacheItem<K, V, D> newItem = this.put(oItem.getKey(), allowReplace, oItem.getValue(), oItem.getData(), oItem.getRemainingTimeoutDelay());

            // if oItem was changed before newItem was created or see CacheWatcher.dataChanged() :

            // 1. if newItem was added to a watcher before the first synchronized block, it will be

            // notified

            // 2. if newItem was added between the synchronized blocks (during the first iteration)

            // it will be notified by the second iteration

            // 3. if newItem was added after the second synchronized block, oItem will already be

            // notified

            if (newItem != null && oItem.getRemovalType() == RemovalType.DATA_CHANGE) {

                newItem.setRemovalType(oItem.getRemovalType());

            }

        }

    }

    public final ICache<K, V, D> copy(final String name, final boolean copyItems) {

        final ICache<K, V, D> res = new ICache<K, V, D>(this.getSupp(), this.delay, this.getMaximumSize(), name);

        if (copyItems)

            res.putAll(this, false);

        return res;

    }

    public final synchronized void clear(K select) {

        log("clear", select);

        if (this.cache.containsKey(select)) {

            this.cache.get(select).setRemovalType(RemovalType.EXPLICIT);

        }

    }

    final boolean clear(final CacheItem<K, V, D> val) {

        if (val.getRemovalType() == null)

            throw new IllegalStateException("Not yet removed : " + val);

        final boolean removedFromRunning, toBeRemoved;

        synchronized (this) {

            log("clear", val);

            removedFromRunning = this.removeRunning(val);

            toBeRemoved = this.cache.get(val.getKey()) == val;

            if (toBeRemoved) {

                this.cache.remove(val.getKey());

            }

        }

        // NOTE these events are often fired with our monitor since this method is called with it

        if (removedFromRunning || toBeRemoved) {

            this.propSupp.firePropertyChange(new Event<K, V, D>(this, ITEMS_CHANGED, null, null));

            this.propSupp.firePropertyChange(this.createItemEvent(ITEM_REMOVED, val, null));

        }

        return toBeRemoved;

    }

    public final synchronized void clear() {

        for (final CacheItem<K, V, D> val : new ArrayList<CacheItem<K, V, D>>(this.cache.values())) {

            // We have our monitor so if val is still in us but setRemovalType() was already called,

            // then it means another thread is waiting on our monitor in clear(CacheItem). In that

            // case, just call it now so that this is empty at the end of this method.

            if (!val.setRemovalType(RemovalType.EXPLICIT)) {

                final boolean removed = this.clear(val);

                assert removed;

            }

        }

        assert this.size() == 0 : this + " expected to be empty but contains : " + this.cache.keySet();

        for (final CacheItem<K, V, D> val : new ArrayList<CacheItem<K, V, D>>(this.running.values()))

            val.setRemovalType(RemovalType.EXPLICIT);

        assert this.running.size() == 0 : this + " expected to have no running but contains : " + this.running.keySet();

    }

    private final void log(String msg, Object subject) {

        // do the toString() on subject only if necessary

        if (Log.get().isLoggable(LEVEL))

            Log.get().log(LEVEL, msg + ": " + subject);

    }

    public final synchronized int size() {

        return this.cache.size();

    }

    static public class Event<K, V, D> extends PropertyChangeEvent {

        public Event(ICache<K, V, D> source, String propertyName, Object oldValue, Object newValue) {

            super(source, propertyName, oldValue, newValue);

        }

        @SuppressWarnings("unchecked")

        @Override

        public ICache<K, V, D> getSource() {

            return (ICache<K, V, D>) super.getSource();

        }

    }

    private final Event<K, V, D> castEvent(final PropertyChangeEvent evt) {

        final Event<?, ?, ?> casted = (Event<?, ?, ?>) evt;

        // Needed sine this method can be called from outside this class

        // Only other option is to not use PropertyChangeSupport, and create our own generics-aware

        // version

        if (casted.getSource() != ICache.this)

            throw new IllegalArgumentException("Cannot uphold type safety");

        @SuppressWarnings("unchecked")

        final Event<K, V, D> res = (Event<K, V, D>) casted;

        return res;

    }

    private ItemEvent<K, V, D> createItemEvent(String propertyName, CacheItem<K, V, D> oldValue, CacheItem<K, V, D> newValue) {

        if (oldValue == null && newValue == null)

            throw new IllegalArgumentException("No values");

        assert (oldValue == null || oldValue.getCache() == this);

        assert (newValue == null || newValue.getCache() == this);

        return new ItemEvent<K, V, D>(this, propertyName, oldValue, newValue);

    }

    static public class ItemEvent<K, V, D> extends Event<K, V, D> {

        // ATTN doesn't check parameters

        private ItemEvent(ICache<K, V, D> source, String propertyName, CacheItem<K, V, D> oldValue, CacheItem<K, V, D> newValue) {

            super(source, propertyName, oldValue, newValue);

        }

        @SuppressWarnings("unchecked")

        @Override

        public CacheItem<K, V, D> getOldValue() {

            return (CacheItem<K, V, D>) super.getOldValue();

        }

        @SuppressWarnings("unchecked")

        @Override

        public CacheItem<K, V, D> getNewValue() {

            return (CacheItem<K, V, D>) super.getNewValue();

        }

    }

    public final PropertyChangeListener addItemListener(final IClosure<? super ItemEvent<K, V, D>> listener) {

        return addListener(new PropertyChangeListener() {

            @Override

            public void propertyChange(PropertyChangeEvent evt) {

                if (evt instanceof ItemEvent)

                    listener.executeChecked((ItemEvent<K, V, D>) castEvent(evt));

            }

        });

    }

    public final PropertyChangeListener addListener(final IClosure<? super Event<K, V, D>> listener) {

        return addListener(new PropertyChangeListener() {

            @Override

            public void propertyChange(PropertyChangeEvent evt) {

                listener.executeChecked(castEvent(evt));

            }

        });

    }

    public final PropertyChangeListener addListener(final PropertyChangeListener listener) {

        this.propSupp.addPropertyChangeListener(listener);

        return listener;

    }

    public final void removeListener(final PropertyChangeListener listener) {

        this.propSupp.removePropertyChangeListener(listener);

    }

    @Override

    public final String toString() {

        return this.toString(false);

    }

    public final String toString(final boolean withKeys) {

        final String keys;

        if (withKeys) {

            synchronized (this) {

                keys = ", keys cached: " + this.cache.keySet().toString();

            }

        } else {

            keys = "";

        }

        return this.getClass().getName() + " '" + this.getName() + "'" + keys;

    }

}