Cosmetics.

core/org.eclipse.cdt.core/model/org/eclipse/cdt/internal/core/util/LRUCache.java

@@ -10,8 +10,6 @@
  *******************************************************************************/
 package org.eclipse.cdt.internal.core.util;
 
-
-
 import java.util.Enumeration;
 import java.util.Hashtable;
 
@@ -43,7 +41,6 @@ public class LRUCache<K,T> implements Cloneable {
 	 * @see LRUCache
 	 */
 	protected static class LRUCacheEntry<K, T> {
-		
 		/**
 		 * Hash table key
 		 */
@@ -89,7 +86,6 @@ public class LRUCache<K,T> implements Cloneable {
 		 */
 		@Override
 		public String toString() {
-
 			return "LRUCacheEntry [" + _fKey + "-->" + _fValue + "]"; //$NON-NLS-3$ //$NON-NLS-1$ //$NON-NLS-2$
 		}
 	}	
@@ -128,25 +124,26 @@ public class LRUCache<K,T> implements Cloneable {
 	 * Default amount of space in the cache
 	 */
 	protected static final int DEFAULT_SPACELIMIT = 100;
+
 	/**
 	 * Creates a new cache.  Size of cache is defined by 
 	 * <code>DEFAULT_SPACELIMIT</code>.
 	 */
 	public LRUCache() {
-		
 		this(DEFAULT_SPACELIMIT);
 	}
+
 	/**
 	 * Creates a new cache.
 	 * @param size Size of Cache
 	 */
 	public LRUCache(int size) {
-		
 		fTimestampCounter = fCurrentSpace = 0;
 		fEntryQueue = fEntryQueueTail = null;
 		fEntryTable = new Hashtable<K,LRUCacheEntry<K, T>>(size);
 		fSpaceLimit = size;
 	}
+
 	/**
 	 * Returns a new cache containing the same contents.
 	 *
@@ -154,7 +151,6 @@ public class LRUCache<K,T> implements Cloneable {
 	 */
 	@Override
 	public Object clone() {
-		
 		LRUCache<K, T> newCache = newInstance(fSpaceLimit);
 		LRUCacheEntry<K, T> qEntry;
 		
@@ -166,11 +162,11 @@ public class LRUCache<K,T> implements Cloneable {
 		}
 		return newCache;
 	}
+
 	/**
 	 * Flushes all entries from the cache.
 	 */
 	public void flush() {
-
 		fCurrentSpace = 0;
 		LRUCacheEntry<K, T> entry = fEntryQueueTail; // Remember last entry
 		fEntryTable = new Hashtable<K,LRUCacheEntry<K, T>>();  // Clear it out
@@ -180,6 +176,7 @@ public class LRUCache<K,T> implements Cloneable {
 			entry = entry._fPrevious;
 		}
 	}
+
 	/**
 	 * Flushes the given entry from the cache.  Does nothing if entry does not
 	 * exist in cache.
@@ -187,25 +184,23 @@ public class LRUCache<K,T> implements Cloneable {
 	 * @param key Key of object to flush
 	 */
 	public void flush(Object key) {
-		
-		LRUCacheEntry<K,T> entry;
-		
-		entry = fEntryTable.get(key);
-
+		LRUCacheEntry<K, T> entry = fEntryTable.get(key);
 		/* If entry does not exist, return */
-		if (entry == null) return;
+		if (entry == null) {
+			return;
+		}
 
 		this.privateRemoveEntry(entry, false);
 	}
+
 	/**
 	 * Answers the value in the cache at the given key.
 	 * If the value is not in the cache, returns null
 	 *
 	 * @param key Hash table key of object to retrieve
-	 * @return Retreived object, or null if object does not exist
+	 * @return Retrieved object, or null if object does not exist
 	 */
 	public Object get(Object key) {
-		
 		LRUCacheEntry<K, T> entry = fEntryTable.get(key);
 		if (entry == null) {
 			return null;
@@ -214,25 +209,28 @@ public class LRUCache<K,T> implements Cloneable {
 		this.updateTimestamp(entry);
 		return entry._fValue;
 	}
+
 	/**
 	 * Returns the amount of space that is current used in the cache.
 	 */
 	public int getCurrentSpace() {
 		return fCurrentSpace;
 	}
+
 	/**
 	 * Returns the maximum amount of space available in the cache.
 	 */
 	public int getSpaceLimit() {
 		return fSpaceLimit;
 	}
+
 	/**
 	 * Returns an Enumeration of the keys currently in the cache.
 	 */
 	public Enumeration<K> keys() {
-		
 		return fEntryTable.keys();
 	}
+
     /**
      * Tests if this cache is empty.
      */
@@ -248,10 +246,7 @@ public class LRUCache<K,T> implements Cloneable {
 	 * @param space Amount of space to free up
 	 */
 	protected boolean makeSpace(int space) {
-		
-		int limit;
-		
-		limit = this.getSpaceLimit();
+		int limit = this.getSpaceLimit();
 		
 		/* if space is already available */
 		if (fCurrentSpace + space <= limit) {
@@ -269,29 +264,28 @@ public class LRUCache<K,T> implements Cloneable {
 		}
 		return true;
 	}
+
 	/**
 	 * Returns a new LRUCache instance
 	 */
 	protected LRUCache<K, T> newInstance(int size) {
 		return new LRUCache<K, T>(size);
 	}
+
 	/**
 	 * Adds an entry for the given key/value/space.
 	 */
 	protected void privateAdd(K key, T value, int space) {
-		
-		LRUCacheEntry<K,T> entry;
-		
-		entry = new LRUCacheEntry<K,T>(key, value, space);
+		LRUCacheEntry<K, T> entry = new LRUCacheEntry<K, T>(key, value, space);
 		this.privateAddEntry(entry, false);
 	}
+
 	/**
 	 * Adds the given entry from the receiver.
 	 * @param shuffle Indicates whether we are just shuffling the queue 
 	 * (i.e., the entry table is left alone).
 	 */
 	protected void privateAddEntry(LRUCacheEntry<K, T> entry, boolean shuffle) {
-		
 		if (!shuffle) {
 			fEntryTable.put(entry._fKey, entry);
 			fCurrentSpace += entry._fSpace;
@@ -310,6 +304,7 @@ public class LRUCache<K,T> implements Cloneable {
 		
 		fEntryQueue = entry;
 	}
+
 	/**
 	 * An entry has been removed from the cache, for example because it has 
 	 * fallen off the bottom of the LRU queue.  
@@ -318,17 +313,15 @@ public class LRUCache<K,T> implements Cloneable {
 	protected void privateNotifyDeletionFromCache(LRUCacheEntry<K, T> entry) {
 		// Default is NOP.
 	}
+
 	/**
 	 * Removes the entry from the entry queue.  
 	 * @param shuffle indicates whether we are just shuffling the queue 
 	 * (i.e., the entry table is left alone).
 	 */
 	protected void privateRemoveEntry(LRUCacheEntry<K, T> entry, boolean shuffle) {
-		
-		LRUCacheEntry<K,T> previous, next;
-		
-		previous = entry._fPrevious;
-		next = entry._fNext;
+		LRUCacheEntry<K, T> previous = entry._fPrevious;
+		LRUCacheEntry<K, T> next = entry._fNext;
 		
 		if (!shuffle) {
 			fEntryTable.remove(entry._fKey);
@@ -350,6 +343,7 @@ public class LRUCache<K,T> implements Cloneable {
 			next._fPrevious = previous;
 		}
 	}
+
 	/**
 	 * Sets the value in the cache at the given key. Returns the value.
 	 *
@@ -358,17 +352,14 @@ public class LRUCache<K,T> implements Cloneable {
 	 * @return added value.
 	 */
 	public T put(K key, T value) {
-		
-		int newSpace, oldSpace, newTotal;
-		LRUCacheEntry<K,T> entry;
+		int oldSpace, newTotal;
 		
 		/* Check whether there's an entry in the cache */
-		newSpace = spaceFor (key, value);
-		entry = fEntryTable.get (key);
+		int newSpace = spaceFor(key, value);
+		LRUCacheEntry<K, T> entry = fEntryTable.get(key);
 		
 		if (entry != null) {
-			
-			/**
+			/*
 			 * Replace the entry in the cache if it would not overflow
 			 * the cache.  Otherwise flush the entry and re-add it so as 
 			 * to keep cache within budget
@@ -389,6 +380,7 @@ public class LRUCache<K,T> implements Cloneable {
 		}
 		return value;
 	}
+
 	/**
 	 * Removes and returns the value in the cache for the given key.
 	 * If the key is not in the cache, returns null.
@@ -397,7 +389,6 @@ public class LRUCache<K,T> implements Cloneable {
 	 * @return Value removed from cache.
 	 */
 	public T removeKey(K key) {
-		
 		LRUCacheEntry<K, T> entry = fEntryTable.get(key);
 		if (entry == null) {
 			return null;
@@ -406,6 +397,7 @@ public class LRUCache<K,T> implements Cloneable {
 		this.privateRemoveEntry(entry, false);
 		return value;
 	}
+
 	/**
 	 * Sets the maximum amount of space that the cache can store
 	 *
@@ -417,26 +409,27 @@ public class LRUCache<K,T> implements Cloneable {
 		}
 		fSpaceLimit = limit;
 	}
+
 	/**
 	 * Returns the space taken by the given key and value.
 	 */
 	protected int spaceFor(Object key, Object value) {
-		
 		if (value instanceof ILRUCacheable) {
 			return ((ILRUCacheable) value).getCacheFootprint();
 		}
 		return 1;
 	}
+
 	/**
 	 * Returns a String that represents the value of this object.  This method
 	 * is for debugging purposes only.
 	 */
 	@Override
 	public String toString() {
-	return 
-		"LRUCache " + (fCurrentSpace * 100.0 / fSpaceLimit) + "% full\n" + //$NON-NLS-1$ //$NON-NLS-2$
+		return "LRUCache " + (fCurrentSpace * 100.0 / fSpaceLimit) + "% full\n" + //$NON-NLS-1$ //$NON-NLS-2$
 				this.toStringContents();
 	}
+
 	/**
 	 * Returns a String that represents the contents of this object.  This method
 	 * is for debugging purposes only.
@@ -467,12 +460,12 @@ protected String toStringContents() {
 		}
 		return result.toString();
 	}
+
 	/**
 	 * Updates the timestamp for the given entry, ensuring that the queue is 
 	 * kept in correct order.  The entry must exist
 	 */
 	protected void updateTimestamp(LRUCacheEntry<K, T> entry) {
-		
 		entry._fTimestamp = fTimestampCounter++;
 		if (fEntryQueue != entry) {
 			this.privateRemoveEntry(entry, true);
@@ -480,5 +473,4 @@ protected String toStringContents() {
 		}
 		return;
 	}
-
 }