Changeset 1028 for raptor-client


Ignore:
Timestamp:
07/03/11 19:19:34 (9 years ago)
Author:
philsmart
Message:
 
Location:
raptor-client/trunk/src/main/java/uk/ac/cardiff/raptor
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • raptor-client/trunk/src/main/java/uk/ac/cardiff/raptor/remoting/client/DefaultEventReleaseClient.java

    r1024 r1028  
    1414 * limitations under the License. 
    1515 */ 
     16 
    1617package uk.ac.cardiff.raptor.remoting.client; 
    1718 
     
    2627import uk.ac.cardiff.raptor.registry.EndpointRegistry; 
    2728 
     29/** 
     30 * The Class DefaultEventReleaseClient. 
     31 */ 
    2832public class DefaultEventReleaseClient implements EventReleaseClient { 
    2933 
    30         /** Class logger. */ 
    31         private final Logger log = LoggerFactory.getLogger(DefaultEventReleaseClient.class); 
     34    /** Class logger. */ 
     35    private final Logger log = LoggerFactory.getLogger(DefaultEventReleaseClient.class); 
    3236 
    33         /** Encapsulation of all endpoints this client can communication with. */ 
    34         private EndpointRegistry endpointRegistry; 
     37    /** Encapsulation of all endpoints this client can communication with. */ 
     38    private EndpointRegistry endpointRegistry; 
    3539 
    36         /** The engine that performs event release to a client endpoint. */ 
    37         private EventReleaseEngine eventReleaseEngine; 
     40    /** The engine that performs event release to a client endpoint. */ 
     41    private EventReleaseEngine eventReleaseEngine; 
    3842 
    39         /** Whether events should be released. Defaults to true. */ 
    40         private boolean enableEventRelease; 
     43    /** Whether events should be released. Defaults to true. */ 
     44    private boolean enableEventRelease; 
    4145 
    42         public DefaultEventReleaseClient() { 
    43                 eventReleaseEngine = new EventReleaseEngine(); 
    44                 enableEventRelease = true; 
    45         } 
     46    /** 
     47     * Instantiates a new default event release client. 
     48     */ 
     49    public DefaultEventReleaseClient() { 
     50        eventReleaseEngine = new EventReleaseEngine(); 
     51        enableEventRelease = true; 
     52    } 
    4653 
    47         @Override 
    48         public boolean release(List<Event> events, ServiceMetadata serviceMetadata) throws ReleaseFailureException { 
    49                 boolean success = false; 
    50                 if (enableEventRelease) { 
    51                         log.info("[Event Release Called]"); 
    52                         success = eventReleaseEngine.release(endpointRegistry, events, serviceMetadata); 
    53                         endpointRegistry.storeReleaseInformationIfEnabled(); 
    54                         log.info("[--Events released to all listening endpoints {}--]", success); 
    55                 } 
     54    /* 
     55     * (non-Javadoc) 
     56     *  
     57     * @see uk.ac.cardiff.raptor.remoting.client.EventReleaseClient#release(java.util.List, 
     58     * uk.ac.cardiff.model.ServiceMetadata) 
     59     */ 
     60    public boolean release(List<Event> events, ServiceMetadata serviceMetadata) throws ReleaseFailureException { 
     61        boolean success = false; 
     62        if (enableEventRelease) { 
     63            log.info("[Event Release Called]"); 
     64            success = eventReleaseEngine.release(endpointRegistry, events, serviceMetadata); 
     65            endpointRegistry.storeReleaseInformationIfEnabled(); 
     66            log.info("[--Events released to all listening endpoints {}--]", success); 
     67        } 
    5668 
    57                 return success; 
    58         } 
     69        return success; 
     70    } 
    5971 
    60         public List<Endpoint> getEndpoints() { 
    61                 return endpointRegistry.getEndpoints(); 
    62         } 
     72    /* 
     73     * (non-Javadoc) 
     74     *  
     75     * @see uk.ac.cardiff.raptor.remoting.client.EventReleaseClient#getEndpoints() 
     76     */ 
     77    public List<Endpoint> getEndpoints() { 
     78        return endpointRegistry.getEndpoints(); 
     79    } 
    6380 
    64         public void setEndpointRegistry(EndpointRegistry endpointRegistry) { 
    65                 this.endpointRegistry = endpointRegistry; 
    66         } 
     81    /** 
     82     * Sets the endpoint registry. 
     83     *  
     84     * @param endpointRegistry the new endpoint registry 
     85     */ 
     86    public void setEndpointRegistry(EndpointRegistry endpointRegistry) { 
     87        this.endpointRegistry = endpointRegistry; 
     88    } 
    6789 
    68         public EndpointRegistry getEndpointRegistry() { 
    69                 return endpointRegistry; 
    70         } 
     90    /** 
     91     * Gets the endpoint registry. 
     92     *  
     93     * @return the endpoint registry 
     94     */ 
     95    public EndpointRegistry getEndpointRegistry() { 
     96        return endpointRegistry; 
     97    } 
    7198 
    72         public void setEventReleaseEngine(EventReleaseEngine eventReleaseEngine) { 
    73                 this.eventReleaseEngine = eventReleaseEngine; 
    74         } 
     99    /** 
     100     * Sets the event release engine. 
     101     *  
     102     * @param eventReleaseEngine the new event release engine 
     103     */ 
     104    public void setEventReleaseEngine(EventReleaseEngine eventReleaseEngine) { 
     105        this.eventReleaseEngine = eventReleaseEngine; 
     106    } 
    75107 
    76         public EventReleaseEngine getEventReleaseEngine() { 
    77                 return eventReleaseEngine; 
    78         } 
     108    /** 
     109     * Gets the event release engine. 
     110     *  
     111     * @return the event release engine 
     112     */ 
     113    public EventReleaseEngine getEventReleaseEngine() { 
     114        return eventReleaseEngine; 
     115    } 
    79116 
    80         /** 
    81          * @param enableEventRelease 
    82          *            the enableEventRelease to set 
    83          */ 
    84         public void setEnableEventRelease(boolean enableEventRelease) { 
    85                 this.enableEventRelease = enableEventRelease; 
    86         } 
     117    /** 
     118     * Sets the enable event release. 
     119     *  
     120     * @param enableEventRelease the enableEventRelease to set 
     121     */ 
     122    public void setEnableEventRelease(boolean enableEventRelease) { 
     123        this.enableEventRelease = enableEventRelease; 
     124    } 
    87125 
    88         /** 
    89          * @return the enableEventRelease 
    90          */ 
    91         public boolean isEnableEventRelease() { 
    92                 return enableEventRelease; 
    93         } 
     126    /** 
     127     * Checks if is enable event release. 
     128     *  
     129     * @return the enableEventRelease 
     130     */ 
     131    public boolean isEnableEventRelease() { 
     132        return enableEventRelease; 
     133    } 
    94134 
    95         public boolean isEnabled(){ 
    96             return isEnableEventRelease(); 
    97         } 
     135    /* 
     136     * (non-Javadoc) 
     137     *  
     138     * @see uk.ac.cardiff.raptor.remoting.client.EventReleaseClient#isEnabled() 
     139     */ 
     140    public boolean isEnabled() { 
     141        return isEnableEventRelease(); 
     142    } 
    98143 
    99144} 
  • raptor-client/trunk/src/main/java/uk/ac/cardiff/raptor/runtimeutils/ReflectionHelper.java

    r796 r1028  
    1717 * 
    1818 */ 
     19 
    1920package uk.ac.cardiff.raptor.runtimeutils; 
    2021 
     
    2526import java.net.URL; 
    2627import java.util.ArrayList; 
    27 import java.util.Arrays; 
    28 import java.util.HashMap; 
    2928import java.util.List; 
    3029import java.util.jar.JarEntry; 
     
    3938/** 
    4039 * @author philsmart 
    41  * 
     40 *  
    4241 */ 
    4342public class ReflectionHelper { 
    4443 
    45         /** Class logger */ 
    46         private static final Logger log = LoggerFactory.getLogger(ReflectionHelper.class); 
    47  
    48         private static final String EVENT_PACKAGE_NAME ="uk.ac.cardiff.model.event"; 
    49  
    50         private static final String JAR_PREFIX = "jar"; 
    51  
    52         /** 
    53          * Checks if an attribute exists on a class by finding if it has a 'get' 
    54          * method associated on the class 
    55          * 
    56          * @param entry 
    57          * @param attributeID 
    58          */ 
    59         public static boolean classHasAttribute(Object object, String attributeID) { 
    60                 try { 
    61                         Class id = object.getClass(); 
    62                         String fieldAsMethod = prepareMethodNameGet(attributeID); 
    63                         Method getter = id.getMethod(fieldAsMethod, new Class[] {}); 
    64                         return true; 
    65                 } catch (Throwable e) { 
    66                         log.error("{}",e.getMessage()); 
    67                         return false; 
    68  
    69                 } 
    70  
    71         } 
    72  
    73         /** 
    74          * Sets the attribute <code>attributeID</code> to null on the class 
    75          * <code>object</code>. Iterates through the list of methods to find the 
    76          * setter method, so as the parameter types to the method e.g. using 
    77          * <code>id.getMethod(..)</code>, do not need to be known. 
    78          * 
    79          * @param object 
    80          * @param attributeID 
    81          */ 
    82         public static void nullAttribute(Object object, String attributeID) { 
    83                 try { 
    84                         // log.debug("Setting {} to null on object {}",attributeID,object); 
    85                         Class id = object.getClass(); 
    86                         String fieldAsMethod = prepareMethodNameSet(attributeID); 
    87                         Method[] methods = id.getMethods(); 
    88                         Method setter = null; 
    89                         for (Method method : methods) { 
    90                                 if (method.getName().equals(fieldAsMethod)) 
    91                                         setter = method; 
    92                         } 
    93                         if (setter != null) { 
    94                                 Object param = null; 
    95                                 setter.invoke(object, new Object[] { param }); 
    96                         } else { 
    97                                 log.error("Attrubute {} did not exist on object {}", attributeID, object); 
    98                         } 
    99                 } catch (Throwable e) { 
    100                         log.error("Field name '" + attributeID + "' does not match internal model attribute"); 
    101                         e.printStackTrace(); 
    102                         System.exit(1); 
    103                 } 
    104  
    105         } 
    106  
    107         public static String determineSubclassForMethods(String methodOne, String methodTwo) throws ReflectionException { 
    108                 Object methodOneObject = findEntrySubclassForMethodAsObject(methodOne); 
    109                 Object methodTwoObject = findEntrySubclassForMethodAsObject(methodTwo); 
    110                 if (methodOneObject != null && methodTwoObject != null) { 
    111                         log.debug("Classes found, methodOne {}, methodTwo {}", methodOneObject.getClass(), methodTwoObject.getClass()); 
    112                         log.debug("Is methodOne a superclass of methodTwo {}", (methodOneObject.getClass().isAssignableFrom(methodTwoObject.getClass()))); 
    113                         if (methodTwoObject.getClass().isAssignableFrom(methodOneObject.getClass())) { 
    114                                 return methodOneObject.getClass().getSimpleName(); 
    115                         } else { 
    116                                 return methodTwoObject.getClass().getSimpleName(); 
    117                         } 
    118                 } else { 
    119                         log.error("Could not determine which method belongs to the subclass, from {} and {}", methodOne, methodTwo); 
    120                         throw new ReflectionException("Could not determine which method belongs to the subclass"); 
    121                 } 
    122  
    123         } 
    124  
    125         /** 
    126          * This is terrible code. Finds all fieldnames of all classes that are subclasses of 
    127          * the <code>uk.ac.cardiff.model.event.Event</code> class. 
    128          * 
    129          * @return 
    130          */ 
    131         public static List<Suggestion> getFieldsFromEntrySubClasses() { 
    132                 List<Suggestion> allFields = new ArrayList<Suggestion>(); 
    133                 String forPckgName = EVENT_PACKAGE_NAME; 
    134                 String jarFile = getJARFilePath(forPckgName); 
    135                 jarFile = jarFile.replace("file:", ""); 
    136                 log.debug("jar {}",jarFile); 
    137                 List<String> classes = getClassNamesInJarOrFolder(jarFile, forPckgName); 
    138  
    139                 ArrayList allclasses = new ArrayList(); 
    140                 for (String classname : classes) { 
    141                         try { 
    142                                 Object o = Class.forName(classname.replace(".class", "")).newInstance(); 
    143                                  if (o!=null)log.debug("found object {}",o.getClass()); 
    144                                 if (o instanceof uk.ac.cardiff.model.event.Event) { 
    145                                         allclasses.add(o); 
    146                                 } 
    147                         } catch (ClassNotFoundException cnfex) { 
    148                                 log.error("error getting subclasses of Entry, {}", cnfex); 
    149                         } catch (InstantiationException iex) { 
    150                                 // log.error("{}", iex); 
    151                         } catch (IllegalAccessException iaex) { 
    152                                 // The class is not public 
    153                         } 
    154                 } 
    155                 for (Object object : allclasses) { 
    156                         Field[] fields = object.getClass().getDeclaredFields(); 
    157                         for (Field field : fields) { 
    158                             //if field is another class in the same package, then expand its methods 
    159                             if (field.getType().getCanonicalName().contains(EVENT_PACKAGE_NAME)){ 
    160                                 Object o=null; 
    161                                 String fieldName = field.getName(); 
    162                                 try { 
    163                                                  o = Class.forName(field.getType().getCanonicalName()).newInstance(); 
    164                                         } catch (Exception e) { 
    165                                         } 
    166                                         if (o!=null){ 
    167                                                 Field[] newFields = o.getClass().getDeclaredFields(); 
    168                                                 for (Field newField : newFields){ 
    169                                                         //format it for hibernate 
    170                                                         allFields.add(new Suggestion(object.getClass().getCanonicalName(),fieldName+"."+newField.getName())); 
    171                                                 } 
    172  
    173                                         } 
    174                             } 
    175                             else{ 
    176                                 allFields.add(new Suggestion(object.getClass().getCanonicalName(),field.getName())); 
    177                             } 
    178                         } 
    179  
    180                 } 
    181  
    182                 return allFields; 
    183         } 
    184  
    185         public static Object findEntrySubclassForMethodAsObject(String fieldName) { 
    186                 String forPckgName = EVENT_PACKAGE_NAME; 
    187                 String jarFile = getJARFilePath(forPckgName); 
    188                 jarFile = jarFile.replace("file:", ""); 
    189                 log.debug("jar {}",jarFile); 
    190                 List<String> classes = getClassNamesInJarOrFolder(jarFile,forPckgName); 
    191                 ArrayList allclasses = new ArrayList(); 
    192                 for (String classname : classes) { 
    193                         try { 
    194                                 Object o = Class.forName(classname.replace(".class", "")).newInstance(); 
    195                                 if (o instanceof uk.ac.cardiff.model.event.Event) { 
    196                                         allclasses.add(o); 
    197                                 } 
    198                         } catch (ClassNotFoundException cnfex) { 
    199                                 log.error("{}", cnfex); 
    200                         } catch (InstantiationException iex) { 
    201                                 // We try to instantiate an interface 
    202                                 // or an object that does not have a 
    203                                 // default constructor 
    204                         } catch (IllegalAccessException iaex) { 
    205                                 // The class is not public 
    206                         } 
    207                 } 
    208  
    209                 Object objectWithMethod = null; 
    210                 for (Object object : allclasses) { 
    211                         if (hasField(object, fieldName)) { 
    212                                 objectWithMethod = object; 
    213                         } 
    214                 } 
    215                 if (objectWithMethod != null) { 
    216                         log.debug("Object " + objectWithMethod.getClass().getName() + " has method " + fieldName + " returning simple name " 
    217                                         + objectWithMethod.getClass().getSimpleName()); 
    218                         return objectWithMethod; 
    219                 } 
    220  
    221                 return null; 
    222  
    223         } 
    224  
    225         /** 
    226          * This method finds the simple name of the class in the uk.ac.cardiff.model 
    227          * package that contains the <code>fieldName</code>. 
    228          * 
    229          * @param fieldName 
    230          * @return 
    231          */ 
    232         public static String findEntrySubclassForMethod(String fieldName) { 
    233                 String forPckgName = EVENT_PACKAGE_NAME; 
    234                 String jarFile = getJARFilePath(forPckgName); 
    235                 jarFile = jarFile.replace("file:", ""); 
    236                 List<String> classes = getClassNamesInJarOrFolder(jarFile,forPckgName); 
    237                 ArrayList allclasses = new ArrayList(); 
    238                 for (String classname : classes) { 
    239                         try { 
    240                                 Object o = Class.forName(classname.replace(".class", "")).newInstance(); 
    241                                 if (o instanceof uk.ac.cardiff.model.event.Event) { 
    242                                         // log.debug("Found classname: "+classname.replace(".class", 
    243                                         // "")); 
    244                                         allclasses.add(o); 
    245                                 } 
    246                         } catch (ClassNotFoundException cnfex) { 
    247                                 log.error("{}", cnfex); 
    248                         } catch (InstantiationException iex) { 
    249                                 // We try to instantiate an interface 
    250                                 // or an object that does not have a 
    251                                 // default constructor 
    252                         } catch (IllegalAccessException iaex) { 
    253                                 // The class is not public 
    254                         } 
    255                 } 
    256  
    257                 Object objectWithMethod = null; 
    258                 for (Object object : allclasses) { 
    259                         if (hasField(object, fieldName)) { 
    260                                 objectWithMethod = object; 
    261                         } 
    262                 } 
    263                 if (objectWithMethod != null) { 
    264                         log.debug("Object " + objectWithMethod.getClass().getName() + " has method " + fieldName + " returning simple name " 
    265                                         + objectWithMethod.getClass().getSimpleName()); 
    266                         return objectWithMethod.getClass().getSimpleName(); 
    267                 } 
    268  
    269                 return null; 
    270  
    271         } 
    272  
    273         /** 
    274          * Gets the name, as a string, of the JAR file that contains the package 
    275          * <code>pckgname</code> 
    276          * 
    277          * @param pckgname 
    278          * @return the name, as a <code>String</code>, of the JAR file that contains the package <code>pckgname</code> 
    279          */ 
    280         private static String getJARFilePath(String pckgname) { 
    281                 String name = new String(pckgname); 
    282                 if (!name.startsWith("/")) { 
    283                         name = "/" + name; 
    284                 } 
    285                 name = name.replace('.', '/'); 
    286                 //log.debug("package name: " + name); 
    287                 URL url = ReflectionHelper.class.getResource(name); 
    288             //log.debug("URL: "+url); 
    289                 if (url != null && url.getPath().contains("!")) 
    290                         return url.getPath().substring(0, url.getPath().indexOf('!')); 
    291                 else if (url != null) 
    292                         return url.getPath(); 
    293                 else 
    294                         return null; 
    295         } 
    296  
    297         /** 
    298          * Gets the names of the classes, as strings, in the jar 
    299          * <code>jarName</code> and package <code>packageName</code> 
    300          * 
    301          * @param jarName 
    302          * @param packageName 
    303          * @return 
    304          */ 
    305         public static List<String> getClasseNamesInPackageJAR(String jarName, String packageName) { 
    306                 ArrayList<String> classes = new ArrayList<String>(); 
    307                 packageName = packageName.replaceAll("\\.", "/"); 
    308                 try { 
    309                         JarInputStream jarFile = new JarInputStream(new FileInputStream(jarName)); 
    310                         JarEntry jarEntry; 
    311                         while (true) { 
    312                                 jarEntry = jarFile.getNextJarEntry(); 
    313                                 if (jarEntry == null) { 
    314                                         break; 
    315                                 } 
    316                                 if ((jarEntry.getName().startsWith(packageName)) && (jarEntry.getName().endsWith(".class"))) { 
    317                                         classes.add(jarEntry.getName().replaceAll("/", "\\.")); 
    318                                 } 
    319                         } 
    320                 } catch (Exception e) { 
    321                         e.printStackTrace(); 
    322                 } 
    323                 return classes; 
    324         } 
    325  
    326         private static List<String> getClassNamesInJarOrFolder(String jarOrDirectoryName, String packageName){ 
    327                 if (jarOrDirectoryName.endsWith(JAR_PREFIX)){ 
    328                         return getClasseNamesInPackageJAR(jarOrDirectoryName, packageName); 
    329                 } 
    330                 else { 
    331                         return getClasseNamesInDirectory(jarOrDirectoryName, packageName); 
    332                 } 
    333         } 
    334  
    335         /** 
    336          * Gets the names of the classes, as strings, in the directory 
    337          * <code>directoryName</code> and package <code>packageName</code> 
    338          * 
    339          * @param directoryName the name of the directory to look for classes 
    340          * @param packageName the name of the package the classes belong to 
    341          * @return a list of class names in the current folder 
    342          */ 
    343         private static List<String> getClasseNamesInDirectory(String directoryName, String packageName) { 
    344                 ArrayList<String> classes = new ArrayList<String>(); 
    345                 packageName = packageName.replaceAll("\\.", "/"); 
    346                 try { 
    347                         File dir = new File(directoryName); 
    348                         //log.debug("Directory {}, is directory {}",dir, dir.isDirectory()); 
    349                         for (String file : dir.list()){ 
    350                                 if ((file.endsWith(".class"))) { 
    351                                         //log.debug("Found class file, {}",file); 
    352                                         classes.add(packageName.replaceAll("/", "\\.")+"."+file); 
    353                                 } 
    354                         } 
    355                 } catch (Exception e) { 
    356                         log.error("Error in getting classnames in directory {}",directoryName); 
    357                 } 
    358                 return classes; 
    359         } 
    360  
    361         /** 
    362          * Code taken and adapted from the JWhich project. Finds all subclasses of 
    363          * the uk.ac.cardiff.model.Entry class in the package <code>pckgname</code> 
    364          * if they exist outside any JAR libraries, use 
    365          * <code>getClasseNamesInPackageJAR</code> 
    366          * 
    367          * @param pckgname 
    368          * @return 
    369          */ 
    370         private static Object[] subclassesInDirectory(String pckgname) { 
    371                 ArrayList<Object> allclasses = new ArrayList(); 
    372  
    373                 String name = new String(pckgname); 
    374                 if (!name.startsWith("/")) { 
    375                         name = "/" + name; 
    376                 } 
    377                 name = name.replace('.', '/'); 
    378  
    379                 // Get a File object for the package 
    380                 log.debug("package name: " + name); 
    381                 URL url = ReflectionHelper.class.getResource(name); 
    382                 log.debug("URL: " + url); 
    383                 File directory = new File(url.getFile()); 
    384  
    385                 // New code 
    386                 // ====== 
    387                 if (directory.exists()) { 
    388                         // Get the list of the files contained in the package 
    389                         String[] files = directory.list(); 
    390                         for (int i = 0; i < files.length; i++) { 
    391  
    392                                 // we are only interested in .class files 
    393                                 if (files[i].endsWith(".class")) { 
    394                                         // removes the .class extension 
    395                                         String classname = files[i].substring(0, files[i].length() - 6); 
    396                                         try { 
    397                                                 log.debug("classname: " + classname); 
    398                                                 // Try to create an instance of the object 
    399                                                 Object o = Class.forName(pckgname + "." + classname).newInstance(); 
    400                                                 if (o instanceof uk.ac.cardiff.model.event.Event) { 
    401                                                         // log.debug("Found classname: "+classname); 
    402                                                         allclasses.add(o); 
    403                                                 } 
    404                                         } catch (ClassNotFoundException cnfex) { 
    405                                                 log.error("{}", cnfex); 
    406                                         } catch (InstantiationException iex) { 
    407                                                 // We try to instantiate an interface 
    408                                                 // or an object that does not have a 
    409                                                 // default constructor 
    410                                         } catch (IllegalAccessException iaex) { 
    411                                                 // The class is not public 
    412                                         } 
    413                                 } 
    414                         } 
    415                 } 
    416                 return allclasses.toArray(); 
    417         } 
    418  
    419         /** 
    420          * Checks whether the Object <code>object</code> has the field 
    421          * <code>fieldName</code> 
    422          * 
    423          * @param object 
    424          * @param fieldName 
    425          * @return 
    426          */ 
    427         private static Boolean hasField(Object object, String fieldName) { 
    428                 try { 
    429                         Field[] fields = object.getClass().getDeclaredFields(); 
    430                         for (Field field : fields) 
    431                                 if (field.getName().equals(fieldName)) 
    432                                         return true; 
    433  
    434                 } catch (Exception e) { 
    435                         e.printStackTrace(); 
    436                 } 
    437                 return false; 
    438  
    439         } 
    440  
    441         public static String prepareMethodNameSet(String method) { 
    442                 if (method.length() > 0) { 
    443                     String name = "set"; 
    444                         // now capitalise the first letter of the method name 
    445                         Character firstLetter = method.charAt(0); 
    446                         firstLetter = Character.toUpperCase(firstLetter); 
    447                         String newMethodName = method.substring(1, method.length()); 
    448                         name += firstLetter + newMethodName; 
    449                         // System.out.println("method name: " + name); 
    450                         return name; 
    451  
    452                 } 
    453                 return method; 
    454  
    455         } 
    456  
    457         /** 
    458          * @param fieldname 
    459          * @return 
    460          */ 
    461         public static String prepareMethodNameGet(String method) { 
    462                 if (method.length() > 0) { 
    463                     String name = "get"; 
    464                         // now capitalise the first letter of the method name 
    465                         Character firstLetter = method.charAt(0); 
    466                         firstLetter = Character.toUpperCase(firstLetter); 
    467                         String newMethodName = method.substring(1, method.length()); 
    468                         name += firstLetter + newMethodName; 
    469                         // System.out.println("method name: " + name); 
    470                         return name; 
    471  
    472                 } 
    473                 return method; 
    474         } 
    475  
    476         public static Object getValueFromObject(String fieldname, Object object) { 
    477                 try { 
    478                         Class<?> id = object.getClass(); 
    479                         String fieldAsMethod = ReflectionHelper.prepareMethodNameGet(fieldname); 
    480                         Method getter = id.getMethod(fieldAsMethod, new Class[] {}); 
    481                         Object result = getter.invoke(object, new Object[] {}); 
    482                         return result; 
    483                 } catch (Throwable e) { 
    484                         log.error("Field name '" + fieldname + "' does not match internal model attribute"); 
    485                         e.printStackTrace(); 
    486  
    487                 } 
    488                 return null; 
    489         } 
    490  
    491         public static void setValueOnObject(String fieldname, Object param, Object object) { 
    492                 try { 
    493                         Class<?> id = object.getClass(); 
    494                         String fieldAsMethod = ReflectionHelper.prepareMethodNameSet(fieldname); 
    495                         Method setter = id.getMethod(fieldAsMethod, new Class[] { param.getClass() }); 
    496                         setter.invoke(object, new Object[] { param }); 
    497                 } catch (Throwable e) { 
    498                         log.error("Field name '" + fieldname + "' does not match internal model attribute, or parameters are wrong"); 
    499  
    500                 } 
    501         } 
     44    /** Class logger */ 
     45    private static final Logger log = LoggerFactory.getLogger(ReflectionHelper.class); 
     46 
     47    private static final String EVENT_PACKAGE_NAME = "uk.ac.cardiff.model.event"; 
     48 
     49    private static final String JAR_PREFIX = "jar"; 
     50 
     51    /** 
     52     * Checks if an attribute exists on a class by finding if it has a 'get' method associated on the class 
     53     *  
     54     * @param entry 
     55     * @param attributeID 
     56     */ 
     57    public static boolean classHasAttribute(Object object, String attributeID) { 
     58        try { 
     59            Class id = object.getClass(); 
     60            String fieldAsMethod = prepareMethodNameGet(attributeID); 
     61            Method getter = id.getMethod(fieldAsMethod, new Class[] {}); 
     62            return true; 
     63        } catch (Throwable e) { 
     64            log.error("{}", e.getMessage()); 
     65            return false; 
     66 
     67        } 
     68 
     69    } 
     70 
     71    /** 
     72     * Sets the attribute <code>attributeID</code> to null on the class <code>object</code>. Iterates through the list 
     73     * of methods to find the setter method, so as the parameter types to the method e.g. using 
     74     * <code>id.getMethod(..)</code>, do not need to be known. 
     75     *  
     76     * @param object 
     77     * @param attributeID 
     78     */ 
     79    public static void nullAttribute(Object object, String attributeID) { 
     80        try { 
     81            // log.debug("Setting {} to null on object {}",attributeID,object); 
     82            Class id = object.getClass(); 
     83            String fieldAsMethod = prepareMethodNameSet(attributeID); 
     84            Method[] methods = id.getMethods(); 
     85            Method setter = null; 
     86            for (Method method : methods) { 
     87                if (method.getName().equals(fieldAsMethod)) 
     88                    setter = method; 
     89            } 
     90            if (setter != null) { 
     91                Object param = null; 
     92                setter.invoke(object, new Object[] {param}); 
     93            } else { 
     94                log.error("Attrubute {} did not exist on object {}", attributeID, object); 
     95            } 
     96        } catch (Throwable e) { 
     97            log.error("Field name '" + attributeID + "' does not match internal model attribute"); 
     98            e.printStackTrace(); 
     99            System.exit(1); 
     100        } 
     101 
     102    } 
     103 
     104    public static String determineSubclassForMethods(String methodOne, String methodTwo) throws ReflectionException { 
     105        Object methodOneObject = findEntrySubclassForMethodAsObject(methodOne); 
     106        Object methodTwoObject = findEntrySubclassForMethodAsObject(methodTwo); 
     107        if (methodOneObject != null && methodTwoObject != null) { 
     108            log.debug("Classes found, methodOne {}, methodTwo {}", methodOneObject.getClass(), 
     109                    methodTwoObject.getClass()); 
     110            log.debug("Is methodOne a superclass of methodTwo {}", 
     111                    (methodOneObject.getClass().isAssignableFrom(methodTwoObject.getClass()))); 
     112            if (methodTwoObject.getClass().isAssignableFrom(methodOneObject.getClass())) { 
     113                return methodOneObject.getClass().getSimpleName(); 
     114            } else { 
     115                return methodTwoObject.getClass().getSimpleName(); 
     116            } 
     117        } else { 
     118            log.error("Could not determine which method belongs to the subclass, from {} and {}", methodOne, methodTwo); 
     119            throw new ReflectionException("Could not determine which method belongs to the subclass"); 
     120        } 
     121 
     122    } 
     123 
     124    /** 
     125     * This is terrible code. Finds all fieldnames of all classes that are subclasses of the 
     126     * <code>uk.ac.cardiff.model.event.Event</code> class. 
     127     *  
     128     * @return 
     129     */ 
     130    public static List<Suggestion> getFieldsFromEntrySubClasses() { 
     131        List<Suggestion> allFields = new ArrayList<Suggestion>(); 
     132        String forPckgName = EVENT_PACKAGE_NAME; 
     133        String jarFile = getJARFilePath(forPckgName); 
     134        jarFile = jarFile.replace("file:", ""); 
     135        log.debug("jar {}", jarFile); 
     136        List<String> classes = getClassNamesInJarOrFolder(jarFile, forPckgName); 
     137 
     138        ArrayList allclasses = new ArrayList(); 
     139        for (String classname : classes) { 
     140            try { 
     141                Object o = Class.forName(classname.replace(".class", "")).newInstance(); 
     142                if (o != null) 
     143                    log.debug("found object {}", o.getClass()); 
     144                if (o instanceof uk.ac.cardiff.model.event.Event) { 
     145                    allclasses.add(o); 
     146                } 
     147            } catch (ClassNotFoundException cnfex) { 
     148                log.error("error getting subclasses of Entry, {}", cnfex); 
     149            } catch (InstantiationException iex) { 
     150                // log.error("{}", iex); 
     151            } catch (IllegalAccessException iaex) { 
     152                // The class is not public 
     153            } 
     154        } 
     155        for (Object object : allclasses) { 
     156            Field[] fields = object.getClass().getDeclaredFields(); 
     157            for (Field field : fields) { 
     158                // if field is another class in the same package, then expand its methods 
     159                if (field.getType().getCanonicalName().contains(EVENT_PACKAGE_NAME)) { 
     160                    Object o = null; 
     161                    String fieldName = field.getName(); 
     162                    try { 
     163                        o = Class.forName(field.getType().getCanonicalName()).newInstance(); 
     164                    } catch (Exception e) { 
     165                    } 
     166                    if (o != null) { 
     167                        Field[] newFields = o.getClass().getDeclaredFields(); 
     168                        for (Field newField : newFields) { 
     169                            // format it for hibernate 
     170                            allFields.add(new Suggestion(object.getClass().getCanonicalName(), fieldName + "." 
     171                                    + newField.getName())); 
     172                        } 
     173 
     174                    } 
     175                } else { 
     176                    allFields.add(new Suggestion(object.getClass().getCanonicalName(), field.getName())); 
     177                } 
     178            } 
     179 
     180        } 
     181 
     182        return allFields; 
     183    } 
     184 
     185    public static Object findEntrySubclassForMethodAsObject(String fieldName) { 
     186        String forPckgName = EVENT_PACKAGE_NAME; 
     187        String jarFile = getJARFilePath(forPckgName); 
     188        jarFile = jarFile.replace("file:", ""); 
     189        log.debug("jar {}", jarFile); 
     190        List<String> classes = getClassNamesInJarOrFolder(jarFile, forPckgName); 
     191        ArrayList allclasses = new ArrayList(); 
     192        for (String classname : classes) { 
     193            try { 
     194                Object o = Class.forName(classname.replace(".class", "")).newInstance(); 
     195                if (o instanceof uk.ac.cardiff.model.event.Event) { 
     196                    allclasses.add(o); 
     197                } 
     198            } catch (ClassNotFoundException cnfex) { 
     199                log.error("{}", cnfex); 
     200            } catch (InstantiationException iex) { 
     201                // We try to instantiate an interface 
     202                // or an object that does not have a 
     203                // default constructor 
     204            } catch (IllegalAccessException iaex) { 
     205                // The class is not public 
     206            } 
     207        } 
     208 
     209        Object objectWithMethod = null; 
     210        for (Object object : allclasses) { 
     211            if (hasField(object, fieldName)) { 
     212                objectWithMethod = object; 
     213            } 
     214        } 
     215        if (objectWithMethod != null) { 
     216            log.debug("Object " + objectWithMethod.getClass().getName() + " has method " + fieldName 
     217                    + " returning simple name " + objectWithMethod.getClass().getSimpleName()); 
     218            return objectWithMethod; 
     219        } 
     220 
     221        return null; 
     222 
     223    } 
     224 
     225    /** 
     226     * This method finds the simple name of the class in the uk.ac.cardiff.model package that contains the 
     227     * <code>fieldName</code>. 
     228     *  
     229     * @param fieldName 
     230     * @return 
     231     */ 
     232    public static String findEntrySubclassForMethod(String fieldName) { 
     233        String forPckgName = EVENT_PACKAGE_NAME; 
     234        String jarFile = getJARFilePath(forPckgName); 
     235        jarFile = jarFile.replace("file:", ""); 
     236        List<String> classes = getClassNamesInJarOrFolder(jarFile, forPckgName); 
     237        ArrayList allclasses = new ArrayList(); 
     238        for (String classname : classes) { 
     239            try { 
     240                Object o = Class.forName(classname.replace(".class", "")).newInstance(); 
     241                if (o instanceof uk.ac.cardiff.model.event.Event) { 
     242                    // log.debug("Found classname: "+classname.replace(".class", 
     243                    // "")); 
     244                    allclasses.add(o); 
     245                } 
     246            } catch (ClassNotFoundException cnfex) { 
     247                log.error("{}", cnfex); 
     248            } catch (InstantiationException iex) { 
     249                // We try to instantiate an interface 
     250                // or an object that does not have a 
     251                // default constructor 
     252            } catch (IllegalAccessException iaex) { 
     253                // The class is not public 
     254            } 
     255        } 
     256 
     257        Object objectWithMethod = null; 
     258        for (Object object : allclasses) { 
     259            if (hasField(object, fieldName)) { 
     260                objectWithMethod = object; 
     261            } 
     262        } 
     263        if (objectWithMethod != null) { 
     264            log.debug("Object " + objectWithMethod.getClass().getName() + " has method " + fieldName 
     265                    + " returning simple name " + objectWithMethod.getClass().getSimpleName()); 
     266            return objectWithMethod.getClass().getSimpleName(); 
     267        } 
     268 
     269        return null; 
     270 
     271    } 
     272 
     273    /** 
     274     * Gets the name, as a string, of the JAR file that contains the package <code>pckgname</code> 
     275     *  
     276     * @param pckgname 
     277     * @return the name, as a <code>String</code>, of the JAR file that contains the package <code>pckgname</code> 
     278     */ 
     279    private static String getJARFilePath(String pckgname) { 
     280        String name = new String(pckgname); 
     281        if (!name.startsWith("/")) { 
     282            name = "/" + name; 
     283        } 
     284        name = name.replace('.', '/'); 
     285        // log.debug("package name: " + name); 
     286        URL url = ReflectionHelper.class.getResource(name); 
     287        // log.debug("URL: "+url); 
     288        if (url != null && url.getPath().contains("!")) 
     289            return url.getPath().substring(0, url.getPath().indexOf('!')); 
     290        else if (url != null) 
     291            return url.getPath(); 
     292        else 
     293            return null; 
     294    } 
     295 
     296    /** 
     297     * Gets the names of the classes, as strings, in the jar <code>jarName</code> and package <code>packageName</code> 
     298     *  
     299     * @param jarName 
     300     * @param packageName 
     301     * @return 
     302     */ 
     303    public static List<String> getClasseNamesInPackageJAR(String jarName, String packageName) { 
     304        ArrayList<String> classes = new ArrayList<String>(); 
     305        packageName = packageName.replaceAll("\\.", "/"); 
     306        try { 
     307            JarInputStream jarFile = new JarInputStream(new FileInputStream(jarName)); 
     308            JarEntry jarEntry; 
     309            while (true) { 
     310                jarEntry = jarFile.getNextJarEntry(); 
     311                if (jarEntry == null) { 
     312                    break; 
     313                } 
     314                if ((jarEntry.getName().startsWith(packageName)) && (jarEntry.getName().endsWith(".class"))) { 
     315                    classes.add(jarEntry.getName().replaceAll("/", "\\.")); 
     316                } 
     317            } 
     318        } catch (Exception e) { 
     319            e.printStackTrace(); 
     320        } 
     321        return classes; 
     322    } 
     323 
     324    private static List<String> getClassNamesInJarOrFolder(String jarOrDirectoryName, String packageName) { 
     325        if (jarOrDirectoryName.endsWith(JAR_PREFIX)) { 
     326            return getClasseNamesInPackageJAR(jarOrDirectoryName, packageName); 
     327        } else { 
     328            return getClasseNamesInDirectory(jarOrDirectoryName, packageName); 
     329        } 
     330    } 
     331 
     332    /** 
     333     * Gets the names of the classes, as strings, in the directory <code>directoryName</code> and package 
     334     * <code>packageName</code> 
     335     *  
     336     * @param directoryName the name of the directory to look for classes 
     337     * @param packageName the name of the package the classes belong to 
     338     * @return a list of class names in the current folder 
     339     */ 
     340    private static List<String> getClasseNamesInDirectory(String directoryName, String packageName) { 
     341        ArrayList<String> classes = new ArrayList<String>(); 
     342        packageName = packageName.replaceAll("\\.", "/"); 
     343        try { 
     344            File dir = new File(directoryName); 
     345            // log.debug("Directory {}, is directory {}",dir, dir.isDirectory()); 
     346            for (String file : dir.list()) { 
     347                if ((file.endsWith(".class"))) { 
     348                    // log.debug("Found class file, {}",file); 
     349                    classes.add(packageName.replaceAll("/", "\\.") + "." + file); 
     350                } 
     351            } 
     352        } catch (Exception e) { 
     353            log.error("Error in getting classnames in directory {}", directoryName); 
     354        } 
     355        return classes; 
     356    } 
     357 
     358    /** 
     359     * Code taken and adapted from the JWhich project. Finds all subclasses of the uk.ac.cardiff.model.Entry class in 
     360     * the package <code>pckgname</code> if they exist outside any JAR libraries, use 
     361     * <code>getClasseNamesInPackageJAR</code> 
     362     *  
     363     * @param pckgname 
     364     * @return 
     365     */ 
     366    private static Object[] subclassesInDirectory(String pckgname) { 
     367        ArrayList<Object> allclasses = new ArrayList(); 
     368 
     369        String name = new String(pckgname); 
     370        if (!name.startsWith("/")) { 
     371            name = "/" + name; 
     372        } 
     373        name = name.replace('.', '/'); 
     374 
     375        // Get a File object for the package 
     376        log.debug("package name: " + name); 
     377        URL url = ReflectionHelper.class.getResource(name); 
     378        log.debug("URL: " + url); 
     379        File directory = new File(url.getFile()); 
     380 
     381        // New code 
     382        // ====== 
     383        if (directory.exists()) { 
     384            // Get the list of the files contained in the package 
     385            String[] files = directory.list(); 
     386            for (int i = 0; i < files.length; i++) { 
     387 
     388                // we are only interested in .class files 
     389                if (files[i].endsWith(".class")) { 
     390                    // removes the .class extension 
     391                    String classname = files[i].substring(0, files[i].length() - 6); 
     392                    try { 
     393                        log.debug("classname: " + classname); 
     394                        // Try to create an instance of the object 
     395                        Object o = Class.forName(pckgname + "." + classname).newInstance(); 
     396                        if (o instanceof uk.ac.cardiff.model.event.Event) { 
     397                            // log.debug("Found classname: "+classname); 
     398                            allclasses.add(o); 
     399                        } 
     400                    } catch (ClassNotFoundException cnfex) { 
     401                        log.error("{}", cnfex); 
     402                    } catch (InstantiationException iex) { 
     403                        // We try to instantiate an interface 
     404                        // or an object that does not have a 
     405                        // default constructor 
     406                    } catch (IllegalAccessException iaex) { 
     407                        // The class is not public 
     408                    } 
     409                } 
     410            } 
     411        } 
     412        return allclasses.toArray(); 
     413    } 
     414 
     415    /** 
     416     * Checks whether the Object <code>object</code> has the field <code>fieldName</code> 
     417     *  
     418     * @param object 
     419     * @param fieldName 
     420     * @return 
     421     */ 
     422    private static Boolean hasField(Object object, String fieldName) { 
     423        try { 
     424            Field[] fields = object.getClass().getDeclaredFields(); 
     425            for (Field field : fields) 
     426                if (field.getName().equals(fieldName)) 
     427                    return true; 
     428 
     429        } catch (Exception e) { 
     430            e.printStackTrace(); 
     431        } 
     432        return false; 
     433 
     434    } 
     435 
     436    public static String prepareMethodNameSet(String method) { 
     437        if (method.length() > 0) { 
     438            String name = "set"; 
     439            // now capitalise the first letter of the method name 
     440            Character firstLetter = method.charAt(0); 
     441            firstLetter = Character.toUpperCase(firstLetter); 
     442            String newMethodName = method.substring(1, method.length()); 
     443            name += firstLetter + newMethodName; 
     444            // System.out.println("method name: " + name); 
     445            return name; 
     446 
     447        } 
     448        return method; 
     449 
     450    } 
     451 
     452    /** 
     453     * @param fieldname 
     454     * @return 
     455     */ 
     456    public static String prepareMethodNameGet(String method) { 
     457        if (method.length() > 0) { 
     458            String name = "get"; 
     459            // now capitalise the first letter of the method name 
     460            Character firstLetter = method.charAt(0); 
     461            firstLetter = Character.toUpperCase(firstLetter); 
     462            String newMethodName = method.substring(1, method.length()); 
     463            name += firstLetter + newMethodName; 
     464            // System.out.println("method name: " + name); 
     465            return name; 
     466 
     467        } 
     468        return method; 
     469    } 
     470 
     471    public static Object getValueFromObject(String fieldname, Object object) { 
     472        try { 
     473            Class<?> id = object.getClass(); 
     474            String fieldAsMethod = ReflectionHelper.prepareMethodNameGet(fieldname); 
     475            Method getter = id.getMethod(fieldAsMethod, new Class[] {}); 
     476            Object result = getter.invoke(object, new Object[] {}); 
     477            return result; 
     478        } catch (Throwable e) { 
     479            log.error("Field name '" + fieldname + "' does not match internal model attribute"); 
     480            e.printStackTrace(); 
     481 
     482        } 
     483        return null; 
     484    } 
     485 
     486    public static void setValueOnObject(String fieldname, Object param, Object object) { 
     487        try { 
     488            Class<?> id = object.getClass(); 
     489            String fieldAsMethod = ReflectionHelper.prepareMethodNameSet(fieldname); 
     490            Method setter = id.getMethod(fieldAsMethod, new Class[] {param.getClass()}); 
     491            setter.invoke(object, new Object[] {param}); 
     492        } catch (Throwable e) { 
     493            log.error("Field name '" + fieldname + "' does not match internal model attribute, or parameters are wrong"); 
     494 
     495        } 
     496    } 
    502497 
    503498    /** 
     
    508503        Field[] fields = getInheritedPrivateFields(event.getClass()).toArray(new Field[0]); 
    509504        Field fieldToSet = null; 
    510         for (Field field : fields){ 
    511             if (field.getType() == objectToAttach.getClass()){ 
     505        for (Field field : fields) { 
     506            if (field.getType() == objectToAttach.getClass()) { 
    512507                fieldToSet = field; 
    513508            } 
    514509        } 
    515         //now use the public accessor method to set it 
     510        // now use the public accessor method to set it 
    516511        String fieldName = fieldToSet.getName(); 
    517512        setValueOnObject(fieldName, objectToAttach, event); 
     
    523518        Class<?> i = type; 
    524519        while (i != null && i != Object.class) { 
    525            for (Field field : i.getDeclaredFields()){ 
    526                result.add(field); 
    527            } 
    528            i = i.getSuperclass(); 
     520            for (Field field : i.getDeclaredFields()) { 
     521                result.add(field); 
     522            } 
     523            i = i.getSuperclass(); 
    529524        } 
    530525 
     
    537532    public static int getHashCodeFromEventOrNull(Event event) { 
    538533        try { 
    539                 int hashcode = ((Integer) ReflectionHelper.getValueFromObject("hashCode", event)); 
    540                 return hashcode; 
     534            int hashcode = ((Integer) ReflectionHelper.getValueFromObject("hashCode", event)); 
     535            return hashcode; 
    541536        } catch (Exception e) { 
    542537            return 0; 
     
    545540    } 
    546541 
    547  
    548542} 
Note: See TracChangeset for help on using the changeset viewer.