commons-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From froehl...@apache.org
Subject cvs commit: jakarta-commons-sandbox/simplestore/src/java/org/apache/commons/simplestore SoftRefMemoryStore.java
Date Sat, 26 Jan 2002 12:00:47 GMT
froehlich    02/01/26 04:00:47

  Modified:    simplestore/src/java/org/apache/commons/simplestore
                        SoftRefMemoryStore.java
  Log:
  applied patches from Juozas Baliuka [baliuka@mwm.lt].
  - re-factored SoftRefMemoryStore
  - added Swapping Simultation and test case
  
  Revision  Changes    Path
  1.6       +65 -34    jakarta-commons-sandbox/simplestore/src/java/org/apache/commons/simplestore/SoftRefMemoryStore.java
  
  Index: SoftRefMemoryStore.java
  ===================================================================
  RCS file: /home/cvs/jakarta-commons-sandbox/simplestore/src/java/org/apache/commons/simplestore/SoftRefMemoryStore.java,v
  retrieving revision 1.5
  retrieving revision 1.6
  diff -u -r1.5 -r1.6
  --- SoftRefMemoryStore.java	21 Jan 2002 22:02:36 -0000	1.5
  +++ SoftRefMemoryStore.java	26 Jan 2002 12:00:47 -0000	1.6
  @@ -20,19 +20,19 @@
    *      baliuka@mwm.lt</a>
    * @author Gerhard Froehlich <a href="mailto:g-froehlich@gmx.de">
    *      g-froehlich@gmx.de</a>
  - * @version $Id: SoftRefMemoryStore.java,v 1.5 2002/01/21 22:02:36 froehlich Exp $
  + * @version $Id: SoftRefMemoryStore.java,v 1.6 2002/01/26 12:00:47 froehlich Exp $
    */
   public class SoftRefMemoryStore
   implements Store {
  -
  +    
       private static boolean DEBUG = true;
  -    private Store store;
       private int maxStrongRefCount;
       private Object [] strongRefs;
       private int current = 0;
       private java.util.Map map = new java.util.HashMap();
       private java.lang.ref.ReferenceQueue queue = new java.lang.ref.ReferenceQueue();
  - 
  +    private Swap swap;
  +    
       static class SoftRef extends java.lang.ref.SoftReference{
           Object key;
           private  SoftRef(Object key,Object object,java.lang.ref.ReferenceQueue queue) {
  @@ -41,48 +41,75 @@
           }
       }
       
  -    public static Store getInstance(Store store,int maxStrongRef) {
  -        return new SynchronizedStore( new  SoftRefMemoryStore(store, maxStrongRef) ) ;
  +    static class StrongRef extends java.lang.Object{
  +        Object object;
  +        Swap queue;
  +        private  StrongRef(Object object, Swap queue ) {
  +            this.queue = queue;// used in finalize
  +            this.object = object;// add strong reference to value
  +        }
  +        
  +        public Object get(){
  +            return object;
  +        }
  +        
  +        protected void finalize() throws java.lang.Throwable {
  +            super.finalize();
  +            queue.add(object);
  +        }
       }
       
  -    /** Creates new SoftRefMemoryStore */
  -    protected SoftRefMemoryStore(Store store, int maxStrongRefCount) {
  -        if(store == null) {
  -            throw new NullPointerException();
  +    private Object makeValue(Object key, Object value,java.lang.ref.ReferenceQueue queue,
Swap swap  ){
  +        if( swap == null ){
  +            return new SoftRef( key, value, queue);
           }
  +        else{
  +            return new SoftRef( key, new StrongRef( value, swap ), queue);
  +        }
  +    }
  +    
  +    public static Store getInstance(Swap swap, int maxStrongRef) {
  +        
  +        return new SynchronizedStore( new  SoftRefMemoryStore( swap, maxStrongRef ) ) ;
  +        
  +    }
  +    
  +    /** Creates new SoftRefMemoryStore */
  +    protected SoftRefMemoryStore(Swap swap, int maxStrongRefCount) {
  +        this.swap = swap;
           if(maxStrongRefCount < 0) {
               throw new java.lang.IllegalArgumentException();
           }
  -        this.store = store;
           this.maxStrongRefCount = maxStrongRefCount;
           if(maxStrongRefCount > 0) {
               strongRefs = new Object[ maxStrongRefCount ];
           }
       }
  -
  -    // remove keys
  +    
  +    // remove unused keys
       private void removeSoftRef(){
           SoftRef ref = (SoftRef)queue.poll();
   
           while( ref != null ) {
               map.remove(ref.key);
               if(DEBUG) {
  -                System.out.println( "Key " + ref.key + " removed from queue, map size is
" + map.size());
  +                System.out.println( "Key " + ref.key + " removed from Reference queue,
map size is " + map.size());
               }
               ref = (SoftRef)queue.poll();
           }
       }
       
  -    private void addStrongRef(Object object) { 
  +    private void addStrongRef(Object object) {
           if( strongRefs != null ) {
               strongRefs[ ( current++ ) % maxStrongRefCount ] = object;
           }
       }
  -
  +    
       private void internalStoreObject(Object key, Object object) {
  -        addStrongRef(object);
  -        map.put(key,new SoftRef(key,object,queue));
  -    }
  +         SoftRef ref = (SoftRef)makeValue(key,object,queue,swap);
  +         addStrongRef(ref.get());
  +         map.put(key,ref);
  +     }
       
       /**
        * Remove the object associated to the given key.
  @@ -91,8 +118,7 @@
        */
       public Object remove(Object key) {
           removeSoftRef();
  -        store.remove(key);
  -        return null;
  +        return map.remove(key);
       }
       
       /**
  @@ -102,13 +128,15 @@
        */
       public boolean containsKey(Object key) {
           removeSoftRef();
  -        return store.containsKey(key);
  +        return map.containsKey(key);
       }
       
       /**
        * Frees some object out of the Store.
        */
       public void free() {
  +       if( strongRefs != null ) 
  +         java.util.Arrays.fill(strongRefs,null);
           removeSoftRef();
       }
       
  @@ -122,7 +150,7 @@
        */
       public void put(Object key, Object object) {
           removeSoftRef();
  -        store.put(key,object);
  +        //  store.put(key,object);
           internalStoreObject(key,object);
       }
       
  @@ -134,33 +162,36 @@
       public Object get(Object key) {
           removeSoftRef();
           Object object = null;
  -        java.lang.ref.Reference ref = (java.lang.ref.Reference)map.get(key);
  +        SoftRef ref = (SoftRef)map.get(key);
           
           if(ref != null) {
  -            object = ref.get();
  +            
  +            Object value = ref.get();
  +            
  +            if( value != null && value instanceof StrongRef ){
  +                object = ((StrongRef)value).object;
  +            }else{
  +                object = value;
  +            }
           }
           
  -        if(object == null) {
  -            object = store.get(key);
  -        }
  -
  -        internalStoreObject(key,object);
  +        
           return object;
       }
       
       public boolean isEmpty()  {
  -        return store.isEmpty();  
  +        return map.isEmpty();
       }
       
       public int size()  {
  -        return store.size();  
  +        return map.size();
       }
       
       public void clear()  {
  -        store.clear();
  +        map.clear();
       }
       
       public Store getNextStore() {
  -        throw new UnsupportedOperationException("method not implemented yet");  
  +        throw new UnsupportedOperationException("method not implemented yet");
       }
   }
  
  
  

--
To unsubscribe, e-mail:   <mailto:commons-dev-unsubscribe@jakarta.apache.org>
For additional commands, e-mail: <mailto:commons-dev-help@jakarta.apache.org>


Mime
View raw message