org.jactr.core.utils.collections.CachedMap.java Source code

Introduction

Here is the source code for org.jactr.core.utils.collections.CachedMap.java

Source

/*
 * Created on Oct 13, 2006 Copyright (C) 2001-6, Anthony Harrison anh23@pitt.edu
 * (jactr.org) This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public License as
 * published by the Free Software Foundation; either version 2.1 of the License,
 * or (at your option) any later version. This library 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
 * library; if not, write to the Free Software Foundation, Inc., 59 Temple
 * Place, Suite 330, Boston, MA 02111-1307 USA
 */
package org.jactr.core.utils.collections;

import java.lang.ref.SoftReference;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Map;
import java.util.Set;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

/**
 * cached values map for rapid access w/o worrying about iterating too
 * much..
 * @author developer
 *
 * @param <K>
 * @param <V>
 */
public class CachedMap<K, V> implements Map<K, V> {
    /**
     * logger definition
     */
    static private final Log LOGGER = LogFactory.getLog(CachedMap.class);

    private Map<K, V> _backingMap;

    private SoftReference<Collection<V>> _cachedValuesReference;

    public CachedMap(Map<K, V> backing) {
        _backingMap = backing;
    }

    synchronized protected void clearCachedValues() {
        _cachedValuesReference = null;
    }

    synchronized protected Collection<V> getCachedValues() {
        Collection<V> rtn = null;
        if (_cachedValuesReference == null || (rtn = _cachedValuesReference.get()) == null) {
            rtn = Collections.unmodifiableCollection(new ArrayList<V>(_backingMap.values()));
            _cachedValuesReference = new SoftReference<Collection<V>>(rtn);
        }
        return rtn;
    }

    synchronized public void clear() {
        _backingMap.clear();
        clearCachedValues();
    }

    synchronized public boolean containsKey(Object arg0) {
        return _backingMap.containsKey(arg0);
    }

    synchronized public boolean containsValue(Object arg0) {
        return _backingMap.containsValue(arg0);
    }

    public Set<java.util.Map.Entry<K, V>> entrySet() {
        // TODO Auto-generated method stub
        if (LOGGER.isWarnEnabled())
            LOGGER.warn("CachedMap.entrySet is not implemented");
        return null;
    }

    synchronized public V get(Object arg0) {
        return _backingMap.get(arg0);
    }

    synchronized public boolean isEmpty() {
        return _backingMap.isEmpty();
    }

    synchronized public Set<K> keySet() {
        return _backingMap.keySet();
    }

    synchronized public V put(K arg0, V arg1) {
        V rtn = _backingMap.put(arg0, arg1);
        clearCachedValues();
        return rtn;
    }

    synchronized public void putAll(Map<? extends K, ? extends V> arg0) {
        _backingMap.putAll(arg0);
        clearCachedValues();
    }

    synchronized public V remove(Object arg0) {
        V rtn = _backingMap.remove(arg0);
        clearCachedValues();
        return rtn;
    }

    synchronized public int size() {
        return _backingMap.size();
    }

    synchronized public Collection<V> values() {
        return getCachedValues();
    }

    synchronized public void getValues(Collection<V> container) {
        container.addAll(_backingMap.values());
    }
}