Coverage Report - org.webmacro.broker.DefaultContextAutoLoader
 
Classes in this File Line Coverage Branch Coverage Complexity
DefaultContextAutoLoader
59%
31/52
55%
10/18
4.2
DefaultContextAutoLoader$1
N/A
N/A
4.2
DefaultContextAutoLoader$AutoContextSettingsHandler
66%
4/6
N/A
4.2
 
 1  
 package org.webmacro.broker;
 2  
 
 3  
 import java.lang.reflect.Constructor;
 4  
 import java.util.Map;
 5  
 import java.util.concurrent.ConcurrentHashMap;
 6  
 
 7  
 import org.slf4j.Logger;
 8  
 import org.slf4j.LoggerFactory;
 9  
 import org.webmacro.Broker;
 10  
 import org.webmacro.Context;
 11  
 import org.webmacro.PropertyException;
 12  
 import org.webmacro.util.Settings;
 13  
 
 14  
 
 15  
 /**
 16  
  * DefaultContextAutoLoader
 17  
  *
 18  
  * @author Brian Goetz
 19  
  */
 20  84
 public class DefaultContextAutoLoader implements ContextAutoLoader {
 21  
 
 22  2
     static Logger _log =  LoggerFactory.getLogger(DefaultContextAutoLoader.class);
 23  
     private Broker _broker;
 24  12
     private Map _factories = new ConcurrentHashMap();
 25  
 
 26  
     public void init(Broker b, String name) {
 27  12
         _broker = b;
 28  12
         loadFactories(name);
 29  12
     }
 30  
 
 31  
     public Object get(String name, Context context) throws PropertyException {
 32  1160
         Object o = _factories.get(name);
 33  1160
         if (o == null)
 34  0
             return null;
 35  1160
         ContextObjectFactory f = (ContextObjectFactory) o;
 36  1160
         return f.get(context);
 37  
     }
 38  
 
 39  
     /**
 40  
      * Load the context tools listed in the supplied string. See
 41  
      * the ComponentMap class for a description of the format of
 42  
      * this string.
 43  
      */
 44  
     private void loadFactories (String keyName)
 45  
     {
 46  12
         _broker.getSettings().processListSetting(keyName, new AutoContextSettingsHandler());
 47  12
     }
 48  
 
 49  12
     private class AutoContextSettingsHandler extends Settings.ListSettingHandler
 50  
     {
 51  
         public void processSetting (String settingKey, String settingValue)
 52  
         {
 53  
             try
 54  
             {
 55  72
                 addAutoVariable(settingKey, settingValue);
 56  
             }
 57  0
             catch (Exception e)
 58  
             {
 59  0
                 _log.error("Automatic variable (" + settingValue + ") failed to load", e);
 60  72
             }
 61  72
         }
 62  
     }
 63  
 
 64  
     /**
 65  
      * Attempts to instantiate the tool using two different constructors
 66  
      * until one succeeds, in the following order:
 67  
      * <ul>
 68  
      * <li>new MyTool(String key)</li>
 69  
      * <li>new MyTool()</li>
 70  
      * </ul>
 71  
      * The key is generally the unqualified class name of the tool minus the
 72  
      * "Tool" suffix, e.g., "My" in the example above
 73  
      * The settings are any configured settings for this tool, i.e, settings
 74  
      * prefixed with the tool's key.
 75  
      * <br>
 76  
      * NOTE: keats - 25 May 2002, no tools are known to use the settings mechanism.
 77  
      * We should create an example of this and test it, or abolish this capability!
 78  
      * Abolished -- BG
 79  
      */
 80  
     private void addAutoVariable(String toolName, String className) {
 81  
         Class c;
 82  
         try
 83  
         {
 84  72
             c = _broker.classForName(className);
 85  
         }
 86  0
         catch (ClassNotFoundException e)
 87  
         {
 88  0
             _log.warn("Context: Could not locate class for context tool " + className);
 89  0
             return;
 90  72
         }
 91  72
         if (toolName == null || toolName.equals(""))
 92  
         {
 93  0
             toolName = className;
 94  0
             int start = 0;
 95  0
             int end = toolName.length();
 96  0
             int lastDot = toolName.lastIndexOf('.');
 97  0
             if (lastDot != -1)
 98  0
                 start = lastDot + 1;
 99  0
             toolName = toolName.substring(start, end);
 100  
         }
 101  
 
 102  72
         Constructor ctor = null;
 103  72
         Constructor[] ctors = c.getConstructors();
 104  72
         Class[] parmTypes = null;
 105  72
         Object instance = null;
 106  
 
 107  
         // check for 1 arg (String) constructor
 108  162
         for (int i = 0; i < ctors.length; i++)
 109  
         {
 110  90
             parmTypes = ctors[i].getParameterTypes();
 111  90
             if (parmTypes.length == 1 && parmTypes[0].equals(String.class))
 112  
             {
 113  0
                 ctor = ctors[i];
 114  0
                 Object[] args = {toolName};
 115  
                 try
 116  
                 {
 117  0
                     instance = ctor.newInstance(args);
 118  
                 }
 119  0
                 catch (Exception e)
 120  
                 {
 121  0
                     _log.error("Failed to instantiate tool "
 122  
                                + toolName + " of class " + className + " using constructor "
 123  
                                + ctor.toString(), e);
 124  0
                 }
 125  
             }
 126  
         }
 127  72
         if (instance == null)
 128  
         {
 129  
             // try no-arg constructor
 130  
             try
 131  
             {
 132  72
                 instance = c.newInstance();
 133  
             }
 134  0
             catch (Exception e)
 135  
             {
 136  0
                 _log.error("Unable to construct tool " + toolName + " of class " + className, e);
 137  0
                 return;
 138  72
             }
 139  
         }
 140  72
         if (instance instanceof ContextObjectFactory) {
 141  72
             _factories.put(toolName, instance);
 142  72
             _broker.registerAutoContextVariable(toolName, this);
 143  72
             _log.info("Registered automatic variable factory " + toolName);
 144  
         }
 145  
         else {
 146  0
             _log.warn("Context object " + toolName + " is not of type ContextObjectFactory");
 147  
         }
 148  72
     }
 149  
 }