Coverage Report - pt.digitalis.dif.dem.managers.impl.ParameterManagerImpl
 
Classes in this File Line Coverage Branch Coverage Complexity
ParameterManagerImpl
0%
0/88
0%
0/42
2,929
 
 1  0
 /**
 2  
  * - Digitalis Internal Framework v2.0 - (C) 2007, Digitalis Informatica. Distribuicao e Gestao de Informatica, Lda.
 3  
  * Estrada de Paco de Arcos num.9 - Piso -1 2780-666 Paco de Arcos Telefone: (351) 21 4408990 Fax: (351) 21 4408999
 4  
  * http://www.digitalis.pt
 5  
  */
 6  
 package pt.digitalis.dif.dem.managers.impl;
 7  
 
 8  
 import java.util.HashMap;
 9  
 import java.util.Map;
 10  
 
 11  
 import pt.digitalis.dif.dem.Entity;
 12  
 import pt.digitalis.dif.dem.interfaces.IApplication;
 13  
 import pt.digitalis.dif.dem.interfaces.IProvider;
 14  
 import pt.digitalis.dif.dem.interfaces.IService;
 15  
 import pt.digitalis.dif.dem.interfaces.IStage;
 16  
 import pt.digitalis.dif.dem.managers.IParameterManager;
 17  
 import pt.digitalis.dif.dem.objects.parameters.IParameter;
 18  
 import pt.digitalis.dif.dem.objects.parameters.ParameterList;
 19  
 import pt.digitalis.dif.ioc.DIFIoCRegistry;
 20  
 import pt.digitalis.dif.utils.logging.DIFLogger;
 21  
 
 22  
 /**
 23  
  * Manages the DEM parameters, providing operations for access, pooling and persistence.
 24  
  * 
 25  
  * @author Pedro Viegas <a href="mailto:pviegas@digitalis.pt">pviegas@digitalis.pt</a>
 26  
  * @author Rodrigo Gonçalves <a href="mailto:rgoncalves@digitalis.pt">rgoncalves@digitalis.pt</a>
 27  
  * @created 2007/06/01
 28  
  */
 29  0
 public class ParameterManagerImpl implements IParameterManager {
 30  
 
 31  
     /** Map of application parameter lists */
 32  0
     private Map<String, ParameterList> applicationParameters = new HashMap<String, ParameterList>();
 33  
 
 34  
     /** Map of provider parameter lists */
 35  0
     private Map<String, ParameterList> providerParameters = new HashMap<String, ParameterList>();
 36  
 
 37  
     /** Map of service parameter lists */
 38  0
     private Map<String, ParameterList> serviceParameters = new HashMap<String, ParameterList>();
 39  
 
 40  
     /** Map of stage parameter lists */
 41  0
     private Map<String, ParameterList> stageParameters = new HashMap<String, ParameterList>();
 42  
 
 43  
     /** The supported class types for parameter attributes */
 44  0
     private Map<String, String> supportedParameterTypes = null;
 45  
 
 46  
     /** Builds the map of supported parameter types and their corresponding implementations */
 47  
     private void buildSupportedParameterTypesMap()
 48  
     {
 49  
         @SuppressWarnings("rawtypes")
 50  0
         Map<String, IParameter> impls = DIFIoCRegistry.getRegistry().getImplementationsMap(IParameter.class);
 51  
 
 52  0
         supportedParameterTypes = new HashMap<String, String>();
 53  
 
 54  0
         for (String id: impls.keySet())
 55  
         {
 56  0
             IParameter<?> parameter = impls.get(id);
 57  
 
 58  0
             for (Object className: parameter.getSupportedClasses())
 59  
             {
 60  0
                 supportedParameterTypes.put(className.toString(), id);
 61  
             }
 62  
         }
 63  0
     }
 64  
 
 65  
     /**
 66  
      * @see pt.digitalis.dif.dem.managers.IParameterManager#getParameter(pt.digitalis.dif.dem.Entity, java.lang.String,
 67  
      *      java.lang.String)
 68  
      */
 69  
     public IParameter<?> getParameter(Entity entityType, String entityID, String parameterID)
 70  
     {
 71  
 
 72  0
         ParameterList list = getParameters(entityType, entityID);
 73  
 
 74  0
         if (list == null)
 75  0
             return null;
 76  
         else
 77  0
             return list.getParameter(parameterID);
 78  
     }
 79  
 
 80  
     /**
 81  
      * @see pt.digitalis.dif.dem.managers.IParameterManager#getParameterInstanceForType(java.lang.String)
 82  
      */
 83  
     public IParameter<?> getParameterInstanceForType(String typeClassName)
 84  
     {
 85  
 
 86  0
         if (isParameterTypeSupported(typeClassName))
 87  0
             return DIFIoCRegistry.getRegistry().getImplementation(IParameter.class,
 88  0
                     supportedParameterTypes.get(typeClassName));
 89  
         else
 90  
         {
 91  0
             DIFLogger.getLogger().error("Bad usage: Parameter type \"" + typeClassName + "\" not supported: ");
 92  
 
 93  0
             return null;
 94  
         }
 95  
     }
 96  
 
 97  
     /**
 98  
      * @see pt.digitalis.dif.dem.managers.IParameterManager#getParameters(pt.digitalis.dif.dem.Entity, java.lang.String)
 99  
      */
 100  
     public ParameterList getParameters(Entity entityType, String entityID)
 101  
     {
 102  0
         if (entityType.equals(Entity.PROVIDER))
 103  0
             return providerParameters.get(entityID);
 104  0
         else if (entityType.equals(Entity.APPLICATION))
 105  0
             return applicationParameters.get(entityID);
 106  0
         else if (entityType.equals(Entity.SERVICE))
 107  0
             return serviceParameters.get(entityID);
 108  0
         else if (entityType.equals(Entity.STAGE))
 109  0
             return stageParameters.get(entityID);
 110  
         else
 111  0
             return null;
 112  
     }
 113  
 
 114  
     /**
 115  
      * @see pt.digitalis.dif.dem.managers.IParameterManager#getParameters(pt.digitalis.dif.dem.interfaces.IApplication)
 116  
      */
 117  
     public ParameterList getParameters(IApplication application)
 118  
     {
 119  0
         ParameterList list = applicationParameters.get(application.getID());
 120  
 
 121  0
         if (list == null)
 122  
         {
 123  0
             list = new ParameterList();
 124  0
             applicationParameters.put(application.getID(), list);
 125  
         }
 126  
 
 127  0
         return list;
 128  
     }
 129  
 
 130  
     /**
 131  
      * @see pt.digitalis.dif.dem.managers.IParameterManager#getParameters(pt.digitalis.dif.dem.interfaces.IProvider)
 132  
      */
 133  
     public ParameterList getParameters(IProvider provider)
 134  
     {
 135  0
         ParameterList list = providerParameters.get(provider.getID());
 136  
 
 137  0
         if (list == null)
 138  
         {
 139  0
             list = new ParameterList();
 140  0
             providerParameters.put(provider.getID(), list);
 141  
         }
 142  
 
 143  0
         return list;
 144  
     }
 145  
 
 146  
     /**
 147  
      * @see pt.digitalis.dif.dem.managers.IParameterManager#getParameters(pt.digitalis.dif.dem.interfaces.IService)
 148  
      */
 149  
     public ParameterList getParameters(IService service)
 150  
     {
 151  0
         ParameterList list = serviceParameters.get(service.getID());
 152  
 
 153  0
         if (list == null)
 154  
         {
 155  0
             list = new ParameterList();
 156  0
             serviceParameters.put(service.getID(), list);
 157  
         }
 158  
 
 159  0
         return list;
 160  
     }
 161  
 
 162  
     /**
 163  
      * @see pt.digitalis.dif.dem.managers.IParameterManager#getParameters(IStage)
 164  
      */
 165  
     public ParameterList getParameters(IStage stage)
 166  
     {
 167  0
         ParameterList list = stageParameters.get(stage.getID());
 168  
 
 169  0
         if (list == null)
 170  
         {
 171  0
             list = new ParameterList();
 172  0
             stageParameters.put(stage.getID(), list);
 173  
         }
 174  
 
 175  0
         return list;
 176  
     }
 177  
 
 178  
     /**
 179  
      * @see pt.digitalis.dif.dem.managers.IParameterManager#isParameterTypeSupported(java.lang.String)
 180  
      */
 181  
     public boolean isParameterTypeSupported(String typeClassName)
 182  
     {
 183  
 
 184  0
         if (supportedParameterTypes == null)
 185  0
             buildSupportedParameterTypesMap();
 186  
 
 187  0
         return supportedParameterTypes.containsKey(typeClassName);
 188  
     }
 189  
 
 190  
     /**
 191  
      * Registers an application parameter.
 192  
      * 
 193  
      * @param parameter
 194  
      *            the parameter to register
 195  
      */
 196  
     private void registerApplicationParameter(IParameter<?> parameter)
 197  
     {
 198  
 
 199  0
         if (!applicationParameters.containsKey(parameter.getParentID()))
 200  
         {
 201  0
             ParameterList parameters = new ParameterList();
 202  0
             parameters.addParameter(parameter);
 203  0
             applicationParameters.put(parameter.getParentID(), parameters);
 204  
         }
 205  
         else
 206  
         {
 207  0
             applicationParameters.get(parameter.getParentID()).addParameter(parameter);
 208  
         }
 209  0
     }
 210  
 
 211  
     /**
 212  
      * @see pt.digitalis.dif.dem.managers.IParameterManager#registerParameter(pt.digitalis.dif.dem.objects.parameters.IParameter)
 213  
      */
 214  
     public void registerParameter(IParameter<?> parameter)
 215  
     {
 216  
 
 217  0
         if (parameter.getParentType() == Entity.PROVIDER)
 218  
         {
 219  0
             registerProviderParameter(parameter);
 220  
         }
 221  0
         else if (parameter.getParentType() == Entity.APPLICATION)
 222  
         {
 223  0
             registerApplicationParameter(parameter);
 224  
         }
 225  0
         else if (parameter.getParentType() == Entity.SERVICE)
 226  
         {
 227  0
             registerServiceParameter(parameter);
 228  
         }
 229  0
         else if (parameter.getParentType() == Entity.STAGE)
 230  
         {
 231  0
             registerStageParameter(parameter);
 232  
         }
 233  
 
 234  
         // Map<String, ParameterList> parameterCache = null;
 235  
         //
 236  
         // // Determine the correct entity type and corresponding cache map
 237  
         // if (parameter.getParentType() == Entity.PROVIDER)
 238  
         // parameterCache = providerParameters;
 239  
         //
 240  
         // else if (parameter.getParentType() == Entity.APPLICATION)
 241  
         // parameterCache = applicationParameters;
 242  
         //
 243  
         // else if (parameter.getParentType() == Entity.SERVICE)
 244  
         // parameterCache = serviceParameters;
 245  
         //
 246  
         // else if (parameter.getParentType() == Entity.STAGE)
 247  
         // parameterCache = stageParameters;
 248  
         //
 249  
         //
 250  
         // // Get the parameter list object
 251  
         // ParameterList list = parameterCache.get(parameter.getParentID());
 252  
         //
 253  
         // // If the parameter list object is yet to be instantiated create it
 254  
         // if (list == null) {
 255  
         // list = new ParameterList();
 256  
         //
 257  
         // // Add it to the cache map
 258  
         // parameterCache.put(parameter.getParentID(), list);
 259  
         // }
 260  
         //
 261  
         // // Add the parameter to the obtained list
 262  
         // list.addParameter(parameter);
 263  0
     }
 264  
 
 265  
     /**
 266  
      * Registers a provider parameter.
 267  
      * 
 268  
      * @param parameter
 269  
      *            the parameter to register
 270  
      */
 271  
     private void registerProviderParameter(IParameter<?> parameter)
 272  
     {
 273  
 
 274  0
         if (!providerParameters.containsKey(parameter.getParentID()))
 275  
         {
 276  0
             ParameterList parameters = new ParameterList();
 277  0
             parameters.addParameter(parameter);
 278  0
             providerParameters.put(parameter.getParentID(), parameters);
 279  
         }
 280  
         else
 281  
         {
 282  0
             providerParameters.get(parameter.getParentID()).addParameter(parameter);
 283  
         }
 284  0
     }
 285  
 
 286  
     /**
 287  
      * Registers a service parameter.
 288  
      * 
 289  
      * @param parameter
 290  
      *            the parameter to register
 291  
      */
 292  
     private void registerServiceParameter(IParameter<?> parameter)
 293  
     {
 294  
 
 295  0
         if (!serviceParameters.containsKey(parameter.getParentID()))
 296  
         {
 297  0
             ParameterList parameters = new ParameterList();
 298  0
             parameters.addParameter(parameter);
 299  0
             serviceParameters.put(parameter.getParentID(), parameters);
 300  
         }
 301  
         else
 302  
         {
 303  0
             serviceParameters.get(parameter.getParentID()).addParameter(parameter);
 304  
         }
 305  0
     }
 306  
 
 307  
     /**
 308  
      * Registers a stage parameter.
 309  
      * 
 310  
      * @param parameter
 311  
      *            the parameter to register
 312  
      */
 313  
     private void registerStageParameter(IParameter<?> parameter)
 314  
     {
 315  
 
 316  0
         if (!stageParameters.containsKey(parameter.getParentID()))
 317  
         {
 318  0
             ParameterList parameters = new ParameterList();
 319  0
             parameters.addParameter(parameter);
 320  0
             stageParameters.put(parameter.getParentID(), parameters);
 321  
         }
 322  
         else
 323  
         {
 324  0
             stageParameters.get(parameter.getParentID()).addParameter(parameter);
 325  
         }
 326  0
     }
 327  
 }