299 lines
9.2 KiB
Java
299 lines
9.2 KiB
Java
/*
|
|
* This is the source code of Telegram for Android v. 1.3.2.
|
|
* It is licensed under GNU GPL v. 2 or later.
|
|
* You should have received a copy of the license in this archive (see LICENSE).
|
|
*
|
|
* Copyright Nikolai Kudashov, 2013.
|
|
*/
|
|
|
|
package org.telegram.messenger;
|
|
|
|
import android.graphics.Bitmap;
|
|
|
|
import java.util.ArrayList;
|
|
import java.util.LinkedHashMap;
|
|
import java.util.Map;
|
|
|
|
/**
|
|
* Static library version of {@link android.util.LruCache}. Used to write apps
|
|
* that run on API levels prior to 12. When running on API level 12 or above,
|
|
* this implementation is still used; it does not try to switch to the
|
|
* framework's implementation. See the framework SDK documentation for a class
|
|
* overview.
|
|
*/
|
|
public class LruCache {
|
|
private final LinkedHashMap<String, Bitmap> map;
|
|
private final LinkedHashMap<String, ArrayList<String>> mapFilters;
|
|
|
|
/** Size of this cache in units. Not necessarily the number of elements. */
|
|
private int size;
|
|
private int maxSize;
|
|
|
|
private int putCount;
|
|
private int evictionCount;
|
|
private int hitCount;
|
|
private int missCount;
|
|
|
|
/**
|
|
* @param maxSize for caches that do not override {@link #sizeOf}, this is
|
|
* the maximum number of entries in the cache. For all other caches,
|
|
* this is the maximum sum of the sizes of the entries in this cache.
|
|
*/
|
|
public LruCache(int maxSize) {
|
|
if (maxSize <= 0) {
|
|
throw new IllegalArgumentException("maxSize <= 0");
|
|
}
|
|
this.maxSize = maxSize;
|
|
this.map = new LinkedHashMap<String, Bitmap>(0, 0.75f, true);
|
|
this.mapFilters = new LinkedHashMap<String, ArrayList<String>>();
|
|
}
|
|
|
|
/**
|
|
* Returns the value for {@code key} if it exists in the cache or can be
|
|
* created by {@code #create}. If a value was returned, it is moved to the
|
|
* head of the queue. This returns null if a value is not cached and cannot
|
|
* be created.
|
|
*/
|
|
public final Bitmap get(String key) {
|
|
if (key == null) {
|
|
throw new NullPointerException("key == null");
|
|
}
|
|
|
|
Bitmap mapValue;
|
|
synchronized (this) {
|
|
mapValue = map.get(key);
|
|
if (mapValue != null) {
|
|
hitCount++;
|
|
return mapValue;
|
|
}
|
|
missCount++;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public ArrayList<String> getFilterKeys(String key) {
|
|
ArrayList<String> arr = mapFilters.get(key);
|
|
if (arr != null) {
|
|
return new ArrayList<String>(arr);
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* Caches {@code value} for {@code key}. The value is moved to the head of
|
|
* the queue.
|
|
*
|
|
* @return the previous value mapped by {@code key}.
|
|
*/
|
|
public Bitmap put(String key, Bitmap value) {
|
|
if (key == null || value == null) {
|
|
throw new NullPointerException("key == null || value == null");
|
|
}
|
|
|
|
Bitmap previous;
|
|
synchronized (this) {
|
|
putCount++;
|
|
size += safeSizeOf(key, value);
|
|
previous = map.put(key, value);
|
|
if (previous != null) {
|
|
size -= safeSizeOf(key, previous);
|
|
}
|
|
}
|
|
|
|
String[] args = key.split("@");
|
|
if (args.length > 1) {
|
|
ArrayList<String> arr = mapFilters.get(args[0]);
|
|
if (arr == null) {
|
|
arr = new ArrayList<String>();
|
|
mapFilters.put(args[0], arr);
|
|
}
|
|
arr.add(args[1]);
|
|
}
|
|
|
|
if (previous != null) {
|
|
entryRemoved(false, key, previous, value);
|
|
}
|
|
|
|
trimToSize(maxSize);
|
|
return previous;
|
|
}
|
|
|
|
/**
|
|
* @param maxSize the maximum size of the cache before returning. May be -1
|
|
* to evict even 0-sized elements.
|
|
*/
|
|
private void trimToSize(int maxSize) {
|
|
while (true) {
|
|
String key;
|
|
Bitmap value;
|
|
synchronized (this) {
|
|
if (size < 0 || (map.isEmpty() && size != 0)) {
|
|
throw new IllegalStateException(getClass().getName()
|
|
+ ".sizeOf() is reporting inconsistent results!");
|
|
}
|
|
|
|
if (size <= maxSize || map.isEmpty()) {
|
|
break;
|
|
}
|
|
|
|
Map.Entry<String, Bitmap> toEvict = map.entrySet().iterator().next();
|
|
key = toEvict.getKey();
|
|
value = toEvict.getValue();
|
|
map.remove(key);
|
|
size -= safeSizeOf(key, value);
|
|
evictionCount++;
|
|
}
|
|
|
|
String[] args = key.split("@");
|
|
if (args.length > 1) {
|
|
ArrayList<String> arr = mapFilters.get(args[0]);
|
|
if (arr != null) {
|
|
arr.remove(key);
|
|
if (arr.isEmpty()) {
|
|
mapFilters.remove(args[1]);
|
|
}
|
|
}
|
|
}
|
|
|
|
entryRemoved(true, key, value, null);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Removes the entry for {@code key} if it exists.
|
|
*
|
|
* @return the previous value mapped by {@code key}.
|
|
*/
|
|
public final Bitmap remove(String key) {
|
|
if (key == null) {
|
|
throw new NullPointerException("key == null");
|
|
}
|
|
|
|
Bitmap previous;
|
|
synchronized (this) {
|
|
previous = map.remove(key);
|
|
if (previous != null) {
|
|
size -= safeSizeOf(key, previous);
|
|
}
|
|
}
|
|
|
|
if (previous != null) {
|
|
String[] args = key.split("@");
|
|
if (args.length > 1) {
|
|
ArrayList<String> arr = mapFilters.get(args[0]);
|
|
if (arr != null) {
|
|
arr.remove(key);
|
|
if (arr.isEmpty()) {
|
|
mapFilters.remove(args[1]);
|
|
}
|
|
}
|
|
}
|
|
|
|
entryRemoved(false, key, previous, null);
|
|
}
|
|
|
|
return previous;
|
|
}
|
|
|
|
public boolean contains(String key){
|
|
return map.containsKey(key);
|
|
}
|
|
|
|
/**
|
|
* Called for entries that have been evicted or removed. This method is
|
|
* invoked when a value is evicted to make space, removed by a call to
|
|
* {@link #remove}, or replaced by a call to {@link #put}. The default
|
|
* implementation does nothing.
|
|
*
|
|
* <p>The method is called without synchronization: other threads may
|
|
* access the cache while this method is executing.
|
|
*
|
|
* @param evicted true if the entry is being removed to make space, false
|
|
* if the removal was caused by a {@link #put} or {@link #remove}.
|
|
* @param newValue the new value for {@code key}, if it exists. If non-null,
|
|
* this removal was caused by a {@link #put}. Otherwise it was caused by
|
|
* an eviction or a {@link #remove}.
|
|
*/
|
|
protected void entryRemoved(boolean evicted, String key, Bitmap oldValue, Bitmap newValue) {}
|
|
|
|
private int safeSizeOf(String key, Bitmap value) {
|
|
int result = sizeOf(key, value);
|
|
if (result < 0) {
|
|
throw new IllegalStateException("Negative size: " + key + "=" + value);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Returns the size of the entry for {@code key} and {@code value} in
|
|
* user-defined units. The default implementation returns 1 so that size
|
|
* is the number of entries and max size is the maximum number of entries.
|
|
*
|
|
* <p>An entry's size must not change while it is in the cache.
|
|
*/
|
|
protected int sizeOf(String key, Bitmap value) {
|
|
return 1;
|
|
}
|
|
|
|
/**
|
|
* Clear the cache, calling {@link #entryRemoved} on each removed entry.
|
|
*/
|
|
public final void evictAll() {
|
|
trimToSize(-1); // -1 will evict 0-sized elements
|
|
}
|
|
|
|
/**
|
|
* For caches that do not override {@link #sizeOf}, this returns the number
|
|
* of entries in the cache. For all other caches, this returns the sum of
|
|
* the sizes of the entries in this cache.
|
|
*/
|
|
public synchronized final int size() {
|
|
return size;
|
|
}
|
|
|
|
/**
|
|
* For caches that do not override {@link #sizeOf}, this returns the maximum
|
|
* number of entries in the cache. For all other caches, this returns the
|
|
* maximum sum of the sizes of the entries in this cache.
|
|
*/
|
|
public synchronized final int maxSize() {
|
|
return maxSize;
|
|
}
|
|
|
|
/**
|
|
* Returns the number of times {@link #get} returned a value.
|
|
*/
|
|
public synchronized final int hitCount() {
|
|
return hitCount;
|
|
}
|
|
|
|
/**
|
|
* Returns the number of times {@link #get} returned null or required a new
|
|
* value to be created.
|
|
*/
|
|
public synchronized final int missCount() {
|
|
return missCount;
|
|
}
|
|
|
|
/**
|
|
* Returns the number of times {@link #put} was called.
|
|
*/
|
|
public synchronized final int putCount() {
|
|
return putCount;
|
|
}
|
|
|
|
/**
|
|
* Returns the number of values that have been evicted.
|
|
*/
|
|
public synchronized final int evictionCount() {
|
|
return evictionCount;
|
|
}
|
|
|
|
@Override public synchronized final String toString() {
|
|
int accesses = hitCount + missCount;
|
|
int hitPercent = accesses != 0 ? (100 * hitCount / accesses) : 0;
|
|
return String.format("LruCache[maxSize=%d,hits=%d,misses=%d,hitRate=%d%%]",
|
|
maxSize, hitCount, missCount, hitPercent);
|
|
}
|
|
}
|