Coverage report

  %line %branch
org.apache.turbine.om.OMTool$PullHelper
0% 
0% 

 1  
 package org.apache.turbine.om;
 2  
 
 3  
 /*
 4  
  * Copyright 2001-2004 The Apache Software Foundation.
 5  
  *
 6  
  * Licensed under the Apache License, Version 2.0 (the "License")
 7  
  * you may not use this file except in compliance with the License.
 8  
  * You may obtain a copy of the License at
 9  
  *
 10  
  *     http://www.apache.org/licenses/LICENSE-2.0
 11  
  *
 12  
  * Unless required by applicable law or agreed to in writing, software
 13  
  * distributed under the License is distributed on an "AS IS" BASIS,
 14  
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 15  
  * See the License for the specific language governing permissions and
 16  
  * limitations under the License.
 17  
  */
 18  
 
 19  
 import java.util.HashMap;
 20  
 import java.util.Map;
 21  
 
 22  
 import org.apache.turbine.Turbine;
 23  
 import org.apache.turbine.services.pull.ApplicationTool;
 24  
 import org.apache.turbine.util.pool.Recyclable;
 25  
 
 26  
 /**
 27  
  * A Pull tool to make om objects available to a template
 28  
  *
 29  
  * @author <a href="mailto:jmcnally@collab.net">John D. McNally</a>
 30  
  * @author <a href="mailto:hps@intermeta.de">Henning P. Schmiedehausen</a>
 31  
  * @version $Id: OMTool.java,v 1.4.2.2 2004/05/20 03:05:19 seade Exp $
 32  
  */
 33  
 public class OMTool implements ApplicationTool, Recyclable
 34  
 {
 35  
     // private RunData data;
 36  
     private HashMap omMap;
 37  
 
 38  
     // note the following could be a static attribute to reduce memory
 39  
     // footprint. Might require a service to front load the
 40  
     // PullHelpers to avoid MT issues. A multiple write is not so bad
 41  
     // though
 42  
 
 43  
     /** The cache of PullHelpers. **/
 44  
     private static Map pullMap = new HashMap();
 45  
 
 46  
     /**
 47  
      *  The Factory responsible for retrieving the
 48  
      *  objects from storage
 49  
      */
 50  
     private RetrieverFactory omFactory;
 51  
 
 52  
     public OMTool()throws Exception
 53  
     {
 54  
         omMap = new HashMap();
 55  
         String className = Turbine.getConfiguration()
 56  
                 .getString("tool.om.factory");
 57  
         //        RetrieverFactory omFactory =
 58  
         //            (RetrieverFactory)Class.forName(className).newInstance();
 59  
     }
 60  
 
 61  
     /**
 62  
      * Prepares tool for a single request
 63  
      */
 64  
     public void init(Object runData)
 65  
     {
 66  
         // data = (RunData)runData;
 67  
     }
 68  
 
 69  
     /**
 70  
      * Implementation of ApplicationTool interface is not needed for this
 71  
      * method as the tool is request scoped
 72  
      */
 73  
     public void refresh()
 74  
     {
 75  
         // empty
 76  
     }
 77  
 
 78  
     /**
 79  
      * Inner class to present a nice interface to the template designer
 80  
      */
 81  0
     private class PullHelper
 82  
     {
 83  
         String omName;
 84  
 
 85  
         private PullHelper(String omName)
 86  0
         {
 87  0
             this.omName = omName;
 88  0
         }
 89  
 
 90  
         public Object setKey(String key)
 91  
             throws Exception
 92  
         {
 93  0
             Object om = null;
 94  
 
 95  0
             String inputKey = omName + key;
 96  0
             if (omMap.containsKey(inputKey))
 97  
             {
 98  0
                 om = omMap.get(inputKey);
 99  
             }
 100  
             else
 101  
             {
 102  0
                 om = omFactory.getInstance(omName).retrieve(key);
 103  0
                 omMap.put(inputKey, om);
 104  
             }
 105  
 
 106  0
             return om;
 107  
         }
 108  
     }
 109  
 
 110  
     public Object get(String omName) throws Exception
 111  
     {
 112  
         if (!pullMap.containsKey(omName))
 113  
         {
 114  
             // MT could overwrite a PullHelper, but that is not a problem
 115  
             // should still synchronize to avoid two threads adding at
 116  
             // same time
 117  
             synchronized (this.getClass())
 118  
             {
 119  
                 pullMap.put(omName, new OMTool.PullHelper(omName));
 120  
             }
 121  
         }
 122  
 
 123  
         return pullMap.get(omName);
 124  
     }
 125  
 
 126  
     public Object get(String omName, String key) throws Exception
 127  
     {
 128  
         return ((OMTool.PullHelper) get(omName)).setKey(key);
 129  
     }
 130  
 
 131  
 
 132  
     public String getName()
 133  
     {
 134  
         return "om";
 135  
     }
 136  
 
 137  
 
 138  
     // ****************** Recyclable implementation ************************
 139  
 
 140  
     private boolean disposed;
 141  
 
 142  
     /**
 143  
      * Recycles the object for a new client. Recycle methods with
 144  
      * parameters must be added to implementing object and they will be
 145  
      * automatically called by pool implementations when the object is
 146  
      * taken from the pool for a new client. The parameters must
 147  
      * correspond to the parameters of the constructors of the object.
 148  
      * For new objects, constructors can call their corresponding recycle
 149  
      * methods whenever applicable.
 150  
      * The recycle methods must call their super.
 151  
      */
 152  
     public void recycle()
 153  
     {
 154  
         disposed = false;
 155  
     }
 156  
 
 157  
     /**
 158  
      * Disposes the object after use. The method is called
 159  
      * when the object is returned to its pool.
 160  
      * The dispose method must call its super.
 161  
      */
 162  
     public void dispose()
 163  
     {
 164  
         omMap.clear();
 165  
         // data = null;
 166  
         disposed = true;
 167  
     }
 168  
 
 169  
     /**
 170  
      * Checks whether the recyclable has been disposed.
 171  
      * @return true, if the recyclable is disposed.
 172  
      */
 173  
     public boolean isDisposed()
 174  
     {
 175  
         return disposed;
 176  
     }
 177  
 }
 178  
 
 179  
 
 180  
 
 181  
 
 182  
 
 183  
 
 184  
 
 185  
 

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