- * Compares two widget strings of the form - * {@code ['title','class','index','text','hashCode']}. - *
- * - * @param widget1 - * @param widget2 - * @return - */ - private boolean compareWidgets(String widget1, String widget2) { - String[] widgetInfo1 = widget1.split("','"); - String[] widgetInfo2 = widget2.split("','"); - // ensure size is equal - if (widgetInfo1.length != 5 || widgetInfo2.length != 5) { - return false; - } - // ensure that class [1], index [2], and text [3] are equal - // and title [0] or hashCode [4] are equal - return (widgetInfo1[1].equals(widgetInfo2[1]) - && widgetInfo1[2].equals(widgetInfo2[2]) && widgetInfo1[3] - .equals(widgetInfo2[3])) - && (widgetInfo1[0].equals(widgetInfo2[0]) || widgetInfo1[4] - .equals(widgetInfo2[4])); - - } - + return JFCTargetComparator.compare(target, otherTarget); + } + + /** + *+ * The targetHashCode ignores the parts of the target that describe the + * title and hash of a widget, to ensure that the equals/hashCode contract + * is fulfilled. + *
+ * + * @see de.ugoe.cs.eventbench.data.Event#targetHashCode() + */ @Override protected int targetHashCode() { int hashCode = 0; int multiplier = 29; - if( target!=null ) { - String[] targetParts = target.split("\\[\\.\\["); - if( targetParts.length==0 ) { + if (target != null) { + String[] targetParts = target.split("\\]\\.\\["); + if (targetParts.length == 0) { hashCode = widgetHashCode(target); } else { - for( String widgetString : targetParts ) { - hashCode = hashCode * multiplier + widgetHashCode(widgetString); + for (String widgetString : targetParts) { + hashCode = hashCode * multiplier + + widgetHashCode(widgetString); } } } - + return hashCode; } - + + /** + *+ * This method calculates the hashCode for a a widget. If is used by + * {@link #targetHashCode()} to build the complete hashCode. + *
+ * + * @param widget + * string describing the widget + * @return hashCode of the widget + */ private int widgetHashCode(String widget) { int hashCode = 0; int multiplier = 37; String[] widgetInfo = widget.split("','"); - if( widgetInfo.length==5 ) { + if (widgetInfo.length == 5) { hashCode = hashCode * multiplier + widgetInfo[1].hashCode(); hashCode = hashCode * multiplier + widgetInfo[2].hashCode(); Index: /trunk/EventBenchConsole/src/de/ugoe/cs/eventbench/jfc/data/JFCTargetComparator.java =================================================================== --- /trunk/EventBenchConsole/src/de/ugoe/cs/eventbench/jfc/data/JFCTargetComparator.java (revision 380) +++ /trunk/EventBenchConsole/src/de/ugoe/cs/eventbench/jfc/data/JFCTargetComparator.java (revision 380) @@ -0,0 +1,335 @@ +package de.ugoe.cs.eventbench.jfc.data; + +import java.util.ArrayList; +import java.util.LinkedHashSet; +import java.util.List; +import java.util.Set; + +/** + *+ * This class implements a comparator for target string for JFC GUIs. It + * internally maintains a collection of all targets that have been compared, to + * ensure transitivity of the equals relation. This memory can always be deleted + * by calling {@link #reset()}. + *
+ * + * @author Steffen Herbold + * @version 1.0 + */ +public class JFCTargetComparator { + + /** + *+ * Compares to target strings. The strings are equal, if + *
+ * All target strings are remembered internally, to be able to test for the + * third property. + *
+ * + * @param target1 + * first target string + * @param target2 + * second target string + * @return true, if both targets are equal; false otherwise + */ + public static boolean compare(String target1, String target2) { + instance.addTarget(target1); + instance.addTarget(target2); + + JFCWidget widget1 = instance.find(target1); + JFCWidget widget2 = instance.find(target2); + + return widget1 == widget2; + } + + /** + *+ * Resets the internal memory of targets. + *
+ */ + public static void reset() { + instance = new JFCTargetComparator(); + } + + /** + *+ * Internal handle to the instance of this class (implemented as + * Singleton!). + *
+ */ + private static JFCTargetComparator instance = new JFCTargetComparator(); + + /** + *+ * Private Constructor. Creates a new instance of the class and prevents + * instantiation from outside of this class. + *
+ */ + private JFCTargetComparator() { + } + + /** + *+ * List of the root widgets found in the target string. + *
+ */ + private List+ * Adds a target to the memory. + *
+ * + * @param target + * target to be added + */ + private void addTarget(String target) { + if (target != null) { + String[] targetParts = target.split("\\]\\.\\["); + if (targetParts.length == 1) { + addWidget(target.substring(1, target.length() - 1), null); + } else { + JFCWidget parent = null; + for (int i = 0; i < targetParts.length; i++) { + if (i == 0) { + parent = addWidget(targetParts[i].substring(1), parent); + } else if (i == targetParts.length - 1) { + parent = addWidget( + targetParts[i].substring(0, + targetParts[i].length() - 1), parent); + } else { + parent = addWidget(targetParts[i], parent); + } + } + } + } + } + + /** + *+ * Adds a widget extracted from a target to the memory. The widget is placed + * as a child/parent of other widget according to the GUI hierarchy of the + * application. + *
+ *+ * In case the widget already exists, the existing widget is returned and + * the known targets and hashCodes of the existing widget are updated. + *
+ * + * @param widgetString + * string identifying the widget + * @param parent + * parent widget; if null, it is a root widget and added to + * {@link #rootWidgets} + * @return the created widget. + */ + private JFCWidget addWidget(String widgetString, JFCWidget parent) { + String[] widgetInfo = widgetString.split("','"); + JFCWidget widget = generateWidget(widgetString); + + if (parent == null) { + int index = rootWidgets.indexOf(widget); + if (index >= 0) { + widget = rootWidgets.get(index); + widget.titles.add(widgetInfo[0]); + widget.hashCodes.add(widgetInfo[4]); + } else { + rootWidgets.add(widget); + } + } else { + int index = parent.children.indexOf(widget); + if (index >= 0) { + widget = parent.children.get(index); + widget.titles.add(widgetInfo[0]); + widget.hashCodes.add(widgetInfo[4]); + } else { + parent.children.add(widget); + } + } + + return widget; + } + + /** + *+ * Creates a new {@link JFCWidget} from a widget string. + *
+ * + * @param widgetString + * string describing the widget + * @return created {@link JFCWidget} + */ + private JFCWidget generateWidget(String widgetString) { + String[] widgetInfo = widgetString.split("','"); + JFCWidget widget = new JFCWidget(); + widget.titles.add(widgetInfo[0]); + widget.widgetClass = widgetInfo[1]; + widget.index = widgetInfo[2]; + widget.text = widgetInfo[3]; + widget.hashCodes.add(widgetInfo[4]); + return widget; + } + + /** + *+ * Tries to find the {@link JFCWidget} that the target string identifies in + * the known GUI hierarchy, by traversing the known widgets starting with + * the {@link #rootWidgets}. + * + * @param target + * target string whose widget is searched for + * @return respective {@link JFCWidget} instance if it is found; null + * otherwise + */ + private JFCWidget find(String target) { + JFCWidget widget = null; + if (target != null) { + String[] targetParts = target.split("\\]\\.\\["); + if (targetParts.length == 1) { + JFCWidget generatedWidget = generateWidget(target.substring(1, + target.length() - 1)); + int index = rootWidgets.indexOf(generatedWidget); + if (index >= 0) { + widget = rootWidgets.get(index); + } else { + return null; + } + } else { + JFCWidget parent = null; + for (int i = 0; i < targetParts.length; i++) { + if (i == 0) { + JFCWidget generatedWidget = generateWidget(targetParts[i] + .substring(1)); + int index = rootWidgets.indexOf(generatedWidget); + if (index >= 0) { + parent = rootWidgets.get(index); + } else { + return null; + } + } else if (i == targetParts.length - 1) { + JFCWidget generatedWidget = generateWidget(targetParts[i] + .substring(0, targetParts[i].length() - 1)); + int index = parent.children.indexOf(generatedWidget); + if (index >= 0) { + widget = parent.children.get(index); + } else { + return null; + } + } else { + JFCWidget generatedWidget = generateWidget(targetParts[i]); + int index = parent.children.indexOf(generatedWidget); + if (index >= 0) { + parent = parent.children.get(index); + } else { + return null; + } + } + } + } + } + return widget; + } + + /** + *
+ * Internal class used to store JFCWidgets. The implementation is more like + * a C-style structure, than a actual class. + *
+ * + * @author Steffen Herbold + * @version 1.0 + */ + private static class JFCWidget { + + /** + *+ * Set of all known title strings of the widget. + *
+ */ + Set+ * Set of all known hashCodes of the widget. + *
+ */ + Set+ * Class of the widget. + *
+ */ + String widgetClass; + + /** + *+ * Index of the widget. + *
+ */ + String index; + + /** + *+ * Text of the widget. + *
+ */ + String text; + + /** + *+ * List of children of the widget. + *
+ */ + List+ * Two widgets are equal, if {@link #widgetClass}, {@link #index}, and + * {@link #text} are equal and the intersection of either the + * {@link #hashCodes}, the {@link #titles}, or both of them is not + * empty. + *
+ * + * @see java.lang.Object#equals(java.lang.Object) + */ + @Override + public boolean equals(Object obj) { + if (obj instanceof JFCWidget) { + JFCWidget other = (JFCWidget) obj; + Set