From 4c43f4a85b1e95603839c365ed0aa064afb75864 Mon Sep 17 00:00:00 2001 From: tama3 Date: Sat, 3 Mar 2007 03:42:06 +0000 Subject: [PATCH] enabled expert mode (more birthmarks, enable define new birthmark) git-svn-id: svn+ssh://svn.sourceforge.jp/svnroot/stigmata/trunk@59 acee48c3-7b26-0410-bdac-b3d0e5314bbc --- pom.xml | 2 +- .../stigmata/ApplicationInitializationError.java | 29 ++ .../jp/naist/se/stigmata/BirthmarkContext.java | 13 +- .../naist/se/stigmata/BirthmarkSpiComparator.java | 37 ++ .../jp/naist/se/stigmata/ConfigFileParser.java | 58 ++-- src/main/java/jp/naist/se/stigmata/Stigmata.java | 2 +- .../birthmarks/AbstractBirthmarkService.java | 20 ++ .../se/stigmata/birthmarks/BirthmarkService.java | 152 +++++++++ .../birthmarks/LocalizedDescriptionManager.java | 9 +- .../se/stigmata/birthmarks/PlainBirthmark.java | 2 +- .../AbstractBirthmarkComparatorService.java | 59 ++++ .../DPMatchingBirthmarkComparator.java | 2 +- .../DPMatchingBirthmarkComparatorService.java | 35 ++ .../EditDistanceBirthmarkComparator.java | 90 +++++ .../EditDistanceBirthmarkComparatorService.java | 35 ++ .../ExtendedEditDistanceBirthmarkComparator.java | 43 +++ .../comparators/LogicalAndBirthmarkComparator.java | 72 ++++ .../LogicalAndBirthmarkComparatorService.java | 35 ++ .../PlainBirthmarkComparator.java | 2 +- .../PlainBirthmarkComparatorService.java | 35 ++ ...alueOfFieldVariableBirthmarkExtractVisitor.java | 1 - ...nstantValueOfFieldVariableBirthmarkService.java | 10 +- .../AbstractBirthmarkExtractorService.java | 59 ++++ ...ueOfFieldVariableBirthmarkExtractorService.java | 36 ++ ...eritanceStructureBirthmarkExtractorService.java | 36 ++ ...uentialMethodCallBirthmarkExtractorService.java | 36 ++ .../UsedClassesBirthmarkExtractorService.java | 36 ++ .../is/InheritanceStructureBirthmarkService.java | 10 +- .../smc/SequentialMethodCallBirthmarkService.java | 10 +- .../birthmarks/uc/UsedClassesBirthmarkService.java | 12 +- .../csv/BirthmarkComparisonResultCsvFormat.java | 22 +- .../se/stigmata/spi/BirthmarkComparatorSpi.java | 40 +++ .../se/stigmata/spi/BirthmarkExtractorSpi.java | 40 +++ .../jp/naist/se/stigmata/spi/BirthmarkSpi.java | 8 + .../stigmata/ui/swing/BirthmarkDefinitionPane.java | 377 +++++++++++++++++++++ .../stigmata/ui/swing/BirthmarkSelectionPane.java | 137 ++++++-- .../jp/naist/se/stigmata/ui/swing/ControlPane.java | 49 ++- .../ui/swing/PairComparisonResultSetPane.java | 9 +- .../naist/se/stigmata/ui/swing/StigmataFrame.java | 46 ++- .../jp/naist/se/stigmata/ui/swing/Utility.java | 53 ++- src/main/resources/META-INF/birthmark-3.0.dtd | 16 +- ...jp.naist.se.stigmata.spi.BirthmarkComparatorSpi | 5 + .../jp.naist.se.stigmata.spi.BirthmarkExtractorSpi | 5 + src/main/resources/resources/birthmark.xml | 68 +++- .../resources/resources/description.properties | 8 +- src/main/resources/resources/images/script_add.png | Bin 0 -> 811 bytes .../resources/resources/images/script_delete.png | Bin 0 -> 811 bytes src/main/resources/resources/images/star.png | Bin 0 -> 670 bytes src/main/resources/resources/messages.properties | 40 ++- src/main/resources/resources/messages_ja.source | 32 ++ .../java/jp/naist/se/stigmata/StigmataTest.java | 2 +- .../cvfv/CVFVBirthmarkExtractorTest.java | 24 +- .../birthmarks/smc/SmcBirthmarkExtractorTest.java | 26 +- 53 files changed, 1860 insertions(+), 125 deletions(-) create mode 100755 src/main/java/jp/naist/se/stigmata/ApplicationInitializationError.java create mode 100755 src/main/java/jp/naist/se/stigmata/BirthmarkSpiComparator.java create mode 100755 src/main/java/jp/naist/se/stigmata/birthmarks/BirthmarkService.java create mode 100755 src/main/java/jp/naist/se/stigmata/birthmarks/comparators/AbstractBirthmarkComparatorService.java rename src/main/java/jp/naist/se/stigmata/birthmarks/{ => comparators}/DPMatchingBirthmarkComparator.java (98%) create mode 100755 src/main/java/jp/naist/se/stigmata/birthmarks/comparators/DPMatchingBirthmarkComparatorService.java create mode 100755 src/main/java/jp/naist/se/stigmata/birthmarks/comparators/EditDistanceBirthmarkComparator.java create mode 100755 src/main/java/jp/naist/se/stigmata/birthmarks/comparators/EditDistanceBirthmarkComparatorService.java create mode 100755 src/main/java/jp/naist/se/stigmata/birthmarks/comparators/ExtendedEditDistanceBirthmarkComparator.java create mode 100755 src/main/java/jp/naist/se/stigmata/birthmarks/comparators/LogicalAndBirthmarkComparator.java create mode 100755 src/main/java/jp/naist/se/stigmata/birthmarks/comparators/LogicalAndBirthmarkComparatorService.java rename src/main/java/jp/naist/se/stigmata/birthmarks/{ => comparators}/PlainBirthmarkComparator.java (96%) create mode 100755 src/main/java/jp/naist/se/stigmata/birthmarks/comparators/PlainBirthmarkComparatorService.java create mode 100755 src/main/java/jp/naist/se/stigmata/birthmarks/extractors/AbstractBirthmarkExtractorService.java create mode 100755 src/main/java/jp/naist/se/stigmata/birthmarks/extractors/ConstantValueOfFieldVariableBirthmarkExtractorService.java create mode 100755 src/main/java/jp/naist/se/stigmata/birthmarks/extractors/InheritanceStructureBirthmarkExtractorService.java create mode 100755 src/main/java/jp/naist/se/stigmata/birthmarks/extractors/SequentialMethodCallBirthmarkExtractorService.java create mode 100755 src/main/java/jp/naist/se/stigmata/birthmarks/extractors/UsedClassesBirthmarkExtractorService.java create mode 100755 src/main/java/jp/naist/se/stigmata/spi/BirthmarkComparatorSpi.java create mode 100755 src/main/java/jp/naist/se/stigmata/spi/BirthmarkExtractorSpi.java create mode 100755 src/main/java/jp/naist/se/stigmata/ui/swing/BirthmarkDefinitionPane.java create mode 100755 src/main/resources/META-INF/services/jp.naist.se.stigmata.spi.BirthmarkComparatorSpi create mode 100755 src/main/resources/META-INF/services/jp.naist.se.stigmata.spi.BirthmarkExtractorSpi create mode 100755 src/main/resources/resources/images/script_add.png create mode 100755 src/main/resources/resources/images/script_delete.png create mode 100755 src/main/resources/resources/images/star.png diff --git a/pom.xml b/pom.xml index 5975e89..0fd3919 100755 --- a/pom.xml +++ b/pom.xml @@ -4,7 +4,7 @@ 4.0.0 jp.naist.se stigmata - 1.0-beta3 + 1.0-beta4 stigmata Java birthmark toolkit http://stigmata.sourceforge.jp/ diff --git a/src/main/java/jp/naist/se/stigmata/ApplicationInitializationError.java b/src/main/java/jp/naist/se/stigmata/ApplicationInitializationError.java new file mode 100755 index 0000000..86129a0 --- /dev/null +++ b/src/main/java/jp/naist/se/stigmata/ApplicationInitializationError.java @@ -0,0 +1,29 @@ +package jp.naist.se.stigmata; + +/* + * $Id$ + */ + +/** + * + * @author Haruaki TAMADA + * @version $Revision$ $Date$ + */ +public class ApplicationInitializationError extends Error{ + private static final long serialVersionUID = 32097456654328L; + + public ApplicationInitializationError(){ + } + + public ApplicationInitializationError(String message){ + super(message); + } + + public ApplicationInitializationError(String message, Throwable cause){ + super(message, cause); + } + + public ApplicationInitializationError(Throwable cause){ + super(cause); + } +} diff --git a/src/main/java/jp/naist/se/stigmata/BirthmarkContext.java b/src/main/java/jp/naist/se/stigmata/BirthmarkContext.java index 8f55168..d3df823 100755 --- a/src/main/java/jp/naist/se/stigmata/BirthmarkContext.java +++ b/src/main/java/jp/naist/se/stigmata/BirthmarkContext.java @@ -9,7 +9,10 @@ import java.util.HashMap; import java.util.Iterator; import java.util.List; import java.util.Map; +import java.util.Arrays; + import javax.imageio.spi.ServiceRegistry; + import jp.naist.se.stigmata.reader.ClasspathContext; import jp.naist.se.stigmata.spi.BirthmarkSpi; import jp.naist.se.stigmata.utils.WellknownClassManager; @@ -148,7 +151,10 @@ public class BirthmarkContext{ */ public synchronized BirthmarkSpi[] getServices(){ List list = getServiceList(); - return list.toArray(new BirthmarkSpi[list.size()]); + BirthmarkSpi[] services = list.toArray(new BirthmarkSpi[list.size()]); + Arrays.sort(services, new BirthmarkSpiComparator()); + + return services; } /** @@ -163,7 +169,10 @@ public class BirthmarkContext{ list.add(spi); } } - return list.toArray(new BirthmarkSpi[list.size()]); + BirthmarkSpi[] services = list.toArray(new BirthmarkSpi[list.size()]); + Arrays.sort(services, new BirthmarkSpiComparator()); + + return services; } /** diff --git a/src/main/java/jp/naist/se/stigmata/BirthmarkSpiComparator.java b/src/main/java/jp/naist/se/stigmata/BirthmarkSpiComparator.java new file mode 100755 index 0000000..6a8fdd4 --- /dev/null +++ b/src/main/java/jp/naist/se/stigmata/BirthmarkSpiComparator.java @@ -0,0 +1,37 @@ +package jp.naist.se.stigmata; + +/* + * $Id$ + */ + +import java.util.Comparator; + +import jp.naist.se.stigmata.spi.BirthmarkSpi; + +/** + * @author Haruaki TAMADA + * @version $Revision$ $Date$ + */ +class BirthmarkSpiComparator implements Comparator{ + /** + * default constructor + */ + public BirthmarkSpiComparator(){ + } + + public int compare(BirthmarkSpi s1, BirthmarkSpi s2){ + if(s1.isExpert() && !s2.isExpert()){ + return 1; + } + else if(!s1.isExpert() && s2.isExpert()){ + return -1; + } + else{ + return s1.getType().compareTo(s2.getType()); + } + } + + public boolean equals(Object o){ + return o == this; + } +} \ No newline at end of file diff --git a/src/main/java/jp/naist/se/stigmata/ConfigFileParser.java b/src/main/java/jp/naist/se/stigmata/ConfigFileParser.java index c8a7896..1d7aa87 100755 --- a/src/main/java/jp/naist/se/stigmata/ConfigFileParser.java +++ b/src/main/java/jp/naist/se/stigmata/ConfigFileParser.java @@ -13,6 +13,7 @@ import javax.xml.parsers.ParserConfigurationException; import javax.xml.parsers.SAXParser; import javax.xml.parsers.SAXParserFactory; +import jp.naist.se.stigmata.birthmarks.BirthmarkService; import jp.naist.se.stigmata.utils.WellknownClassManager; import jp.naist.se.stigmata.utils.WellknownClassJudgeRule; @@ -26,15 +27,15 @@ import org.xml.sax.helpers.DefaultHandler; * @version $Revision$ $Date$ */ public class ConfigFileParser extends DefaultHandler{ + private enum Part{ WELLKNOWN_CLASSES, PROPERTIES, CLASSPATH, SERVICES, } + private BirthmarkContext context; private WellknownClassManager manager; - private boolean wellknownPart = false; - - private boolean propertyPart = false; + private BirthmarkService service; - private boolean classpathPart = false; + private Part part; private int wellknownType = 0; @@ -69,19 +70,18 @@ public class ConfigFileParser extends DefaultHandler{ qname = qName; if(qName.equals("wellknown-classes")){ - wellknownPart = true; - propertyPart = false; - classpathPart = false; + part = Part.WELLKNOWN_CLASSES; } else if(qName.equals("property")){ - wellknownPart = false; - propertyPart = true; - classpathPart = false; + part = Part.PROPERTIES; } else if(qName.equals("classpath-list")){ - wellknownPart = false; - propertyPart = false; - classpathPart = true; + part = Part.CLASSPATH; + } + else if(qName.equals("service")){ + part = Part.SERVICES; + service = new BirthmarkService(); + service.setUserDefined(false); } else if(qName.equals("exclude")){ wellknownType = WellknownClassJudgeRule.EXCLUDE_TYPE; @@ -110,24 +110,38 @@ public class ConfigFileParser extends DefaultHandler{ public void characters(char[] data, int offset, int length) throws SAXException{ String value = new String(data, offset, length).trim(); if(value.length() > 0){ - if(qname.equals("name") && propertyPart){ - key = new String(data, offset, length).trim(); + if(qname.equals("name") && part == Part.PROPERTIES){ + key = value; } - else if(qname.equals("value") && propertyPart){ - context.addProperty(key, new String(data, offset, length).trim()); + else if(qname.equals("value") && part == Part.PROPERTIES){ + context.addProperty(key, value); } - else if(wellknownPart && (qname.equals("suffix") || qname.equals("prefix") || - qname.equals("match"))){ - manager.add(new WellknownClassJudgeRule(new String(data, offset, length), - wellknownType | patternType)); + else if(part == Part.WELLKNOWN_CLASSES && + (qname.equals("suffix") || qname.equals("prefix") || qname.equals("match"))){ + manager.add(new WellknownClassJudgeRule(value, wellknownType | patternType)); } - else if(classpathPart && qname.equals("classpath")){ + else if(part == Part.CLASSPATH && qname.equals("classpath")){ try{ context.getBytecodeContext().addClasspath(new URL(value)); } catch(MalformedURLException e){ throw new SAXException(e); } } + else if(part == Part.SERVICES){ + if(qname.equals("type")) service.setType(value); + else if(qname.equals("display-name")) service.setDisplayType(value); + else if(qname.equals("description")) service.setDescription(value); + else if(qname.equals("extractor")) service.setExtractorClassName(value); + else if(qname.equals("comparator")) service.setComparatorClassName(value); + } + } + } + + @Override + public void endElement(String uri, String localname, String qname){ + if(part == Part.SERVICES && qname.equals("service")){ + context.addService(service); + service = null; } } } diff --git a/src/main/java/jp/naist/se/stigmata/Stigmata.java b/src/main/java/jp/naist/se/stigmata/Stigmata.java index 5101385..683b3f7 100755 --- a/src/main/java/jp/naist/se/stigmata/Stigmata.java +++ b/src/main/java/jp/naist/se/stigmata/Stigmata.java @@ -235,7 +235,7 @@ public class Stigmata{ ConfigFileParser parser = new ConfigFileParser(defaultContext); parser.parse(in); } catch(IOException e){ - return; + throw new ApplicationInitializationError(e); } for(Iterator i = ServiceRegistry.lookupProviders(BirthmarkSpi.class); i.hasNext(); ){ BirthmarkSpi service = i.next(); diff --git a/src/main/java/jp/naist/se/stigmata/birthmarks/AbstractBirthmarkService.java b/src/main/java/jp/naist/se/stigmata/birthmarks/AbstractBirthmarkService.java index 523fa88..c4a9391 100755 --- a/src/main/java/jp/naist/se/stigmata/birthmarks/AbstractBirthmarkService.java +++ b/src/main/java/jp/naist/se/stigmata/birthmarks/AbstractBirthmarkService.java @@ -38,4 +38,24 @@ public abstract class AbstractBirthmarkService implements BirthmarkSpi{ } return description; } + + public String getComparatorClassName(){ + return getComparator().getClass().getName(); + } + + public String getExtractorClassName(){ + return getExtractor().getClass().getName(); + } + + public abstract String getType(); + + public abstract String getDefaultDescription(); + + public boolean isExpert(){ + return true; + } + + public boolean isUserDefined(){ + return true; + } } diff --git a/src/main/java/jp/naist/se/stigmata/birthmarks/BirthmarkService.java b/src/main/java/jp/naist/se/stigmata/birthmarks/BirthmarkService.java new file mode 100755 index 0000000..1ac67f6 --- /dev/null +++ b/src/main/java/jp/naist/se/stigmata/birthmarks/BirthmarkService.java @@ -0,0 +1,152 @@ +package jp.naist.se.stigmata.birthmarks; + +/* + * $Id: BirthmarkSpi.java 20 2007-01-17 02:06:01Z tama3 $ + */ + +import java.lang.reflect.Constructor; + +import jp.naist.se.stigmata.BirthmarkComparator; +import jp.naist.se.stigmata.BirthmarkContext; +import jp.naist.se.stigmata.BirthmarkExtractor; +import jp.naist.se.stigmata.spi.BirthmarkSpi; + +/** + * Birthmark Service Provider Interface. + * + * @author Haruaki TAMADA + * @version $Revision: 20 $ $Date: 2007-01-17 11:06:01 +0900 (Wed, 17 Jan 2007) $ + */ +public class BirthmarkService extends AbstractBirthmarkService implements BirthmarkSpi{ + private Class extractorClass; + private Class comparatorClass; + private String type; + private String displayType; + private String description; + private BirthmarkExtractor extractorObject; + private BirthmarkComparator comparatorObject; + private boolean userDefined = true; + private BirthmarkContext context; + + public BirthmarkService(BirthmarkContext context){ + this.context = context; + } + + public BirthmarkService(){ + } + + public void setExtractorClassName(String extractor){ + try{ + Class c; + if(context == null){ + c = Class.forName(extractor); + } + else{ + c = context.getBytecodeContext().findClass(extractor); + } + extractorClass = c.asSubclass(BirthmarkExtractor.class); + extractorObject = null; + } catch(ClassNotFoundException e){ + e.printStackTrace(); + } + } + + public void setComparatorClassName(String comparator){ + try{ + Class c; + if(context == null){ + c = Class.forName(comparator); + } + else{ + c = context.getBytecodeContext().findClass(comparator); + } + comparatorClass = c.asSubclass(BirthmarkComparator.class); + comparatorObject = null; + } catch(ClassNotFoundException e){ + e.printStackTrace(); + } + } + + public void setType(String type){ + this.type = type; + } + + /** + * returns a type of the birthmark this service provides. + */ + @Override + public String getType(){ + return type; + } + + public void setDisplayType(String displayType){ + this.displayType = displayType; + } + + public String getDisplayType(){ + return displayType; + } + + public void setDescription(String description){ + this.description = description; + } + + public String getDescription(){ + return description; + } + + /** + * returns a description of the birthmark this service provides. + */ + @Override + public String getDefaultDescription(){ + return description; + } + + public String getExtractorClassName(){ + return extractorClass.getName(); + } + + /** + * returns a extractor for the birthmark of this service. + */ + public BirthmarkExtractor getExtractor(){ + if(extractorObject == null){ + try{ + Constructor c = extractorClass.getConstructor(BirthmarkSpi.class); + extractorObject = c.newInstance(this); + } catch(Exception e){ + e.printStackTrace(); + } + } + return extractorObject; + } + + public String getComparatorClassName(){ + return comparatorClass.getName(); + } + + /** + * returns a comparator for the birthmark of this service. + */ + public BirthmarkComparator getComparator(){ + if(comparatorObject == null){ + try{ + Constructor c = comparatorClass.getConstructor(BirthmarkSpi.class); + comparatorObject = c.newInstance(this); + } catch(Exception e){ + e.printStackTrace(); + } + } + return comparatorObject; + } + + public boolean isUserDefined(){ + return userDefined; + } + + public void setUserDefined(boolean userDefined){ + this.userDefined = userDefined; + } +} + diff --git a/src/main/java/jp/naist/se/stigmata/birthmarks/LocalizedDescriptionManager.java b/src/main/java/jp/naist/se/stigmata/birthmarks/LocalizedDescriptionManager.java index 05aa340..3b4962f 100755 --- a/src/main/java/jp/naist/se/stigmata/birthmarks/LocalizedDescriptionManager.java +++ b/src/main/java/jp/naist/se/stigmata/birthmarks/LocalizedDescriptionManager.java @@ -15,6 +15,9 @@ import java.util.ResourceBundle; * @version $Revision$ $Date$ */ public class LocalizedDescriptionManager{ + public static enum Type{ + comparator, extractor, birthmark, + }; private Map resources = new HashMap(); /** @@ -34,8 +37,12 @@ public class LocalizedDescriptionManager{ } public String getDescription(Locale locale, String birthmarkType){ + return getDescription(locale, birthmarkType, Type.birthmark); + } + + public String getDescription(Locale locale, String birthmarkType, Type type){ try{ - return getBundle(locale).getString("birthmark." + birthmarkType + ".description"); + return getBundle(locale).getString(type.name() + "." + birthmarkType + ".description"); } catch(MissingResourceException e){ return null; } diff --git a/src/main/java/jp/naist/se/stigmata/birthmarks/PlainBirthmark.java b/src/main/java/jp/naist/se/stigmata/birthmarks/PlainBirthmark.java index 2c962ab..6d98c91 100755 --- a/src/main/java/jp/naist/se/stigmata/birthmarks/PlainBirthmark.java +++ b/src/main/java/jp/naist/se/stigmata/birthmarks/PlainBirthmark.java @@ -19,7 +19,7 @@ public class PlainBirthmark extends AbstractBirthmark{ public PlainBirthmark(String type){ this.type = type; } - + public void setType(String type){ this.type = type; } diff --git a/src/main/java/jp/naist/se/stigmata/birthmarks/comparators/AbstractBirthmarkComparatorService.java b/src/main/java/jp/naist/se/stigmata/birthmarks/comparators/AbstractBirthmarkComparatorService.java new file mode 100755 index 0000000..707a2ec --- /dev/null +++ b/src/main/java/jp/naist/se/stigmata/birthmarks/comparators/AbstractBirthmarkComparatorService.java @@ -0,0 +1,59 @@ +package jp.naist.se.stigmata.birthmarks.comparators; + +/* + * $Id: BirthmarkSpi.java 20 2007-01-17 02:06:01Z tama3 $ + */ + +import java.lang.reflect.Constructor; +import java.util.Locale; + +import jp.naist.se.stigmata.BirthmarkComparator; +import jp.naist.se.stigmata.spi.BirthmarkComparatorSpi; +import jp.naist.se.stigmata.spi.BirthmarkSpi; +import jp.naist.se.stigmata.birthmarks.LocalizedDescriptionManager; + +/** + * Birthmark Service Provider Interface. + * + * @author Haruaki TAMADA + * @version $Revision: 20 $ $Date: 2007-01-17 11:06:01 +0900 (Wed, 17 Jan 2007) $ + */ +abstract class AbstractBirthmarkComparatorService implements BirthmarkComparatorSpi{ + /** + * returns a type of the birthmark this service provides. + */ + public abstract String getType(); + + /** + * returns a localized description of the birthmark this service provides. + */ + public String getDescription(Locale locale){ + return LocalizedDescriptionManager.getInstance().getDescription( + locale, getType(), LocalizedDescriptionManager.Type.comparator + ); + } + + /** + * returns a localized description of the birthmark in default locale. + */ + public String getDescription(){ + return getDescription(Locale.getDefault()); + } + + public abstract String getComparatorClassName(); + + /** + * returns a extractor for the birthmark of this service. + */ + public BirthmarkComparator getComparator(BirthmarkSpi service){ + try{ + Class c = Class.forName(getComparatorClassName()); + Class clazz = c.asSubclass(BirthmarkComparator.class); + Constructor constructor = clazz.getConstructor(BirthmarkSpi.class); + return constructor.newInstance(service); + } catch(Exception e){ + } + return null; + } +} + diff --git a/src/main/java/jp/naist/se/stigmata/birthmarks/DPMatchingBirthmarkComparator.java b/src/main/java/jp/naist/se/stigmata/birthmarks/comparators/DPMatchingBirthmarkComparator.java similarity index 98% rename from src/main/java/jp/naist/se/stigmata/birthmarks/DPMatchingBirthmarkComparator.java rename to src/main/java/jp/naist/se/stigmata/birthmarks/comparators/DPMatchingBirthmarkComparator.java index dca1549..5d9d323 100755 --- a/src/main/java/jp/naist/se/stigmata/birthmarks/DPMatchingBirthmarkComparator.java +++ b/src/main/java/jp/naist/se/stigmata/birthmarks/comparators/DPMatchingBirthmarkComparator.java @@ -1,4 +1,4 @@ -package jp.naist.se.stigmata.birthmarks; +package jp.naist.se.stigmata.birthmarks.comparators; /* * $Id$ diff --git a/src/main/java/jp/naist/se/stigmata/birthmarks/comparators/DPMatchingBirthmarkComparatorService.java b/src/main/java/jp/naist/se/stigmata/birthmarks/comparators/DPMatchingBirthmarkComparatorService.java new file mode 100755 index 0000000..dba72b3 --- /dev/null +++ b/src/main/java/jp/naist/se/stigmata/birthmarks/comparators/DPMatchingBirthmarkComparatorService.java @@ -0,0 +1,35 @@ +package jp.naist.se.stigmata.birthmarks.comparators; + +/* + * $Id: BirthmarkSpi.java 20 2007-01-17 02:06:01Z tama3 $ + */ + +import jp.naist.se.stigmata.BirthmarkComparator; +import jp.naist.se.stigmata.spi.BirthmarkSpi; + +/** + * Birthmark Service Provider Interface. + * + * @author Haruaki TAMADA + * @version $Revision: 20 $ $Date: 2007-01-17 11:06:01 +0900 (Wed, 17 Jan 2007) $ + */ +public class DPMatchingBirthmarkComparatorService extends AbstractBirthmarkComparatorService{ + /** + * returns a type of the birthmark this service provides. + */ + public String getType(){ + return "DP Matching"; + } + + public String getComparatorClassName(){ + return "jp.naist.se.stigmata.birthmarks.comparators.DPMatchingBirthmarkComparator"; + } + + /** + * returns a extractor for the birthmark of this service. + */ + public BirthmarkComparator getComparator(BirthmarkSpi service){ + return new DPMatchingBirthmarkComparator(service); + } +} + diff --git a/src/main/java/jp/naist/se/stigmata/birthmarks/comparators/EditDistanceBirthmarkComparator.java b/src/main/java/jp/naist/se/stigmata/birthmarks/comparators/EditDistanceBirthmarkComparator.java new file mode 100755 index 0000000..93f2ad8 --- /dev/null +++ b/src/main/java/jp/naist/se/stigmata/birthmarks/comparators/EditDistanceBirthmarkComparator.java @@ -0,0 +1,90 @@ +package jp.naist.se.stigmata.birthmarks.comparators; + +/* + * $Id: DPMatchingBirthmarkComparator.java 53 2007-02-22 02:46:40Z tama3 $ + */ + +import jp.naist.se.stigmata.Birthmark; +import jp.naist.se.stigmata.BirthmarkComparator; +import jp.naist.se.stigmata.BirthmarkElement; +import jp.naist.se.stigmata.spi.BirthmarkSpi; + +/** + * calculate similarities between two birthmarks by edit distance + * algorithm (levenshtein distance). + * + * @author Haruaki TAMADA + * @version $Revision: 53 $ $Date: 2007-02-22 11:46:40 +0900 (Thu, 22 Feb 2007) $ + */ +public class EditDistanceBirthmarkComparator implements BirthmarkComparator{ + private BirthmarkSpi spi; + + public EditDistanceBirthmarkComparator(){ + } + + public EditDistanceBirthmarkComparator(BirthmarkSpi spi){ + this.spi = spi; + } + + public BirthmarkSpi getProvider(){ + return spi; + } + + public String getType(){ + return spi.getType(); + } + + public double compare(Birthmark b1, Birthmark b2) { + if(!b1.getType().equals(b2.getType())){ + return Double.NaN; + } + + BirthmarkElement[] element1 = b1.getElements(); + BirthmarkElement[] element2 = b2.getElements(); + int[][] distance = createDistanceMatrics(element1, element2); + + int length = element1.length; + if(length < element2.length){ + length = element2.length; + } + int d = distance[element1.length][element2.length]; + + if(element1.length == 0 && element2.length == 0){ + return 1d; + } + return (double)(length - d) / length; + } + + public int getCompareCount(Birthmark b1, Birthmark b2){ + return b1.getElementCount() + b2.getElementCount(); + } + + protected int[][] createDistanceMatrics(BirthmarkElement[] element1, + BirthmarkElement[] element2){ + int[][] distance = new int[element1.length + 1][element2.length + 1]; + for(int i = 0; i <= element1.length; i++) distance[i][0] = i; + for(int i = 0; i <= element2.length; i++) distance[0][i] = i; + + for(int i = 1; i <= element1.length; i++){ + for(int j = 1; j <= element2.length; j++){ + int cost = 1; + if(element1[i - 1] == null){ + if(element2[j - 1] == null) cost = 0; + else cost = 1; + } + else{ + if(element1[i - 1].equals(element2[j - 1])) cost = 0; + else cost = 1; + } + int insertion = distance[i - 1][j ] + 1; + int deletion = distance[i ][j - 1] + 1; + int replace = distance[i - 1][j - 1] + cost; + + if(insertion <= deletion && insertion <= replace) distance[i][j] = insertion; + else if(deletion <= replace) distance[i][j] = deletion; + else distance[i][j] = replace; + } + } + return distance; + } +} diff --git a/src/main/java/jp/naist/se/stigmata/birthmarks/comparators/EditDistanceBirthmarkComparatorService.java b/src/main/java/jp/naist/se/stigmata/birthmarks/comparators/EditDistanceBirthmarkComparatorService.java new file mode 100755 index 0000000..daaf0fd --- /dev/null +++ b/src/main/java/jp/naist/se/stigmata/birthmarks/comparators/EditDistanceBirthmarkComparatorService.java @@ -0,0 +1,35 @@ +package jp.naist.se.stigmata.birthmarks.comparators; + +/* + * $Id: BirthmarkSpi.java 20 2007-01-17 02:06:01Z tama3 $ + */ + +import jp.naist.se.stigmata.BirthmarkComparator; +import jp.naist.se.stigmata.spi.BirthmarkSpi; + +/** + * Birthmark Service Provider Interface. + * + * @author Haruaki TAMADA + * @version $Revision: 20 $ $Date: 2007-01-17 11:06:01 +0900 (Wed, 17 Jan 2007) $ + */ +public class EditDistanceBirthmarkComparatorService extends AbstractBirthmarkComparatorService{ + /** + * returns a type of the birthmark this service provides. + */ + public String getType(){ + return "Edit Distance"; + } + + public String getComparatorClassName(){ + return "jp.naist.se.stigmata.birthmarks.comparators.EditDistanceBirthmarkComparator"; + } + + /** + * returns a extractor for the birthmark of this service. + */ + public BirthmarkComparator getComparator(BirthmarkSpi service){ + return new EditDistanceBirthmarkComparator(service); + } +} + diff --git a/src/main/java/jp/naist/se/stigmata/birthmarks/comparators/ExtendedEditDistanceBirthmarkComparator.java b/src/main/java/jp/naist/se/stigmata/birthmarks/comparators/ExtendedEditDistanceBirthmarkComparator.java new file mode 100755 index 0000000..83af600 --- /dev/null +++ b/src/main/java/jp/naist/se/stigmata/birthmarks/comparators/ExtendedEditDistanceBirthmarkComparator.java @@ -0,0 +1,43 @@ +package jp.naist.se.stigmata.birthmarks.comparators; + +/* + * $Id: DPMatchingBirthmarkComparator.java 53 2007-02-22 02:46:40Z tama3 $ + */ + +import jp.naist.se.stigmata.Birthmark; +import jp.naist.se.stigmata.BirthmarkElement; +import jp.naist.se.stigmata.spi.BirthmarkSpi; + +/** + * calculate similarities between two birthmarks by edit distance + * algorithm (levenshtein distance). + * + * @author Haruaki TAMADA + * @version $Revision: 53 $ $Date: 2007-02-22 11:46:40 +0900 (Thu, 22 Feb 2007) $ + */ +public class ExtendedEditDistanceBirthmarkComparator extends EditDistanceBirthmarkComparator{ + public ExtendedEditDistanceBirthmarkComparator(){ + } + + public ExtendedEditDistanceBirthmarkComparator(BirthmarkSpi spi){ + super(spi); + } + + public double compare(Birthmark b1, Birthmark b2) { + if(!b1.getType().equals(b2.getType())){ + return Double.NaN; + } + + BirthmarkElement[] element1 = b1.getElements(); + BirthmarkElement[] element2 = b2.getElements(); + int[][] distance = createDistanceMatrics(element1, element2); + + int length = element1.length; + if(length > element2.length){ + length = element2.length; + } + int d = distance[element1.length][element2.length]; + + return (double)(1 - (d + Math.abs(element1.length - element2.length))) / length; + } +} diff --git a/src/main/java/jp/naist/se/stigmata/birthmarks/comparators/LogicalAndBirthmarkComparator.java b/src/main/java/jp/naist/se/stigmata/birthmarks/comparators/LogicalAndBirthmarkComparator.java new file mode 100755 index 0000000..8db1114 --- /dev/null +++ b/src/main/java/jp/naist/se/stigmata/birthmarks/comparators/LogicalAndBirthmarkComparator.java @@ -0,0 +1,72 @@ +package jp.naist.se.stigmata.birthmarks.comparators; + +/* + * $Id: PlainBirthmarkComparator.java 20 2007-01-17 02:06:01Z tama3 $ + */ + +import java.util.Set; +import java.util.HashSet; + +import jp.naist.se.stigmata.Birthmark; +import jp.naist.se.stigmata.BirthmarkComparator; +import jp.naist.se.stigmata.BirthmarkElement; +import jp.naist.se.stigmata.spi.BirthmarkSpi; + +/** + * + * @author Haruaki TAMADA + * @version $Revision: 20 $ $Date: 2007-01-17 11:06:01 +0900 (Wed, 17 Jan 2007) $ + */ +public class LogicalAndBirthmarkComparator implements BirthmarkComparator{ + private BirthmarkSpi spi; + + public LogicalAndBirthmarkComparator(){ + } + + public LogicalAndBirthmarkComparator(BirthmarkSpi spi){ + this.spi = spi; + } + + public BirthmarkSpi getProvider(){ + return spi; + } + + public String getType(){ + return spi.getType(); + } + + public double compare(Birthmark b1, Birthmark b2) { + if(!b1.getType().equals(b2.getType())){ + return Double.NaN; + } + + + BirthmarkElement[] element1 = b1.getElements(); + BirthmarkElement[] element2 = b2.getElements(); + Set set1 = new HashSet(); + for(int i = 0; i < element1.length; i++) set1.add(element1[i]); + Set set2 = new HashSet(); + for(int i = 0; i < element2.length; i++) set2.add(element2[i]); + + Set set = new HashSet(); + for(BirthmarkElement elem: set1){ + if(set2.contains(elem)) set.add(elem); + } + for(BirthmarkElement elem: set2){ + if(set1.contains(elem)) set.add(elem); + } + + int len = set1.size() + set2.size(); + int frac = set.size() * 2; + + double similarity = (double)frac / (double)len; + if(len == 0 && frac == 0){ + similarity = 1d; + } + return similarity; + } + + public int getCompareCount(Birthmark b1, Birthmark b2){ + return b1.getElementCount() + b2.getElementCount(); + } +} diff --git a/src/main/java/jp/naist/se/stigmata/birthmarks/comparators/LogicalAndBirthmarkComparatorService.java b/src/main/java/jp/naist/se/stigmata/birthmarks/comparators/LogicalAndBirthmarkComparatorService.java new file mode 100755 index 0000000..fdb2a90 --- /dev/null +++ b/src/main/java/jp/naist/se/stigmata/birthmarks/comparators/LogicalAndBirthmarkComparatorService.java @@ -0,0 +1,35 @@ +package jp.naist.se.stigmata.birthmarks.comparators; + +/* + * $Id: BirthmarkSpi.java 20 2007-01-17 02:06:01Z tama3 $ + */ + +import jp.naist.se.stigmata.BirthmarkComparator; +import jp.naist.se.stigmata.spi.BirthmarkSpi; + +/** + * Birthmark Service Provider Interface. + * + * @author Haruaki TAMADA + * @version $Revision: 20 $ $Date: 2007-01-17 11:06:01 +0900 (Wed, 17 Jan 2007) $ + */ +public class LogicalAndBirthmarkComparatorService extends AbstractBirthmarkComparatorService{ + /** + * returns a type of the birthmark this service provides. + */ + public String getType(){ + return "AND"; + } + + public String getComparatorClassName(){ + return "jp.naist.se.stigmata.birthmarks.comparators.LogicalAndBirthmarkComparator"; + } + + /** + * returns a extractor for the birthmark of this service. + */ + public BirthmarkComparator getComparator(BirthmarkSpi service){ + return new LogicalAndBirthmarkComparator(service); + } +} + diff --git a/src/main/java/jp/naist/se/stigmata/birthmarks/PlainBirthmarkComparator.java b/src/main/java/jp/naist/se/stigmata/birthmarks/comparators/PlainBirthmarkComparator.java similarity index 96% rename from src/main/java/jp/naist/se/stigmata/birthmarks/PlainBirthmarkComparator.java rename to src/main/java/jp/naist/se/stigmata/birthmarks/comparators/PlainBirthmarkComparator.java index e000573..9c269ee 100755 --- a/src/main/java/jp/naist/se/stigmata/birthmarks/PlainBirthmarkComparator.java +++ b/src/main/java/jp/naist/se/stigmata/birthmarks/comparators/PlainBirthmarkComparator.java @@ -1,4 +1,4 @@ -package jp.naist.se.stigmata.birthmarks; +package jp.naist.se.stigmata.birthmarks.comparators; /* * $Id$ diff --git a/src/main/java/jp/naist/se/stigmata/birthmarks/comparators/PlainBirthmarkComparatorService.java b/src/main/java/jp/naist/se/stigmata/birthmarks/comparators/PlainBirthmarkComparatorService.java new file mode 100755 index 0000000..ea53a83 --- /dev/null +++ b/src/main/java/jp/naist/se/stigmata/birthmarks/comparators/PlainBirthmarkComparatorService.java @@ -0,0 +1,35 @@ +package jp.naist.se.stigmata.birthmarks.comparators; + +/* + * $Id: BirthmarkSpi.java 20 2007-01-17 02:06:01Z tama3 $ + */ + +import jp.naist.se.stigmata.BirthmarkComparator; +import jp.naist.se.stigmata.spi.BirthmarkSpi; + +/** + * Birthmark Service Provider Interface. + * + * @author Haruaki TAMADA + * @version $Revision: 20 $ $Date: 2007-01-17 11:06:01 +0900 (Wed, 17 Jan 2007) $ + */ +public class PlainBirthmarkComparatorService extends AbstractBirthmarkComparatorService{ + /** + * returns a type of the birthmark this service provides. + */ + public String getType(){ + return "plain"; + } + + public String getComparatorClassName(){ + return "jp.naist.se.stigmata.birthmarks.comparators.PlainBirthmarkComparator"; + } + + /** + * returns a extractor for the birthmark of this service. + */ + public BirthmarkComparator getComparator(BirthmarkSpi service){ + return new PlainBirthmarkComparator(service); + } +} + diff --git a/src/main/java/jp/naist/se/stigmata/birthmarks/cvfv/ConstantValueOfFieldVariableBirthmarkExtractVisitor.java b/src/main/java/jp/naist/se/stigmata/birthmarks/cvfv/ConstantValueOfFieldVariableBirthmarkExtractVisitor.java index 6f282c3..79c5517 100755 --- a/src/main/java/jp/naist/se/stigmata/birthmarks/cvfv/ConstantValueOfFieldVariableBirthmarkExtractVisitor.java +++ b/src/main/java/jp/naist/se/stigmata/birthmarks/cvfv/ConstantValueOfFieldVariableBirthmarkExtractVisitor.java @@ -37,7 +37,6 @@ public class ConstantValueOfFieldVariableBirthmarkExtractVisitor extends Birthma public void visitEnd(){ for(String key: elements.keySet()){ - TypeAndValueBirthmarkElement element = elements.get(key); birthmark.addElement(elements.get(key)); } super.visitEnd(); diff --git a/src/main/java/jp/naist/se/stigmata/birthmarks/cvfv/ConstantValueOfFieldVariableBirthmarkService.java b/src/main/java/jp/naist/se/stigmata/birthmarks/cvfv/ConstantValueOfFieldVariableBirthmarkService.java index ad93f0f..e3f8722 100755 --- a/src/main/java/jp/naist/se/stigmata/birthmarks/cvfv/ConstantValueOfFieldVariableBirthmarkService.java +++ b/src/main/java/jp/naist/se/stigmata/birthmarks/cvfv/ConstantValueOfFieldVariableBirthmarkService.java @@ -7,7 +7,7 @@ package jp.naist.se.stigmata.birthmarks.cvfv; import jp.naist.se.stigmata.BirthmarkComparator; import jp.naist.se.stigmata.BirthmarkExtractor; import jp.naist.se.stigmata.birthmarks.AbstractBirthmarkService; -import jp.naist.se.stigmata.birthmarks.PlainBirthmarkComparator; +import jp.naist.se.stigmata.birthmarks.comparators.PlainBirthmarkComparator; import jp.naist.se.stigmata.spi.BirthmarkSpi; /** @@ -36,4 +36,12 @@ public class ConstantValueOfFieldVariableBirthmarkService extends AbstractBirthm public BirthmarkComparator getComparator(){ return comparator; } + + public boolean isExpert(){ + return false; + } + + public boolean isUserDefined(){ + return false; + } } diff --git a/src/main/java/jp/naist/se/stigmata/birthmarks/extractors/AbstractBirthmarkExtractorService.java b/src/main/java/jp/naist/se/stigmata/birthmarks/extractors/AbstractBirthmarkExtractorService.java new file mode 100755 index 0000000..7198a2a --- /dev/null +++ b/src/main/java/jp/naist/se/stigmata/birthmarks/extractors/AbstractBirthmarkExtractorService.java @@ -0,0 +1,59 @@ +package jp.naist.se.stigmata.birthmarks.extractors; + +/* + * $Id: BirthmarkSpi.java 20 2007-01-17 02:06:01Z tama3 $ + */ + +import java.lang.reflect.Constructor; +import java.util.Locale; + +import jp.naist.se.stigmata.BirthmarkExtractor; +import jp.naist.se.stigmata.spi.BirthmarkExtractorSpi; +import jp.naist.se.stigmata.spi.BirthmarkSpi; +import jp.naist.se.stigmata.birthmarks.LocalizedDescriptionManager; + +/** + * Birthmark Service Provider Interface. + * + * @author Haruaki TAMADA + * @version $Revision: 20 $ $Date: 2007-01-17 11:06:01 +0900 (Wed, 17 Jan 2007) $ + */ +abstract class AbstractBirthmarkExtractorService implements BirthmarkExtractorSpi{ + /** + * returns a type of the birthmark this service provides. + */ + public abstract String getType(); + + /** + * returns a localized description of the birthmark this service provides. + */ + public String getDescription(Locale locale){ + return LocalizedDescriptionManager.getInstance().getDescription( + locale, getType(), LocalizedDescriptionManager.Type.extractor + ); + } + + /** + * returns a localized description of the birthmark in default locale. + */ + public String getDescription(){ + return getDescription(Locale.getDefault()); + } + + public abstract String getExtractorClassName(); + + /** + * returns a extractor for the birthmark of this service. + */ + public BirthmarkExtractor getExtractor(BirthmarkSpi service){ + try{ + Class c = Class.forName(getExtractorClassName()); + Class clazz = c.asSubclass(BirthmarkExtractor.class); + Constructor constructor = clazz.getConstructor(BirthmarkSpi.class); + return constructor.newInstance(service); + } catch(Exception e){ + } + return null; + } +} + diff --git a/src/main/java/jp/naist/se/stigmata/birthmarks/extractors/ConstantValueOfFieldVariableBirthmarkExtractorService.java b/src/main/java/jp/naist/se/stigmata/birthmarks/extractors/ConstantValueOfFieldVariableBirthmarkExtractorService.java new file mode 100755 index 0000000..6b1d153 --- /dev/null +++ b/src/main/java/jp/naist/se/stigmata/birthmarks/extractors/ConstantValueOfFieldVariableBirthmarkExtractorService.java @@ -0,0 +1,36 @@ +package jp.naist.se.stigmata.birthmarks.extractors; + +/* + * $Id: BirthmarkSpi.java 20 2007-01-17 02:06:01Z tama3 $ + */ + +import jp.naist.se.stigmata.BirthmarkExtractor; +import jp.naist.se.stigmata.birthmarks.cvfv.ConstantValueOfFieldVariableBirthmarkExtractor; +import jp.naist.se.stigmata.spi.BirthmarkSpi; + +/** + * Birthmark Service Provider Interface. + * + * @author Haruaki TAMADA + * @version $Revision: 20 $ $Date: 2007-01-17 11:06:01 +0900 (Wed, 17 Jan 2007) $ + */ +public class ConstantValueOfFieldVariableBirthmarkExtractorService extends AbstractBirthmarkExtractorService{ + + /** + * returns a type of the birthmark this service provides. + */ + public String getType(){ + return "cvfv"; + } + + public String getExtractorClassName(){ + return "jp.naist.se.stigmata.birthmarks.cvfv.ConstantValueOfFieldVariableBirthmarkExtractor"; + } + + /** + * returns a extractor for the birthmark of this service. + */ + public BirthmarkExtractor getExtractor(BirthmarkSpi service){ + return new ConstantValueOfFieldVariableBirthmarkExtractor(service); + } +} \ No newline at end of file diff --git a/src/main/java/jp/naist/se/stigmata/birthmarks/extractors/InheritanceStructureBirthmarkExtractorService.java b/src/main/java/jp/naist/se/stigmata/birthmarks/extractors/InheritanceStructureBirthmarkExtractorService.java new file mode 100755 index 0000000..4086c36 --- /dev/null +++ b/src/main/java/jp/naist/se/stigmata/birthmarks/extractors/InheritanceStructureBirthmarkExtractorService.java @@ -0,0 +1,36 @@ +package jp.naist.se.stigmata.birthmarks.extractors; + +/* + * $Id: BirthmarkSpi.java 20 2007-01-17 02:06:01Z tama3 $ + */ + +import jp.naist.se.stigmata.BirthmarkExtractor; +import jp.naist.se.stigmata.birthmarks.is.InheritanceStructureBirthmarkExtractor; +import jp.naist.se.stigmata.spi.BirthmarkSpi; + +/** + * Birthmark Service Provider Interface. + * + * @author Haruaki TAMADA + * @version $Revision: 20 $ $Date: 2007-01-17 11:06:01 +0900 (Wed, 17 Jan 2007) $ + */ +public class InheritanceStructureBirthmarkExtractorService extends AbstractBirthmarkExtractorService{ + + /** + * returns a type of the birthmark this service provides. + */ + public String getType(){ + return "is"; + } + + public String getExtractorClassName(){ + return "jp.naist.se.stigmata.birthmarks.is.InheritanceStructureBirthmarkExtractor"; + } + + /** + * returns a extractor for the birthmark of this service. + */ + public BirthmarkExtractor getExtractor(BirthmarkSpi service){ + return new InheritanceStructureBirthmarkExtractor(service); + } +} \ No newline at end of file diff --git a/src/main/java/jp/naist/se/stigmata/birthmarks/extractors/SequentialMethodCallBirthmarkExtractorService.java b/src/main/java/jp/naist/se/stigmata/birthmarks/extractors/SequentialMethodCallBirthmarkExtractorService.java new file mode 100755 index 0000000..066eb94 --- /dev/null +++ b/src/main/java/jp/naist/se/stigmata/birthmarks/extractors/SequentialMethodCallBirthmarkExtractorService.java @@ -0,0 +1,36 @@ +package jp.naist.se.stigmata.birthmarks.extractors; + +/* + * $Id: BirthmarkSpi.java 20 2007-01-17 02:06:01Z tama3 $ + */ + +import jp.naist.se.stigmata.BirthmarkExtractor; +import jp.naist.se.stigmata.birthmarks.smc.SequentialMethodCallBirthmarkExtractor; +import jp.naist.se.stigmata.spi.BirthmarkSpi; + +/** + * Birthmark Service Provider Interface. + * + * @author Haruaki TAMADA + * @version $Revision: 20 $ $Date: 2007-01-17 11:06:01 +0900 (Wed, 17 Jan 2007) $ + */ +public class SequentialMethodCallBirthmarkExtractorService extends AbstractBirthmarkExtractorService{ + + /** + * returns a type of the birthmark this service provides. + */ + public String getType(){ + return "smc"; + } + + public String getExtractorClassName(){ + return "jp.naist.se.stigmata.birthmarks.smc.SequentialMethodCallBirthmarkExtractor"; + } + + /** + * returns a extractor for the birthmark of this service. + */ + public BirthmarkExtractor getExtractor(BirthmarkSpi service){ + return new SequentialMethodCallBirthmarkExtractor(service); + } +} \ No newline at end of file diff --git a/src/main/java/jp/naist/se/stigmata/birthmarks/extractors/UsedClassesBirthmarkExtractorService.java b/src/main/java/jp/naist/se/stigmata/birthmarks/extractors/UsedClassesBirthmarkExtractorService.java new file mode 100755 index 0000000..bf1ee97 --- /dev/null +++ b/src/main/java/jp/naist/se/stigmata/birthmarks/extractors/UsedClassesBirthmarkExtractorService.java @@ -0,0 +1,36 @@ +package jp.naist.se.stigmata.birthmarks.extractors; + +/* + * $Id: BirthmarkSpi.java 20 2007-01-17 02:06:01Z tama3 $ + */ + +import jp.naist.se.stigmata.BirthmarkExtractor; +import jp.naist.se.stigmata.birthmarks.uc.UsedClassesBirthmarkExtractor; +import jp.naist.se.stigmata.spi.BirthmarkSpi; + +/** + * Birthmark Service Provider Interface. + * + * @author Haruaki TAMADA + * @version $Revision: 20 $ $Date: 2007-01-17 11:06:01 +0900 (Wed, 17 Jan 2007) $ + */ +public class UsedClassesBirthmarkExtractorService extends AbstractBirthmarkExtractorService{ + + /** + * returns a type of the birthmark this service provides. + */ + public String getType(){ + return "uc"; + } + + public String getExtractorClassName(){ + return "jp.naist.se.stigmata.birthmarks.uc.UsedClassesBirthmarkExtractor"; + } + + /** + * returns a extractor for the birthmark of this service. + */ + public BirthmarkExtractor getExtractor(BirthmarkSpi service){ + return new UsedClassesBirthmarkExtractor(service); + } +} \ No newline at end of file diff --git a/src/main/java/jp/naist/se/stigmata/birthmarks/is/InheritanceStructureBirthmarkService.java b/src/main/java/jp/naist/se/stigmata/birthmarks/is/InheritanceStructureBirthmarkService.java index aadf601..07c0223 100755 --- a/src/main/java/jp/naist/se/stigmata/birthmarks/is/InheritanceStructureBirthmarkService.java +++ b/src/main/java/jp/naist/se/stigmata/birthmarks/is/InheritanceStructureBirthmarkService.java @@ -7,7 +7,7 @@ package jp.naist.se.stigmata.birthmarks.is; import jp.naist.se.stigmata.BirthmarkComparator; import jp.naist.se.stigmata.BirthmarkExtractor; import jp.naist.se.stigmata.birthmarks.AbstractBirthmarkService; -import jp.naist.se.stigmata.birthmarks.PlainBirthmarkComparator; +import jp.naist.se.stigmata.birthmarks.comparators.PlainBirthmarkComparator; import jp.naist.se.stigmata.spi.BirthmarkSpi; /** @@ -36,4 +36,12 @@ public class InheritanceStructureBirthmarkService extends AbstractBirthmarkServi public BirthmarkComparator getComparator(){ return comparator; } + + public boolean isExpert(){ + return false; + } + + public boolean isUserDefined(){ + return false; + } } diff --git a/src/main/java/jp/naist/se/stigmata/birthmarks/smc/SequentialMethodCallBirthmarkService.java b/src/main/java/jp/naist/se/stigmata/birthmarks/smc/SequentialMethodCallBirthmarkService.java index 62b7450..4b30dec 100755 --- a/src/main/java/jp/naist/se/stigmata/birthmarks/smc/SequentialMethodCallBirthmarkService.java +++ b/src/main/java/jp/naist/se/stigmata/birthmarks/smc/SequentialMethodCallBirthmarkService.java @@ -7,7 +7,7 @@ package jp.naist.se.stigmata.birthmarks.smc; import jp.naist.se.stigmata.BirthmarkComparator; import jp.naist.se.stigmata.BirthmarkExtractor; import jp.naist.se.stigmata.birthmarks.AbstractBirthmarkService; -import jp.naist.se.stigmata.birthmarks.PlainBirthmarkComparator; +import jp.naist.se.stigmata.birthmarks.comparators.PlainBirthmarkComparator; import jp.naist.se.stigmata.spi.BirthmarkSpi; /** @@ -36,4 +36,12 @@ public class SequentialMethodCallBirthmarkService extends AbstractBirthmarkServi public BirthmarkComparator getComparator(){ return comparator; } + + public boolean isExpert(){ + return false; + } + + public boolean isUserDefined(){ + return false; + } } diff --git a/src/main/java/jp/naist/se/stigmata/birthmarks/uc/UsedClassesBirthmarkService.java b/src/main/java/jp/naist/se/stigmata/birthmarks/uc/UsedClassesBirthmarkService.java index 0587789..0ddf00a 100755 --- a/src/main/java/jp/naist/se/stigmata/birthmarks/uc/UsedClassesBirthmarkService.java +++ b/src/main/java/jp/naist/se/stigmata/birthmarks/uc/UsedClassesBirthmarkService.java @@ -7,7 +7,7 @@ package jp.naist.se.stigmata.birthmarks.uc; import jp.naist.se.stigmata.BirthmarkComparator; import jp.naist.se.stigmata.BirthmarkExtractor; import jp.naist.se.stigmata.birthmarks.AbstractBirthmarkService; -import jp.naist.se.stigmata.birthmarks.PlainBirthmarkComparator; +import jp.naist.se.stigmata.birthmarks.comparators.LogicalAndBirthmarkComparator; import jp.naist.se.stigmata.spi.BirthmarkSpi; /** @@ -18,7 +18,7 @@ import jp.naist.se.stigmata.spi.BirthmarkSpi; * @version $Revision$ $Date$ */ public class UsedClassesBirthmarkService extends AbstractBirthmarkService implements BirthmarkSpi{ - private BirthmarkComparator comparator = new PlainBirthmarkComparator(this); + private BirthmarkComparator comparator = new LogicalAndBirthmarkComparator(this); private BirthmarkExtractor extractor = new UsedClassesBirthmarkExtractor(this); public String getType(){ @@ -36,4 +36,12 @@ public class UsedClassesBirthmarkService extends AbstractBirthmarkService implem public BirthmarkComparator getComparator(){ return comparator; } + + public boolean isExpert(){ + return false; + } + + public boolean isUserDefined(){ + return false; + } } diff --git a/src/main/java/jp/naist/se/stigmata/format/csv/BirthmarkComparisonResultCsvFormat.java b/src/main/java/jp/naist/se/stigmata/format/csv/BirthmarkComparisonResultCsvFormat.java index 225bd2b..ce31200 100755 --- a/src/main/java/jp/naist/se/stigmata/format/csv/BirthmarkComparisonResultCsvFormat.java +++ b/src/main/java/jp/naist/se/stigmata/format/csv/BirthmarkComparisonResultCsvFormat.java @@ -14,6 +14,7 @@ import java.util.Map; import jp.naist.se.stigmata.ComparisonPair; import jp.naist.se.stigmata.ComparisonPairElement; import jp.naist.se.stigmata.ComparisonResultSet; +import jp.naist.se.stigmata.CertainPairComparisonResultSet; import jp.naist.se.stigmata.format.AbstractBirthmarkComparisonResultFormat; /** @@ -46,6 +47,25 @@ public class BirthmarkComparisonResultCsvFormat extends AbstractBirthmarkCompari @Override public void printResult(PrintWriter out, ComparisonResultSet resultset){ + if(resultset instanceof CertainPairComparisonResultSet){ + printResultImpl(out, (CertainPairComparisonResultSet)resultset); + } + else{ + printResultImpl(out, resultset); + } + } + + private void printResultImpl(PrintWriter out, CertainPairComparisonResultSet resultset){ + for(ComparisonPair pair: resultset){ + out.print(pair.getTarget1().getClassName()); + out.print(","); + out.print(pair.getTarget1().getClassName()); + out.print(","); + out.println(pair.calculateSimilarity()); + } + } + + private void printResultImpl(PrintWriter out, ComparisonResultSet resultset){ Map> map = new LinkedHashMap>(); List names = new ArrayList(); @@ -63,7 +83,7 @@ public class BirthmarkComparisonResultCsvFormat extends AbstractBirthmarkCompari for(String name: names){ out.print(","); - out.print(name); + out.print(name); } out.println(); for(String key: map.keySet()){ diff --git a/src/main/java/jp/naist/se/stigmata/spi/BirthmarkComparatorSpi.java b/src/main/java/jp/naist/se/stigmata/spi/BirthmarkComparatorSpi.java new file mode 100755 index 0000000..0269ad6 --- /dev/null +++ b/src/main/java/jp/naist/se/stigmata/spi/BirthmarkComparatorSpi.java @@ -0,0 +1,40 @@ +package jp.naist.se.stigmata.spi; + +/* + * $Id: BirthmarkSpi.java 20 2007-01-17 02:06:01Z tama3 $ + */ + +import java.util.Locale; + +import jp.naist.se.stigmata.BirthmarkComparator; + +/** + * Birthmark Service Provider Interface. + * + * @author Haruaki TAMADA + * @version $Revision: 20 $ $Date: 2007-01-17 11:06:01 +0900 (Wed, 17 Jan 2007) $ + */ +public interface BirthmarkComparatorSpi{ + /** + * returns a type of the birthmark this service provides. + */ + public String getType(); + + /** + * returns a localized description of the birthmark this service provides. + */ + public String getDescription(Locale locale); + + /** + * returns a localized description of the birthmark in default locale. + */ + public String getDescription(); + + public String getComparatorClassName(); + + /** + * returns a extractor for the birthmark of this service. + */ + public BirthmarkComparator getComparator(BirthmarkSpi service); +} + diff --git a/src/main/java/jp/naist/se/stigmata/spi/BirthmarkExtractorSpi.java b/src/main/java/jp/naist/se/stigmata/spi/BirthmarkExtractorSpi.java new file mode 100755 index 0000000..0d307d2 --- /dev/null +++ b/src/main/java/jp/naist/se/stigmata/spi/BirthmarkExtractorSpi.java @@ -0,0 +1,40 @@ +package jp.naist.se.stigmata.spi; + +/* + * $Id: BirthmarkSpi.java 20 2007-01-17 02:06:01Z tama3 $ + */ + +import java.util.Locale; + +import jp.naist.se.stigmata.BirthmarkExtractor; + +/** + * Birthmark Service Provider Interface. + * + * @author Haruaki TAMADA + * @version $Revision: 20 $ $Date: 2007-01-17 11:06:01 +0900 (Wed, 17 Jan 2007) $ + */ +public interface BirthmarkExtractorSpi{ + /** + * returns a type of the birthmark this service provides. + */ + public String getType(); + + /** + * returns a localized description of the birthmark this service provides. + */ + public String getDescription(Locale locale); + + /** + * returns a localized description of the birthmark in default locale. + */ + public String getDescription(); + + public String getExtractorClassName(); + + /** + * returns a extractor for the birthmark of this service. + */ + public BirthmarkExtractor getExtractor(BirthmarkSpi service); +} + diff --git a/src/main/java/jp/naist/se/stigmata/spi/BirthmarkSpi.java b/src/main/java/jp/naist/se/stigmata/spi/BirthmarkSpi.java index e88075d..883c09f 100755 --- a/src/main/java/jp/naist/se/stigmata/spi/BirthmarkSpi.java +++ b/src/main/java/jp/naist/se/stigmata/spi/BirthmarkSpi.java @@ -46,14 +46,22 @@ public interface BirthmarkSpi{ */ public String getDescription(); + public String getExtractorClassName(); + /** * returns a extractor for the birthmark of this service. */ public BirthmarkExtractor getExtractor(); + public String getComparatorClassName(); + /** * returns a comparator for the birthmark of this service. */ public BirthmarkComparator getComparator(); + + public boolean isExpert(); + + public boolean isUserDefined(); } diff --git a/src/main/java/jp/naist/se/stigmata/ui/swing/BirthmarkDefinitionPane.java b/src/main/java/jp/naist/se/stigmata/ui/swing/BirthmarkDefinitionPane.java new file mode 100755 index 0000000..01dbf1e --- /dev/null +++ b/src/main/java/jp/naist/se/stigmata/ui/swing/BirthmarkDefinitionPane.java @@ -0,0 +1,377 @@ +package jp.naist.se.stigmata.ui.swing; + +/* + * $Id: BirthmarkSelectionPane.java 24 2007-01-30 15:08:43Z tama3 $ + */ + +import java.awt.BorderLayout; +import java.awt.FlowLayout; +import java.awt.event.ActionEvent; +import java.awt.event.ActionListener; +import java.awt.event.ItemEvent; +import java.awt.event.ItemListener; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.Iterator; +import java.util.List; +import java.util.Map; + +import javax.imageio.spi.ServiceRegistry; +import javax.swing.Box; +import javax.swing.DefaultListModel; +import javax.swing.JButton; +import javax.swing.JCheckBox; +import javax.swing.JComboBox; +import javax.swing.JList; +import javax.swing.JPanel; +import javax.swing.JScrollPane; +import javax.swing.JTextArea; +import javax.swing.JTextField; +import javax.swing.ListModel; +import javax.swing.border.TitledBorder; +import javax.swing.event.DocumentEvent; +import javax.swing.event.DocumentListener; +import javax.swing.event.ListSelectionEvent; +import javax.swing.event.ListSelectionListener; + +import jp.naist.se.stigmata.BirthmarkContext; +import jp.naist.se.stigmata.birthmarks.BirthmarkService; +import jp.naist.se.stigmata.spi.BirthmarkComparatorSpi; +import jp.naist.se.stigmata.spi.BirthmarkExtractorSpi; +import jp.naist.se.stigmata.spi.BirthmarkSpi; + +/** + * + * @author Haruaki TAMADA + * @version $Revision: 24 $ $Date: 2007-01-31 00:08:43 +0900 (Wed, 31 Jan 2007) $ + */ +public class BirthmarkDefinitionPane extends JPanel{ + private static final long serialVersionUID = 3932637653297802978L; + + private StigmataFrame stigmata; + private JList serviceList; + private DefaultListModel model; + private InformationPane information; + private JButton newService; + private JButton removeService; + private Map services = new HashMap(); + private List addedService = new ArrayList(); + + public BirthmarkDefinitionPane(StigmataFrame stigmata){ + this.stigmata = stigmata; + + initLayouts(); + initData(); + + updateView(); + } + + public void reset(){ + BirthmarkContext context = stigmata.getContext(); + for(BirthmarkSpi service: addedService){ + context.removeService(service.getType()); + model.removeElement(service.getDisplayType()); + } + } + + private void initData(){ + information.initData(); + model.addElement(Messages.getString("newservice.definition.label")); + + for(BirthmarkSpi service: stigmata.getContext().findServices()){ + model.addElement(service.getDisplayType()); + services.put(service.getDisplayType(), service); + } + } + + private void initLayouts(){ + JPanel panel = new JPanel(new BorderLayout()); + serviceList = new JList(model = new DefaultListModel()); + JScrollPane scroll = new JScrollPane(serviceList); + + scroll.setBorder(new TitledBorder(Messages.getString("servicelist.border"))); + serviceList.setToolTipText(Messages.getString("servicelist.tooltip")); + + panel.add(information = new InformationPane(stigmata, this), BorderLayout.CENTER); + panel.add(scroll, BorderLayout.WEST); + + JPanel buttonPanel = new JPanel(new FlowLayout(FlowLayout.CENTER)); + newService = Utility.createButton("newservice"); + removeService = Utility.createButton("removeservice"); + buttonPanel.add(newService); + buttonPanel.add(removeService); + + setLayout(new BorderLayout()); + add(panel, BorderLayout.CENTER); + add(buttonPanel, BorderLayout.SOUTH); + + removeService.setEnabled(false); + + serviceList.addListSelectionListener(new ListSelectionListener(){ + public void valueChanged(ListSelectionEvent e){ + listValueChanged(e); + } + }); + + newService.addActionListener(new ActionListener(){ + public void actionPerformed(ActionEvent e){ + addNewService(); + } + }); + + removeService.addActionListener(new ActionListener(){ + public void actionPerformed(ActionEvent e){ + removeService(); + } + }); + } + + private BirthmarkSpi getService(String displayType){ + return services.get(displayType); + } + + private void removeService(){ + int index = serviceList.getSelectedIndex(); + if(index > 0){ + String label = (String)model.getElementAt(index); + BirthmarkSpi service = services.get(label); + if(service != null && service.isUserDefined()){ + stigmata.getContext().removeService(service.getType()); + model.remove(index); + } + } + stigmata.updateService(); + updateView(); + } + + private void addNewService(){ + BirthmarkService service = information.createService(); + stigmata.getContext().addService(service); + services.put(service.getDisplayType(), service); + model.addElement(service.getDisplayType()); + addedService.add(service); + + stigmata.updateService(); + updateView(); + } + + private void listValueChanged(ListSelectionEvent e){ + int index = serviceList.getSelectedIndex(); + if(index > 0){ + String label = (String)model.getElementAt(index); + if(label != null){ + information.setService(services.get(label)); + } + } + else if(index == 0){ + information.clear(); + } + updateView(); + } + + private void updateView(){ + int index = serviceList.getSelectedIndex(); + ListModel model = serviceList.getModel(); + BirthmarkSpi service = null; + if(index > 0){ + service = services.get(model.getElementAt(index)); + } + newService.setEnabled( + (index <= 0 || service.isUserDefined()) && + information.isAvailableService() + ); + removeService.setEnabled(index > 0 && service.isUserDefined()); + information.setEnabled(index <= 0 || service.isUserDefined()); + } + + private static class InformationPane extends JPanel{ + private static final long serialVersionUID = 37906542932362L; + + private StigmataFrame stigmata; + private BirthmarkDefinitionPane thisPane; + private JTextField type; + private JTextField displayType; + private JTextArea description; + private JComboBox extractor; + private JComboBox comparator; + private JCheckBox expert; + private JCheckBox userDefined; + + public InformationPane(StigmataFrame stigmata, BirthmarkDefinitionPane thisPane){ + this.stigmata = stigmata; + this.thisPane = thisPane; + initLayouts(); + } + + public void setEnabled(boolean flag){ + super.setEnabled(flag); + + type.setEnabled(flag); + displayType.setEnabled(flag); + description.setEnabled(flag); + extractor.setEnabled(flag); + comparator.setEnabled(flag); + } + + public BirthmarkService createService(){ + BirthmarkService service = new BirthmarkService(stigmata.getContext()); + service.setType(type.getText()); + service.setDisplayType(displayType.getText()); + service.setDescription(description.getText()); + service.setExtractorClassName(extractor.getSelectedItem().toString()); + service.setComparatorClassName(comparator.getSelectedItem().toString()); + service.setUserDefined(true); + + return service; + } + + public void clear(){ + type.setText(""); + displayType.setText(""); + description.setText(""); + extractor.getModel().setSelectedItem(null); + comparator.getModel().setSelectedItem(null); + userDefined.setSelected(true); + expert.setSelected(true); + } + + public boolean isAvailableService(){ + String newType = type.getText(); + Object selectedExtractor = extractor.getSelectedItem(); + String extractorClass = "";; + if(selectedExtractor != null){ + extractorClass = selectedExtractor.toString(); + } + Object selectedComparator = comparator.getSelectedItem(); + String comparatorClass = ""; + if(selectedComparator != null){ + comparatorClass = selectedComparator.toString(); + } + BirthmarkContext context = stigmata.getContext(); + + boolean flag = newType.length() > 0 + && displayType.getText().length() > 0 + && extractorClass.length() > 0 + && comparatorClass.length() > 0; + + // check inputed type is free + flag = flag && context.getService(newType) == null; + // check display type is free + flag = flag && thisPane.getService(displayType.getText()) == null; + + // check extractor/comparator classes are available + try{ + flag = flag + && context.getBytecodeContext().find(extractorClass) != null + && context.getBytecodeContext().find(comparatorClass) != null; + } catch(ClassNotFoundException e){ + flag = false; + } + + return flag; + } + + public void setService(BirthmarkSpi service){ + type.setText(service.getType()); + displayType.setText(service.getDisplayType()); + description.setText(service.getDefaultDescription()); + selectComboBoxItem(extractor, service.getExtractorClassName()); + selectComboBoxItem(comparator, service.getComparatorClassName()); + userDefined.setSelected(service.isUserDefined()); + expert.setSelected(service.isExpert()); + + setEnabled(service.isUserDefined()); + } + + public void initData(){ + comparator.addItem(""); + for(Iterator i = ServiceRegistry.lookupProviders(BirthmarkComparatorSpi.class); i.hasNext();){ + BirthmarkComparatorSpi service = i.next(); + comparator.addItem(service.getComparatorClassName()); + } + extractor.addItem(""); + for(Iterator i = ServiceRegistry.lookupProviders(BirthmarkExtractorSpi.class); i.hasNext();){ + BirthmarkExtractorSpi service = i.next(); + extractor.addItem(service.getExtractorClassName()); + } + } + + private void selectComboBoxItem(JComboBox box, String item){ + box.getModel().setSelectedItem(item); + } + + private void initLayouts(){ + setLayout(new BorderLayout()); + Box box = Box.createVerticalBox(); + Box box1 = Box.createHorizontalBox(); + box1.add(type = new JTextField()); + box1.add(displayType = new JTextField()); + + Box box2 = Box.createHorizontalBox(); + box2.add(extractor = new JComboBox()); + + Box box3 = Box.createHorizontalBox(); + box3.add(comparator = new JComboBox()); + + Box box4 = Box.createHorizontalBox(); + box4.add(description = new JTextArea()); + + Box box5 = Box.createHorizontalBox(); + box5.add(Box.createHorizontalGlue()); + box5.add(expert = new JCheckBox(Messages + .getString("define.expert.label"))); + box5.add(Box.createHorizontalGlue()); + box5.add(userDefined = new JCheckBox(Messages + .getString("define.userdef.label"))); + box5.add(Box.createHorizontalGlue()); + + box.add(box1); + box.add(box2); + box.add(box3); + box.add(box5); + add(box, BorderLayout.NORTH); + add(box4, BorderLayout.CENTER); + + Utility.decorateJComponent(type, "define.type"); + Utility.decorateJComponent(displayType, "define.displaytype"); + Utility.decorateJComponent(description, "define.description"); + Utility.decorateJComponent(extractor, "define.extractor"); + Utility.decorateJComponent(comparator, "define.comparator"); + Utility.decorateJComponent(expert, "define.expert"); + Utility.decorateJComponent(userDefined, "define.userdef"); + + userDefined.setEnabled(false); + expert.setEnabled(false); + userDefined.setSelected(true); + expert.setSelected(true); + + extractor.setEditable(true); + comparator.setEditable(true); + + DocumentListener listener = new DocumentListener(){ + public void insertUpdate(DocumentEvent e){ + thisPane.updateView(); + } + + public void removeUpdate(DocumentEvent e){ + thisPane.updateView(); + } + + public void changedUpdate(DocumentEvent e){ + thisPane.updateView(); + } + }; + + type.getDocument().addDocumentListener(listener); + displayType.getDocument().addDocumentListener(listener); + description.getDocument().addDocumentListener(listener); + ItemListener itemListener = new ItemListener(){ + public void itemStateChanged(ItemEvent e){ + thisPane.updateView(); + } + }; + comparator.addItemListener(itemListener); + extractor.addItemListener(itemListener); + } + } +} diff --git a/src/main/java/jp/naist/se/stigmata/ui/swing/BirthmarkSelectionPane.java b/src/main/java/jp/naist/se/stigmata/ui/swing/BirthmarkSelectionPane.java index 89f236e..d09b4d3 100755 --- a/src/main/java/jp/naist/se/stigmata/ui/swing/BirthmarkSelectionPane.java +++ b/src/main/java/jp/naist/se/stigmata/ui/swing/BirthmarkSelectionPane.java @@ -4,36 +4,40 @@ package jp.naist.se.stigmata.ui.swing; * $Id$ */ -import java.awt.BorderLayout; +import java.awt.Dimension; import java.awt.GridLayout; import java.awt.event.ActionEvent; import java.util.ArrayList; +import java.util.HashMap; +import java.util.HashSet; import java.util.List; +import java.util.Map; +import java.util.Set; import javax.swing.AbstractAction; import javax.swing.JCheckBox; +import javax.swing.JPanel; import jp.naist.se.stigmata.spi.BirthmarkSpi; /** - * - * * * @author Haruaki TAMADA * @version $Revision$ $Date$ */ -public class BirthmarkSelectionPane extends javax.swing.JPanel { +public class BirthmarkSelectionPane extends JPanel{ private static final long serialVersionUID = 3209854654743223453L; private StigmataFrame stigmata; - private List selectedServices = new ArrayList(); - private List serviceList = new ArrayList(); - private List checks = new ArrayList(); + private Set selectedServices = new HashSet(); + private List serviceList; + private Map checks; private List listeners = new ArrayList(); + private boolean geekmode = false; public BirthmarkSelectionPane(StigmataFrame stigmata) { this.stigmata = stigmata; - initComponents(); + initServices(); } public void select(BirthmarkSpi service, boolean flag){ @@ -46,15 +50,25 @@ public class BirthmarkSelectionPane extends javax.swing.JPanel { fireEvent(); } - public void reset(){ - selectedServices = new ArrayList(); - for(JCheckBox check: checks){ - check.setSelected(true); - } + public void refresh(){ + initServices(); + updateLayouts(); + } - for(BirthmarkSpi service: serviceList){ - selectedServices.add(service.getType()); - } + public void setGeekMode(boolean geekmode){ + this.geekmode = geekmode; + updateLayouts(); + } + + public boolean isGeekMode(){ + return geekmode; + } + + public void reset(){ + selectedServices.clear(); + initServices(); + geekmode = false; + updateLayouts(); fireEvent(); } @@ -74,7 +88,33 @@ public class BirthmarkSelectionPane extends javax.swing.JPanel { public String[] getSelectedServices(){ String[] services = selectedServices.toArray(new String[selectedServices.size()]); return services; + } + public void updateService(){ + Map newChecks = new HashMap(); + BirthmarkSpi[] services = stigmata.getContext().getServices(); + for(BirthmarkSpi service: services){ + if(checks.get(service) == null){ // added service is found + JCheckBox check = new JCheckBox(new BirthmarkSelectAction(service, this)); + check.setToolTipText(service.getDescription()); + check.setSelected(true); + newChecks.put(service, check); + selectedServices.add(service.getType()); + serviceList.add(service); + } + else{ // unchanged services + newChecks.put(service, checks.get(service)); + checks.remove(service); + } + } + for(BirthmarkSpi remainService: checks.keySet()){ + JCheckBox check = checks.get(remainService); + selectedServices.remove(remainService.getType()); + serviceList.remove(remainService); + remove(check); + } + this.checks = newChecks; + updateLayouts(); } private void fireEvent(){ @@ -83,19 +123,69 @@ public class BirthmarkSelectionPane extends javax.swing.JPanel { } } - private void initComponents() { - BirthmarkSpi[] services = stigmata.getContext().getServices(); + private Dimension calculateDimension(){ + int rows = 1; + int cols = 0; + if(!isGeekMode()){ + for(BirthmarkSpi service: serviceList){ + if(!service.isExpert()){ + cols++; + } + } + } + else{ + cols = serviceList.size(); + } - setLayout(new GridLayout(1, services.length)); + if(cols > 4){ + rows = (cols / 3); + cols = 3; + if((cols % 3) != 0) rows++; + } + return new Dimension(cols, rows); + } + + /** + * update layouts and update selected birthmarks list. + */ + private void updateLayouts(){ + removeAll(); + Dimension d = calculateDimension(); + setLayout(new GridLayout(d.height, d.width)); + + for(BirthmarkSpi service: serviceList){ + JCheckBox check = checks.get(service); + check.setVisible(true); + if(!service.isExpert() || (isGeekMode() && service.isExpert())){ + add(check); + } + else{ + check.setVisible(false); + } + + if(check.isSelected() && check.isVisible()){ + selectedServices.add(service.getType()); + } + else{ + selectedServices.remove(service.getType()); + } + } + updateUI(); + } + + private void initServices(){ + BirthmarkSpi[] services = stigmata.getContext().getServices(); + + serviceList = new ArrayList(); + checks = new HashMap(); for(BirthmarkSpi service: services){ - serviceList.add(service); JCheckBox check = new JCheckBox(new BirthmarkSelectAction(service, this)); check.setToolTipText(service.getDescription()); - add(check, BorderLayout.CENTER); - checks.add(check); + check.setSelected(true); + checks.put(service, check); + serviceList.add(service); } - reset(); } private static class BirthmarkSelectAction extends AbstractAction{ @@ -119,4 +209,3 @@ public class BirthmarkSelectionPane extends javax.swing.JPanel { } } } - diff --git a/src/main/java/jp/naist/se/stigmata/ui/swing/ControlPane.java b/src/main/java/jp/naist/se/stigmata/ui/swing/ControlPane.java index 1b9f9a4..e060bf7 100755 --- a/src/main/java/jp/naist/se/stigmata/ui/swing/ControlPane.java +++ b/src/main/java/jp/naist/se/stigmata/ui/swing/ControlPane.java @@ -20,7 +20,6 @@ import javax.swing.JTabbedPane; import javax.swing.border.TitledBorder; import jp.naist.se.stigmata.BirthmarkContext; -import jp.naist.se.stigmata.Stigmata; import jp.naist.se.stigmata.reader.ClasspathContext; import jp.naist.se.stigmata.utils.WellknownClassManager; @@ -38,11 +37,13 @@ public class ControlPane extends JPanel{ private TargetSelectionPane targetY; private ClasspathSettingsPane classpath; private WellknownClassesSettingsPane wellknownClassses; + private BirthmarkDefinitionPane definition; private JTabbedPane controlTab; private JButton compareButton; private JButton extractButton; private JButton resetButton; private JComboBox comparisonMethods; + private boolean geekmode = false; public ControlPane(StigmataFrame stigmata){ this.stigmata = stigmata; @@ -51,17 +52,53 @@ public class ControlPane extends JPanel{ Utility.addNewTab("targets", controlTab, createControlPane()); Utility.addNewTab("wellknown", controlTab, createWellknownClassPane()); Utility.addNewTab("classpath", controlTab, classpath = new ClasspathSettingsPane(stigmata)); + definition = new BirthmarkDefinitionPane(stigmata); reset(); } + public void updateService(){ + birthmarks.updateService(); + updateEnable(); + } + public void reset(){ + this.geekmode = false; + definition.reset(); birthmarks.reset(); + stigmata.setGeekMode(false); targetX.removeAllElements(); targetY.removeAllElements(); classpath.reset(); wellknownClassses.reset(); + updateEnable(); + + int index = controlTab.indexOfTab(Messages.getString("definition.tab.label")); + if(index >= 0){ + controlTab.removeTabAt(index); + } + } + + public void setGeekMode(boolean geekmode){ + this.geekmode = geekmode; + birthmarks.setGeekMode(geekmode); + stigmata.setGeekMode(geekmode); + + if(geekmode){ + Utility.addNewTab("definition", controlTab, definition); + } + else{ + int index = controlTab.indexOfTab(Messages.getString("definition.tab.label")); + if(index >= 0){ + controlTab.removeTabAt(index); + } + } + updateEnable(); + } + + public boolean isGeekMode(){ + return geekmode; } private JComponent createWellknownClassPane(){ @@ -99,7 +136,7 @@ public class ControlPane extends JPanel{ DataChangeListener dcl = new DataChangeListener(){ public void valueChanged(Object source){ - checkButtonEnabled(); + updateEnable(); } }; targetX.addDataChangeListener(dcl); @@ -109,7 +146,7 @@ public class ControlPane extends JPanel{ return center; } - private void checkButtonEnabled(){ + private void updateEnable(){ String[] valueX = targetX.getValues(); String[] valueY = targetY.getValues(); String[] targets = birthmarks.getSelectedServices(); @@ -166,8 +203,7 @@ public class ControlPane extends JPanel{ } private BirthmarkContext initAction(){ - Stigmata s = stigmata.getStigmata(); - BirthmarkContext context = s.createContext(); + BirthmarkContext context = stigmata.getContext(); ClasspathContext bytecode = context.getBytecodeContext(); WellknownClassManager manager = context.getWellknownClassManager(); @@ -226,6 +262,9 @@ public class ControlPane extends JPanel{ else if(item.equals(Messages.getString("specifiedpair.label"))){ compareSpecifiedPair(); } + else if(item.equals(Messages.getString("roundrobin.filtering.label"))){ + // compareRoundRobinWithFiltering(); + } } }); } diff --git a/src/main/java/jp/naist/se/stigmata/ui/swing/PairComparisonResultSetPane.java b/src/main/java/jp/naist/se/stigmata/ui/swing/PairComparisonResultSetPane.java index 5aa39d7..67d70db 100755 --- a/src/main/java/jp/naist/se/stigmata/ui/swing/PairComparisonResultSetPane.java +++ b/src/main/java/jp/naist/se/stigmata/ui/swing/PairComparisonResultSetPane.java @@ -32,6 +32,7 @@ import jp.naist.se.stigmata.BirthmarkSet; import jp.naist.se.stigmata.CertainPairComparisonResultSet; import jp.naist.se.stigmata.ComparisonPair; import jp.naist.se.stigmata.ComparisonResultSet; +import jp.naist.se.stigmata.format.BirthmarkComparisonResultFormat; import jp.naist.se.stigmata.spi.ResultFormatSpi; /** @@ -70,10 +71,10 @@ public class PairComparisonResultSetPane extends JPanel implements BirthmarkData } public void writeData(PrintWriter out, ResultFormatSpi service) throws IOException{ - service.getComparisonResultFormat().printResult( - out, - new CertainPairComparisonResultSet(list.toArray(new ComparisonPair[list.size()]), - context)); + BirthmarkComparisonResultFormat format = service.getComparisonResultFormat(); + format.printResult(out, new CertainPairComparisonResultSet( + list.toArray(new ComparisonPair[list.size()]), context + )); } private void obfuscateClassNames(){ diff --git a/src/main/java/jp/naist/se/stigmata/ui/swing/StigmataFrame.java b/src/main/java/jp/naist/se/stigmata/ui/swing/StigmataFrame.java index 19ad965..0d8ba7d 100755 --- a/src/main/java/jp/naist/se/stigmata/ui/swing/StigmataFrame.java +++ b/src/main/java/jp/naist/se/stigmata/ui/swing/StigmataFrame.java @@ -27,6 +27,7 @@ import java.util.HashMap; import java.util.List; import java.util.Map; +import javax.swing.JCheckBoxMenuItem; import javax.swing.JFileChooser; import javax.swing.JFrame; import javax.swing.JLabel; @@ -63,25 +64,17 @@ public class StigmataFrame extends JFrame implements CurrentDirectoryHolder{ private static final long serialVersionUID = 92345543665342134L; private static List frameList = new ArrayList(); - private JTabbedPane tabPane; - private JMenuItem closeTabMenu; - + private JCheckBoxMenuItem geekmodeMenu; private Stigmata stigmata; - private BirthmarkContext context; - + private ControlPane control; private File currentDirectory; - private int extractCount = 0; - private int compareCount = 0; - private int compareDetail = 0; - private int graphCount = 0; - private int comparePair = 0; public StigmataFrame(){ @@ -325,6 +318,10 @@ public class StigmataFrame extends JFrame implements CurrentDirectoryHolder{ return mapping; } + public void updateService(){ + control.updateService(); + } + private File findFile(boolean open, String[] exts, String desc){ JFileChooser chooser = new JFileChooser(getCurrentDirectory()); chooser.setFileFilter(new ExtensionFilter(exts, desc)); @@ -346,7 +343,7 @@ public class StigmataFrame extends JFrame implements CurrentDirectoryHolder{ setTitle(Messages.getString("stigmata.frame.title")); initComponents(); - Utility.addNewTab("control", tabPane, new ControlPane(this), null, null); + Utility.addNewTab("control", tabPane, control = new ControlPane(this), null, null); tabPane.setSelectedIndex(tabPane.getTabCount() - 1); currentDirectory = new File("."); @@ -428,13 +425,15 @@ public class StigmataFrame extends JFrame implements CurrentDirectoryHolder{ JMenuItem license = Utility.createJMenuItem("license"); JMenuItem help = Utility.createJMenuItem("helpmenu"); JMenu laf = Utility.createJMenu("lookandfeel"); + geekmodeMenu = Utility.createJCheckBoxMenuItem("geekmenu"); menu.add(about); menu.add(license); + menu.add(help); menu.add(new JSeparator()); menu.add(laf); menu.add(new JSeparator()); - menu.add(help); + menu.add(geekmodeMenu); about.addActionListener(new ActionListener(){ public void actionPerformed(ActionEvent e){ @@ -447,6 +446,11 @@ public class StigmataFrame extends JFrame implements CurrentDirectoryHolder{ licenseMenuActionPerformed(); } }); + geekmodeMenu.addActionListener(new ActionListener(){ + public void actionPerformed(ActionEvent e){ + geekMenuActionPerformed(((JCheckBoxMenuItem)e.getSource()).getState()); + } + }); final UIManager.LookAndFeelInfo[] info = UIManager.getInstalledLookAndFeels(); for(int i = 0; i < info.length; i++){ @@ -468,6 +472,14 @@ public class StigmataFrame extends JFrame implements CurrentDirectoryHolder{ return menu; } + public void setGeekMode(boolean geekmode){ + geekmodeMenu.setState(geekmode); + } + + private void geekMenuActionPerformed(boolean status){ + control.setGeekMode(status); + } + private void aboutMenuActionPerformed(){ Package p = getClass().getPackage(); JPanel panel = new JPanel(new BorderLayout()); @@ -489,7 +501,7 @@ public class StigmataFrame extends JFrame implements CurrentDirectoryHolder{ panel.add(scroll, BorderLayout.CENTER); JOptionPane.showMessageDialog(this, panel, Messages.getString("about.dialog.title"), - JOptionPane.INFORMATION_MESSAGE); + JOptionPane.INFORMATION_MESSAGE); } private void licenseMenuActionPerformed(){ @@ -538,9 +550,11 @@ public class StigmataFrame extends JFrame implements CurrentDirectoryHolder{ private void closeTabMenuActionPerformed(){ int index = tabPane.getSelectedIndex(); if(index == 0){ - JOptionPane.showMessageDialog(this, Messages - .getString("cannotclosecontroltab.dialog.message"), Messages - .getString("cannotclosecontroltab.dialog.title"), JOptionPane.ERROR_MESSAGE); + JOptionPane.showMessageDialog( + this, Messages.getString("cannotclosecontroltab.dialog.message"), + Messages.getString("cannotclosecontroltab.dialog.title"), + JOptionPane.ERROR_MESSAGE + ); } else{ tabPane.removeTabAt(index); diff --git a/src/main/java/jp/naist/se/stigmata/ui/swing/Utility.java b/src/main/java/jp/naist/se/stigmata/ui/swing/Utility.java index 960c48c..09271bf 100755 --- a/src/main/java/jp/naist/se/stigmata/ui/swing/Utility.java +++ b/src/main/java/jp/naist/se/stigmata/ui/swing/Utility.java @@ -10,10 +10,12 @@ import java.text.MessageFormat; import javax.swing.Icon; import javax.swing.ImageIcon; import javax.swing.JButton; +import javax.swing.JCheckBoxMenuItem; +import javax.swing.JComponent; import javax.swing.JMenu; import javax.swing.JMenuItem; import javax.swing.JTabbedPane; - +import javax.swing.border.TitledBorder; /** * @@ -28,6 +30,24 @@ class Utility{ private Utility(){ } + public static void decorateJComponent(JComponent component, String label){ + if(Messages.hasString(label + ".tooltip")){ + component.setToolTipText(Messages.getString(label + ".tooltip")); + } + if(Messages.hasString(label + ".border")){ + component.setBorder(new TitledBorder(Messages.getString(label + ".border"))); + } + try{ + if(component.getClass().getMethod("setIcon") != null){ + Icon icon = getIcon(label + ".icon"); + if(icon != null){ + component.getClass().getMethod("setIcon").invoke(component, icon); + } + } + } catch(Exception e){ + } + } + public static JButton createButton(String label){ JButton button = new JButton(Messages.getString(label + ".button.label")); button.setActionCommand(label); @@ -35,18 +55,40 @@ class Utility{ button.setToolTipText(Messages.getString(label + ".button.tooltip")); } Icon icon = getIcon(label + ".button.icon"); - button.setIcon(icon); + if(icon != null){ + button.setIcon(icon); + } return button; } + public static JCheckBoxMenuItem createJCheckBoxMenuItem(String label){ + return createJCheckBoxMenuItem(label, false); + } + + public static JCheckBoxMenuItem createJCheckBoxMenuItem(String label, boolean status){ + JCheckBoxMenuItem item = new JCheckBoxMenuItem(Messages.getString(label + ".menuitem.label"), status); + item.setActionCommand(label); + if(Messages.hasString(label + ".menuitem.tooltip")){ + item.setToolTipText(Messages.getString(label + ".menuitem.tooltip")); + } + Icon icon = getIcon(label + ".menuitem.icon"); + if(icon != null){ + item.setIcon(icon); + } + return item; + } + public static JMenuItem createJMenuItem(String label){ JMenuItem item = new JMenuItem(Messages.getString(label + ".menuitem.label")); item.setActionCommand(label); if(Messages.hasString(label + ".menuitem.tooltip")){ item.setToolTipText(Messages.getString(label + ".menuitem.tooltip")); } - item.setIcon(getIcon(label + ".menuitem.icon")); + Icon icon = getIcon(label + ".menuitem.icon"); + if(icon != null){ + item.setIcon(icon); + } return item; } @@ -56,7 +98,10 @@ class Utility{ if(Messages.hasString(label + ".menu.tooltip")){ menu.setToolTipText(Messages.getString(label + ".menu.tooltip")); } - menu.setIcon(getIcon(label + ".menu.icon")); + Icon icon = getIcon(label + ".menu.icon"); + if(icon != null){ + menu.setIcon(icon); + } return menu; } diff --git a/src/main/resources/META-INF/birthmark-3.0.dtd b/src/main/resources/META-INF/birthmark-3.0.dtd index 62d557f..47e10bd 100755 --- a/src/main/resources/META-INF/birthmark-3.0.dtd +++ b/src/main/resources/META-INF/birthmark-3.0.dtd @@ -4,6 +4,14 @@ $Id$ --> + + + + + + + + @@ -25,5 +33,11 @@ - + + + + + + + diff --git a/src/main/resources/META-INF/services/jp.naist.se.stigmata.spi.BirthmarkComparatorSpi b/src/main/resources/META-INF/services/jp.naist.se.stigmata.spi.BirthmarkComparatorSpi new file mode 100755 index 0000000..8b4ca13 --- /dev/null +++ b/src/main/resources/META-INF/services/jp.naist.se.stigmata.spi.BirthmarkComparatorSpi @@ -0,0 +1,5 @@ +jp.naist.se.stigmata.birthmarks.comparators.PlainBirthmarkComparatorService +jp.naist.se.stigmata.birthmarks.comparators.LogicalAndBirthmarkComparatorService +jp.naist.se.stigmata.birthmarks.comparators.DPMatchingBirthmarkComparatorService +jp.naist.se.stigmata.birthmarks.comparators.EditDistanceBirthmarkComparatorService +jp.naist.se.stigmata.birthmarks.comparators.ExtendedEditDistanceBirthmarkComparatorService diff --git a/src/main/resources/META-INF/services/jp.naist.se.stigmata.spi.BirthmarkExtractorSpi b/src/main/resources/META-INF/services/jp.naist.se.stigmata.spi.BirthmarkExtractorSpi new file mode 100755 index 0000000..1188a21 --- /dev/null +++ b/src/main/resources/META-INF/services/jp.naist.se.stigmata.spi.BirthmarkExtractorSpi @@ -0,0 +1,5 @@ +jp.naist.se.stigmata.birthmarks.extractors.ConstantValueOfFieldVariableBirthmarkExtractorService +jp.naist.se.stigmata.birthmarks.extractors.InheritanceStructureBirthmarkExtractorService +jp.naist.se.stigmata.birthmarks.extractors.SequentialMethodCallBirthmarkExtractorService +jp.naist.se.stigmata.birthmarks.extractors.UsedClassesBirthmarkExtractorService + diff --git a/src/main/resources/resources/birthmark.xml b/src/main/resources/resources/birthmark.xml index c89168a..4b22307 100755 --- a/src/main/resources/resources/birthmark.xml +++ b/src/main/resources/resources/birthmark.xml @@ -5,6 +5,72 @@ $Id$ --> + + + uc_seq + Used Classes (compare as sequence) + + jp.naist.se.stigmata.birthmarks.uc.UsedClassesBirthmarkExtractor + jp.naist.se.stigmata.birthmarks.comparators.PlainBirthmarkComparator + + + uc_dp + Used Classes (DP matching) + + jp.naist.se.stigmata.birthmarks.uc.UsedClassesBirthmarkExtractor + jp.naist.se.stigmata.birthmarks.comparators.DPMatchingBirthmarkComparator + + + uc_ed + Used Classes (Edit distance) + + jp.naist.se.stigmata.birthmarks.uc.UsedClassesBirthmarkExtractor + jp.naist.se.stigmata.birthmarks.comparators.EditDistanceBirthmarkComparator + + + is_ed + Inheritance Structure (Edit distance) + + jp.naist.se.stigmata.birthmarks.is.InheritanceStructureBirthmarkExtractor + jp.naist.se.stigmata.birthmarks.comparators.EditDistanceBirthmarkComparator + + + is_dp + Inheritance Structure (DP matching) + + jp.naist.se.stigmata.birthmarks.is.InheritanceStructureBirthmarkExtractor + jp.naist.se.stigmata.birthmarks.comparators.DPMatchingBirthmarkComparator + + + smc_ed + Sequence of Method Calls (Edit distance) + + jp.naist.se.stigmata.birthmarks.smc.SequentialMethodCallBirthmarkExtractor + jp.naist.se.stigmata.birthmarks.comparators.EditDistanceBirthmarkComparator + + + smc_dp + Sequence of Method Calls (DP matching) + + jp.naist.se.stigmata.birthmarks.smc.SequentialMethodCallBirthmarkExtractor + jp.naist.se.stigmata.birthmarks.comparators.DPMatchingBirthmarkComparator + + + cvfv_ed + Constant Value of Field Variable (Edit distance) + + jp.naist.se.stigmata.birthmarks.cvfv.ConstantValueOfFieldVariableBirthmarkExtractor + jp.naist.se.stigmata.birthmarks.comparators.EditDistanceBirthmarkComparator + + + cvfv_dp + Constant Value of Field Variable (DP matching) + + jp.naist.se.stigmata.birthmarks.cvfv.ConstantValueOfFieldVariableBirthmarkExtractor + jp.naist.se.stigmata.birthmarks.comparators.DPMatchingBirthmarkComparator + + + Exception Error - diff --git a/src/main/resources/resources/description.properties b/src/main/resources/resources/description.properties index 1cd2add..0ed3e3c 100644 --- a/src/main/resources/resources/description.properties +++ b/src/main/resources/resources/description.properties @@ -1,8 +1,8 @@ -birthmark.cvfv.display.type=CVFV +birthmark.cvfv.display.type=Constant Value of Field Variable birthmark.cvfv.description=Field type and its initial value. -birthmark.smc.display.type=SMC +birthmark.smc.display.type=Sequence of Method Call birthmark.smc.description=Sequence of method call which order is appeared in method definition. -birthmark.uc.display.type=UC +birthmark.uc.display.type=Used Classes birthmark.uc.description=Set of used classes in target class. -birthmark.is.display.type=IS +birthmark.is.display.type=Inheritance Structure birthmark.is.description=Inheritance sequence to root class and user classes is replaced to . diff --git a/src/main/resources/resources/images/script_add.png b/src/main/resources/resources/images/script_add.png new file mode 100755 index 0000000000000000000000000000000000000000..d650552d967042327d9b2b49577582cc95253613 GIT binary patch literal 811 zcmV+`1JwM9P)9Gp0rM-&EhljN^i}(|Pq=@5XF~~)>U!;+BT;WiZ;-?olqd>fK_MstEkar}b9uop zSG%(%K&q)D8CgaWKtPPtDOv9I8!SQz&9K@qF)=0vTF8Vz6y!_@T)cF~Uzb0()L$?a z`$c#8#_Jq>ql8oq?5#4M^3MAs_Mj^9a~&q%&y!>ZY?Ffij=buvY#%T_TY|PQcQN;bwCQWy*nR;m&;UD z`|<407yq%aQd%Bnb;^cyP&KV4wU)a7>4a6Dx$h-#bpLzK{Pr$B8!J;?KlH*=4~)Nd zXfFUrnL1@v!}G_xF3kSm{Oos*9r(bTXJ0f{jKZMUxbxsWQRhe^WR#$JvyI#9! z6)lXSPy)q8C1lZ}g3^41=HNKqnYs7QJ?H%A@B2c|8SMY^(nC0W>$>q>gSs`STXowS zHf;~fxQ2v9EZ{R7D*@W3dHBBBHM?GWY!d+JSMBtmYNr=h)3&N+d6b;Lw&L5f{XIBX z0<=xDd8!-0r5i~n1ZAKo8S6whk3~g{It4qoP1rg;x#5%3mk&jNRM%6JB~8n674&Lu zjOeY>TV-L${7M3Ee16fcxk-1=bT*X$sjfGy?MD3({naGKphQs+3kpFIXc5wqAI~j1 zbFp{11V~l2d3vJI8#V@`EXJ&e#1s^fLRJ*Wg{w;=M~?r!g#9HzQ&rnHPj&QGvj#Fn z3Svg0kd--VGpUm_RWo<=l}E2ffK-jP&rXl&S6PS@A&7_wfRM?VW;BwjQGycozWv=q zS;X#GC#q5sWn>vi00A*lr(~r+Xs`q&G^1+MA;g07I7@NDx@V8^d@28HxbNq=; zzxe*f?K5pkhju@>PI%T6esG3%jS_iIPFg`oSQ?CLj-`b*R!!2d1>j$2D{N9N- z_dNmtQl?H>)o|vgtp>k-WAdw)jfVdjV0o#K3YUx7d-mS8etPnmh2`4C`M&w3RZD|f z-DE|Kx}BgKTK}9nDt3ap=<6+H=dQ$*8t;dl`wq|GAhu&8Hex;2V|u*X>5Pwe>`ABX pxbn5N{RLGS=ZoANdGc8E?*HisN=owtMsNTC002ovPDHLkV1hpQeRTi; literal 0 HcmV?d00001 diff --git a/src/main/resources/resources/images/star.png b/src/main/resources/resources/images/star.png new file mode 100755 index 0000000000000000000000000000000000000000..b88c8578956ceec4ff17f81995b8652f6aa2b58d GIT binary patch literal 670 zcmV;P0%84$P)rx?szq&Dw38OK zY!^{rCAFy_2z8TV&4=Ube7+y|oYO*02OOyb5BD7I^ZdAQt`ZS+tMaFrb6^=AxbXHx zH;=|4CCm%L{PZwSS3v3G^sH+#W3JcR_xs(&`Tqt8^J9}d0vU#im5^f#04JL4qMaI^seoYDXwB>7;oyw=|M z1!ayym?6XvqV3ae_f95{py8ukt2TxB^!VIzRRh4#rNu~y^X+P>L{SXo3_|Qqm>9wY zz(9!5s#OBElpmj4DRyjO`0`RiEIkUg%7D)8y}}Ye3}prow;JG>UQOIs{kfZSJ9bYz zskMPbH9)1H6FDf)1=ZKVfe+;jf`a(O{!9meiN~~d0iA$0qX=t0D6Ydx4#RO76h@#R z9_k7Z;$fv6G>QeZ{Yu0n&xL4%!?l}UPj4!j&Vs@?dl=y8#_IQ`5I-5a_T$dJtJ_~5 z4&186>klZh{hfba"); - Assert.assertEquals(elements[15].toString(), "java.lang.String#trim"); - Assert.assertEquals(elements[16].toString(), "java.lang.String#length"); - Assert.assertEquals(elements[17].toString(), "java.lang.String#equals"); - Assert.assertEquals(elements[18].toString(), "java.lang.String#"); - Assert.assertEquals(elements[19].toString(), "java.lang.String#trim"); + Assert.assertEquals(elements[14].toString(), "java.lang.String#equals"); + Assert.assertEquals(elements[15].toString(), "java.lang.String#"); + Assert.assertEquals(elements[16].toString(), "java.lang.String#trim"); + Assert.assertEquals(elements[17].toString(), "java.lang.String#length"); + Assert.assertEquals(elements[18].toString(), "java.lang.String#equals"); + Assert.assertEquals(elements[19].toString(), "java.lang.String#equals"); Assert.assertEquals(elements[20].toString(), "java.lang.String#equals"); - Assert.assertEquals(elements[21].toString(), "java.lang.String#"); - Assert.assertEquals(elements[22].toString(), "java.lang.String#trim"); + Assert.assertEquals(elements[21].toString(), "java.lang.String#equals"); + Assert.assertEquals(elements[22].toString(), "java.lang.String#equals"); Assert.assertEquals(elements[23].toString(), "java.lang.String#equals"); - Assert.assertEquals(elements[24].toString(), "java.lang.String#equals"); + Assert.assertEquals(elements[24].toString(), "java.net.URL#"); Assert.assertEquals(elements[25].toString(), "java.lang.String#equals"); - Assert.assertEquals(elements[26].toString(), "java.lang.String#"); + Assert.assertEquals(elements[26].toString(), "java.lang.String#equals"); Assert.assertEquals(elements[27].toString(), "java.lang.String#equals"); - Assert.assertEquals(elements[28].toString(), "java.net.URL#"); + Assert.assertEquals(elements[28].toString(), "java.lang.String#equals"); + Assert.assertEquals(elements[29].toString(), "java.lang.String#equals"); + Assert.assertEquals(elements[30].toString(), "java.lang.String#equals"); } } -- 2.11.0