001/**
002 * Licensed to the Apache Software Foundation (ASF) under one or more
003 * contributor license agreements.  See the NOTICE file distributed with
004 * this work for additional information regarding copyright ownership.
005 * The ASF licenses this file to You under the Apache License, Version 2.0
006 * (the "License"); you may not use this file except in compliance with
007 * the License.  You may obtain a copy of the License at
008 *
009 *      http://www.apache.org/licenses/LICENSE-2.0
010 *
011 * Unless required by applicable law or agreed to in writing, software
012 * distributed under the License is distributed on an "AS IS" BASIS,
013 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
014 * See the License for the specific language governing permissions and
015 * limitations under the License.
016 */
017package org.apache.activemq.util;
018
019import java.util.AbstractSet;
020import java.util.Iterator;
021import java.util.Set;
022
023/**
024 * A Simple LRU Set
025 * 
026 * 
027 * @param <K>
028 * @param <V>
029 */
030
031public class LRUSet<E>
032extends AbstractSet<E>
033implements Set<E>, Cloneable, java.io.Serializable{
034   
035    private static final Object IGNORE = new Object();
036   
037    private final LRUCache cache;
038
039    /**
040     * Default constructor for an LRU Cache The default capacity is 10000
041     */
042    public LRUSet() {
043        this(0,10000, 0.75f, true);
044    }
045
046    /**
047     * Constructs a LRUCache with a maximum capacity
048     * 
049     * @param maximumCacheSize
050     */
051    public LRUSet(int maximumCacheSize) {
052        this(0, maximumCacheSize, 0.75f, true);
053    }
054
055    /**
056     * Constructs an empty <tt>LRUCache</tt> instance with the specified
057     * initial capacity, maximumCacheSize,load factor and ordering mode.
058     * 
059     * @param initialCapacity
060     *            the initial capacity.
061     * @param maximumCacheSize
062     * @param loadFactor
063     *            the load factor.
064     * @param accessOrder
065     *            the ordering mode - <tt>true</tt> for access-order,
066     *            <tt>false</tt> for insertion-order.
067     * @throws IllegalArgumentException
068     *             if the initial capacity is negative or the load factor is
069     *             non-positive.
070     */
071
072    public LRUSet(int initialCapacity, int maximumCacheSize, float loadFactor, boolean accessOrder) {
073        this.cache = new LRUCache<E,Object>(initialCapacity,maximumCacheSize,loadFactor,accessOrder);
074    }
075
076   
077    public Iterator<E> iterator() {
078    return cache.keySet().iterator();
079    }
080
081   
082    public int size() {
083    return cache.size();
084    }
085
086   
087    public boolean isEmpty() {
088    return cache.isEmpty();
089    }
090
091    public boolean contains(Object o) {
092    return cache.containsKey(o);
093    }
094
095   
096    public boolean add(E o) {
097    return cache.put(o, IGNORE)==null;
098    }
099
100    public boolean remove(Object o) {
101    return cache.remove(o)==IGNORE;
102    }
103
104    
105    public void clear() {
106    cache.clear();
107    }
108
109    
110
111    
112      
113}