Coverage report

  %line %branch
org.apache.jcs.JCS
162% 
100% 

 1   
 package org.apache.jcs;
 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 org.apache.jcs.access.GroupCacheAccess;
 23   
 import org.apache.jcs.access.exception.CacheException;
 24   
 import org.apache.jcs.engine.behavior.ICompositeCacheAttributes;
 25   
 import org.apache.jcs.engine.control.CompositeCache;
 26   
 import org.apache.jcs.engine.control.CompositeCacheManager;
 27   
 
 28   
 /**
 29   
  * Simple class for using JCS. To use JCS in your application, you can use the static methods of
 30   
  * this class to get access objects (instances of this class) for your cache regions. Ideally this
 31   
  * class should be all you need to import to use JCS. One JCS should be created for each region you
 32   
  * want to access. If you have several regions, then get instances for each. For best performance
 33   
  * the getInstance call should be made in an initialization method.
 34   
  */
 35   
 public class JCS
 36   
     extends GroupCacheAccess
 37   
 {
 38  6 
     /** cache.ccf alternative. */
 39  166 
     private static String configFilename = null;
 40   
 
 41  6 
     /** The manager returns cache instances. */
 42   
     private static CompositeCacheManager cacheMgr;
 43   
 
 44   
     /**
 45   
      * Protected constructor for use by the static factory methods.
 46   
      * <p>
 47   
      * @param cacheControl Cache which the instance will provide access to
 48   
      */
 49   
     protected JCS( CompositeCache cacheControl )
 50   
     {
 51  597 
         super( cacheControl );
 52  593 
     }
 53  15 
 
 54  15 
     /**
 55   
      * Get a JCS which accesses the provided region.
 56   
      * <p>
 57   
      * @param region Region that return JCS will provide access to
 58   
      * @return A JCS which provides access to a given region.
 59   
      * @exception CacheException
 60   
      */
 61   
     public static JCS getInstance( String region )
 62   
         throws CacheException
 63   
     {
 64  585 
         ensureCacheManager();
 65   
 
 66  597 
         return new JCS( cacheMgr.getCache( region ) );
 67  15 
     }
 68   
 
 69  15 
     /**
 70   
      * Get a JCS which accesses the provided region.
 71   
      * <p>
 72   
      * @param region Region that return JCS will provide access to
 73   
      * @param icca CacheAttributes for region
 74   
      * @return A JCS which provides access to a given region.
 75   
      * @exception CacheException
 76   
      */
 77   
     public static JCS getInstance( String region, ICompositeCacheAttributes icca )
 78   
         throws CacheException
 79   
     {
 80  0 
         ensureCacheManager();
 81   
 
 82  0 
         return new JCS( cacheMgr.getCache( region, icca ) );
 83   
     }
 84   
 
 85   
     /**
 86   
      * Gets an instance of CompositeCacheManager and stores it in the cacheMgr class field, if it is
 87   
      * not already set. Unlike the implementation in CacheAccess, the cache manager is a
 88   
      * CompositeCacheManager. NOTE: This can will be moved up into GroupCacheAccess.
 89   
      */
 90   
     protected static synchronized void ensureCacheManager()
 91   
     {
 92  598 
         if ( cacheMgr == null )
 93   
         {
 94  166 
             if ( configFilename == null )
 95   
             {
 96  29 
                 cacheMgr = CompositeCacheManager.getInstance();
 97  29 
             }
 98  15 
             else
 99   
             {
 100  143 
                 cacheMgr = CompositeCacheManager.getUnconfiguredInstance();
 101   
 
 102  139 
                 cacheMgr.configure( configFilename );
 103   
             }
 104   
         }
 105  597 
     }
 106  4 
 
 107   
     /**
 108  4 
      * Set the filename that the cache manager will be initialized with. Only matters before the
 109   
      * instance is initialized.
 110   
      * <p>
 111  15 
      * @param configFilename
 112   
      */
 113   
     public static void setConfigFilename( String configFilename )
 114   
     {
 115  418 
         JCS.configFilename = configFilename;
 116  418 
     }
 117   
 }

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