source: trunk/quest-ui-core/src/main/java/de/ugoe/cs/quest/plugin/jfc/JFCReplayIDCalculator.java @ 560

package de.ugoe.cs.quest.plugin.jfc;

import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import de.ugoe.cs.quest.plugin.jfc.eventcore.JFCEvent;

/**
 * <p>
 * This class provides the functionality to calculate the unique GUITAR replayIDs
 * for {@link JFCEvent}s. This code is mainly based on guitar source code: edu.umd.cs.guitar.
 * model.JFCDefaultIDGeneratorSimple
 *    
 * </p>
 * @author fabian.glaser
 *
 */

public class JFCReplayIDCalculator {
        
        final int prime = 31;
        
        /**
         * Properties that are used to identify widgets
         */
        private static List<String> ID_PROPERTIES = Arrays.asList(
                        "Class","Title","Icon");
        
        private static Map<String, Integer> ID_PROPERTIES_MAP;
        static{
                Map<String, Integer> idmap = new HashMap<String, Integer>(4);
                idmap.put("Class", 1);
                idmap.put("Title", 0);
                idmap.put("Icon", 2);
                idmap.put("Index", 3);
                ID_PROPERTIES_MAP = Collections.unmodifiableMap(idmap);
        }
                
        
   /**
    * Those classes are invisible widgets but cause false-positive when
    * calculating ID (compare guitar source code: edu.umd.cs.guitar.
    * model.JFCDefaultIDGeneratorSimple)
    */
   private static List<String> IGNORED_CLASSES = Arrays.asList("javax.swing.JPanel",
         "javax.swing.JTabbedPane", "javax.swing.JScrollPane",
         "javax.swing.JSplitPane", "javax.swing.Box",
         "javax.swing.JViewport", "javax.swing.JScrollBar",
         "javax.swing.JLayeredPane",
         "javax.swing.JList$AccessibleJList$AccessibleJListChild",
         "javax.swing.JList$AccessibleJList", "javax.swing.JList",
         "javax.swing.JScrollPane$ScrollBar",
         "javax.swing.plaf.metal.MetalScrollButton");
        
        
        /**
         * Calculates the replayID needed for compatibility with Guitar suite of a JFCEvent
         * @param event for which the ID should be calculated
         * @return replayID
         */
        public String calculateReplayID(JFCEvent event){
                String replayID = "";
                long hashCode = 1;
                
                // extract target string information
                String target = event.getTarget();
                String[] targetParts = target.split("\\]\\.\\[");
                
                // we assume that first component corresponds to the notion of a 
                // window in GUITAR suite
                
                // calculate window hashcode
                String[] windowInfo = targetParts[0].split("','");
                String title = windowInfo[0];
                String fuzzyTitle = getFuzzyTitle(title);
                long windowHashCode = fuzzyTitle.hashCode();
                windowHashCode = (windowHashCode * 2) & 0xffffffffL;
                
                long propagatedHashCode = windowHashCode;
                
                for (int i = 1; i < targetParts.length; i++){
                        long localHashCode = getLocalHashCode(targetParts[i]);
                        hashCode = propagatedHashCode * prime + localHashCode;
                hashCode = (hashCode * 2) & 0xffffffffL;
                        
                if (i < targetParts.length - 1){
                        Integer index = getIndex(targetParts[i+1]);
                                propagatedHashCode = prime * propagatedHashCode
                                + index.hashCode();
                }
                }
                
                replayID = "e" + hashCode;
                
                return replayID;
        }
        
        /**
         * Calculates the hashcode part of one component.
         * @param targetPart A string that represents a compontent
         * @return the local hashcode
         */
        
        private long getLocalHashCode(String targetPart){
                long hashcode = 1;
                String[] widgetInfo = targetPart.split("','");
                widgetInfo[0] = widgetInfo[0].substring(1);
                int length = widgetInfo.length - 1;
                widgetInfo[length] = widgetInfo[length].substring(0,widgetInfo[length].length()-1);
                String wClass = widgetInfo[ID_PROPERTIES_MAP.get("Class")];
                if (IGNORED_CLASSES.contains(wClass)) {
                    hashcode = (prime * hashcode + (wClass.equals("null") ? 0 : (wClass
                               .hashCode())));
                    return hashcode;
                }
                else{
                        for (String property: ID_PROPERTIES){
                                String value = widgetInfo[ID_PROPERTIES_MAP.get(property)];
                                if (!value.equals("null")){
                                        hashcode = prime * hashcode + property.hashCode();
                                        hashcode = prime * hashcode + value.hashCode();
                                }
                        }
                }
                
                hashcode = (hashcode * 2) & 0xffffffffL;
                
                return hashcode;
        }
        
        /**
         * Guitar has a special way to deal with window titles when
         * calculating unique widget IDs. This method mimics Guitar's
         * behavior (compare guitar source code: edu.umd.cs.guitar.
         * model.JFCDefaultIDGeneratorSimple).
         * @param title
         * @return
         */

        private String getFuzzyTitle(String title){
                final List<String> PATTERNS = 
                                Arrays.asList("Rachota .*",
                                                "OmegaT-.*",
                                                "Buddi.*",
                                                "Open:.*",
                                                "JabRef.*",
                                                "GanttProject.*",
                                                ".*Pauker.*",
                                                ".*FreeMind.*",
                                                ".* - ArgoUML.*",
                                                "Save Project .*");


                for (String sPattern : PATTERNS) {
                        if (matchRegex(title, sPattern)) {
                                return sPattern;
                        }
                }

                return title;
        }

        /**
         * Determine if the input string matches the input regex pattern.
         * This method mimics Guitars behavior.
         * Attempt to match the pattern 'sPattern' with the string 'sInputString'.

         * @param sInputString    Input string to match with pattern
         * @param sPattern        Regex pattern to match with string
         * @return                True if match, false otherwise
         */
        private static boolean
        matchRegex(String sInputString,
                        String sPattern)
        {
                Pattern pattern;
                Matcher matcher;

                pattern = Pattern.compile(sPattern);
                matcher = pattern.matcher(sInputString);
                if (matcher.matches()) {
                        return true;
                }

                return false;
        }
        
        /**
         * Extracts the index from a component string
         * @param targetPart String that represents the component
         * @return Index of the component
         */
        
        private Integer getIndex(String targetPart){
                String[] widgetInfo = targetPart.split("','");
                String index = widgetInfo[ID_PROPERTIES_MAP.get("Index")];
                if (index.equals("-1"))
                                throw new AssertionError("Index should only be -1 for components" +
                                                "that have no parent.");
                
                return Integer.parseInt(index);
        }
};