From e8367bbd4e6efef2eb4d496c52079c94f0c5133d Mon Sep 17 00:00:00 2001 From: AlpTorac Date: Fri, 30 Aug 2024 15:23:51 +0200 Subject: [PATCH 01/35] Use Map instead of LinkedHashMap --- .../src/org/splevo/diffing/util/NormalizationUtil.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/commit-based-cipm/bundles/fi/org.splevo.diffing/src/org/splevo/diffing/util/NormalizationUtil.java b/commit-based-cipm/bundles/fi/org.splevo.diffing/src/org/splevo/diffing/util/NormalizationUtil.java index 9d76db89b2..97e2cf598b 100644 --- a/commit-based-cipm/bundles/fi/org.splevo.diffing/src/org/splevo/diffing/util/NormalizationUtil.java +++ b/commit-based-cipm/bundles/fi/org.splevo.diffing/src/org/splevo/diffing/util/NormalizationUtil.java @@ -64,7 +64,7 @@ public static String normalize(String original, Map normalizati * The list of normalizations to apply. * @return The normalized name space string. */ - public static String normalizeNamespace(String namespace, LinkedHashMap normalizations) { + public static String normalizeNamespace(String namespace, Map normalizations) { namespace = Strings.nullToEmpty(namespace); for (Pattern pattern : normalizations.keySet()) { From c0976343f849810d016860d712b67598210d4a0a Mon Sep 17 00:00:00 2001 From: AlpTorac Date: Fri, 30 Aug 2024 15:38:07 +0200 Subject: [PATCH 02/35] Extract structure from SimilarityChecker and related classes --- .../base/AbstractSimilarityChecker.java | 71 +++++++++++++++ .../base/AbstractSimilarityComparer.java | 57 ++++++++++++ .../AbstractSimilarityToolboxBuilder.java | 82 ++++++++++++++++++ .../similarity/base/ISimilarityChecker.java | 45 ++++++++++ .../similarity/base/ISimilarityComparer.java | 33 +++++++ .../similarity/base/ISimilarityRequest.java | 23 +++++ .../base/ISimilarityRequestHandler.java | 44 ++++++++++ .../similarity/base/ISimilarityToolbox.java | 75 ++++++++++++++++ .../base/ISimilarityToolboxBuilder.java | 86 +++++++++++++++++++ .../base/ISimilarityToolboxFactory.java | 22 +++++ .../similarity/base/MapSimilarityToolbox.java | 70 +++++++++++++++ .../base/MapSimilarityToolboxFactory.java | 13 +++ .../diffing/similarity/base/package-info.java | 73 ++++++++++++++++ 13 files changed, 694 insertions(+) create mode 100644 commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/base/AbstractSimilarityChecker.java create mode 100644 commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/base/AbstractSimilarityComparer.java create mode 100644 commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/base/AbstractSimilarityToolboxBuilder.java create mode 100644 commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/base/ISimilarityChecker.java create mode 100644 commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/base/ISimilarityComparer.java create mode 100644 commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/base/ISimilarityRequest.java create mode 100644 commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/base/ISimilarityRequestHandler.java create mode 100644 commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/base/ISimilarityToolbox.java create mode 100644 commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/base/ISimilarityToolboxBuilder.java create mode 100644 commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/base/ISimilarityToolboxFactory.java create mode 100644 commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/base/MapSimilarityToolbox.java create mode 100644 commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/base/MapSimilarityToolboxFactory.java create mode 100644 commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/base/package-info.java diff --git a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/base/AbstractSimilarityChecker.java b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/base/AbstractSimilarityChecker.java new file mode 100644 index 0000000000..b1c45afe4b --- /dev/null +++ b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/base/AbstractSimilarityChecker.java @@ -0,0 +1,71 @@ +package org.splevo.jamopp.diffing.similarity.base; + +/** + * An abstract class for similarity checkers to extend. Complements + * {@link ISimilarityChecker} with the integration of + * {@link ISimilarityComparer}.
+ *
+ * Does not implement {@link ISimilarityRequestHandler}, because its concrete + * implementors are thought to serve as facades to the outside. They are thus + * not intended to be used during the similarity checking process, other than a + * call to similarity checking methods, such as + * {@link #isSimilar(Object, Object)}, at the start. + * + * @author atora + */ +public abstract class AbstractSimilarityChecker implements ISimilarityChecker { + /** + * The {@link ISimilarityComparer}, to which incoming {@link ISimilarityRequest} + * instances are to be delegated. + */ + private ISimilarityComparer sc; + + /** + * Constructs an {@link AbstractSimilarityChecker} instance with an + * {@link ISimilarityComparer}, which delegates all incoming + * {@link ISimilarityRequest} to the given parameter. + * + * @param st {@link ISimilarityToolbox} to which all incoming + * {@link ISimilarityRequest} instances will be delegated to. + */ + public AbstractSimilarityChecker(ISimilarityToolbox st) { + this.sc = this.createSimilarityComparer(st); + } + + /** + * Declared as protected only to allow access to the underlying + * {@link ISimilarityComparer} from concrete implementors. + * + * @return {@link ISimilarityToolbox} to which all incoming + * {@link ISimilarityRequest} instances will be delegated to. + */ + protected ISimilarityComparer getSimilarityComparer() { + return this.sc; + } + + /** + * Delegates the incoming {@link ISimilarityRequest} to the underlying + * {@link ISimilarityComparer}.
+ *
+ * Declared as protected only to let concrete implementors delegate incoming + * {@link ISimilarityRequest} instances to their {@link ISimilarityComparer}. + *
+ *
+ * This is necessary, because creating further internal constructs that contain + * similarity checking logic, such as similarity switches, may involve using + * {@link ISimilarityRequestHandler} instances and that in return requires + * delegating {@link ISimilarityRequest} instances. + */ + protected Object handleSimilarityRequest(ISimilarityRequest req) { + return this.getSimilarityComparer().handleSimilarityRequest(req); + } + + /** + * Creates an {@link ISimilarityComparer} with the given + * {@link ISimilarityToolbox}. + * + * @param st The {@link ISimilarityToolbox} that the constructed + * {@link ISimilarityComparer} will use. + */ + protected abstract ISimilarityComparer createSimilarityComparer(ISimilarityToolbox st); +} \ No newline at end of file diff --git a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/base/AbstractSimilarityComparer.java b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/base/AbstractSimilarityComparer.java new file mode 100644 index 0000000000..992135469a --- /dev/null +++ b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/base/AbstractSimilarityComparer.java @@ -0,0 +1,57 @@ +package org.splevo.jamopp.diffing.similarity.base; + +/** + * An abstract class for similarity comparers to extend. Complements + * {@link ISimilarityComparer} with the integration of + * {@link ISimilarityToolbox}.
+ *
+ * Delegates incoming {@link ISimilarityRequest} instances to its + * {@link ISimilarityToolbox}. + * + * @author atora + */ +public abstract class AbstractSimilarityComparer implements ISimilarityComparer { + /** + * The {@link ISimilarityToolbox}, to which all incoming + * {@link ISimilarityRequest} instances should be delegated to. + */ + private ISimilarityToolbox st; + + /** + * Constructs an instance with a given {@link ISimilarityToolbox} + * + * @param st The {@link ISimilarityToolbox}, to which all incoming + * {@link ISimilarityRequest} instances should be delegated to. + */ + public AbstractSimilarityComparer(ISimilarityToolbox st) { + this.st = st; + } + + /** + * @return The {@link ISimilarityToolbox}, to which all incoming + * {@link ISimilarityRequest} instances should be delegated to. + */ + protected ISimilarityToolbox getSimilarityToolbox() { + return this.st; + } + + /** + * {@inheritDoc}
+ *
+ * Here, this method is delegated to {@link #getSimilarityToolbox()}. + */ + @Override + public Object handleSimilarityRequest(ISimilarityRequest req) { + return this.getSimilarityToolbox().handleSimilarityRequest(req); + } + + /** + * {@inheritDoc}
+ *
+ * Here, this method is delegated to {@link #getSimilarityToolbox()}. + */ + @Override + public boolean canHandleSimilarityRequest(Class reqClass) { + return this.getSimilarityToolbox().canHandleSimilarityRequest(reqClass); + } +} \ No newline at end of file diff --git a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/base/AbstractSimilarityToolboxBuilder.java b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/base/AbstractSimilarityToolboxBuilder.java new file mode 100644 index 0000000000..8bfb4aadff --- /dev/null +++ b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/base/AbstractSimilarityToolboxBuilder.java @@ -0,0 +1,82 @@ +package org.splevo.jamopp.diffing.similarity.base; + +/** + * An abstract class for concrete similarity {@link ISimilarityToolbox} builders + * to extend. Complements {@link ISimilarityToolboxBuilder} with the integration + * of {@link ISimilarityToolboxFactory}. + * + * @author atora + */ +public abstract class AbstractSimilarityToolboxBuilder implements ISimilarityToolboxBuilder { + /** + * The {@link ISimilarityToolboxFactory}, which determines the data structure + * used to store request-handler pairs within the {@link ISimilarityToolbox} + * instances built using this builder. + */ + private ISimilarityToolboxFactory stf; + + /** + * The current version of the {@link ISimilarityToolbox} instance being built. + */ + private ISimilarityToolbox st; + + /** + * Constructs an instance. + */ + public AbstractSimilarityToolboxBuilder() { + super(); + } + + @Override + public void setSimilarityToolboxFactory(ISimilarityToolboxFactory stf) { + this.stf = stf; + } + + /** + * @return The {@link ISimilarityToolboxFactory}, which determines the data + * structure used to store request-handler pairs within the + * {@link ISimilarityToolbox} instances built using this builder. + */ + @Override + public ISimilarityToolboxFactory getToolboxFactory() { + return this.stf; + } + + /** + * Meant to allow concrete implementors the access to the current version of the + * {@link ISimilarityToolbox} under construction. + * + * @return The current version of the {@link ISimilarityToolbox} instance being + * built. + */ + protected ISimilarityToolbox getCurrentToolbox() { + return this.st; + } + + /** + * {@inheritDoc}
+ *
+ * Resets the {@link ISimilarityToolbox} instance currently being built to + * null. + */ + @Override + public ISimilarityToolbox build() { + var result = this.getCurrentToolbox(); + this.st = null; + return result; + } + + @Override + public ISimilarityToolboxBuilder instantiate() { + this.st = this.getToolboxFactory().createSimilarityToolbox(); + return this; + } + + @Override + public ISimilarityToolboxBuilder buildRequestHandlerPair(Class req, + ISimilarityRequestHandler srh) { + this.getCurrentToolbox().addRequestHandlerPair(req, srh); + return this; + } + +} \ No newline at end of file diff --git a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/base/ISimilarityChecker.java b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/base/ISimilarityChecker.java new file mode 100644 index 0000000000..7ffa15af18 --- /dev/null +++ b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/base/ISimilarityChecker.java @@ -0,0 +1,45 @@ +package org.splevo.jamopp.diffing.similarity.base; + +import java.util.Collection; + +/** + * An interface for classes that contain the means to compare elements and + * compute their similarity. The classes implementing this interface, the + * similarity checkers, are meant to serve as facades to outside.
+ *
+ * {@link AbstractSimilarityChecker} contains further useful methods for + * similarity checkers. It is therefore recommended to extend + * {@link AbstractSimilarityChecker} for similarity checker classes rather than + * implementing this interface alone. {@link AbstractSimilarityChecker} also + * makes use of {@link ISimilarityComparer}, which can be used to free the + * implementors of {@link ISimilarityChecker} of internal details.
+ *
+ * If the structure defined in {@link AbstractSimilarityChecker} is not to be + * used, this interface can be directly implemented. + * + * @see {@link AbstractSimilarityChecker}, {@link ISimilarityComparer} + * @author atora + */ +public interface ISimilarityChecker { + /** + * Check the similarity of two elements. + * + * @param element1 The first element. + * @param element2 The second element. + * @return TRUE, if they are similar; FALSE if not, NULL if it can't be decided. + */ + public Boolean isSimilar(Object element1, Object element2); + + /** + * Check two lists of elements for similarity.
+ *
+ * The elements are compared pairwise and it is the responsibility of the + * provided list implementations to return them in an appropriate order by + * calling get(i) with a increasing index i. + * + * @return TRUE, if they are all similar; FALSE if a different number of + * elements is submitted or at least one pair of elements is not similar + * to each other. + */ + public Boolean areSimilar(Collection elements1, Collection elements2); +} \ No newline at end of file diff --git a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/base/ISimilarityComparer.java b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/base/ISimilarityComparer.java new file mode 100644 index 0000000000..0e815c8931 --- /dev/null +++ b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/base/ISimilarityComparer.java @@ -0,0 +1,33 @@ +package org.splevo.jamopp.diffing.similarity.base; + +/** + * An interface for similarity comparers, which can be used as a layer of + * indirection between {@link ISimilarityChecker} and + * {@link ISimilarityToolbox}. This allows to integrate additional similarity + * checking related constructs without bloating the implementors of + * {@link ISimilarityChecker}.
+ *
+ * {@link AbstractSimilarityComparer} contains further useful methods for + * similarity comparers. It also integrates {@link ISimilarityToolbox} with + * {@link ISimilarityComparer}. It is therefore recommended to extend + * {@link AbstractSimilarityComparer} for similarity comparer classes rather + * than implementing this interface alone.
+ *
+ * Implements {@link ISimilarityRequestHandler} because this increases the + * flexibility of similarity comparers. This is important, as they are thought + * as a layer of indirection. For example, a similarity comparer could be + * implemented to work with multiple {@link ISimilarityToolbox} instances, so + * that {@link ISimilarityToolbox} instances with different purposes can be + * separated. Alternatively, one can choose to implement + * {@link ISimilarityComparer} with means other than {@link ISimilarityToolbox} + * to deal with {@link ISimilarityRequest} instances, although doing so would + * deviate from {@link AbstractSimilarityComparer} and + * {@link AbstractSimilarityChecker}. + * + * @see {@link AbstractSimilarityChecker}, {@link AbstractSimilarityComparer}, + * {@link ISimilarityToolbox} + * @author atora + */ +public interface ISimilarityComparer extends ISimilarityRequestHandler { + +} \ No newline at end of file diff --git a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/base/ISimilarityRequest.java b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/base/ISimilarityRequest.java new file mode 100644 index 0000000000..3db53cf8de --- /dev/null +++ b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/base/ISimilarityRequest.java @@ -0,0 +1,23 @@ +package org.splevo.jamopp.diffing.similarity.base; + +/** + * An interface for encapsulating parameters required by similarity checking + * operations. Similarity requests are intended to be used by their matching + * {@link ISimilarityRequestHandler}.
+ *
+ * It is recommended to not override the return type of {@link #getParams()}, + * especially if the concrete similarity requests are planned to be extended. + * + * @see {@link ISimilarityToolbox}, {@link ISimilarityRequestHandler} + * @author atora + */ +public interface ISimilarityRequest { + /** + * @return All parameters encapsulated by this instance. Unless specified + * otherwise, the return type is an Object array of all parameters + * passed to the constructor of the concrete implementation in the same + * order. If the said constructor only takes one parameter, the return + * type of this method is the type of that parameter in the constructor. + */ + public Object getParams(); +} diff --git a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/base/ISimilarityRequestHandler.java b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/base/ISimilarityRequestHandler.java new file mode 100644 index 0000000000..e9f945177d --- /dev/null +++ b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/base/ISimilarityRequestHandler.java @@ -0,0 +1,44 @@ +package org.splevo.jamopp.diffing.similarity.base; + +/** + * An interface for encapsulating similarity operations, whose implementors take + * {@link ISimilarityRequest} instances and process them. Implementors of this + * interface are meant to be used to extract such operations from other + * classes/interfaces, as well as their relevant parameters, if plausible. Doing + * so keeps other classes/interfaces clear of functionality that does not + * concern them.
+ *
+ * Implementors can contain further {@link ISimilarityRequestHandler} instances, + * such as an {@link ISimilarityToolbox} or request-specific + * {@link ISimilarityRequestHandler} instances, if they have to process requests + * that need further processing. + * + * @author atora + */ +public interface ISimilarityRequestHandler { + /** + * Processes the given {@link ISimilarityRequest} and returns the result.
+ *
+ * It is recommended to not override the return type, especially if the concrete + * {@link ISimilarityRequestHandler} instances are planned to be extended. + * + * @param req The incoming request. + */ + public Object handleSimilarityRequest(ISimilarityRequest req); + + /** + * @param req A given {@link ISimilarityRequest} instance + * + * @return Whether {@code req} can be handled. + */ + public default boolean canHandleSimilarityRequest(ISimilarityRequest req) { + return this.canHandleSimilarityRequest(req.getClass()); + } + + /** + * @param reqClass The class of the {@link ISimilarityRequest} instance + * + * @return Whether instances of {@code reqClass} can be handled. + */ + public boolean canHandleSimilarityRequest(Class reqClass); +} diff --git a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/base/ISimilarityToolbox.java b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/base/ISimilarityToolbox.java new file mode 100644 index 0000000000..342507cd19 --- /dev/null +++ b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/base/ISimilarityToolbox.java @@ -0,0 +1,75 @@ +package org.splevo.jamopp.diffing.similarity.base; + +/** + * An interface for classes that contain ({@link ISimilarityRequest} (class), + * {@link ISimilarityRequestHandler} (instance)) pairs (or request-handler + * pairs).
+ *
+ * Since the implementors contain request-handler pairs specified above, they + * themselves can be used as {@link ISimilarityRequestHandler} to handle + * {@link ISimilarityRequest} instances. In such cases, they delegate the + * received {@link ISimilarityRequest} to their matching + * {@link ISimilarityRequestHandler}.
+ *
+ * Implementors of this interface allow adding and removing the said pairs + * dynamically. In doing so, they make dynamic changes to similarity checking + * possible. Additionally, new similarity operations can be integrated without + * modifying the implementors themselves by calling the + * {@link #addRequestHandlerPair(Class, ISimilarityRequestHandler)} method.
+ *
+ * This interface makes no assumptions on the data structure used in its + * concrete implementors to store request-handler pairs. Neither does it + * explicitly specify how incoming {@link ISimilarityRequest} instances are + * internally handled. + * + * @see {@link ISimilarityToolboxBuilder}, {@link ISimilarityToolboxFactory} + * @author atora + */ +public interface ISimilarityToolbox extends ISimilarityRequestHandler { + /** + * Adds a ({@link ISimilarityRequest} (class), {@link ISimilarityRequestHandler} + * (instance)) pair (or request-handler pair).
+ *
+ * Note that the first parameter (reqClass) is the class of the + * {@link ISimilarityRequest} and the second parameter (srh) is an + * {@link ISimilarityRequestHandler} instance. + * + * @param reqClass The class of the {@link ISimilarityRequest} instances, which + * should be processed using the given + * {@link ISimilarityRequestHandler} instance. + * @param srh The {@link ISimilarityRequestHandler} instance, which should + * be used to process the {@link ISimilarityRequest} instances + * of the given class. + */ + public void addRequestHandlerPair(Class reqClass, ISimilarityRequestHandler srh); + + /** + * Removes the pairs added for {@link ISimilarityRequest}. + * + * @param reqClass The class of the {@link ISimilarityRequest} instances + * + * @see {@link #addRequestHandlerPair(Class, ISimilarityRequestHandler)} + */ + public void removeRequestHandlerPair(Class reqClass); + + /** + * Removes all pairs added to this instance. + * + * @see {@link #addRequestHandlerPair(Class, ISimilarityRequestHandler)} + */ + public void clearRequestHandlerPairs(); + + /** + * {@inheritDoc}
+ *
+ * The data structure used in the {@link ISimilarityToolbox} implementation to + * store request-handler pairs can influence the way {@code req} is handled. For + * example, in cases where there is no corresponding handler or if there are + * multiple corresponding handlers. + */ + @Override + public Object handleSimilarityRequest(ISimilarityRequest req); + + @Override + public boolean canHandleSimilarityRequest(Class reqClass); +} diff --git a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/base/ISimilarityToolboxBuilder.java b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/base/ISimilarityToolboxBuilder.java new file mode 100644 index 0000000000..3c94125651 --- /dev/null +++ b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/base/ISimilarityToolboxBuilder.java @@ -0,0 +1,86 @@ +package org.splevo.jamopp.diffing.similarity.base; + +/** + * An interface implemented by classes that help build a + * {@link ISimilarityToolbox} dynamically. The implementors use the builder + * pattern and may include further building methods.
+ *
+ * To build a {@link ISimilarityToolbox}: + *
    + *
  1. Set the {@link ISimilarityToolboxFactory} to specify the internal data + * structure that will be used in the end product to store request-handler pairs + * using {@link #setSimilarityToolboxFactory(ISimilarityToolboxFactory)}. + *
  2. Instantiate a {@link ISimilarityToolbox} within the + * {@link ISimilarityToolboxBuilder} using {@link #instantiate()}. + *
  3. Use the provided building methods, such as + * {@link #buildRequestHandlerPair(Class, ISimilarityRequestHandler)}. + *
  4. Return the end product by calling {@link #build()}. + *
+ * Concrete implementors may provide additional building methods, such as those + * that summarise multiple + * {@link #buildRequestHandlerPair(Class, ISimilarityRequestHandler)} calls into + * one method. In such cases, it is recommended to use those methods instead, in + * order to keep the building process tidier. + * + * @author atora + */ +public interface ISimilarityToolboxBuilder { + /** + * Sets the {@link ISimilarityToolboxFactory}, which specifies the internal data + * structure that will be used in the end product to store request-handler + * pairs. Currently used {@link ISimilarityToolboxFactory} can be changed by + * using this method as well.
+ *
+ * Note that changing the {@link ISimilarityToolboxFactory} after calling + * {@link #instantiate()} has no effect on the {@link ISimilarityToolbox} that + * is currently being built. For this change to take effect, + * {@link #instantiate()} can be called to start the building process anew with + * the new {@link ISimilarityToolboxFactory}. + * + * @param stf The new {@link ISimilarityToolboxFactory} that this builder will + * use + */ + public void setSimilarityToolboxFactory(ISimilarityToolboxFactory stf); + + /** + * @return Currently used {@link ISimilarityToolboxFactory}. + */ + public ISimilarityToolboxFactory getToolboxFactory(); + + /** + * Returns the current version of the {@link ISimilarityToolbox} being built. + *
+ *
+ * Depending on the concrete implementation, calling this method may set the + * current version of the {@link ISimilarityToolbox} to null after + * returning. + * + * @return The resulting {@link ISimilarityToolbox}. + */ + public ISimilarityToolbox build(); + + /** + * Creates a {@link ISimilarityToolbox} using the current + * {@link ISimilarityToolboxFactory} within this builder. Can also be used to + * reset the current version of the {@link ISimilarityToolbox}. + * + * @return this + */ + public ISimilarityToolboxBuilder instantiate(); + + /** + * Adds the given request-handler pair (reqClass, srh) to the + * {@link ISimilarityToolbox}. + * + * @param reqClass The class of the {@link ISimilarityRequest} instances, which + * should be processed using the given + * {@link ISimilarityRequestHandler} instance. + * @param srh The {@link ISimilarityRequestHandler} instance, which should + * be used to process the {@link ISimilarityRequest} instances + * of the given class. + * + * @return this + */ + public ISimilarityToolboxBuilder buildRequestHandlerPair(Class reqClass, + ISimilarityRequestHandler srh); +} \ No newline at end of file diff --git a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/base/ISimilarityToolboxFactory.java b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/base/ISimilarityToolboxFactory.java new file mode 100644 index 0000000000..868e74dadb --- /dev/null +++ b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/base/ISimilarityToolboxFactory.java @@ -0,0 +1,22 @@ +package org.splevo.jamopp.diffing.similarity.base; + +/** + * An interface for {@link ISimilarityToolbox} factories.
+ *
+ * The purpose of the implementors of this interface is to set the data + * structure that will be used in the {@link ISimilarityToolbox} to contain the + * request-handler pairs added to them.
+ *
+ * It is recommended to use {@link ISimilarityToolboxBuilder} and its + * implementors to build {@link ISimilarityToolbox} instances. + * + * @see {@link ISimilarityToolbox}, {@link ISimilarityToolboxBuilder} + * @author atora + */ +public interface ISimilarityToolboxFactory { + /** + * Constructs and returns an {@link ISimilarityToolbox} instance without any + * pairs. + */ + public ISimilarityToolbox createSimilarityToolbox(); +} diff --git a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/base/MapSimilarityToolbox.java b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/base/MapSimilarityToolbox.java new file mode 100644 index 0000000000..d7f3e487a1 --- /dev/null +++ b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/base/MapSimilarityToolbox.java @@ -0,0 +1,70 @@ +package org.splevo.jamopp.diffing.similarity.base; + +import java.util.HashMap; +import java.util.Map; + +/** + * An {@link ISimilarityToolbox} implementor, that uses a {@link Map} to contain + * 1 to 1 mappings between request-handler pairs (see + * {@link ISimilarityToolbox}).
+ *
+ * This means that only one {@link ISimilarityRequestHandler} stored in this + * instance will process incoming {@link ISimilarityRequest}.
+ *
+ * Therefore, if a request is to be handled by further handlers, either the + * delegation to those handlers must be implemented in the initial handler or + * another concrete {@link ISimilarityToolbox} implementation should be used. + * + * @author atora + */ +public class MapSimilarityToolbox implements ISimilarityToolbox { + /** + * The map that contains the request-handler pairs. + */ + private Map, ISimilarityRequestHandler> rhMap; + + /** + * Constructs an instance and initialises the map it uses to store + * request-handler pairs. + */ + public MapSimilarityToolbox() { + this.rhMap = new HashMap, ISimilarityRequestHandler>(); + } + + /** + * {@inheritDoc}
+ *
+ * If there is already a request-handler pair for reqClass, it will be replaced + * by the given pair (reqClass, srh). + */ + @Override + public void addRequestHandlerPair(Class reqClass, ISimilarityRequestHandler srh) { + this.rhMap.put(reqClass, srh); + } + + @Override + public void removeRequestHandlerPair(Class reqClass) { + this.rhMap.remove(reqClass); + } + + @Override + public void clearRequestHandlerPairs() { + this.rhMap.clear(); + } + + /** + * Attempts to handle the given {@link ISimilarityRequest} with a matching + * {@link ISimilarityRequestHandler} and returns the output. + */ + @Override + public Object handleSimilarityRequest(ISimilarityRequest req) { + var handler = this.rhMap.get(req.getClass()); + + return handler != null ? handler.handleSimilarityRequest(req) : null; + } + + @Override + public boolean canHandleSimilarityRequest(Class reqClass) { + return this.rhMap.containsKey(reqClass); + } +} diff --git a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/base/MapSimilarityToolboxFactory.java b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/base/MapSimilarityToolboxFactory.java new file mode 100644 index 0000000000..a6041b5dd8 --- /dev/null +++ b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/base/MapSimilarityToolboxFactory.java @@ -0,0 +1,13 @@ +package org.splevo.jamopp.diffing.similarity.base; + +/** + * A factory that creates {@link MapSimilarityToolbox} instances. + * + * @author atora + */ +public class MapSimilarityToolboxFactory implements ISimilarityToolboxFactory { + @Override + public MapSimilarityToolbox createSimilarityToolbox() { + return new MapSimilarityToolbox(); + } +} diff --git a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/base/package-info.java b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/base/package-info.java new file mode 100644 index 0000000000..98c88676ca --- /dev/null +++ b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/base/package-info.java @@ -0,0 +1,73 @@ +/** + * This package contains interfaces and abstract classes that can be used to + * implement similarity checking. An overview of the similarity checking + * process, as well as the roles of individual elements can be found below.
+ *
+ * The similarity checking process begins with the similarity checker + * {@link ISimilarityChecker}, which serves as a facade to outside. It + * translates the incoming similarity checking calls to similarity checking + * request(s), i.e. {@link ISimilarityRequest}. It then delegates those requests + * to its {@link ISimilarityComparer}, which serves as a layer of indirection + * between {@link ISimilarityChecker} and the similarity checking logic. The + * purpose of {@link ISimilarityComparer} is to keep {@link ISimilarityChecker} + * as clean and simple as possible, since it is supposed to serve as a facade. + * {@link ISimilarityComparer} delegates {@link ISimilarityRequest} instances + * delegated to it to the similarity checking "tools", which can be implemented + * in form of {@link ISimilarityRequestHandler} instances.
+ *
+ * {@link ISimilarityToolbox} contains {@link ISimilarityRequestHandler} + * instances, which are meant to handle the incoming {@link ISimilarityRequest} + * instances. It is responsible for storing and organising + * {@link ISimilarityRequestHandler} instances in a way that the incoming + * {@link ISimilarityRequest} instances can be matched with their corresponding + * {@link ISimilarityRequestHandler} instance(s) and be handled by them. Because + * of this, the {@link ISimilarityToolbox} itself is also a + * {@link ISimilarityRequestHandler}. Likewise, {@link ISimilarityComparer} is + * also a {@link ISimilarityRequestHandler}. Further similarity checking tools + * can be added to {@link ISimilarityToolbox} dynamically in form of + * ({@link ISimilarityRequest} (class), {@link ISimilarityRequestHandler} + * (instance)) pairs (or request-handler pairs). The request-handler pairs can + * also be removed dynamically.
+ *
+ * To build a {@link ISimilarityToolbox} instance, one can use + * {@link ISimilarityToolboxBuilder}. {@link ISimilarityToolboxBuilder} + * encapsulates the means to construct {@link ISimilarityToolbox} instances + * dynamically and it may also provide "standard" building methods to bundle + * certain request-handler pairs to ease the building process. Since there are + * many ways to implement {@link ISimilarityToolbox}, one needs to pass a + * {@link ISimilarityToolboxFactory} to the {@link ISimilarityToolboxBuilder}. + * {@link ISimilarityToolboxFactory} is used to create the initial instance of + * the {@link ISimilarityToolbox}, which can then be filled with either the + * {@link ISimilarityToolboxBuilder} or manually.
+ *
+ * While implementing {@link ISimilarityRequestHandler}, including a reference + * to {@link ISimilarityToolbox} in the concrete implementation will allow it to + * create further {@link ISimilarityRequest} instances and delegate them. Doing + * so allows re-using code and creating chains of requests, which can help + * separate concerns better.
+ *
+ * From a design standpoint, using {@link ISimilarityToolbox} helps centralise + * similarity checking operations and makes them easier to modify. Furthermore, + * dynamic modifications are also made possible with this approach, as + * request-handler pairs can be changed during runtime. Outside parameters that + * are only relevant for certain operations can also be stored within the + * relevant {@link ISimilarityRequestHandler} instances. Doing so frees + * similarity checking mechanisms from storing all such parameters and stops the + * said parameters from getting dragged around (as constructor parameters, + * getter/setter methods, etc.). It is therefore important to extract such + * parameters/variables into {@link ISimilarityRequestHandler} implementors + * whenever plausible. Not abiding this can easily pollute classes implementing + * similarity checking logic with those parameters, even though they have no + * purpose being in them. This in return can bloat the said classes' + * constructors and/or the classes themselves with setter/getter methods for the + * said parameters.
+ *
+ * Although the use of the abstract classes, such as + * {@link AbstractSimilarityChecker}, in future implementations is expected, one + * can choose to directly implement their corresponding interfaces, if the said + * abstract classes and/or the intended architecture are not helpful. In order + * to not lose this flexibility, it is important to hide all future (abstract) + * classes behind interfaces and to only use {@link ISimilarityChecker} from + * outside. + */ +package org.splevo.jamopp.diffing.similarity.base; \ No newline at end of file From 34687eed92349ff1f9036f77e67c4ba250d826de Mon Sep 17 00:00:00 2001 From: AlpTorac Date: Mon, 2 Sep 2024 17:23:36 +0200 Subject: [PATCH 03/35] Extract similarity checking operations Implement requests and handlers for certain similarity checking operations used in Java similarity switches Helps centralise the said operations Helps encapsulates some parameters that would otherwise unnecessarily clutter similarity checker and similarity switches --- .../ClassifierNormalizationHandler.java | 48 ++++++++++++++ .../CompilationUnitNormalizationHandler.java | 48 ++++++++++++++ .../handlers/NamespaceCheckHandler.java | 62 +++++++++++++++++++ .../NamespaceNormalizationHandler.java | 48 ++++++++++++++ .../handlers/PackageNormalizationHandler.java | 48 ++++++++++++++ .../ClassifierNormalizationRequest.java | 30 +++++++++ .../CompilationUnitNormalizationRequest.java | 31 ++++++++++ .../requests/NamespaceCheckRequest.java | 31 ++++++++++ .../NamespaceNormalizationRequest.java | 33 ++++++++++ .../requests/PackageNormalizationRequest.java | 35 +++++++++++ 10 files changed, 414 insertions(+) create mode 100644 commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/handlers/ClassifierNormalizationHandler.java create mode 100644 commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/handlers/CompilationUnitNormalizationHandler.java create mode 100644 commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/handlers/NamespaceCheckHandler.java create mode 100644 commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/handlers/NamespaceNormalizationHandler.java create mode 100644 commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/handlers/PackageNormalizationHandler.java create mode 100644 commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/requests/ClassifierNormalizationRequest.java create mode 100644 commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/requests/CompilationUnitNormalizationRequest.java create mode 100644 commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/requests/NamespaceCheckRequest.java create mode 100644 commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/requests/NamespaceNormalizationRequest.java create mode 100644 commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/requests/PackageNormalizationRequest.java diff --git a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/handlers/ClassifierNormalizationHandler.java b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/handlers/ClassifierNormalizationHandler.java new file mode 100644 index 0000000000..a107a45c79 --- /dev/null +++ b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/handlers/ClassifierNormalizationHandler.java @@ -0,0 +1,48 @@ +package org.splevo.jamopp.diffing.similarity.handlers; + +import java.util.Map; +import java.util.regex.Pattern; + +import org.splevo.diffing.util.NormalizationUtil; +import org.splevo.jamopp.diffing.similarity.base.ISimilarityRequest; +import org.splevo.jamopp.diffing.similarity.base.ISimilarityRequestHandler; +import org.splevo.jamopp.diffing.similarity.requests.ClassifierNormalizationRequest; + +/** + * An {@link ISimilarityRequestHandler} that processes incoming + * {@link ClassifierNormalizationRequest} instances. + * + * @author atora + */ +public class ClassifierNormalizationHandler implements ISimilarityRequestHandler { + /** + * @see {@link JaMoPPDiffer#initSimilarityChecker(Map)} + */ + private Map classifierNormalizations; + + /** + * Constructs an instance with the given parameter. + * + * @see {@link JaMoPPDiffer#initSimilarityChecker(Map)} + */ + public ClassifierNormalizationHandler(Map classifierNormalizations) { + this.classifierNormalizations = classifierNormalizations; + } + + /** + * {@inheritDoc}
+ *
+ * Performs the requested normalisation and returns the result. + */ + @Override + public Object handleSimilarityRequest(ISimilarityRequest req) { + ClassifierNormalizationRequest castedR = (ClassifierNormalizationRequest) req; + + return NormalizationUtil.normalize((String) castedR.getParams(), this.classifierNormalizations); + } + + @Override + public boolean canHandleSimilarityRequest(Class reqClass) { + return reqClass.equals(ClassifierNormalizationRequest.class); + } +} diff --git a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/handlers/CompilationUnitNormalizationHandler.java b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/handlers/CompilationUnitNormalizationHandler.java new file mode 100644 index 0000000000..59bd9f2496 --- /dev/null +++ b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/handlers/CompilationUnitNormalizationHandler.java @@ -0,0 +1,48 @@ +package org.splevo.jamopp.diffing.similarity.handlers; + +import java.util.Map; +import java.util.regex.Pattern; + +import org.splevo.diffing.util.NormalizationUtil; +import org.splevo.jamopp.diffing.similarity.base.ISimilarityRequest; +import org.splevo.jamopp.diffing.similarity.base.ISimilarityRequestHandler; +import org.splevo.jamopp.diffing.similarity.requests.CompilationUnitNormalizationRequest; + +/** + * An {@link ISimilarityRequestHandler} that processes incoming + * {@link CompilationUnitNormalizationRequest} instances. + * + * @author atora + */ +public class CompilationUnitNormalizationHandler implements ISimilarityRequestHandler { + /** + * @see {@link JaMoPPDiffer#initSimilarityChecker(Map)} + */ + private Map compilationUnitNormalizations; + + /** + * Constructs an instance with the given parameter. + * + * @see {@link JaMoPPDiffer#initSimilarityChecker(Map)} + */ + public CompilationUnitNormalizationHandler(Map compilationUnitNormalizations) { + this.compilationUnitNormalizations = compilationUnitNormalizations; + } + + /** + * {@inheritDoc}
+ *
+ * Performs the requested normalisation and returns the result. + */ + @Override + public Object handleSimilarityRequest(ISimilarityRequest req) { + CompilationUnitNormalizationRequest castedR = (CompilationUnitNormalizationRequest) req; + + return NormalizationUtil.normalize((String) castedR.getParams(), this.compilationUnitNormalizations); + } + + @Override + public boolean canHandleSimilarityRequest(Class reqClass) { + return reqClass.equals(CompilationUnitNormalizationRequest.class); + } +} diff --git a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/handlers/NamespaceCheckHandler.java b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/handlers/NamespaceCheckHandler.java new file mode 100644 index 0000000000..639d9f0c09 --- /dev/null +++ b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/handlers/NamespaceCheckHandler.java @@ -0,0 +1,62 @@ +package org.splevo.jamopp.diffing.similarity.handlers; + +import org.splevo.jamopp.diffing.similarity.requests.NamespaceCheckRequest; +import org.emftext.language.java.commons.NamespaceAwareElement; +import org.splevo.jamopp.diffing.similarity.base.ISimilarityRequest; +import org.splevo.jamopp.diffing.similarity.base.ISimilarityRequestHandler; + +/** + * An {@link ISimilarityRequestHandler} that processes incoming + * {@link NamespaceCheckRequest} instances. + * + * @author atora + */ +public class NamespaceCheckHandler implements ISimilarityRequestHandler { + + /** + * {@inheritDoc}
+ *
+ * Checks the given namespaces for similarity and returns the similarity result. + */ + @Override + public Object handleSimilarityRequest(ISimilarityRequest req) { + NamespaceCheckRequest castedR = (NamespaceCheckRequest) req; + NamespaceAwareElement[] params = (NamespaceAwareElement[]) castedR.getParams(); + + var ele1 = params[0]; + var ele2 = params[1]; + + // Null check to avoid NullPointerExceptions + if (ele1 == ele2) { + return true; + } else if (ele1 == null ^ ele2 == null) { + return false; + } + + var nss1 = ele1.getNamespaces(); + var nss2 = ele2.getNamespaces(); + + // Null check to avoid NullPointerExceptions + if (nss1 == nss2) { + return true; + } else if (nss1 == null ^ nss2 == null) { + return false; + } + + if (nss1.size() != nss2.size()) { + return false; + } + + for (int idx = 0; idx < nss1.size(); idx++) { + if (!nss1.get(idx).equals(nss2.get(idx))) { + return false; + } + } + return true; + } + + @Override + public boolean canHandleSimilarityRequest(Class reqClass) { + return reqClass.equals(NamespaceCheckRequest.class); + } +} diff --git a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/handlers/NamespaceNormalizationHandler.java b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/handlers/NamespaceNormalizationHandler.java new file mode 100644 index 0000000000..f99eea8ca6 --- /dev/null +++ b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/handlers/NamespaceNormalizationHandler.java @@ -0,0 +1,48 @@ +package org.splevo.jamopp.diffing.similarity.handlers; + +import java.util.Map; +import java.util.regex.Pattern; + +import org.splevo.diffing.util.NormalizationUtil; +import org.splevo.jamopp.diffing.similarity.base.ISimilarityRequest; +import org.splevo.jamopp.diffing.similarity.base.ISimilarityRequestHandler; +import org.splevo.jamopp.diffing.similarity.requests.NamespaceNormalizationRequest; + +/** + * An {@link ISimilarityRequestHandler} that processes incoming + * {@link NamespaceNormalizationRequest} instances. + * + * @author atora + */ +public class NamespaceNormalizationHandler implements ISimilarityRequestHandler { + /** + * @see {@link JaMoPPDiffer#initSimilarityChecker(Map)} + */ + private Map packageNormalizations; + + /** + * Constructs an instance with the given parameter. + * + * @see {@link JaMoPPDiffer#initSimilarityChecker(Map)} + */ + public NamespaceNormalizationHandler(Map packageNormalizations) { + this.packageNormalizations = packageNormalizations; + } + + /** + * {@inheritDoc}
+ *
+ * Performs the requested normalisation and returns the result. + */ + @Override + public Object handleSimilarityRequest(ISimilarityRequest req) { + NamespaceNormalizationRequest castedR = (NamespaceNormalizationRequest) req; + + return NormalizationUtil.normalize((String) castedR.getParams(), this.packageNormalizations); + } + + @Override + public boolean canHandleSimilarityRequest(Class reqClass) { + return reqClass.equals(NamespaceNormalizationRequest.class); + } +} diff --git a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/handlers/PackageNormalizationHandler.java b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/handlers/PackageNormalizationHandler.java new file mode 100644 index 0000000000..a3ddfc8032 --- /dev/null +++ b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/handlers/PackageNormalizationHandler.java @@ -0,0 +1,48 @@ +package org.splevo.jamopp.diffing.similarity.handlers; + +import java.util.Map; +import java.util.regex.Pattern; + +import org.splevo.diffing.util.NormalizationUtil; +import org.splevo.jamopp.diffing.similarity.base.ISimilarityRequest; +import org.splevo.jamopp.diffing.similarity.base.ISimilarityRequestHandler; +import org.splevo.jamopp.diffing.similarity.requests.PackageNormalizationRequest; + +/** + * An {@link ISimilarityRequestHandler} that processes incoming + * {@link PackageNormalizationRequest} instances. + * + * @author atora + */ +public class PackageNormalizationHandler implements ISimilarityRequestHandler { + /** + * @see {@link JaMoPPDiffer#initSimilarityChecker(Map)} + */ + private Map packageNormalizations; + + /** + * Constructs an instance with the given parameter. + * + * @see {@link JaMoPPDiffer#initSimilarityChecker(Map)} + */ + public PackageNormalizationHandler(Map packageNormalizations) { + this.packageNormalizations = packageNormalizations; + } + + /** + * {@inheritDoc}
+ *
+ * Performs the requested normalisation and returns the result. + */ + @Override + public Object handleSimilarityRequest(ISimilarityRequest req) { + PackageNormalizationRequest castedR = (PackageNormalizationRequest) req; + + return NormalizationUtil.normalize((String) castedR.getParams(), this.packageNormalizations); + } + + @Override + public boolean canHandleSimilarityRequest(Class reqClass) { + return reqClass.equals(PackageNormalizationRequest.class); + } +} diff --git a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/requests/ClassifierNormalizationRequest.java b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/requests/ClassifierNormalizationRequest.java new file mode 100644 index 0000000000..5b549d77b7 --- /dev/null +++ b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/requests/ClassifierNormalizationRequest.java @@ -0,0 +1,30 @@ +package org.splevo.jamopp.diffing.similarity.requests; + +import org.splevo.jamopp.diffing.similarity.base.ISimilarityRequest; + +/** + * An {@link ISimilarityRequest}, which contains the qualified name of a + * {@link ConcreteClassifier} instance: {@code conCls.getQualifiedName()}. + * + * @author atora + */ +public class ClassifierNormalizationRequest implements ISimilarityRequest { + /** + * The qualified name of the {@link ConcreteClassifier}. + */ + private String toBeNormalized; + + /** + * Constructs an instance. + * + * @param toBeNormalized The qualified name of the {@link ConcreteClassifier} ({@code conCls.getQualifiedName()}) + */ + public ClassifierNormalizationRequest(String toBeNormalized) { + this.toBeNormalized = toBeNormalized; + } + + @Override + public Object getParams() { + return this.toBeNormalized; + } +} diff --git a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/requests/CompilationUnitNormalizationRequest.java b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/requests/CompilationUnitNormalizationRequest.java new file mode 100644 index 0000000000..54792c12d1 --- /dev/null +++ b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/requests/CompilationUnitNormalizationRequest.java @@ -0,0 +1,31 @@ +package org.splevo.jamopp.diffing.similarity.requests; + +import org.splevo.jamopp.diffing.similarity.base.ISimilarityRequest; + +/** + * An {@link ISimilarityRequest}, which contains the name of a + * {@link CompilationUnit} instance: {@code compUnit.name()}. + * + * @author atora + * + */ +public class CompilationUnitNormalizationRequest implements ISimilarityRequest { + /** + * The name of the {@link CompilationUnit}. + */ + private String toBeNormalized; + + /** + * Constructs an instance. + * + * @param toBeNormalized The name of the {@link CompilationUnit} ({@code compUnit.name()}). + */ + public CompilationUnitNormalizationRequest(String toBeNormalized) { + this.toBeNormalized = toBeNormalized; + } + + @Override + public Object getParams() { + return this.toBeNormalized; + } +} diff --git a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/requests/NamespaceCheckRequest.java b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/requests/NamespaceCheckRequest.java new file mode 100644 index 0000000000..e3a689308e --- /dev/null +++ b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/requests/NamespaceCheckRequest.java @@ -0,0 +1,31 @@ +package org.splevo.jamopp.diffing.similarity.requests; + +import org.emftext.language.java.commons.NamespaceAwareElement; +import org.splevo.jamopp.diffing.similarity.base.ISimilarityRequest; + +/** + * An {@link ISimilarityRequest}, which contains 2 {@link NamespaceAwareElement} + * instances. + * + * @author atora + */ +public class NamespaceCheckRequest implements ISimilarityRequest { + private NamespaceAwareElement ele1; + private NamespaceAwareElement ele2; + + /** + * Constructs an instance with the given parameters. + * + * @param ele1 The first element. + * @param ele2 The second element. + */ + public NamespaceCheckRequest(NamespaceAwareElement ele1, NamespaceAwareElement ele2) { + this.ele1 = ele1; + this.ele2 = ele2; + } + + @Override + public Object getParams() { + return new NamespaceAwareElement[] { this.ele1, this.ele2 }; + } +} diff --git a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/requests/NamespaceNormalizationRequest.java b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/requests/NamespaceNormalizationRequest.java new file mode 100644 index 0000000000..3055f4fdeb --- /dev/null +++ b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/requests/NamespaceNormalizationRequest.java @@ -0,0 +1,33 @@ +package org.splevo.jamopp.diffing.similarity.requests; + +import org.splevo.jamopp.diffing.similarity.base.ISimilarityRequest; + +/** + * An {@link ISimilarityRequest}, which contains all namespaces of a + * {@link NamespaceAwareElement} instance as String: + * {@code nae.getNamespacesAsString()} + * + * @author atora + * + */ +public class NamespaceNormalizationRequest implements ISimilarityRequest { + /** + * All namespaces of the {@link NamespaceAwareElement} instance as String. + */ + private String toBeNormalized; + + /** + * Constructs an instance with the given parameter. + * + * @param toBeNormalized All namespaces of the {@link NamespaceAwareElement} + * instance as String ({@code nae.getNamespacesAsString()}) + */ + public NamespaceNormalizationRequest(String toBeNormalized) { + this.toBeNormalized = toBeNormalized; + } + + @Override + public Object getParams() { + return this.toBeNormalized; + } +} diff --git a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/requests/PackageNormalizationRequest.java b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/requests/PackageNormalizationRequest.java new file mode 100644 index 0000000000..8142fefd4a --- /dev/null +++ b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/requests/PackageNormalizationRequest.java @@ -0,0 +1,35 @@ +package org.splevo.jamopp.diffing.similarity.requests; + +import org.splevo.jamopp.diffing.similarity.base.ISimilarityRequest; + +/** + * An {@link ISimilarityRequest}, which contains the name of a + * {@link CompilationUnit} instance normalised via + * {@link CompilationUnitNormalizationRequest} first. + * + * @author atora + * + */ +public class PackageNormalizationRequest implements ISimilarityRequest { + /** + * The name of the {@link CompilationUnit} instance normalised via + * {@link CompilationUnitNormalizationRequest} first. + */ + private String toBeNormalized; + + /** + * Constructs an instance with the given parameter. + * + * @param toBeNormalized The name of the {@link CompilationUnit} instance + * normalised via + * {@link CompilationUnitNormalizationRequest} first. + */ + public PackageNormalizationRequest(String toBeNormalized) { + this.toBeNormalized = toBeNormalized; + } + + @Override + public Object getParams() { + return this.toBeNormalized; + } +} From ce439d3ff4212af91e242e9c81cd508dbf0e99dd Mon Sep 17 00:00:00 2001 From: AlpTorac Date: Mon, 2 Sep 2024 17:28:15 +0200 Subject: [PATCH 04/35] Extract EMFtext related structure Builds upon the ...similarity.base package, extends and complements its elements with EMFtext Provides exemplary similarity checking requests and handlers (using them is not mandatory) --- .../AbstractComposedSimilaritySwitch.java | 90 +++++++++++++++ ...tractComposedSimilaritySwitchComparer.java | 23 ++++ .../ecore/AbstractComposedSwitchAdapter.java | 73 ++++++++++++ ...stractComposedSwitchSimilarityChecker.java | 75 ++++++++++++ .../base/ecore/IComposedSimilaritySwitch.java | 13 +++ .../base/ecore/IComposedSwitchAdapter.java | 41 +++++++ .../similarity/base/ecore/IInnerSwitch.java | 55 +++++++++ .../base/ecore/IPositionInnerSwitch.java | 109 ++++++++++++++++++ .../ecore/MultipleSimilarityCheckHandler.java | 99 ++++++++++++++++ .../ecore/MultipleSimilarityCheckRequest.java | 43 +++++++ .../ecore/SingleSimilarityCheckHandler.java | 100 ++++++++++++++++ .../ecore/SingleSimilarityCheckRequest.java | 34 ++++++ .../similarity/base/ecore/package-info.java | 45 ++++++++ 13 files changed, 800 insertions(+) create mode 100644 commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/base/ecore/AbstractComposedSimilaritySwitch.java create mode 100644 commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/base/ecore/AbstractComposedSimilaritySwitchComparer.java create mode 100644 commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/base/ecore/AbstractComposedSwitchAdapter.java create mode 100644 commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/base/ecore/AbstractComposedSwitchSimilarityChecker.java create mode 100644 commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/base/ecore/IComposedSimilaritySwitch.java create mode 100644 commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/base/ecore/IComposedSwitchAdapter.java create mode 100644 commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/base/ecore/IInnerSwitch.java create mode 100644 commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/base/ecore/IPositionInnerSwitch.java create mode 100644 commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/base/ecore/MultipleSimilarityCheckHandler.java create mode 100644 commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/base/ecore/MultipleSimilarityCheckRequest.java create mode 100644 commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/base/ecore/SingleSimilarityCheckHandler.java create mode 100644 commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/base/ecore/SingleSimilarityCheckRequest.java create mode 100644 commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/base/ecore/package-info.java diff --git a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/base/ecore/AbstractComposedSimilaritySwitch.java b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/base/ecore/AbstractComposedSimilaritySwitch.java new file mode 100644 index 0000000000..da4c0ec811 --- /dev/null +++ b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/base/ecore/AbstractComposedSimilaritySwitch.java @@ -0,0 +1,90 @@ +package org.splevo.jamopp.diffing.similarity.base.ecore; + +import java.util.Collection; + +import org.eclipse.emf.ecore.util.Switch; +import org.splevo.jamopp.diffing.similarity.base.ISimilarityRequest; +import org.splevo.jamopp.diffing.similarity.base.ISimilarityRequestHandler; + +/** + * An abstract class that complements {@link AbstractComposedSwitchAdapter} with + * an attribute to store an {@link ISimilarityRequestHandler} instance. This + * attribute is then used during similarity checking to delegate + * {@link ISimilarityRequest} instances to their proper + * {@link ISimilarityRequestHandler} instance. + * + * @author atora + */ +public abstract class AbstractComposedSimilaritySwitch extends AbstractComposedSwitchAdapter + implements ISimilarityRequestHandler { + + /** + * The {@link ISimilarityRequestHandler}, to which incoming + * {@link ISimilarityRequest} instances will be delegated. + */ + private ISimilarityRequestHandler srh; + + /** + * Constructs an instance with the given {@link ISimilarityRequestHandler}. + * + * @param srh The {@link ISimilarityRequestHandler}, to which incoming + * {@link ISimilarityRequest} instances will be delegated. + */ + public AbstractComposedSimilaritySwitch(ISimilarityRequestHandler srh) { + super(); + this.srh = srh; + } + + /** + * Variation of + * {@link #AbstractComposedSimilaritySwitch(ISimilarityRequestHandler)} that + * constructs an instance with the given switches. + * + * @see {@link AbstractComposedSwitchAdapter#AbstractComposedSwitchWrapper(Collection)} + */ + protected AbstractComposedSimilaritySwitch(ISimilarityRequestHandler srh, Collection> switches) { + super(switches); + this.srh = srh; + } + + /** + * Variation of + * {@link #AbstractComposedSimilaritySwitch(ISimilarityRequestHandler)} that + * constructs an instance with the given switches. + * + * @see {@link AbstractComposedSwitchAdapter#AbstractComposedSwitchWrapper(Switch[])} + */ + protected AbstractComposedSimilaritySwitch(ISimilarityRequestHandler srh, Switch[] switches) { + super(switches); + this.srh = srh; + } + + /** + * @return The {@link ISimilarityRequestHandler}, to which incoming + * {@link ISimilarityRequest} instances will be delegated. + */ + protected ISimilarityRequestHandler getSimilarityRequestHandler() { + return this.srh; + } + + /** + * {@inheritDoc}
+ *
+ * Here, it delegates the incoming {@link ISimilarityRequest} to + * {@link #getSimilarityRequestHandler()}. + */ + @Override + public Object handleSimilarityRequest(ISimilarityRequest req) { + return this.getSimilarityRequestHandler().handleSimilarityRequest(req); + } + + /** + * {@inheritDoc}
+ *
+ * Here, this method is delegated to {@link #getSimilarityRequestHandler()}. + */ + @Override + public boolean canHandleSimilarityRequest(Class reqClass) { + return this.getSimilarityRequestHandler().canHandleSimilarityRequest(reqClass); + } +} diff --git a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/base/ecore/AbstractComposedSimilaritySwitchComparer.java b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/base/ecore/AbstractComposedSimilaritySwitchComparer.java new file mode 100644 index 0000000000..746a6d9057 --- /dev/null +++ b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/base/ecore/AbstractComposedSimilaritySwitchComparer.java @@ -0,0 +1,23 @@ +package org.splevo.jamopp.diffing.similarity.base.ecore; + +import org.splevo.jamopp.diffing.similarity.base.AbstractSimilarityComparer; +import org.splevo.jamopp.diffing.similarity.base.ISimilarityRequest; +import org.splevo.jamopp.diffing.similarity.base.ISimilarityToolbox; + +/** + * An abstract class provided for integrating future {@link EObject} constructs + * that may complement {@link AbstractSimilarityComparer}. + * + * @author atora + */ +public abstract class AbstractComposedSimilaritySwitchComparer extends AbstractSimilarityComparer { + /** + * Constructs an instance with the given {@link ISimilarityToolbox}. + * + * @param st The {@link ISimilarityToolbox}, to which all incoming + * {@link ISimilarityRequest} instances should be delegated to. + */ + public AbstractComposedSimilaritySwitchComparer(ISimilarityToolbox st) { + super(st); + } +} diff --git a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/base/ecore/AbstractComposedSwitchAdapter.java b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/base/ecore/AbstractComposedSwitchAdapter.java new file mode 100644 index 0000000000..4bc26b9532 --- /dev/null +++ b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/base/ecore/AbstractComposedSwitchAdapter.java @@ -0,0 +1,73 @@ +package org.splevo.jamopp.diffing.similarity.base.ecore; + +import java.util.Collection; +import java.util.List; + +import org.eclipse.emf.ecore.EObject; +import org.eclipse.emf.ecore.util.ComposedSwitch; +import org.eclipse.emf.ecore.util.Switch; + +/** + * An abstract class that complements {@link IComposedSwitchAdapter} with an + * attribute to contain the compare element mentioned there. It also provides + * implementations for the methods from {@link IComposedSwitchAdapter}. + * + * @author atora + */ +public abstract class AbstractComposedSwitchAdapter extends ComposedSwitch implements IComposedSwitchAdapter { + /** The object to compare the switched element with. */ + private EObject compareElement = null; + + /** + * @see {@link ComposedSwitch#ComposedSwitch()} + */ + public AbstractComposedSwitchAdapter() { + + } + + /** + * Constructs an instance with the given switches.
+ *
+ * Meant to be used while testing. + */ + protected AbstractComposedSwitchAdapter(Collection> switches) { + super(switches); + } + + /** + * Constructs an instance with the given switches.
+ *
+ * Meant to be used while testing. + */ + protected AbstractComposedSwitchAdapter(Switch[] switches) { + this(List.of(switches)); + } + + /** + * {@inheritDoc} + * + * @return The object to compare the switched element with. + */ + @Override + public EObject getCompareElement() { + return this.compareElement; + } + + @Override + public Boolean compare(EObject eo1, EObject eo2) { + this.compareElement = eo2; + return this.doSwitch(eo1); + } + + /** + * The default case for not explicitly handled elements always returns null to + * identify the open decision. + * + * @param object The object to compare with the compare element. + * @return null + */ + @Override + public Boolean defaultCase(EObject object) { + return null; + } +} diff --git a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/base/ecore/AbstractComposedSwitchSimilarityChecker.java b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/base/ecore/AbstractComposedSwitchSimilarityChecker.java new file mode 100644 index 0000000000..ffd0c4a856 --- /dev/null +++ b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/base/ecore/AbstractComposedSwitchSimilarityChecker.java @@ -0,0 +1,75 @@ +package org.splevo.jamopp.diffing.similarity.base.ecore; + +import java.util.ArrayList; +import java.util.Collection; + +import org.eclipse.emf.ecore.EObject; +import org.splevo.jamopp.diffing.similarity.base.AbstractSimilarityChecker; +import org.splevo.jamopp.diffing.similarity.base.ISimilarityRequest; +import org.splevo.jamopp.diffing.similarity.base.ISimilarityToolbox; + +/** + * A version of {@link AbstractSimilarityChecker}, which is adapted for + * {@link EObject}. + * + * @author atora + */ +public abstract class AbstractComposedSwitchSimilarityChecker extends AbstractSimilarityChecker { + /** + * Constructs an instance with a given {@link ISimilarityToolbox}. + * + * @param st The {@link ISimilarityToolbox}, to which all incoming + * {@link ISimilarityRequest} instances should be delegated to. + */ + public AbstractComposedSwitchSimilarityChecker(ISimilarityToolbox st) { + super(st); + } + + /** + * Creates and returns a new {@link IComposedSwitchAdapter}. + */ + protected IComposedSwitchAdapter createDefaultNewSwitch() { + return (IComposedSwitchAdapter) this.handleSimilarityRequest(this.makeDefaultSwitchRequest()); + } + + @Override + public Boolean isSimilar(Object element1, Object element2) { + return (Boolean) this.handleSimilarityRequest(new SingleSimilarityCheckRequest((EObject) element1, + (EObject) element2, this.createDefaultNewSwitch())); + } + + @SuppressWarnings("unchecked") + @Override + public Boolean areSimilar(Collection elements1, Collection elements2) { + Collection sss = new ArrayList(); + + // Null check to avoid NullPointerExceptions + if (elements1 == elements2) { + return Boolean.TRUE; + } + else if (elements1 == null ^ elements2 == null) { + return Boolean.FALSE; + } + + if (elements1.size() != elements2.size()) { + return Boolean.FALSE; + } + + for (int i = 0; i < elements1.size(); i++) { + sss.add(this.createDefaultNewSwitch()); + } + + return (Boolean) this.handleSimilarityRequest(new MultipleSimilarityCheckRequest( + (Collection) elements1, (Collection) elements2, sss)); + } + + /** + * Used by other methods in this instance and concrete implementors that create + * switches. This method can be overridden in the concrete implementors to + * create different {@link ISimilarityRequest} instances, which can be used to + * create different switches ({@link IComposedSwitchAdapter} instances). + * + * @return A {@link ISimilarityRequest} to create a new switch. + */ + protected abstract ISimilarityRequest makeDefaultSwitchRequest(); +} diff --git a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/base/ecore/IComposedSimilaritySwitch.java b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/base/ecore/IComposedSimilaritySwitch.java new file mode 100644 index 0000000000..c1875471c3 --- /dev/null +++ b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/base/ecore/IComposedSimilaritySwitch.java @@ -0,0 +1,13 @@ +package org.splevo.jamopp.diffing.similarity.base.ecore; + +import org.splevo.jamopp.diffing.similarity.base.ISimilarityRequestHandler; + +/** + * This interface complements {@link IComposedSwitchAdapter} and bundles it with + * {@link ISimilarityRequestHandler}. + * + * @author atora + */ +public interface IComposedSimilaritySwitch extends IComposedSwitchAdapter, ISimilarityRequestHandler { + +} diff --git a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/base/ecore/IComposedSwitchAdapter.java b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/base/ecore/IComposedSwitchAdapter.java new file mode 100644 index 0000000000..de1f7ed5b8 --- /dev/null +++ b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/base/ecore/IComposedSwitchAdapter.java @@ -0,0 +1,41 @@ +package org.splevo.jamopp.diffing.similarity.base.ecore; + +import org.eclipse.emf.ecore.EObject; + +/** + * An interface that is meant to be implemented by classes, which extend + * {@link org.eclipse.emf.ecore.util.ComposedSwitch}.
+ *
+ * Adapts its implementors to comply with the ComposedSwitch, which requires an + * {@link EObject} instance that remains constant throughout the entire + * similarity checking process. Unlike ComposedSwitch, the implementors will + * provide the {@link #compare(EObject, EObject)} method, which takes two + * {@link EObject} instances and compares them. Due to ComposedSwitch taking + * only one {@link EObject} instance, the second {@link EObject} instance is + * stored in an attribute inside the implementors and is retrieved with + * {@link #getCompareElement()} when needed. + * + * @see {@link IComposedSimilaritySwitch} + * @author atora + */ +public interface IComposedSwitchAdapter { + /** + * Returns the current compare element, which is the second parameter in + * {@link #compare(EObject, EObject)}. + */ + public EObject getCompareElement(); + + /** + * Compares the given {@link EObject} instances and returns the result. + * + * @param eo1 An {@link EObject} instance, which will be compared with eo2. + * @param eo2 The {@link EObject} instance, which will be the compare element. + * @return + *
    + *
  • True, if given {@link EObject} instances are similar + *
  • False, if they are not similar + *
  • Null, if their similarity cannot be decided + *
+ */ + public Boolean compare(EObject eo1, EObject eo2); +} diff --git a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/base/ecore/IInnerSwitch.java b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/base/ecore/IInnerSwitch.java new file mode 100644 index 0000000000..c46c23952b --- /dev/null +++ b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/base/ecore/IInnerSwitch.java @@ -0,0 +1,55 @@ +package org.splevo.jamopp.diffing.similarity.base.ecore; + +import org.eclipse.emf.ecore.EObject; +import org.splevo.jamopp.diffing.similarity.base.ISimilarityRequest; +import org.splevo.jamopp.diffing.similarity.base.ISimilarityRequestHandler; + +/** + * An interface for the classes to implement, which extend + * {@link org.eclipse.emf.ecore.util.Switch} and are nested in + * {@link org.eclipse.emf.ecore.util.ComposedSwitch}. This interface contains + * getters and delegation methods that are mutual among its implementors. + * + * @author atora + */ +public interface IInnerSwitch extends ISimilarityRequestHandler { + /** + * @return The {@link ISimilarityRequestHandler}, to which all incoming + * {@link ISimilarityRequest} instances will be delegated. + */ + public ISimilarityRequestHandler getSimilarityRequestHandler(); + + /** + * @return The {@link IComposedSwitchAdapter} containing this switch + */ + public IComposedSwitchAdapter getContainingSwitch(); + + /** + * @return The current compare element. + * @see {@link IComposedSwitchAdapter} + */ + public default EObject getCompareElement() { + return this.getContainingSwitch().getCompareElement(); + } + + /** + * {@inheritDoc}
+ *
+ * Here, the incoming requests are delegated to + * {@link #getSimilarityRequestHandler()}. + */ + @Override + public default Object handleSimilarityRequest(ISimilarityRequest req) { + return this.getSimilarityRequestHandler().handleSimilarityRequest(req); + } + + /** + * {@inheritDoc}
+ *
+ * Here, this method is delegated to {@link #getSimilarityRequestHandler()}. + */ + @Override + public default boolean canHandleSimilarityRequest(Class reqClass) { + return this.getSimilarityRequestHandler().canHandleSimilarityRequest(reqClass); + } +} diff --git a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/base/ecore/IPositionInnerSwitch.java b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/base/ecore/IPositionInnerSwitch.java new file mode 100644 index 0000000000..b7c349878a --- /dev/null +++ b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/base/ecore/IPositionInnerSwitch.java @@ -0,0 +1,109 @@ +package org.splevo.jamopp.diffing.similarity.base.ecore; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.List; + +import org.eclipse.emf.ecore.EObject; + +/** + * An interface that extends {@link IInnerSwitch} with methods, which are mutual + * among the implementors of {@link IInnerSwitch} that additionally use a flag + * to check statement positions in {@link EObject} instances they compare. + * + * @author atora + */ +public interface IPositionInnerSwitch extends IInnerSwitch { + /** + * @return Whether this switch should take statement positions in + * {@link EObject} instances it compares into account while comparing + * them. + */ + public boolean shouldCheckStatementPosition(); + + /** + * @return Whether the {@link EObject} instances are similar. + * @see {@link ISimilarityChecker} + */ + public default Boolean isSimilar(EObject eo1, EObject eo2) { + return this.isSimilar(eo1, eo2, this.shouldCheckStatementPosition()); + } + + /** + * @param checkStatementPosition See {@link #shouldCheckStatementPosition()} + * @return Whether the {@link EObject} instances are similar, given the + * checkStatementPosition flag. + * @see {@link ISimilarityChecker} + */ + public default Boolean isSimilar(EObject eo1, EObject eo2, boolean checkStatementPosition) { + return (Boolean) this.handleSimilarityRequest( + new SingleSimilarityCheckRequest(eo1, eo2, this.requestNewSwitch(checkStatementPosition))); + } + + /** + * @return Whether the given lists are pairwise similar, using the given list of + * {@link IComposedSwitchAdapter}. + * @see {@link ISimilarityChecker} + */ + public default Boolean areSimilar(Collection eos1, Collection eos2, + Collection sss) { + return (Boolean) this.handleSimilarityRequest(new MultipleSimilarityCheckRequest(eos1, eos2, sss)); + } + + /** + * A version of {@link #areSimilar(Collection, Collection, Collection)} that + * first constructs new switches with the given csps. + * + * @param csps A collection of checkStatementPosition flags (see + * {@link #isSimilar(EObject, EObject, boolean)}). i-th flag in the + * collection meant to be used for similarity checking i-th elements + * of the given {@link EObject} collections. + * @return Whether the given collections are pairwise similar, using the given + * collection of checkStatementPosition flags. + * + * @see {@link ISimilarityChecker} + */ + public default Boolean areSimilar(Collection eos1, Collection eos2, + List csps) { + + Collection sss = new ArrayList(); + + if (csps == null) + return null; + + csps.forEach((csp) -> sss.add((IComposedSwitchAdapter) this.requestNewSwitch(csp))); + + return this.areSimilar(eos1, eos2, sss); + } + + /** + * @return Whether the given collections are pairwise similar, so whether i-th + * element of both collections are similar for {@code i = 0, 1, ...} + * @see {@link ISimilarityChecker} + */ + public default Boolean areSimilar(Collection eos1, Collection eos2) { + var csps = new ArrayList(); + + if (eos1 == eos2) { + return Boolean.TRUE; + } else if (eos1 == null ^ eos2 == null) { + return Boolean.FALSE; + } + + if (eos1.size() != eos2.size()) { + return Boolean.FALSE; + } + + for (int i = 0; i < eos1.size(); i++) { + csps.add(this.shouldCheckStatementPosition()); + } + + return this.areSimilar(eos1, eos2, csps); + } + + /** + * @param checkStatementPosition See {@link #shouldCheckStatementPosition()} + * @return A new switch with the given checkStatementPosition flag. + */ + public IComposedSwitchAdapter requestNewSwitch(boolean checkStatementPosition); +} diff --git a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/base/ecore/MultipleSimilarityCheckHandler.java b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/base/ecore/MultipleSimilarityCheckHandler.java new file mode 100644 index 0000000000..ef7ae110e9 --- /dev/null +++ b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/base/ecore/MultipleSimilarityCheckHandler.java @@ -0,0 +1,99 @@ +package org.splevo.jamopp.diffing.similarity.base.ecore; + +import java.util.Collection; + +import org.eclipse.emf.ecore.EObject; +import org.splevo.jamopp.diffing.similarity.base.ISimilarityRequest; +import org.splevo.jamopp.diffing.similarity.base.ISimilarityRequestHandler; + +/** + * A {@link ISimilarityRequestHandler} that processes + * {@link MultipleSimilarityCheckRequest} instances. + * + * @author atora + */ +public class MultipleSimilarityCheckHandler implements ISimilarityRequestHandler { + /** + * The {@link ISimilarityRequestHandler}, to which + * {@link SingleSimilarityCheckRequest} instances will be delegated. + */ + private ISimilarityRequestHandler srh; + + /** + * Constructs an instance with the given {@link ISimilarityRequestHandler}, + * which is able to handle {@link SingleSimilarityCheckRequest} instances. + * + * @param srh The {@link ISimilarityRequestHandler}, to which + * {@link SingleSimilarityCheckRequest} instances will be delegated. + */ + public MultipleSimilarityCheckHandler(ISimilarityRequestHandler srh) { + this.srh = srh; + } + + /** + * {@inheritDoc}
+ *
+ * Compares the similarity of the {@link EObject} collections from the incoming + * request pairwise. To do so, it uses the switch at index i to compare elements + * at the index i in their respective lists. + * + * @return + *
    + *
  • True (as Boolean), if they are all similar + *
  • False (as Boolean), if a different number of elements is + * submitted or at least one pair of elements is not similar to each + * other + *
  • Null, if sizes of both collections of {@link EObjects} match but + * the amount of provided similarity switches in {@code req} does not + * match their size + *
+ * @see {@link ISimilarityChecker} + */ + @SuppressWarnings("unchecked") + @Override + public Object handleSimilarityRequest(ISimilarityRequest req) { + MultipleSimilarityCheckRequest castedR = (MultipleSimilarityCheckRequest) req; + + Object[] params = (Object[]) castedR.getParams(); + Collection elements1 = (Collection) params[0]; + Collection elements2 = (Collection) params[1]; + Collection sss = (Collection) params[2]; + + // Null check to avoid NullPointerExceptions + if (elements1 == elements2) { + return Boolean.TRUE; + } else if (elements1 == null ^ elements2 == null) { + return Boolean.FALSE; + } + + int size = elements1.size(); + + if (size != elements2.size()) { + return Boolean.FALSE; + } + + if (sss == null || size != sss.size()) { + return null; + } + + var es1 = elements1.toArray(EObject[]::new); + var es2 = elements2.toArray(EObject[]::new); + var ssA = sss.toArray(IComposedSwitchAdapter[]::new); + + for (int i = 0; i < size; i++) { + Boolean childSimilarity = (Boolean) this.srh + .handleSimilarityRequest(new SingleSimilarityCheckRequest(es1[i], es2[i], ssA[i])); + + if (childSimilarity == Boolean.FALSE) { + return Boolean.FALSE; + } + } + + return Boolean.TRUE; + } + + @Override + public boolean canHandleSimilarityRequest(Class reqClass) { + return reqClass.equals(MultipleSimilarityCheckRequest.class); + } +} diff --git a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/base/ecore/MultipleSimilarityCheckRequest.java b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/base/ecore/MultipleSimilarityCheckRequest.java new file mode 100644 index 0000000000..7f6a32a6e3 --- /dev/null +++ b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/base/ecore/MultipleSimilarityCheckRequest.java @@ -0,0 +1,43 @@ +package org.splevo.jamopp.diffing.similarity.base.ecore; + +import java.util.Collection; + +import org.eclipse.emf.ecore.EObject; +import org.splevo.jamopp.diffing.similarity.base.ISimilarityRequest; + +/** + * An {@link ISimilarityRequest} for checking the similarity of 2 collections of + * {@link EObject} instances. + * + * @author atora + */ +public class MultipleSimilarityCheckRequest implements ISimilarityRequest { + private Collection elements1; + private Collection elements2; + private Collection sss; + + /** + * Constructs a request that encapsulates 2 {@link EObject} collections and a + * collection of switches. + * + * @param elements1 The first element collection. + * @param elements2 The second element collection. + * @param sss Collection of switches that will be used for comparing the + * elements. i-th switch in the collection will be used in the + * similarity checking of i-th elements from respective + * collections. + * + * @see {@link MultipleSimilarityCheckHandler#handleSimilarityRequest(ISimilarityRequest)} + */ + public MultipleSimilarityCheckRequest(Collection elements1, + Collection elements2, Collection sss) { + this.elements1 = elements1; + this.elements2 = elements2; + this.sss = sss; + } + + @Override + public Object getParams() { + return new Object[] { this.elements1, this.elements2, this.sss }; + } +} diff --git a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/base/ecore/SingleSimilarityCheckHandler.java b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/base/ecore/SingleSimilarityCheckHandler.java new file mode 100644 index 0000000000..a534cb54e7 --- /dev/null +++ b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/base/ecore/SingleSimilarityCheckHandler.java @@ -0,0 +1,100 @@ +package org.splevo.jamopp.diffing.similarity.base.ecore; + +import org.eclipse.emf.ecore.EObject; +import org.eclipse.emf.ecore.util.EcoreUtil; +import org.splevo.jamopp.diffing.similarity.base.ISimilarityRequest; +import org.splevo.jamopp.diffing.similarity.base.ISimilarityRequestHandler; + +/** + * A {@link ISimilarityRequestHandler} that processes + * {@link SingleSimilarityCheckRequest} instances. + * + * @author atora + */ +public class SingleSimilarityCheckHandler implements ISimilarityRequestHandler { + /** + * Uses the given switch to compute the similarity of the given elements. + * + * @param element1 The first element to check. + * @param element2 The second element to check. + * @param ss The switch that will be used during the similarity checking + * @return TRUE, if they are similar; FALSE if not, NULL if it can't be decided. + */ + public Boolean isSimilar(EObject element1, EObject element2, IComposedSwitchAdapter ss) { + // If no switch is given, similarity cannot be computed + if (ss == null) { + return null; + } + + // check that either both or none of them is null + if (element1 == element2) { + return Boolean.TRUE; + } + + if (onlyOneIsNull(element1, element2)) { + return Boolean.FALSE; + } + + // if a proxy is present try to resolve it + // the other element is used as a context. + // TODO Clarify why it can happen that one proxy is resolved and the other is + // not + // further notes available with the issue + // https://sdqbuild.ipd.kit.edu/jira/browse/SPLEVO-279 + if (element2.eIsProxy() && !element1.eIsProxy()) { + element2 = EcoreUtil.resolve(element2, element1); + } else if (element1.eIsProxy() && !element2.eIsProxy()) { + element1 = EcoreUtil.resolve(element1, element2); + } + + // check the elements to be of the same type + if (!element1.getClass().equals(element2.getClass())) { + return Boolean.FALSE; + } + + // check type specific similarity + return ss.compare(element1, element2); + } + + /** + * Method to check if only one of the provided elements is null. + * + * @param element1 The first element. + * @param element2 The second element. + * @return True if only one element is null and the other is not. + */ + protected Boolean onlyOneIsNull(final EObject element1, final EObject element2) { + Boolean onlyOneIsNull = false; + if (element1 != null && element2 == null) { + onlyOneIsNull = Boolean.TRUE; + } else if (element1 == null && element2 != null) { + onlyOneIsNull = Boolean.TRUE; + } + return onlyOneIsNull; + } + + /** + * {@inheritDoc}
+ *
+ * Check two objects if they are similar. + * + * @param element1 The first element to check. + * @param element2 The second element to check. + * @return TRUE, if they are similar; FALSE if not, NULL if it can't be decided. + */ + @Override + public Object handleSimilarityRequest(ISimilarityRequest req) { + SingleSimilarityCheckRequest castedR = (SingleSimilarityCheckRequest) req; + Object[] params = (Object[]) castedR.getParams(); + EObject elem1 = (EObject) params[0]; + EObject elem2 = (EObject) params[1]; + IComposedSwitchAdapter ss = (IComposedSwitchAdapter) params[2]; + + return this.isSimilar(elem1, elem2, ss); + } + + @Override + public boolean canHandleSimilarityRequest(Class reqClass) { + return reqClass.equals(SingleSimilarityCheckRequest.class); + } +} diff --git a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/base/ecore/SingleSimilarityCheckRequest.java b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/base/ecore/SingleSimilarityCheckRequest.java new file mode 100644 index 0000000000..8542f767f9 --- /dev/null +++ b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/base/ecore/SingleSimilarityCheckRequest.java @@ -0,0 +1,34 @@ +package org.splevo.jamopp.diffing.similarity.base.ecore; + +import org.eclipse.emf.ecore.EObject; +import org.splevo.jamopp.diffing.similarity.base.ISimilarityRequest; + +/** + * An {@link ISimilarityRequest} for checking the similarity of 2 + * {@link EObject} instances. + * + * @author atora + */ +public class SingleSimilarityCheckRequest implements ISimilarityRequest { + private EObject element1; + private EObject element2; + private IComposedSwitchAdapter ss; + + /** + * @param element1 The first element. + * @param element2 The second element. + * @param ss The switch that will be used to compare the elements above. + * + * @see {@link ISimilarityChecker} + */ + public SingleSimilarityCheckRequest(EObject element1, EObject element2, IComposedSwitchAdapter ss) { + this.element1 = element1; + this.element2 = element2; + this.ss = ss; + } + + @Override + public Object getParams() { + return new Object[] { this.element1, this.element2, this.ss }; + } +} diff --git a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/base/ecore/package-info.java b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/base/ecore/package-info.java new file mode 100644 index 0000000000..e2b4a14c36 --- /dev/null +++ b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/base/ecore/package-info.java @@ -0,0 +1,45 @@ +/** + * Complements {@link org.splevo.jamopp.diffing.similarity.base} with further + * similarity checking elements for {@link EObject} and EMFtext.
+ *
+ * The way similarity checking works remains mostly the same as in + * {@link org.splevo.jamopp.diffing.similarity.base}. Here, the similarity + * checking logic mostly resides in {@link org.eclipse.emf.ecore.util.Switch} + * implementations, which are nested in a + * {@link org.eclipse.emf.ecore.util.ComposedSwitch}. The + * {@link ISimilarityToolbox} instead provides the means to compute certain + * operations during similarity checking. The use of {@link ISimilarityToolbox} + * (as well as {@link ISimilarityRequest} and {@link ISimilarityRequestHandler}) + * makes extracting parameters regarding normalisation possible, for instance. + *
+ *
+ * {@link AbstractComposedSwitchSimilarityChecker} and + * {@link AbstractComposedSimilaritySwitchComparer} extend their correspondent + * from the {@link org.splevo.jamopp.diffing.similarity.base} package.
+ *
+ * {@link IComposedSwitchAdapter} and {@link AbstractComposedSwitchAdapter} can + * be used to make the switches similar to the {@link ISimilarityChecker} in + * terms of how similarity checking methods are called. Without them, + * {@link ISimilarityChecker} (as well as the elements it uses) would have to be + * replicated for each {@link EObject} nested within the {@link EObject} + * instances, whose similarity is being checked, due to the similarity checking + * process here being hierarchical.
+ *
+ * {@link IInnerSwitch}, along with {@link AbstractComposedSimilaritySwitch}, + * helps integrate {@link ISimilarityRequestHandler} into switches, which allows + * them to delegate certain similarity checking operations to + * {@link ISimilarityRequestHandler} (such as an {@link ISimilarityToolbox}). + * Additionally, it provides the switches with some default methods to spare + * them from declaring the same methods. {@link IPositionInnerSwitch} extends + * {@link IInnerSwitch} with further methods that can be used by switches, which + * may need to compare nested {@link EObject} instances and/or account for the + * positions of statements (in form of {@link EObject} instances).
+ *
+ * The concrete {@link ISimilarityRequest} implementations in this package can + * be used by {@link AbstractComposedSwitchSimilarityChecker} to translate and + * delegate incoming similarity checking method calls. The + * {@link ISimilarityRequestHandler} implementations in this package can be used + * in the underlying {@link ISimilarityToolbox} instance to handle the said + * requests. + */ +package org.splevo.jamopp.diffing.similarity.base.ecore; \ No newline at end of file From 9415c531b858ef0005f94765cb445ffd43fd5064 Mon Sep 17 00:00:00 2001 From: AlpTorac Date: Mon, 2 Sep 2024 17:32:56 +0200 Subject: [PATCH 05/35] Implement interface For Java-related similarity switches Currently empty Can help separate Java-related similarity switches from the rest in the future --- .../diffing/similarity/IJavaSimilaritySwitch.java | 13 +++++++++++++ 1 file changed, 13 insertions(+) create mode 100644 commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/IJavaSimilaritySwitch.java diff --git a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/IJavaSimilaritySwitch.java b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/IJavaSimilaritySwitch.java new file mode 100644 index 0000000000..cee4ae6d17 --- /dev/null +++ b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/IJavaSimilaritySwitch.java @@ -0,0 +1,13 @@ +package org.splevo.jamopp.diffing.similarity; + +import org.splevo.jamopp.diffing.similarity.base.ecore.IComposedSimilaritySwitch; + +/** + * An interface for switches that can be used to compute the similarity of Java + * model elements. + * + * @author atora + */ +public interface IJavaSimilaritySwitch extends IComposedSimilaritySwitch { + +} \ No newline at end of file From 0f24f6a0aba656eb32441b6afdd71b30a77c2b49 Mon Sep 17 00:00:00 2001 From: AlpTorac Date: Mon, 2 Sep 2024 17:35:13 +0200 Subject: [PATCH 06/35] Implement interface to keep the logging logic for Java-related inner switches in one place --- .../similarity/ILoggableJavaSwitch.java | 82 +++++++++++++++++++ 1 file changed, 82 insertions(+) create mode 100644 commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/ILoggableJavaSwitch.java diff --git a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/ILoggableJavaSwitch.java b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/ILoggableJavaSwitch.java new file mode 100644 index 0000000000..e6a800e299 --- /dev/null +++ b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/ILoggableJavaSwitch.java @@ -0,0 +1,82 @@ +package org.splevo.jamopp.diffing.similarity; + +import org.apache.log4j.Logger; +import org.apache.log4j.Level; + +import com.google.common.base.Strings; + +/** + * An interface to help log the switch classes without having to duplicate + * similar log message structures.
+ *
+ * Log messages' level is set to {@code Priority.INFO} to avoid flooding the + * console and causing memory issues. + * + * @author atora + */ +public interface ILoggableJavaSwitch { + /** + * @return The logger associated with the concrete implementor. + */ + public default Logger getLogger() { + return Logger.getLogger(this.getLoggerName()); + } + + /** + * Can be overridden in implementors to group log messages better. + * + * @return The logger's name, which can be accessed by {@link #getLogger()}. + */ + public default String getLoggerName() { + return this.getLoggerPrefix() + this.getClass().getSimpleName(); + } + + /** + * Can be overridden in implementors to group log messages better. + * + * @return The prefix of the logger's name, which can be accessed by + * {@link #getLogger()}. + */ + public default String getLoggerPrefix() { + return "javaswitch."; + } + + /** + * The version of {@link #logComparison(String, String, String)} for Object. + */ + public default void logComparison(Object subject1, Object subject2, String subjectDesc) { + String s1 = subject1 != null ? subject1.toString() : null; + String s2 = subject2 != null ? subject2.toString() : null; + + this.logComparison(s1, s2, subjectDesc); + } + + /** + * Logs the comparison of the both subjects. + */ + public default void logComparison(String subject1, String subject2, String subjectDesc) { + this.logMessage("Comparing " + subjectDesc + "s (1 vs 2): " + Strings.nullToEmpty(subject1) + " vs " + + Strings.nullToEmpty(subject2)); + } + + /** + * Logs a boolean result with the given subject description. + */ + public default void logResult(boolean result, String subjectDesc) { + this.logMessage("Result of comparing " + subjectDesc + "s: " + result); + } + + /** + * Logs the given message. + */ + public default void logMessage(String msg) { + this.logMessage(msg, Level.INFO); + } + + /** + * Logs the given message at the given level. + */ + public default void logMessage(String msg, Level level) { + this.getLogger().log(level, msg); + } +} From 1545fb2d9ffd065b46268fd034508f1a74864f62 Mon Sep 17 00:00:00 2001 From: AlpTorac Date: Mon, 2 Sep 2024 17:37:35 +0200 Subject: [PATCH 07/35] Implement interface For Java-related inner switches to not implement some mutual operations multiple times --- .../switches/IJavaSimilarityInnerSwitch.java | 67 +++++++++++++++++++ 1 file changed, 67 insertions(+) create mode 100644 commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/IJavaSimilarityInnerSwitch.java diff --git a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/IJavaSimilarityInnerSwitch.java b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/IJavaSimilarityInnerSwitch.java new file mode 100644 index 0000000000..66668b714a --- /dev/null +++ b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/IJavaSimilarityInnerSwitch.java @@ -0,0 +1,67 @@ +package org.splevo.jamopp.diffing.similarity.switches; + +import org.emftext.language.java.commons.NamespaceAwareElement; +import org.splevo.jamopp.diffing.similarity.base.ecore.IInnerSwitch; +import org.splevo.jamopp.diffing.similarity.requests.ClassifierNormalizationRequest; +import org.splevo.jamopp.diffing.similarity.requests.CompilationUnitNormalizationRequest; +import org.splevo.jamopp.diffing.similarity.requests.NamespaceCheckRequest; +import org.splevo.jamopp.diffing.similarity.requests.NamespaceNormalizationRequest; +import org.splevo.jamopp.diffing.similarity.requests.PackageNormalizationRequest; + +/** + * An interface that contains default methods, which create and send + * {@link ISimilarityRequest} instances to {@link ISimilarityRequestHandler} + * instances that are supposed to handle them.
+ *
+ * These methods can be used to spare code duplication in inner switches, which + * need them. + * + * @author atora + */ +public interface IJavaSimilarityInnerSwitch extends IInnerSwitch { + /** + * Sends out a {@link ClassifierNormalizationRequest} and returns the result. + * + * @see {@link #handleSimilarityRequest(org.splevo.jamopp.diffing.similarity.base.ISimilarityRequest)} + */ + public default String normalizeClassifier(String origin) { + return (String) this.handleSimilarityRequest(new ClassifierNormalizationRequest(origin)); + } + + /** + * Sends out a {@link CompilationUnitNormalizationRequest} and returns the + * result. + * + * @see {@link #handleSimilarityRequest(org.splevo.jamopp.diffing.similarity.base.ISimilarityRequest)} + */ + public default String normalizeCompilationUnit(String origin) { + return (String) this.handleSimilarityRequest(new CompilationUnitNormalizationRequest(origin)); + } + + /** + * Sends out a {@link PackageNormalizationRequest} and returns the result. + * + * @see {@link #handleSimilarityRequest(org.splevo.jamopp.diffing.similarity.base.ISimilarityRequest)} + */ + public default String normalizePackage(String origin) { + return (String) this.handleSimilarityRequest(new PackageNormalizationRequest(origin)); + } + + /** + * Sends out a {@link NamespaceNormalizationRequest} and returns the result. + * + * @see {@link #handleSimilarityRequest(org.splevo.jamopp.diffing.similarity.base.ISimilarityRequest)} + */ + public default String normalizeNamespace(String origin) { + return (String) this.handleSimilarityRequest(new NamespaceNormalizationRequest(origin)); + } + + /** + * Sends out a {@link NamespaceCheckRequest} and returns the result. + * + * @see {@link #handleSimilarityRequest(org.splevo.jamopp.diffing.similarity.base.ISimilarityRequest)} + */ + public default Boolean compareNamespacesByPart(NamespaceAwareElement ele1, NamespaceAwareElement ele2) { + return (Boolean) this.handleSimilarityRequest(new NamespaceCheckRequest(ele1, ele2)); + } +} From 7f62d062c5fd317249ef481ec58468fd5e000460 Mon Sep 17 00:00:00 2001 From: AlpTorac Date: Fri, 30 Aug 2024 17:12:23 +0200 Subject: [PATCH 08/35] Export new packages Created for Java-related similarity checking --- .../fi/org.splevo.jamopp.diffing/META-INF/MANIFEST.MF | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/META-INF/MANIFEST.MF b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/META-INF/MANIFEST.MF index 88e5314ed3..4c2532b922 100644 --- a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/META-INF/MANIFEST.MF +++ b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/META-INF/MANIFEST.MF @@ -31,6 +31,11 @@ Export-Package: org.splevo.jamopp.diffing, org.splevo.jamopp.diffing.postprocessor, org.splevo.jamopp.diffing.scope, org.splevo.jamopp.diffing.similarity, + org.splevo.jamopp.diffing.similarity.base, + org.splevo.jamopp.diffing.similarity.base.ecore, + org.splevo.jamopp.diffing.similarity.switches, + org.splevo.jamopp.diffing.similarity.handlers, + org.splevo.jamopp.diffing.similarity.requests, org.splevo.jamopp.diffing.util Bundle-ActivationPolicy: lazy Automatic-Module-Name: org.splevo.jamopp.diffing From 159c4a2c3dfed567c09885167b7b336da920bb74 Mon Sep 17 00:00:00 2001 From: AlpTorac Date: Fri, 30 Aug 2024 16:12:00 +0200 Subject: [PATCH 09/35] Implement interface For PCM-related similarity switches --- .../util/pcm/IPCMRepositorySimilaritySwitch.java | 13 +++++++++++++ 1 file changed, 13 insertions(+) create mode 100644 commit-based-cipm/bundles/fi/cipm.consistency.commitintegration.diff.util/src/cipm/consistency/commitintegration/diff/util/pcm/IPCMRepositorySimilaritySwitch.java diff --git a/commit-based-cipm/bundles/fi/cipm.consistency.commitintegration.diff.util/src/cipm/consistency/commitintegration/diff/util/pcm/IPCMRepositorySimilaritySwitch.java b/commit-based-cipm/bundles/fi/cipm.consistency.commitintegration.diff.util/src/cipm/consistency/commitintegration/diff/util/pcm/IPCMRepositorySimilaritySwitch.java new file mode 100644 index 0000000000..42703c42c5 --- /dev/null +++ b/commit-based-cipm/bundles/fi/cipm.consistency.commitintegration.diff.util/src/cipm/consistency/commitintegration/diff/util/pcm/IPCMRepositorySimilaritySwitch.java @@ -0,0 +1,13 @@ +package cipm.consistency.commitintegration.diff.util.pcm; + +import org.splevo.jamopp.diffing.similarity.base.ecore.IComposedSimilaritySwitch; + +/** + * An interface for switches that can be used to compute the similarity of + * Palladio Component Model (PCM) repositories. + * + * @author atora + */ +public interface IPCMRepositorySimilaritySwitch extends IComposedSimilaritySwitch { + +} From 633ce456ca5e31d544bb41981fe7c9218c049f32 Mon Sep 17 00:00:00 2001 From: AlpTorac Date: Fri, 30 Aug 2024 16:21:45 +0200 Subject: [PATCH 10/35] Implement interface For PCM-related inner similarity switches --- .../diff/util/pcm/switches/IPCMInnerSwitch.java | 17 +++++++++++++++++ 1 file changed, 17 insertions(+) create mode 100644 commit-based-cipm/bundles/fi/cipm.consistency.commitintegration.diff.util/src/cipm/consistency/commitintegration/diff/util/pcm/switches/IPCMInnerSwitch.java diff --git a/commit-based-cipm/bundles/fi/cipm.consistency.commitintegration.diff.util/src/cipm/consistency/commitintegration/diff/util/pcm/switches/IPCMInnerSwitch.java b/commit-based-cipm/bundles/fi/cipm.consistency.commitintegration.diff.util/src/cipm/consistency/commitintegration/diff/util/pcm/switches/IPCMInnerSwitch.java new file mode 100644 index 0000000000..e14418cb89 --- /dev/null +++ b/commit-based-cipm/bundles/fi/cipm.consistency.commitintegration.diff.util/src/cipm/consistency/commitintegration/diff/util/pcm/switches/IPCMInnerSwitch.java @@ -0,0 +1,17 @@ +package cipm.consistency.commitintegration.diff.util.pcm.switches; + +import org.splevo.jamopp.diffing.similarity.base.ecore.IInnerSwitch; + +/** + * An interface that contains default methods, which create and send + * {@link ISimilarityRequest} instances to {@link ISimilarityRequestHandler} + * instances that are supposed to handle them.
+ *
+ * These methods can be used to spare code duplication in inner switches, which + * need them. + * + * @author atora + */ +public interface IPCMInnerSwitch extends IInnerSwitch { + +} From e9bae56df1767ff86529514ba6ab653cc73ea3a5 Mon Sep 17 00:00:00 2001 From: AlpTorac Date: Fri, 30 Aug 2024 16:10:58 +0200 Subject: [PATCH 11/35] Implement similarity comparer For PCM-related similarity checker Use the extracted structure --- .../pcm/PCMRepositorySimilarityComparer.java | 23 +++++++++++++++++++ 1 file changed, 23 insertions(+) create mode 100644 commit-based-cipm/bundles/fi/cipm.consistency.commitintegration.diff.util/src/cipm/consistency/commitintegration/diff/util/pcm/PCMRepositorySimilarityComparer.java diff --git a/commit-based-cipm/bundles/fi/cipm.consistency.commitintegration.diff.util/src/cipm/consistency/commitintegration/diff/util/pcm/PCMRepositorySimilarityComparer.java b/commit-based-cipm/bundles/fi/cipm.consistency.commitintegration.diff.util/src/cipm/consistency/commitintegration/diff/util/pcm/PCMRepositorySimilarityComparer.java new file mode 100644 index 0000000000..e19825f8eb --- /dev/null +++ b/commit-based-cipm/bundles/fi/cipm.consistency.commitintegration.diff.util/src/cipm/consistency/commitintegration/diff/util/pcm/PCMRepositorySimilarityComparer.java @@ -0,0 +1,23 @@ +package cipm.consistency.commitintegration.diff.util.pcm; + +import org.splevo.jamopp.diffing.similarity.base.ecore.AbstractComposedSimilaritySwitchComparer; +import org.splevo.jamopp.diffing.similarity.base.ISimilarityRequest; +import org.splevo.jamopp.diffing.similarity.base.ISimilarityToolbox; + +/** + * Concrete implementation of {@link AbstractComposedSimilaritySwitchComparer} + * for for comparing Palladio Component Model (PCM) repositories. + * + * @author atora + */ +public class PCMRepositorySimilarityComparer extends AbstractComposedSimilaritySwitchComparer { + /** + * Constructs an instance with a given {@link ISimilarityToolbox}. + * + * @param st The {@link ISimilarityToolbox}, to which all incoming + * {@link ISimilarityRequest} instances should be delegated to. + */ + public PCMRepositorySimilarityComparer(ISimilarityToolbox st) { + super(st); + } +} From bb947f6d340e175d035c35ae03080e332e6f7a02 Mon Sep 17 00:00:00 2001 From: AlpTorac Date: Fri, 30 Aug 2024 19:09:22 +0200 Subject: [PATCH 12/35] Implement handler For ID-based similarity checking of PCMs A separate similarity checker implementation will no longer be necessary To be integrated in the following future commits --- .../IDBasedSingleSimilarityCheckHandler.java | 40 +++++++++++++++++++ 1 file changed, 40 insertions(+) create mode 100644 commit-based-cipm/bundles/fi/cipm.consistency.commitintegration.diff.util/src/cipm/consistency/commitintegration/diff/util/pcm/handlers/IDBasedSingleSimilarityCheckHandler.java diff --git a/commit-based-cipm/bundles/fi/cipm.consistency.commitintegration.diff.util/src/cipm/consistency/commitintegration/diff/util/pcm/handlers/IDBasedSingleSimilarityCheckHandler.java b/commit-based-cipm/bundles/fi/cipm.consistency.commitintegration.diff.util/src/cipm/consistency/commitintegration/diff/util/pcm/handlers/IDBasedSingleSimilarityCheckHandler.java new file mode 100644 index 0000000000..87772efc14 --- /dev/null +++ b/commit-based-cipm/bundles/fi/cipm.consistency.commitintegration.diff.util/src/cipm/consistency/commitintegration/diff/util/pcm/handlers/IDBasedSingleSimilarityCheckHandler.java @@ -0,0 +1,40 @@ +package cipm.consistency.commitintegration.diff.util.pcm.handlers; + +import org.eclipse.emf.ecore.EObject; +import org.splevo.jamopp.diffing.similarity.base.ISimilarityRequest; +import org.splevo.jamopp.diffing.similarity.base.ecore.SingleSimilarityCheckHandler; +import org.splevo.jamopp.diffing.similarity.base.ecore.SingleSimilarityCheckRequest; + +import de.uka.ipd.sdq.identifier.Identifier; + +/** + * A {@link SingleSimilarityCheckHandler} sub-class that handles + * {@link SingleSimilarityCheckRequest} instances. + * + * @author atora + */ +public class IDBasedSingleSimilarityCheckHandler extends SingleSimilarityCheckHandler { + /** + * {@inheritDoc}
+ *
+ * Takes the IDs of the elements from {@code req} into account. + */ + @Override + public Object handleSimilarityRequest(ISimilarityRequest req) { + SingleSimilarityCheckRequest castedR = (SingleSimilarityCheckRequest) req; + Object[] params = (Object[]) castedR.getParams(); + EObject element1 = (EObject) params[0]; + EObject element2 = (EObject) params[1]; + + if (element1 instanceof Identifier) { + if (element2 instanceof Identifier) { + Identifier id1 = (Identifier) element1; + Identifier id2 = (Identifier) element2; + return id1.getId().equals(id2.getId()); + } + return Boolean.FALSE; + } + + return super.handleSimilarityRequest(req); + } +} From b133441bbed16d5c0cee061e7e16577791dcca9e Mon Sep 17 00:00:00 2001 From: AlpTorac Date: Mon, 2 Sep 2024 17:41:19 +0200 Subject: [PATCH 13/35] Implement similarity comparer For Java-related similarity checking --- .../similarity/JavaSimilarityComparer.java | 23 +++++++++++++++++++ 1 file changed, 23 insertions(+) create mode 100644 commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/JavaSimilarityComparer.java diff --git a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/JavaSimilarityComparer.java b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/JavaSimilarityComparer.java new file mode 100644 index 0000000000..0b89dd5a0e --- /dev/null +++ b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/JavaSimilarityComparer.java @@ -0,0 +1,23 @@ +package org.splevo.jamopp.diffing.similarity; + +import org.splevo.jamopp.diffing.similarity.base.ISimilarityRequest; +import org.splevo.jamopp.diffing.similarity.base.ISimilarityToolbox; +import org.splevo.jamopp.diffing.similarity.base.ecore.AbstractComposedSimilaritySwitchComparer; + +/** + * Concrete implementation of {@link AbstractComposedSimilaritySwitchComparer} + * for comparing Java elements. + * + * @author atora + */ +public class JavaSimilarityComparer extends AbstractComposedSimilaritySwitchComparer { + /** + * Constructs an instance with the given parameter. + * + * @param st {@link ISimilarityToolbox} to which all incoming + * {@link ISimilarityRequest} instances will be delegated to. + */ + public JavaSimilarityComparer(ISimilarityToolbox st) { + super(st); + } +} From 04e66275f3bfac4f3110427edcef2856da78c6b8 Mon Sep 17 00:00:00 2001 From: AlpTorac Date: Fri, 30 Aug 2024 17:37:46 +0200 Subject: [PATCH 14/35] Implement temporary interface For logging Java-related inner switches --- .../diffing/similarity/ILoggableSwitch.java | 42 +++++++++++++++++++ 1 file changed, 42 insertions(+) create mode 100644 commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/ILoggableSwitch.java diff --git a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/ILoggableSwitch.java b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/ILoggableSwitch.java new file mode 100644 index 0000000000..6cd35a1871 --- /dev/null +++ b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/ILoggableSwitch.java @@ -0,0 +1,42 @@ +package org.splevo.jamopp.diffing.similarity; + +import org.apache.log4j.Logger; +import org.apache.log4j.Level; + +import com.google.common.base.Strings; + +/** + * An interface to help log the switch classes without having to duplicate + * similar log message structures. + *

+ * Log messages' level is set to {@code Priority.INFO} to avoid flooding the console + * and causing memory issues. + * + * @author atora + */ +public interface ILoggableSwitch { + public default Logger getLogger() { + return Logger.getLogger(this.getClass().getSimpleName()); + } + + public default void logComparison(String subject1, String subject2, String subjectDesc) { + this.logMessage("Comparing " + subjectDesc + "s (1 vs 2): " + + Strings.nullToEmpty(subject1) + " vs " + Strings.nullToEmpty(subject2)); + } + + public default void logResult(boolean result, String subjectDesc) { + this.logMessage("Result of comparing " + subjectDesc + "s: " + result); + } + + public default void logMessage(String msg) { + this.logMessage(msg, Level.INFO); + } + + public default void logMessage(String msg, Level p) { + this.getLogger().log(p, msg); + } + + public default void logMessage(String msg, String subjectDesc) { + this.logMessage(msg + " (while comparing" + subjectDesc + ")"); + } +} From 8ea786374bf4544311bdf5b67971fa4a4548eca9 Mon Sep 17 00:00:00 2001 From: AlpTorac Date: Fri, 30 Aug 2024 16:23:59 +0200 Subject: [PATCH 15/35] Add package-info --- .../splevo/jamopp/diffing/similarity/package-info.java | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) diff --git a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/package-info.java b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/package-info.java index ffe7e8d00a..671572a11b 100644 --- a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/package-info.java +++ b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/package-info.java @@ -1,4 +1,10 @@ /** - * Similarity definitions for the JaMoPP difference analysis. + * Contains similarity checking implementation for Java-Model elements generated + * by JaMoPP. Java-Model elements are stored in form of {@link EObject} + * instances and EMFtext is used for similarity checking.
+ *
+ * + * @see {@link org.splevo.jamopp.diffing.similarity.base}
+ * {@link org.splevo.jamopp.diffing.similarity.base.ecore} */ package org.splevo.jamopp.diffing.similarity; From 90f4421e31bfec17a530706d64000860386e2a04 Mon Sep 17 00:00:00 2001 From: AlpTorac Date: Sat, 31 Aug 2024 16:09:40 +0200 Subject: [PATCH 16/35] Relocate package-info --- .../jamopp/diffing/similarity/switches/package-info.java | 4 ++++ 1 file changed, 4 insertions(+) create mode 100644 commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/package-info.java diff --git a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/package-info.java b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/package-info.java new file mode 100644 index 0000000000..fb8ee101b4 --- /dev/null +++ b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/package-info.java @@ -0,0 +1,4 @@ +/** + * Similarity definitions for the JaMoPP difference analysis. + */ +package org.splevo.jamopp.diffing.similarity.switches; \ No newline at end of file From 352d4e21c7142e6aa62e9cc9eec2b44a92ffc55b Mon Sep 17 00:00:00 2001 From: AlpTorac Date: Tue, 3 Sep 2024 16:46:08 +0200 Subject: [PATCH 17/35] (WIP) Copy Java-related inner switches To their own files without modifying them Non-functional commit --- .../switches/AnnotationsSimilaritySwitch.java | 48 +++ .../switches/ArraysSimilaritySwitch.java | 18 + .../switches/ClassifiersSimilaritySwitch.java | 65 ++++ .../switches/CommonsSimilaritySwitch.java | 30 ++ .../switches/ContainersSimilaritySwitch.java | 118 ++++++ .../switches/ExpressionsSimilaritySwitch.java | 222 ++++++++++++ .../switches/GenericsSimilaritySwitch.java | 48 +++ .../switches/ImportsSimilaritySwitch.java | 51 +++ .../InstantiationsSimilaritySwitch.java | 90 +++++ .../switches/LayoutSimilaritySwitch.java | 15 + .../switches/LiteralsSimilaritySwitch.java | 126 +++++++ .../switches/MembersSimilaritySwitch.java | 179 ++++++++++ .../switches/ModifiersSimilaritySwitch.java | 19 + .../switches/ModulesSimilaritySwitch.java | 99 +++++ .../switches/OperatorsSimilaritySwitch.java | 19 + .../switches/ParametersSimilaritySwitch.java | 23 ++ .../switches/ReferencesSimilaritySwitch.java | 154 ++++++++ .../switches/StatementsSimilaritySwitch.java | 337 ++++++++++++++++++ .../switches/TypesSimilaritySwitch.java | 107 ++++++ .../switches/VariablesSimilaritySwitch.java | 52 +++ 20 files changed, 1820 insertions(+) create mode 100644 commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/AnnotationsSimilaritySwitch.java create mode 100644 commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/ArraysSimilaritySwitch.java create mode 100644 commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/ClassifiersSimilaritySwitch.java create mode 100644 commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/CommonsSimilaritySwitch.java create mode 100644 commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/ContainersSimilaritySwitch.java create mode 100644 commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/ExpressionsSimilaritySwitch.java create mode 100644 commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/GenericsSimilaritySwitch.java create mode 100644 commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/ImportsSimilaritySwitch.java create mode 100644 commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/InstantiationsSimilaritySwitch.java create mode 100644 commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/LayoutSimilaritySwitch.java create mode 100644 commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/LiteralsSimilaritySwitch.java create mode 100644 commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/MembersSimilaritySwitch.java create mode 100644 commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/ModifiersSimilaritySwitch.java create mode 100644 commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/ModulesSimilaritySwitch.java create mode 100644 commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/OperatorsSimilaritySwitch.java create mode 100644 commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/ParametersSimilaritySwitch.java create mode 100644 commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/ReferencesSimilaritySwitch.java create mode 100644 commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/StatementsSimilaritySwitch.java create mode 100644 commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/TypesSimilaritySwitch.java create mode 100644 commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/VariablesSimilaritySwitch.java diff --git a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/AnnotationsSimilaritySwitch.java b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/AnnotationsSimilaritySwitch.java new file mode 100644 index 0000000000..7160cbba7e --- /dev/null +++ b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/AnnotationsSimilaritySwitch.java @@ -0,0 +1,48 @@ +package org.splevo.jamopp.diffing.similarity.switches; + +import org.eclipse.emf.ecore.EObject; +import org.emftext.language.java.annotations.AnnotationAttributeSetting; +import org.emftext.language.java.annotations.AnnotationInstance; +import org.emftext.language.java.annotations.util.AnnotationsSwitch; +import org.emftext.language.java.classifiers.Classifier; + +/** + * Similarity decisions for annotation elements. + */ +private class AnnotationsSimilaritySwitch extends AnnotationsSwitch { + + @Override + public Boolean caseAnnotationInstance(AnnotationInstance instance1) { + AnnotationInstance instance2 = (AnnotationInstance) compareElement; + + Classifier class1 = instance1.getAnnotation(); + Classifier class2 = instance2.getAnnotation(); + Boolean classifierSimilarity = similarityChecker.isSimilar(class1, class2); + if (classifierSimilarity == Boolean.FALSE) { + return Boolean.FALSE; + } + + String namespace1 = instance1.getNamespacesAsString(); + String namespace2 = instance2.getNamespacesAsString(); + if (namespace1 == null) { + return (namespace2 == null); + } else { + return (namespace1.equals(namespace2)); + } + } + + @Override + public Boolean caseAnnotationAttributeSetting(AnnotationAttributeSetting setting1) { + AnnotationAttributeSetting setting2 = (AnnotationAttributeSetting) compareElement; + Boolean similarity = similarityChecker.isSimilar(setting1.getAttribute(), setting2.getAttribute()); + if (similarity == Boolean.FALSE) { + return Boolean.FALSE; + } + return Boolean.TRUE; + } + + @Override + public Boolean defaultCase(EObject object) { + return Boolean.TRUE; + } +} diff --git a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/ArraysSimilaritySwitch.java b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/ArraysSimilaritySwitch.java new file mode 100644 index 0000000000..78f910012c --- /dev/null +++ b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/ArraysSimilaritySwitch.java @@ -0,0 +1,18 @@ +package org.splevo.jamopp.diffing.similarity.switches; + +import org.eclipse.emf.ecore.EObject; +import org.emftext.language.java.arrays.util.ArraysSwitch; + +/** + * Similarity decision for array elements. + *

+ * All array elements are strongly typed. They have no identifying attributes. Their location + * and runtime type are assumed to be checked before this switch is called. So nothing to check + * here. + */ +private class ArraysSimilaritySwitch extends ArraysSwitch { + @Override + public Boolean defaultCase(EObject object) { + return Boolean.TRUE; + } +} diff --git a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/ClassifiersSimilaritySwitch.java b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/ClassifiersSimilaritySwitch.java new file mode 100644 index 0000000000..3d727ab6ba --- /dev/null +++ b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/ClassifiersSimilaritySwitch.java @@ -0,0 +1,65 @@ +package org.splevo.jamopp.diffing.similarity.switches; + +import java.util.Map; +import java.util.regex.Pattern; + +import org.emftext.language.java.classifiers.AnonymousClass; +import org.emftext.language.java.classifiers.ConcreteClassifier; +import org.emftext.language.java.classifiers.util.ClassifiersSwitch; +import org.splevo.diffing.util.NormalizationUtil; + +import com.google.common.base.Strings; + +/** + * Similarity decisions for classifier elements. + */ +private class ClassifiersSimilaritySwitch extends ClassifiersSwitch { + + /** + * A list of patterns replace any match in a classifier name with the defined replacement + * string. + */ + private Map classifierNormalizationPatterns = null; + + /** + * Constructor to set the required configurations. + * + * @param classifierNormalizationPatterns + * A list of patterns replace any match in a classifier name with the defined + * replacement string. + */ + public ClassifiersSimilaritySwitch(Map classifierNormalizationPatterns) { + this.classifierNormalizationPatterns = classifierNormalizationPatterns; + } + + /** + * Concrete classifiers such as classes and interface are identified by their location and + * name. The location is considered implicitly. + * + * @param classifier1 + * the classifier to compare with the compareelement + * @return True or false whether they are similar or not. + */ + @Override + public Boolean caseConcreteClassifier(ConcreteClassifier classifier1) { + + ConcreteClassifier classifier2 = (ConcreteClassifier) compareElement; + + String name1 = NormalizationUtil.normalize(classifier1.getQualifiedName(), classifierNormalizationPatterns); + String name2 = Strings.nullToEmpty(classifier2.getQualifiedName()); + + return (name1.equals(name2)); + } + + /** + * Anonymous classes are considered to be similar. + * + * @param anon the anonymous class to compare with the compare element. + * @return true. + */ + @Override + public Boolean caseAnonymousClass(AnonymousClass anon) { + return Boolean.TRUE; + } + +} diff --git a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/CommonsSimilaritySwitch.java b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/CommonsSimilaritySwitch.java new file mode 100644 index 0000000000..4020ce4cf7 --- /dev/null +++ b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/CommonsSimilaritySwitch.java @@ -0,0 +1,30 @@ +package org.splevo.jamopp.diffing.similarity.switches; + +import org.emftext.language.java.commons.NamedElement; +import org.emftext.language.java.commons.util.CommonsSwitch; + +/** + * Similarity decisions for commons elements. + */ +private class CommonsSimilaritySwitch extends CommonsSwitch { + + /** + * Check named element + * + * Similarity is defined by the names of the elements. + * + * @param element1 + * The method call to compare with the compare element. + * @return True As null always means null. + */ + @Override + public Boolean caseNamedElement(NamedElement element1) { + NamedElement element2 = (NamedElement) compareElement; + + if (element1.getName() == null) { + return (element2.getName() == null); + } + + return (element1.getName().equals(element2.getName())); + } +} diff --git a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/ContainersSimilaritySwitch.java b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/ContainersSimilaritySwitch.java new file mode 100644 index 0000000000..36b64f65ad --- /dev/null +++ b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/ContainersSimilaritySwitch.java @@ -0,0 +1,118 @@ +package org.splevo.jamopp.diffing.similarity.switches; + +import java.util.LinkedHashMap; +import java.util.regex.Pattern; + +import org.emftext.language.java.containers.CompilationUnit; +import org.emftext.language.java.containers.Package; +import org.emftext.language.java.containers.util.ContainersSwitch; +import org.splevo.diffing.util.NormalizationUtil; +import org.splevo.jamopp.diffing.util.JaMoPPModelUtil; + +import com.google.common.base.Strings; + +/** + * Similarity decisions for container elements. + */ +private class ContainersSimilaritySwitch extends ContainersSwitch { + + private LinkedHashMap compilationUnitNormalizations = null; + + private LinkedHashMap packageNormalizations = null; + + /** + * Constructor to set the required configurations. + * + * @param compilationUnitNormalizations + * A list of patterns replace any match in a classifier name with the defined + * replacement string. + * @param packageNormalizations + * A list of package normalization patterns. + */ + public ContainersSimilaritySwitch(LinkedHashMap compilationUnitNormalizations, + LinkedHashMap packageNormalizations) { + this.compilationUnitNormalizations = compilationUnitNormalizations; + this.packageNormalizations = packageNormalizations; + } + + /** + * Check the similarity of two CompilationUnits.
+ * Similarity is checked by + *

    + *
  • Comparing their names (including renamings)
    • + *
  • Comparing their namespaces' values (including renamings)
    • + *
+ * Note: CompilationUnit names are full qualified. So it is important to apply classifier as + * well as package renaming normalizations to them. + * + * @param unit1 + * The compilation unit to compare with the compareElement. + * @return True/False whether they are similar or not. + */ + @Override + public Boolean caseCompilationUnit(CompilationUnit unit1) { + + CompilationUnit unit2 = (CompilationUnit) compareElement; + + String name1 = NormalizationUtil.normalize(unit1.getName(), compilationUnitNormalizations); + name1 = NormalizationUtil.normalize(name1, packageNormalizations); + String name2 = unit2.getName(); + if (!name1.equals(name2)) { + return Boolean.FALSE; + } + + String namespaceString1 = NormalizationUtil.normalizeNamespace(unit1.getNamespacesAsString(), + packageNormalizations); + String namespaceString2 = Strings.nullToEmpty(unit2.getNamespacesAsString()); + if (!namespaceString1.equals(namespaceString2)) { + return Boolean.FALSE; + } + + return Boolean.TRUE; + } + + /** + * Check package similarity.
+ * Similarity is checked by + *
    + *
  • full qualified package path
    • + *
+ * + * @param package1 + * The package to compare with the compare element. + * @return True/False if the packages are similar or not. + */ + @Override + public Boolean casePackage(Package package1) { + Package package2 = (Package) compareElement; + + String packagePath1 = JaMoPPModelUtil.buildNamespacePath(package1); + packagePath1 = NormalizationUtil.normalizeNamespace(packagePath1, packageNormalizations); + String packagePath2 = JaMoPPModelUtil.buildNamespacePath(package2); + if (!packagePath1.equals(packagePath2)) { + return Boolean.FALSE; + } + + return Boolean.TRUE; + } + + /** + * Check module similarity.
+ * Similarity is checked by + *
    + *
  • module names
    • + *
+ * + * @param module1 The module to compare with the compare element. + * @return True/False if the modules are similar or not. + */ + @Override + public Boolean caseModule(org.emftext.language.java.containers.Module module1) { + org.emftext.language.java.containers.Module module2 = + (org.emftext.language.java.containers.Module) compareElement; + if (!module1.getName().equals(module2.getName())) { + return Boolean.FALSE; + } + return Boolean.TRUE; + } +} diff --git a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/ExpressionsSimilaritySwitch.java b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/ExpressionsSimilaritySwitch.java new file mode 100644 index 0000000000..45775a316a --- /dev/null +++ b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/ExpressionsSimilaritySwitch.java @@ -0,0 +1,222 @@ +package org.splevo.jamopp.diffing.similarity.switches; + +import org.eclipse.emf.common.util.EList; +import org.eclipse.emf.ecore.EObject; +import org.emftext.language.java.expressions.AdditiveExpression; +import org.emftext.language.java.expressions.AndExpression; +import org.emftext.language.java.expressions.AndExpressionChild; +import org.emftext.language.java.expressions.AssignmentExpression; +import org.emftext.language.java.expressions.AssignmentExpressionChild; +import org.emftext.language.java.expressions.ConditionalAndExpression; +import org.emftext.language.java.expressions.ConditionalAndExpressionChild; +import org.emftext.language.java.expressions.ConditionalOrExpression; +import org.emftext.language.java.expressions.ConditionalOrExpressionChild; +import org.emftext.language.java.expressions.EqualityExpression; +import org.emftext.language.java.expressions.EqualityExpressionChild; +import org.emftext.language.java.expressions.Expression; +import org.emftext.language.java.expressions.InstanceOfExpression; +import org.emftext.language.java.expressions.InstanceOfExpressionChild; +import org.emftext.language.java.expressions.NestedExpression; +import org.emftext.language.java.expressions.RelationExpression; +import org.emftext.language.java.expressions.RelationExpressionChild; +import org.emftext.language.java.expressions.UnaryExpression; +import org.emftext.language.java.expressions.UnaryExpressionChild; +import org.emftext.language.java.expressions.util.ExpressionsSwitch; +import org.emftext.language.java.operators.AssignmentOperator; +import org.emftext.language.java.operators.EqualityOperator; +import org.emftext.language.java.operators.RelationOperator; +import org.emftext.language.java.operators.UnaryOperator; +import org.emftext.language.java.types.TypeReference; + +/** + * Similarity decisions for expression elements. + *

+ * All expression elements are strong typed with no identifying attributes or non-containment + * references. Their location and runtime types are assumed to be checked before this switch is + * called. + *

+ */ +private class ExpressionsSimilaritySwitch extends ExpressionsSwitch { + + @Override + public Boolean caseAssignmentExpression(AssignmentExpression exp1) { + + AssignmentExpression exp2 = (AssignmentExpression) compareElement; + + AssignmentExpressionChild child1 = exp1.getChild(); + AssignmentExpressionChild child2 = exp2.getChild(); + Boolean childSimilarity = similarityChecker.isSimilar(child1, child2); + if (childSimilarity == Boolean.FALSE) { + return Boolean.FALSE; + } + + AssignmentOperator op1 = exp1.getAssignmentOperator(); + AssignmentOperator op2 = exp2.getAssignmentOperator(); + Boolean operatorSimilarity = similarityChecker.isSimilar(op1, op2); + if (operatorSimilarity == Boolean.FALSE) { + return Boolean.FALSE; + } + + Expression value1 = exp1.getValue(); + Expression value2 = exp2.getValue(); + Boolean valueSimilarity = similarityChecker.isSimilar(value1, value2); + if (valueSimilarity == Boolean.FALSE) { + return Boolean.FALSE; + } + + return Boolean.TRUE; + } + + @Override + public Boolean caseEqualityExpression(EqualityExpression exp1) { + EqualityExpression exp2 = (EqualityExpression) compareElement; + + // check operator equality + EList operators1 = exp1.getEqualityOperators(); + EList operators2 = exp2.getEqualityOperators(); + Boolean operatorSimilarity = similarityChecker.areSimilar(operators1, operators2); + if (operatorSimilarity == Boolean.FALSE) { + return Boolean.FALSE; + } + + // check expression equality + EList children1 = exp1.getChildren(); + EList children2 = exp2.getChildren(); + Boolean childSimilarity = similarityChecker.areSimilar(children1, children2); + if (childSimilarity == Boolean.FALSE) { + return Boolean.FALSE; + } + + return Boolean.TRUE; + } + + @Override + public Boolean caseRelationExpression(RelationExpression exp1) { + + RelationExpression exp2 = (RelationExpression) compareElement; + + // check operator equality + EList operators1 = exp1.getRelationOperators(); + EList operators2 = exp2.getRelationOperators(); + Boolean operatorSimilarity = similarityChecker.areSimilar(operators1, operators2); + if (operatorSimilarity == Boolean.FALSE) { + return Boolean.FALSE; + } + + // check expression equality + EList children1 = exp1.getChildren(); + EList children2 = exp2.getChildren(); + Boolean childSimilarity = similarityChecker.areSimilar(children1, children2); + if (childSimilarity == Boolean.FALSE) { + return Boolean.FALSE; + } + + return Boolean.TRUE; + } + + @Override + public Boolean caseAndExpression(AndExpression exp1) { + + AndExpression exp2 = (AndExpression) compareElement; + + // check expression equality + EList children1 = exp1.getChildren(); + EList children2 = exp2.getChildren(); + Boolean childSimilarity = similarityChecker.areSimilar(children1, children2); + if (childSimilarity == Boolean.FALSE) { + return Boolean.FALSE; + } + + return Boolean.TRUE; + } + + @Override + public Boolean caseUnaryExpression(UnaryExpression exp1) { + + UnaryExpression exp2 = (UnaryExpression) compareElement; + + // check operator equality + EList operators1 = exp1.getOperators(); + EList operators2 = exp2.getOperators(); + Boolean operatorSimilarity = similarityChecker.areSimilar(operators1, operators2); + if (operatorSimilarity == Boolean.FALSE) { + return Boolean.FALSE; + } + + // check expression equality + UnaryExpressionChild child1 = exp1.getChild(); + UnaryExpressionChild child2 = exp2.getChild(); + return similarityChecker.isSimilar(child1, child2); + } + + @Override + public Boolean caseAdditiveExpression(AdditiveExpression exp1) { + + AdditiveExpression exp2 = (AdditiveExpression) compareElement; + + Boolean opSimilarity = similarityChecker.areSimilar(exp1.getAdditiveOperators(), exp2.getAdditiveOperators()); + if (opSimilarity == Boolean.FALSE) { + return Boolean.FALSE; + } + + return similarityChecker.areSimilar(exp1.getChildren(), exp2.getChildren()); + } + + @Override + public Boolean caseInstanceOfExpression(InstanceOfExpression exp1) { + + InstanceOfExpression exp2 = (InstanceOfExpression) compareElement; + + // check type equality + TypeReference typeReference1 = exp1.getTypeReference(); + TypeReference typeReference2 = exp2.getTypeReference(); + Boolean typeSimilarity = similarityChecker.isSimilar(typeReference1, typeReference2); + if (typeSimilarity == Boolean.FALSE) { + return Boolean.FALSE; + } + + // check expression equality + InstanceOfExpressionChild child1 = exp1.getChild(); + InstanceOfExpressionChild child2 = exp2.getChild(); + return similarityChecker.isSimilar(child1, child2); + } + + @Override + public Boolean caseConditionalOrExpression(ConditionalOrExpression exp1) { + + ConditionalOrExpression exp2 = (ConditionalOrExpression) compareElement; + + // check expression equality + EList children1 = exp1.getChildren(); + EList children2 = exp2.getChildren(); + return similarityChecker.areSimilar(children1, children2); + } + + @Override + public Boolean caseConditionalAndExpression(ConditionalAndExpression exp1) { + + ConditionalAndExpression exp2 = (ConditionalAndExpression) compareElement; + + // check expression equality + EList children1 = exp1.getChildren(); + EList children2 = exp2.getChildren(); + return similarityChecker.areSimilar(children1, children2); + } + + @Override + public Boolean caseNestedExpression(NestedExpression exp1) { + + NestedExpression exp2 = (NestedExpression) compareElement; + + // check expression equality + Expression childExp1 = exp1.getExpression(); + Expression childExp2 = exp2.getExpression(); + return similarityChecker.isSimilar(childExp1, childExp2); + } + + @Override + public Boolean defaultCase(EObject object) { + return Boolean.TRUE; + } +} + diff --git a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/GenericsSimilaritySwitch.java b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/GenericsSimilaritySwitch.java new file mode 100644 index 0000000000..a998bdbdcc --- /dev/null +++ b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/GenericsSimilaritySwitch.java @@ -0,0 +1,48 @@ +package org.splevo.jamopp.diffing.similarity.switches; + +import org.emftext.language.java.generics.ExtendsTypeArgument; +import org.emftext.language.java.generics.QualifiedTypeArgument; +import org.emftext.language.java.generics.SuperTypeArgument; +import org.emftext.language.java.generics.TypeParameter; +import org.emftext.language.java.generics.UnknownTypeArgument; +import org.emftext.language.java.generics.util.GenericsSwitch; + +/** + * Similarity decisions for the generic elements. + */ +private class GenericsSimilaritySwitch extends GenericsSwitch { + @Override + public Boolean caseQualifiedTypeArgument(QualifiedTypeArgument qta1) { + QualifiedTypeArgument qta2 = (QualifiedTypeArgument) compareElement; + return similarityChecker.isSimilar(qta1.getTypeReference(), qta2.getTypeReference()); + } + + @Override + public Boolean caseSuperTypeArgument(SuperTypeArgument sta1) { + SuperTypeArgument sta2 = (SuperTypeArgument) compareElement; + return similarityChecker.isSimilar(sta1.getSuperType(), sta2.getSuperType()); + } + + @Override + public Boolean caseExtendsTypeArgument(ExtendsTypeArgument eta1) { + ExtendsTypeArgument eta2 = (ExtendsTypeArgument) compareElement; + return similarityChecker.isSimilar(eta1.getExtendType(), eta2.getExtendType()); + } + + @Override + public Boolean caseUnknownTypeArgument(UnknownTypeArgument arg) { + return Boolean.TRUE; + } + + @Override + public Boolean caseTypeParameter(TypeParameter param1) { + TypeParameter param2 = (TypeParameter) compareElement; + + if (!param1.getName().equals(param2.getName())) { + return Boolean.FALSE; + } + + return similarityChecker.areSimilar(param1.getExtendTypes(), param2.getExtendTypes()); + } +} + diff --git a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/ImportsSimilaritySwitch.java b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/ImportsSimilaritySwitch.java new file mode 100644 index 0000000000..37ae5724a3 --- /dev/null +++ b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/ImportsSimilaritySwitch.java @@ -0,0 +1,51 @@ +package org.splevo.jamopp.diffing.similarity.switches; + +import org.emftext.language.java.imports.ClassifierImport; +import org.emftext.language.java.imports.StaticMemberImport; +import org.emftext.language.java.imports.util.ImportsSwitch; +import org.emftext.language.java.references.ReferenceableElement; + +import com.google.common.base.Strings; + +/** + * Similarity decisions for the import elements. + */ +private class ImportsSimilaritySwitch extends ImportsSwitch { + + @Override + public Boolean caseClassifierImport(ClassifierImport import1) { + + ClassifierImport import2 = (ClassifierImport) compareElement; + + Boolean similarity = similarityChecker.isSimilar(import1.getClassifier(), import2.getClassifier()); + if (similarity == Boolean.FALSE) { + return Boolean.FALSE; + } + + String namespace1 = Strings.nullToEmpty(import1.getNamespacesAsString()); + String namespace2 = Strings.nullToEmpty(import2.getNamespacesAsString()); + return (namespace1.equals(namespace2)); + } + + @Override + public Boolean caseStaticMemberImport(StaticMemberImport import1) { + + StaticMemberImport import2 = (StaticMemberImport) compareElement; + + if (import1.getStaticMembers().size() != import2.getStaticMembers().size()) { + return Boolean.FALSE; + } + for (int i = 0; i < import1.getStaticMembers().size(); i++) { + ReferenceableElement member1 = import1.getStaticMembers().get(i); + ReferenceableElement member2 = import2.getStaticMembers().get(i); + Boolean similarity = similarityChecker.isSimilar(member1, member2); + if (similarity == Boolean.FALSE) { + return Boolean.FALSE; + } + } + + String namespace1 = Strings.nullToEmpty(import1.getNamespacesAsString()); + String namespace2 = Strings.nullToEmpty(import2.getNamespacesAsString()); + return (namespace1.equals(namespace2)); + } +} diff --git a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/InstantiationsSimilaritySwitch.java b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/InstantiationsSimilaritySwitch.java new file mode 100644 index 0000000000..a71d20cc53 --- /dev/null +++ b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/InstantiationsSimilaritySwitch.java @@ -0,0 +1,90 @@ +package org.splevo.jamopp.diffing.similarity.switches; + +import org.eclipse.emf.common.util.EList; +import org.eclipse.emf.ecore.EObject; +import org.emftext.language.java.expressions.Expression; +import org.emftext.language.java.instantiations.ExplicitConstructorCall; +import org.emftext.language.java.instantiations.NewConstructorCall; +import org.emftext.language.java.instantiations.util.InstantiationsSwitch; +import org.emftext.language.java.types.Type; + +/** + * Similarity decisions for object instantiation elements. + */ +private class InstantiationsSimilaritySwitch extends InstantiationsSwitch { + + /** + * Check class instance creation similarity.
+ * Similarity is checked by + *
    + *
  • instance type similarity
    • + *
  • number of constructor arguments
    • + *
  • types of constructor arguments
    • + *
+ * + * @param call1 + * The class instance creation to compare with the compare element. + * @return True/False if the class instance creations are similar or not. + */ + @Override + public Boolean caseExplicitConstructorCall(ExplicitConstructorCall call1) { + + ExplicitConstructorCall call2 = (ExplicitConstructorCall) compareElement; + + // check the class instance types + Boolean typeSimilarity = similarityChecker.isSimilar(call1.getCallTarget(), call2.getCallTarget()); + if (typeSimilarity == Boolean.FALSE) { + return Boolean.FALSE; + } + + // check number of type arguments + EList cic1Args = call1.getArguments(); + EList cic2Args = call2.getArguments(); + if (cic1Args.size() != cic2Args.size()) { + return Boolean.FALSE; + } + + // check the argument similarity + for (int i = 0; i < cic1Args.size(); i++) { + Boolean argumentSimilarity = similarityChecker.isSimilar(cic1Args.get(i), cic2Args.get(i)); + if (argumentSimilarity == Boolean.FALSE) { + return Boolean.FALSE; + } + } + + return Boolean.TRUE; + } + + @Override + public Boolean caseNewConstructorCall(NewConstructorCall call1) { + NewConstructorCall call2 = (NewConstructorCall) compareElement; + + Type type1 = call1.getTypeReference().getTarget(); + Type type2 = call2.getTypeReference().getTarget(); + Boolean typeSimilarity = similarityChecker.isSimilar(type1, type2); + if (typeSimilarity == Boolean.FALSE) { + return Boolean.FALSE; + } + + EList types1 = call1.getArguments(); + EList types2 = call2.getArguments(); + if (types1.size() != types2.size()) { + return Boolean.FALSE; + } + for (int i = 0; i < types1.size(); i++) { + Expression argType1 = types1.get(i); + Expression argType2 = types2.get(i); + Boolean similarity = similarityChecker.isSimilar(argType1, argType2); + if (similarity == Boolean.FALSE) { + return Boolean.FALSE; + } + } + + return Boolean.TRUE; + } + + @Override + public Boolean defaultCase(EObject object) { + return Boolean.TRUE; + } +} diff --git a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/LayoutSimilaritySwitch.java b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/LayoutSimilaritySwitch.java new file mode 100644 index 0000000000..9e45e930fb --- /dev/null +++ b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/LayoutSimilaritySwitch.java @@ -0,0 +1,15 @@ +package org.splevo.jamopp.diffing.similarity.switches; + +import org.eclipse.emf.ecore.EObject; +import org.emftext.commons.layout.util.LayoutSwitch; + +/** + * Similarity Decisions for layout information is always true as they are not considered for + * now. + */ +private class LayoutSimilaritySwitch extends LayoutSwitch { + @Override + public Boolean defaultCase(EObject object) { + return Boolean.TRUE; + } +} diff --git a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/LiteralsSimilaritySwitch.java b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/LiteralsSimilaritySwitch.java new file mode 100644 index 0000000000..4fc73f4331 --- /dev/null +++ b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/LiteralsSimilaritySwitch.java @@ -0,0 +1,126 @@ +package org.splevo.jamopp.diffing.similarity.switches; + +import org.eclipse.emf.ecore.EObject; +import org.emftext.language.java.literals.BinaryIntegerLiteral; +import org.emftext.language.java.literals.BinaryLongLiteral; +import org.emftext.language.java.literals.BooleanLiteral; +import org.emftext.language.java.literals.CharacterLiteral; +import org.emftext.language.java.literals.DecimalDoubleLiteral; +import org.emftext.language.java.literals.DecimalFloatLiteral; +import org.emftext.language.java.literals.DecimalIntegerLiteral; +import org.emftext.language.java.literals.DecimalLongLiteral; +import org.emftext.language.java.literals.HexDoubleLiteral; +import org.emftext.language.java.literals.HexFloatLiteral; +import org.emftext.language.java.literals.HexIntegerLiteral; +import org.emftext.language.java.literals.HexLongLiteral; +import org.emftext.language.java.literals.OctalIntegerLiteral; +import org.emftext.language.java.literals.OctalLongLiteral; +import org.emftext.language.java.literals.util.LiteralsSwitch; + +/** + * Similarity decisions for literal elements. + */ +private class LiteralsSimilaritySwitch extends LiteralsSwitch { + + @Override + public Boolean caseBooleanLiteral(BooleanLiteral boolean1) { + BooleanLiteral boolean2 = (BooleanLiteral) compareElement; + return (boolean1.isValue() == boolean2.isValue()); + } + + @Override + public Boolean caseCharacterLiteral(CharacterLiteral char1) { + CharacterLiteral char2 = (CharacterLiteral) compareElement; + return char1.getValue().equals(char2.getValue()); + } + + @Override + public Boolean caseDecimalFloatLiteral(DecimalFloatLiteral float1) { + DecimalFloatLiteral float2 = (DecimalFloatLiteral) compareElement; + return compareDouble(float1.getDecimalValue(), float2.getDecimalValue()); + } + + @Override + public Boolean caseHexFloatLiteral(HexFloatLiteral float1) { + HexFloatLiteral float2 = (HexFloatLiteral) compareElement; + return compareDouble(float1.getHexValue(), float2.getHexValue()); + } + + @Override + public Boolean caseDecimalDoubleLiteral(DecimalDoubleLiteral double1) { + DecimalDoubleLiteral double2 = (DecimalDoubleLiteral) compareElement; + return compareDouble(double1.getDecimalValue(), double2.getDecimalValue()); + } + + @Override + public Boolean caseHexDoubleLiteral(HexDoubleLiteral double1) { + HexDoubleLiteral double2 = (HexDoubleLiteral) compareElement; + return compareDouble(double1.getHexValue(), double2.getHexValue()); + } + + private boolean compareDouble(double d1, double d2) { + return d1 == d2 || Double.isNaN(d1) && Double.isNaN(d2); + } + + @Override + public Boolean caseDecimalIntegerLiteral(DecimalIntegerLiteral int1) { + DecimalIntegerLiteral int2 = (DecimalIntegerLiteral) compareElement; + return (int1.getDecimalValue().equals(int2.getDecimalValue())); + } + + @Override + public Boolean caseHexIntegerLiteral(HexIntegerLiteral int1) { + HexIntegerLiteral int2 = (HexIntegerLiteral) compareElement; + return (int1.getHexValue().equals(int2.getHexValue())); + } + + @Override + public Boolean caseOctalIntegerLiteral(OctalIntegerLiteral int1) { + OctalIntegerLiteral int2 = (OctalIntegerLiteral) compareElement; + return (int1.getOctalValue().equals(int2.getOctalValue())); + } + + @Override + public Boolean caseDecimalLongLiteral(DecimalLongLiteral long1) { + DecimalLongLiteral long2 = (DecimalLongLiteral) compareElement; + return (long1.getDecimalValue().equals(long2.getDecimalValue())); + } + + @Override + public Boolean caseHexLongLiteral(HexLongLiteral long1) { + HexLongLiteral long2 = (HexLongLiteral) compareElement; + return (long1.getHexValue().equals(long2.getHexValue())); + } + + @Override + public Boolean caseOctalLongLiteral(OctalLongLiteral long1) { + OctalLongLiteral long2 = (OctalLongLiteral) compareElement; + return (long1.getOctalValue().equals(long2.getOctalValue())); + } + + @Override + public Boolean caseBinaryLongLiteral(BinaryLongLiteral long1) { + BinaryLongLiteral long2 = (BinaryLongLiteral) compareElement; + return long1.getBinaryValue().equals(long2.getBinaryValue()); + } + + @Override + public Boolean caseBinaryIntegerLiteral(BinaryIntegerLiteral int1) { + BinaryIntegerLiteral int2 = (BinaryIntegerLiteral) compareElement; + return int1.getBinaryValue().equals(int2.getBinaryValue()); + } + + /** + * Check null literal similarity.
+ * + * Null literals are always assumed to be similar. + * + * @param object + * The literal to compare with the compare element. + * @return True As null always means null. + */ + @Override + public Boolean defaultCase(EObject object) { + return Boolean.TRUE; + } +} diff --git a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/MembersSimilaritySwitch.java b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/MembersSimilaritySwitch.java new file mode 100644 index 0000000000..b0f12b3b66 --- /dev/null +++ b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/MembersSimilaritySwitch.java @@ -0,0 +1,179 @@ +package org.splevo.jamopp.diffing.similarity.switches; + +import org.eclipse.emf.common.util.EList; +import org.emftext.language.java.classifiers.AnonymousClass; +import org.emftext.language.java.classifiers.ConcreteClassifier; +import org.emftext.language.java.members.Constructor; +import org.emftext.language.java.members.EnumConstant; +import org.emftext.language.java.members.Member; +import org.emftext.language.java.members.Method; +import org.emftext.language.java.members.util.MembersSwitch; +import org.emftext.language.java.parameters.Parameter; +import org.emftext.language.java.types.Type; + +import com.google.common.base.Strings; + +/** + * Similarity decisions for the member elements. + */ +private class MembersSimilaritySwitch extends MembersSwitch { + + /** + * Check abstract method declaration similarity. Similarity is checked by + *
    + *
  • name
    • + *
  • parameter list size
    • + *
  • parameter types
    • + *
  • name
    • + *
  • container for + *
      + *
    • AbstractTypeDeclaration
      • + *
    • AnonymousClassDeclaration
      • + *
    • Model
      • + *
    + *
    • + *
+ * + * The container must be checked to check similarity for referenced methods. + * + * + * @param method1 + * The abstract method declaration to compare with the compare element. + * @return True/False if the abstract method declarations are similar or not. + */ + @Override + public Boolean caseMethod(Method method1) { + + Method method2 = (Method) compareElement; + + // if methods have different names they are not similar. + if (!method1.getName().equals(method2.getName())) { + return Boolean.FALSE; + } + + if (method1.getParameters().size() != method2.getParameters().size()) { + return Boolean.FALSE; + } + + for (int i = 0; i < method1.getParameters().size(); i++) { + Parameter param1 = method1.getParameters().get(i); + Parameter param2 = method2.getParameters().get(i); + Type type1 = param1.getTypeReference().getTarget(); + Type type2 = param2.getTypeReference().getTarget(); + Boolean typeSimilarity = similarityChecker.isSimilar(type1, type2); + if (typeSimilarity == Boolean.FALSE) { + return Boolean.FALSE; + } + if (param1.getTypeReference().getArrayDimension() != param2.getTypeReference().getArrayDimension()) { + return Boolean.FALSE; + } + } + + /* ************************************** + * methods as members of regular classes + */ + if (method1.getContainingConcreteClassifier() != null) { + ConcreteClassifier type1 = method1.getContainingConcreteClassifier(); + ConcreteClassifier type2 = method2.getContainingConcreteClassifier(); + return similarityChecker.isSimilar(type1, type2); + } + + /* ************************************** + * methods as members of anonymous classes + */ + if (method1.getContainingAnonymousClass() != null) { + AnonymousClass type1 = method1.getContainingAnonymousClass(); + AnonymousClass type2 = method2.getContainingAnonymousClass(); + Boolean typeSimilarity = similarityChecker.isSimilar(type1, type2); + if (typeSimilarity != null) { + return typeSimilarity; + } + } + + logger.warn("MethodDeclaration in unknown container: " + method1.getName() + " : " + + method1.eContainer()); + return super.caseMethod(method1); + } + + /** + * Check constuctor declaration similarity. Similarity is checked by + *
    + *
  • name
    • + *
  • parameter list size
    • + *
  • parameter types
    • + *
  • name
    • + *
  • container for + *
      + *
    • AbstractTypeDeclaration
      • + *
    • AnonymousClassDeclaration
      • + *
    • Model
      • + *
    + *
    • + *
+ * + * The container must be checked to check similarity for referenced methods. + * + * + * @param constructor1 + * The abstract method declaration to compare with the compare element. + * @return True/False if the abstract method declarations are similar or not. + */ + @Override + public Boolean caseConstructor(Constructor constructor1) { + + Constructor constructor2 = (Constructor) compareElement; + + // if methods have different names they are not similar. + if (!constructor1.getName().equals(constructor2.getName())) { + return Boolean.FALSE; + } + + EList params1 = constructor1.getParameters(); + EList params2 = constructor2.getParameters(); + Boolean parameterSimilarity = similarityChecker.areSimilar(params1, params2); + if (parameterSimilarity == Boolean.FALSE) { + return Boolean.FALSE; + } + + /* ************************************** + * methods as members of regular classes + */ + if (constructor1.getContainingConcreteClassifier() != null) { + ConcreteClassifier type1 = constructor1.getContainingConcreteClassifier(); + ConcreteClassifier type2 = constructor2.getContainingConcreteClassifier(); + return similarityChecker.isSimilar(type1, type2); + } + + /* ************************************** + * methods as members of anonymous classes + */ + if (constructor1.getContainingAnonymousClass() != null) { + AnonymousClass type1 = constructor1.getContainingAnonymousClass(); + AnonymousClass type2 = constructor2.getContainingAnonymousClass(); + Boolean typeSimilarity = similarityChecker.isSimilar(type1, type2); + if (typeSimilarity != null) { + return typeSimilarity; + } + } + + logger.warn("ConstructorDeclaration in unknown container: " + constructor1.getName() + " : " + + constructor1.eContainer().getClass().getSimpleName()); + return super.caseConstructor(constructor1); + } + + @Override + public Boolean caseEnumConstant(EnumConstant const1) { + EnumConstant const2 = (EnumConstant) compareElement; + String name1 = Strings.nullToEmpty(const1.getName()); + String name2 = Strings.nullToEmpty(const2.getName()); + return (name1.equals(name2)); + } + + @Override + public Boolean caseMember(Member member1) { + Member member2 = (Member) compareElement; + String name1 = Strings.nullToEmpty(member1.getName()); + String name2 = Strings.nullToEmpty(member2.getName()); + return (name1.equals(name2)); + } +} diff --git a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/ModifiersSimilaritySwitch.java b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/ModifiersSimilaritySwitch.java new file mode 100644 index 0000000000..530c2c4382 --- /dev/null +++ b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/ModifiersSimilaritySwitch.java @@ -0,0 +1,19 @@ +package org.splevo.jamopp.diffing.similarity.switches; + +import org.eclipse.emf.ecore.EObject; +import org.emftext.language.java.modifiers.util.ModifiersSwitch; + +/** + * Similarity decisions for modifier elements. + *

+ * All modifier elements are strong typed with no identifying attributes or non-containment + * references. Their location and runtime types are assumed to be checked before this switch is + * called. + *

+ */ +private class ModifiersSimilaritySwitch extends ModifiersSwitch { + @Override + public Boolean defaultCase(EObject object) { + return Boolean.TRUE; + } +} diff --git a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/ModulesSimilaritySwitch.java b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/ModulesSimilaritySwitch.java new file mode 100644 index 0000000000..427ec1f6d8 --- /dev/null +++ b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/ModulesSimilaritySwitch.java @@ -0,0 +1,99 @@ +package org.splevo.jamopp.diffing.similarity.switches; + +import org.emftext.language.java.modules.AccessProvidingModuleDirective; +import org.emftext.language.java.modules.ModuleReference; +import org.emftext.language.java.modules.ProvidesModuleDirective; +import org.emftext.language.java.modules.RequiresModuleDirective; +import org.emftext.language.java.modules.UsesModuleDirective; +import org.emftext.language.java.modules.util.ModulesSwitch; + +/** + * Similarity Decisions for module elements. + */ +private class ModulesSimilaritySwitch extends ModulesSwitch { + /** + * Check ModuleReference similarity.
+ * Similarity is checked by + *
    + *
  • module names
    • + *
+ * + * @param modRef1 The module reference to compare with the compare element. + * @return True/False if the module references are similar or not. + */ + @Override + public Boolean caseModuleReference(ModuleReference modRef1) { + ModuleReference modRef2 = (ModuleReference) compareElement; + if (compareNamespacesByPart(modRef1, modRef2)) { + return Boolean.TRUE; + } + return Boolean.FALSE; + } + + /** + * Check similarity for access providing module directives.
+ * Similarity is checked by + *
    + *
  • the provided package
    • + *
+ * + * @param dir1 The access providing module directive to compare with the compare element. + * @return True/False if the module directives are similar or not. + */ + @Override + public Boolean caseAccessProvidingModuleDirective(AccessProvidingModuleDirective dir1) { + AccessProvidingModuleDirective dir2 = (AccessProvidingModuleDirective) compareElement; + if (!compareNamespacesByPart(dir1, dir2)) { + return Boolean.FALSE; + } + return Boolean.TRUE; + } + + /** + * Check similarity for require module directives.
+ * Similarity is checked by + *
    + *
  • required modules
    • + *
+ * + * @param dir1 The require module directive to compare with the compare element. + * @return True/False if the module directives are similar or not. + */ + @Override + public Boolean caseRequiresModuleDirective(RequiresModuleDirective dir1) { + RequiresModuleDirective dir2 = (RequiresModuleDirective) compareElement; + return similarityChecker.isSimilar(dir1.getRequiredModule(), dir2.getRequiredModule()); + } + + /** + * Check similarity for provide module directives.
+ * Similarity is checked by + *
    + *
  • provided types
    • + *
+ * + * @param dir1 The provide module directive to compare with the compare element. + * @return True/False if the module directives are similar or not. + */ + @Override + public Boolean caseProvidesModuleDirective(ProvidesModuleDirective dir1) { + ProvidesModuleDirective dir2 = (ProvidesModuleDirective) compareElement; + return similarityChecker.isSimilar(dir1.getTypeReference(), dir2.getTypeReference()); + } + + /** + * Check similarity for use module directives.
+ * Similarity is checked by + *
    + *
  • used types
    • + *
+ * + * @param dir1 The use module directive to compare with the compare element. + * @return True/False if the module directives are similar or not. + */ + @Override + public Boolean caseUsesModuleDirective(UsesModuleDirective dir1) { + UsesModuleDirective dir2 = (UsesModuleDirective) compareElement; + return similarityChecker.isSimilar(dir1.getTypeReference(), dir2.getTypeReference()); + } +} diff --git a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/OperatorsSimilaritySwitch.java b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/OperatorsSimilaritySwitch.java new file mode 100644 index 0000000000..0aaf41a2bf --- /dev/null +++ b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/OperatorsSimilaritySwitch.java @@ -0,0 +1,19 @@ +package org.splevo.jamopp.diffing.similarity.switches; + +import org.eclipse.emf.ecore.EObject; +import org.emftext.language.java.operators.util.OperatorsSwitch; + +/** + * Similarity decisions for operator elements. + *

+ * All operator elements are strong typed with no identifying attributes or non-containment + * references. Their location and runtime types are assumed to be checked before this switch is + * called. + *

+ */ +private class OperatorsSimilaritySwitch extends OperatorsSwitch { + @Override + public Boolean defaultCase(EObject object) { + return Boolean.TRUE; + } +} diff --git a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/ParametersSimilaritySwitch.java b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/ParametersSimilaritySwitch.java new file mode 100644 index 0000000000..1683b3a9a6 --- /dev/null +++ b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/ParametersSimilaritySwitch.java @@ -0,0 +1,23 @@ +package org.splevo.jamopp.diffing.similarity.switches; + +import org.emftext.language.java.parameters.Parameter; +import org.emftext.language.java.parameters.util.ParametersSwitch; + +import com.google.common.base.Strings; + +/** + * Similarity decisions for parameter elements. + *

+ * Parameters are variables and for this named elements. So their names must be checked but no + * more identifying attributes or references exist. + *

+ */ +private class ParametersSimilaritySwitch extends ParametersSwitch { + @Override + public Boolean caseParameter(Parameter param1) { + Parameter param2 = (Parameter) compareElement; + String name1 = Strings.nullToEmpty(param1.getName()); + String name2 = Strings.nullToEmpty(param2.getName()); + return (name1.equals(name2)); + } +} diff --git a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/ReferencesSimilaritySwitch.java b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/ReferencesSimilaritySwitch.java new file mode 100644 index 0000000000..2feaf933ba --- /dev/null +++ b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/ReferencesSimilaritySwitch.java @@ -0,0 +1,154 @@ +package org.splevo.jamopp.diffing.similarity.switches; + +import org.eclipse.emf.ecore.EObject; +import org.emftext.language.java.arrays.ArraySelector; +import org.emftext.language.java.expressions.Expression; +import org.emftext.language.java.references.ElementReference; +import org.emftext.language.java.references.IdentifierReference; +import org.emftext.language.java.references.MethodCall; +import org.emftext.language.java.references.Reference; +import org.emftext.language.java.references.ReferenceableElement; +import org.emftext.language.java.references.StringReference; +import org.emftext.language.java.references.util.ReferencesSwitch; +import org.splevo.jamopp.util.JaMoPPElementUtil; + +/** + * Similarity decisions for reference elements. + */ +private class ReferencesSimilaritySwitch extends ReferencesSwitch { + + @Override + public Boolean caseStringReference(StringReference ref1) { + + StringReference ref2 = (StringReference) compareElement; + if (ref1.getValue() == null) { + return (ref2.getValue() == null); + } + + return (ref1.getValue().equals(ref2.getValue())); + } + + @Override + public Boolean caseIdentifierReference(IdentifierReference ref1) { + + IdentifierReference ref2 = (IdentifierReference) compareElement; + ReferenceableElement target1 = ref1.getTarget(); + ReferenceableElement target2 = ref2.getTarget(); + + // target identity similarity + Boolean similarity = similarityChecker.isSimilar(target1, target2); + if (similarity == Boolean.FALSE) { + return Boolean.FALSE; + } + + if (target1 != null) { + // target container similarity + // check this only if the reference target is located + // in another container than the reference itself. + // Otherwise such a situation would lead to endless loops + // e.g. for for "(Iterator i = c.iterator(); i.hasNext(); ) {" + // Attention: The reference could be encapsulated by an expression! + EObject ref1Container = JaMoPPElementUtil.getFirstContainerNotOfGivenType(ref1, Expression.class, + ArraySelector.class); + EObject ref2Container = JaMoPPElementUtil.getFirstContainerNotOfGivenType(ref2, Expression.class, + ArraySelector.class); + EObject target1Container = target1.eContainer(); + EObject target2Container = target2.eContainer(); + if (target1Container != ref1Container && target2Container != ref2Container + && target1Container != ref1 && target2Container != ref2) { + Boolean containerSimilarity = similarityChecker.isSimilar(target1Container, target2Container); + if (containerSimilarity == Boolean.FALSE) { + return Boolean.FALSE; + } + } + } + + if (ref1.getArraySelectors().size() != ref2.getArraySelectors().size()) { + return Boolean.FALSE; + } + for (int i = 0; i < ref1.getArraySelectors().size(); i++) { + ArraySelector selector1 = ref1.getArraySelectors().get(i); + ArraySelector selector2 = ref2.getArraySelectors().get(i); + Boolean positionSimilarity = similarityChecker.isSimilar(selector1.getPosition(), + selector2.getPosition()); + if (positionSimilarity == Boolean.FALSE) { + return Boolean.FALSE; + } + } + + Reference next1 = ref1.getNext(); + Reference next2 = ref2.getNext(); + Boolean nextSimilarity = similarityChecker.isSimilar(next1, next2); + if (nextSimilarity == Boolean.FALSE) { + return Boolean.FALSE; + } + + return Boolean.TRUE; + } + + /** + * Check element reference similarity.
+ * + * Is checked by the target (the method called). Everything else are containment references + * checked indirectly. + * + * @param ref1 + * The method call to compare with the compare element. + * @return True As null always means null. + */ + @Override + public Boolean caseElementReference(ElementReference ref1) { + ElementReference ref2 = (ElementReference) compareElement; + + Boolean targetSimilarity = similarityChecker.isSimilar(ref1.getTarget(), ref2.getTarget()); + if (targetSimilarity == Boolean.FALSE) { + return Boolean.FALSE; + } + + return Boolean.TRUE; + } + + /** + * Proof method call similarity. + * + * Similarity is decided by the method referenced and the arguments passed by. + * + * @param call1 + * The left / modified method call to compare with the original one. + * @return True/False if the method calls are similar or not. + */ + @Override + public Boolean caseMethodCall(MethodCall call1) { + MethodCall call2 = (MethodCall) compareElement; + + Boolean targetSimilarity = similarityChecker.isSimilar(call1.getTarget(), call2.getTarget()); + if (targetSimilarity == Boolean.FALSE) { + return Boolean.FALSE; + } + + if (call1.getArguments().size() != call2.getArguments().size()) { + return Boolean.FALSE; + } + + for (int i = 0; i < call1.getArguments().size(); i++) { + Expression exp1 = call1.getArguments().get(i); + Expression exp2 = call2.getArguments().get(i); + Boolean argSimilarity = similarityChecker.isSimilar(exp1, exp2); + if (argSimilarity == Boolean.FALSE) { + return Boolean.FALSE; + } + } + + Boolean nextSimilarity = similarityChecker.isSimilar(call1.getNext(), call2.getNext()); + if (nextSimilarity == Boolean.FALSE) { + return Boolean.FALSE; + } + + return Boolean.TRUE; + } + + @Override + public Boolean defaultCase(EObject object) { + return Boolean.TRUE; + } +} diff --git a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/StatementsSimilaritySwitch.java b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/StatementsSimilaritySwitch.java new file mode 100644 index 0000000000..0c9dd5d5ea --- /dev/null +++ b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/StatementsSimilaritySwitch.java @@ -0,0 +1,337 @@ +package org.splevo.jamopp.diffing.similarity.switches; + +import org.eclipse.emf.ecore.EObject; +import org.emftext.language.java.expressions.Expression; +import org.emftext.language.java.parameters.OrdinaryParameter; +import org.emftext.language.java.statements.CatchBlock; +import org.emftext.language.java.statements.Conditional; +import org.emftext.language.java.statements.ExpressionStatement; +import org.emftext.language.java.statements.Jump; +import org.emftext.language.java.statements.JumpLabel; +import org.emftext.language.java.statements.LocalVariableStatement; +import org.emftext.language.java.statements.Return; +import org.emftext.language.java.statements.Statement; +import org.emftext.language.java.statements.StatementListContainer; +import org.emftext.language.java.statements.Switch; +import org.emftext.language.java.statements.SynchronizedBlock; +import org.emftext.language.java.statements.Throw; +import org.emftext.language.java.statements.util.StatementsSwitch; +import org.emftext.language.java.variables.Variable; +import org.splevo.jamopp.util.JaMoPPElementUtil; + +import com.google.common.base.Strings; + +/** + * Similarity decisions for the statement elements. + */ +private class StatementsSimilaritySwitch extends StatementsSwitch { + + /** + * Flag if the position of a statement should be considered for similarity or not. + */ + private boolean checkStatementPosition = true; + + /** + * Constructor to set required configurations. + * + * @param checkStatementPosition + * Flag if the position of a statement should be considered for similarity or + * not. + */ + public StatementsSimilaritySwitch(boolean checkStatementPosition) { + this.checkStatementPosition = checkStatementPosition; + } + + /** + * Check expression statement similarity.
+ * Similarity is checked by + *
    + *
  • similarity statements expressions
    • + *
+ * + * @param statement1 + * The expression statement to compare with the compare element. + * @return True/False if the expression statements are similar or not. + */ + @Override + public Boolean caseExpressionStatement(ExpressionStatement statement1) { + + ExpressionStatement statement2 = (ExpressionStatement) compareElement; + + Expression exp1 = statement1.getExpression(); + Expression exp2 = statement2.getExpression(); + + Boolean expSimilarity = similarityChecker.isSimilar(exp1, exp2); + if (expSimilarity == Boolean.FALSE) { + return Boolean.FALSE; + } + + // check predecessor similarity + if (checkStatementPosition) { + if (differentPredecessor(statement1, statement2) && differentSuccessor(statement1, statement2)) { + return Boolean.FALSE; + } + } + + return Boolean.TRUE; + } + + /** + * Check the similarity of a variable declaration. + * + * The similarity is decided by the declared variables name only. A changed variable type or + * value initialization should lead to a changed statement not a new one. + * + * @param varStmt1 + * The variable to compare with the original / right-side one + * @return True/False if they are similar or not. + */ + @Override + public Boolean caseLocalVariableStatement(LocalVariableStatement varStmt1) { + LocalVariableStatement varStmt2 = (LocalVariableStatement) compareElement; + + Variable var1 = varStmt1.getVariable(); + Variable var2 = varStmt2.getVariable(); + Boolean varSimilarity = similarityChecker.isSimilar(var1, var2); + if (varSimilarity == Boolean.FALSE) { + return Boolean.FALSE; + } + + if (checkStatementPosition) { + varSimilarity = similarityChecker.isSimilar(varStmt1.eContainer(), varStmt2.eContainer(), false); + if (!varSimilarity) { + return Boolean.FALSE; + } + if (differentPredecessor(varStmt1, varStmt2) && differentSuccessor(varStmt1, varStmt2)) { + return Boolean.FALSE; + } + } + + return Boolean.TRUE; + } + + /** + * Check return statement similarity.
+ * Similarity is checked by + *
    + *
  • expressions similarity
    • + *
+ * + * @param returnStatement1 + * The return statement to compare with the compare element. + * @return True/False if the return statements are similar or not. + */ + @Override + public Boolean caseReturn(Return returnStatement1) { + + Return returnStatement2 = (Return) compareElement; + + Expression exp1 = returnStatement1.getReturnValue(); + Expression exp2 = returnStatement2.getReturnValue(); + + return similarityChecker.isSimilar(exp1, exp2); + } + + /** + * Check synchronized statement similarity.
+ * Similarity is checked by + *
    + *
  • expression similarity
    • + *
+ * + * @param statement1 + * The synchronized statement to compare with the compare element. + * @return True/False if the synchronized statements are similar or not. + */ + @Override + public Boolean caseSynchronizedBlock(SynchronizedBlock statement1) { + + SynchronizedBlock statement2 = (SynchronizedBlock) compareElement; + + Expression exp1 = statement1.getLockProvider(); + Expression exp2 = statement2.getLockProvider(); + Boolean similarity = similarityChecker.isSimilar(exp1, exp2); + if (similarity == Boolean.FALSE) { + return Boolean.FALSE; + } + + if (checkStatementPosition) { + if (differentPredecessor(statement1, statement2) && differentSuccessor(statement1, statement2)) { + return Boolean.FALSE; + } + } + return Boolean.TRUE; + } + + /** + * Check throw statement similarity.
+ * + * Only one throw statement can exist at the same code location. As a result the container + * similarity checked implicitly is enough for this. + * + * @param throwStatement1 + * The throw statement to compare with the compare element. + * @return True/False if the throw statements are similar or not. + */ + @Override + public Boolean caseThrow(Throw throwStatement1) { + return Boolean.TRUE; + } + + @Override + public Boolean caseCatchBlock(CatchBlock catchBlock1) { + + CatchBlock catchBlock2 = (CatchBlock) compareElement; + + OrdinaryParameter catchedException1 = catchBlock1.getParameter(); + OrdinaryParameter catchedException2 = catchBlock2.getParameter(); + + Boolean exceptionSimilarity = similarityChecker.isSimilar(catchedException1, catchedException2); + if (exceptionSimilarity == Boolean.FALSE) { + return exceptionSimilarity; + } + + return Boolean.TRUE; + } + + /** + * Check if two conditional statements are similar. + * + * Similarity is checked by: + *
    + *
  • similarity of the expressions
    • + *
+ * + * The then and else statements are not checked as part of the condition statement check + * because this is only about the container if statement similarity. The contained + * statements are checked in a separate step of the compare process if the enclosing + * condition statement matches. + * + * @param conditional1 + * The statement to compare with the compare element. + * @return True/False whether they are similar or not. + */ + @Override + public Boolean caseConditional(Conditional conditional1) { + + Conditional conditional2 = (Conditional) compareElement; + + Expression expression1 = conditional1.getCondition(); + Expression expression2 = conditional2.getCondition(); + Boolean expressionSimilarity = similarityChecker.isSimilar(expression1, expression2); + if (expressionSimilarity == Boolean.FALSE) { + return expressionSimilarity; + } + + return Boolean.TRUE; + } + + @Override + public Boolean caseJump(Jump jump1) { + Jump jump2 = (Jump) compareElement; + + Boolean similarity = similarityChecker.isSimilar(jump1.getTarget(), jump2.getTarget()); + if (similarity == Boolean.FALSE) { + return Boolean.FALSE; + } + + return Boolean.TRUE; + } + + @Override + public Boolean caseJumpLabel(JumpLabel label1) { + + JumpLabel label2 = (JumpLabel) compareElement; + + String name1 = Strings.nullToEmpty(label1.getName()); + String name2 = Strings.nullToEmpty(label2.getName()); + + return (name1.equals(name2)); + } + + @Override + public Boolean caseSwitch(Switch switch1) { + Switch switch2 = (Switch) compareElement; + + return similarityChecker.isSimilar(switch1.getVariable(), switch2.getVariable()); + } + + @Override + public Boolean defaultCase(EObject object) { + return Boolean.TRUE; + } + + /** + * Decide of two statements differ from each other or not. + * + * @param statement1 + * The first statement to compare + * @param statement2 + * The second statement to compare. + * @return True if they differ, null if not. + */ + private boolean differentPredecessor(Statement statement1, Statement statement2) { + Statement pred1 = getPredecessor(statement1); + Statement pred2 = getPredecessor(statement2); + Boolean similarity = similarityChecker.isSimilar(pred1, pred2, false); + return similarity == Boolean.FALSE; + } + + /** + * Check if two statements have differing successor statements. + * + * @param statement1 + * The first statement to check. + * @param statement2 + * The second statement to check. + * @return True if their successor differ, false if not. + */ + private boolean differentSuccessor(Statement statement1, Statement statement2) { + Statement pred1 = getSuccessor(statement1); + Statement pred2 = getSuccessor(statement2); + Boolean similarity = similarityChecker.isSimilar(pred1, pred2, false); + return similarity == Boolean.FALSE; + } + + /** + * Get the predecessor statement of a statement within the parents container statement list.
+ * If a statement is the first, the only one, or the container is not a + * {@link StatementListContainer}, or no predecessor exists, null will be returned. + * + * @param statement + * The statement to get the predecessor for. + * @return The predecessor or null if non exists. + */ + private Statement getPredecessor(Statement statement) { + + int pos = JaMoPPElementUtil.getPositionInContainer(statement); + if (pos > 0) { + StatementListContainer container = (StatementListContainer) statement.eContainer(); + return container.getStatements().get(pos - 1); + } + + return null; + } + + /** + * Get the successor statement of a statement within the parents container statement list.
+ * If a statement is the last, the only one, or the container is not a + * {@link StatementListContainer}, no successor exists, null will be returned. + * + * @param statement + * The statement to get the predecessor for. + * @return The predecessor or null if non exists. + */ + private Statement getSuccessor(Statement statement) { + + int pos = JaMoPPElementUtil.getPositionInContainer(statement); + if (pos != -1) { + StatementListContainer container = (StatementListContainer) statement.eContainer(); + if (container.getStatements().size() > pos + 1) { + return container.getStatements().get(pos + 1); + } + } + + return null; + } +} diff --git a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/TypesSimilaritySwitch.java b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/TypesSimilaritySwitch.java new file mode 100644 index 0000000000..76287588e8 --- /dev/null +++ b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/TypesSimilaritySwitch.java @@ -0,0 +1,107 @@ +package org.splevo.jamopp.diffing.similarity.switches; + +import org.eclipse.emf.ecore.EObject; +import org.emftext.language.java.types.ClassifierReference; +import org.emftext.language.java.types.InferableType; +import org.emftext.language.java.types.NamespaceClassifierReference; +import org.emftext.language.java.types.PrimitiveType; +import org.emftext.language.java.types.TypeReference; +import org.emftext.language.java.types.util.TypesSwitch; +import org.splevo.jamopp.diffing.similarity.SimilarityChecker; + +import com.google.common.base.Strings; + +/** + * Similarity decisions for elements of the types package. + */ +private class TypesSimilaritySwitch extends TypesSwitch { + + /** + * Check element reference similarity.
+ * + * Is checked by the target (the method called). Everything else are containment references + * checked indirectly. + * + * @param ref1 + * The method call to compare with the compare element. + * @return True As null always means null. + */ + @Override + public Boolean caseClassifierReference(ClassifierReference ref1) { + ClassifierReference ref2 = (ClassifierReference) compareElement; + + Boolean targetSimilarity = similarityChecker.isSimilar(ref1.getTarget(), ref2.getTarget()); + if (targetSimilarity == Boolean.FALSE) { + return Boolean.FALSE; + } + + return Boolean.TRUE; + } + + @Override + public Boolean caseTypeReference(TypeReference ref1) { + + TypeReference ref2 = (TypeReference) compareElement; + + Boolean targetSimilarity = similarityChecker.isSimilar(ref1.getTarget(), ref2.getTarget()); + if (targetSimilarity == Boolean.FALSE) { + return Boolean.FALSE; + } + + return Boolean.TRUE; + } + + @Override + public Boolean caseNamespaceClassifierReference(NamespaceClassifierReference ref1) { + + NamespaceClassifierReference ref2 = (NamespaceClassifierReference) compareElement; + + String namespace1 = Strings.nullToEmpty(ref1.getNamespacesAsString()); + String namespace2 = Strings.nullToEmpty(ref2.getNamespacesAsString()); + if (!namespace1.equals(namespace2)) { + return Boolean.FALSE; + } + + ClassifierReference pureRef1 = ref1.getPureClassifierReference(); + ClassifierReference pureRef2 = ref2.getPureClassifierReference(); + + return similarityChecker.isSimilar(pureRef1, pureRef2); + } + + /** + * Primitive types are always similar as their class similarity is assumed before by the + * outer {@link SimilarityChecker}. + * + * Note: The fall back to the default case is not sufficient here, as the common + * TypeReference case would be used before, leading to a loop. + * + * @param type + * The primitive type object. + * @return TRUE + */ + @Override + public Boolean casePrimitiveType(PrimitiveType type) { + return Boolean.TRUE; + } + + /** + * Inferable types are considered to be similar. + * + * @param type The element to compare with the compare element. + * @return true. + */ + @Override + public Boolean caseInferableType(InferableType type) { + return Boolean.TRUE; + } + + /** + * Primitive type elements are strongly typed and the exact type is already checked by the + * outer {@link SimilarityChecker}.
+ * {@inheritDoc} + */ + @Override + public Boolean defaultCase(EObject object) { + return Boolean.TRUE; + } +} diff --git a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/VariablesSimilaritySwitch.java b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/VariablesSimilaritySwitch.java new file mode 100644 index 0000000000..a9946b1986 --- /dev/null +++ b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/VariablesSimilaritySwitch.java @@ -0,0 +1,52 @@ +package org.splevo.jamopp.diffing.similarity.switches; + +import org.emftext.language.java.variables.AdditionalLocalVariable; +import org.emftext.language.java.variables.Variable; +import org.emftext.language.java.variables.util.VariablesSwitch; + +import com.google.common.base.Strings; + +/** + * Similarity decisions for the variable elements. + */ +private class VariablesSimilaritySwitch extends VariablesSwitch { + + /** + * Check variable declaration similarity.
+ * Similarity is checked by + *
    + *
  • variable name
    • + *
  • variable container (name space)
    • + *
+ * + * @param var1 + * The variable declaration to compare with the compare element. + * @return True/False if the variable declarations are similar or not. + */ + @Override + public Boolean caseVariable(Variable var1) { + + Variable var2 = (Variable) compareElement; + + // check the variables name equality + if (!var1.getName().equals(var2.getName())) { + return Boolean.FALSE; + } + + return Boolean.TRUE; + } + + @Override + public Boolean caseAdditionalLocalVariable(AdditionalLocalVariable var1) { + AdditionalLocalVariable var2 = (AdditionalLocalVariable) compareElement; + + // check the variables name equality + String name1 = Strings.nullToEmpty(var1.getName()); + String name2 = Strings.nullToEmpty(var2.getName()); + if (!name1.equals(name2)) { + return Boolean.FALSE; + } + + return Boolean.TRUE; + } +} From 8b470c9034b64ad3925a79a1012a1a7c6118c2c3 Mon Sep 17 00:00:00 2001 From: AlpTorac Date: Mon, 2 Sep 2024 18:26:05 +0200 Subject: [PATCH 18/35] (WIP) Adapt SimilaritySwitch Rename SimilaritySwitch to JavaSimilaritySwitch to indicate its intent better Use the extracted inner switches in the JavaSimilaritySwitch Non-functional commit --- .../similarity/JavaSimilaritySwitch.java | 128 ++ .../diffing/similarity/SimilaritySwitch.java | 1858 ----------------- 2 files changed, 128 insertions(+), 1858 deletions(-) create mode 100644 commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/JavaSimilaritySwitch.java delete mode 100644 commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/SimilaritySwitch.java diff --git a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/JavaSimilaritySwitch.java b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/JavaSimilaritySwitch.java new file mode 100644 index 0000000000..8664c56575 --- /dev/null +++ b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/JavaSimilaritySwitch.java @@ -0,0 +1,128 @@ +/******************************************************************************* + * Copyright (c) 2014 + * + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Eclipse Public License v1.0 + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v10.html + * + * Contributors: + * Benjamin Klatt - initial API and implementation and/or initial documentation + * Martin Armbruster - extension for expanded JaMoPP + *******************************************************************************/ +package org.splevo.jamopp.diffing.similarity; + +import java.util.Collection; + +import org.eclipse.emf.ecore.util.Switch; +import org.splevo.jamopp.diffing.similarity.base.ISimilarityRequestHandler; +import org.splevo.jamopp.diffing.similarity.base.ecore.AbstractComposedSimilaritySwitch; +import org.splevo.jamopp.diffing.similarity.switches.AnnotationsSimilaritySwitch; +import org.splevo.jamopp.diffing.similarity.switches.ArraysSimilaritySwitch; +import org.splevo.jamopp.diffing.similarity.switches.ClassifiersSimilaritySwitch; +import org.splevo.jamopp.diffing.similarity.switches.CommonsSimilaritySwitch; +import org.splevo.jamopp.diffing.similarity.switches.ContainersSimilaritySwitch; +import org.splevo.jamopp.diffing.similarity.switches.ExpressionsSimilaritySwitch; +import org.splevo.jamopp.diffing.similarity.switches.GenericsSimilaritySwitch; +import org.splevo.jamopp.diffing.similarity.switches.ImportsSimilaritySwitch; +import org.splevo.jamopp.diffing.similarity.switches.InstantiationsSimilaritySwitch; +import org.splevo.jamopp.diffing.similarity.switches.LayoutSimilaritySwitch; +import org.splevo.jamopp.diffing.similarity.switches.LiteralsSimilaritySwitch; +import org.splevo.jamopp.diffing.similarity.switches.MembersSimilaritySwitch; +import org.splevo.jamopp.diffing.similarity.switches.ModifiersSimilaritySwitch; +import org.splevo.jamopp.diffing.similarity.switches.ModulesSimilaritySwitch; +import org.splevo.jamopp.diffing.similarity.switches.OperatorsSimilaritySwitch; +import org.splevo.jamopp.diffing.similarity.switches.ParametersSimilaritySwitch; +import org.splevo.jamopp.diffing.similarity.switches.ReferencesSimilaritySwitch; +import org.splevo.jamopp.diffing.similarity.switches.StatementsSimilaritySwitch; +import org.splevo.jamopp.diffing.similarity.switches.TypesSimilaritySwitch; +import org.splevo.jamopp.diffing.similarity.switches.VariablesSimilaritySwitch; + +/** + * Internal switch class to prove element similarity. + * + *

+ * The similarity case methods do not need to check for null values. It is + * assumed that the calling class does a null value check for the elements to + * compare in advanced, such as done by the SimilarityChecker class. + *

+ * + *

+ * Check strategy:
+ * First all "not-similar"-criteria are checked. If none hits, true will be + * returned. + *

+ */ +public class JavaSimilaritySwitch extends AbstractComposedSimilaritySwitch implements IJavaSimilaritySwitch { + /** + * Constructs an instance with the given request handler and the flag. Adds + * default inner switches to the constructed instance. + * + * @param srh The request handler, to which all incoming + * {@link ISimilarityRequest} instances will be + * delegated. + * @param checkStatementPosition The flag, which denotes whether this switch + * should take positions of statements while + * comparing. + */ + public JavaSimilaritySwitch(ISimilarityRequestHandler srh, boolean checkStatementPosition) { + super(srh); + + addSwitch(new AnnotationsSimilaritySwitch(this, checkStatementPosition)); + addSwitch(new ArraysSimilaritySwitch()); + addSwitch(new ClassifiersSimilaritySwitch(this, checkStatementPosition)); + addSwitch(new CommonsSimilaritySwitch(this, checkStatementPosition)); + addSwitch(new ContainersSimilaritySwitch(this, checkStatementPosition)); + addSwitch(new ExpressionsSimilaritySwitch(this, checkStatementPosition)); + addSwitch(new GenericsSimilaritySwitch(this, checkStatementPosition)); + addSwitch(new ImportsSimilaritySwitch(this, checkStatementPosition)); + addSwitch(new InstantiationsSimilaritySwitch(this, checkStatementPosition)); + addSwitch(new LiteralsSimilaritySwitch(this)); + addSwitch(new MembersSimilaritySwitch(this, checkStatementPosition)); + addSwitch(new ModifiersSimilaritySwitch()); + addSwitch(new OperatorsSimilaritySwitch()); + addSwitch(new ParametersSimilaritySwitch(this)); + addSwitch(new ReferencesSimilaritySwitch(this, checkStatementPosition)); + addSwitch(new StatementsSimilaritySwitch(this, checkStatementPosition)); + addSwitch(new TypesSimilaritySwitch(this, checkStatementPosition)); + addSwitch(new VariablesSimilaritySwitch(this)); + addSwitch(new LayoutSimilaritySwitch()); + addSwitch(new ModulesSimilaritySwitch(this, checkStatementPosition)); + } + + /** + * Variation of + * {@link #JavaSimilaritySwitch(ISimilarityRequestHandler, boolean)} that + * constructs an instance without any inner switches. + * + * @see {@link AbstractComposedSimilaritySwitch} + * @see {@link IInnerSwitch} + */ + protected JavaSimilaritySwitch(ISimilarityRequestHandler srh) { + super(srh); + } + + /** + * Variation of + * {@link #JavaSimilaritySwitch(ISimilarityRequestHandler, boolean)} that + * constructs an instance with the given switches. + * + * @see {@link AbstractComposedSimilaritySwitch} + * @see {@link IInnerSwitch} + */ + protected JavaSimilaritySwitch(ISimilarityRequestHandler srh, Collection> switches) { + super(srh, switches); + } + + /** + * Variation of + * {@link #JavaSimilaritySwitch(ISimilarityRequestHandler, boolean)} that + * constructs an instance with the given switches. + * + * @see {@link AbstractComposedSimilaritySwitch} + * @see {@link IInnerSwitch} + */ + protected JavaSimilaritySwitch(ISimilarityRequestHandler srh, Switch[] switches) { + super(srh, switches); + } +} diff --git a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/SimilaritySwitch.java b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/SimilaritySwitch.java deleted file mode 100644 index 83b7b6789e..0000000000 --- a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/SimilaritySwitch.java +++ /dev/null @@ -1,1858 +0,0 @@ -/******************************************************************************* - * Copyright (c) 2014 - * - * All rights reserved. This program and the accompanying materials - * are made available under the terms of the Eclipse Public License v1.0 - * which accompanies this distribution, and is available at - * http://www.eclipse.org/legal/epl-v10.html - * - * Contributors: - * Benjamin Klatt - initial API and implementation and/or initial documentation - * Martin Armbruster - extension for expanded JaMoPP - *******************************************************************************/ -package org.splevo.jamopp.diffing.similarity; - -import java.util.LinkedHashMap; -import java.util.Map; -import java.util.regex.Pattern; - -import org.apache.log4j.Logger; -import org.eclipse.emf.common.util.EList; -import org.eclipse.emf.ecore.EObject; -import org.eclipse.emf.ecore.util.ComposedSwitch; -import org.emftext.commons.layout.util.LayoutSwitch; -import org.emftext.language.java.annotations.AnnotationAttributeSetting; -import org.emftext.language.java.annotations.AnnotationInstance; -import org.emftext.language.java.annotations.util.AnnotationsSwitch; -import org.emftext.language.java.arrays.ArraySelector; -import org.emftext.language.java.arrays.util.ArraysSwitch; -import org.emftext.language.java.classifiers.AnonymousClass; -import org.emftext.language.java.classifiers.Classifier; -import org.emftext.language.java.classifiers.ConcreteClassifier; -import org.emftext.language.java.classifiers.util.ClassifiersSwitch; -import org.emftext.language.java.commons.NamedElement; -import org.emftext.language.java.commons.NamespaceAwareElement; -import org.emftext.language.java.commons.util.CommonsSwitch; -import org.emftext.language.java.containers.CompilationUnit; -import org.emftext.language.java.containers.Package; -import org.emftext.language.java.containers.util.ContainersSwitch; -import org.emftext.language.java.expressions.AdditiveExpression; -import org.emftext.language.java.expressions.AndExpression; -import org.emftext.language.java.expressions.AndExpressionChild; -import org.emftext.language.java.expressions.AssignmentExpression; -import org.emftext.language.java.expressions.AssignmentExpressionChild; -import org.emftext.language.java.expressions.ConditionalAndExpression; -import org.emftext.language.java.expressions.ConditionalAndExpressionChild; -import org.emftext.language.java.expressions.ConditionalOrExpression; -import org.emftext.language.java.expressions.ConditionalOrExpressionChild; -import org.emftext.language.java.expressions.EqualityExpression; -import org.emftext.language.java.expressions.EqualityExpressionChild; -import org.emftext.language.java.expressions.Expression; -import org.emftext.language.java.expressions.InstanceOfExpression; -import org.emftext.language.java.expressions.InstanceOfExpressionChild; -import org.emftext.language.java.expressions.NestedExpression; -import org.emftext.language.java.expressions.RelationExpression; -import org.emftext.language.java.expressions.RelationExpressionChild; -import org.emftext.language.java.expressions.UnaryExpression; -import org.emftext.language.java.expressions.UnaryExpressionChild; -import org.emftext.language.java.expressions.util.ExpressionsSwitch; -import org.emftext.language.java.generics.ExtendsTypeArgument; -import org.emftext.language.java.generics.QualifiedTypeArgument; -import org.emftext.language.java.generics.SuperTypeArgument; -import org.emftext.language.java.generics.TypeParameter; -import org.emftext.language.java.generics.UnknownTypeArgument; -import org.emftext.language.java.generics.util.GenericsSwitch; -import org.emftext.language.java.imports.ClassifierImport; -import org.emftext.language.java.imports.StaticMemberImport; -import org.emftext.language.java.imports.util.ImportsSwitch; -import org.emftext.language.java.instantiations.ExplicitConstructorCall; -import org.emftext.language.java.instantiations.NewConstructorCall; -import org.emftext.language.java.instantiations.util.InstantiationsSwitch; -import org.emftext.language.java.literals.BinaryIntegerLiteral; -import org.emftext.language.java.literals.BinaryLongLiteral; -import org.emftext.language.java.literals.BooleanLiteral; -import org.emftext.language.java.literals.CharacterLiteral; -import org.emftext.language.java.literals.DecimalDoubleLiteral; -import org.emftext.language.java.literals.DecimalFloatLiteral; -import org.emftext.language.java.literals.DecimalIntegerLiteral; -import org.emftext.language.java.literals.DecimalLongLiteral; -import org.emftext.language.java.literals.HexDoubleLiteral; -import org.emftext.language.java.literals.HexFloatLiteral; -import org.emftext.language.java.literals.HexIntegerLiteral; -import org.emftext.language.java.literals.HexLongLiteral; -import org.emftext.language.java.literals.OctalIntegerLiteral; -import org.emftext.language.java.literals.OctalLongLiteral; -import org.emftext.language.java.literals.util.LiteralsSwitch; -import org.emftext.language.java.members.Constructor; -import org.emftext.language.java.members.EnumConstant; -import org.emftext.language.java.members.Member; -import org.emftext.language.java.members.Method; -import org.emftext.language.java.members.util.MembersSwitch; -import org.emftext.language.java.modifiers.util.ModifiersSwitch; -import org.emftext.language.java.modules.AccessProvidingModuleDirective; -import org.emftext.language.java.modules.ModuleReference; -import org.emftext.language.java.modules.ProvidesModuleDirective; -import org.emftext.language.java.modules.RequiresModuleDirective; -import org.emftext.language.java.modules.UsesModuleDirective; -import org.emftext.language.java.modules.util.ModulesSwitch; -import org.emftext.language.java.operators.AssignmentOperator; -import org.emftext.language.java.operators.EqualityOperator; -import org.emftext.language.java.operators.RelationOperator; -import org.emftext.language.java.operators.UnaryOperator; -import org.emftext.language.java.operators.util.OperatorsSwitch; -import org.emftext.language.java.parameters.OrdinaryParameter; -import org.emftext.language.java.parameters.Parameter; -import org.emftext.language.java.parameters.util.ParametersSwitch; -import org.emftext.language.java.references.ElementReference; -import org.emftext.language.java.references.IdentifierReference; -import org.emftext.language.java.references.MethodCall; -import org.emftext.language.java.references.Reference; -import org.emftext.language.java.references.ReferenceableElement; -import org.emftext.language.java.references.StringReference; -import org.emftext.language.java.references.util.ReferencesSwitch; -import org.emftext.language.java.statements.CatchBlock; -import org.emftext.language.java.statements.Conditional; -import org.emftext.language.java.statements.ExpressionStatement; -import org.emftext.language.java.statements.Jump; -import org.emftext.language.java.statements.JumpLabel; -import org.emftext.language.java.statements.LocalVariableStatement; -import org.emftext.language.java.statements.Return; -import org.emftext.language.java.statements.Statement; -import org.emftext.language.java.statements.StatementListContainer; -import org.emftext.language.java.statements.Switch; -import org.emftext.language.java.statements.SynchronizedBlock; -import org.emftext.language.java.statements.Throw; -import org.emftext.language.java.statements.util.StatementsSwitch; -import org.emftext.language.java.types.ClassifierReference; -import org.emftext.language.java.types.InferableType; -import org.emftext.language.java.types.NamespaceClassifierReference; -import org.emftext.language.java.types.PrimitiveType; -import org.emftext.language.java.types.Type; -import org.emftext.language.java.types.TypeReference; -import org.emftext.language.java.types.util.TypesSwitch; -import org.emftext.language.java.variables.AdditionalLocalVariable; -import org.emftext.language.java.variables.Variable; -import org.emftext.language.java.variables.util.VariablesSwitch; -import org.splevo.diffing.util.NormalizationUtil; -import org.splevo.jamopp.diffing.util.JaMoPPModelUtil; -import org.splevo.jamopp.util.JaMoPPElementUtil; - -import com.google.common.base.Strings; - -/** - * Internal switch class to prove element similarity. - * - *

- * The similarity case methods do not need to check for null values. It is assumed that the calling - * class does a null value check for the elements to compare in advanced, such as done by the - * SimilarityChecker class. - *

- * - *

- * Check strategy:
- * First all "not-similar"-criteria are checked. If none hits, true will be returned. - *

- */ -public class SimilaritySwitch extends ComposedSwitch { - - /** The logger for this class. */ - private Logger logger = Logger.getLogger(SimilaritySwitch.class); - - /** The object to compare the switched element with. */ - private EObject compareElement = null; - - /** Internal similarity checker to compare container elements etc. */ - private SimilarityChecker similarityChecker = null; - - /** - * Constructor requiring the element to compare with. - * - * @param compareElement - * The right-side / original element to check the similarity against. - * @param checkStatementPosition - * Flag if the similarity check should consider the position of a statement or not. - * @param classifierNormalizations - * A list of patterns replace any match in a classifier name with the defined - * replacement string. - * @param compilationUnitNormalizations - * A list of patterns replace any match in a compilation unit name with the defined - * replacement string. - * @param packageNormalizations - * A list of package normalization patterns. - */ - public SimilaritySwitch(EObject compareElement, boolean checkStatementPosition, - LinkedHashMap classifierNormalizations, - LinkedHashMap compilationUnitNormalizations, - LinkedHashMap packageNormalizations) { - this.similarityChecker = new SimilarityChecker(classifierNormalizations, compilationUnitNormalizations, - packageNormalizations); - this.similarityChecker.setCheckStatementPositionOnDefault(checkStatementPosition); - this.compareElement = compareElement; - addSwitch(new AnnotationsSimilaritySwitch()); - addSwitch(new ArraysSimilaritySwitch()); - addSwitch(new ClassifiersSimilaritySwitch(classifierNormalizations)); - addSwitch(new CommonsSimilaritySwitch()); - addSwitch(new ContainersSimilaritySwitch(compilationUnitNormalizations, packageNormalizations)); - addSwitch(new ExpressionsSimilaritySwitch()); - addSwitch(new GenericsSimilaritySwitch()); - addSwitch(new ImportsSimilaritySwitch()); - addSwitch(new InstantiationsSimilaritySwitch()); - addSwitch(new LiteralsSimilaritySwitch()); - addSwitch(new MembersSimilaritySwitch()); - addSwitch(new ModifiersSimilaritySwitch()); - addSwitch(new OperatorsSimilaritySwitch()); - addSwitch(new ParametersSimilaritySwitch()); - addSwitch(new ReferencesSimilaritySwitch()); - addSwitch(new StatementsSimilaritySwitch(checkStatementPosition)); - addSwitch(new TypesSimilaritySwitch()); - addSwitch(new VariablesSimilaritySwitch()); - addSwitch(new LayoutSimilaritySwitch()); - addSwitch(new ModulesSimilaritySwitch()); - } - - /** - * Similarity decisions for annotation elements. - */ - private class AnnotationsSimilaritySwitch extends AnnotationsSwitch { - - @Override - public Boolean caseAnnotationInstance(AnnotationInstance instance1) { - AnnotationInstance instance2 = (AnnotationInstance) compareElement; - - Classifier class1 = instance1.getAnnotation(); - Classifier class2 = instance2.getAnnotation(); - Boolean classifierSimilarity = similarityChecker.isSimilar(class1, class2); - if (classifierSimilarity == Boolean.FALSE) { - return Boolean.FALSE; - } - - String namespace1 = instance1.getNamespacesAsString(); - String namespace2 = instance2.getNamespacesAsString(); - if (namespace1 == null) { - return (namespace2 == null); - } else { - return (namespace1.equals(namespace2)); - } - } - - @Override - public Boolean caseAnnotationAttributeSetting(AnnotationAttributeSetting setting1) { - AnnotationAttributeSetting setting2 = (AnnotationAttributeSetting) compareElement; - Boolean similarity = similarityChecker.isSimilar(setting1.getAttribute(), setting2.getAttribute()); - if (similarity == Boolean.FALSE) { - return Boolean.FALSE; - } - return Boolean.TRUE; - } - - @Override - public Boolean defaultCase(EObject object) { - return Boolean.TRUE; - } - } - - /** - * Similarity decision for array elements. - *

- * All array elements are strongly typed. They have no identifying attributes. Their location - * and runtime type are assumed to be checked before this switch is called. So nothing to check - * here. - */ - private class ArraysSimilaritySwitch extends ArraysSwitch { - @Override - public Boolean defaultCase(EObject object) { - return Boolean.TRUE; - } - } - - /** - * Similarity decisions for classifier elements. - */ - private class ClassifiersSimilaritySwitch extends ClassifiersSwitch { - - /** - * A list of patterns replace any match in a classifier name with the defined replacement - * string. - */ - private Map classifierNormalizationPatterns = null; - - /** - * Constructor to set the required configurations. - * - * @param classifierNormalizationPatterns - * A list of patterns replace any match in a classifier name with the defined - * replacement string. - */ - public ClassifiersSimilaritySwitch(Map classifierNormalizationPatterns) { - this.classifierNormalizationPatterns = classifierNormalizationPatterns; - } - - /** - * Concrete classifiers such as classes and interface are identified by their location and - * name. The location is considered implicitly. - * - * @param classifier1 - * the classifier to compare with the compareelement - * @return True or false whether they are similar or not. - */ - @Override - public Boolean caseConcreteClassifier(ConcreteClassifier classifier1) { - - ConcreteClassifier classifier2 = (ConcreteClassifier) compareElement; - - String name1 = NormalizationUtil.normalize(classifier1.getQualifiedName(), classifierNormalizationPatterns); - String name2 = Strings.nullToEmpty(classifier2.getQualifiedName()); - - return (name1.equals(name2)); - } - - /** - * Anonymous classes are considered to be similar. - * - * @param anon the anonymous class to compare with the compare element. - * @return true. - */ - @Override - public Boolean caseAnonymousClass(AnonymousClass anon) { - return Boolean.TRUE; - } - - } - - /** - * Similarity decisions for commons elements. - */ - private class CommonsSimilaritySwitch extends CommonsSwitch { - - /** - * Check named element - * - * Similarity is defined by the names of the elements. - * - * @param element1 - * The method call to compare with the compare element. - * @return True As null always means null. - */ - @Override - public Boolean caseNamedElement(NamedElement element1) { - NamedElement element2 = (NamedElement) compareElement; - - if (element1.getName() == null) { - return (element2.getName() == null); - } - - return (element1.getName().equals(element2.getName())); - } - } - - /** - * Similarity decisions for container elements. - */ - private class ContainersSimilaritySwitch extends ContainersSwitch { - - private LinkedHashMap compilationUnitNormalizations = null; - - private LinkedHashMap packageNormalizations = null; - - /** - * Constructor to set the required configurations. - * - * @param compilationUnitNormalizations - * A list of patterns replace any match in a classifier name with the defined - * replacement string. - * @param packageNormalizations - * A list of package normalization patterns. - */ - public ContainersSimilaritySwitch(LinkedHashMap compilationUnitNormalizations, - LinkedHashMap packageNormalizations) { - this.compilationUnitNormalizations = compilationUnitNormalizations; - this.packageNormalizations = packageNormalizations; - } - - /** - * Check the similarity of two CompilationUnits.
- * Similarity is checked by - *

    - *
  • Comparing their names (including renamings)
    • - *
  • Comparing their namespaces' values (including renamings)
    • - *
- * Note: CompilationUnit names are full qualified. So it is important to apply classifier as - * well as package renaming normalizations to them. - * - * @param unit1 - * The compilation unit to compare with the compareElement. - * @return True/False whether they are similar or not. - */ - @Override - public Boolean caseCompilationUnit(CompilationUnit unit1) { - - CompilationUnit unit2 = (CompilationUnit) compareElement; - - String name1 = NormalizationUtil.normalize(unit1.getName(), compilationUnitNormalizations); - name1 = NormalizationUtil.normalize(name1, packageNormalizations); - String name2 = unit2.getName(); - if (!name1.equals(name2)) { - return Boolean.FALSE; - } - - String namespaceString1 = NormalizationUtil.normalizeNamespace(unit1.getNamespacesAsString(), - packageNormalizations); - String namespaceString2 = Strings.nullToEmpty(unit2.getNamespacesAsString()); - if (!namespaceString1.equals(namespaceString2)) { - return Boolean.FALSE; - } - - return Boolean.TRUE; - } - - /** - * Check package similarity.
- * Similarity is checked by - *
    - *
  • full qualified package path
    • - *
- * - * @param package1 - * The package to compare with the compare element. - * @return True/False if the packages are similar or not. - */ - @Override - public Boolean casePackage(Package package1) { - Package package2 = (Package) compareElement; - - String packagePath1 = JaMoPPModelUtil.buildNamespacePath(package1); - packagePath1 = NormalizationUtil.normalizeNamespace(packagePath1, packageNormalizations); - String packagePath2 = JaMoPPModelUtil.buildNamespacePath(package2); - if (!packagePath1.equals(packagePath2)) { - return Boolean.FALSE; - } - - return Boolean.TRUE; - } - - /** - * Check module similarity.
- * Similarity is checked by - *
    - *
  • module names
    • - *
- * - * @param module1 The module to compare with the compare element. - * @return True/False if the modules are similar or not. - */ - @Override - public Boolean caseModule(org.emftext.language.java.containers.Module module1) { - org.emftext.language.java.containers.Module module2 = - (org.emftext.language.java.containers.Module) compareElement; - if (!module1.getName().equals(module2.getName())) { - return Boolean.FALSE; - } - return Boolean.TRUE; - } - } - - /** - * Similarity decisions for expression elements. - *

- * All expression elements are strong typed with no identifying attributes or non-containment - * references. Their location and runtime types are assumed to be checked before this switch is - * called. - *

- */ - private class ExpressionsSimilaritySwitch extends ExpressionsSwitch { - - @Override - public Boolean caseAssignmentExpression(AssignmentExpression exp1) { - - AssignmentExpression exp2 = (AssignmentExpression) compareElement; - - AssignmentExpressionChild child1 = exp1.getChild(); - AssignmentExpressionChild child2 = exp2.getChild(); - Boolean childSimilarity = similarityChecker.isSimilar(child1, child2); - if (childSimilarity == Boolean.FALSE) { - return Boolean.FALSE; - } - - AssignmentOperator op1 = exp1.getAssignmentOperator(); - AssignmentOperator op2 = exp2.getAssignmentOperator(); - Boolean operatorSimilarity = similarityChecker.isSimilar(op1, op2); - if (operatorSimilarity == Boolean.FALSE) { - return Boolean.FALSE; - } - - Expression value1 = exp1.getValue(); - Expression value2 = exp2.getValue(); - Boolean valueSimilarity = similarityChecker.isSimilar(value1, value2); - if (valueSimilarity == Boolean.FALSE) { - return Boolean.FALSE; - } - - return Boolean.TRUE; - } - - @Override - public Boolean caseEqualityExpression(EqualityExpression exp1) { - EqualityExpression exp2 = (EqualityExpression) compareElement; - - // check operator equality - EList operators1 = exp1.getEqualityOperators(); - EList operators2 = exp2.getEqualityOperators(); - Boolean operatorSimilarity = similarityChecker.areSimilar(operators1, operators2); - if (operatorSimilarity == Boolean.FALSE) { - return Boolean.FALSE; - } - - // check expression equality - EList children1 = exp1.getChildren(); - EList children2 = exp2.getChildren(); - Boolean childSimilarity = similarityChecker.areSimilar(children1, children2); - if (childSimilarity == Boolean.FALSE) { - return Boolean.FALSE; - } - - return Boolean.TRUE; - } - - @Override - public Boolean caseRelationExpression(RelationExpression exp1) { - - RelationExpression exp2 = (RelationExpression) compareElement; - - // check operator equality - EList operators1 = exp1.getRelationOperators(); - EList operators2 = exp2.getRelationOperators(); - Boolean operatorSimilarity = similarityChecker.areSimilar(operators1, operators2); - if (operatorSimilarity == Boolean.FALSE) { - return Boolean.FALSE; - } - - // check expression equality - EList children1 = exp1.getChildren(); - EList children2 = exp2.getChildren(); - Boolean childSimilarity = similarityChecker.areSimilar(children1, children2); - if (childSimilarity == Boolean.FALSE) { - return Boolean.FALSE; - } - - return Boolean.TRUE; - } - - @Override - public Boolean caseAndExpression(AndExpression exp1) { - - AndExpression exp2 = (AndExpression) compareElement; - - // check expression equality - EList children1 = exp1.getChildren(); - EList children2 = exp2.getChildren(); - Boolean childSimilarity = similarityChecker.areSimilar(children1, children2); - if (childSimilarity == Boolean.FALSE) { - return Boolean.FALSE; - } - - return Boolean.TRUE; - } - - @Override - public Boolean caseUnaryExpression(UnaryExpression exp1) { - - UnaryExpression exp2 = (UnaryExpression) compareElement; - - // check operator equality - EList operators1 = exp1.getOperators(); - EList operators2 = exp2.getOperators(); - Boolean operatorSimilarity = similarityChecker.areSimilar(operators1, operators2); - if (operatorSimilarity == Boolean.FALSE) { - return Boolean.FALSE; - } - - // check expression equality - UnaryExpressionChild child1 = exp1.getChild(); - UnaryExpressionChild child2 = exp2.getChild(); - return similarityChecker.isSimilar(child1, child2); - } - - @Override - public Boolean caseAdditiveExpression(AdditiveExpression exp1) { - - AdditiveExpression exp2 = (AdditiveExpression) compareElement; - - Boolean opSimilarity = similarityChecker.areSimilar(exp1.getAdditiveOperators(), exp2.getAdditiveOperators()); - if (opSimilarity == Boolean.FALSE) { - return Boolean.FALSE; - } - - return similarityChecker.areSimilar(exp1.getChildren(), exp2.getChildren()); - } - - @Override - public Boolean caseInstanceOfExpression(InstanceOfExpression exp1) { - - InstanceOfExpression exp2 = (InstanceOfExpression) compareElement; - - // check type equality - TypeReference typeReference1 = exp1.getTypeReference(); - TypeReference typeReference2 = exp2.getTypeReference(); - Boolean typeSimilarity = similarityChecker.isSimilar(typeReference1, typeReference2); - if (typeSimilarity == Boolean.FALSE) { - return Boolean.FALSE; - } - - // check expression equality - InstanceOfExpressionChild child1 = exp1.getChild(); - InstanceOfExpressionChild child2 = exp2.getChild(); - return similarityChecker.isSimilar(child1, child2); - } - - @Override - public Boolean caseConditionalOrExpression(ConditionalOrExpression exp1) { - - ConditionalOrExpression exp2 = (ConditionalOrExpression) compareElement; - - // check expression equality - EList children1 = exp1.getChildren(); - EList children2 = exp2.getChildren(); - return similarityChecker.areSimilar(children1, children2); - } - - @Override - public Boolean caseConditionalAndExpression(ConditionalAndExpression exp1) { - - ConditionalAndExpression exp2 = (ConditionalAndExpression) compareElement; - - // check expression equality - EList children1 = exp1.getChildren(); - EList children2 = exp2.getChildren(); - return similarityChecker.areSimilar(children1, children2); - } - - @Override - public Boolean caseNestedExpression(NestedExpression exp1) { - - NestedExpression exp2 = (NestedExpression) compareElement; - - // check expression equality - Expression childExp1 = exp1.getExpression(); - Expression childExp2 = exp2.getExpression(); - return similarityChecker.isSimilar(childExp1, childExp2); - } - - @Override - public Boolean defaultCase(EObject object) { - return Boolean.TRUE; - } - } - - /** - * Similarity decisions for the generic elements. - */ - private class GenericsSimilaritySwitch extends GenericsSwitch { - @Override - public Boolean caseQualifiedTypeArgument(QualifiedTypeArgument qta1) { - QualifiedTypeArgument qta2 = (QualifiedTypeArgument) compareElement; - return similarityChecker.isSimilar(qta1.getTypeReference(), qta2.getTypeReference()); - } - - @Override - public Boolean caseSuperTypeArgument(SuperTypeArgument sta1) { - SuperTypeArgument sta2 = (SuperTypeArgument) compareElement; - return similarityChecker.isSimilar(sta1.getSuperType(), sta2.getSuperType()); - } - - @Override - public Boolean caseExtendsTypeArgument(ExtendsTypeArgument eta1) { - ExtendsTypeArgument eta2 = (ExtendsTypeArgument) compareElement; - return similarityChecker.isSimilar(eta1.getExtendType(), eta2.getExtendType()); - } - - @Override - public Boolean caseUnknownTypeArgument(UnknownTypeArgument arg) { - return Boolean.TRUE; - } - - @Override - public Boolean caseTypeParameter(TypeParameter param1) { - TypeParameter param2 = (TypeParameter) compareElement; - - if (!param1.getName().equals(param2.getName())) { - return Boolean.FALSE; - } - - return similarityChecker.areSimilar(param1.getExtendTypes(), param2.getExtendTypes()); - } - } - - /** - * Similarity decisions for the import elements. - */ - private class ImportsSimilaritySwitch extends ImportsSwitch { - - @Override - public Boolean caseClassifierImport(ClassifierImport import1) { - - ClassifierImport import2 = (ClassifierImport) compareElement; - - Boolean similarity = similarityChecker.isSimilar(import1.getClassifier(), import2.getClassifier()); - if (similarity == Boolean.FALSE) { - return Boolean.FALSE; - } - - String namespace1 = Strings.nullToEmpty(import1.getNamespacesAsString()); - String namespace2 = Strings.nullToEmpty(import2.getNamespacesAsString()); - return (namespace1.equals(namespace2)); - } - - @Override - public Boolean caseStaticMemberImport(StaticMemberImport import1) { - - StaticMemberImport import2 = (StaticMemberImport) compareElement; - - if (import1.getStaticMembers().size() != import2.getStaticMembers().size()) { - return Boolean.FALSE; - } - for (int i = 0; i < import1.getStaticMembers().size(); i++) { - ReferenceableElement member1 = import1.getStaticMembers().get(i); - ReferenceableElement member2 = import2.getStaticMembers().get(i); - Boolean similarity = similarityChecker.isSimilar(member1, member2); - if (similarity == Boolean.FALSE) { - return Boolean.FALSE; - } - } - - String namespace1 = Strings.nullToEmpty(import1.getNamespacesAsString()); - String namespace2 = Strings.nullToEmpty(import2.getNamespacesAsString()); - return (namespace1.equals(namespace2)); - } - } - - /** - * Similarity decisions for object instantiation elements. - */ - private class InstantiationsSimilaritySwitch extends InstantiationsSwitch { - - /** - * Check class instance creation similarity.
- * Similarity is checked by - *
    - *
  • instance type similarity
    • - *
  • number of constructor arguments
    • - *
  • types of constructor arguments
    • - *
- * - * @param call1 - * The class instance creation to compare with the compare element. - * @return True/False if the class instance creations are similar or not. - */ - @Override - public Boolean caseExplicitConstructorCall(ExplicitConstructorCall call1) { - - ExplicitConstructorCall call2 = (ExplicitConstructorCall) compareElement; - - // check the class instance types - Boolean typeSimilarity = similarityChecker.isSimilar(call1.getCallTarget(), call2.getCallTarget()); - if (typeSimilarity == Boolean.FALSE) { - return Boolean.FALSE; - } - - // check number of type arguments - EList cic1Args = call1.getArguments(); - EList cic2Args = call2.getArguments(); - if (cic1Args.size() != cic2Args.size()) { - return Boolean.FALSE; - } - - // check the argument similarity - for (int i = 0; i < cic1Args.size(); i++) { - Boolean argumentSimilarity = similarityChecker.isSimilar(cic1Args.get(i), cic2Args.get(i)); - if (argumentSimilarity == Boolean.FALSE) { - return Boolean.FALSE; - } - } - - return Boolean.TRUE; - } - - @Override - public Boolean caseNewConstructorCall(NewConstructorCall call1) { - NewConstructorCall call2 = (NewConstructorCall) compareElement; - - Type type1 = call1.getTypeReference().getTarget(); - Type type2 = call2.getTypeReference().getTarget(); - Boolean typeSimilarity = similarityChecker.isSimilar(type1, type2); - if (typeSimilarity == Boolean.FALSE) { - return Boolean.FALSE; - } - - EList types1 = call1.getArguments(); - EList types2 = call2.getArguments(); - if (types1.size() != types2.size()) { - return Boolean.FALSE; - } - for (int i = 0; i < types1.size(); i++) { - Expression argType1 = types1.get(i); - Expression argType2 = types2.get(i); - Boolean similarity = similarityChecker.isSimilar(argType1, argType2); - if (similarity == Boolean.FALSE) { - return Boolean.FALSE; - } - } - - return Boolean.TRUE; - } - - @Override - public Boolean defaultCase(EObject object) { - return Boolean.TRUE; - } - } - - /** - * Similarity decisions for literal elements. - */ - private class LiteralsSimilaritySwitch extends LiteralsSwitch { - - @Override - public Boolean caseBooleanLiteral(BooleanLiteral boolean1) { - BooleanLiteral boolean2 = (BooleanLiteral) compareElement; - return (boolean1.isValue() == boolean2.isValue()); - } - - @Override - public Boolean caseCharacterLiteral(CharacterLiteral char1) { - CharacterLiteral char2 = (CharacterLiteral) compareElement; - return char1.getValue().equals(char2.getValue()); - } - - @Override - public Boolean caseDecimalFloatLiteral(DecimalFloatLiteral float1) { - DecimalFloatLiteral float2 = (DecimalFloatLiteral) compareElement; - return compareDouble(float1.getDecimalValue(), float2.getDecimalValue()); - } - - @Override - public Boolean caseHexFloatLiteral(HexFloatLiteral float1) { - HexFloatLiteral float2 = (HexFloatLiteral) compareElement; - return compareDouble(float1.getHexValue(), float2.getHexValue()); - } - - @Override - public Boolean caseDecimalDoubleLiteral(DecimalDoubleLiteral double1) { - DecimalDoubleLiteral double2 = (DecimalDoubleLiteral) compareElement; - return compareDouble(double1.getDecimalValue(), double2.getDecimalValue()); - } - - @Override - public Boolean caseHexDoubleLiteral(HexDoubleLiteral double1) { - HexDoubleLiteral double2 = (HexDoubleLiteral) compareElement; - return compareDouble(double1.getHexValue(), double2.getHexValue()); - } - - private boolean compareDouble(double d1, double d2) { - return d1 == d2 || Double.isNaN(d1) && Double.isNaN(d2); - } - - @Override - public Boolean caseDecimalIntegerLiteral(DecimalIntegerLiteral int1) { - DecimalIntegerLiteral int2 = (DecimalIntegerLiteral) compareElement; - return (int1.getDecimalValue().equals(int2.getDecimalValue())); - } - - @Override - public Boolean caseHexIntegerLiteral(HexIntegerLiteral int1) { - HexIntegerLiteral int2 = (HexIntegerLiteral) compareElement; - return (int1.getHexValue().equals(int2.getHexValue())); - } - - @Override - public Boolean caseOctalIntegerLiteral(OctalIntegerLiteral int1) { - OctalIntegerLiteral int2 = (OctalIntegerLiteral) compareElement; - return (int1.getOctalValue().equals(int2.getOctalValue())); - } - - @Override - public Boolean caseDecimalLongLiteral(DecimalLongLiteral long1) { - DecimalLongLiteral long2 = (DecimalLongLiteral) compareElement; - return (long1.getDecimalValue().equals(long2.getDecimalValue())); - } - - @Override - public Boolean caseHexLongLiteral(HexLongLiteral long1) { - HexLongLiteral long2 = (HexLongLiteral) compareElement; - return (long1.getHexValue().equals(long2.getHexValue())); - } - - @Override - public Boolean caseOctalLongLiteral(OctalLongLiteral long1) { - OctalLongLiteral long2 = (OctalLongLiteral) compareElement; - return (long1.getOctalValue().equals(long2.getOctalValue())); - } - - @Override - public Boolean caseBinaryLongLiteral(BinaryLongLiteral long1) { - BinaryLongLiteral long2 = (BinaryLongLiteral) compareElement; - return long1.getBinaryValue().equals(long2.getBinaryValue()); - } - - @Override - public Boolean caseBinaryIntegerLiteral(BinaryIntegerLiteral int1) { - BinaryIntegerLiteral int2 = (BinaryIntegerLiteral) compareElement; - return int1.getBinaryValue().equals(int2.getBinaryValue()); - } - - /** - * Check null literal similarity.
- * - * Null literals are always assumed to be similar. - * - * @param object - * The literal to compare with the compare element. - * @return True As null always means null. - */ - @Override - public Boolean defaultCase(EObject object) { - return Boolean.TRUE; - } - } - - /** - * Similarity decisions for the member elements. - */ - private class MembersSimilaritySwitch extends MembersSwitch { - - /** - * Check abstract method declaration similarity. Similarity is checked by - *
    - *
  • name
    • - *
  • parameter list size
    • - *
  • parameter types
    • - *
  • name
    • - *
  • container for - *
      - *
    • AbstractTypeDeclaration
      • - *
    • AnonymousClassDeclaration
      • - *
    • Model
      • - *
    - *
    • - *
- * - * The container must be checked to check similarity for referenced methods. - * - * - * @param method1 - * The abstract method declaration to compare with the compare element. - * @return True/False if the abstract method declarations are similar or not. - */ - @Override - public Boolean caseMethod(Method method1) { - - Method method2 = (Method) compareElement; - - // if methods have different names they are not similar. - if (!method1.getName().equals(method2.getName())) { - return Boolean.FALSE; - } - - if (method1.getParameters().size() != method2.getParameters().size()) { - return Boolean.FALSE; - } - - for (int i = 0; i < method1.getParameters().size(); i++) { - Parameter param1 = method1.getParameters().get(i); - Parameter param2 = method2.getParameters().get(i); - Type type1 = param1.getTypeReference().getTarget(); - Type type2 = param2.getTypeReference().getTarget(); - Boolean typeSimilarity = similarityChecker.isSimilar(type1, type2); - if (typeSimilarity == Boolean.FALSE) { - return Boolean.FALSE; - } - if (param1.getTypeReference().getArrayDimension() != param2.getTypeReference().getArrayDimension()) { - return Boolean.FALSE; - } - } - - /* ************************************** - * methods as members of regular classes - */ - if (method1.getContainingConcreteClassifier() != null) { - ConcreteClassifier type1 = method1.getContainingConcreteClassifier(); - ConcreteClassifier type2 = method2.getContainingConcreteClassifier(); - return similarityChecker.isSimilar(type1, type2); - } - - /* ************************************** - * methods as members of anonymous classes - */ - if (method1.getContainingAnonymousClass() != null) { - AnonymousClass type1 = method1.getContainingAnonymousClass(); - AnonymousClass type2 = method2.getContainingAnonymousClass(); - Boolean typeSimilarity = similarityChecker.isSimilar(type1, type2); - if (typeSimilarity != null) { - return typeSimilarity; - } - } - - logger.warn("MethodDeclaration in unknown container: " + method1.getName() + " : " - + method1.eContainer()); - return super.caseMethod(method1); - } - - /** - * Check constuctor declaration similarity. Similarity is checked by - *
    - *
  • name
    • - *
  • parameter list size
    • - *
  • parameter types
    • - *
  • name
    • - *
  • container for - *
      - *
    • AbstractTypeDeclaration
      • - *
    • AnonymousClassDeclaration
      • - *
    • Model
      • - *
    - *
    • - *
- * - * The container must be checked to check similarity for referenced methods. - * - * - * @param constructor1 - * The abstract method declaration to compare with the compare element. - * @return True/False if the abstract method declarations are similar or not. - */ - @Override - public Boolean caseConstructor(Constructor constructor1) { - - Constructor constructor2 = (Constructor) compareElement; - - // if methods have different names they are not similar. - if (!constructor1.getName().equals(constructor2.getName())) { - return Boolean.FALSE; - } - - EList params1 = constructor1.getParameters(); - EList params2 = constructor2.getParameters(); - Boolean parameterSimilarity = similarityChecker.areSimilar(params1, params2); - if (parameterSimilarity == Boolean.FALSE) { - return Boolean.FALSE; - } - - /* ************************************** - * methods as members of regular classes - */ - if (constructor1.getContainingConcreteClassifier() != null) { - ConcreteClassifier type1 = constructor1.getContainingConcreteClassifier(); - ConcreteClassifier type2 = constructor2.getContainingConcreteClassifier(); - return similarityChecker.isSimilar(type1, type2); - } - - /* ************************************** - * methods as members of anonymous classes - */ - if (constructor1.getContainingAnonymousClass() != null) { - AnonymousClass type1 = constructor1.getContainingAnonymousClass(); - AnonymousClass type2 = constructor2.getContainingAnonymousClass(); - Boolean typeSimilarity = similarityChecker.isSimilar(type1, type2); - if (typeSimilarity != null) { - return typeSimilarity; - } - } - - logger.warn("ConstructorDeclaration in unknown container: " + constructor1.getName() + " : " - + constructor1.eContainer().getClass().getSimpleName()); - return super.caseConstructor(constructor1); - } - - @Override - public Boolean caseEnumConstant(EnumConstant const1) { - EnumConstant const2 = (EnumConstant) compareElement; - String name1 = Strings.nullToEmpty(const1.getName()); - String name2 = Strings.nullToEmpty(const2.getName()); - return (name1.equals(name2)); - } - - @Override - public Boolean caseMember(Member member1) { - Member member2 = (Member) compareElement; - String name1 = Strings.nullToEmpty(member1.getName()); - String name2 = Strings.nullToEmpty(member2.getName()); - return (name1.equals(name2)); - } - } - - /** - * Similarity decisions for modifier elements. - *

- * All modifier elements are strong typed with no identifying attributes or non-containment - * references. Their location and runtime types are assumed to be checked before this switch is - * called. - *

- */ - private class ModifiersSimilaritySwitch extends ModifiersSwitch { - @Override - public Boolean defaultCase(EObject object) { - return Boolean.TRUE; - } - } - - /** - * Similarity decisions for operator elements. - *

- * All operator elements are strong typed with no identifying attributes or non-containment - * references. Their location and runtime types are assumed to be checked before this switch is - * called. - *

- */ - private class OperatorsSimilaritySwitch extends OperatorsSwitch { - @Override - public Boolean defaultCase(EObject object) { - return Boolean.TRUE; - } - } - - /** - * Similarity decisions for parameter elements. - *

- * Parameters are variables and for this named elements. So their names must be checked but no - * more identifying attributes or references exist. - *

- */ - private class ParametersSimilaritySwitch extends ParametersSwitch { - @Override - public Boolean caseParameter(Parameter param1) { - Parameter param2 = (Parameter) compareElement; - String name1 = Strings.nullToEmpty(param1.getName()); - String name2 = Strings.nullToEmpty(param2.getName()); - return (name1.equals(name2)); - } - } - - /** - * Similarity decisions for reference elements. - */ - private class ReferencesSimilaritySwitch extends ReferencesSwitch { - - @Override - public Boolean caseStringReference(StringReference ref1) { - - StringReference ref2 = (StringReference) compareElement; - if (ref1.getValue() == null) { - return (ref2.getValue() == null); - } - - return (ref1.getValue().equals(ref2.getValue())); - } - - @Override - public Boolean caseIdentifierReference(IdentifierReference ref1) { - - IdentifierReference ref2 = (IdentifierReference) compareElement; - ReferenceableElement target1 = ref1.getTarget(); - ReferenceableElement target2 = ref2.getTarget(); - - // target identity similarity - Boolean similarity = similarityChecker.isSimilar(target1, target2); - if (similarity == Boolean.FALSE) { - return Boolean.FALSE; - } - - if (target1 != null) { - // target container similarity - // check this only if the reference target is located - // in another container than the reference itself. - // Otherwise such a situation would lead to endless loops - // e.g. for for "(Iterator i = c.iterator(); i.hasNext(); ) {" - // Attention: The reference could be encapsulated by an expression! - EObject ref1Container = JaMoPPElementUtil.getFirstContainerNotOfGivenType(ref1, Expression.class, - ArraySelector.class); - EObject ref2Container = JaMoPPElementUtil.getFirstContainerNotOfGivenType(ref2, Expression.class, - ArraySelector.class); - EObject target1Container = target1.eContainer(); - EObject target2Container = target2.eContainer(); - if (target1Container != ref1Container && target2Container != ref2Container - && target1Container != ref1 && target2Container != ref2) { - Boolean containerSimilarity = similarityChecker.isSimilar(target1Container, target2Container); - if (containerSimilarity == Boolean.FALSE) { - return Boolean.FALSE; - } - } - } - - if (ref1.getArraySelectors().size() != ref2.getArraySelectors().size()) { - return Boolean.FALSE; - } - for (int i = 0; i < ref1.getArraySelectors().size(); i++) { - ArraySelector selector1 = ref1.getArraySelectors().get(i); - ArraySelector selector2 = ref2.getArraySelectors().get(i); - Boolean positionSimilarity = similarityChecker.isSimilar(selector1.getPosition(), - selector2.getPosition()); - if (positionSimilarity == Boolean.FALSE) { - return Boolean.FALSE; - } - } - - Reference next1 = ref1.getNext(); - Reference next2 = ref2.getNext(); - Boolean nextSimilarity = similarityChecker.isSimilar(next1, next2); - if (nextSimilarity == Boolean.FALSE) { - return Boolean.FALSE; - } - - return Boolean.TRUE; - } - - /** - * Check element reference similarity.
- * - * Is checked by the target (the method called). Everything else are containment references - * checked indirectly. - * - * @param ref1 - * The method call to compare with the compare element. - * @return True As null always means null. - */ - @Override - public Boolean caseElementReference(ElementReference ref1) { - ElementReference ref2 = (ElementReference) compareElement; - - Boolean targetSimilarity = similarityChecker.isSimilar(ref1.getTarget(), ref2.getTarget()); - if (targetSimilarity == Boolean.FALSE) { - return Boolean.FALSE; - } - - return Boolean.TRUE; - } - - /** - * Proof method call similarity. - * - * Similarity is decided by the method referenced and the arguments passed by. - * - * @param call1 - * The left / modified method call to compare with the original one. - * @return True/False if the method calls are similar or not. - */ - @Override - public Boolean caseMethodCall(MethodCall call1) { - MethodCall call2 = (MethodCall) compareElement; - - Boolean targetSimilarity = similarityChecker.isSimilar(call1.getTarget(), call2.getTarget()); - if (targetSimilarity == Boolean.FALSE) { - return Boolean.FALSE; - } - - if (call1.getArguments().size() != call2.getArguments().size()) { - return Boolean.FALSE; - } - - for (int i = 0; i < call1.getArguments().size(); i++) { - Expression exp1 = call1.getArguments().get(i); - Expression exp2 = call2.getArguments().get(i); - Boolean argSimilarity = similarityChecker.isSimilar(exp1, exp2); - if (argSimilarity == Boolean.FALSE) { - return Boolean.FALSE; - } - } - - Boolean nextSimilarity = similarityChecker.isSimilar(call1.getNext(), call2.getNext()); - if (nextSimilarity == Boolean.FALSE) { - return Boolean.FALSE; - } - - return Boolean.TRUE; - } - - @Override - public Boolean defaultCase(EObject object) { - return Boolean.TRUE; - } - } - - /** - * Similarity decisions for the statement elements. - */ - private class StatementsSimilaritySwitch extends StatementsSwitch { - - /** - * Flag if the position of a statement should be considered for similarity or not. - */ - private boolean checkStatementPosition = true; - - /** - * Constructor to set required configurations. - * - * @param checkStatementPosition - * Flag if the position of a statement should be considered for similarity or - * not. - */ - public StatementsSimilaritySwitch(boolean checkStatementPosition) { - this.checkStatementPosition = checkStatementPosition; - } - - /** - * Check expression statement similarity.
- * Similarity is checked by - *
    - *
  • similarity statements expressions
    • - *
- * - * @param statement1 - * The expression statement to compare with the compare element. - * @return True/False if the expression statements are similar or not. - */ - @Override - public Boolean caseExpressionStatement(ExpressionStatement statement1) { - - ExpressionStatement statement2 = (ExpressionStatement) compareElement; - - Expression exp1 = statement1.getExpression(); - Expression exp2 = statement2.getExpression(); - - Boolean expSimilarity = similarityChecker.isSimilar(exp1, exp2); - if (expSimilarity == Boolean.FALSE) { - return Boolean.FALSE; - } - - // check predecessor similarity - if (checkStatementPosition) { - if (differentPredecessor(statement1, statement2) && differentSuccessor(statement1, statement2)) { - return Boolean.FALSE; - } - } - - return Boolean.TRUE; - } - - /** - * Check the similarity of a variable declaration. - * - * The similarity is decided by the declared variables name only. A changed variable type or - * value initialization should lead to a changed statement not a new one. - * - * @param varStmt1 - * The variable to compare with the original / right-side one - * @return True/False if they are similar or not. - */ - @Override - public Boolean caseLocalVariableStatement(LocalVariableStatement varStmt1) { - LocalVariableStatement varStmt2 = (LocalVariableStatement) compareElement; - - Variable var1 = varStmt1.getVariable(); - Variable var2 = varStmt2.getVariable(); - Boolean varSimilarity = similarityChecker.isSimilar(var1, var2); - if (varSimilarity == Boolean.FALSE) { - return Boolean.FALSE; - } - - if (checkStatementPosition) { - varSimilarity = similarityChecker.isSimilar(varStmt1.eContainer(), varStmt2.eContainer(), false); - if (!varSimilarity) { - return Boolean.FALSE; - } - if (differentPredecessor(varStmt1, varStmt2) && differentSuccessor(varStmt1, varStmt2)) { - return Boolean.FALSE; - } - } - - return Boolean.TRUE; - } - - /** - * Check return statement similarity.
- * Similarity is checked by - *
    - *
  • expressions similarity
    • - *
- * - * @param returnStatement1 - * The return statement to compare with the compare element. - * @return True/False if the return statements are similar or not. - */ - @Override - public Boolean caseReturn(Return returnStatement1) { - - Return returnStatement2 = (Return) compareElement; - - Expression exp1 = returnStatement1.getReturnValue(); - Expression exp2 = returnStatement2.getReturnValue(); - - return similarityChecker.isSimilar(exp1, exp2); - } - - /** - * Check synchronized statement similarity.
- * Similarity is checked by - *
    - *
  • expression similarity
    • - *
- * - * @param statement1 - * The synchronized statement to compare with the compare element. - * @return True/False if the synchronized statements are similar or not. - */ - @Override - public Boolean caseSynchronizedBlock(SynchronizedBlock statement1) { - - SynchronizedBlock statement2 = (SynchronizedBlock) compareElement; - - Expression exp1 = statement1.getLockProvider(); - Expression exp2 = statement2.getLockProvider(); - Boolean similarity = similarityChecker.isSimilar(exp1, exp2); - if (similarity == Boolean.FALSE) { - return Boolean.FALSE; - } - - if (checkStatementPosition) { - if (differentPredecessor(statement1, statement2) && differentSuccessor(statement1, statement2)) { - return Boolean.FALSE; - } - } - return Boolean.TRUE; - } - - /** - * Check throw statement similarity.
- * - * Only one throw statement can exist at the same code location. As a result the container - * similarity checked implicitly is enough for this. - * - * @param throwStatement1 - * The throw statement to compare with the compare element. - * @return True/False if the throw statements are similar or not. - */ - @Override - public Boolean caseThrow(Throw throwStatement1) { - return Boolean.TRUE; - } - - @Override - public Boolean caseCatchBlock(CatchBlock catchBlock1) { - - CatchBlock catchBlock2 = (CatchBlock) compareElement; - - OrdinaryParameter catchedException1 = catchBlock1.getParameter(); - OrdinaryParameter catchedException2 = catchBlock2.getParameter(); - - Boolean exceptionSimilarity = similarityChecker.isSimilar(catchedException1, catchedException2); - if (exceptionSimilarity == Boolean.FALSE) { - return exceptionSimilarity; - } - - return Boolean.TRUE; - } - - /** - * Check if two conditional statements are similar. - * - * Similarity is checked by: - *
    - *
  • similarity of the expressions
    • - *
- * - * The then and else statements are not checked as part of the condition statement check - * because this is only about the container if statement similarity. The contained - * statements are checked in a separate step of the compare process if the enclosing - * condition statement matches. - * - * @param conditional1 - * The statement to compare with the compare element. - * @return True/False whether they are similar or not. - */ - @Override - public Boolean caseConditional(Conditional conditional1) { - - Conditional conditional2 = (Conditional) compareElement; - - Expression expression1 = conditional1.getCondition(); - Expression expression2 = conditional2.getCondition(); - Boolean expressionSimilarity = similarityChecker.isSimilar(expression1, expression2); - if (expressionSimilarity == Boolean.FALSE) { - return expressionSimilarity; - } - - return Boolean.TRUE; - } - - @Override - public Boolean caseJump(Jump jump1) { - Jump jump2 = (Jump) compareElement; - - Boolean similarity = similarityChecker.isSimilar(jump1.getTarget(), jump2.getTarget()); - if (similarity == Boolean.FALSE) { - return Boolean.FALSE; - } - - return Boolean.TRUE; - } - - @Override - public Boolean caseJumpLabel(JumpLabel label1) { - - JumpLabel label2 = (JumpLabel) compareElement; - - String name1 = Strings.nullToEmpty(label1.getName()); - String name2 = Strings.nullToEmpty(label2.getName()); - - return (name1.equals(name2)); - } - - @Override - public Boolean caseSwitch(Switch switch1) { - Switch switch2 = (Switch) compareElement; - - return similarityChecker.isSimilar(switch1.getVariable(), switch2.getVariable()); - } - - @Override - public Boolean defaultCase(EObject object) { - return Boolean.TRUE; - } - - /** - * Decide of two statements differ from each other or not. - * - * @param statement1 - * The first statement to compare - * @param statement2 - * The second statement to compare. - * @return True if they differ, null if not. - */ - private boolean differentPredecessor(Statement statement1, Statement statement2) { - Statement pred1 = getPredecessor(statement1); - Statement pred2 = getPredecessor(statement2); - Boolean similarity = similarityChecker.isSimilar(pred1, pred2, false); - return similarity == Boolean.FALSE; - } - - /** - * Check if two statements have differing successor statements. - * - * @param statement1 - * The first statement to check. - * @param statement2 - * The second statement to check. - * @return True if their successor differ, false if not. - */ - private boolean differentSuccessor(Statement statement1, Statement statement2) { - Statement pred1 = getSuccessor(statement1); - Statement pred2 = getSuccessor(statement2); - Boolean similarity = similarityChecker.isSimilar(pred1, pred2, false); - return similarity == Boolean.FALSE; - } - - /** - * Get the predecessor statement of a statement within the parents container statement list.
- * If a statement is the first, the only one, or the container is not a - * {@link StatementListContainer}, or no predecessor exists, null will be returned. - * - * @param statement - * The statement to get the predecessor for. - * @return The predecessor or null if non exists. - */ - private Statement getPredecessor(Statement statement) { - - int pos = JaMoPPElementUtil.getPositionInContainer(statement); - if (pos > 0) { - StatementListContainer container = (StatementListContainer) statement.eContainer(); - return container.getStatements().get(pos - 1); - } - - return null; - } - - /** - * Get the successor statement of a statement within the parents container statement list.
- * If a statement is the last, the only one, or the container is not a - * {@link StatementListContainer}, no successor exists, null will be returned. - * - * @param statement - * The statement to get the predecessor for. - * @return The predecessor or null if non exists. - */ - private Statement getSuccessor(Statement statement) { - - int pos = JaMoPPElementUtil.getPositionInContainer(statement); - if (pos != -1) { - StatementListContainer container = (StatementListContainer) statement.eContainer(); - if (container.getStatements().size() > pos + 1) { - return container.getStatements().get(pos + 1); - } - } - - return null; - } - } - - /** - * Similarity decisions for elements of the types package. - */ - private class TypesSimilaritySwitch extends TypesSwitch { - - /** - * Check element reference similarity.
- * - * Is checked by the target (the method called). Everything else are containment references - * checked indirectly. - * - * @param ref1 - * The method call to compare with the compare element. - * @return True As null always means null. - */ - @Override - public Boolean caseClassifierReference(ClassifierReference ref1) { - ClassifierReference ref2 = (ClassifierReference) compareElement; - - Boolean targetSimilarity = similarityChecker.isSimilar(ref1.getTarget(), ref2.getTarget()); - if (targetSimilarity == Boolean.FALSE) { - return Boolean.FALSE; - } - - return Boolean.TRUE; - } - - @Override - public Boolean caseTypeReference(TypeReference ref1) { - - TypeReference ref2 = (TypeReference) compareElement; - - Boolean targetSimilarity = similarityChecker.isSimilar(ref1.getTarget(), ref2.getTarget()); - if (targetSimilarity == Boolean.FALSE) { - return Boolean.FALSE; - } - - return Boolean.TRUE; - } - - @Override - public Boolean caseNamespaceClassifierReference(NamespaceClassifierReference ref1) { - - NamespaceClassifierReference ref2 = (NamespaceClassifierReference) compareElement; - - String namespace1 = Strings.nullToEmpty(ref1.getNamespacesAsString()); - String namespace2 = Strings.nullToEmpty(ref2.getNamespacesAsString()); - if (!namespace1.equals(namespace2)) { - return Boolean.FALSE; - } - - ClassifierReference pureRef1 = ref1.getPureClassifierReference(); - ClassifierReference pureRef2 = ref2.getPureClassifierReference(); - - return similarityChecker.isSimilar(pureRef1, pureRef2); - } - - /** - * Primitive types are always similar as their class similarity is assumed before by the - * outer {@link SimilarityChecker}. - * - * Note: The fall back to the default case is not sufficient here, as the common - * TypeReference case would be used before, leading to a loop. - * - * @param type - * The primitive type object. - * @return TRUE - */ - @Override - public Boolean casePrimitiveType(PrimitiveType type) { - return Boolean.TRUE; - } - - /** - * Inferable types are considered to be similar. - * - * @param type The element to compare with the compare element. - * @return true. - */ - @Override - public Boolean caseInferableType(InferableType type) { - return Boolean.TRUE; - } - - /** - * Primitive type elements are strongly typed and the exact type is already checked by the - * outer {@link SimilarityChecker}.
- * {@inheritDoc} - */ - @Override - public Boolean defaultCase(EObject object) { - return Boolean.TRUE; - } - } - - /** - * Similarity decisions for the variable elements. - */ - private class VariablesSimilaritySwitch extends VariablesSwitch { - - /** - * Check variable declaration similarity.
- * Similarity is checked by - *
    - *
  • variable name
    • - *
  • variable container (name space)
    • - *
- * - * @param var1 - * The variable declaration to compare with the compare element. - * @return True/False if the variable declarations are similar or not. - */ - @Override - public Boolean caseVariable(Variable var1) { - - Variable var2 = (Variable) compareElement; - - // check the variables name equality - if (!var1.getName().equals(var2.getName())) { - return Boolean.FALSE; - } - - return Boolean.TRUE; - } - - @Override - public Boolean caseAdditionalLocalVariable(AdditionalLocalVariable var1) { - AdditionalLocalVariable var2 = (AdditionalLocalVariable) compareElement; - - // check the variables name equality - String name1 = Strings.nullToEmpty(var1.getName()); - String name2 = Strings.nullToEmpty(var2.getName()); - if (!name1.equals(name2)) { - return Boolean.FALSE; - } - - return Boolean.TRUE; - } - } - - /** - * Similarity Decisions for layout information is always true as they are not considered for - * now. - */ - private class LayoutSimilaritySwitch extends LayoutSwitch { - @Override - public Boolean defaultCase(EObject object) { - return Boolean.TRUE; - } - } - - /** - * Similarity Decisions for module elements. - */ - private class ModulesSimilaritySwitch extends ModulesSwitch { - /** - * Check ModuleReference similarity.
- * Similarity is checked by - *
    - *
  • module names
    • - *
- * - * @param modRef1 The module reference to compare with the compare element. - * @return True/False if the module references are similar or not. - */ - @Override - public Boolean caseModuleReference(ModuleReference modRef1) { - ModuleReference modRef2 = (ModuleReference) compareElement; - if (compareNamespacesByPart(modRef1, modRef2)) { - return Boolean.TRUE; - } - return Boolean.FALSE; - } - - /** - * Check similarity for access providing module directives.
- * Similarity is checked by - *
    - *
  • the provided package
    • - *
- * - * @param dir1 The access providing module directive to compare with the compare element. - * @return True/False if the module directives are similar or not. - */ - @Override - public Boolean caseAccessProvidingModuleDirective(AccessProvidingModuleDirective dir1) { - AccessProvidingModuleDirective dir2 = (AccessProvidingModuleDirective) compareElement; - if (!compareNamespacesByPart(dir1, dir2)) { - return Boolean.FALSE; - } - return Boolean.TRUE; - } - - /** - * Check similarity for require module directives.
- * Similarity is checked by - *
    - *
  • required modules
    • - *
- * - * @param dir1 The require module directive to compare with the compare element. - * @return True/False if the module directives are similar or not. - */ - @Override - public Boolean caseRequiresModuleDirective(RequiresModuleDirective dir1) { - RequiresModuleDirective dir2 = (RequiresModuleDirective) compareElement; - return similarityChecker.isSimilar(dir1.getRequiredModule(), dir2.getRequiredModule()); - } - - /** - * Check similarity for provide module directives.
- * Similarity is checked by - *
    - *
  • provided types
    • - *
- * - * @param dir1 The provide module directive to compare with the compare element. - * @return True/False if the module directives are similar or not. - */ - @Override - public Boolean caseProvidesModuleDirective(ProvidesModuleDirective dir1) { - ProvidesModuleDirective dir2 = (ProvidesModuleDirective) compareElement; - return similarityChecker.isSimilar(dir1.getTypeReference(), dir2.getTypeReference()); - } - - /** - * Check similarity for use module directives.
- * Similarity is checked by - *
    - *
  • used types
    • - *
- * - * @param dir1 The use module directive to compare with the compare element. - * @return True/False if the module directives are similar or not. - */ - @Override - public Boolean caseUsesModuleDirective(UsesModuleDirective dir1) { - UsesModuleDirective dir2 = (UsesModuleDirective) compareElement; - return similarityChecker.isSimilar(dir1.getTypeReference(), dir2.getTypeReference()); - } - } - - /** - * Compares the namespaces of two elements by comparing each part of the namespaces. - * - * @param ele1 the first element. - * @param ele2 the second element to compare to the first element. - * @return true if the number of parts of the namespaces and each part in both namespaces are equal. false otherwise. - */ - private boolean compareNamespacesByPart(NamespaceAwareElement ele1, NamespaceAwareElement ele2) { - if (ele1.getNamespaces().size() != ele2.getNamespaces().size()) { - return false; - } - for (int idx = 0; idx < ele1.getNamespaces().size(); idx++) { - if (!ele1.getNamespaces().get(idx).equals(ele2.getNamespaces().get(idx))) { - return false; - } - } - return true; - } - - /** - * The default case for not explicitly handled elements always returns null to identify the open - * decision. - * - * @param object - * The object to compare with the compare element. - * @return null - */ - @Override - public Boolean defaultCase(EObject object) { - return null; - } -} From 5b6da63076b783be455bfab7355bd81ab6ff2fc6 Mon Sep 17 00:00:00 2001 From: AlpTorac Date: Mon, 2 Sep 2024 17:48:10 +0200 Subject: [PATCH 19/35] (WIP) Implement request and handler To create new Java-related similarity switches Non-functional commit --- .../handlers/NewSimilaritySwitchHandler.java | 49 +++++++++++++++++++ .../requests/NewSimilaritySwitchRequest.java | 35 +++++++++++++ 2 files changed, 84 insertions(+) create mode 100644 commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/handlers/NewSimilaritySwitchHandler.java create mode 100644 commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/requests/NewSimilaritySwitchRequest.java diff --git a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/handlers/NewSimilaritySwitchHandler.java b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/handlers/NewSimilaritySwitchHandler.java new file mode 100644 index 0000000000..9f09eeacf1 --- /dev/null +++ b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/handlers/NewSimilaritySwitchHandler.java @@ -0,0 +1,49 @@ +package org.splevo.jamopp.diffing.similarity.handlers; + +import org.splevo.jamopp.diffing.similarity.JavaSimilaritySwitch; +import org.splevo.jamopp.diffing.similarity.base.ISimilarityRequest; +import org.splevo.jamopp.diffing.similarity.base.ISimilarityRequestHandler; +import org.splevo.jamopp.diffing.similarity.requests.NewSimilaritySwitchRequest; + +/** + * An {@link ISimilarityRequestHandler} that processes incoming + * {@link NewSimilaritySwitchRequest} instances. + * + * @author atora + */ +public class NewSimilaritySwitchHandler implements ISimilarityRequestHandler { + /** + * The {@link ISimilarityRequestHandler}, which will be passed onto the + * similarity switch created in + * {@link #handleSimilarityRequest(ISimilarityRequest)}. + */ + private ISimilarityRequestHandler srh; + + /** + * Constructs an instance with the given {@link ISimilarityRequestHandler}. + * + * @param srh The {@link ISimilarityRequestHandler}, which will be passed onto + * the similarity switch created in + * {@link #handleSimilarityRequest(ISimilarityRequest)}. + */ + public NewSimilaritySwitchHandler(ISimilarityRequestHandler srh) { + this.srh = srh; + } + + /** + * {@inheritDoc}
+ *
+ * Constructs a new {@link JavaSimilaritySwitch}. + */ + @Override + public Object handleSimilarityRequest(ISimilarityRequest req) { + NewSimilaritySwitchRequest castedR = (NewSimilaritySwitchRequest) req; + Boolean csp = (Boolean) castedR.getParams(); + return new JavaSimilaritySwitch(this.srh, csp); + } + + @Override + public boolean canHandleSimilarityRequest(Class reqClass) { + return reqClass.equals(NewSimilaritySwitchRequest.class); + } +} diff --git a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/requests/NewSimilaritySwitchRequest.java b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/requests/NewSimilaritySwitchRequest.java new file mode 100644 index 0000000000..189d80cb46 --- /dev/null +++ b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/requests/NewSimilaritySwitchRequest.java @@ -0,0 +1,35 @@ +package org.splevo.jamopp.diffing.similarity.requests; + +import org.splevo.jamopp.diffing.similarity.base.ISimilarityRequest; + +/** + * An {@link ISimilarityRequest}, which contains a flag (checkStatementPosition) + * that denotes, whether the new similarity switch created by processing this + * request should care about positions of statements while computing similarity. + * + * @author atora + */ +public class NewSimilaritySwitchRequest implements ISimilarityRequest { + /** + * The flag that denotes, whether the resulting new similarity switch should + * care about positions of statements while computing similarity. + */ + private boolean checkStatementPosition; + + /** + * Constructs an instance with the given parameter. + * + * @param checkStatementPosition The flag that denotes, whether the resulting + * new similarity switch should care about + * positions of statements while computing + * similarity. + */ + public NewSimilaritySwitchRequest(boolean checkStatementPosition) { + this.checkStatementPosition = checkStatementPosition; + } + + @Override + public Object getParams() { + return this.checkStatementPosition; + } +} From 317e58bcfd373413584dbcecd70075f9f02b90df Mon Sep 17 00:00:00 2001 From: AlpTorac Date: Sat, 31 Aug 2024 16:10:53 +0200 Subject: [PATCH 20/35] (WIP) Implement interface For Java-related inner switches that create further switches Non-functional commit --- .../IJavaSimilarityPositionInnerSwitch.java | 25 +++++++++++++++++++ 1 file changed, 25 insertions(+) create mode 100644 commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/IJavaSimilarityPositionInnerSwitch.java diff --git a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/IJavaSimilarityPositionInnerSwitch.java b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/IJavaSimilarityPositionInnerSwitch.java new file mode 100644 index 0000000000..ae669f191b --- /dev/null +++ b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/IJavaSimilarityPositionInnerSwitch.java @@ -0,0 +1,25 @@ +package org.splevo.jamopp.diffing.similarity.switches; + +import org.splevo.jamopp.diffing.similarity.IJavaSimilaritySwitch; +import org.splevo.jamopp.diffing.similarity.base.ecore.IPositionInnerSwitch; +import org.splevo.jamopp.diffing.similarity.requests.NewSimilaritySwitchRequest; + +/** + * An interface that bundles and complements {@link IJavaSimilarityInnerSwitch} + * and {@link IPositionInnerSwitch} interfaces. Contains methods, which are + * specific to computing similarity in the context of Java model elements. + * + * @author atora + * + */ +public interface IJavaSimilarityPositionInnerSwitch extends IJavaSimilarityInnerSwitch, IPositionInnerSwitch { + /** + * Sends out a {@link NewSimilaritySwitchRequest} and returns the result. + * + * @see {@link #handleSimilarityRequest(org.splevo.jamopp.diffing.similarity.base.ISimilarityRequest)} + */ + public default IJavaSimilaritySwitch requestNewSwitch(boolean checkStatementPosition) { + return (IJavaSimilaritySwitch) this + .handleSimilarityRequest(new NewSimilaritySwitchRequest(checkStatementPosition)); + } +} From 96fb3ee4e98ebcbf760eaad1769b6592570b38a9 Mon Sep 17 00:00:00 2001 From: AlpTorac Date: Tue, 3 Sep 2024 17:13:56 +0200 Subject: [PATCH 21/35] (WIP) Adapt inner switches Use extracted structure in the Java-related inner switches Use implemented interfaces in the Java-related inner switches Non-functional commit --- .../switches/AnnotationsSimilaritySwitch.java | 52 +++++++++-- .../switches/ArraysSimilaritySwitch.java | 6 +- .../switches/ClassifiersSimilaritySwitch.java | 49 +++++----- .../switches/CommonsSimilaritySwitch.java | 32 ++++++- .../switches/ContainersSimilaritySwitch.java | 86 ++++++++++-------- .../switches/ExpressionsSimilaritySwitch.java | 87 +++++++++++------- .../switches/GenericsSimilaritySwitch.java | 46 +++++++--- .../switches/ImportsSimilaritySwitch.java | 38 ++++++-- .../InstantiationsSimilaritySwitch.java | 42 +++++++-- .../switches/LayoutSimilaritySwitch.java | 4 +- .../switches/LiteralsSimilaritySwitch.java | 51 +++++++---- .../switches/MembersSimilaritySwitch.java | 62 +++++++++---- .../switches/ModifiersSimilaritySwitch.java | 4 +- .../switches/ModulesSimilaritySwitch.java | 49 +++++++--- .../switches/OperatorsSimilaritySwitch.java | 4 +- .../switches/ParametersSimilaritySwitch.java | 26 +++++- .../switches/ReferencesSimilaritySwitch.java | 56 ++++++++---- .../switches/StatementsSimilaritySwitch.java | 90 ++++++++++--------- .../switches/TypesSimilaritySwitch.java | 50 ++++++++--- .../switches/VariablesSimilaritySwitch.java | 27 ++++-- 20 files changed, 596 insertions(+), 265 deletions(-) diff --git a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/AnnotationsSimilaritySwitch.java b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/AnnotationsSimilaritySwitch.java index 7160cbba7e..46bb1a6ca0 100644 --- a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/AnnotationsSimilaritySwitch.java +++ b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/AnnotationsSimilaritySwitch.java @@ -5,36 +5,71 @@ import org.emftext.language.java.annotations.AnnotationInstance; import org.emftext.language.java.annotations.util.AnnotationsSwitch; import org.emftext.language.java.classifiers.Classifier; +import org.splevo.jamopp.diffing.similarity.IJavaSimilaritySwitch; +import org.splevo.jamopp.diffing.similarity.ILoggableJavaSwitch; +import org.splevo.jamopp.diffing.similarity.base.ISimilarityRequestHandler; /** * Similarity decisions for annotation elements. */ -private class AnnotationsSimilaritySwitch extends AnnotationsSwitch { +public class AnnotationsSimilaritySwitch extends AnnotationsSwitch implements ILoggableJavaSwitch, IJavaSimilarityPositionInnerSwitch { + private IJavaSimilaritySwitch similaritySwitch; + private boolean checkStatementPosition; - @Override + @Override + public ISimilarityRequestHandler getSimilarityRequestHandler() { + return this.similaritySwitch; + } + + @Override + public boolean shouldCheckStatementPosition() { + return this.checkStatementPosition; + } + + @Override + public IJavaSimilaritySwitch getContainingSwitch() { + return this.similaritySwitch; + } + + public AnnotationsSimilaritySwitch(IJavaSimilaritySwitch similaritySwitch, boolean checkStatementPosition) { + this.similaritySwitch = similaritySwitch; + this.checkStatementPosition = checkStatementPosition; + } + + @Override public Boolean caseAnnotationInstance(AnnotationInstance instance1) { - AnnotationInstance instance2 = (AnnotationInstance) compareElement; + AnnotationInstance instance2 = (AnnotationInstance) this.getCompareElement(); + this.logComparison( + instance1.getAnnotation().getName(), + instance2.getAnnotation().getName(), + AnnotationInstance.class.getSimpleName()); Classifier class1 = instance1.getAnnotation(); Classifier class2 = instance2.getAnnotation(); - Boolean classifierSimilarity = similarityChecker.isSimilar(class1, class2); + Boolean classifierSimilarity = this.isSimilar(class1, class2); + this.logResult(classifierSimilarity, Classifier.class.getSimpleName()); if (classifierSimilarity == Boolean.FALSE) { return Boolean.FALSE; } - + String namespace1 = instance1.getNamespacesAsString(); String namespace2 = instance2.getNamespacesAsString(); + this.logComparison(namespace1, namespace2, "namespace"); if (namespace1 == null) { + this.logResult(namespace2 == null, "namespace"); return (namespace2 == null); } else { + this.logResult(namespace1.equals(namespace2), "namespace"); return (namespace1.equals(namespace2)); } } @Override public Boolean caseAnnotationAttributeSetting(AnnotationAttributeSetting setting1) { - AnnotationAttributeSetting setting2 = (AnnotationAttributeSetting) compareElement; - Boolean similarity = similarityChecker.isSimilar(setting1.getAttribute(), setting2.getAttribute()); + AnnotationAttributeSetting setting2 = (AnnotationAttributeSetting) this.getCompareElement(); + this.logComparison(setting1.getAttribute().getName(), setting2.getAttribute().getName(), AnnotationAttributeSetting.class.getSimpleName()); + Boolean similarity = this.isSimilar(setting1.getAttribute(), setting2.getAttribute()); + this.logResult(similarity, AnnotationAttributeSetting.class.getSimpleName()); if (similarity == Boolean.FALSE) { return Boolean.FALSE; } @@ -43,6 +78,7 @@ public Boolean caseAnnotationAttributeSetting(AnnotationAttributeSetting setting @Override public Boolean defaultCase(EObject object) { + this.logMessage("Default annotation comparing case (" + object.eClass().getName() +"), similarity: true"); return Boolean.TRUE; } -} +} \ No newline at end of file diff --git a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/ArraysSimilaritySwitch.java b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/ArraysSimilaritySwitch.java index 78f910012c..4f09f34fa4 100644 --- a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/ArraysSimilaritySwitch.java +++ b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/ArraysSimilaritySwitch.java @@ -10,9 +10,9 @@ * and runtime type are assumed to be checked before this switch is called. So nothing to check * here. */ -private class ArraysSimilaritySwitch extends ArraysSwitch { - @Override +public class ArraysSimilaritySwitch extends ArraysSwitch { + @Override public Boolean defaultCase(EObject object) { return Boolean.TRUE; } -} +} \ No newline at end of file diff --git a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/ClassifiersSimilaritySwitch.java b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/ClassifiersSimilaritySwitch.java index 3d727ab6ba..82eeac624b 100644 --- a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/ClassifiersSimilaritySwitch.java +++ b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/ClassifiersSimilaritySwitch.java @@ -1,36 +1,39 @@ package org.splevo.jamopp.diffing.similarity.switches; -import java.util.Map; -import java.util.regex.Pattern; - import org.emftext.language.java.classifiers.AnonymousClass; import org.emftext.language.java.classifiers.ConcreteClassifier; import org.emftext.language.java.classifiers.util.ClassifiersSwitch; -import org.splevo.diffing.util.NormalizationUtil; +import org.splevo.jamopp.diffing.similarity.IJavaSimilaritySwitch; +import org.splevo.jamopp.diffing.similarity.base.ISimilarityRequestHandler; import com.google.common.base.Strings; /** * Similarity decisions for classifier elements. */ -private class ClassifiersSimilaritySwitch extends ClassifiersSwitch { +public class ClassifiersSimilaritySwitch extends ClassifiersSwitch implements IJavaSimilarityPositionInnerSwitch { + private IJavaSimilaritySwitch similaritySwitch; + private boolean checkStatementPosition; - /** - * A list of patterns replace any match in a classifier name with the defined replacement - * string. - */ - private Map classifierNormalizationPatterns = null; + @Override + public ISimilarityRequestHandler getSimilarityRequestHandler() { + return this.similaritySwitch; + } - /** - * Constructor to set the required configurations. - * - * @param classifierNormalizationPatterns - * A list of patterns replace any match in a classifier name with the defined - * replacement string. - */ - public ClassifiersSimilaritySwitch(Map classifierNormalizationPatterns) { - this.classifierNormalizationPatterns = classifierNormalizationPatterns; - } + @Override + public boolean shouldCheckStatementPosition() { + return this.checkStatementPosition; + } + + @Override + public IJavaSimilaritySwitch getContainingSwitch() { + return this.similaritySwitch; + } + + public ClassifiersSimilaritySwitch(IJavaSimilaritySwitch similaritySwitch, boolean checkStatementPosition) { + this.similaritySwitch = similaritySwitch; + this.checkStatementPosition = checkStatementPosition; + } /** * Concrete classifiers such as classes and interface are identified by their location and @@ -43,9 +46,9 @@ public ClassifiersSimilaritySwitch(Map classifierNormalizationP @Override public Boolean caseConcreteClassifier(ConcreteClassifier classifier1) { - ConcreteClassifier classifier2 = (ConcreteClassifier) compareElement; + ConcreteClassifier classifier2 = (ConcreteClassifier) this.getCompareElement(); - String name1 = NormalizationUtil.normalize(classifier1.getQualifiedName(), classifierNormalizationPatterns); + String name1 = this.normalizeClassifier(classifier1.getQualifiedName()); String name2 = Strings.nullToEmpty(classifier2.getQualifiedName()); return (name1.equals(name2)); @@ -62,4 +65,4 @@ public Boolean caseAnonymousClass(AnonymousClass anon) { return Boolean.TRUE; } -} +} \ No newline at end of file diff --git a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/CommonsSimilaritySwitch.java b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/CommonsSimilaritySwitch.java index 4020ce4cf7..9e9920d25f 100644 --- a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/CommonsSimilaritySwitch.java +++ b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/CommonsSimilaritySwitch.java @@ -2,13 +2,37 @@ import org.emftext.language.java.commons.NamedElement; import org.emftext.language.java.commons.util.CommonsSwitch; +import org.splevo.jamopp.diffing.similarity.IJavaSimilaritySwitch; +import org.splevo.jamopp.diffing.similarity.base.ISimilarityRequestHandler; /** * Similarity decisions for commons elements. */ -private class CommonsSimilaritySwitch extends CommonsSwitch { +public class CommonsSimilaritySwitch extends CommonsSwitch implements IJavaSimilarityPositionInnerSwitch { + private IJavaSimilaritySwitch similaritySwitch; + private boolean checkStatementPosition; - /** + @Override + public ISimilarityRequestHandler getSimilarityRequestHandler() { + return this.similaritySwitch; + } + + @Override + public boolean shouldCheckStatementPosition() { + return this.checkStatementPosition; + } + + @Override + public IJavaSimilaritySwitch getContainingSwitch() { + return this.similaritySwitch; + } + + public CommonsSimilaritySwitch(IJavaSimilaritySwitch similaritySwitch, boolean checkStatementPosition) { + this.similaritySwitch = similaritySwitch; + this.checkStatementPosition = checkStatementPosition; + } + + /** * Check named element * * Similarity is defined by the names of the elements. @@ -19,7 +43,7 @@ private class CommonsSimilaritySwitch extends CommonsSwitch { */ @Override public Boolean caseNamedElement(NamedElement element1) { - NamedElement element2 = (NamedElement) compareElement; + NamedElement element2 = (NamedElement) this.getCompareElement(); if (element1.getName() == null) { return (element2.getName() == null); @@ -27,4 +51,4 @@ public Boolean caseNamedElement(NamedElement element1) { return (element1.getName().equals(element2.getName())); } -} +} \ No newline at end of file diff --git a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/ContainersSimilaritySwitch.java b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/ContainersSimilaritySwitch.java index 36b64f65ad..1d17d6d70c 100644 --- a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/ContainersSimilaritySwitch.java +++ b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/ContainersSimilaritySwitch.java @@ -1,12 +1,11 @@ package org.splevo.jamopp.diffing.similarity.switches; -import java.util.LinkedHashMap; -import java.util.regex.Pattern; - import org.emftext.language.java.containers.CompilationUnit; import org.emftext.language.java.containers.Package; import org.emftext.language.java.containers.util.ContainersSwitch; -import org.splevo.diffing.util.NormalizationUtil; +import org.splevo.jamopp.diffing.similarity.IJavaSimilaritySwitch; +import org.splevo.jamopp.diffing.similarity.ILoggableJavaSwitch; +import org.splevo.jamopp.diffing.similarity.base.ISimilarityRequestHandler; import org.splevo.jamopp.diffing.util.JaMoPPModelUtil; import com.google.common.base.Strings; @@ -14,26 +13,29 @@ /** * Similarity decisions for container elements. */ -private class ContainersSimilaritySwitch extends ContainersSwitch { +public class ContainersSimilaritySwitch extends ContainersSwitch implements ILoggableJavaSwitch, IJavaSimilarityPositionInnerSwitch { + private IJavaSimilaritySwitch similaritySwitch; + private boolean checkStatementPosition; - private LinkedHashMap compilationUnitNormalizations = null; + @Override + public ISimilarityRequestHandler getSimilarityRequestHandler() { + return this.similaritySwitch; + } - private LinkedHashMap packageNormalizations = null; + @Override + public boolean shouldCheckStatementPosition() { + return this.checkStatementPosition; + } + + @Override + public IJavaSimilaritySwitch getContainingSwitch() { + return this.similaritySwitch; + } - /** - * Constructor to set the required configurations. - * - * @param compilationUnitNormalizations - * A list of patterns replace any match in a classifier name with the defined - * replacement string. - * @param packageNormalizations - * A list of package normalization patterns. - */ - public ContainersSimilaritySwitch(LinkedHashMap compilationUnitNormalizations, - LinkedHashMap packageNormalizations) { - this.compilationUnitNormalizations = compilationUnitNormalizations; - this.packageNormalizations = packageNormalizations; - } + public ContainersSimilaritySwitch(IJavaSimilaritySwitch similaritySwitch, boolean checkStatementPosition) { + this.similaritySwitch = similaritySwitch; + this.checkStatementPosition = checkStatementPosition; + } /** * Check the similarity of two CompilationUnits.
@@ -51,23 +53,28 @@ public ContainersSimilaritySwitch(LinkedHashMap compilationUnit */ @Override public Boolean caseCompilationUnit(CompilationUnit unit1) { - - CompilationUnit unit2 = (CompilationUnit) compareElement; - - String name1 = NormalizationUtil.normalize(unit1.getName(), compilationUnitNormalizations); - name1 = NormalizationUtil.normalize(name1, packageNormalizations); + CompilationUnit unit2 = (CompilationUnit) this.getCompareElement(); + this.logComparison(unit1.getName(), unit2.getName(), CompilationUnit.class.getSimpleName()); + this.logComparison(unit1.eClass().getName(), unit2.eClass().getName(), "compilation unit class"); + + String name1 = this.normalizeCompilationUnit(unit1.getName()); + name1 = this.normalizePackage(name1); String name2 = unit2.getName(); + + this.logResult(name1.equals(name2), "compilation unit name"); if (!name1.equals(name2)) { return Boolean.FALSE; } - - String namespaceString1 = NormalizationUtil.normalizeNamespace(unit1.getNamespacesAsString(), - packageNormalizations); + + String namespaceString1 = this.normalizeNamespace(unit1.getNamespacesAsString()); String namespaceString2 = Strings.nullToEmpty(unit2.getNamespacesAsString()); + + this.logResult(namespaceString1.equals(namespaceString2), "compilation unit namespace"); + if (!namespaceString1.equals(namespaceString2)) { return Boolean.FALSE; } - + return Boolean.TRUE; } @@ -84,15 +91,20 @@ public Boolean caseCompilationUnit(CompilationUnit unit1) { */ @Override public Boolean casePackage(Package package1) { - Package package2 = (Package) compareElement; - + Package package2 = (Package) this.getCompareElement(); + this.logComparison(package1.getName(), package2.getName(), Package.class.getSimpleName()); + this.logComparison(package1.getNamespacesAsString(), package2.getNamespacesAsString(), "package namespace"); + String packagePath1 = JaMoPPModelUtil.buildNamespacePath(package1); - packagePath1 = NormalizationUtil.normalizeNamespace(packagePath1, packageNormalizations); + packagePath1 = this.normalizeNamespace(packagePath1); String packagePath2 = JaMoPPModelUtil.buildNamespacePath(package2); + + this.logResult(packagePath1.equals(packagePath2), "package path"); + if (!packagePath1.equals(packagePath2)) { return Boolean.FALSE; } - + return Boolean.TRUE; } @@ -109,10 +121,12 @@ public Boolean casePackage(Package package1) { @Override public Boolean caseModule(org.emftext.language.java.containers.Module module1) { org.emftext.language.java.containers.Module module2 = - (org.emftext.language.java.containers.Module) compareElement; + (org.emftext.language.java.containers.Module) this.getCompareElement(); + + this.logResult(module1.getName().equals(module2.getName()), Module.class.getSimpleName()); if (!module1.getName().equals(module2.getName())) { return Boolean.FALSE; } return Boolean.TRUE; } -} +} \ No newline at end of file diff --git a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/ExpressionsSimilaritySwitch.java b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/ExpressionsSimilaritySwitch.java index 45775a316a..0a1bb74f98 100644 --- a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/ExpressionsSimilaritySwitch.java +++ b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/ExpressionsSimilaritySwitch.java @@ -27,6 +27,8 @@ import org.emftext.language.java.operators.RelationOperator; import org.emftext.language.java.operators.UnaryOperator; import org.emftext.language.java.types.TypeReference; +import org.splevo.jamopp.diffing.similarity.IJavaSimilaritySwitch; +import org.splevo.jamopp.diffing.similarity.base.ISimilarityRequestHandler; /** * Similarity decisions for expression elements. @@ -36,30 +38,52 @@ * called. *

*/ -private class ExpressionsSimilaritySwitch extends ExpressionsSwitch { - - @Override +public class ExpressionsSimilaritySwitch extends ExpressionsSwitch implements IJavaSimilarityPositionInnerSwitch { + private IJavaSimilaritySwitch similaritySwitch; + private boolean checkStatementPosition; + + @Override + public ISimilarityRequestHandler getSimilarityRequestHandler() { + return this.similaritySwitch; + } + + @Override + public boolean shouldCheckStatementPosition() { + return this.checkStatementPosition; + } + + @Override + public IJavaSimilaritySwitch getContainingSwitch() { + return this.similaritySwitch; + } + + public ExpressionsSimilaritySwitch(IJavaSimilaritySwitch similaritySwitch, boolean checkStatementPosition) { + this.similaritySwitch = similaritySwitch; + this.checkStatementPosition = checkStatementPosition; + } + + @Override public Boolean caseAssignmentExpression(AssignmentExpression exp1) { - AssignmentExpression exp2 = (AssignmentExpression) compareElement; + AssignmentExpression exp2 = (AssignmentExpression) this.getCompareElement(); AssignmentExpressionChild child1 = exp1.getChild(); AssignmentExpressionChild child2 = exp2.getChild(); - Boolean childSimilarity = similarityChecker.isSimilar(child1, child2); + Boolean childSimilarity = this.isSimilar(child1, child2); if (childSimilarity == Boolean.FALSE) { return Boolean.FALSE; } AssignmentOperator op1 = exp1.getAssignmentOperator(); AssignmentOperator op2 = exp2.getAssignmentOperator(); - Boolean operatorSimilarity = similarityChecker.isSimilar(op1, op2); + Boolean operatorSimilarity = this.isSimilar(op1, op2); if (operatorSimilarity == Boolean.FALSE) { return Boolean.FALSE; } Expression value1 = exp1.getValue(); Expression value2 = exp2.getValue(); - Boolean valueSimilarity = similarityChecker.isSimilar(value1, value2); + Boolean valueSimilarity = this.isSimilar(value1, value2); if (valueSimilarity == Boolean.FALSE) { return Boolean.FALSE; } @@ -69,12 +93,12 @@ public Boolean caseAssignmentExpression(AssignmentExpression exp1) { @Override public Boolean caseEqualityExpression(EqualityExpression exp1) { - EqualityExpression exp2 = (EqualityExpression) compareElement; + EqualityExpression exp2 = (EqualityExpression) this.getCompareElement(); // check operator equality EList operators1 = exp1.getEqualityOperators(); EList operators2 = exp2.getEqualityOperators(); - Boolean operatorSimilarity = similarityChecker.areSimilar(operators1, operators2); + Boolean operatorSimilarity = this.areSimilar(operators1, operators2); if (operatorSimilarity == Boolean.FALSE) { return Boolean.FALSE; } @@ -82,7 +106,7 @@ public Boolean caseEqualityExpression(EqualityExpression exp1) { // check expression equality EList children1 = exp1.getChildren(); EList children2 = exp2.getChildren(); - Boolean childSimilarity = similarityChecker.areSimilar(children1, children2); + Boolean childSimilarity = this.areSimilar(children1, children2); if (childSimilarity == Boolean.FALSE) { return Boolean.FALSE; } @@ -93,12 +117,12 @@ public Boolean caseEqualityExpression(EqualityExpression exp1) { @Override public Boolean caseRelationExpression(RelationExpression exp1) { - RelationExpression exp2 = (RelationExpression) compareElement; + RelationExpression exp2 = (RelationExpression) this.getCompareElement(); // check operator equality EList operators1 = exp1.getRelationOperators(); EList operators2 = exp2.getRelationOperators(); - Boolean operatorSimilarity = similarityChecker.areSimilar(operators1, operators2); + Boolean operatorSimilarity = this.areSimilar(operators1, operators2); if (operatorSimilarity == Boolean.FALSE) { return Boolean.FALSE; } @@ -106,7 +130,7 @@ public Boolean caseRelationExpression(RelationExpression exp1) { // check expression equality EList children1 = exp1.getChildren(); EList children2 = exp2.getChildren(); - Boolean childSimilarity = similarityChecker.areSimilar(children1, children2); + Boolean childSimilarity = this.areSimilar(children1, children2); if (childSimilarity == Boolean.FALSE) { return Boolean.FALSE; } @@ -117,12 +141,12 @@ public Boolean caseRelationExpression(RelationExpression exp1) { @Override public Boolean caseAndExpression(AndExpression exp1) { - AndExpression exp2 = (AndExpression) compareElement; + AndExpression exp2 = (AndExpression) this.getCompareElement(); // check expression equality EList children1 = exp1.getChildren(); EList children2 = exp2.getChildren(); - Boolean childSimilarity = similarityChecker.areSimilar(children1, children2); + Boolean childSimilarity = this.areSimilar(children1, children2); if (childSimilarity == Boolean.FALSE) { return Boolean.FALSE; } @@ -133,12 +157,12 @@ public Boolean caseAndExpression(AndExpression exp1) { @Override public Boolean caseUnaryExpression(UnaryExpression exp1) { - UnaryExpression exp2 = (UnaryExpression) compareElement; + UnaryExpression exp2 = (UnaryExpression) this.getCompareElement(); // check operator equality EList operators1 = exp1.getOperators(); EList operators2 = exp2.getOperators(); - Boolean operatorSimilarity = similarityChecker.areSimilar(operators1, operators2); + Boolean operatorSimilarity = this.areSimilar(operators1, operators2); if (operatorSimilarity == Boolean.FALSE) { return Boolean.FALSE; } @@ -146,31 +170,31 @@ public Boolean caseUnaryExpression(UnaryExpression exp1) { // check expression equality UnaryExpressionChild child1 = exp1.getChild(); UnaryExpressionChild child2 = exp2.getChild(); - return similarityChecker.isSimilar(child1, child2); + return this.isSimilar(child1, child2); } @Override public Boolean caseAdditiveExpression(AdditiveExpression exp1) { - AdditiveExpression exp2 = (AdditiveExpression) compareElement; + AdditiveExpression exp2 = (AdditiveExpression) this.getCompareElement(); - Boolean opSimilarity = similarityChecker.areSimilar(exp1.getAdditiveOperators(), exp2.getAdditiveOperators()); + Boolean opSimilarity = this.areSimilar(exp1.getAdditiveOperators(), exp2.getAdditiveOperators()); if (opSimilarity == Boolean.FALSE) { return Boolean.FALSE; } - return similarityChecker.areSimilar(exp1.getChildren(), exp2.getChildren()); + return this.areSimilar(exp1.getChildren(), exp2.getChildren()); } @Override public Boolean caseInstanceOfExpression(InstanceOfExpression exp1) { - InstanceOfExpression exp2 = (InstanceOfExpression) compareElement; + InstanceOfExpression exp2 = (InstanceOfExpression) this.getCompareElement(); // check type equality TypeReference typeReference1 = exp1.getTypeReference(); TypeReference typeReference2 = exp2.getTypeReference(); - Boolean typeSimilarity = similarityChecker.isSimilar(typeReference1, typeReference2); + Boolean typeSimilarity = this.isSimilar(typeReference1, typeReference2); if (typeSimilarity == Boolean.FALSE) { return Boolean.FALSE; } @@ -178,45 +202,44 @@ public Boolean caseInstanceOfExpression(InstanceOfExpression exp1) { // check expression equality InstanceOfExpressionChild child1 = exp1.getChild(); InstanceOfExpressionChild child2 = exp2.getChild(); - return similarityChecker.isSimilar(child1, child2); + return this.isSimilar(child1, child2); } @Override public Boolean caseConditionalOrExpression(ConditionalOrExpression exp1) { - ConditionalOrExpression exp2 = (ConditionalOrExpression) compareElement; + ConditionalOrExpression exp2 = (ConditionalOrExpression) this.getCompareElement(); // check expression equality EList children1 = exp1.getChildren(); EList children2 = exp2.getChildren(); - return similarityChecker.areSimilar(children1, children2); + return this.areSimilar(children1, children2); } @Override public Boolean caseConditionalAndExpression(ConditionalAndExpression exp1) { - ConditionalAndExpression exp2 = (ConditionalAndExpression) compareElement; + ConditionalAndExpression exp2 = (ConditionalAndExpression) this.getCompareElement(); // check expression equality EList children1 = exp1.getChildren(); EList children2 = exp2.getChildren(); - return similarityChecker.areSimilar(children1, children2); + return this.areSimilar(children1, children2); } @Override public Boolean caseNestedExpression(NestedExpression exp1) { - NestedExpression exp2 = (NestedExpression) compareElement; + NestedExpression exp2 = (NestedExpression) this.getCompareElement(); // check expression equality Expression childExp1 = exp1.getExpression(); Expression childExp2 = exp2.getExpression(); - return similarityChecker.isSimilar(childExp1, childExp2); + return this.isSimilar(childExp1, childExp2); } @Override public Boolean defaultCase(EObject object) { return Boolean.TRUE; } -} - +} \ No newline at end of file diff --git a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/GenericsSimilaritySwitch.java b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/GenericsSimilaritySwitch.java index a998bdbdcc..7309c29b65 100644 --- a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/GenericsSimilaritySwitch.java +++ b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/GenericsSimilaritySwitch.java @@ -6,27 +6,52 @@ import org.emftext.language.java.generics.TypeParameter; import org.emftext.language.java.generics.UnknownTypeArgument; import org.emftext.language.java.generics.util.GenericsSwitch; +import org.splevo.jamopp.diffing.similarity.IJavaSimilaritySwitch; +import org.splevo.jamopp.diffing.similarity.base.ISimilarityRequestHandler; /** * Similarity decisions for the generic elements. */ -private class GenericsSimilaritySwitch extends GenericsSwitch { +public class GenericsSimilaritySwitch extends GenericsSwitch implements IJavaSimilarityPositionInnerSwitch { + private IJavaSimilaritySwitch similaritySwitch; + private boolean checkStatementPosition; + + @Override + public ISimilarityRequestHandler getSimilarityRequestHandler() { + return this.similaritySwitch; + } + + @Override + public boolean shouldCheckStatementPosition() { + return this.checkStatementPosition; + } + + @Override + public IJavaSimilaritySwitch getContainingSwitch() { + return this.similaritySwitch; + } + + public GenericsSimilaritySwitch(IJavaSimilaritySwitch similaritySwitch, boolean checkStatementPosition) { + this.similaritySwitch = similaritySwitch; + this.checkStatementPosition = checkStatementPosition; + } + @Override public Boolean caseQualifiedTypeArgument(QualifiedTypeArgument qta1) { - QualifiedTypeArgument qta2 = (QualifiedTypeArgument) compareElement; - return similarityChecker.isSimilar(qta1.getTypeReference(), qta2.getTypeReference()); + QualifiedTypeArgument qta2 = (QualifiedTypeArgument) this.getCompareElement(); + return this.isSimilar(qta1.getTypeReference(), qta2.getTypeReference()); } @Override public Boolean caseSuperTypeArgument(SuperTypeArgument sta1) { - SuperTypeArgument sta2 = (SuperTypeArgument) compareElement; - return similarityChecker.isSimilar(sta1.getSuperType(), sta2.getSuperType()); + SuperTypeArgument sta2 = (SuperTypeArgument) this.getCompareElement(); + return this.isSimilar(sta1.getSuperType(), sta2.getSuperType()); } @Override public Boolean caseExtendsTypeArgument(ExtendsTypeArgument eta1) { - ExtendsTypeArgument eta2 = (ExtendsTypeArgument) compareElement; - return similarityChecker.isSimilar(eta1.getExtendType(), eta2.getExtendType()); + ExtendsTypeArgument eta2 = (ExtendsTypeArgument) this.getCompareElement(); + return this.isSimilar(eta1.getExtendType(), eta2.getExtendType()); } @Override @@ -36,13 +61,12 @@ public Boolean caseUnknownTypeArgument(UnknownTypeArgument arg) { @Override public Boolean caseTypeParameter(TypeParameter param1) { - TypeParameter param2 = (TypeParameter) compareElement; + TypeParameter param2 = (TypeParameter) this.getCompareElement(); if (!param1.getName().equals(param2.getName())) { return Boolean.FALSE; } - return similarityChecker.areSimilar(param1.getExtendTypes(), param2.getExtendTypes()); + return this.areSimilar(param1.getExtendTypes(), param2.getExtendTypes()); } -} - +} \ No newline at end of file diff --git a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/ImportsSimilaritySwitch.java b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/ImportsSimilaritySwitch.java index 37ae5724a3..0cff9de19e 100644 --- a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/ImportsSimilaritySwitch.java +++ b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/ImportsSimilaritySwitch.java @@ -4,20 +4,44 @@ import org.emftext.language.java.imports.StaticMemberImport; import org.emftext.language.java.imports.util.ImportsSwitch; import org.emftext.language.java.references.ReferenceableElement; +import org.splevo.jamopp.diffing.similarity.IJavaSimilaritySwitch; +import org.splevo.jamopp.diffing.similarity.base.ISimilarityRequestHandler; import com.google.common.base.Strings; /** * Similarity decisions for the import elements. */ -private class ImportsSimilaritySwitch extends ImportsSwitch { +public class ImportsSimilaritySwitch extends ImportsSwitch implements IJavaSimilarityPositionInnerSwitch { + private IJavaSimilaritySwitch similaritySwitch; + private boolean checkStatementPosition; - @Override + @Override + public ISimilarityRequestHandler getSimilarityRequestHandler() { + return this.similaritySwitch; + } + + @Override + public boolean shouldCheckStatementPosition() { + return this.checkStatementPosition; + } + + @Override + public IJavaSimilaritySwitch getContainingSwitch() { + return this.similaritySwitch; + } + + public ImportsSimilaritySwitch(IJavaSimilaritySwitch similaritySwitch, boolean checkStatementPosition) { + this.similaritySwitch = similaritySwitch; + this.checkStatementPosition = checkStatementPosition; + } + + @Override public Boolean caseClassifierImport(ClassifierImport import1) { - ClassifierImport import2 = (ClassifierImport) compareElement; + ClassifierImport import2 = (ClassifierImport) this.getCompareElement(); - Boolean similarity = similarityChecker.isSimilar(import1.getClassifier(), import2.getClassifier()); + Boolean similarity = this.isSimilar(import1.getClassifier(), import2.getClassifier()); if (similarity == Boolean.FALSE) { return Boolean.FALSE; } @@ -30,7 +54,7 @@ public Boolean caseClassifierImport(ClassifierImport import1) { @Override public Boolean caseStaticMemberImport(StaticMemberImport import1) { - StaticMemberImport import2 = (StaticMemberImport) compareElement; + StaticMemberImport import2 = (StaticMemberImport) this.getCompareElement(); if (import1.getStaticMembers().size() != import2.getStaticMembers().size()) { return Boolean.FALSE; @@ -38,7 +62,7 @@ public Boolean caseStaticMemberImport(StaticMemberImport import1) { for (int i = 0; i < import1.getStaticMembers().size(); i++) { ReferenceableElement member1 = import1.getStaticMembers().get(i); ReferenceableElement member2 = import2.getStaticMembers().get(i); - Boolean similarity = similarityChecker.isSimilar(member1, member2); + Boolean similarity = this.isSimilar(member1, member2); if (similarity == Boolean.FALSE) { return Boolean.FALSE; } @@ -48,4 +72,4 @@ public Boolean caseStaticMemberImport(StaticMemberImport import1) { String namespace2 = Strings.nullToEmpty(import2.getNamespacesAsString()); return (namespace1.equals(namespace2)); } -} +} \ No newline at end of file diff --git a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/InstantiationsSimilaritySwitch.java b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/InstantiationsSimilaritySwitch.java index a71d20cc53..26723a7182 100644 --- a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/InstantiationsSimilaritySwitch.java +++ b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/InstantiationsSimilaritySwitch.java @@ -7,13 +7,37 @@ import org.emftext.language.java.instantiations.NewConstructorCall; import org.emftext.language.java.instantiations.util.InstantiationsSwitch; import org.emftext.language.java.types.Type; +import org.splevo.jamopp.diffing.similarity.IJavaSimilaritySwitch; +import org.splevo.jamopp.diffing.similarity.base.ISimilarityRequestHandler; /** * Similarity decisions for object instantiation elements. */ -private class InstantiationsSimilaritySwitch extends InstantiationsSwitch { +public class InstantiationsSimilaritySwitch extends InstantiationsSwitch implements IJavaSimilarityPositionInnerSwitch { + private IJavaSimilaritySwitch similaritySwitch; + private boolean checkStatementPosition; - /** + @Override + public ISimilarityRequestHandler getSimilarityRequestHandler() { + return this.similaritySwitch; + } + + @Override + public boolean shouldCheckStatementPosition() { + return this.checkStatementPosition; + } + + @Override + public IJavaSimilaritySwitch getContainingSwitch() { + return this.similaritySwitch; + } + + public InstantiationsSimilaritySwitch(IJavaSimilaritySwitch similaritySwitch, boolean checkStatementPosition) { + this.similaritySwitch = similaritySwitch; + this.checkStatementPosition = checkStatementPosition; + } + + /** * Check class instance creation similarity.
* Similarity is checked by *
    @@ -29,10 +53,10 @@ private class InstantiationsSimilaritySwitch extends InstantiationsSwitch { +public class LayoutSimilaritySwitch extends LayoutSwitch { @Override public Boolean defaultCase(EObject object) { return Boolean.TRUE; } -} +} \ No newline at end of file diff --git a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/LiteralsSimilaritySwitch.java b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/LiteralsSimilaritySwitch.java index 4fc73f4331..6354eb61ef 100644 --- a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/LiteralsSimilaritySwitch.java +++ b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/LiteralsSimilaritySwitch.java @@ -16,45 +16,62 @@ import org.emftext.language.java.literals.OctalIntegerLiteral; import org.emftext.language.java.literals.OctalLongLiteral; import org.emftext.language.java.literals.util.LiteralsSwitch; +import org.splevo.jamopp.diffing.similarity.IJavaSimilaritySwitch; +import org.splevo.jamopp.diffing.similarity.base.ISimilarityRequestHandler; /** * Similarity decisions for literal elements. */ -private class LiteralsSimilaritySwitch extends LiteralsSwitch { +public class LiteralsSimilaritySwitch extends LiteralsSwitch implements IJavaSimilarityInnerSwitch { + private IJavaSimilaritySwitch similaritySwitch; - @Override + @Override + public ISimilarityRequestHandler getSimilarityRequestHandler() { + return this.similaritySwitch; + } + + @Override + public IJavaSimilaritySwitch getContainingSwitch() { + return this.similaritySwitch; + } + + public LiteralsSimilaritySwitch(IJavaSimilaritySwitch similaritySwitch) { + this.similaritySwitch = similaritySwitch; + } + + @Override public Boolean caseBooleanLiteral(BooleanLiteral boolean1) { - BooleanLiteral boolean2 = (BooleanLiteral) compareElement; + BooleanLiteral boolean2 = (BooleanLiteral) this.getCompareElement(); return (boolean1.isValue() == boolean2.isValue()); } @Override public Boolean caseCharacterLiteral(CharacterLiteral char1) { - CharacterLiteral char2 = (CharacterLiteral) compareElement; + CharacterLiteral char2 = (CharacterLiteral) this.getCompareElement(); return char1.getValue().equals(char2.getValue()); } @Override public Boolean caseDecimalFloatLiteral(DecimalFloatLiteral float1) { - DecimalFloatLiteral float2 = (DecimalFloatLiteral) compareElement; + DecimalFloatLiteral float2 = (DecimalFloatLiteral) this.getCompareElement(); return compareDouble(float1.getDecimalValue(), float2.getDecimalValue()); } @Override public Boolean caseHexFloatLiteral(HexFloatLiteral float1) { - HexFloatLiteral float2 = (HexFloatLiteral) compareElement; + HexFloatLiteral float2 = (HexFloatLiteral) this.getCompareElement(); return compareDouble(float1.getHexValue(), float2.getHexValue()); } @Override public Boolean caseDecimalDoubleLiteral(DecimalDoubleLiteral double1) { - DecimalDoubleLiteral double2 = (DecimalDoubleLiteral) compareElement; + DecimalDoubleLiteral double2 = (DecimalDoubleLiteral) this.getCompareElement(); return compareDouble(double1.getDecimalValue(), double2.getDecimalValue()); } @Override public Boolean caseHexDoubleLiteral(HexDoubleLiteral double1) { - HexDoubleLiteral double2 = (HexDoubleLiteral) compareElement; + HexDoubleLiteral double2 = (HexDoubleLiteral) this.getCompareElement(); return compareDouble(double1.getHexValue(), double2.getHexValue()); } @@ -64,49 +81,49 @@ private boolean compareDouble(double d1, double d2) { @Override public Boolean caseDecimalIntegerLiteral(DecimalIntegerLiteral int1) { - DecimalIntegerLiteral int2 = (DecimalIntegerLiteral) compareElement; + DecimalIntegerLiteral int2 = (DecimalIntegerLiteral) this.getCompareElement(); return (int1.getDecimalValue().equals(int2.getDecimalValue())); } @Override public Boolean caseHexIntegerLiteral(HexIntegerLiteral int1) { - HexIntegerLiteral int2 = (HexIntegerLiteral) compareElement; + HexIntegerLiteral int2 = (HexIntegerLiteral) this.getCompareElement(); return (int1.getHexValue().equals(int2.getHexValue())); } @Override public Boolean caseOctalIntegerLiteral(OctalIntegerLiteral int1) { - OctalIntegerLiteral int2 = (OctalIntegerLiteral) compareElement; + OctalIntegerLiteral int2 = (OctalIntegerLiteral) this.getCompareElement(); return (int1.getOctalValue().equals(int2.getOctalValue())); } @Override public Boolean caseDecimalLongLiteral(DecimalLongLiteral long1) { - DecimalLongLiteral long2 = (DecimalLongLiteral) compareElement; + DecimalLongLiteral long2 = (DecimalLongLiteral) this.getCompareElement(); return (long1.getDecimalValue().equals(long2.getDecimalValue())); } @Override public Boolean caseHexLongLiteral(HexLongLiteral long1) { - HexLongLiteral long2 = (HexLongLiteral) compareElement; + HexLongLiteral long2 = (HexLongLiteral) this.getCompareElement(); return (long1.getHexValue().equals(long2.getHexValue())); } @Override public Boolean caseOctalLongLiteral(OctalLongLiteral long1) { - OctalLongLiteral long2 = (OctalLongLiteral) compareElement; + OctalLongLiteral long2 = (OctalLongLiteral) this.getCompareElement(); return (long1.getOctalValue().equals(long2.getOctalValue())); } @Override public Boolean caseBinaryLongLiteral(BinaryLongLiteral long1) { - BinaryLongLiteral long2 = (BinaryLongLiteral) compareElement; + BinaryLongLiteral long2 = (BinaryLongLiteral) this.getCompareElement(); return long1.getBinaryValue().equals(long2.getBinaryValue()); } @Override public Boolean caseBinaryIntegerLiteral(BinaryIntegerLiteral int1) { - BinaryIntegerLiteral int2 = (BinaryIntegerLiteral) compareElement; + BinaryIntegerLiteral int2 = (BinaryIntegerLiteral) this.getCompareElement(); return int1.getBinaryValue().equals(int2.getBinaryValue()); } @@ -123,4 +140,4 @@ public Boolean caseBinaryIntegerLiteral(BinaryIntegerLiteral int1) { public Boolean defaultCase(EObject object) { return Boolean.TRUE; } -} +} \ No newline at end of file diff --git a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/MembersSimilaritySwitch.java b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/MembersSimilaritySwitch.java index b0f12b3b66..0051f1a391 100644 --- a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/MembersSimilaritySwitch.java +++ b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/MembersSimilaritySwitch.java @@ -1,5 +1,6 @@ package org.splevo.jamopp.diffing.similarity.switches; +import org.apache.log4j.Level; import org.eclipse.emf.common.util.EList; import org.emftext.language.java.classifiers.AnonymousClass; import org.emftext.language.java.classifiers.ConcreteClassifier; @@ -10,15 +11,40 @@ import org.emftext.language.java.members.util.MembersSwitch; import org.emftext.language.java.parameters.Parameter; import org.emftext.language.java.types.Type; +import org.splevo.jamopp.diffing.similarity.IJavaSimilaritySwitch; +import org.splevo.jamopp.diffing.similarity.ILoggableJavaSwitch; +import org.splevo.jamopp.diffing.similarity.base.ISimilarityRequestHandler; import com.google.common.base.Strings; /** * Similarity decisions for the member elements. */ -private class MembersSimilaritySwitch extends MembersSwitch { - - /** +public class MembersSimilaritySwitch extends MembersSwitch implements ILoggableJavaSwitch, IJavaSimilarityPositionInnerSwitch { + private IJavaSimilaritySwitch similaritySwitch; + private boolean checkStatementPosition; + + @Override + public ISimilarityRequestHandler getSimilarityRequestHandler() { + return this.similaritySwitch; + } + + @Override + public boolean shouldCheckStatementPosition() { + return this.checkStatementPosition; + } + + @Override + public IJavaSimilaritySwitch getContainingSwitch() { + return this.similaritySwitch; + } + + public MembersSimilaritySwitch(IJavaSimilaritySwitch similaritySwitch, boolean checkStatementPosition) { + this.similaritySwitch = similaritySwitch; + this.checkStatementPosition = checkStatementPosition; + } + + /** * Check abstract method declaration similarity. Similarity is checked by *
      *
    • name
      • @@ -44,7 +70,7 @@ private class MembersSimilaritySwitch extends MembersSwitch { @Override public Boolean caseMethod(Method method1) { - Method method2 = (Method) compareElement; + Method method2 = (Method) this.getCompareElement(); // if methods have different names they are not similar. if (!method1.getName().equals(method2.getName())) { @@ -60,7 +86,7 @@ public Boolean caseMethod(Method method1) { Parameter param2 = method2.getParameters().get(i); Type type1 = param1.getTypeReference().getTarget(); Type type2 = param2.getTypeReference().getTarget(); - Boolean typeSimilarity = similarityChecker.isSimilar(type1, type2); + Boolean typeSimilarity = this.isSimilar(type1, type2); if (typeSimilarity == Boolean.FALSE) { return Boolean.FALSE; } @@ -75,7 +101,7 @@ public Boolean caseMethod(Method method1) { if (method1.getContainingConcreteClassifier() != null) { ConcreteClassifier type1 = method1.getContainingConcreteClassifier(); ConcreteClassifier type2 = method2.getContainingConcreteClassifier(); - return similarityChecker.isSimilar(type1, type2); + return this.isSimilar(type1, type2); } /* ************************************** @@ -84,14 +110,14 @@ public Boolean caseMethod(Method method1) { if (method1.getContainingAnonymousClass() != null) { AnonymousClass type1 = method1.getContainingAnonymousClass(); AnonymousClass type2 = method2.getContainingAnonymousClass(); - Boolean typeSimilarity = similarityChecker.isSimilar(type1, type2); + Boolean typeSimilarity = this.isSimilar(type1, type2); if (typeSimilarity != null) { return typeSimilarity; } } - logger.warn("MethodDeclaration in unknown container: " + method1.getName() + " : " - + method1.eContainer()); + this.logMessage("MethodDeclaration in unknown container: " + method1.getName() + " : " + + method1.eContainer(), Level.WARN); return super.caseMethod(method1); } @@ -121,7 +147,7 @@ public Boolean caseMethod(Method method1) { @Override public Boolean caseConstructor(Constructor constructor1) { - Constructor constructor2 = (Constructor) compareElement; + Constructor constructor2 = (Constructor) this.getCompareElement(); // if methods have different names they are not similar. if (!constructor1.getName().equals(constructor2.getName())) { @@ -130,7 +156,7 @@ public Boolean caseConstructor(Constructor constructor1) { EList params1 = constructor1.getParameters(); EList params2 = constructor2.getParameters(); - Boolean parameterSimilarity = similarityChecker.areSimilar(params1, params2); + Boolean parameterSimilarity = this.areSimilar(params1, params2); if (parameterSimilarity == Boolean.FALSE) { return Boolean.FALSE; } @@ -141,7 +167,7 @@ public Boolean caseConstructor(Constructor constructor1) { if (constructor1.getContainingConcreteClassifier() != null) { ConcreteClassifier type1 = constructor1.getContainingConcreteClassifier(); ConcreteClassifier type2 = constructor2.getContainingConcreteClassifier(); - return similarityChecker.isSimilar(type1, type2); + return this.isSimilar(type1, type2); } /* ************************************** @@ -150,20 +176,20 @@ public Boolean caseConstructor(Constructor constructor1) { if (constructor1.getContainingAnonymousClass() != null) { AnonymousClass type1 = constructor1.getContainingAnonymousClass(); AnonymousClass type2 = constructor2.getContainingAnonymousClass(); - Boolean typeSimilarity = similarityChecker.isSimilar(type1, type2); + Boolean typeSimilarity = this.isSimilar(type1, type2); if (typeSimilarity != null) { return typeSimilarity; } } - logger.warn("ConstructorDeclaration in unknown container: " + constructor1.getName() + " : " - + constructor1.eContainer().getClass().getSimpleName()); + this.logMessage("ConstructorDeclaration in unknown container: " + constructor1.getName() + " : " + + constructor1.eContainer().getClass().getSimpleName(), Level.WARN); return super.caseConstructor(constructor1); } @Override public Boolean caseEnumConstant(EnumConstant const1) { - EnumConstant const2 = (EnumConstant) compareElement; + EnumConstant const2 = (EnumConstant) this.getCompareElement(); String name1 = Strings.nullToEmpty(const1.getName()); String name2 = Strings.nullToEmpty(const2.getName()); return (name1.equals(name2)); @@ -171,9 +197,9 @@ public Boolean caseEnumConstant(EnumConstant const1) { @Override public Boolean caseMember(Member member1) { - Member member2 = (Member) compareElement; + Member member2 = (Member) this.getCompareElement(); String name1 = Strings.nullToEmpty(member1.getName()); String name2 = Strings.nullToEmpty(member2.getName()); return (name1.equals(name2)); } -} +} \ No newline at end of file diff --git a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/ModifiersSimilaritySwitch.java b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/ModifiersSimilaritySwitch.java index 530c2c4382..2b54127bdb 100644 --- a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/ModifiersSimilaritySwitch.java +++ b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/ModifiersSimilaritySwitch.java @@ -11,9 +11,9 @@ * called. *

      */ -private class ModifiersSimilaritySwitch extends ModifiersSwitch { +public class ModifiersSimilaritySwitch extends ModifiersSwitch { @Override public Boolean defaultCase(EObject object) { return Boolean.TRUE; } -} +} \ No newline at end of file diff --git a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/ModulesSimilaritySwitch.java b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/ModulesSimilaritySwitch.java index 427ec1f6d8..194d93eceb 100644 --- a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/ModulesSimilaritySwitch.java +++ b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/ModulesSimilaritySwitch.java @@ -6,11 +6,36 @@ import org.emftext.language.java.modules.RequiresModuleDirective; import org.emftext.language.java.modules.UsesModuleDirective; import org.emftext.language.java.modules.util.ModulesSwitch; +import org.splevo.jamopp.diffing.similarity.IJavaSimilaritySwitch; +import org.splevo.jamopp.diffing.similarity.base.ISimilarityRequestHandler; /** * Similarity Decisions for module elements. */ -private class ModulesSimilaritySwitch extends ModulesSwitch { +public class ModulesSimilaritySwitch extends ModulesSwitch implements IJavaSimilarityPositionInnerSwitch { + private IJavaSimilaritySwitch similaritySwitch; + private boolean checkStatementPosition; + + @Override + public ISimilarityRequestHandler getSimilarityRequestHandler() { + return this.similaritySwitch; + } + + @Override + public boolean shouldCheckStatementPosition() { + return this.checkStatementPosition; + } + + @Override + public IJavaSimilaritySwitch getContainingSwitch() { + return this.similaritySwitch; + } + + public ModulesSimilaritySwitch(IJavaSimilaritySwitch similaritySwitch, boolean checkStatementPosition) { + this.similaritySwitch = similaritySwitch; + this.checkStatementPosition = checkStatementPosition; + } + /** * Check ModuleReference similarity.
      * Similarity is checked by @@ -23,8 +48,8 @@ private class ModulesSimilaritySwitch extends ModulesSwitch { */ @Override public Boolean caseModuleReference(ModuleReference modRef1) { - ModuleReference modRef2 = (ModuleReference) compareElement; - if (compareNamespacesByPart(modRef1, modRef2)) { + ModuleReference modRef2 = (ModuleReference) this.getCompareElement(); + if (this.compareNamespacesByPart(modRef1, modRef2)) { return Boolean.TRUE; } return Boolean.FALSE; @@ -42,8 +67,8 @@ public Boolean caseModuleReference(ModuleReference modRef1) { */ @Override public Boolean caseAccessProvidingModuleDirective(AccessProvidingModuleDirective dir1) { - AccessProvidingModuleDirective dir2 = (AccessProvidingModuleDirective) compareElement; - if (!compareNamespacesByPart(dir1, dir2)) { + AccessProvidingModuleDirective dir2 = (AccessProvidingModuleDirective) this.getCompareElement(); + if (!this.compareNamespacesByPart(dir1, dir2)) { return Boolean.FALSE; } return Boolean.TRUE; @@ -61,8 +86,8 @@ public Boolean caseAccessProvidingModuleDirective(AccessProvidingModuleDirective */ @Override public Boolean caseRequiresModuleDirective(RequiresModuleDirective dir1) { - RequiresModuleDirective dir2 = (RequiresModuleDirective) compareElement; - return similarityChecker.isSimilar(dir1.getRequiredModule(), dir2.getRequiredModule()); + RequiresModuleDirective dir2 = (RequiresModuleDirective) this.getCompareElement(); + return this.isSimilar(dir1.getRequiredModule(), dir2.getRequiredModule()); } /** @@ -77,8 +102,8 @@ public Boolean caseRequiresModuleDirective(RequiresModuleDirective dir1) { */ @Override public Boolean caseProvidesModuleDirective(ProvidesModuleDirective dir1) { - ProvidesModuleDirective dir2 = (ProvidesModuleDirective) compareElement; - return similarityChecker.isSimilar(dir1.getTypeReference(), dir2.getTypeReference()); + ProvidesModuleDirective dir2 = (ProvidesModuleDirective) this.getCompareElement(); + return this.isSimilar(dir1.getTypeReference(), dir2.getTypeReference()); } /** @@ -93,7 +118,7 @@ public Boolean caseProvidesModuleDirective(ProvidesModuleDirective dir1) { */ @Override public Boolean caseUsesModuleDirective(UsesModuleDirective dir1) { - UsesModuleDirective dir2 = (UsesModuleDirective) compareElement; - return similarityChecker.isSimilar(dir1.getTypeReference(), dir2.getTypeReference()); + UsesModuleDirective dir2 = (UsesModuleDirective) this.getCompareElement(); + return this.isSimilar(dir1.getTypeReference(), dir2.getTypeReference()); } -} +} \ No newline at end of file diff --git a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/OperatorsSimilaritySwitch.java b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/OperatorsSimilaritySwitch.java index 0aaf41a2bf..d9895f5962 100644 --- a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/OperatorsSimilaritySwitch.java +++ b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/OperatorsSimilaritySwitch.java @@ -11,9 +11,9 @@ * called. *

      */ -private class OperatorsSimilaritySwitch extends OperatorsSwitch { +public class OperatorsSimilaritySwitch extends OperatorsSwitch { @Override public Boolean defaultCase(EObject object) { return Boolean.TRUE; } -} +} \ No newline at end of file diff --git a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/ParametersSimilaritySwitch.java b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/ParametersSimilaritySwitch.java index 1683b3a9a6..9e4f412b4f 100644 --- a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/ParametersSimilaritySwitch.java +++ b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/ParametersSimilaritySwitch.java @@ -2,6 +2,8 @@ import org.emftext.language.java.parameters.Parameter; import org.emftext.language.java.parameters.util.ParametersSwitch; +import org.splevo.jamopp.diffing.similarity.IJavaSimilaritySwitch; +import org.splevo.jamopp.diffing.similarity.base.ISimilarityRequestHandler; import com.google.common.base.Strings; @@ -12,12 +14,28 @@ * more identifying attributes or references exist. *

      */ -private class ParametersSimilaritySwitch extends ParametersSwitch { - @Override +public class ParametersSimilaritySwitch extends ParametersSwitch implements IJavaSimilarityInnerSwitch { + private IJavaSimilaritySwitch similaritySwitch; + + @Override + public ISimilarityRequestHandler getSimilarityRequestHandler() { + return this.similaritySwitch; + } + + @Override + public IJavaSimilaritySwitch getContainingSwitch() { + return this.similaritySwitch; + } + + public ParametersSimilaritySwitch(IJavaSimilaritySwitch similaritySwitch) { + this.similaritySwitch = similaritySwitch; + } + + @Override public Boolean caseParameter(Parameter param1) { - Parameter param2 = (Parameter) compareElement; + Parameter param2 = (Parameter) this.getCompareElement(); String name1 = Strings.nullToEmpty(param1.getName()); String name2 = Strings.nullToEmpty(param2.getName()); return (name1.equals(name2)); } -} +} \ No newline at end of file diff --git a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/ReferencesSimilaritySwitch.java b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/ReferencesSimilaritySwitch.java index 2feaf933ba..1991124f0f 100644 --- a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/ReferencesSimilaritySwitch.java +++ b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/ReferencesSimilaritySwitch.java @@ -10,17 +10,41 @@ import org.emftext.language.java.references.ReferenceableElement; import org.emftext.language.java.references.StringReference; import org.emftext.language.java.references.util.ReferencesSwitch; +import org.splevo.jamopp.diffing.similarity.IJavaSimilaritySwitch; +import org.splevo.jamopp.diffing.similarity.base.ISimilarityRequestHandler; import org.splevo.jamopp.util.JaMoPPElementUtil; /** * Similarity decisions for reference elements. */ -private class ReferencesSimilaritySwitch extends ReferencesSwitch { - - @Override +public class ReferencesSimilaritySwitch extends ReferencesSwitch implements IJavaSimilarityPositionInnerSwitch { + private IJavaSimilaritySwitch similaritySwitch; + private boolean checkStatementPosition; + + @Override + public ISimilarityRequestHandler getSimilarityRequestHandler() { + return this.similaritySwitch; + } + + @Override + public boolean shouldCheckStatementPosition() { + return this.checkStatementPosition; + } + + @Override + public IJavaSimilaritySwitch getContainingSwitch() { + return this.similaritySwitch; + } + + public ReferencesSimilaritySwitch(IJavaSimilaritySwitch similaritySwitch, boolean checkStatementPosition) { + this.similaritySwitch = similaritySwitch; + this.checkStatementPosition = checkStatementPosition; + } + + @Override public Boolean caseStringReference(StringReference ref1) { - StringReference ref2 = (StringReference) compareElement; + StringReference ref2 = (StringReference) this.getCompareElement(); if (ref1.getValue() == null) { return (ref2.getValue() == null); } @@ -31,12 +55,12 @@ public Boolean caseStringReference(StringReference ref1) { @Override public Boolean caseIdentifierReference(IdentifierReference ref1) { - IdentifierReference ref2 = (IdentifierReference) compareElement; + IdentifierReference ref2 = (IdentifierReference) this.getCompareElement(); ReferenceableElement target1 = ref1.getTarget(); ReferenceableElement target2 = ref2.getTarget(); // target identity similarity - Boolean similarity = similarityChecker.isSimilar(target1, target2); + Boolean similarity = this.isSimilar(target1, target2); if (similarity == Boolean.FALSE) { return Boolean.FALSE; } @@ -56,7 +80,7 @@ public Boolean caseIdentifierReference(IdentifierReference ref1) { EObject target2Container = target2.eContainer(); if (target1Container != ref1Container && target2Container != ref2Container && target1Container != ref1 && target2Container != ref2) { - Boolean containerSimilarity = similarityChecker.isSimilar(target1Container, target2Container); + Boolean containerSimilarity = this.isSimilar(target1Container, target2Container); if (containerSimilarity == Boolean.FALSE) { return Boolean.FALSE; } @@ -69,7 +93,7 @@ public Boolean caseIdentifierReference(IdentifierReference ref1) { for (int i = 0; i < ref1.getArraySelectors().size(); i++) { ArraySelector selector1 = ref1.getArraySelectors().get(i); ArraySelector selector2 = ref2.getArraySelectors().get(i); - Boolean positionSimilarity = similarityChecker.isSimilar(selector1.getPosition(), + Boolean positionSimilarity = this.isSimilar(selector1.getPosition(), selector2.getPosition()); if (positionSimilarity == Boolean.FALSE) { return Boolean.FALSE; @@ -78,7 +102,7 @@ public Boolean caseIdentifierReference(IdentifierReference ref1) { Reference next1 = ref1.getNext(); Reference next2 = ref2.getNext(); - Boolean nextSimilarity = similarityChecker.isSimilar(next1, next2); + Boolean nextSimilarity = this.isSimilar(next1, next2); if (nextSimilarity == Boolean.FALSE) { return Boolean.FALSE; } @@ -98,9 +122,9 @@ public Boolean caseIdentifierReference(IdentifierReference ref1) { */ @Override public Boolean caseElementReference(ElementReference ref1) { - ElementReference ref2 = (ElementReference) compareElement; + ElementReference ref2 = (ElementReference) this.getCompareElement(); - Boolean targetSimilarity = similarityChecker.isSimilar(ref1.getTarget(), ref2.getTarget()); + Boolean targetSimilarity = this.isSimilar(ref1.getTarget(), ref2.getTarget()); if (targetSimilarity == Boolean.FALSE) { return Boolean.FALSE; } @@ -119,9 +143,9 @@ public Boolean caseElementReference(ElementReference ref1) { */ @Override public Boolean caseMethodCall(MethodCall call1) { - MethodCall call2 = (MethodCall) compareElement; + MethodCall call2 = (MethodCall) this.getCompareElement(); - Boolean targetSimilarity = similarityChecker.isSimilar(call1.getTarget(), call2.getTarget()); + Boolean targetSimilarity = this.isSimilar(call1.getTarget(), call2.getTarget()); if (targetSimilarity == Boolean.FALSE) { return Boolean.FALSE; } @@ -133,13 +157,13 @@ public Boolean caseMethodCall(MethodCall call1) { for (int i = 0; i < call1.getArguments().size(); i++) { Expression exp1 = call1.getArguments().get(i); Expression exp2 = call2.getArguments().get(i); - Boolean argSimilarity = similarityChecker.isSimilar(exp1, exp2); + Boolean argSimilarity = this.isSimilar(exp1, exp2); if (argSimilarity == Boolean.FALSE) { return Boolean.FALSE; } } - Boolean nextSimilarity = similarityChecker.isSimilar(call1.getNext(), call2.getNext()); + Boolean nextSimilarity = this.isSimilar(call1.getNext(), call2.getNext()); if (nextSimilarity == Boolean.FALSE) { return Boolean.FALSE; } @@ -151,4 +175,4 @@ public Boolean caseMethodCall(MethodCall call1) { public Boolean defaultCase(EObject object) { return Boolean.TRUE; } -} +} \ No newline at end of file diff --git a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/StatementsSimilaritySwitch.java b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/StatementsSimilaritySwitch.java index 0c9dd5d5ea..d00b64891e 100644 --- a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/StatementsSimilaritySwitch.java +++ b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/StatementsSimilaritySwitch.java @@ -17,6 +17,8 @@ import org.emftext.language.java.statements.Throw; import org.emftext.language.java.statements.util.StatementsSwitch; import org.emftext.language.java.variables.Variable; +import org.splevo.jamopp.diffing.similarity.IJavaSimilaritySwitch; +import org.splevo.jamopp.diffing.similarity.base.ISimilarityRequestHandler; import org.splevo.jamopp.util.JaMoPPElementUtil; import com.google.common.base.Strings; @@ -24,23 +26,29 @@ /** * Similarity decisions for the statement elements. */ -private class StatementsSimilaritySwitch extends StatementsSwitch { - - /** - * Flag if the position of a statement should be considered for similarity or not. - */ - private boolean checkStatementPosition = true; - - /** - * Constructor to set required configurations. - * - * @param checkStatementPosition - * Flag if the position of a statement should be considered for similarity or - * not. - */ - public StatementsSimilaritySwitch(boolean checkStatementPosition) { - this.checkStatementPosition = checkStatementPosition; - } +public class StatementsSimilaritySwitch extends StatementsSwitch implements IJavaSimilarityPositionInnerSwitch { + private IJavaSimilaritySwitch similaritySwitch; + private boolean checkStatementPosition; + + @Override + public ISimilarityRequestHandler getSimilarityRequestHandler() { + return this.similaritySwitch; + } + + @Override + public boolean shouldCheckStatementPosition() { + return this.checkStatementPosition; + } + + @Override + public IJavaSimilaritySwitch getContainingSwitch() { + return this.similaritySwitch; + } + + public StatementsSimilaritySwitch(IJavaSimilaritySwitch similaritySwitch, boolean checkStatementPosition) { + this.similaritySwitch = similaritySwitch; + this.checkStatementPosition = checkStatementPosition; + } /** * Check expression statement similarity.
      @@ -56,18 +64,18 @@ public StatementsSimilaritySwitch(boolean checkStatementPosition) { @Override public Boolean caseExpressionStatement(ExpressionStatement statement1) { - ExpressionStatement statement2 = (ExpressionStatement) compareElement; + ExpressionStatement statement2 = (ExpressionStatement) this.getCompareElement(); Expression exp1 = statement1.getExpression(); Expression exp2 = statement2.getExpression(); - Boolean expSimilarity = similarityChecker.isSimilar(exp1, exp2); + Boolean expSimilarity = this.isSimilar(exp1, exp2); if (expSimilarity == Boolean.FALSE) { return Boolean.FALSE; } // check predecessor similarity - if (checkStatementPosition) { + if (this.shouldCheckStatementPosition()) { if (differentPredecessor(statement1, statement2) && differentSuccessor(statement1, statement2)) { return Boolean.FALSE; } @@ -88,17 +96,17 @@ public Boolean caseExpressionStatement(ExpressionStatement statement1) { */ @Override public Boolean caseLocalVariableStatement(LocalVariableStatement varStmt1) { - LocalVariableStatement varStmt2 = (LocalVariableStatement) compareElement; + LocalVariableStatement varStmt2 = (LocalVariableStatement) this.getCompareElement(); Variable var1 = varStmt1.getVariable(); Variable var2 = varStmt2.getVariable(); - Boolean varSimilarity = similarityChecker.isSimilar(var1, var2); + Boolean varSimilarity = this.isSimilar(var1, var2); if (varSimilarity == Boolean.FALSE) { return Boolean.FALSE; } - if (checkStatementPosition) { - varSimilarity = similarityChecker.isSimilar(varStmt1.eContainer(), varStmt2.eContainer(), false); + if (this.shouldCheckStatementPosition()) { + varSimilarity = this.isSimilar(varStmt1.eContainer(), varStmt2.eContainer(), false); if (!varSimilarity) { return Boolean.FALSE; } @@ -124,12 +132,12 @@ public Boolean caseLocalVariableStatement(LocalVariableStatement varStmt1) { @Override public Boolean caseReturn(Return returnStatement1) { - Return returnStatement2 = (Return) compareElement; + Return returnStatement2 = (Return) this.getCompareElement(); Expression exp1 = returnStatement1.getReturnValue(); Expression exp2 = returnStatement2.getReturnValue(); - return similarityChecker.isSimilar(exp1, exp2); + return this.isSimilar(exp1, exp2); } /** @@ -146,16 +154,16 @@ public Boolean caseReturn(Return returnStatement1) { @Override public Boolean caseSynchronizedBlock(SynchronizedBlock statement1) { - SynchronizedBlock statement2 = (SynchronizedBlock) compareElement; + SynchronizedBlock statement2 = (SynchronizedBlock) this.getCompareElement(); Expression exp1 = statement1.getLockProvider(); Expression exp2 = statement2.getLockProvider(); - Boolean similarity = similarityChecker.isSimilar(exp1, exp2); + Boolean similarity = this.isSimilar(exp1, exp2); if (similarity == Boolean.FALSE) { return Boolean.FALSE; } - if (checkStatementPosition) { + if (this.shouldCheckStatementPosition()) { if (differentPredecessor(statement1, statement2) && differentSuccessor(statement1, statement2)) { return Boolean.FALSE; } @@ -181,12 +189,12 @@ public Boolean caseThrow(Throw throwStatement1) { @Override public Boolean caseCatchBlock(CatchBlock catchBlock1) { - CatchBlock catchBlock2 = (CatchBlock) compareElement; + CatchBlock catchBlock2 = (CatchBlock) this.getCompareElement(); OrdinaryParameter catchedException1 = catchBlock1.getParameter(); OrdinaryParameter catchedException2 = catchBlock2.getParameter(); - Boolean exceptionSimilarity = similarityChecker.isSimilar(catchedException1, catchedException2); + Boolean exceptionSimilarity = this.isSimilar(catchedException1, catchedException2); if (exceptionSimilarity == Boolean.FALSE) { return exceptionSimilarity; } @@ -214,11 +222,11 @@ public Boolean caseCatchBlock(CatchBlock catchBlock1) { @Override public Boolean caseConditional(Conditional conditional1) { - Conditional conditional2 = (Conditional) compareElement; + Conditional conditional2 = (Conditional) this.getCompareElement(); Expression expression1 = conditional1.getCondition(); Expression expression2 = conditional2.getCondition(); - Boolean expressionSimilarity = similarityChecker.isSimilar(expression1, expression2); + Boolean expressionSimilarity = this.isSimilar(expression1, expression2); if (expressionSimilarity == Boolean.FALSE) { return expressionSimilarity; } @@ -228,9 +236,9 @@ public Boolean caseConditional(Conditional conditional1) { @Override public Boolean caseJump(Jump jump1) { - Jump jump2 = (Jump) compareElement; + Jump jump2 = (Jump) this.getCompareElement(); - Boolean similarity = similarityChecker.isSimilar(jump1.getTarget(), jump2.getTarget()); + Boolean similarity = this.isSimilar(jump1.getTarget(), jump2.getTarget()); if (similarity == Boolean.FALSE) { return Boolean.FALSE; } @@ -241,7 +249,7 @@ public Boolean caseJump(Jump jump1) { @Override public Boolean caseJumpLabel(JumpLabel label1) { - JumpLabel label2 = (JumpLabel) compareElement; + JumpLabel label2 = (JumpLabel) this.getCompareElement(); String name1 = Strings.nullToEmpty(label1.getName()); String name2 = Strings.nullToEmpty(label2.getName()); @@ -251,9 +259,9 @@ public Boolean caseJumpLabel(JumpLabel label1) { @Override public Boolean caseSwitch(Switch switch1) { - Switch switch2 = (Switch) compareElement; + Switch switch2 = (Switch) this.getCompareElement(); - return similarityChecker.isSimilar(switch1.getVariable(), switch2.getVariable()); + return this.isSimilar(switch1.getVariable(), switch2.getVariable()); } @Override @@ -273,7 +281,7 @@ public Boolean defaultCase(EObject object) { private boolean differentPredecessor(Statement statement1, Statement statement2) { Statement pred1 = getPredecessor(statement1); Statement pred2 = getPredecessor(statement2); - Boolean similarity = similarityChecker.isSimilar(pred1, pred2, false); + Boolean similarity = this.isSimilar(pred1, pred2, false); return similarity == Boolean.FALSE; } @@ -289,7 +297,7 @@ private boolean differentPredecessor(Statement statement1, Statement statement2) private boolean differentSuccessor(Statement statement1, Statement statement2) { Statement pred1 = getSuccessor(statement1); Statement pred2 = getSuccessor(statement2); - Boolean similarity = similarityChecker.isSimilar(pred1, pred2, false); + Boolean similarity = this.isSimilar(pred1, pred2, false); return similarity == Boolean.FALSE; } @@ -334,4 +342,4 @@ private Statement getSuccessor(Statement statement) { return null; } -} +} \ No newline at end of file diff --git a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/TypesSimilaritySwitch.java b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/TypesSimilaritySwitch.java index 76287588e8..711795e256 100644 --- a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/TypesSimilaritySwitch.java +++ b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/TypesSimilaritySwitch.java @@ -7,16 +7,40 @@ import org.emftext.language.java.types.PrimitiveType; import org.emftext.language.java.types.TypeReference; import org.emftext.language.java.types.util.TypesSwitch; -import org.splevo.jamopp.diffing.similarity.SimilarityChecker; +import org.splevo.jamopp.diffing.similarity.base.ISimilarityRequestHandler; +import org.splevo.jamopp.diffing.similarity.IJavaSimilaritySwitch; +import org.splevo.jamopp.diffing.similarity.JavaSimilarityChecker; import com.google.common.base.Strings; /** * Similarity decisions for elements of the types package. */ -private class TypesSimilaritySwitch extends TypesSwitch { - - /** +public class TypesSimilaritySwitch extends TypesSwitch implements IJavaSimilarityPositionInnerSwitch { + private IJavaSimilaritySwitch similaritySwitch; + private boolean checkStatementPosition; + + @Override + public ISimilarityRequestHandler getSimilarityRequestHandler() { + return this.similaritySwitch; + } + + @Override + public boolean shouldCheckStatementPosition() { + return this.checkStatementPosition; + } + + @Override + public IJavaSimilaritySwitch getContainingSwitch() { + return this.similaritySwitch; + } + + public TypesSimilaritySwitch(IJavaSimilaritySwitch similaritySwitch, boolean checkStatementPosition) { + this.similaritySwitch = similaritySwitch; + this.checkStatementPosition = checkStatementPosition; + } + + /** * Check element reference similarity.
      * * Is checked by the target (the method called). Everything else are containment references @@ -28,9 +52,9 @@ private class TypesSimilaritySwitch extends TypesSwitch { */ @Override public Boolean caseClassifierReference(ClassifierReference ref1) { - ClassifierReference ref2 = (ClassifierReference) compareElement; + ClassifierReference ref2 = (ClassifierReference) this.getCompareElement(); - Boolean targetSimilarity = similarityChecker.isSimilar(ref1.getTarget(), ref2.getTarget()); + Boolean targetSimilarity = this.isSimilar(ref1.getTarget(), ref2.getTarget()); if (targetSimilarity == Boolean.FALSE) { return Boolean.FALSE; } @@ -41,9 +65,9 @@ public Boolean caseClassifierReference(ClassifierReference ref1) { @Override public Boolean caseTypeReference(TypeReference ref1) { - TypeReference ref2 = (TypeReference) compareElement; + TypeReference ref2 = (TypeReference) this.getCompareElement(); - Boolean targetSimilarity = similarityChecker.isSimilar(ref1.getTarget(), ref2.getTarget()); + Boolean targetSimilarity = this.isSimilar(ref1.getTarget(), ref2.getTarget()); if (targetSimilarity == Boolean.FALSE) { return Boolean.FALSE; } @@ -54,7 +78,7 @@ public Boolean caseTypeReference(TypeReference ref1) { @Override public Boolean caseNamespaceClassifierReference(NamespaceClassifierReference ref1) { - NamespaceClassifierReference ref2 = (NamespaceClassifierReference) compareElement; + NamespaceClassifierReference ref2 = (NamespaceClassifierReference) this.getCompareElement(); String namespace1 = Strings.nullToEmpty(ref1.getNamespacesAsString()); String namespace2 = Strings.nullToEmpty(ref2.getNamespacesAsString()); @@ -65,12 +89,12 @@ public Boolean caseNamespaceClassifierReference(NamespaceClassifierReference ref ClassifierReference pureRef1 = ref1.getPureClassifierReference(); ClassifierReference pureRef2 = ref2.getPureClassifierReference(); - return similarityChecker.isSimilar(pureRef1, pureRef2); + return this.isSimilar(pureRef1, pureRef2); } /** * Primitive types are always similar as their class similarity is assumed before by the - * outer {@link SimilarityChecker}. + * outer {@link JavaSimilarityChecker}. * * Note: The fall back to the default case is not sufficient here, as the common * TypeReference case would be used before, leading to a loop. @@ -97,11 +121,11 @@ public Boolean caseInferableType(InferableType type) { /** * Primitive type elements are strongly typed and the exact type is already checked by the - * outer {@link SimilarityChecker}.
      + * outer {@link JavaSimilarityChecker}.
      * {@inheritDoc} */ @Override public Boolean defaultCase(EObject object) { return Boolean.TRUE; } -} +} \ No newline at end of file diff --git a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/VariablesSimilaritySwitch.java b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/VariablesSimilaritySwitch.java index a9946b1986..15e672cb69 100644 --- a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/VariablesSimilaritySwitch.java +++ b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/VariablesSimilaritySwitch.java @@ -3,15 +3,32 @@ import org.emftext.language.java.variables.AdditionalLocalVariable; import org.emftext.language.java.variables.Variable; import org.emftext.language.java.variables.util.VariablesSwitch; +import org.splevo.jamopp.diffing.similarity.IJavaSimilaritySwitch; +import org.splevo.jamopp.diffing.similarity.base.ISimilarityRequestHandler; import com.google.common.base.Strings; /** * Similarity decisions for the variable elements. */ -private class VariablesSimilaritySwitch extends VariablesSwitch { +public class VariablesSimilaritySwitch extends VariablesSwitch implements IJavaSimilarityInnerSwitch { + private IJavaSimilaritySwitch similaritySwitch; - /** + @Override + public ISimilarityRequestHandler getSimilarityRequestHandler() { + return this.similaritySwitch; + } + + @Override + public IJavaSimilaritySwitch getContainingSwitch() { + return this.similaritySwitch; + } + + public VariablesSimilaritySwitch(IJavaSimilaritySwitch similaritySwitch) { + this.similaritySwitch = similaritySwitch; + } + + /** * Check variable declaration similarity.
      * Similarity is checked by *
        @@ -26,7 +43,7 @@ private class VariablesSimilaritySwitch extends VariablesSwitch { @Override public Boolean caseVariable(Variable var1) { - Variable var2 = (Variable) compareElement; + Variable var2 = (Variable) this.getCompareElement(); // check the variables name equality if (!var1.getName().equals(var2.getName())) { @@ -38,7 +55,7 @@ public Boolean caseVariable(Variable var1) { @Override public Boolean caseAdditionalLocalVariable(AdditionalLocalVariable var1) { - AdditionalLocalVariable var2 = (AdditionalLocalVariable) compareElement; + AdditionalLocalVariable var2 = (AdditionalLocalVariable) this.getCompareElement(); // check the variables name equality String name1 = Strings.nullToEmpty(var1.getName()); @@ -49,4 +66,4 @@ public Boolean caseAdditionalLocalVariable(AdditionalLocalVariable var1) { return Boolean.TRUE; } -} +} \ No newline at end of file From a5d337fe194caa23d08f560ea9b66cb2475b51a2 Mon Sep 17 00:00:00 2001 From: AlpTorac Date: Thu, 25 Apr 2024 23:09:56 +0200 Subject: [PATCH 22/35] (WIP) Add logging to Java-related inner switches Non-functional commit --- .../switches/AnnotationsSimilaritySwitch.java | 14 +++++--- .../switches/ArraysSimilaritySwitch.java | 5 ++- .../switches/ClassifiersSimilaritySwitch.java | 8 +++-- .../switches/CommonsSimilaritySwitch.java | 5 ++- .../switches/ContainersSimilaritySwitch.java | 13 +++++--- .../switches/ExpressionsSimilaritySwitch.java | 16 ++++++++- .../switches/GenericsSimilaritySwitch.java | 13 +++++++- .../switches/ImportsSimilaritySwitch.java | 5 ++- .../InstantiationsSimilaritySwitch.java | 8 ++++- .../switches/LayoutSimilaritySwitch.java | 5 ++- .../switches/LiteralsSimilaritySwitch.java | 33 ++++++++++++++++++- .../switches/MembersSimilaritySwitch.java | 8 ++++- .../switches/ModifiersSimilaritySwitch.java | 5 ++- .../switches/ModulesSimilaritySwitch.java | 13 +++++++- .../switches/OperatorsSimilaritySwitch.java | 5 ++- .../switches/ParametersSimilaritySwitch.java | 5 ++- .../switches/ReferencesSimilaritySwitch.java | 11 ++++++- .../switches/StatementsSimilaritySwitch.java | 19 ++++++++++- .../switches/TypesSimilaritySwitch.java | 13 +++++++- .../switches/VariablesSimilaritySwitch.java | 6 +++- 20 files changed, 183 insertions(+), 27 deletions(-) diff --git a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/AnnotationsSimilaritySwitch.java b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/AnnotationsSimilaritySwitch.java index 46bb1a6ca0..ceffa1f9e0 100644 --- a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/AnnotationsSimilaritySwitch.java +++ b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/AnnotationsSimilaritySwitch.java @@ -38,10 +38,12 @@ public AnnotationsSimilaritySwitch(IJavaSimilaritySwitch similaritySwitch, boole @Override public Boolean caseAnnotationInstance(AnnotationInstance instance1) { + this.logMessage("caseAnnotationInstance"); + AnnotationInstance instance2 = (AnnotationInstance) this.getCompareElement(); this.logComparison( - instance1.getAnnotation().getName(), - instance2.getAnnotation().getName(), + instance1.getAnnotation(), + instance2.getAnnotation(), AnnotationInstance.class.getSimpleName()); Classifier class1 = instance1.getAnnotation(); @@ -66,8 +68,10 @@ public Boolean caseAnnotationInstance(AnnotationInstance instance1) { @Override public Boolean caseAnnotationAttributeSetting(AnnotationAttributeSetting setting1) { + this.logMessage("caseAnnotationAttributeSetting"); + AnnotationAttributeSetting setting2 = (AnnotationAttributeSetting) this.getCompareElement(); - this.logComparison(setting1.getAttribute().getName(), setting2.getAttribute().getName(), AnnotationAttributeSetting.class.getSimpleName()); + this.logComparison(setting1.getAttribute(), setting2.getAttribute(), AnnotationAttributeSetting.class.getSimpleName()); Boolean similarity = this.isSimilar(setting1.getAttribute(), setting2.getAttribute()); this.logResult(similarity, AnnotationAttributeSetting.class.getSimpleName()); if (similarity == Boolean.FALSE) { @@ -78,7 +82,9 @@ public Boolean caseAnnotationAttributeSetting(AnnotationAttributeSetting setting @Override public Boolean defaultCase(EObject object) { - this.logMessage("Default annotation comparing case (" + object.eClass().getName() +"), similarity: true"); + this.logMessage("defaultCase for Annotation"); + + this.logMessage("Default annotation comparing case for "+AnnotationsSimilaritySwitch.class.getSimpleName()+", similarity: true"); return Boolean.TRUE; } } \ No newline at end of file diff --git a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/ArraysSimilaritySwitch.java b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/ArraysSimilaritySwitch.java index 4f09f34fa4..5dc5aee00f 100644 --- a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/ArraysSimilaritySwitch.java +++ b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/ArraysSimilaritySwitch.java @@ -2,6 +2,7 @@ import org.eclipse.emf.ecore.EObject; import org.emftext.language.java.arrays.util.ArraysSwitch; +import org.splevo.jamopp.diffing.similarity.ILoggableJavaSwitch; /** * Similarity decision for array elements. @@ -10,9 +11,11 @@ * and runtime type are assumed to be checked before this switch is called. So nothing to check * here. */ -public class ArraysSimilaritySwitch extends ArraysSwitch { +public class ArraysSimilaritySwitch extends ArraysSwitch implements ILoggableJavaSwitch { @Override public Boolean defaultCase(EObject object) { + this.logMessage("defaultCase for Array"); + return Boolean.TRUE; } } \ No newline at end of file diff --git a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/ClassifiersSimilaritySwitch.java b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/ClassifiersSimilaritySwitch.java index 82eeac624b..24c3a3c038 100644 --- a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/ClassifiersSimilaritySwitch.java +++ b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/ClassifiersSimilaritySwitch.java @@ -4,6 +4,7 @@ import org.emftext.language.java.classifiers.ConcreteClassifier; import org.emftext.language.java.classifiers.util.ClassifiersSwitch; import org.splevo.jamopp.diffing.similarity.IJavaSimilaritySwitch; +import org.splevo.jamopp.diffing.similarity.ILoggableJavaSwitch; import org.splevo.jamopp.diffing.similarity.base.ISimilarityRequestHandler; import com.google.common.base.Strings; @@ -11,7 +12,7 @@ /** * Similarity decisions for classifier elements. */ -public class ClassifiersSimilaritySwitch extends ClassifiersSwitch implements IJavaSimilarityPositionInnerSwitch { +public class ClassifiersSimilaritySwitch extends ClassifiersSwitch implements ILoggableJavaSwitch, IJavaSimilarityPositionInnerSwitch { private IJavaSimilaritySwitch similaritySwitch; private boolean checkStatementPosition; @@ -45,7 +46,8 @@ public ClassifiersSimilaritySwitch(IJavaSimilaritySwitch similaritySwitch, boole */ @Override public Boolean caseConcreteClassifier(ConcreteClassifier classifier1) { - + this.logMessage("caseConcreteClassifier"); + ConcreteClassifier classifier2 = (ConcreteClassifier) this.getCompareElement(); String name1 = this.normalizeClassifier(classifier1.getQualifiedName()); @@ -62,6 +64,8 @@ public Boolean caseConcreteClassifier(ConcreteClassifier classifier1) { */ @Override public Boolean caseAnonymousClass(AnonymousClass anon) { + this.logMessage("caseAnonymousClass"); + return Boolean.TRUE; } diff --git a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/CommonsSimilaritySwitch.java b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/CommonsSimilaritySwitch.java index 9e9920d25f..38fb70cb04 100644 --- a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/CommonsSimilaritySwitch.java +++ b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/CommonsSimilaritySwitch.java @@ -3,12 +3,13 @@ import org.emftext.language.java.commons.NamedElement; import org.emftext.language.java.commons.util.CommonsSwitch; import org.splevo.jamopp.diffing.similarity.IJavaSimilaritySwitch; +import org.splevo.jamopp.diffing.similarity.ILoggableJavaSwitch; import org.splevo.jamopp.diffing.similarity.base.ISimilarityRequestHandler; /** * Similarity decisions for commons elements. */ -public class CommonsSimilaritySwitch extends CommonsSwitch implements IJavaSimilarityPositionInnerSwitch { +public class CommonsSimilaritySwitch extends CommonsSwitch implements ILoggableJavaSwitch, IJavaSimilarityPositionInnerSwitch { private IJavaSimilaritySwitch similaritySwitch; private boolean checkStatementPosition; @@ -43,6 +44,8 @@ public CommonsSimilaritySwitch(IJavaSimilaritySwitch similaritySwitch, boolean c */ @Override public Boolean caseNamedElement(NamedElement element1) { + this.logMessage("caseNamedElement"); + NamedElement element2 = (NamedElement) this.getCompareElement(); if (element1.getName() == null) { diff --git a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/ContainersSimilaritySwitch.java b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/ContainersSimilaritySwitch.java index 1d17d6d70c..ab98afce0c 100644 --- a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/ContainersSimilaritySwitch.java +++ b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/ContainersSimilaritySwitch.java @@ -53,9 +53,10 @@ public ContainersSimilaritySwitch(IJavaSimilaritySwitch similaritySwitch, boolea */ @Override public Boolean caseCompilationUnit(CompilationUnit unit1) { + this.logMessage("caseCompilationUnit"); + CompilationUnit unit2 = (CompilationUnit) this.getCompareElement(); this.logComparison(unit1.getName(), unit2.getName(), CompilationUnit.class.getSimpleName()); - this.logComparison(unit1.eClass().getName(), unit2.eClass().getName(), "compilation unit class"); String name1 = this.normalizeCompilationUnit(unit1.getName()); name1 = this.normalizePackage(name1); @@ -91,14 +92,16 @@ public Boolean caseCompilationUnit(CompilationUnit unit1) { */ @Override public Boolean casePackage(Package package1) { + this.logMessage("casePackage"); + Package package2 = (Package) this.getCompareElement(); - this.logComparison(package1.getName(), package2.getName(), Package.class.getSimpleName()); - this.logComparison(package1.getNamespacesAsString(), package2.getNamespacesAsString(), "package namespace"); + this.logComparison(package1, package2, Package.class.getSimpleName()); String packagePath1 = JaMoPPModelUtil.buildNamespacePath(package1); packagePath1 = this.normalizeNamespace(packagePath1); String packagePath2 = JaMoPPModelUtil.buildNamespacePath(package2); + this.logComparison(packagePath1, packagePath2, "package namespace"); this.logResult(packagePath1.equals(packagePath2), "package path"); if (!packagePath1.equals(packagePath2)) { @@ -120,10 +123,12 @@ public Boolean casePackage(Package package1) { */ @Override public Boolean caseModule(org.emftext.language.java.containers.Module module1) { + this.logMessage("caseModule"); + org.emftext.language.java.containers.Module module2 = (org.emftext.language.java.containers.Module) this.getCompareElement(); - this.logResult(module1.getName().equals(module2.getName()), Module.class.getSimpleName()); + this.logResult(module1.getName().equals(module2.getName()), org.emftext.language.java.containers.Module.class.getSimpleName()); if (!module1.getName().equals(module2.getName())) { return Boolean.FALSE; } diff --git a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/ExpressionsSimilaritySwitch.java b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/ExpressionsSimilaritySwitch.java index 0a1bb74f98..d444317384 100644 --- a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/ExpressionsSimilaritySwitch.java +++ b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/ExpressionsSimilaritySwitch.java @@ -28,6 +28,7 @@ import org.emftext.language.java.operators.UnaryOperator; import org.emftext.language.java.types.TypeReference; import org.splevo.jamopp.diffing.similarity.IJavaSimilaritySwitch; +import org.splevo.jamopp.diffing.similarity.ILoggableJavaSwitch; import org.splevo.jamopp.diffing.similarity.base.ISimilarityRequestHandler; /** @@ -38,7 +39,7 @@ * called. *

        */ -public class ExpressionsSimilaritySwitch extends ExpressionsSwitch implements IJavaSimilarityPositionInnerSwitch { +public class ExpressionsSimilaritySwitch extends ExpressionsSwitch implements ILoggableJavaSwitch, IJavaSimilarityPositionInnerSwitch { private IJavaSimilaritySwitch similaritySwitch; private boolean checkStatementPosition; @@ -64,6 +65,7 @@ public ExpressionsSimilaritySwitch(IJavaSimilaritySwitch similaritySwitch, boole @Override public Boolean caseAssignmentExpression(AssignmentExpression exp1) { + this.logMessage("caseAssignmentExpression"); AssignmentExpression exp2 = (AssignmentExpression) this.getCompareElement(); @@ -93,6 +95,8 @@ public Boolean caseAssignmentExpression(AssignmentExpression exp1) { @Override public Boolean caseEqualityExpression(EqualityExpression exp1) { + this.logMessage("caseEqualityExpression"); + EqualityExpression exp2 = (EqualityExpression) this.getCompareElement(); // check operator equality @@ -116,6 +120,7 @@ public Boolean caseEqualityExpression(EqualityExpression exp1) { @Override public Boolean caseRelationExpression(RelationExpression exp1) { + this.logMessage("caseRelationExpression"); RelationExpression exp2 = (RelationExpression) this.getCompareElement(); @@ -140,6 +145,7 @@ public Boolean caseRelationExpression(RelationExpression exp1) { @Override public Boolean caseAndExpression(AndExpression exp1) { + this.logMessage("caseAndExpression"); AndExpression exp2 = (AndExpression) this.getCompareElement(); @@ -156,6 +162,7 @@ public Boolean caseAndExpression(AndExpression exp1) { @Override public Boolean caseUnaryExpression(UnaryExpression exp1) { + this.logMessage("caseUnaryExpression"); UnaryExpression exp2 = (UnaryExpression) this.getCompareElement(); @@ -175,6 +182,7 @@ public Boolean caseUnaryExpression(UnaryExpression exp1) { @Override public Boolean caseAdditiveExpression(AdditiveExpression exp1) { + this.logMessage("caseAdditiveExpression"); AdditiveExpression exp2 = (AdditiveExpression) this.getCompareElement(); @@ -188,6 +196,7 @@ public Boolean caseAdditiveExpression(AdditiveExpression exp1) { @Override public Boolean caseInstanceOfExpression(InstanceOfExpression exp1) { + this.logMessage("caseInstanceOfExpression"); InstanceOfExpression exp2 = (InstanceOfExpression) this.getCompareElement(); @@ -207,6 +216,7 @@ public Boolean caseInstanceOfExpression(InstanceOfExpression exp1) { @Override public Boolean caseConditionalOrExpression(ConditionalOrExpression exp1) { + this.logMessage("caseConditionalOrExpression"); ConditionalOrExpression exp2 = (ConditionalOrExpression) this.getCompareElement(); @@ -218,6 +228,7 @@ public Boolean caseConditionalOrExpression(ConditionalOrExpression exp1) { @Override public Boolean caseConditionalAndExpression(ConditionalAndExpression exp1) { + this.logMessage("caseConditionalAndExpression"); ConditionalAndExpression exp2 = (ConditionalAndExpression) this.getCompareElement(); @@ -229,6 +240,7 @@ public Boolean caseConditionalAndExpression(ConditionalAndExpression exp1) { @Override public Boolean caseNestedExpression(NestedExpression exp1) { + this.logMessage("caseNestedExpression"); NestedExpression exp2 = (NestedExpression) this.getCompareElement(); @@ -240,6 +252,8 @@ public Boolean caseNestedExpression(NestedExpression exp1) { @Override public Boolean defaultCase(EObject object) { + this.logMessage("defaultCase for Expression"); + return Boolean.TRUE; } } \ No newline at end of file diff --git a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/GenericsSimilaritySwitch.java b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/GenericsSimilaritySwitch.java index 7309c29b65..5b176f9c98 100644 --- a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/GenericsSimilaritySwitch.java +++ b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/GenericsSimilaritySwitch.java @@ -7,12 +7,13 @@ import org.emftext.language.java.generics.UnknownTypeArgument; import org.emftext.language.java.generics.util.GenericsSwitch; import org.splevo.jamopp.diffing.similarity.IJavaSimilaritySwitch; +import org.splevo.jamopp.diffing.similarity.ILoggableJavaSwitch; import org.splevo.jamopp.diffing.similarity.base.ISimilarityRequestHandler; /** * Similarity decisions for the generic elements. */ -public class GenericsSimilaritySwitch extends GenericsSwitch implements IJavaSimilarityPositionInnerSwitch { +public class GenericsSimilaritySwitch extends GenericsSwitch implements ILoggableJavaSwitch, IJavaSimilarityPositionInnerSwitch { private IJavaSimilaritySwitch similaritySwitch; private boolean checkStatementPosition; @@ -38,29 +39,39 @@ public GenericsSimilaritySwitch(IJavaSimilaritySwitch similaritySwitch, boolean @Override public Boolean caseQualifiedTypeArgument(QualifiedTypeArgument qta1) { + this.logMessage("caseQualifiedTypeArgument"); + QualifiedTypeArgument qta2 = (QualifiedTypeArgument) this.getCompareElement(); return this.isSimilar(qta1.getTypeReference(), qta2.getTypeReference()); } @Override public Boolean caseSuperTypeArgument(SuperTypeArgument sta1) { + this.logMessage("caseSuperTypeArgument"); + SuperTypeArgument sta2 = (SuperTypeArgument) this.getCompareElement(); return this.isSimilar(sta1.getSuperType(), sta2.getSuperType()); } @Override public Boolean caseExtendsTypeArgument(ExtendsTypeArgument eta1) { + this.logMessage("caseExtendsTypeArgument"); + ExtendsTypeArgument eta2 = (ExtendsTypeArgument) this.getCompareElement(); return this.isSimilar(eta1.getExtendType(), eta2.getExtendType()); } @Override public Boolean caseUnknownTypeArgument(UnknownTypeArgument arg) { + this.logMessage("caseUnknownTypeArgument"); + return Boolean.TRUE; } @Override public Boolean caseTypeParameter(TypeParameter param1) { + this.logMessage("caseTypeParameter"); + TypeParameter param2 = (TypeParameter) this.getCompareElement(); if (!param1.getName().equals(param2.getName())) { diff --git a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/ImportsSimilaritySwitch.java b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/ImportsSimilaritySwitch.java index 0cff9de19e..40c6335052 100644 --- a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/ImportsSimilaritySwitch.java +++ b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/ImportsSimilaritySwitch.java @@ -5,6 +5,7 @@ import org.emftext.language.java.imports.util.ImportsSwitch; import org.emftext.language.java.references.ReferenceableElement; import org.splevo.jamopp.diffing.similarity.IJavaSimilaritySwitch; +import org.splevo.jamopp.diffing.similarity.ILoggableJavaSwitch; import org.splevo.jamopp.diffing.similarity.base.ISimilarityRequestHandler; import com.google.common.base.Strings; @@ -12,7 +13,7 @@ /** * Similarity decisions for the import elements. */ -public class ImportsSimilaritySwitch extends ImportsSwitch implements IJavaSimilarityPositionInnerSwitch { +public class ImportsSimilaritySwitch extends ImportsSwitch implements ILoggableJavaSwitch, IJavaSimilarityPositionInnerSwitch { private IJavaSimilaritySwitch similaritySwitch; private boolean checkStatementPosition; @@ -38,6 +39,7 @@ public ImportsSimilaritySwitch(IJavaSimilaritySwitch similaritySwitch, boolean c @Override public Boolean caseClassifierImport(ClassifierImport import1) { + this.logMessage("caseClassifierImport"); ClassifierImport import2 = (ClassifierImport) this.getCompareElement(); @@ -53,6 +55,7 @@ public Boolean caseClassifierImport(ClassifierImport import1) { @Override public Boolean caseStaticMemberImport(StaticMemberImport import1) { + this.logMessage("caseStaticMemberImport"); StaticMemberImport import2 = (StaticMemberImport) this.getCompareElement(); diff --git a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/InstantiationsSimilaritySwitch.java b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/InstantiationsSimilaritySwitch.java index 26723a7182..4e78a5b812 100644 --- a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/InstantiationsSimilaritySwitch.java +++ b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/InstantiationsSimilaritySwitch.java @@ -8,12 +8,13 @@ import org.emftext.language.java.instantiations.util.InstantiationsSwitch; import org.emftext.language.java.types.Type; import org.splevo.jamopp.diffing.similarity.IJavaSimilaritySwitch; +import org.splevo.jamopp.diffing.similarity.ILoggableJavaSwitch; import org.splevo.jamopp.diffing.similarity.base.ISimilarityRequestHandler; /** * Similarity decisions for object instantiation elements. */ -public class InstantiationsSimilaritySwitch extends InstantiationsSwitch implements IJavaSimilarityPositionInnerSwitch { +public class InstantiationsSimilaritySwitch extends InstantiationsSwitch implements ILoggableJavaSwitch, IJavaSimilarityPositionInnerSwitch { private IJavaSimilaritySwitch similaritySwitch; private boolean checkStatementPosition; @@ -52,6 +53,7 @@ public InstantiationsSimilaritySwitch(IJavaSimilaritySwitch similaritySwitch, bo */ @Override public Boolean caseExplicitConstructorCall(ExplicitConstructorCall call1) { + this.logMessage("caseExplicitConstructorCall"); ExplicitConstructorCall call2 = (ExplicitConstructorCall) this.getCompareElement(); @@ -81,6 +83,8 @@ public Boolean caseExplicitConstructorCall(ExplicitConstructorCall call1) { @Override public Boolean caseNewConstructorCall(NewConstructorCall call1) { + this.logMessage("caseNewConstructorCall"); + NewConstructorCall call2 = (NewConstructorCall) this.getCompareElement(); Type type1 = call1.getTypeReference().getTarget(); @@ -109,6 +113,8 @@ public Boolean caseNewConstructorCall(NewConstructorCall call1) { @Override public Boolean defaultCase(EObject object) { + this.logMessage("defaultCase for Instantiation"); + return Boolean.TRUE; } } \ No newline at end of file diff --git a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/LayoutSimilaritySwitch.java b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/LayoutSimilaritySwitch.java index b7f5fc2223..c4fd77ee36 100644 --- a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/LayoutSimilaritySwitch.java +++ b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/LayoutSimilaritySwitch.java @@ -2,14 +2,17 @@ import org.eclipse.emf.ecore.EObject; import org.emftext.commons.layout.util.LayoutSwitch; +import org.splevo.jamopp.diffing.similarity.ILoggableJavaSwitch; /** * Similarity Decisions for layout information is always true as they are not considered for * now. */ -public class LayoutSimilaritySwitch extends LayoutSwitch { +public class LayoutSimilaritySwitch extends LayoutSwitch implements ILoggableJavaSwitch { @Override public Boolean defaultCase(EObject object) { + this.logMessage("defaultCase for Layout"); + return Boolean.TRUE; } } \ No newline at end of file diff --git a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/LiteralsSimilaritySwitch.java b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/LiteralsSimilaritySwitch.java index 6354eb61ef..679a88e23a 100644 --- a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/LiteralsSimilaritySwitch.java +++ b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/LiteralsSimilaritySwitch.java @@ -17,12 +17,13 @@ import org.emftext.language.java.literals.OctalLongLiteral; import org.emftext.language.java.literals.util.LiteralsSwitch; import org.splevo.jamopp.diffing.similarity.IJavaSimilaritySwitch; +import org.splevo.jamopp.diffing.similarity.ILoggableJavaSwitch; import org.splevo.jamopp.diffing.similarity.base.ISimilarityRequestHandler; /** * Similarity decisions for literal elements. */ -public class LiteralsSimilaritySwitch extends LiteralsSwitch implements IJavaSimilarityInnerSwitch { +public class LiteralsSimilaritySwitch extends LiteralsSwitch implements ILoggableJavaSwitch, IJavaSimilarityInnerSwitch { private IJavaSimilaritySwitch similaritySwitch; @Override @@ -41,36 +42,48 @@ public LiteralsSimilaritySwitch(IJavaSimilaritySwitch similaritySwitch) { @Override public Boolean caseBooleanLiteral(BooleanLiteral boolean1) { + this.logMessage("caseBooleanLiteral"); + BooleanLiteral boolean2 = (BooleanLiteral) this.getCompareElement(); return (boolean1.isValue() == boolean2.isValue()); } @Override public Boolean caseCharacterLiteral(CharacterLiteral char1) { + this.logMessage("caseCharacterLiteral"); + CharacterLiteral char2 = (CharacterLiteral) this.getCompareElement(); return char1.getValue().equals(char2.getValue()); } @Override public Boolean caseDecimalFloatLiteral(DecimalFloatLiteral float1) { + this.logMessage("caseDecimalFloatLiteral"); + DecimalFloatLiteral float2 = (DecimalFloatLiteral) this.getCompareElement(); return compareDouble(float1.getDecimalValue(), float2.getDecimalValue()); } @Override public Boolean caseHexFloatLiteral(HexFloatLiteral float1) { + this.logMessage("caseHexFloatLiteral"); + HexFloatLiteral float2 = (HexFloatLiteral) this.getCompareElement(); return compareDouble(float1.getHexValue(), float2.getHexValue()); } @Override public Boolean caseDecimalDoubleLiteral(DecimalDoubleLiteral double1) { + this.logMessage("caseDecimalDoubleLiteral"); + DecimalDoubleLiteral double2 = (DecimalDoubleLiteral) this.getCompareElement(); return compareDouble(double1.getDecimalValue(), double2.getDecimalValue()); } @Override public Boolean caseHexDoubleLiteral(HexDoubleLiteral double1) { + this.logMessage("caseHexDoubleLiteral"); + HexDoubleLiteral double2 = (HexDoubleLiteral) this.getCompareElement(); return compareDouble(double1.getHexValue(), double2.getHexValue()); } @@ -81,48 +94,64 @@ private boolean compareDouble(double d1, double d2) { @Override public Boolean caseDecimalIntegerLiteral(DecimalIntegerLiteral int1) { + this.logMessage("caseDecimalIntegerLiteral"); + DecimalIntegerLiteral int2 = (DecimalIntegerLiteral) this.getCompareElement(); return (int1.getDecimalValue().equals(int2.getDecimalValue())); } @Override public Boolean caseHexIntegerLiteral(HexIntegerLiteral int1) { + this.logMessage("caseHexIntegerLiteral"); + HexIntegerLiteral int2 = (HexIntegerLiteral) this.getCompareElement(); return (int1.getHexValue().equals(int2.getHexValue())); } @Override public Boolean caseOctalIntegerLiteral(OctalIntegerLiteral int1) { + this.logMessage("caseOctalIntegerLiteral"); + OctalIntegerLiteral int2 = (OctalIntegerLiteral) this.getCompareElement(); return (int1.getOctalValue().equals(int2.getOctalValue())); } @Override public Boolean caseDecimalLongLiteral(DecimalLongLiteral long1) { + this.logMessage("caseDecimalLongLiteral"); + DecimalLongLiteral long2 = (DecimalLongLiteral) this.getCompareElement(); return (long1.getDecimalValue().equals(long2.getDecimalValue())); } @Override public Boolean caseHexLongLiteral(HexLongLiteral long1) { + this.logMessage("caseHexLongLiteral"); + HexLongLiteral long2 = (HexLongLiteral) this.getCompareElement(); return (long1.getHexValue().equals(long2.getHexValue())); } @Override public Boolean caseOctalLongLiteral(OctalLongLiteral long1) { + this.logMessage("caseOctalLongLiteral"); + OctalLongLiteral long2 = (OctalLongLiteral) this.getCompareElement(); return (long1.getOctalValue().equals(long2.getOctalValue())); } @Override public Boolean caseBinaryLongLiteral(BinaryLongLiteral long1) { + this.logMessage("caseBinaryLongLiteral"); + BinaryLongLiteral long2 = (BinaryLongLiteral) this.getCompareElement(); return long1.getBinaryValue().equals(long2.getBinaryValue()); } @Override public Boolean caseBinaryIntegerLiteral(BinaryIntegerLiteral int1) { + this.logMessage("caseBinaryIntegerLiteral"); + BinaryIntegerLiteral int2 = (BinaryIntegerLiteral) this.getCompareElement(); return int1.getBinaryValue().equals(int2.getBinaryValue()); } @@ -138,6 +167,8 @@ public Boolean caseBinaryIntegerLiteral(BinaryIntegerLiteral int1) { */ @Override public Boolean defaultCase(EObject object) { + this.logMessage("defaultCase for Literals"); + return Boolean.TRUE; } } \ No newline at end of file diff --git a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/MembersSimilaritySwitch.java b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/MembersSimilaritySwitch.java index 0051f1a391..ecee0fb31c 100644 --- a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/MembersSimilaritySwitch.java +++ b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/MembersSimilaritySwitch.java @@ -69,6 +69,7 @@ public MembersSimilaritySwitch(IJavaSimilaritySwitch similaritySwitch, boolean c */ @Override public Boolean caseMethod(Method method1) { + this.logMessage("caseMethod"); Method method2 = (Method) this.getCompareElement(); @@ -146,6 +147,7 @@ public Boolean caseMethod(Method method1) { */ @Override public Boolean caseConstructor(Constructor constructor1) { + this.logMessage("caseConstructor"); Constructor constructor2 = (Constructor) this.getCompareElement(); @@ -183,12 +185,14 @@ public Boolean caseConstructor(Constructor constructor1) { } this.logMessage("ConstructorDeclaration in unknown container: " + constructor1.getName() + " : " - + constructor1.eContainer().getClass().getSimpleName(), Level.WARN); + + constructor1.eContainer(), Level.WARN); return super.caseConstructor(constructor1); } @Override public Boolean caseEnumConstant(EnumConstant const1) { + this.logMessage("caseEnumConstant"); + EnumConstant const2 = (EnumConstant) this.getCompareElement(); String name1 = Strings.nullToEmpty(const1.getName()); String name2 = Strings.nullToEmpty(const2.getName()); @@ -197,6 +201,8 @@ public Boolean caseEnumConstant(EnumConstant const1) { @Override public Boolean caseMember(Member member1) { + this.logMessage("caseMember"); + Member member2 = (Member) this.getCompareElement(); String name1 = Strings.nullToEmpty(member1.getName()); String name2 = Strings.nullToEmpty(member2.getName()); diff --git a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/ModifiersSimilaritySwitch.java b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/ModifiersSimilaritySwitch.java index 2b54127bdb..c5409839ed 100644 --- a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/ModifiersSimilaritySwitch.java +++ b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/ModifiersSimilaritySwitch.java @@ -2,6 +2,7 @@ import org.eclipse.emf.ecore.EObject; import org.emftext.language.java.modifiers.util.ModifiersSwitch; +import org.splevo.jamopp.diffing.similarity.ILoggableJavaSwitch; /** * Similarity decisions for modifier elements. @@ -11,9 +12,11 @@ * called. *

        */ -public class ModifiersSimilaritySwitch extends ModifiersSwitch { +public class ModifiersSimilaritySwitch extends ModifiersSwitch implements ILoggableJavaSwitch { @Override public Boolean defaultCase(EObject object) { + this.logMessage("defaultCase for Modifier"); + return Boolean.TRUE; } } \ No newline at end of file diff --git a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/ModulesSimilaritySwitch.java b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/ModulesSimilaritySwitch.java index 194d93eceb..a53bd40823 100644 --- a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/ModulesSimilaritySwitch.java +++ b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/ModulesSimilaritySwitch.java @@ -7,12 +7,13 @@ import org.emftext.language.java.modules.UsesModuleDirective; import org.emftext.language.java.modules.util.ModulesSwitch; import org.splevo.jamopp.diffing.similarity.IJavaSimilaritySwitch; +import org.splevo.jamopp.diffing.similarity.ILoggableJavaSwitch; import org.splevo.jamopp.diffing.similarity.base.ISimilarityRequestHandler; /** * Similarity Decisions for module elements. */ -public class ModulesSimilaritySwitch extends ModulesSwitch implements IJavaSimilarityPositionInnerSwitch { +public class ModulesSimilaritySwitch extends ModulesSwitch implements ILoggableJavaSwitch, IJavaSimilarityPositionInnerSwitch { private IJavaSimilaritySwitch similaritySwitch; private boolean checkStatementPosition; @@ -48,6 +49,8 @@ public ModulesSimilaritySwitch(IJavaSimilaritySwitch similaritySwitch, boolean c */ @Override public Boolean caseModuleReference(ModuleReference modRef1) { + this.logMessage("caseModuleReference"); + ModuleReference modRef2 = (ModuleReference) this.getCompareElement(); if (this.compareNamespacesByPart(modRef1, modRef2)) { return Boolean.TRUE; @@ -67,6 +70,8 @@ public Boolean caseModuleReference(ModuleReference modRef1) { */ @Override public Boolean caseAccessProvidingModuleDirective(AccessProvidingModuleDirective dir1) { + this.logMessage("caseAccessProvidingModuleDirective"); + AccessProvidingModuleDirective dir2 = (AccessProvidingModuleDirective) this.getCompareElement(); if (!this.compareNamespacesByPart(dir1, dir2)) { return Boolean.FALSE; @@ -86,6 +91,8 @@ public Boolean caseAccessProvidingModuleDirective(AccessProvidingModuleDirective */ @Override public Boolean caseRequiresModuleDirective(RequiresModuleDirective dir1) { + this.logMessage("caseRequiresModuleDirective"); + RequiresModuleDirective dir2 = (RequiresModuleDirective) this.getCompareElement(); return this.isSimilar(dir1.getRequiredModule(), dir2.getRequiredModule()); } @@ -102,6 +109,8 @@ public Boolean caseRequiresModuleDirective(RequiresModuleDirective dir1) { */ @Override public Boolean caseProvidesModuleDirective(ProvidesModuleDirective dir1) { + this.logMessage("caseProvidesModuleDirective"); + ProvidesModuleDirective dir2 = (ProvidesModuleDirective) this.getCompareElement(); return this.isSimilar(dir1.getTypeReference(), dir2.getTypeReference()); } @@ -118,6 +127,8 @@ public Boolean caseProvidesModuleDirective(ProvidesModuleDirective dir1) { */ @Override public Boolean caseUsesModuleDirective(UsesModuleDirective dir1) { + this.logMessage("caseUsesModuleDirective"); + UsesModuleDirective dir2 = (UsesModuleDirective) this.getCompareElement(); return this.isSimilar(dir1.getTypeReference(), dir2.getTypeReference()); } diff --git a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/OperatorsSimilaritySwitch.java b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/OperatorsSimilaritySwitch.java index d9895f5962..8af7d34720 100644 --- a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/OperatorsSimilaritySwitch.java +++ b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/OperatorsSimilaritySwitch.java @@ -2,6 +2,7 @@ import org.eclipse.emf.ecore.EObject; import org.emftext.language.java.operators.util.OperatorsSwitch; +import org.splevo.jamopp.diffing.similarity.ILoggableJavaSwitch; /** * Similarity decisions for operator elements. @@ -11,9 +12,11 @@ * called. *

        */ -public class OperatorsSimilaritySwitch extends OperatorsSwitch { +public class OperatorsSimilaritySwitch extends OperatorsSwitch implements ILoggableJavaSwitch { @Override public Boolean defaultCase(EObject object) { + this.logMessage("defaultCase for Operator"); + return Boolean.TRUE; } } \ No newline at end of file diff --git a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/ParametersSimilaritySwitch.java b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/ParametersSimilaritySwitch.java index 9e4f412b4f..704ccfc799 100644 --- a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/ParametersSimilaritySwitch.java +++ b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/ParametersSimilaritySwitch.java @@ -3,6 +3,7 @@ import org.emftext.language.java.parameters.Parameter; import org.emftext.language.java.parameters.util.ParametersSwitch; import org.splevo.jamopp.diffing.similarity.IJavaSimilaritySwitch; +import org.splevo.jamopp.diffing.similarity.ILoggableJavaSwitch; import org.splevo.jamopp.diffing.similarity.base.ISimilarityRequestHandler; import com.google.common.base.Strings; @@ -14,7 +15,7 @@ * more identifying attributes or references exist. *

        */ -public class ParametersSimilaritySwitch extends ParametersSwitch implements IJavaSimilarityInnerSwitch { +public class ParametersSimilaritySwitch extends ParametersSwitch implements ILoggableJavaSwitch, IJavaSimilarityInnerSwitch { private IJavaSimilaritySwitch similaritySwitch; @Override @@ -33,6 +34,8 @@ public ParametersSimilaritySwitch(IJavaSimilaritySwitch similaritySwitch) { @Override public Boolean caseParameter(Parameter param1) { + this.logMessage("caseParameter"); + Parameter param2 = (Parameter) this.getCompareElement(); String name1 = Strings.nullToEmpty(param1.getName()); String name2 = Strings.nullToEmpty(param2.getName()); diff --git a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/ReferencesSimilaritySwitch.java b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/ReferencesSimilaritySwitch.java index 1991124f0f..7b5a9c2175 100644 --- a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/ReferencesSimilaritySwitch.java +++ b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/ReferencesSimilaritySwitch.java @@ -11,13 +11,14 @@ import org.emftext.language.java.references.StringReference; import org.emftext.language.java.references.util.ReferencesSwitch; import org.splevo.jamopp.diffing.similarity.IJavaSimilaritySwitch; +import org.splevo.jamopp.diffing.similarity.ILoggableJavaSwitch; import org.splevo.jamopp.diffing.similarity.base.ISimilarityRequestHandler; import org.splevo.jamopp.util.JaMoPPElementUtil; /** * Similarity decisions for reference elements. */ -public class ReferencesSimilaritySwitch extends ReferencesSwitch implements IJavaSimilarityPositionInnerSwitch { +public class ReferencesSimilaritySwitch extends ReferencesSwitch implements ILoggableJavaSwitch, IJavaSimilarityPositionInnerSwitch { private IJavaSimilaritySwitch similaritySwitch; private boolean checkStatementPosition; @@ -43,6 +44,7 @@ public ReferencesSimilaritySwitch(IJavaSimilaritySwitch similaritySwitch, boolea @Override public Boolean caseStringReference(StringReference ref1) { + this.logMessage("caseStringReference"); StringReference ref2 = (StringReference) this.getCompareElement(); if (ref1.getValue() == null) { @@ -54,6 +56,7 @@ public Boolean caseStringReference(StringReference ref1) { @Override public Boolean caseIdentifierReference(IdentifierReference ref1) { + this.logMessage("caseIdentifierReference"); IdentifierReference ref2 = (IdentifierReference) this.getCompareElement(); ReferenceableElement target1 = ref1.getTarget(); @@ -122,6 +125,8 @@ public Boolean caseIdentifierReference(IdentifierReference ref1) { */ @Override public Boolean caseElementReference(ElementReference ref1) { + this.logMessage("caseElementReference"); + ElementReference ref2 = (ElementReference) this.getCompareElement(); Boolean targetSimilarity = this.isSimilar(ref1.getTarget(), ref2.getTarget()); @@ -143,6 +148,8 @@ public Boolean caseElementReference(ElementReference ref1) { */ @Override public Boolean caseMethodCall(MethodCall call1) { + this.logMessage("caseMethodCall"); + MethodCall call2 = (MethodCall) this.getCompareElement(); Boolean targetSimilarity = this.isSimilar(call1.getTarget(), call2.getTarget()); @@ -173,6 +180,8 @@ public Boolean caseMethodCall(MethodCall call1) { @Override public Boolean defaultCase(EObject object) { + this.logMessage("defaultCase for Reference"); + return Boolean.TRUE; } } \ No newline at end of file diff --git a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/StatementsSimilaritySwitch.java b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/StatementsSimilaritySwitch.java index d00b64891e..5803c83123 100644 --- a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/StatementsSimilaritySwitch.java +++ b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/StatementsSimilaritySwitch.java @@ -18,6 +18,7 @@ import org.emftext.language.java.statements.util.StatementsSwitch; import org.emftext.language.java.variables.Variable; import org.splevo.jamopp.diffing.similarity.IJavaSimilaritySwitch; +import org.splevo.jamopp.diffing.similarity.ILoggableJavaSwitch; import org.splevo.jamopp.diffing.similarity.base.ISimilarityRequestHandler; import org.splevo.jamopp.util.JaMoPPElementUtil; @@ -26,7 +27,7 @@ /** * Similarity decisions for the statement elements. */ -public class StatementsSimilaritySwitch extends StatementsSwitch implements IJavaSimilarityPositionInnerSwitch { +public class StatementsSimilaritySwitch extends StatementsSwitch implements ILoggableJavaSwitch, IJavaSimilarityPositionInnerSwitch { private IJavaSimilaritySwitch similaritySwitch; private boolean checkStatementPosition; @@ -63,6 +64,7 @@ public StatementsSimilaritySwitch(IJavaSimilaritySwitch similaritySwitch, boolea */ @Override public Boolean caseExpressionStatement(ExpressionStatement statement1) { + this.logMessage("caseExpressionStatement"); ExpressionStatement statement2 = (ExpressionStatement) this.getCompareElement(); @@ -96,6 +98,8 @@ public Boolean caseExpressionStatement(ExpressionStatement statement1) { */ @Override public Boolean caseLocalVariableStatement(LocalVariableStatement varStmt1) { + this.logMessage("caseLocalVariableStatement"); + LocalVariableStatement varStmt2 = (LocalVariableStatement) this.getCompareElement(); Variable var1 = varStmt1.getVariable(); @@ -131,6 +135,7 @@ public Boolean caseLocalVariableStatement(LocalVariableStatement varStmt1) { */ @Override public Boolean caseReturn(Return returnStatement1) { + this.logMessage("caseReturn"); Return returnStatement2 = (Return) this.getCompareElement(); @@ -153,6 +158,7 @@ public Boolean caseReturn(Return returnStatement1) { */ @Override public Boolean caseSynchronizedBlock(SynchronizedBlock statement1) { + this.logMessage("caseSynchronizedBlock"); SynchronizedBlock statement2 = (SynchronizedBlock) this.getCompareElement(); @@ -183,11 +189,14 @@ public Boolean caseSynchronizedBlock(SynchronizedBlock statement1) { */ @Override public Boolean caseThrow(Throw throwStatement1) { + this.logMessage("caseThrow"); + return Boolean.TRUE; } @Override public Boolean caseCatchBlock(CatchBlock catchBlock1) { + this.logMessage("caseCatchBlock"); CatchBlock catchBlock2 = (CatchBlock) this.getCompareElement(); @@ -221,6 +230,7 @@ public Boolean caseCatchBlock(CatchBlock catchBlock1) { */ @Override public Boolean caseConditional(Conditional conditional1) { + this.logMessage("caseConditional"); Conditional conditional2 = (Conditional) this.getCompareElement(); @@ -236,6 +246,8 @@ public Boolean caseConditional(Conditional conditional1) { @Override public Boolean caseJump(Jump jump1) { + this.logMessage("caseJump"); + Jump jump2 = (Jump) this.getCompareElement(); Boolean similarity = this.isSimilar(jump1.getTarget(), jump2.getTarget()); @@ -248,6 +260,7 @@ public Boolean caseJump(Jump jump1) { @Override public Boolean caseJumpLabel(JumpLabel label1) { + this.logMessage("caseJumpLabel"); JumpLabel label2 = (JumpLabel) this.getCompareElement(); @@ -259,6 +272,8 @@ public Boolean caseJumpLabel(JumpLabel label1) { @Override public Boolean caseSwitch(Switch switch1) { + this.logMessage("caseSwitch"); + Switch switch2 = (Switch) this.getCompareElement(); return this.isSimilar(switch1.getVariable(), switch2.getVariable()); @@ -266,6 +281,8 @@ public Boolean caseSwitch(Switch switch1) { @Override public Boolean defaultCase(EObject object) { + this.logMessage("defaultCase for Statement"); + return Boolean.TRUE; } diff --git a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/TypesSimilaritySwitch.java b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/TypesSimilaritySwitch.java index 711795e256..49a69d46b5 100644 --- a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/TypesSimilaritySwitch.java +++ b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/TypesSimilaritySwitch.java @@ -9,6 +9,7 @@ import org.emftext.language.java.types.util.TypesSwitch; import org.splevo.jamopp.diffing.similarity.base.ISimilarityRequestHandler; import org.splevo.jamopp.diffing.similarity.IJavaSimilaritySwitch; +import org.splevo.jamopp.diffing.similarity.ILoggableJavaSwitch; import org.splevo.jamopp.diffing.similarity.JavaSimilarityChecker; import com.google.common.base.Strings; @@ -16,7 +17,7 @@ /** * Similarity decisions for elements of the types package. */ -public class TypesSimilaritySwitch extends TypesSwitch implements IJavaSimilarityPositionInnerSwitch { +public class TypesSimilaritySwitch extends TypesSwitch implements ILoggableJavaSwitch, IJavaSimilarityPositionInnerSwitch { private IJavaSimilaritySwitch similaritySwitch; private boolean checkStatementPosition; @@ -52,6 +53,8 @@ public TypesSimilaritySwitch(IJavaSimilaritySwitch similaritySwitch, boolean che */ @Override public Boolean caseClassifierReference(ClassifierReference ref1) { + this.logMessage("caseClassifierReference"); + ClassifierReference ref2 = (ClassifierReference) this.getCompareElement(); Boolean targetSimilarity = this.isSimilar(ref1.getTarget(), ref2.getTarget()); @@ -64,6 +67,7 @@ public Boolean caseClassifierReference(ClassifierReference ref1) { @Override public Boolean caseTypeReference(TypeReference ref1) { + this.logMessage("caseTypeReference"); TypeReference ref2 = (TypeReference) this.getCompareElement(); @@ -77,6 +81,7 @@ public Boolean caseTypeReference(TypeReference ref1) { @Override public Boolean caseNamespaceClassifierReference(NamespaceClassifierReference ref1) { + this.logMessage("caseNamespaceClassifierReference"); NamespaceClassifierReference ref2 = (NamespaceClassifierReference) this.getCompareElement(); @@ -105,6 +110,8 @@ public Boolean caseNamespaceClassifierReference(NamespaceClassifierReference ref */ @Override public Boolean casePrimitiveType(PrimitiveType type) { + this.logMessage("casePrimitiveType"); + return Boolean.TRUE; } @@ -116,6 +123,8 @@ public Boolean casePrimitiveType(PrimitiveType type) { */ @Override public Boolean caseInferableType(InferableType type) { + this.logMessage("caseInferableType"); + return Boolean.TRUE; } @@ -126,6 +135,8 @@ public Boolean caseInferableType(InferableType type) { */ @Override public Boolean defaultCase(EObject object) { + this.logMessage("defaultCase for Type"); + return Boolean.TRUE; } } \ No newline at end of file diff --git a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/VariablesSimilaritySwitch.java b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/VariablesSimilaritySwitch.java index 15e672cb69..6884027974 100644 --- a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/VariablesSimilaritySwitch.java +++ b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/switches/VariablesSimilaritySwitch.java @@ -4,6 +4,7 @@ import org.emftext.language.java.variables.Variable; import org.emftext.language.java.variables.util.VariablesSwitch; import org.splevo.jamopp.diffing.similarity.IJavaSimilaritySwitch; +import org.splevo.jamopp.diffing.similarity.ILoggableJavaSwitch; import org.splevo.jamopp.diffing.similarity.base.ISimilarityRequestHandler; import com.google.common.base.Strings; @@ -11,7 +12,7 @@ /** * Similarity decisions for the variable elements. */ -public class VariablesSimilaritySwitch extends VariablesSwitch implements IJavaSimilarityInnerSwitch { +public class VariablesSimilaritySwitch extends VariablesSwitch implements ILoggableJavaSwitch, IJavaSimilarityInnerSwitch { private IJavaSimilaritySwitch similaritySwitch; @Override @@ -42,6 +43,7 @@ public VariablesSimilaritySwitch(IJavaSimilaritySwitch similaritySwitch) { */ @Override public Boolean caseVariable(Variable var1) { + this.logMessage("caseVariable"); Variable var2 = (Variable) this.getCompareElement(); @@ -55,6 +57,8 @@ public Boolean caseVariable(Variable var1) { @Override public Boolean caseAdditionalLocalVariable(AdditionalLocalVariable var1) { + this.logMessage("caseAdditionalLocalVariable"); + AdditionalLocalVariable var2 = (AdditionalLocalVariable) this.getCompareElement(); // check the variables name equality From 2e77e55300438e7c6e2875c3cb457dcf84b9d212 Mon Sep 17 00:00:00 2001 From: AlpTorac Date: Fri, 30 Aug 2024 18:59:38 +0200 Subject: [PATCH 23/35] (WIP) Implement toolbox builder For Java-related similarity checking Non-functional commit --- .../JavaSimilarityToolboxBuilder.java | 114 ++++++++++++++++++ 1 file changed, 114 insertions(+) create mode 100644 commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/JavaSimilarityToolboxBuilder.java diff --git a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/JavaSimilarityToolboxBuilder.java b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/JavaSimilarityToolboxBuilder.java new file mode 100644 index 0000000000..cd454f1bab --- /dev/null +++ b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/JavaSimilarityToolboxBuilder.java @@ -0,0 +1,114 @@ +package org.splevo.jamopp.diffing.similarity; + +import java.util.LinkedHashMap; +import java.util.Map; +import java.util.regex.Pattern; + +import org.splevo.jamopp.diffing.similarity.base.AbstractSimilarityToolboxBuilder; +import org.splevo.jamopp.diffing.similarity.base.ISimilarityRequest; +import org.splevo.jamopp.diffing.similarity.base.ISimilarityRequestHandler; +import org.splevo.jamopp.diffing.similarity.base.ecore.MultipleSimilarityCheckHandler; +import org.splevo.jamopp.diffing.similarity.base.ecore.MultipleSimilarityCheckRequest; +import org.splevo.jamopp.diffing.similarity.base.ecore.SingleSimilarityCheckHandler; +import org.splevo.jamopp.diffing.similarity.base.ecore.SingleSimilarityCheckRequest; +import org.splevo.jamopp.diffing.similarity.handlers.ClassifierNormalizationHandler; +import org.splevo.jamopp.diffing.similarity.handlers.CompilationUnitNormalizationHandler; +import org.splevo.jamopp.diffing.similarity.handlers.NamespaceCheckHandler; +import org.splevo.jamopp.diffing.similarity.handlers.NamespaceNormalizationHandler; +import org.splevo.jamopp.diffing.similarity.handlers.NewSimilaritySwitchHandler; +import org.splevo.jamopp.diffing.similarity.handlers.PackageNormalizationHandler; +import org.splevo.jamopp.diffing.similarity.requests.ClassifierNormalizationRequest; +import org.splevo.jamopp.diffing.similarity.requests.NamespaceCheckRequest; +import org.splevo.jamopp.diffing.similarity.requests.CompilationUnitNormalizationRequest; +import org.splevo.jamopp.diffing.similarity.requests.NamespaceNormalizationRequest; +import org.splevo.jamopp.diffing.similarity.requests.NewSimilaritySwitchRequest; +import org.splevo.jamopp.diffing.similarity.requests.PackageNormalizationRequest; + +/** + * Concrete implementation of {@link AbstractSimilarityToolboxBuilder} for + * constructing {@link ISimilarityToolbox} instances for computing similarity of + * Java model elements. + * + * @author atora + */ +public class JavaSimilarityToolboxBuilder extends AbstractSimilarityToolboxBuilder { + @Override + public JavaSimilarityToolboxBuilder instantiate() { + return (JavaSimilarityToolboxBuilder) super.instantiate(); + } + + @Override + public JavaSimilarityToolboxBuilder buildRequestHandlerPair(Class req, + ISimilarityRequestHandler srh) { + return (JavaSimilarityToolboxBuilder) super.buildRequestHandlerPair(req, srh); + } + + /** + * Adds the handlers needed to handle normalisation related + * {@link ISimilarityRequest} instances. Passes the given parameters to their + * corresponding handlers. + * + * @return this + * @see {@link NormalizationUtil} + */ + public JavaSimilarityToolboxBuilder buildNormalizationHandlers(Map classifierNormalizations, + Map compilationUnitNormalizations, Map packageNormalizations) { + + this.buildRequestHandlerPair(ClassifierNormalizationRequest.class, + new ClassifierNormalizationHandler(classifierNormalizations)); + this.buildRequestHandlerPair(CompilationUnitNormalizationRequest.class, + new CompilationUnitNormalizationHandler(compilationUnitNormalizations)); + this.buildRequestHandlerPair(PackageNormalizationRequest.class, + new PackageNormalizationHandler(packageNormalizations)); + this.buildRequestHandlerPair(NamespaceNormalizationRequest.class, + new NamespaceNormalizationHandler(packageNormalizations)); + + return this; + } + + /** + * Adds the handlers needed to handle normalisation related + * {@link ISimilarityRequest} instances. Does so without any normalisation + * parameters. + * + * @return this + * @see {@link #buildNormalizationHandlers(Map, Map, Map)} + */ + public JavaSimilarityToolboxBuilder buildNormalizationHandlers() { + var classifierNormalizations = new LinkedHashMap(); + var compilationUnitNormalizations = new LinkedHashMap(); + var packageNormalizations = new LinkedHashMap(); + + return this.buildNormalizationHandlers(classifierNormalizations, compilationUnitNormalizations, + packageNormalizations); + } + + /** + * Adds the handlers required to handle similarity checking related + * {@link ISimilarityRequest} instances. + * + * @return this + */ + public JavaSimilarityToolboxBuilder buildComparisonHandlers() { + this.buildRequestHandlerPair(SingleSimilarityCheckRequest.class, new SingleSimilarityCheckHandler()); + this.buildRequestHandlerPair(MultipleSimilarityCheckRequest.class, + new MultipleSimilarityCheckHandler(this.getCurrentToolbox())); + this.buildRequestHandlerPair(NamespaceCheckRequest.class, new NamespaceCheckHandler()); + + return this; + } + + /** + * Adds the handler needed to handle {@link ISimilarityRequest} instances, which + * request new similarity switch instances. + * + * @return this + * @see {@link IJavaSimilaritySwitch} + */ + public JavaSimilarityToolboxBuilder buildNewSimilaritySwitchHandler() { + this.buildRequestHandlerPair(NewSimilaritySwitchRequest.class, + new NewSimilaritySwitchHandler(this.getCurrentToolbox())); + + return this; + } +} From a6362b6914c0f6311bcb425eb3db32e6a7e56bb2 Mon Sep 17 00:00:00 2001 From: AlpTorac Date: Fri, 30 Aug 2024 18:58:32 +0200 Subject: [PATCH 24/35] (WIP) Adapt SimilarityChecker Rename SimilarityChecker to JavaSimilarityChecker Use the extracted structure in the JavaSimilarityChecker Delegate similarity switch creation by using a new similarity switch request Non-functional commit --- .../similarity/JavaSimilarityChecker.java | 54 +++++ .../diffing/similarity/SimilarityChecker.java | 205 ------------------ 2 files changed, 54 insertions(+), 205 deletions(-) create mode 100644 commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/JavaSimilarityChecker.java delete mode 100644 commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/SimilarityChecker.java diff --git a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/JavaSimilarityChecker.java b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/JavaSimilarityChecker.java new file mode 100644 index 0000000000..9d4b38cb95 --- /dev/null +++ b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/JavaSimilarityChecker.java @@ -0,0 +1,54 @@ +/******************************************************************************* + * Copyright (c) 2014 + * + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Eclipse Public License v1.0 + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v10.html + * + * Contributors: + * Benjamin Klatt - initial API and implementation and/or initial documentation + * Martin Armbruster - enable change of default behavior for statement position check. + *******************************************************************************/ +package org.splevo.jamopp.diffing.similarity; + +import org.apache.log4j.Logger; +import org.splevo.jamopp.diffing.similarity.base.ISimilarityRequest; +import org.splevo.jamopp.diffing.similarity.base.ISimilarityToolbox; +import org.splevo.jamopp.diffing.similarity.base.ecore.AbstractComposedSwitchSimilarityChecker; +import org.splevo.jamopp.diffing.similarity.requests.NewSimilaritySwitchRequest; + +/** + * Checker for the similarity of two elements specific for the java application + * model. + * + * TODO: Check caching for this similarity checker. Would require to pass this + * to the similarity switch as well! + * + */ +public class JavaSimilarityChecker extends AbstractComposedSwitchSimilarityChecker { + + /** The logger for this class. */ + @SuppressWarnings("unused") + private Logger logger = Logger.getLogger(JavaSimilarityChecker.class); + + /** + * Constructs an instance with the given parameter. + * + * @param st {@link ISimilarityToolbox} to which all incoming + * {@link ISimilarityRequest} instances will be delegated to. + */ + public JavaSimilarityChecker(ISimilarityToolbox st) { + super(st); + } + + @Override + protected JavaSimilarityComparer createSimilarityComparer(ISimilarityToolbox st) { + return new JavaSimilarityComparer(st); + } + + @Override + protected ISimilarityRequest makeDefaultSwitchRequest() { + return new NewSimilaritySwitchRequest(true); + } +} diff --git a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/SimilarityChecker.java b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/SimilarityChecker.java deleted file mode 100644 index dfcd2d159a..0000000000 --- a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/similarity/SimilarityChecker.java +++ /dev/null @@ -1,205 +0,0 @@ -/******************************************************************************* - * Copyright (c) 2014 - * - * All rights reserved. This program and the accompanying materials - * are made available under the terms of the Eclipse Public License v1.0 - * which accompanies this distribution, and is available at - * http://www.eclipse.org/legal/epl-v10.html - * - * Contributors: - * Benjamin Klatt - initial API and implementation and/or initial documentation - * Martin Armbruster - enable change of default behavior for statement position check. - *******************************************************************************/ -package org.splevo.jamopp.diffing.similarity; - -import java.util.LinkedHashMap; -import java.util.List; -import java.util.regex.Pattern; - -import org.apache.log4j.Logger; -import org.eclipse.emf.ecore.EObject; -import org.eclipse.emf.ecore.util.EcoreUtil; - -import com.google.common.collect.Maps; - -/** - * Checker for the similarity of two elements specific for the java application model. - * - * TODO: Check caching for this similarity checker. Would require to pass this to the similarity - * switch as well! - * - */ -public class SimilarityChecker { - - /** The logger for this class. */ - @SuppressWarnings("unused") - private Logger logger = Logger.getLogger(SimilarityChecker.class); - - private LinkedHashMap classifierNormalizations = null; - private LinkedHashMap compilationUnitNormalizations = null; - private LinkedHashMap packageNormalizations = null; - private boolean defaultCheckStatementPositionFlag = true; - - /** - * Constructor to set the required configurations. - * - * @param classifierNormalizations - * A list of patterns replace any match in a classifier name with the defined - * replacement string. - * @param compilationUnitNormalizations - * A list of patterns replace any match in a compilation unit name with the defined - * replacement string. - * @param packageNormalizations - * The normalizations to replace expressions. - */ - public SimilarityChecker(LinkedHashMap classifierNormalizations, - LinkedHashMap compilationUnitNormalizations, LinkedHashMap packageNormalizations) { - this.classifierNormalizations = classifierNormalizations; - this.compilationUnitNormalizations = compilationUnitNormalizations; - this.packageNormalizations = packageNormalizations; - } - - /** - * Default constructor for a similarity checker without any normalization configurations. - */ - public SimilarityChecker() { - this.classifierNormalizations = Maps.newLinkedHashMap(); - this.compilationUnitNormalizations = Maps.newLinkedHashMap(); - this.packageNormalizations = Maps.newLinkedHashMap(); - } - - /** - * Indicates if the SimilarityChecker instance checks the position of statements in its default behavior. - * - * @return true if the statement positions are checked. false otherwise. - */ - public boolean checksStatementPositionOnDefault() { - return this.defaultCheckStatementPositionFlag; - } - - /** - * Controls if the SimilarityChecker checks the position of statements in the default behavior. - * - * @param check true if the statement positions are checked. false otherwise. - */ - public void setCheckStatementPositionOnDefault(boolean check) { - this.defaultCheckStatementPositionFlag = check; - } - - /** - * Check two object lists if they are similar. - * - * The elements is compared pairwise and it is the responsibility of the provided list - * implementations to return them in an appropriate order by calling get(i) with a increasing - * index i. - * - * @param elements1 - * The first list of elements to check. - * @param elements2 - * The second list of elements to check. - * @return TRUE, if they are all similar; FALSE if a different number of elements is submitted or at least one pair of elements is not similar to each other. - */ - public Boolean areSimilar(final List elements1, final List elements2) { - if (elements1.size() != elements2.size()) { - return Boolean.FALSE; - } - for (int i = 0; i < elements1.size(); i++) { - Boolean childSimilarity = isSimilar(elements1.get(i), elements2.get(i)); - if (childSimilarity == Boolean.FALSE) { - return Boolean.FALSE; - } - } - - return Boolean.TRUE; - } - - /** - * Check two objects if they are similar. - * - * @param element1 - * The first element to check. - * @param element2 - * The second element to check. - * @return TRUE, if they are similar; FALSE if not, NULL if it can't be decided. - */ - public Boolean isSimilar(final EObject element1, final EObject element2) { - return isSimilar(element1, element2, this.defaultCheckStatementPositionFlag); - } - - /** - * Check two objects if they are similar. - * - * @param element1 - * The first element to check. - * @param element2 - * The second element to check. - * @param checkStatementPosition - * Flag if the position of statement elements should be considered or not. - * @return TRUE, if they are similar; FALSE if not, NULL if it can't be decided. - */ - public Boolean isSimilar(EObject element1, EObject element2, boolean checkStatementPosition) { - - // check that either both or none of them is null - if (element1 == element2) { - return Boolean.TRUE; - } - - if (onlyOneIsNull(element1, element2)) { - return Boolean.FALSE; - } - - // if a proxy is present try to resolve it - // the other element is used as a context. - // TODO Clarify why it can happen that one proxy is resolved and the other is not - // further notes available with the issue - // https://sdqbuild.ipd.kit.edu/jira/browse/SPLEVO-279 - if (element2.eIsProxy() && !element1.eIsProxy()) { - element2 = EcoreUtil.resolve(element2, element1); - } else if (element1.eIsProxy() && !element2.eIsProxy()) { - element1 = EcoreUtil.resolve(element1, element2); - } - - // check the elements to be of the same type - if (!element1.getClass().equals(element2.getClass())) { - return Boolean.FALSE; - } - - // check type specific similarity - return this.checkSimilarityForResolvedAndSameType(element1, element2, checkStatementPosition); - } - - /** - * Checks the similarity of two EObjects where both EObjects are resolved and have the same type. - * - * @param element1 the first EObject. - * @param element2 the second EObject. - * @param checkStatementPosition true if the position of statements should be checked. false otherwise. - * If no statements are involved, the flag can be ignored. - * @return true if the EObjects are similar. null if they cannot be compared. false otherwise. - */ - protected Boolean checkSimilarityForResolvedAndSameType(EObject element1, EObject element2, - boolean checkStatementPosition) { - return new SimilaritySwitch(element2, checkStatementPosition, classifierNormalizations, - compilationUnitNormalizations, packageNormalizations).doSwitch(element1); - } - - /** - * Method to check if only one of the provided elements is null. - * - * @param element1 - * The first element. - * @param element2 - * The second element. - * @return True if only one element is null and the other is not. - */ - private Boolean onlyOneIsNull(final EObject element1, final EObject element2) { - Boolean onlyOneIsNull = false; - if (element1 != null && element2 == null) { - onlyOneIsNull = Boolean.TRUE; - } else if (element1 == null && element2 != null) { - onlyOneIsNull = Boolean.TRUE; - } - return onlyOneIsNull; - } - -} From 88ca0d0f0b60d569a8cadd60c36576fd9be8debe Mon Sep 17 00:00:00 2001 From: AlpTorac Date: Fri, 30 Aug 2024 18:41:23 +0200 Subject: [PATCH 25/35] (WIP) Integrate changes with outside Adapt classes affected by the changes to the Java-related part of the similarity checking Non-functional commit --- ...erarchicalMatchEngineFactoryGenerator.java | 4 ++-- .../util/JavaMatchEngineFactoryGenerator.java | 15 +++++++++++-- ...lityHelperExtensionProviderDescriptor.java | 6 ++--- .../splevo/jamopp/diffing/JaMoPPDiffer.java | 22 ++++++++++++++----- .../diffing/match/JaMoPPEqualityHelper.java | 6 ++--- .../diffing/match/JaMoPPEqualityStrategy.java | 6 ++--- 6 files changed, 41 insertions(+), 18 deletions(-) diff --git a/commit-based-cipm/bundles/fi/cipm.consistency.commitintegration.diff.util/src/cipm/consistency/commitintegration/diff/util/HierarchicalMatchEngineFactoryGenerator.java b/commit-based-cipm/bundles/fi/cipm.consistency.commitintegration.diff.util/src/cipm/consistency/commitintegration/diff/util/HierarchicalMatchEngineFactoryGenerator.java index 93ac1007d9..5310336516 100644 --- a/commit-based-cipm/bundles/fi/cipm.consistency.commitintegration.diff.util/src/cipm/consistency/commitintegration/diff/util/HierarchicalMatchEngineFactoryGenerator.java +++ b/commit-based-cipm/bundles/fi/cipm.consistency.commitintegration.diff.util/src/cipm/consistency/commitintegration/diff/util/HierarchicalMatchEngineFactoryGenerator.java @@ -12,7 +12,7 @@ import org.splevo.jamopp.diffing.match.JaMoPPEqualityStrategy; import org.splevo.jamopp.diffing.match.JaMoPPIgnoreStrategy; import org.splevo.jamopp.diffing.scope.PackageIgnoreChecker; -import org.splevo.jamopp.diffing.similarity.SimilarityChecker; +import org.splevo.jamopp.diffing.similarity.base.ISimilarityChecker; import com.google.common.cache.CacheBuilder; @@ -32,7 +32,7 @@ private HierarchicalMatchEngineFactoryGenerator() { * @param key a key to identify the compared models. * @return the generated factory. */ - public static HierarchicalMatchEngineFactory generateMatchEngineFactory(SimilarityChecker simChecker, String key) { + public static HierarchicalMatchEngineFactory generateMatchEngineFactory(ISimilarityChecker simChecker, String key) { EqualityHelperExtensionProvider.Descriptor.Registry descRegistryImpl = EqualityHelperExtensionProviderDescriptorRegistryImpl.createStandaloneInstance(); descRegistryImpl.put(key, new SimilarityCheckerBasedEqualityHelperExtensionProviderDescriptor(simChecker)); diff --git a/commit-based-cipm/bundles/fi/cipm.consistency.commitintegration.diff.util/src/cipm/consistency/commitintegration/diff/util/JavaMatchEngineFactoryGenerator.java b/commit-based-cipm/bundles/fi/cipm.consistency.commitintegration.diff.util/src/cipm/consistency/commitintegration/diff/util/JavaMatchEngineFactoryGenerator.java index 97d59aae81..00014c26db 100644 --- a/commit-based-cipm/bundles/fi/cipm.consistency.commitintegration.diff.util/src/cipm/consistency/commitintegration/diff/util/JavaMatchEngineFactoryGenerator.java +++ b/commit-based-cipm/bundles/fi/cipm.consistency.commitintegration.diff.util/src/cipm/consistency/commitintegration/diff/util/JavaMatchEngineFactoryGenerator.java @@ -1,7 +1,9 @@ package cipm.consistency.commitintegration.diff.util; import org.splevo.diffing.match.HierarchicalMatchEngineFactory; -import org.splevo.jamopp.diffing.similarity.SimilarityChecker; +import org.splevo.jamopp.diffing.similarity.JavaSimilarityChecker; +import org.splevo.jamopp.diffing.similarity.JavaSimilarityToolboxBuilder; +import org.splevo.jamopp.diffing.similarity.base.MapSimilarityToolboxFactory; /** * A generator for HierarchicalMatchEngineFactories specific to Java models. @@ -18,6 +20,15 @@ private JavaMatchEngineFactoryGenerator() { * @return the generated factory. */ public static HierarchicalMatchEngineFactory generateMatchEngineFactory() { - return HierarchicalMatchEngineFactoryGenerator.generateMatchEngineFactory(new SimilarityChecker(), "javaxmi"); + var builder = new JavaSimilarityToolboxBuilder(); + builder.setSimilarityToolboxFactory(new MapSimilarityToolboxFactory()); + + var toolbox = builder.instantiate() + .buildNewSimilaritySwitchHandler() + .buildNormalizationHandlers() + .buildComparisonHandlers() + .build(); + + return HierarchicalMatchEngineFactoryGenerator.generateMatchEngineFactory(new JavaSimilarityChecker(toolbox), "javaxmi"); } } diff --git a/commit-based-cipm/bundles/fi/cipm.consistency.commitintegration.diff.util/src/cipm/consistency/commitintegration/diff/util/SimilarityCheckerBasedEqualityHelperExtensionProviderDescriptor.java b/commit-based-cipm/bundles/fi/cipm.consistency.commitintegration.diff.util/src/cipm/consistency/commitintegration/diff/util/SimilarityCheckerBasedEqualityHelperExtensionProviderDescriptor.java index c2eb53710e..be42434561 100644 --- a/commit-based-cipm/bundles/fi/cipm.consistency.commitintegration.diff.util/src/cipm/consistency/commitintegration/diff/util/SimilarityCheckerBasedEqualityHelperExtensionProviderDescriptor.java +++ b/commit-based-cipm/bundles/fi/cipm.consistency.commitintegration.diff.util/src/cipm/consistency/commitintegration/diff/util/SimilarityCheckerBasedEqualityHelperExtensionProviderDescriptor.java @@ -5,7 +5,7 @@ import org.eclipse.emf.compare.match.eobject.EqualityHelperExtensionProvider; import org.eclipse.emf.compare.utils.IEqualityHelper; import org.eclipse.emf.ecore.EObject; -import org.splevo.jamopp.diffing.similarity.SimilarityChecker; +import org.splevo.jamopp.diffing.similarity.base.ISimilarityChecker; /** * A descriptor for the provider of a EqualityHelperExtension which is based on the SimilarityChecker. @@ -14,9 +14,9 @@ */ public class SimilarityCheckerBasedEqualityHelperExtensionProviderDescriptor implements EqualityHelperExtensionProvider.Descriptor { - private SimilarityChecker checker; + private ISimilarityChecker checker; - public SimilarityCheckerBasedEqualityHelperExtensionProviderDescriptor(SimilarityChecker check) { + public SimilarityCheckerBasedEqualityHelperExtensionProviderDescriptor(ISimilarityChecker check) { checker = check; } diff --git a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/JaMoPPDiffer.java b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/JaMoPPDiffer.java index 6d8ad5bd2d..35b3ddb311 100644 --- a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/JaMoPPDiffer.java +++ b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/JaMoPPDiffer.java @@ -63,7 +63,10 @@ import org.splevo.jamopp.diffing.postprocessor.JaMoPPPostProcessor; import org.splevo.jamopp.diffing.scope.JavaModelMatchScope; import org.splevo.jamopp.diffing.scope.PackageIgnoreChecker; -import org.splevo.jamopp.diffing.similarity.SimilarityChecker; +import org.splevo.jamopp.diffing.similarity.JavaSimilarityChecker; +import org.splevo.jamopp.diffing.similarity.JavaSimilarityToolboxBuilder; +import org.splevo.jamopp.diffing.similarity.base.ISimilarityChecker; +import org.splevo.jamopp.diffing.similarity.base.MapSimilarityToolboxFactory; import org.splevo.jamopp.extraction.JaMoPPSoftwareModelExtractor; import com.google.common.cache.CacheBuilder; @@ -405,7 +408,7 @@ private boolean isSingleSideRootMatch(Match rootMatch) { private IMatchEngine.Factory.Registry initMatchEngine(PackageIgnoreChecker packageIgnoreChecker, Map diffingOptions) { - SimilarityChecker similarityChecker = initSimilarityChecker(diffingOptions); + ISimilarityChecker similarityChecker = initSimilarityChecker(diffingOptions); IEqualityHelper equalityHelper = initEqualityHelper(similarityChecker); EqualityStrategy equalityStrategy = new JaMoPPEqualityStrategy(similarityChecker); IgnoreStrategy ignoreStrategy = new JaMoPPIgnoreStrategy(packageIgnoreChecker); @@ -428,7 +431,7 @@ private IMatchEngine.Factory.Registry initMatchEngine(PackageIgnoreChecker packa * The map of configurations. * @return The prepared checker. */ - private SimilarityChecker initSimilarityChecker(Map diffingOptions) { + private ISimilarityChecker initSimilarityChecker(Map diffingOptions) { String configString = diffingOptions.get(OPTION_JAVA_CLASSIFIER_NORMALIZATION); LinkedHashMap classifierNorms = NormalizationUtil.loadRemoveNormalizations(configString, null); LinkedHashMap compUnitNorms = NormalizationUtil @@ -437,7 +440,16 @@ private SimilarityChecker initSimilarityChecker(Map diffingOptio String configStringPackage = diffingOptions.get(OPTION_JAVA_PACKAGE_NORMALIZATION); LinkedHashMap packageNorms = NormalizationUtil.loadReplaceNormalizations(configStringPackage); - return new SimilarityChecker(classifierNorms, compUnitNorms, packageNorms); + var builder = new JavaSimilarityToolboxBuilder(); + builder.setSimilarityToolboxFactory(new MapSimilarityToolboxFactory()); + + var toolbox = builder.instantiate() + .buildNewSimilaritySwitchHandler() + .buildNormalizationHandlers(classifierNorms, compUnitNorms, packageNorms) + .buildComparisonHandlers() + .build(); + + return new JavaSimilarityChecker(toolbox); } /** @@ -447,7 +459,7 @@ private SimilarityChecker initSimilarityChecker(Map diffingOptio * The similarity checker to use. * @return The prepared equality helper. */ - private IEqualityHelper initEqualityHelper(SimilarityChecker similarityChecker) { + private IEqualityHelper initEqualityHelper(ISimilarityChecker similarityChecker) { final LoadingCache cache = initEqualityCache(); IEqualityHelper equalityHelper = new JaMoPPEqualityHelper(cache, similarityChecker); return equalityHelper; diff --git a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/match/JaMoPPEqualityHelper.java b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/match/JaMoPPEqualityHelper.java index f684932dd0..d4e46a28f2 100644 --- a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/match/JaMoPPEqualityHelper.java +++ b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/match/JaMoPPEqualityHelper.java @@ -13,7 +13,7 @@ import org.eclipse.emf.compare.utils.EqualityHelper; import org.eclipse.emf.ecore.EObject; -import org.splevo.jamopp.diffing.similarity.SimilarityChecker; +import org.splevo.jamopp.diffing.similarity.base.ISimilarityChecker; import com.google.common.cache.LoadingCache; @@ -23,7 +23,7 @@ public class JaMoPPEqualityHelper extends EqualityHelper { /** A similarity checker for internal similarity comparisons. */ - private SimilarityChecker similarityChecker = null; + private ISimilarityChecker similarityChecker = null; /** * Constructor to initialize the required cache. @@ -34,7 +34,7 @@ public class JaMoPPEqualityHelper extends EqualityHelper { * The similarity checker to be used. */ public JaMoPPEqualityHelper(LoadingCache uriCache, - SimilarityChecker similarityChecker) { + ISimilarityChecker similarityChecker) { super(uriCache); this.similarityChecker = similarityChecker; } diff --git a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/match/JaMoPPEqualityStrategy.java b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/match/JaMoPPEqualityStrategy.java index 468076aa68..9760aaaa37 100644 --- a/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/match/JaMoPPEqualityStrategy.java +++ b/commit-based-cipm/bundles/fi/org.splevo.jamopp.diffing/src/org/splevo/jamopp/diffing/match/JaMoPPEqualityStrategy.java @@ -13,7 +13,7 @@ import org.eclipse.emf.ecore.EObject; import org.splevo.diffing.match.HierarchicalMatchEngine.EqualityStrategy; -import org.splevo.jamopp.diffing.similarity.SimilarityChecker; +import org.splevo.jamopp.diffing.similarity.base.ISimilarityChecker; /** * JaMoPP java model specific equality strategy based on the similarity checker strategy. @@ -21,7 +21,7 @@ public class JaMoPPEqualityStrategy implements EqualityStrategy { /** The similarity checker to use internally for equality checks. */ - private SimilarityChecker similarityChecker = null; + private ISimilarityChecker similarityChecker = null; /** * Constructor to set the required dependencies. @@ -29,7 +29,7 @@ public class JaMoPPEqualityStrategy implements EqualityStrategy { * @param similarityChecker * The similarity checker to proof equality. */ - public JaMoPPEqualityStrategy(SimilarityChecker similarityChecker) { + public JaMoPPEqualityStrategy(ISimilarityChecker similarityChecker) { this.similarityChecker = similarityChecker; } From ee3d19bc50007417549b1990eb58190d852ce5a3 Mon Sep 17 00:00:00 2001 From: AlpTorac Date: Tue, 3 Sep 2024 17:42:58 +0200 Subject: [PATCH 26/35] (WIP) Copy PCM-related inner switches To their own files without modifying them Non-functional commit --- .../switches/SimilarityRepositorySwitch.java | 149 ++++++++++++++++++ .../pcm/switches/SimilaritySeffSwitch.java | 83 ++++++++++ 2 files changed, 232 insertions(+) create mode 100644 commit-based-cipm/bundles/fi/cipm.consistency.commitintegration.diff.util/src/cipm/consistency/commitintegration/diff/util/pcm/switches/SimilarityRepositorySwitch.java create mode 100644 commit-based-cipm/bundles/fi/cipm.consistency.commitintegration.diff.util/src/cipm/consistency/commitintegration/diff/util/pcm/switches/SimilaritySeffSwitch.java diff --git a/commit-based-cipm/bundles/fi/cipm.consistency.commitintegration.diff.util/src/cipm/consistency/commitintegration/diff/util/pcm/switches/SimilarityRepositorySwitch.java b/commit-based-cipm/bundles/fi/cipm.consistency.commitintegration.diff.util/src/cipm/consistency/commitintegration/diff/util/pcm/switches/SimilarityRepositorySwitch.java new file mode 100644 index 0000000000..35d6215985 --- /dev/null +++ b/commit-based-cipm/bundles/fi/cipm.consistency.commitintegration.diff.util/src/cipm/consistency/commitintegration/diff/util/pcm/switches/SimilarityRepositorySwitch.java @@ -0,0 +1,149 @@ +package cipm.consistency.commitintegration.diff.util.pcm.switches; + +import org.palladiosimulator.pcm.repository.BasicComponent; +import org.palladiosimulator.pcm.repository.CollectionDataType; +import org.palladiosimulator.pcm.repository.CompositeComponent; +import org.palladiosimulator.pcm.repository.CompositeDataType; +import org.palladiosimulator.pcm.repository.InnerDeclaration; +import org.palladiosimulator.pcm.repository.OperationInterface; +import org.palladiosimulator.pcm.repository.OperationProvidedRole; +import org.palladiosimulator.pcm.repository.OperationRequiredRole; +import org.palladiosimulator.pcm.repository.OperationSignature; +import org.palladiosimulator.pcm.repository.Parameter; +import org.palladiosimulator.pcm.repository.PrimitiveDataType; +import org.palladiosimulator.pcm.repository.Repository; +import org.palladiosimulator.pcm.repository.util.RepositorySwitch; + +import cipm.consistency.commitintegration.diff.util.pcm.PCMRepositorySimilarityChecker; + +class SimilarityRepositorySwitch extends RepositorySwitch { + @Override + public Boolean caseRepository(Repository repo1) { + Repository repo2 = (Repository) compareElement; + + if (!repo1.getEntityName().equals(repo2.getEntityName())) { + return Boolean.FALSE; + } + + return Boolean.TRUE; + } + + @Override + public Boolean caseOperationInterface(OperationInterface opInterface1) { + OperationInterface opInterface2 = (OperationInterface) compareElement; + + if (!opInterface1.getEntityName().equals(opInterface2.getEntityName())) { + return Boolean.FALSE; + } + + return PCMRepositorySimilarityChecker.this.areSimilar( + opInterface1.getParentInterfaces__Interface(), + opInterface2.getParentInterfaces__Interface()); + } + + @Override + public Boolean caseOperationSignature(OperationSignature sign1) { + OperationSignature sign2 = (OperationSignature) compareElement; + + if (!sign1.getEntityName().equals(sign2.getEntityName())) { + return Boolean.FALSE; + } + + var result = PCMRepositorySimilarityChecker.this.areSimilar( + sign1.getParameters__OperationSignature(), + sign2.getParameters__OperationSignature()); + + if (!result) { + return Boolean.FALSE; + } + + return PCMRepositorySimilarityChecker.this.isSimilar(sign1.getReturnType__OperationSignature(), + sign2.getReturnType__OperationSignature()); + } + + @Override + public Boolean caseParameter(Parameter param1) { + Parameter param2 = (Parameter) compareElement; + + if (!param1.getParameterName().equals(param2.getParameterName())) { + return Boolean.FALSE; + } + + return PCMRepositorySimilarityChecker.this.isSimilar(param1.getDataType__Parameter(), + param2.getDataType__Parameter()); + } + + @Override + public Boolean casePrimitiveDataType(PrimitiveDataType type1) { + PrimitiveDataType type2 = (PrimitiveDataType) compareElement; + return type1.getType() == type2.getType(); + } + + @Override + public Boolean caseCollectionDataType(CollectionDataType type1) { + CollectionDataType type2 = (CollectionDataType) compareElement; + + if (!type1.getEntityName().equals(type2.getEntityName())) { + return Boolean.FALSE; + } + + return PCMRepositorySimilarityChecker.this.isSimilar(type1.getInnerType_CollectionDataType(), + type2.getInnerType_CollectionDataType()); + } + + @Override + public Boolean caseCompositeDataType(CompositeDataType type1) { + CompositeDataType type2 = (CompositeDataType) compareElement; + + if (!type1.getEntityName().equals(type2.getEntityName())) { + return Boolean.FALSE; + } + + return PCMRepositorySimilarityChecker.this.areSimilar(type1.getParentType_CompositeDataType(), + type2.getParentType_CompositeDataType()); + } + + @Override + public Boolean caseInnerDeclaration(InnerDeclaration decl1) { + InnerDeclaration decl2 = (InnerDeclaration) compareElement; + + if (!decl1.getEntityName().equals(decl2.getEntityName())) { + return Boolean.FALSE; + } + + return PCMRepositorySimilarityChecker.this.isSimilar(decl1.getDatatype_InnerDeclaration(), + decl2.getDatatype_InnerDeclaration()); + } + + @Override + public Boolean caseBasicComponent(BasicComponent com1) { + BasicComponent com2 = (BasicComponent) compareElement; + + return com1.getEntityName().equals(com2.getEntityName()); + } + + @Override + public Boolean caseOperationProvidedRole(OperationProvidedRole opRole1) { + OperationProvidedRole opRole2 = (OperationProvidedRole) compareElement; + + return PCMRepositorySimilarityChecker.this.isSimilar( + opRole1.getProvidedInterface__OperationProvidedRole(), + opRole2.getProvidedInterface__OperationProvidedRole()); + } + + @Override + public Boolean caseOperationRequiredRole(OperationRequiredRole reqRole1) { + OperationRequiredRole reqRole2 = (OperationRequiredRole) compareElement; + + return PCMRepositorySimilarityChecker.this.isSimilar( + reqRole1.getRequiredInterface__OperationRequiredRole(), + reqRole2.getRequiredInterface__OperationRequiredRole()); + } + + @Override + public Boolean caseCompositeComponent(CompositeComponent com1) { + CompositeComponent com2 = (CompositeComponent) compareElement; + + return com1.getEntityName().equals(com2.getEntityName()); + } +} diff --git a/commit-based-cipm/bundles/fi/cipm.consistency.commitintegration.diff.util/src/cipm/consistency/commitintegration/diff/util/pcm/switches/SimilaritySeffSwitch.java b/commit-based-cipm/bundles/fi/cipm.consistency.commitintegration.diff.util/src/cipm/consistency/commitintegration/diff/util/pcm/switches/SimilaritySeffSwitch.java new file mode 100644 index 0000000000..5d6c5e8829 --- /dev/null +++ b/commit-based-cipm/bundles/fi/cipm.consistency.commitintegration.diff.util/src/cipm/consistency/commitintegration/diff/util/pcm/switches/SimilaritySeffSwitch.java @@ -0,0 +1,83 @@ +package cipm.consistency.commitintegration.diff.util.pcm.switches; + +import org.palladiosimulator.pcm.seff.AbstractAction; +import org.palladiosimulator.pcm.seff.AbstractBranchTransition; +import org.palladiosimulator.pcm.seff.BranchAction; +import org.palladiosimulator.pcm.seff.CollectionIteratorAction; +import org.palladiosimulator.pcm.seff.ExternalCallAction; +import org.palladiosimulator.pcm.seff.ResourceDemandingBehaviour; +import org.palladiosimulator.pcm.seff.ResourceDemandingSEFF; +import org.palladiosimulator.pcm.seff.util.SeffSwitch; + +import cipm.consistency.commitintegration.diff.util.pcm.PCMRepositorySimilarityChecker; + +class SimilaritySeffSwitch extends SeffSwitch { + private Boolean checkPositionInContainer(AbstractAction action1, AbstractAction action2) { + ResourceDemandingBehaviour parent1 = (ResourceDemandingBehaviour) action1.eContainer(); + ResourceDemandingBehaviour parent2 = (ResourceDemandingBehaviour) action2.eContainer(); + + return parent1.getSteps_Behaviour().indexOf(action1) + == parent2.getSteps_Behaviour().indexOf(action2); + } + + @Override + public Boolean caseAbstractAction(AbstractAction action1) { + AbstractAction action2 = (AbstractAction) compareElement; + return checkPositionInContainer(action1, action2); + } + + @Override + public Boolean caseResourceDemandingBehaviour(ResourceDemandingBehaviour behav1) { + ResourceDemandingBehaviour behav2 = (ResourceDemandingBehaviour) compareElement; + return PCMRepositorySimilarityChecker.this.areSimilar(behav1.getSteps_Behaviour(), behav2.getSteps_Behaviour()); + } + + @Override + public Boolean caseResourceDemandingSEFF(ResourceDemandingSEFF seff1) { + ResourceDemandingSEFF seff2 = (ResourceDemandingSEFF) compareElement; + + return PCMRepositorySimilarityChecker.this.isSimilar(seff1.getDescribedService__SEFF(), + seff2.getDescribedService__SEFF()); + } + + @Override + public Boolean caseCollectionIteratorAction(CollectionIteratorAction action1) { + CollectionIteratorAction action2 = (CollectionIteratorAction) compareElement; + + var result = PCMRepositorySimilarityChecker.this.isSimilar( + action1.getParameter_CollectionIteratorAction(), + action2.getParameter_CollectionIteratorAction()); + + if (!result) { + return Boolean.FALSE; + } + + return checkPositionInContainer(action1, action2); + } + + @Override + public Boolean caseAbstractBranchTransition(AbstractBranchTransition transition1) { + AbstractBranchTransition transition2 = (AbstractBranchTransition) compareElement; + + BranchAction parent1 = (BranchAction) transition1.eContainer(); + BranchAction parent2 = (BranchAction) transition2.eContainer(); + + return parent1.getBranches_Branch().indexOf(transition1) == parent2.getBranches_Branch() + .indexOf(transition2); + } + + @Override + public Boolean caseExternalCallAction(ExternalCallAction action1) { + ExternalCallAction action2 = (ExternalCallAction) compareElement; + + var result = PCMRepositorySimilarityChecker.this.isSimilar( + action1.getCalledService_ExternalService(), + action2.getCalledService_ExternalService()); + + if (!result) { + return Boolean.FALSE; + } + + return checkPositionInContainer(action1, action2); + } +} From d0ed14793f7278c98d329d175cec9a349e48287e Mon Sep 17 00:00:00 2001 From: AlpTorac Date: Tue, 3 Sep 2024 17:50:08 +0200 Subject: [PATCH 27/35] (WIP) Implement similarity switch for PCM Use the extracted structure in PCM-related similarity switch Use extracted inner switches in PCM-related similarity switch Non-similarity switch --- .../pcm/PCMRepositorySimilaritySwitch.java | 66 +++++++++++++++++++ 1 file changed, 66 insertions(+) create mode 100644 commit-based-cipm/bundles/fi/cipm.consistency.commitintegration.diff.util/src/cipm/consistency/commitintegration/diff/util/pcm/PCMRepositorySimilaritySwitch.java diff --git a/commit-based-cipm/bundles/fi/cipm.consistency.commitintegration.diff.util/src/cipm/consistency/commitintegration/diff/util/pcm/PCMRepositorySimilaritySwitch.java b/commit-based-cipm/bundles/fi/cipm.consistency.commitintegration.diff.util/src/cipm/consistency/commitintegration/diff/util/pcm/PCMRepositorySimilaritySwitch.java new file mode 100644 index 0000000000..8f70179a5a --- /dev/null +++ b/commit-based-cipm/bundles/fi/cipm.consistency.commitintegration.diff.util/src/cipm/consistency/commitintegration/diff/util/pcm/PCMRepositorySimilaritySwitch.java @@ -0,0 +1,66 @@ +package cipm.consistency.commitintegration.diff.util.pcm; + +import java.util.Collection; + +import org.eclipse.emf.ecore.util.Switch; +import org.splevo.jamopp.diffing.similarity.base.ISimilarityRequest; +import org.splevo.jamopp.diffing.similarity.base.ISimilarityRequestHandler; +import org.splevo.jamopp.diffing.similarity.base.ecore.AbstractComposedSimilaritySwitch; + +import cipm.consistency.commitintegration.diff.util.pcm.switches.SimilarityRepositorySwitch; +import cipm.consistency.commitintegration.diff.util.pcm.switches.SimilaritySeffSwitch; + +/** + * Concrete implementation of {@link AbstractComposedSimilaritySwitch} for + * computing the similarity of Palladio Component Model (PCM) repositories. + * + * @author atora + */ +public class PCMRepositorySimilaritySwitch extends AbstractComposedSimilaritySwitch + implements IPCMRepositorySimilaritySwitch { + /** + * Constructs an instance with the given request handler and the flag. Adds + * default inner switches to the constructed instance. + * + * @param srh The request handler, to which all incoming + * {@link ISimilarityRequest} instances will be + * delegated. + * @param checkStatementPosition The flag, which denotes whether this switch + * should take positions of statements while + * comparing. + */ + public PCMRepositorySimilaritySwitch(ISimilarityRequestHandler srh, boolean checkStatementPosition) { + super(srh); + + this.addSwitch(new SimilarityRepositorySwitch(this, checkStatementPosition)); + this.addSwitch(new SimilaritySeffSwitch(this, checkStatementPosition)); + } + + /** + * Constructs an instance with the given {@link ISimilarityRequestHandler}. + * + * @param srh The {@link ISimilarityRequestHandler}, to which incoming + * {@link ISimilarityRequest} instances will be delegated. + */ + protected PCMRepositorySimilaritySwitch(ISimilarityRequestHandler srh) { + super(srh); + } + + /** + * Variation of + * {@link #PCMRepositorySimilaritySwitch(ISimilarityRequestHandler)} that + * constructs an instance with the given switches. + */ + protected PCMRepositorySimilaritySwitch(ISimilarityRequestHandler srh, Collection> switches) { + super(srh, switches); + } + + /** + * Variation of + * {@link #PCMRepositorySimilaritySwitch(ISimilarityRequestHandler)} that + * constructs an instance with the given switches. + */ + protected PCMRepositorySimilaritySwitch(ISimilarityRequestHandler srh, Switch[] switches) { + super(srh, switches); + } +} \ No newline at end of file From 45ddfdbb21a92eab7b74339efd62559b6cae9c31 Mon Sep 17 00:00:00 2001 From: AlpTorac Date: Mon, 2 Sep 2024 19:03:25 +0200 Subject: [PATCH 28/35] (WIP) Implement request and handler For creating new PCM-related similarity switches Non-functional commit --- ...wPCMRepositorySimilaritySwitchHandler.java | 51 +++++++++++++++++++ ...wPCMRepositorySimilaritySwitchRequest.java | 35 +++++++++++++ 2 files changed, 86 insertions(+) create mode 100644 commit-based-cipm/bundles/fi/cipm.consistency.commitintegration.diff.util/src/cipm/consistency/commitintegration/diff/util/pcm/handlers/NewPCMRepositorySimilaritySwitchHandler.java create mode 100644 commit-based-cipm/bundles/fi/cipm.consistency.commitintegration.diff.util/src/cipm/consistency/commitintegration/diff/util/pcm/requests/NewPCMRepositorySimilaritySwitchRequest.java diff --git a/commit-based-cipm/bundles/fi/cipm.consistency.commitintegration.diff.util/src/cipm/consistency/commitintegration/diff/util/pcm/handlers/NewPCMRepositorySimilaritySwitchHandler.java b/commit-based-cipm/bundles/fi/cipm.consistency.commitintegration.diff.util/src/cipm/consistency/commitintegration/diff/util/pcm/handlers/NewPCMRepositorySimilaritySwitchHandler.java new file mode 100644 index 0000000000..e43f434872 --- /dev/null +++ b/commit-based-cipm/bundles/fi/cipm.consistency.commitintegration.diff.util/src/cipm/consistency/commitintegration/diff/util/pcm/handlers/NewPCMRepositorySimilaritySwitchHandler.java @@ -0,0 +1,51 @@ +package cipm.consistency.commitintegration.diff.util.pcm.handlers; + +import org.splevo.jamopp.diffing.similarity.base.ISimilarityRequest; +import org.splevo.jamopp.diffing.similarity.base.ISimilarityRequestHandler; + +import cipm.consistency.commitintegration.diff.util.pcm.PCMRepositorySimilaritySwitch; +import cipm.consistency.commitintegration.diff.util.pcm.requests.NewPCMRepositorySimilaritySwitchRequest; + +/** + * An {@link ISimilarityRequestHandler} that processes incoming + * {@link NewPCMRepositorySimilaritySwitchRequest} instances. + * + * @author atora + */ +public class NewPCMRepositorySimilaritySwitchHandler implements ISimilarityRequestHandler { + /** + * The {@link ISimilarityRequestHandler}, which will be passed onto the + * similarity switches created in + * {@link #handleSimilarityRequest(ISimilarityRequest)}. + */ + private ISimilarityRequestHandler srh; + + /** + * Constructs an instance with the given {@link ISimilarityRequestHandler}. + * + * @param srh The {@link ISimilarityRequestHandler}, which will be passed onto + * the similarity switches created in + * {@link #handleSimilarityRequest(ISimilarityRequest)}. + */ + public NewPCMRepositorySimilaritySwitchHandler(ISimilarityRequestHandler srh) { + this.srh = srh; + } + + /** + * {@inheritDoc}
        + *
        + * Constructs a new {@link PCMRepositorySimilaritySwitch} (with its + * {@link #srh}) and returns it. + */ + @Override + public Object handleSimilarityRequest(ISimilarityRequest req) { + NewPCMRepositorySimilaritySwitchRequest castedR = (NewPCMRepositorySimilaritySwitchRequest) req; + Boolean csp = (Boolean) castedR.getParams(); + return new PCMRepositorySimilaritySwitch(this.srh, csp); + } + + @Override + public boolean canHandleSimilarityRequest(Class reqClass) { + return reqClass.equals(NewPCMRepositorySimilaritySwitchRequest.class); + } +} diff --git a/commit-based-cipm/bundles/fi/cipm.consistency.commitintegration.diff.util/src/cipm/consistency/commitintegration/diff/util/pcm/requests/NewPCMRepositorySimilaritySwitchRequest.java b/commit-based-cipm/bundles/fi/cipm.consistency.commitintegration.diff.util/src/cipm/consistency/commitintegration/diff/util/pcm/requests/NewPCMRepositorySimilaritySwitchRequest.java new file mode 100644 index 0000000000..dc115cea6a --- /dev/null +++ b/commit-based-cipm/bundles/fi/cipm.consistency.commitintegration.diff.util/src/cipm/consistency/commitintegration/diff/util/pcm/requests/NewPCMRepositorySimilaritySwitchRequest.java @@ -0,0 +1,35 @@ +package cipm.consistency.commitintegration.diff.util.pcm.requests; + +import org.splevo.jamopp.diffing.similarity.base.ISimilarityRequest; + +/** + * An {@link ISimilarityRequest}, which contains a flag that denotes, whether + * the new similarity switch created by processing this request should care + * about positions of statements while computing similarity. + * + * @author atora + */ +public class NewPCMRepositorySimilaritySwitchRequest implements ISimilarityRequest { + /** + * The flag that denotes, whether the resulting new similarity switch should + * care about positions of statements while computing similarity. + */ + private boolean checkStatementPosition; + + /** + * Constructs an instance with the given parameter. + * + * @param checkStatementPosition The flag that denotes, whether the resulting + * new similarity switch should care about + * positions of statements while computing + * similarity. + */ + public NewPCMRepositorySimilaritySwitchRequest(boolean checkStatementPosition) { + this.checkStatementPosition = checkStatementPosition; + } + + @Override + public Object getParams() { + return this.checkStatementPosition; + } +} From c135c8e50afce97be7df939cc62e7cb7a4563533 Mon Sep 17 00:00:00 2001 From: AlpTorac Date: Sat, 31 Aug 2024 16:11:17 +0200 Subject: [PATCH 29/35] (WIP) Implement interface For PCM-related inner switches that create further switches Non-functional commit --- .../pcm/switches/IPCMPositionInnerSwitch.java | 27 +++++++++++++++++++ 1 file changed, 27 insertions(+) create mode 100644 commit-based-cipm/bundles/fi/cipm.consistency.commitintegration.diff.util/src/cipm/consistency/commitintegration/diff/util/pcm/switches/IPCMPositionInnerSwitch.java diff --git a/commit-based-cipm/bundles/fi/cipm.consistency.commitintegration.diff.util/src/cipm/consistency/commitintegration/diff/util/pcm/switches/IPCMPositionInnerSwitch.java b/commit-based-cipm/bundles/fi/cipm.consistency.commitintegration.diff.util/src/cipm/consistency/commitintegration/diff/util/pcm/switches/IPCMPositionInnerSwitch.java new file mode 100644 index 0000000000..246e9f72f2 --- /dev/null +++ b/commit-based-cipm/bundles/fi/cipm.consistency.commitintegration.diff.util/src/cipm/consistency/commitintegration/diff/util/pcm/switches/IPCMPositionInnerSwitch.java @@ -0,0 +1,27 @@ +package cipm.consistency.commitintegration.diff.util.pcm.switches; + +import org.splevo.jamopp.diffing.similarity.base.ecore.IPositionInnerSwitch; + +import cipm.consistency.commitintegration.diff.util.pcm.IPCMRepositorySimilaritySwitch; +import cipm.consistency.commitintegration.diff.util.pcm.requests.NewPCMRepositorySimilaritySwitchRequest; + +/** + * An interface that bundles and complements {@link IPCMInnerSwitch} and + * {@link IPositionInnerSwitch} interfaces. Contains methods, which are specific + * to computing similarity in the context of Palladio Component Model (PCM) + * repositories. + * + * @author atora + */ +public interface IPCMPositionInnerSwitch extends IPCMInnerSwitch, IPositionInnerSwitch { + /** + * Sends out a {@link NewPCMRepositorySimilaritySwitchRequest} and returns the + * result. + * + * @see {@link #handleSimilarityRequest(org.splevo.jamopp.diffing.similarity.base.ISimilarityRequest)} + */ + public default IPCMRepositorySimilaritySwitch requestNewSwitch(boolean checkStatementPosition) { + return (IPCMRepositorySimilaritySwitch) this + .handleSimilarityRequest(new NewPCMRepositorySimilaritySwitchRequest(checkStatementPosition)); + } +} From 7c79364c929b60cc4b6324a45888cb6572f2cc35 Mon Sep 17 00:00:00 2001 From: AlpTorac Date: Tue, 3 Sep 2024 17:52:19 +0200 Subject: [PATCH 30/35] (WIP) Adapt inner switches Use implemented interfaces in PCM-related inner switches Use extracted structure in PCM-related inner switches Non-functional commit --- .../switches/SimilarityRepositorySwitch.java | 75 +++++++++++++------ .../pcm/switches/SimilaritySeffSwitch.java | 53 +++++++++---- 2 files changed, 91 insertions(+), 37 deletions(-) diff --git a/commit-based-cipm/bundles/fi/cipm.consistency.commitintegration.diff.util/src/cipm/consistency/commitintegration/diff/util/pcm/switches/SimilarityRepositorySwitch.java b/commit-based-cipm/bundles/fi/cipm.consistency.commitintegration.diff.util/src/cipm/consistency/commitintegration/diff/util/pcm/switches/SimilarityRepositorySwitch.java index 35d6215985..c004833d5e 100644 --- a/commit-based-cipm/bundles/fi/cipm.consistency.commitintegration.diff.util/src/cipm/consistency/commitintegration/diff/util/pcm/switches/SimilarityRepositorySwitch.java +++ b/commit-based-cipm/bundles/fi/cipm.consistency.commitintegration.diff.util/src/cipm/consistency/commitintegration/diff/util/pcm/switches/SimilarityRepositorySwitch.java @@ -13,13 +13,40 @@ import org.palladiosimulator.pcm.repository.PrimitiveDataType; import org.palladiosimulator.pcm.repository.Repository; import org.palladiosimulator.pcm.repository.util.RepositorySwitch; +import org.splevo.jamopp.diffing.similarity.base.ISimilarityRequestHandler; +import org.splevo.jamopp.diffing.similarity.base.ecore.IComposedSwitchAdapter; -import cipm.consistency.commitintegration.diff.util.pcm.PCMRepositorySimilarityChecker; +import cipm.consistency.commitintegration.diff.util.pcm.IPCMRepositorySimilaritySwitch; + +public class SimilarityRepositorySwitch extends RepositorySwitch implements IPCMPositionInnerSwitch { + private IPCMRepositorySimilaritySwitch similaritySwitch; + private boolean checkStatementPosition; + + @Override + public ISimilarityRequestHandler getSimilarityRequestHandler() { + return this.similaritySwitch; + } + + @Override + public IComposedSwitchAdapter getContainingSwitch() { + return this.similaritySwitch; + } + + @Override + public boolean shouldCheckStatementPosition() { + return this.checkStatementPosition; + } + + public SimilarityRepositorySwitch( + IPCMRepositorySimilaritySwitch similaritySwitch, + boolean checkStatementPosition) { + this.similaritySwitch = similaritySwitch; + this.checkStatementPosition = checkStatementPosition; + } -class SimilarityRepositorySwitch extends RepositorySwitch { @Override public Boolean caseRepository(Repository repo1) { - Repository repo2 = (Repository) compareElement; + Repository repo2 = (Repository) this.getCompareElement(); if (!repo1.getEntityName().equals(repo2.getEntityName())) { return Boolean.FALSE; @@ -30,26 +57,26 @@ public Boolean caseRepository(Repository repo1) { @Override public Boolean caseOperationInterface(OperationInterface opInterface1) { - OperationInterface opInterface2 = (OperationInterface) compareElement; + OperationInterface opInterface2 = (OperationInterface) this.getCompareElement(); if (!opInterface1.getEntityName().equals(opInterface2.getEntityName())) { return Boolean.FALSE; } - return PCMRepositorySimilarityChecker.this.areSimilar( + return this.areSimilar( opInterface1.getParentInterfaces__Interface(), opInterface2.getParentInterfaces__Interface()); } @Override public Boolean caseOperationSignature(OperationSignature sign1) { - OperationSignature sign2 = (OperationSignature) compareElement; + OperationSignature sign2 = (OperationSignature) this.getCompareElement(); if (!sign1.getEntityName().equals(sign2.getEntityName())) { return Boolean.FALSE; } - var result = PCMRepositorySimilarityChecker.this.areSimilar( + var result = this.areSimilar( sign1.getParameters__OperationSignature(), sign2.getParameters__OperationSignature()); @@ -57,93 +84,93 @@ public Boolean caseOperationSignature(OperationSignature sign1) { return Boolean.FALSE; } - return PCMRepositorySimilarityChecker.this.isSimilar(sign1.getReturnType__OperationSignature(), + return this.isSimilar(sign1.getReturnType__OperationSignature(), sign2.getReturnType__OperationSignature()); } @Override public Boolean caseParameter(Parameter param1) { - Parameter param2 = (Parameter) compareElement; + Parameter param2 = (Parameter) this.getCompareElement(); if (!param1.getParameterName().equals(param2.getParameterName())) { return Boolean.FALSE; } - return PCMRepositorySimilarityChecker.this.isSimilar(param1.getDataType__Parameter(), + return this.isSimilar(param1.getDataType__Parameter(), param2.getDataType__Parameter()); } @Override public Boolean casePrimitiveDataType(PrimitiveDataType type1) { - PrimitiveDataType type2 = (PrimitiveDataType) compareElement; + PrimitiveDataType type2 = (PrimitiveDataType) this.getCompareElement(); return type1.getType() == type2.getType(); } @Override public Boolean caseCollectionDataType(CollectionDataType type1) { - CollectionDataType type2 = (CollectionDataType) compareElement; + CollectionDataType type2 = (CollectionDataType) this.getCompareElement(); if (!type1.getEntityName().equals(type2.getEntityName())) { return Boolean.FALSE; } - return PCMRepositorySimilarityChecker.this.isSimilar(type1.getInnerType_CollectionDataType(), + return this.isSimilar(type1.getInnerType_CollectionDataType(), type2.getInnerType_CollectionDataType()); } @Override public Boolean caseCompositeDataType(CompositeDataType type1) { - CompositeDataType type2 = (CompositeDataType) compareElement; + CompositeDataType type2 = (CompositeDataType) this.getCompareElement(); if (!type1.getEntityName().equals(type2.getEntityName())) { return Boolean.FALSE; } - return PCMRepositorySimilarityChecker.this.areSimilar(type1.getParentType_CompositeDataType(), + return this.areSimilar(type1.getParentType_CompositeDataType(), type2.getParentType_CompositeDataType()); } @Override public Boolean caseInnerDeclaration(InnerDeclaration decl1) { - InnerDeclaration decl2 = (InnerDeclaration) compareElement; + InnerDeclaration decl2 = (InnerDeclaration) this.getCompareElement(); if (!decl1.getEntityName().equals(decl2.getEntityName())) { return Boolean.FALSE; } - return PCMRepositorySimilarityChecker.this.isSimilar(decl1.getDatatype_InnerDeclaration(), + return this.isSimilar(decl1.getDatatype_InnerDeclaration(), decl2.getDatatype_InnerDeclaration()); } @Override public Boolean caseBasicComponent(BasicComponent com1) { - BasicComponent com2 = (BasicComponent) compareElement; + BasicComponent com2 = (BasicComponent) this.getCompareElement(); return com1.getEntityName().equals(com2.getEntityName()); } @Override public Boolean caseOperationProvidedRole(OperationProvidedRole opRole1) { - OperationProvidedRole opRole2 = (OperationProvidedRole) compareElement; + OperationProvidedRole opRole2 = (OperationProvidedRole) this.getCompareElement(); - return PCMRepositorySimilarityChecker.this.isSimilar( + return this.isSimilar( opRole1.getProvidedInterface__OperationProvidedRole(), opRole2.getProvidedInterface__OperationProvidedRole()); } @Override public Boolean caseOperationRequiredRole(OperationRequiredRole reqRole1) { - OperationRequiredRole reqRole2 = (OperationRequiredRole) compareElement; + OperationRequiredRole reqRole2 = (OperationRequiredRole) this.getCompareElement(); - return PCMRepositorySimilarityChecker.this.isSimilar( + return this.isSimilar( reqRole1.getRequiredInterface__OperationRequiredRole(), reqRole2.getRequiredInterface__OperationRequiredRole()); } @Override public Boolean caseCompositeComponent(CompositeComponent com1) { - CompositeComponent com2 = (CompositeComponent) compareElement; + CompositeComponent com2 = (CompositeComponent) this.getCompareElement(); return com1.getEntityName().equals(com2.getEntityName()); } -} +} \ No newline at end of file diff --git a/commit-based-cipm/bundles/fi/cipm.consistency.commitintegration.diff.util/src/cipm/consistency/commitintegration/diff/util/pcm/switches/SimilaritySeffSwitch.java b/commit-based-cipm/bundles/fi/cipm.consistency.commitintegration.diff.util/src/cipm/consistency/commitintegration/diff/util/pcm/switches/SimilaritySeffSwitch.java index 5d6c5e8829..67b946e198 100644 --- a/commit-based-cipm/bundles/fi/cipm.consistency.commitintegration.diff.util/src/cipm/consistency/commitintegration/diff/util/pcm/switches/SimilaritySeffSwitch.java +++ b/commit-based-cipm/bundles/fi/cipm.consistency.commitintegration.diff.util/src/cipm/consistency/commitintegration/diff/util/pcm/switches/SimilaritySeffSwitch.java @@ -8,10 +8,37 @@ import org.palladiosimulator.pcm.seff.ResourceDemandingBehaviour; import org.palladiosimulator.pcm.seff.ResourceDemandingSEFF; import org.palladiosimulator.pcm.seff.util.SeffSwitch; +import org.splevo.jamopp.diffing.similarity.base.ISimilarityRequestHandler; +import org.splevo.jamopp.diffing.similarity.base.ecore.IComposedSwitchAdapter; -import cipm.consistency.commitintegration.diff.util.pcm.PCMRepositorySimilarityChecker; +import cipm.consistency.commitintegration.diff.util.pcm.IPCMRepositorySimilaritySwitch; + +public class SimilaritySeffSwitch extends SeffSwitch implements IPCMPositionInnerSwitch { + private IPCMRepositorySimilaritySwitch similaritySwitch; + private boolean checkStatementPosition; + + @Override + public ISimilarityRequestHandler getSimilarityRequestHandler() { + return this.similaritySwitch; + } + + @Override + public IComposedSwitchAdapter getContainingSwitch() { + return this.similaritySwitch; + } + + @Override + public boolean shouldCheckStatementPosition() { + return this.checkStatementPosition; + } + + public SimilaritySeffSwitch( + IPCMRepositorySimilaritySwitch similaritySwitch, + boolean checkStatementPosition) { + this.similaritySwitch = similaritySwitch; + this.checkStatementPosition = checkStatementPosition; + } -class SimilaritySeffSwitch extends SeffSwitch { private Boolean checkPositionInContainer(AbstractAction action1, AbstractAction action2) { ResourceDemandingBehaviour parent1 = (ResourceDemandingBehaviour) action1.eContainer(); ResourceDemandingBehaviour parent2 = (ResourceDemandingBehaviour) action2.eContainer(); @@ -22,29 +49,29 @@ private Boolean checkPositionInContainer(AbstractAction action1, AbstractAction @Override public Boolean caseAbstractAction(AbstractAction action1) { - AbstractAction action2 = (AbstractAction) compareElement; + AbstractAction action2 = (AbstractAction) getCompareElement(); return checkPositionInContainer(action1, action2); } @Override public Boolean caseResourceDemandingBehaviour(ResourceDemandingBehaviour behav1) { - ResourceDemandingBehaviour behav2 = (ResourceDemandingBehaviour) compareElement; - return PCMRepositorySimilarityChecker.this.areSimilar(behav1.getSteps_Behaviour(), behav2.getSteps_Behaviour()); + ResourceDemandingBehaviour behav2 = (ResourceDemandingBehaviour) getCompareElement(); + return areSimilar(behav1.getSteps_Behaviour(), behav2.getSteps_Behaviour()); } @Override public Boolean caseResourceDemandingSEFF(ResourceDemandingSEFF seff1) { - ResourceDemandingSEFF seff2 = (ResourceDemandingSEFF) compareElement; + ResourceDemandingSEFF seff2 = (ResourceDemandingSEFF) getCompareElement(); - return PCMRepositorySimilarityChecker.this.isSimilar(seff1.getDescribedService__SEFF(), + return isSimilar(seff1.getDescribedService__SEFF(), seff2.getDescribedService__SEFF()); } @Override public Boolean caseCollectionIteratorAction(CollectionIteratorAction action1) { - CollectionIteratorAction action2 = (CollectionIteratorAction) compareElement; + CollectionIteratorAction action2 = (CollectionIteratorAction) getCompareElement(); - var result = PCMRepositorySimilarityChecker.this.isSimilar( + var result = isSimilar( action1.getParameter_CollectionIteratorAction(), action2.getParameter_CollectionIteratorAction()); @@ -57,7 +84,7 @@ public Boolean caseCollectionIteratorAction(CollectionIteratorAction action1) { @Override public Boolean caseAbstractBranchTransition(AbstractBranchTransition transition1) { - AbstractBranchTransition transition2 = (AbstractBranchTransition) compareElement; + AbstractBranchTransition transition2 = (AbstractBranchTransition) getCompareElement(); BranchAction parent1 = (BranchAction) transition1.eContainer(); BranchAction parent2 = (BranchAction) transition2.eContainer(); @@ -68,9 +95,9 @@ public Boolean caseAbstractBranchTransition(AbstractBranchTransition transition1 @Override public Boolean caseExternalCallAction(ExternalCallAction action1) { - ExternalCallAction action2 = (ExternalCallAction) compareElement; + ExternalCallAction action2 = (ExternalCallAction) getCompareElement(); - var result = PCMRepositorySimilarityChecker.this.isSimilar( + var result = isSimilar( action1.getCalledService_ExternalService(), action2.getCalledService_ExternalService()); @@ -80,4 +107,4 @@ public Boolean caseExternalCallAction(ExternalCallAction action1) { return checkPositionInContainer(action1, action2); } -} +} \ No newline at end of file From f5b7348e42d4b3f3049e9383590b3f9d6097c302 Mon Sep 17 00:00:00 2001 From: AlpTorac Date: Fri, 30 Aug 2024 19:19:05 +0200 Subject: [PATCH 31/35] (WIP) Implement toolbox builder For PCM similarity checker construction Non-functional commit --- ...PCMRepositorySimilarityToolboxBuilder.java | 81 +++++++++++++++++++ 1 file changed, 81 insertions(+) create mode 100644 commit-based-cipm/bundles/fi/cipm.consistency.commitintegration.diff.util/src/cipm/consistency/commitintegration/diff/util/pcm/PCMRepositorySimilarityToolboxBuilder.java diff --git a/commit-based-cipm/bundles/fi/cipm.consistency.commitintegration.diff.util/src/cipm/consistency/commitintegration/diff/util/pcm/PCMRepositorySimilarityToolboxBuilder.java b/commit-based-cipm/bundles/fi/cipm.consistency.commitintegration.diff.util/src/cipm/consistency/commitintegration/diff/util/pcm/PCMRepositorySimilarityToolboxBuilder.java new file mode 100644 index 0000000000..f6a10e0114 --- /dev/null +++ b/commit-based-cipm/bundles/fi/cipm.consistency.commitintegration.diff.util/src/cipm/consistency/commitintegration/diff/util/pcm/PCMRepositorySimilarityToolboxBuilder.java @@ -0,0 +1,81 @@ +package cipm.consistency.commitintegration.diff.util.pcm; + +import org.splevo.jamopp.diffing.similarity.base.AbstractSimilarityToolboxBuilder; +import org.splevo.jamopp.diffing.similarity.base.ISimilarityRequest; +import org.splevo.jamopp.diffing.similarity.base.ISimilarityRequestHandler; +import org.splevo.jamopp.diffing.similarity.base.ecore.MultipleSimilarityCheckHandler; +import org.splevo.jamopp.diffing.similarity.base.ecore.MultipleSimilarityCheckRequest; +import org.splevo.jamopp.diffing.similarity.base.ecore.SingleSimilarityCheckHandler; +import org.splevo.jamopp.diffing.similarity.base.ecore.SingleSimilarityCheckRequest; + +import cipm.consistency.commitintegration.diff.util.pcm.handlers.IDBasedSingleSimilarityCheckHandler; +import cipm.consistency.commitintegration.diff.util.pcm.handlers.NewPCMRepositorySimilaritySwitchHandler; +import cipm.consistency.commitintegration.diff.util.pcm.requests.NewPCMRepositorySimilaritySwitchRequest; + +/** + * Concrete implementation of {@link AbstractSimilarityToolboxBuilder} for + * constructing {@link ISimilarityToolbox} instances for computing similarity of + * Palladio Component Model (PCM) repositories. + * + * @author atora + */ +public class PCMRepositorySimilarityToolboxBuilder extends AbstractSimilarityToolboxBuilder { + @Override + public PCMRepositorySimilarityToolboxBuilder instantiate() { + return (PCMRepositorySimilarityToolboxBuilder) super.instantiate(); + } + + @Override + public PCMRepositorySimilarityToolboxBuilder buildRequestHandlerPair(Class req, + ISimilarityRequestHandler srh) { + return (PCMRepositorySimilarityToolboxBuilder) super.buildRequestHandlerPair(req, srh); + } + + /** + * Adds the handlers required to handle similarity checking related + * {@link ISimilarityRequest} instances.
        + *
        + * Pairs added by this method will override those added by + * {@link #buildIDBasedComparisonPairs()} + * + * @return this + */ + public PCMRepositorySimilarityToolboxBuilder buildComparisonPairs() { + this.buildRequestHandlerPair(SingleSimilarityCheckRequest.class, new SingleSimilarityCheckHandler()); + this.buildRequestHandlerPair(MultipleSimilarityCheckRequest.class, + new MultipleSimilarityCheckHandler(this.getCurrentToolbox())); + + return this; + } + + /** + * Adds the handlers required to handle ID based similarity checking related + * {@link ISimilarityRequest} instances.
        + *
        + * Pairs added by this method will override those added by + * {@link #buildComparisonPairs()} + * + * @return this + */ + public PCMRepositorySimilarityToolboxBuilder buildIDBasedComparisonPairs() { + this.buildRequestHandlerPair(SingleSimilarityCheckRequest.class, new IDBasedSingleSimilarityCheckHandler()); + this.buildRequestHandlerPair(MultipleSimilarityCheckRequest.class, + new MultipleSimilarityCheckHandler(this.getCurrentToolbox())); + + return this; + } + + /** + * Adds the handler needed to handle {@link ISimilarityRequest} instances, which + * request new similarity switch instances. + * + * @return this + * @see {@link IPCMRepositorySimilaritySwitch} + */ + public PCMRepositorySimilarityToolboxBuilder buildNewPCMRepositorySimilaritySwitch() { + this.buildRequestHandlerPair(NewPCMRepositorySimilaritySwitchRequest.class, + new NewPCMRepositorySimilaritySwitchHandler(this.getCurrentToolbox())); + + return this; + } +} From 26bf1511604d8d8667746db24d9131bbaaae2f58 Mon Sep 17 00:00:00 2001 From: AlpTorac Date: Fri, 30 Aug 2024 19:14:56 +0200 Subject: [PATCH 32/35] (WIP) Prepare PCM similarity checker Non-functional commit --- .../pcm/PCMRepositorySimilarityChecker.java | 259 +----------------- 1 file changed, 15 insertions(+), 244 deletions(-) diff --git a/commit-based-cipm/bundles/fi/cipm.consistency.commitintegration.diff.util/src/cipm/consistency/commitintegration/diff/util/pcm/PCMRepositorySimilarityChecker.java b/commit-based-cipm/bundles/fi/cipm.consistency.commitintegration.diff.util/src/cipm/consistency/commitintegration/diff/util/pcm/PCMRepositorySimilarityChecker.java index 60e5d5686c..a6b22d8755 100644 --- a/commit-based-cipm/bundles/fi/cipm.consistency.commitintegration.diff.util/src/cipm/consistency/commitintegration/diff/util/pcm/PCMRepositorySimilarityChecker.java +++ b/commit-based-cipm/bundles/fi/cipm.consistency.commitintegration.diff.util/src/cipm/consistency/commitintegration/diff/util/pcm/PCMRepositorySimilarityChecker.java @@ -1,257 +1,28 @@ package cipm.consistency.commitintegration.diff.util.pcm; -import org.eclipse.emf.ecore.EObject; -import org.eclipse.emf.ecore.util.ComposedSwitch; -import org.palladiosimulator.pcm.repository.BasicComponent; -import org.palladiosimulator.pcm.repository.CollectionDataType; -import org.palladiosimulator.pcm.repository.CompositeComponent; -import org.palladiosimulator.pcm.repository.CompositeDataType; -import org.palladiosimulator.pcm.repository.InnerDeclaration; -import org.palladiosimulator.pcm.repository.OperationInterface; -import org.palladiosimulator.pcm.repository.OperationProvidedRole; -import org.palladiosimulator.pcm.repository.OperationRequiredRole; -import org.palladiosimulator.pcm.repository.OperationSignature; -import org.palladiosimulator.pcm.repository.Parameter; -import org.palladiosimulator.pcm.repository.PrimitiveDataType; -import org.palladiosimulator.pcm.repository.Repository; -import org.palladiosimulator.pcm.repository.util.RepositorySwitch; -import org.palladiosimulator.pcm.seff.AbstractAction; -import org.palladiosimulator.pcm.seff.AbstractBranchTransition; -import org.palladiosimulator.pcm.seff.BranchAction; -import org.palladiosimulator.pcm.seff.CollectionIteratorAction; -import org.palladiosimulator.pcm.seff.ExternalCallAction; -import org.palladiosimulator.pcm.seff.ResourceDemandingBehaviour; -import org.palladiosimulator.pcm.seff.ResourceDemandingSEFF; -import org.palladiosimulator.pcm.seff.util.SeffSwitch; -import org.splevo.jamopp.diffing.similarity.SimilarityChecker; +import org.splevo.jamopp.diffing.similarity.base.ISimilarityRequest; +import org.splevo.jamopp.diffing.similarity.base.ISimilarityToolbox; +import org.splevo.jamopp.diffing.similarity.base.ecore.AbstractComposedSwitchSimilarityChecker; + +import cipm.consistency.commitintegration.diff.util.pcm.requests.NewPCMRepositorySimilaritySwitchRequest; /** * A SimilarityChecker for PCM repository models. * * @author Martin Armbruster */ -public class PCMRepositorySimilarityChecker extends SimilarityChecker { +public class PCMRepositorySimilarityChecker extends AbstractComposedSwitchSimilarityChecker { + public PCMRepositorySimilarityChecker(ISimilarityToolbox st) { + super(st); + } + @Override - protected Boolean checkSimilarityForResolvedAndSameType(EObject element1, EObject element2, - boolean checkStatementPosition) { - return new PCMRepositorySimilaritySwitch(element1).doSwitch(element2); + protected PCMRepositorySimilarityComparer createSimilarityComparer(ISimilarityToolbox st) { + return new PCMRepositorySimilarityComparer(st); } - class PCMRepositorySimilaritySwitch extends ComposedSwitch { - private EObject compareElement; - - PCMRepositorySimilaritySwitch(EObject compareElement) { - this.compareElement = compareElement; - this.addSwitch(new SimilarityRepositorySwitch()); - this.addSwitch(new SimilaritySeffSwitch()); - } - - class SimilarityRepositorySwitch extends RepositorySwitch { - @Override - public Boolean caseRepository(Repository repo1) { - Repository repo2 = (Repository) compareElement; - - if (!repo1.getEntityName().equals(repo2.getEntityName())) { - return Boolean.FALSE; - } - - return Boolean.TRUE; - } - - @Override - public Boolean caseOperationInterface(OperationInterface opInterface1) { - OperationInterface opInterface2 = (OperationInterface) compareElement; - - if (!opInterface1.getEntityName().equals(opInterface2.getEntityName())) { - return Boolean.FALSE; - } - - return PCMRepositorySimilarityChecker.this.areSimilar( - opInterface1.getParentInterfaces__Interface(), - opInterface2.getParentInterfaces__Interface()); - } - - @Override - public Boolean caseOperationSignature(OperationSignature sign1) { - OperationSignature sign2 = (OperationSignature) compareElement; - - if (!sign1.getEntityName().equals(sign2.getEntityName())) { - return Boolean.FALSE; - } - - var result = PCMRepositorySimilarityChecker.this.areSimilar( - sign1.getParameters__OperationSignature(), - sign2.getParameters__OperationSignature()); - - if (!result) { - return Boolean.FALSE; - } - - return PCMRepositorySimilarityChecker.this.isSimilar(sign1.getReturnType__OperationSignature(), - sign2.getReturnType__OperationSignature()); - } - - @Override - public Boolean caseParameter(Parameter param1) { - Parameter param2 = (Parameter) compareElement; - - if (!param1.getParameterName().equals(param2.getParameterName())) { - return Boolean.FALSE; - } - - return PCMRepositorySimilarityChecker.this.isSimilar(param1.getDataType__Parameter(), - param2.getDataType__Parameter()); - } - - @Override - public Boolean casePrimitiveDataType(PrimitiveDataType type1) { - PrimitiveDataType type2 = (PrimitiveDataType) compareElement; - return type1.getType() == type2.getType(); - } - - @Override - public Boolean caseCollectionDataType(CollectionDataType type1) { - CollectionDataType type2 = (CollectionDataType) compareElement; - - if (!type1.getEntityName().equals(type2.getEntityName())) { - return Boolean.FALSE; - } - - return PCMRepositorySimilarityChecker.this.isSimilar(type1.getInnerType_CollectionDataType(), - type2.getInnerType_CollectionDataType()); - } - - @Override - public Boolean caseCompositeDataType(CompositeDataType type1) { - CompositeDataType type2 = (CompositeDataType) compareElement; - - if (!type1.getEntityName().equals(type2.getEntityName())) { - return Boolean.FALSE; - } - - return PCMRepositorySimilarityChecker.this.areSimilar(type1.getParentType_CompositeDataType(), - type2.getParentType_CompositeDataType()); - } - - @Override - public Boolean caseInnerDeclaration(InnerDeclaration decl1) { - InnerDeclaration decl2 = (InnerDeclaration) compareElement; - - if (!decl1.getEntityName().equals(decl2.getEntityName())) { - return Boolean.FALSE; - } - - return PCMRepositorySimilarityChecker.this.isSimilar(decl1.getDatatype_InnerDeclaration(), - decl2.getDatatype_InnerDeclaration()); - } - - @Override - public Boolean caseBasicComponent(BasicComponent com1) { - BasicComponent com2 = (BasicComponent) compareElement; - - return com1.getEntityName().equals(com2.getEntityName()); - } - - @Override - public Boolean caseOperationProvidedRole(OperationProvidedRole opRole1) { - OperationProvidedRole opRole2 = (OperationProvidedRole) compareElement; - - return PCMRepositorySimilarityChecker.this.isSimilar( - opRole1.getProvidedInterface__OperationProvidedRole(), - opRole2.getProvidedInterface__OperationProvidedRole()); - } - - @Override - public Boolean caseOperationRequiredRole(OperationRequiredRole reqRole1) { - OperationRequiredRole reqRole2 = (OperationRequiredRole) compareElement; - - return PCMRepositorySimilarityChecker.this.isSimilar( - reqRole1.getRequiredInterface__OperationRequiredRole(), - reqRole2.getRequiredInterface__OperationRequiredRole()); - } - - @Override - public Boolean caseCompositeComponent(CompositeComponent com1) { - CompositeComponent com2 = (CompositeComponent) compareElement; - - return com1.getEntityName().equals(com2.getEntityName()); - } - } - - class SimilaritySeffSwitch extends SeffSwitch { - private Boolean checkPositionInContainer(AbstractAction action1, AbstractAction action2) { - ResourceDemandingBehaviour parent1 = (ResourceDemandingBehaviour) action1.eContainer(); - ResourceDemandingBehaviour parent2 = (ResourceDemandingBehaviour) action2.eContainer(); - - return parent1.getSteps_Behaviour().indexOf(action1) - == parent2.getSteps_Behaviour().indexOf(action2); - } - - @Override - public Boolean caseAbstractAction(AbstractAction action1) { - AbstractAction action2 = (AbstractAction) compareElement; - return checkPositionInContainer(action1, action2); - } - - @Override - public Boolean caseResourceDemandingBehaviour(ResourceDemandingBehaviour behav1) { - ResourceDemandingBehaviour behav2 = (ResourceDemandingBehaviour) compareElement; - return PCMRepositorySimilarityChecker.this.areSimilar(behav1.getSteps_Behaviour(), behav2.getSteps_Behaviour()); - } - - @Override - public Boolean caseResourceDemandingSEFF(ResourceDemandingSEFF seff1) { - ResourceDemandingSEFF seff2 = (ResourceDemandingSEFF) compareElement; - - return PCMRepositorySimilarityChecker.this.isSimilar(seff1.getDescribedService__SEFF(), - seff2.getDescribedService__SEFF()); - } - - @Override - public Boolean caseCollectionIteratorAction(CollectionIteratorAction action1) { - CollectionIteratorAction action2 = (CollectionIteratorAction) compareElement; - - var result = PCMRepositorySimilarityChecker.this.isSimilar( - action1.getParameter_CollectionIteratorAction(), - action2.getParameter_CollectionIteratorAction()); - - if (!result) { - return Boolean.FALSE; - } - - return checkPositionInContainer(action1, action2); - } - - @Override - public Boolean caseAbstractBranchTransition(AbstractBranchTransition transition1) { - AbstractBranchTransition transition2 = (AbstractBranchTransition) compareElement; - - BranchAction parent1 = (BranchAction) transition1.eContainer(); - BranchAction parent2 = (BranchAction) transition2.eContainer(); - - return parent1.getBranches_Branch().indexOf(transition1) == parent2.getBranches_Branch() - .indexOf(transition2); - } - - @Override - public Boolean caseExternalCallAction(ExternalCallAction action1) { - ExternalCallAction action2 = (ExternalCallAction) compareElement; - - var result = PCMRepositorySimilarityChecker.this.isSimilar( - action1.getCalledService_ExternalService(), - action2.getCalledService_ExternalService()); - - if (!result) { - return Boolean.FALSE; - } - - return checkPositionInContainer(action1, action2); - } - } - - @Override - public Boolean defaultCase(EObject obj) { - return null; - } + @Override + protected ISimilarityRequest makeDefaultSwitchRequest() { + return new NewPCMRepositorySimilaritySwitchRequest(true); } } From c4a3df0a051aa84fdaf68ccf687ffb41e1b83851 Mon Sep 17 00:00:00 2001 From: AlpTorac Date: Fri, 30 Aug 2024 19:17:12 +0200 Subject: [PATCH 33/35] (WIP) Delete ID-based similarity checker The dynamic toolbox can be set to use ID-based similarity checking handler Non-functional commit --- ...PCMRepositoryIDBasedSimilarityChecker.java | 26 ------------------- 1 file changed, 26 deletions(-) delete mode 100644 commit-based-cipm/bundles/fi/cipm.consistency.commitintegration.diff.util/src/cipm/consistency/commitintegration/diff/util/pcm/PCMRepositoryIDBasedSimilarityChecker.java diff --git a/commit-based-cipm/bundles/fi/cipm.consistency.commitintegration.diff.util/src/cipm/consistency/commitintegration/diff/util/pcm/PCMRepositoryIDBasedSimilarityChecker.java b/commit-based-cipm/bundles/fi/cipm.consistency.commitintegration.diff.util/src/cipm/consistency/commitintegration/diff/util/pcm/PCMRepositoryIDBasedSimilarityChecker.java deleted file mode 100644 index 3487e84f16..0000000000 --- a/commit-based-cipm/bundles/fi/cipm.consistency.commitintegration.diff.util/src/cipm/consistency/commitintegration/diff/util/pcm/PCMRepositoryIDBasedSimilarityChecker.java +++ /dev/null @@ -1,26 +0,0 @@ -package cipm.consistency.commitintegration.diff.util.pcm; - -import org.eclipse.emf.ecore.EObject; - -import de.uka.ipd.sdq.identifier.Identifier; - -/** - * A SimiliarityChecker for PCM Repository models which includes the IDs of elements in the comparison. - * - * @author Martin Armbruster - */ -public class PCMRepositoryIDBasedSimilarityChecker extends PCMRepositorySimilarityChecker { - @Override - protected Boolean checkSimilarityForResolvedAndSameType(EObject element1, EObject element2, - boolean checkStatementPosition) { - if (element1 instanceof Identifier) { - if (element2 instanceof Identifier) { - Identifier id1 = (Identifier) element1; - Identifier id2 = (Identifier) element2; - return id1.getId().equals(id2.getId()); - } - return Boolean.FALSE; - } - return super.checkSimilarityForResolvedAndSameType(element1, element2, checkStatementPosition); - } -} From d231a3e1c27ed3b8aefab08e7883180522483f8d Mon Sep 17 00:00:00 2001 From: AlpTorac Date: Fri, 30 Aug 2024 19:19:58 +0200 Subject: [PATCH 34/35] Integrate toolbox builder To the PCM related similarity checker construction The FirstInstance should now work in a vacuum SecondInstance is not adapted to the changes yet --- ...RepositoryMatchEngineFactoryGenerator.java | 19 +++++++++++++++++-- 1 file changed, 17 insertions(+), 2 deletions(-) diff --git a/commit-based-cipm/bundles/fi/cipm.consistency.commitintegration.diff.util/src/cipm/consistency/commitintegration/diff/util/pcm/PCMRepositoryMatchEngineFactoryGenerator.java b/commit-based-cipm/bundles/fi/cipm.consistency.commitintegration.diff.util/src/cipm/consistency/commitintegration/diff/util/pcm/PCMRepositoryMatchEngineFactoryGenerator.java index aaefb22438..f046b0e9fe 100644 --- a/commit-based-cipm/bundles/fi/cipm.consistency.commitintegration.diff.util/src/cipm/consistency/commitintegration/diff/util/pcm/PCMRepositoryMatchEngineFactoryGenerator.java +++ b/commit-based-cipm/bundles/fi/cipm.consistency.commitintegration.diff.util/src/cipm/consistency/commitintegration/diff/util/pcm/PCMRepositoryMatchEngineFactoryGenerator.java @@ -1,6 +1,7 @@ package cipm.consistency.commitintegration.diff.util.pcm; import org.splevo.diffing.match.HierarchicalMatchEngineFactory; +import org.splevo.jamopp.diffing.similarity.base.MapSimilarityToolboxFactory; import cipm.consistency.commitintegration.diff.util.HierarchicalMatchEngineFactoryGenerator; @@ -21,7 +22,14 @@ private PCMRepositoryMatchEngineFactoryGenerator() { * @return the generated factory. */ public static HierarchicalMatchEngineFactory generateMatchEngineFactory() { - return HierarchicalMatchEngineFactoryGenerator.generateMatchEngineFactory(new PCMRepositorySimilarityChecker(), + var builder = new PCMRepositorySimilarityToolboxBuilder(); + builder.setSimilarityToolboxFactory(new MapSimilarityToolboxFactory()); + + var toolbox = builder.instantiate() + .buildComparisonPairs() + .build(); + + return HierarchicalMatchEngineFactoryGenerator.generateMatchEngineFactory(new PCMRepositorySimilarityChecker(toolbox), "repository"); } @@ -32,7 +40,14 @@ public static HierarchicalMatchEngineFactory generateMatchEngineFactory() { * @return the generated factory. */ public static HierarchicalMatchEngineFactory generateIDBasedMatchEngineFactory() { + var builder = new PCMRepositorySimilarityToolboxBuilder(); + builder.setSimilarityToolboxFactory(new MapSimilarityToolboxFactory()); + + var toolbox = builder.instantiate() + .buildIDBasedComparisonPairs() + .build(); + return HierarchicalMatchEngineFactoryGenerator - .generateMatchEngineFactory(new PCMRepositoryIDBasedSimilarityChecker(), "repository"); + .generateMatchEngineFactory(new PCMRepositorySimilarityChecker(toolbox), "repository"); } } From 7ecc86c56674ea554b827d3fc892573c12e74c45 Mon Sep 17 00:00:00 2001 From: AlpTorac Date: Fri, 30 Aug 2024 15:08:25 +0200 Subject: [PATCH 35/35] Adapt SecondInstance The SecondInstance should now work with the preceding changes to FirstInstance --- ...dClassMethodBodyChangedTransformation.java | 19 ++++++++++++++++--- 1 file changed, 16 insertions(+), 3 deletions(-) diff --git a/commit-based-cipm/bundles/si/tools.vitruv.applications.pcmjava.seffstatements.finegrained/src/tools/vitruv/applications/pcmjava/seffstatements/code2seff/finegrained/FineGrainedClassMethodBodyChangedTransformation.java b/commit-based-cipm/bundles/si/tools.vitruv.applications.pcmjava.seffstatements.finegrained/src/tools/vitruv/applications/pcmjava/seffstatements/code2seff/finegrained/FineGrainedClassMethodBodyChangedTransformation.java index dbd8d53b11..57050a243d 100644 --- a/commit-based-cipm/bundles/si/tools.vitruv.applications.pcmjava.seffstatements.finegrained/src/tools/vitruv/applications/pcmjava/seffstatements/code2seff/finegrained/FineGrainedClassMethodBodyChangedTransformation.java +++ b/commit-based-cipm/bundles/si/tools.vitruv.applications.pcmjava.seffstatements.finegrained/src/tools/vitruv/applications/pcmjava/seffstatements/code2seff/finegrained/FineGrainedClassMethodBodyChangedTransformation.java @@ -22,7 +22,10 @@ import org.somox.gast2seff.visitors.ResourceDemandingBehaviourForClassMethodFinding; import org.somox.gast2seff.visitors.VisitorUtils; import org.somox.sourcecodedecorator.SeffElementSourceCodeLink; -import org.splevo.jamopp.diffing.similarity.SimilarityChecker; +import org.splevo.jamopp.diffing.similarity.base.ISimilarityChecker; +import org.splevo.jamopp.diffing.similarity.base.MapSimilarityToolboxFactory; +import org.splevo.jamopp.diffing.similarity.JavaSimilarityToolboxBuilder; +import org.splevo.jamopp.diffing.similarity.JavaSimilarityChecker; import de.uka.ipd.sdq.identifier.Identifier; import tools.vitruv.applications.pcmjava.seffstatements.code2seff.BasicComponentFinding; @@ -45,7 +48,7 @@ public class FineGrainedClassMethodBodyChangedTransformation extends ExtendedCla private final Method newMethod; private final BasicComponentFinding basicComponentFinder; private ResourceDemandingBehaviourDiff rdbDifference; - private final SimilarityChecker similarityChecker; + private final ISimilarityChecker similarityChecker; public FineGrainedClassMethodBodyChangedTransformation(final Method newMethod, final BasicComponentFinding basicComponentFinder, @@ -56,7 +59,17 @@ public FineGrainedClassMethodBodyChangedTransformation(final Method newMethod, resourceDemandingBehaviourForClassMethodFinding); this.newMethod = newMethod; this.basicComponentFinder = basicComponentFinder; - this.similarityChecker = new SimilarityChecker(); + + var builder = new JavaSimilarityToolboxBuilder(); + builder.setSimilarityToolboxFactory(new MapSimilarityToolboxFactory()); + + var toolbox = builder.instantiate() + .buildNewSimilaritySwitchHandler() + .buildNormalizationHandlers() + .buildComparisonHandlers() + .build(); + + this.similarityChecker = new JavaSimilarityChecker(toolbox); } /**