Coverage report

  %line %branch
org.apache.jcs.auxiliary.disk.indexed.IndexedDiskCacheManager
45% 
78% 

 1  
 package org.apache.jcs.auxiliary.disk.indexed;
 2  
 
 3  
 /*
 4  
  * Licensed to the Apache Software Foundation (ASF) under one
 5  
  * or more contributor license agreements.  See the NOTICE file
 6  
  * distributed with this work for additional information
 7  
  * regarding copyright ownership.  The ASF licenses this file
 8  
  * to you under the Apache License, Version 2.0 (the
 9  
  * "License"); you may not use this file except in compliance
 10  
  * with the License.  You may obtain a copy of the License at
 11  
  *
 12  
  *   http://www.apache.org/licenses/LICENSE-2.0
 13  
  *
 14  
  * Unless required by applicable law or agreed to in writing,
 15  
  * software distributed under the License is distributed on an
 16  
  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 17  
  * KIND, either express or implied.  See the License for the
 18  
  * specific language governing permissions and limitations
 19  
  * under the License.
 20  
  */
 21  
 
 22  
 import java.util.Enumeration;
 23  
 import java.util.Hashtable;
 24  
 
 25  
 import org.apache.commons.logging.Log;
 26  
 import org.apache.commons.logging.LogFactory;
 27  
 import org.apache.jcs.auxiliary.AuxiliaryCache;
 28  
 import org.apache.jcs.auxiliary.AuxiliaryCacheManager;
 29  
 import org.apache.jcs.engine.behavior.ICache;
 30  
 
 31  
 /**
 32  
  * Cache manager for IndexedDiskCaches. This manages the instances of the disk
 33  
  * cache.
 34  
  */
 35  
 public class IndexedDiskCacheManager
 36  
     implements AuxiliaryCacheManager
 37  
 {
 38  
     private static final long serialVersionUID = -4153287154512274626L;
 39  
 
 40  116
     private final static Log log = LogFactory.getLog( IndexedDiskCacheManager.class );
 41  
 
 42  
     private static int clients;
 43  
 
 44  
     private static IndexedDiskCacheManager instance;
 45  
 
 46  58
     private Hashtable caches = new Hashtable();
 47  
 
 48  
     private IndexedDiskCacheAttributes defaultCacheAttributes;
 49  
 
 50  
     /**
 51  
      * Constructor for the IndexedDiskCacheManager object
 52  
      * <p>
 53  
      * @param defaultCacheAttributes
 54  
      *            Default attributes for caches managed by the instance.
 55  
      */
 56  
     private IndexedDiskCacheManager( IndexedDiskCacheAttributes defaultCacheAttributes )
 57  58
     {
 58  58
         this.defaultCacheAttributes = defaultCacheAttributes;
 59  58
     }
 60  
 
 61  
     /**
 62  
      * Gets the singleton instance of the manager
 63  
      * <p>
 64  
      * @param defaultCacheAttributes
 65  
      *            If the instance has not yet been created, it will be
 66  
      *            initialized with this set of default attributes.
 67  
      * @return The instance value
 68  
      */
 69  
     public static IndexedDiskCacheManager getInstance( IndexedDiskCacheAttributes defaultCacheAttributes )
 70  
     {
 71  209
         synchronized ( IndexedDiskCacheManager.class )
 72  
         {
 73  209
             if ( instance == null )
 74  
             {
 75  58
                 instance = new IndexedDiskCacheManager( defaultCacheAttributes );
 76  
             }
 77  209
         }
 78  
 
 79  209
         clients++;
 80  
 
 81  209
         return instance;
 82  
     }
 83  
 
 84  
     /**
 85  
      * Gets an IndexedDiskCache for the supplied name using the default
 86  
      * attributes.
 87  
      * <p>
 88  
      * @param cacheName
 89  
      *            Name that will be used when creating attributes.
 90  
      * @return A cache.
 91  
      */
 92  
     public AuxiliaryCache getCache( String cacheName )
 93  
     {
 94  0
         IndexedDiskCacheAttributes cacheAttributes = (IndexedDiskCacheAttributes) defaultCacheAttributes.copy();
 95  
 
 96  0
         cacheAttributes.setCacheName( cacheName );
 97  
 
 98  0
         return getCache( cacheAttributes );
 99  
     }
 100  
 
 101  
     /**
 102  
      * Get an IndexedDiskCache for the supplied attributes. Will provide an
 103  
      * existing cache for the name attribute if one has been created, or will
 104  
      * create a new cache.
 105  
      * <p>
 106  
      * @param cacheAttributes
 107  
      *            Attributes the cache should have.
 108  
      * @return A cache, either from the existing set or newly created.
 109  
      */
 110  
     public AuxiliaryCache getCache( IndexedDiskCacheAttributes cacheAttributes )
 111  
     {
 112  209
         AuxiliaryCache cache = null;
 113  
 
 114  209
         String cacheName = cacheAttributes.getCacheName();
 115  
 
 116  209
         log.debug( "Getting cache named: " + cacheName );
 117  
 
 118  209
         synchronized ( caches )
 119  
         {
 120  
             // Try to load the cache from the set that have already been
 121  
             // created. This only looks at the name attribute.
 122  
 
 123  209
             cache = (AuxiliaryCache) caches.get( cacheName );
 124  
 
 125  
             // If it was not found, create a new one using the supplied
 126  
             // attributes
 127  
 
 128  209
             if ( cache == null )
 129  
             {
 130  209
                 cache = new IndexedDiskCache( cacheAttributes );
 131  
 
 132  209
                 caches.put( cacheName, cache );
 133  
             }
 134  209
         }
 135  
 
 136  209
         return cache;
 137  
     }
 138  
 
 139  
     /**
 140  
      * Disposes the cache with the given name, if found in the set of managed
 141  
      * caches.
 142  
      * <p>
 143  
      * @param cacheName
 144  
      *            Name of cache to dispose.
 145  
      */
 146  
     public void freeCache( String cacheName )
 147  
     {
 148  0
         ICache cache = (ICache) caches.get( cacheName );
 149  
 
 150  0
         if ( cache != null )
 151  
         {
 152  
             try
 153  
             {
 154  0
                 cache.dispose();
 155  
             }
 156  0
             catch ( Exception e )
 157  
             {
 158  0
                 log.error( "Failure disposing cache: " + cacheName, e );
 159  0
             }
 160  
         }
 161  0
     }
 162  
 
 163  
     /**
 164  
      * Gets the cacheType attribute of the DiskCacheManager object
 165  
      * <p>
 166  
      * @return The cacheType value
 167  
      */
 168  
     public int getCacheType()
 169  
     {
 170  0
         return DISK_CACHE;
 171  
     }
 172  
 
 173  
     /**
 174  
      * Releases the cache manager instance. When all clients have released the
 175  
      * cache manager, all contained caches will be disposed.
 176  
      */
 177  
     public void release()
 178  
     {
 179  0
         clients--;
 180  
 
 181  0
         if ( --clients != 0 )
 182  
         {
 183  0
             return;
 184  
         }
 185  
 
 186  0
         synchronized ( caches )
 187  
         {
 188  0
             Enumeration allCaches = caches.elements();
 189  
 
 190  0
             while ( allCaches.hasMoreElements() )
 191  
             {
 192  0
                 ICache cache = (ICache) allCaches.nextElement();
 193  
 
 194  0
                 if ( cache != null )
 195  
                 {
 196  
                     try
 197  
                     {
 198  0
                         cache.dispose();
 199  
                     }
 200  0
                     catch ( Exception e )
 201  
                     {
 202  0
                         log.error( "Failure disposing cache: " + cache.getCacheName(), e );
 203  0
                     }
 204  
                 }
 205  0
             }
 206  0
         }
 207  0
     }
 208  
 }

This report is generated by jcoverage, Maven and Maven JCoverage Plugin.