[infinispan-commits] Infinispan SVN: r1505 - trunk/core/src/main/java/org/infinispan/util/concurrent.

[infinispan-commits at lists.jboss.org]

Author: vblagojevic at jboss.com
Date: 2010-02-14 17:18:00 -0500 (Sun, 14 Feb 2010)
New Revision: 1505

Modified:
   trunk/core/src/main/java/org/infinispan/util/concurrent/BufferedConcurrentHashMap.java
Log:
remove asserts

Modified: trunk/core/src/main/java/org/infinispan/util/concurrent/BufferedConcurrentHashMap.java
===================================================================
--- trunk/core/src/main/java/org/infinispan/util/concurrent/BufferedConcurrentHashMap.java	2010-02-12 20:14:34 UTC (rev 1504)
+++ trunk/core/src/main/java/org/infinispan/util/concurrent/BufferedConcurrentHashMap.java	2010-02-14 22:18:00 UTC (rev 1505)
@@ -228,23 +228,15 @@
             return hash == other.hash && key.equals(other.key);
         }
 
-        public void transitionHIRResidentToLIRResident() {
-            assert state == Recency.HIR_RESIDENT;
+        public void transitionToLIRResident() {           
             state = Recency.LIR_RESIDENT;
         }
 
-        public void transitionHIRResidentToHIRNonResident() {
-            assert state == Recency.HIR_RESIDENT;
+        public void transitionHIRResidentToHIRNonResident() {            
             state = Recency.HIR_NONRESIDENT;
         }
-
-        public void transitionHIRNonResidentToLIRResident() {
-            assert state == Recency.HIR_NONRESIDENT;
-            state = Recency.LIR_RESIDENT;
-        }
-
-        public void transitionLIRResidentToHIRResident() {
-            assert state == Recency.LIR_RESIDENT;
+        
+        public void transitionLIRResidentToHIRResident() {            
             state = Recency.HIR_RESIDENT;
         }
 
@@ -468,10 +460,9 @@
 
         @Override
         public void onEntryRemove(HashEntry<K, V> e) {
-            assert lruQueue.remove(e);
+            lruQueue.remove(e);
             // we could have multiple instances of e in accessQueue; remove them all
-            while (accessQueue.remove(e))
-                ;
+            while (accessQueue.remove(e));
         }
 
         @Override
@@ -544,13 +535,11 @@
             // first put on top of the stack
             stack.put(e.hashCode(), e);
 
-            if (inStack) {
-                assert queue.contains(e);
+            if (inStack) {                
                 queue.remove(e);
-                e.transitionHIRResidentToLIRResident();
+                e.transitionToLIRResident();
                 switchBottomostLIRtoHIRAndPrune(evicted);
-            } else {
-                assert queue.contains(e);
+            } else {               
                 queue.remove(e);
                 queue.addLast(e);
             }
@@ -579,28 +568,24 @@
             // initialization
             if (currentLIRSize + 1 < lirSizeLimit) {
                 currentLIRSize++;
-                e.transitionHIRResidentToLIRResident();
+                e.transitionToLIRResident();
                 stack.put(e.hashCode(), e);
             } else {
-                if (queue.size() < hirSizeLimit) {
-                    assert !queue.contains(e);
+                if (queue.size() < hirSizeLimit) {                    
                     queue.addLast(e);
                 } else {
                     boolean inStack = stack.containsKey(e.hashCode());
-
-                    HashEntry<K, V> first = queue.removeFirst();
-                    assert first.recency() == Recency.HIR_RESIDENT;
+                    HashEntry<K, V> first = queue.removeFirst();                    
                     first.transitionHIRResidentToHIRNonResident();
 
                     stack.put(e.hashCode(), e);
 
                     if (inStack) {
-                        e.transitionHIRResidentToLIRResident();
+                        e.transitionToLIRResident();
                         Set<HashEntry<K, V>> evicted = new HashSet<HashEntry<K, V>>();
                         switchBottomostLIRtoHIRAndPrune(evicted);
                         removeFromSegment(evicted);
-                    } else {
-                        assert !queue.contains(e);
+                    } else {                        
                         queue.addLast(e);
                     }
 
@@ -624,8 +609,7 @@
                     if (!seenFirstLIR) {
                         seenFirstLIR = true;
                         i.remove();
-                        next.transitionLIRResidentToHIRResident();
-                        assert !queue.contains(next);
+                        next.transitionLIRResidentToHIRResident();                       
                         queue.addLast(next);
                     } else {
                         break;