Changeset 694


Ignore:
Timestamp:
04/25/11 22:53:44 (8 years ago)
Author:
philsmart
Message:
 
Location:
raptor-client/trunk
Files:
20 added
3 edited

Legend:

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

    r669 r694  
    3434import uk.ac.cardiff.model.event.Event; 
    3535 
    36  
    3736/** 
    3837 * @author philsmart 
     
    4342        /** Class logger */ 
    4443        private static final Logger log = LoggerFactory.getLogger(ReflectionHelper.class); 
     44         
     45        private static final String EVENT_PACKAGE_NAME ="uk.ac.cardiff.model.event"; 
     46         
     47        private static final String JAR_PREFIX = "jar"; 
    4548 
    4649        /** 
     
    98101 
    99102        } 
    100          
    101         public static String determineSubclassForMethods(String methodOne, String methodTwo) { 
     103 
     104        public static String determineSubclassForMethods(String methodOne, String methodTwo) throws ReflectionException { 
    102105                Object methodOneObject = findEntrySubclassForMethodAsObject(methodOne); 
    103106                Object methodTwoObject = findEntrySubclassForMethodAsObject(methodTwo); 
    104                 log.debug("Classes found, methodOne {}, methodTwo {}", methodOneObject.getClass(), methodTwoObject.getClass()); 
    105                 // is methodTwoObject a superclass of methodOneObject, if it is, then 
    106                 // its either an equivalent class 
    107                 // or its a subclass so return it 
    108                 log.debug("Is methodOne a superclass of methodTwo {}", 
    109                                 (methodOneObject.getClass().isAssignableFrom(methodTwoObject.getClass()))); 
    110                 if (methodTwoObject.getClass().isAssignableFrom(methodOneObject.getClass())) { 
    111                         return methodOneObject.getClass().getSimpleName(); 
     107                if (methodOneObject != null && methodTwoObject != null) { 
     108                        log.debug("Classes found, methodOne {}, methodTwo {}", methodOneObject.getClass(), methodTwoObject.getClass()); 
     109                        log.debug("Is methodOne a superclass of methodTwo {}", (methodOneObject.getClass().isAssignableFrom(methodTwoObject.getClass()))); 
     110                        if (methodTwoObject.getClass().isAssignableFrom(methodOneObject.getClass())) { 
     111                                return methodOneObject.getClass().getSimpleName(); 
     112                        } else { 
     113                                return methodTwoObject.getClass().getSimpleName(); 
     114                        } 
    112115                } else { 
    113                         return methodTwoObject.getClass().getSimpleName(); 
    114                 } 
    115  
    116         } 
    117  
    118         public static List<String> getFieldsFromEntrySubClasses(){ 
     116                        log.error("Could not determine which method belongs to the subclass, from {} and {}", methodOne, methodTwo); 
     117                        throw new ReflectionException("Could not determine which method belongs to the subclass"); 
     118                } 
     119 
     120        } 
     121 
     122        public static List<String> getFieldsFromEntrySubClasses() { 
    119123                ArrayList<String> allFields = new ArrayList<String>(); 
    120                 String forPckgName = "uk.ac.cardiff.model"; 
     124                String forPckgName = EVENT_PACKAGE_NAME; 
    121125                String jarFile = getJARFilePath(forPckgName); 
    122126                jarFile = jarFile.replace("file:", ""); 
     
    127131                        try { 
    128132                                Object o = Class.forName(classname.replace(".class", "")).newInstance(); 
    129                                 //if (o!=null)log.debug("found object {}",o.getClass()); 
     133                                // if (o!=null)log.debug("found object {}",o.getClass()); 
    130134                                if (o instanceof uk.ac.cardiff.model.event.Event) { 
    131135                                        allclasses.add(o); 
     
    134138                                log.error("error getting subclasses of Entry, {}", cnfex); 
    135139                        } catch (InstantiationException iex) { 
    136                                 //log.error("{}", iex); 
     140                                // log.error("{}", iex); 
    137141                        } catch (IllegalAccessException iaex) { 
    138142                                // The class is not public 
    139                                 //log.error("{}", iaex); 
     143                                // log.error("{}", iaex); 
    140144                        } 
    141145                } 
    142146                for (Object object : allclasses) { 
    143147                        Field[] fields = object.getClass().getDeclaredFields(); 
    144                         for (Field field : fields){ 
     148                        for (Field field : fields) { 
    145149                                allFields.add(field.getName()); 
    146150                        } 
     
    151155        } 
    152156 
    153  
    154157        public static Object findEntrySubclassForMethodAsObject(String fieldName) { 
    155                 String forPckgName = "uk.ac.cardiff.model"; 
     158                String forPckgName = EVENT_PACKAGE_NAME; 
    156159                String jarFile = getJARFilePath(forPckgName); 
    157160                jarFile = jarFile.replace("file:", ""); 
    158                 List<String> classes = getClasseNamesInPackageJAR(jarFile, forPckgName); 
     161                log.debug("jar {}",jarFile); 
     162                List<String> classes = getClassNamesInJarOrFolder(jarFile,forPckgName); 
    159163                ArrayList allclasses = new ArrayList(); 
    160164                for (String classname : classes) { 
     
    182186                } 
    183187                if (objectWithMethod != null) { 
    184                         log.debug("Object " + objectWithMethod.getClass().getName() + " has method " + fieldName 
    185                                         + " returning simple name " + objectWithMethod.getClass().getSimpleName()); 
     188                        log.debug("Object " + objectWithMethod.getClass().getName() + " has method " + fieldName + " returning simple name " 
     189                                        + objectWithMethod.getClass().getSimpleName()); 
    186190                        return objectWithMethod; 
    187191                } 
     
    194198         * This method finds the simple name of the class in the uk.ac.cardiff.model 
    195199         * package that contains the <code>fieldName</code>. 
    196          * 
     200         *  
    197201         * @param fieldName 
    198202         * @return 
    199203         */ 
    200204        public static String findEntrySubclassForMethod(String fieldName) { 
    201                 String forPckgName = "uk.ac.cardiff.model"; 
     205                String forPckgName = EVENT_PACKAGE_NAME; 
    202206                String jarFile = getJARFilePath(forPckgName); 
    203207                jarFile = jarFile.replace("file:", ""); 
    204                 List<String> classes = getClasseNamesInPackageJAR(jarFile, forPckgName); 
     208                List<String> classes = getClassNamesInJarOrFolder(jarFile,forPckgName); 
    205209                ArrayList allclasses = new ArrayList(); 
    206210                for (String classname : classes) { 
     
    230234                } 
    231235                if (objectWithMethod != null) { 
    232                         log.debug("Object " + objectWithMethod.getClass().getName() + " has method " + fieldName 
    233                                         + " returning simple name " + objectWithMethod.getClass().getSimpleName()); 
     236                        log.debug("Object " + objectWithMethod.getClass().getName() + " has method " + fieldName + " returning simple name " 
     237                                        + objectWithMethod.getClass().getSimpleName()); 
    234238                        return objectWithMethod.getClass().getSimpleName(); 
    235239                } 
     
    242246         * Gets the name, as a string, of the JAR file that contains the package 
    243247         * <code>pckgname</code> 
    244          * 
     248         *  
    245249         * @param pckgname 
    246          * @return 
     250         * @return the name, as a <code>String</code>, of the JAR file that contains the package <code>pckgname</code> 
    247251         */ 
    248252        private static String getJARFilePath(String pckgname) { 
     
    254258                //log.debug("package name: " + name); 
    255259                URL url = ReflectionHelper.class.getResource(name); 
    256                 //log.debug("URL: "+url); 
     260            //log.debug("URL: "+url); 
    257261                if (url != null && url.getPath().contains("!")) 
    258262                        return url.getPath().substring(0, url.getPath().indexOf('!')); 
     
    266270         * Gets the names of the classes, as strings, in the jar 
    267271         * <code>jarName</code> and package <code>packageName</code> 
    268          * 
     272         *  
    269273         * @param jarName 
    270274         * @param packageName 
     
    291295                return classes; 
    292296        } 
     297         
     298        private static List<String> getClassNamesInJarOrFolder(String jarOrDirectoryName, String packageName){ 
     299                if (jarOrDirectoryName.endsWith(JAR_PREFIX)){ 
     300                        return getClasseNamesInPackageJAR(jarOrDirectoryName, packageName); 
     301                } 
     302                else { 
     303                        return getClasseNamesInDirectory(jarOrDirectoryName, packageName); 
     304                } 
     305        } 
     306         
     307        /** 
     308         * Gets the names of the classes, as strings, in the directory 
     309         * <code>directoryName</code> and package <code>packageName</code> 
     310         *  
     311         * @param directoryName the name of the directory to look for classes  
     312         * @param packageName the name of the package the classes belong to 
     313         * @return a list of class names in the current folder 
     314         */ 
     315        private static List<String> getClasseNamesInDirectory(String directoryName, String packageName) { 
     316                ArrayList<String> classes = new ArrayList<String>(); 
     317                packageName = packageName.replaceAll("\\.", "/"); 
     318                try { 
     319                        File dir = new File(directoryName); 
     320                        //log.debug("Directory {}, is directory {}",dir, dir.isDirectory()); 
     321                        for (String file : dir.list()){ 
     322                                if ((file.endsWith(".class"))) { 
     323                                        //log.debug("Found class file, {}",file); 
     324                                        classes.add(packageName.replaceAll("/", "\\.")+"."+file); 
     325                                } 
     326                        } 
     327                } catch (Exception e) { 
     328                        log.error("Error in getting classnames in directory {}",directoryName); 
     329                } 
     330                return classes; 
     331        } 
    293332 
    294333        /** 
     
    297336         * if they exist outside any JAR libraries, use 
    298337         * <code>getClasseNamesInPackageJAR</code> 
    299          * 
     338         *  
    300339         * @param pckgname 
    301340         * @return 
     
    353392         * Checks whether the Object <code>object</code> has the field 
    354393         * <code>fieldName</code> 
    355          * 
     394         *  
    356395         * @param object 
    357396         * @param fieldName 
     
    374413        public static String prepareMethodNameSet(String method) { 
    375414                if (method.length() > 0) { 
    376                         String name = "set"; 
     415                    String name = "set"; 
    377416                        // now capitalise the first letter of the method name 
    378417                        Character firstLetter = method.charAt(0); 
     
    394433        public static String prepareMethodNameGet(String method) { 
    395434                if (method.length() > 0) { 
    396                         String name = "get"; 
     435                    String name = "get"; 
    397436                        // now capitalise the first letter of the method name 
    398437                        Character firstLetter = method.charAt(0); 
  • raptor-client/trunk/src/main/java/uk/ac/cardiff/raptor/store/EntryHandler.java

    r672 r694  
    2626import java.util.Set; 
    2727 
     28import org.joda.time.DateTime; 
     29 
    2830import uk.ac.cardiff.model.event.Event; 
    2931import uk.ac.cardiff.raptor.store.dao.StorageException; 
     
    3739         */ 
    3840        public void addEntries(List<Event> entries) throws StorageException; 
     41         
     42        /** 
     43         *  
     44         * @param event 
     45         */ 
     46        public void addEntry(Event event); 
     47         
     48        /** 
     49         *  
     50         * @return 
     51         */ 
     52        public DateTime getLatestEntryTime(); 
    3953 
    4054        /** 
     
    5569        public void removeAllEntries(); 
    5670 
    57         /** 
    58          * 
    59          */ 
    60         public void endTransaction(); 
    6171 
    6272        /** 
  • raptor-client/trunk/src/main/java/uk/ac/cardiff/raptor/store/impl/PersistantEntryHandler.java

    r677 r694  
    6363         * memory overhead is too high for large databases 
    6464         */ 
    65         private Set<Event> entries; 
     65        //private Set<Event> entries; 
    6666 
    6767        /** Used to hold events temporarily before they are persisted, allows 
     
    8787        } 
    8888 
    89         /** 
    90          * This method loads all <code>Entries</code> in the <code>entries</code> 
    91          * variable. This method is often not used as large datasets will require 
    92          * vast amounts of memory 
    93          */ 
    94         private void loadEntries() { 
    95                 log.info("Loading entries from main datastore"); 
    96                 List<Event> entriesAsList = dataConnection.runQuery("from Event", null); 
    97                 log.info("MUA has loaded {} entries from main datastore",entriesAsList.size()); 
    98                 entries = new LinkedHashSet<Event>(entriesAsList); 
    99         } 
    10089 
    10190        public List query(String query) { 
     
    158147        } 
    159148 
    160         public void addEntry(Event entry) { 
    161                 entries.add(entry); 
    162  
    163         } 
    164  
    165         public void endTransaction() { 
    166                 log.debug("Saving transaction for MUA"); 
    167                 dataConnection.saveAll(entries); 
    168                 log.debug("Saving transaction for MUA...Done"); 
    169         } 
    170  
    171         public Set getEntries() { 
    172                 return entries; 
     149        public void addEntry(Event event) { 
     150                int hashcode = 0; 
     151                try { 
     152                        hashcode = ((Integer) ReflectionHelper.getValueFromObject("hashCode", event)).intValue(); 
     153                } catch (Exception e) { 
     154                    log.error("Could not get hashcode for event {}, event not stored"); 
     155                    return; 
     156                } 
     157                String query ="select count(*) from "+event.getClass().getSimpleName()+" where eventTime = ? and hashCode =?"; 
     158                Object[] parameters= new Object[]{event.getEventTime().toDate(),hashcode}; 
     159                int numberOfDuplicates = ((Integer) dataConnection.runQueryUnique(query, parameters)).intValue(); 
     160 
     161                if (numberOfDuplicates == 0){ 
     162                   dataConnection.save(event); 
     163                } 
     164                else{ 
     165                        log.error("Duplicated event found\n{}", event); 
     166                } 
     167 
     168 
     169        } 
     170 
     171        public Set<Event> getEntries() { 
     172                return (Set<Event>) dataConnection.runQuery("Select from Event",null); 
    173173        } 
    174174 
    175175        public void removeAllEntries() { 
    176                 log.debug("Removing all entries from this entry handler"); 
    177                 dataConnection.deleteAllEntries(entries); 
    178                 entries.clear(); 
     176//              log.debug("Removing all entries from this entry handler"); 
     177//              dataConnection.deleteAllEntries(entries); 
     178//              entries.clear(); 
    179179        } 
    180180 
     
    194194                return (Integer) dataConnection.runQueryUnique("select count(*) from Event", null); 
    195195        } 
     196         
     197        public DateTime getLatestEntryTime(){ 
     198                return (DateTime) dataConnection.runQueryUnique("select max(eventTime) from Event", null); 
     199        } 
    196200 
    197201 
Note: See TracChangeset for help on using the changeset viewer.