From 6ab72400e3deff26883755e5641c91ad3f91e797 Mon Sep 17 00:00:00 2001 From: AlpTorac Date: Fri, 25 Oct 2024 16:06:16 +0200 Subject: [PATCH 01/55] Create new plug-in for initialisers --- .../cipm.consistency.initialisers/.classpath | 7 ++++ .../cipm.consistency.initialisers/.project | 28 +++++++++++++++ .../.settings/org.eclipse.jdt.core.prefs | 9 +++++ .../META-INF/MANIFEST.MF | 35 +++++++++++++++++++ .../build.properties | 4 +++ 5 files changed, 83 insertions(+) create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/.classpath create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/.project create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/.settings/org.eclipse.jdt.core.prefs create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/META-INF/MANIFEST.MF create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/build.properties diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/.classpath b/commit-based-cipm/initialisers/cipm.consistency.initialisers/.classpath new file mode 100644 index 0000000000..e801ebfb46 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/.classpath @@ -0,0 +1,7 @@ + + + + + + + diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/.project b/commit-based-cipm/initialisers/cipm.consistency.initialisers/.project new file mode 100644 index 0000000000..7bd4543292 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/.project @@ -0,0 +1,28 @@ + + + cipm.consistency.initialisers + + + + + + org.eclipse.jdt.core.javabuilder + + + + + org.eclipse.pde.ManifestBuilder + + + + + org.eclipse.pde.SchemaBuilder + + + + + + org.eclipse.pde.PluginNature + org.eclipse.jdt.core.javanature + + diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/.settings/org.eclipse.jdt.core.prefs b/commit-based-cipm/initialisers/cipm.consistency.initialisers/.settings/org.eclipse.jdt.core.prefs new file mode 100644 index 0000000000..c9545f06a4 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/.settings/org.eclipse.jdt.core.prefs @@ -0,0 +1,9 @@ +eclipse.preferences.version=1 +org.eclipse.jdt.core.compiler.codegen.targetPlatform=11 +org.eclipse.jdt.core.compiler.compliance=11 +org.eclipse.jdt.core.compiler.problem.assertIdentifier=error +org.eclipse.jdt.core.compiler.problem.enablePreviewFeatures=disabled +org.eclipse.jdt.core.compiler.problem.enumIdentifier=error +org.eclipse.jdt.core.compiler.problem.reportPreviewFeatures=warning +org.eclipse.jdt.core.compiler.release=enabled +org.eclipse.jdt.core.compiler.source=11 diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/META-INF/MANIFEST.MF b/commit-based-cipm/initialisers/cipm.consistency.initialisers/META-INF/MANIFEST.MF new file mode 100644 index 0000000000..217185e3c3 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/META-INF/MANIFEST.MF @@ -0,0 +1,35 @@ +Manifest-Version: 1.0 +Bundle-ManifestVersion: 2 +Bundle-Name: cipm.consistency.initialisers +Bundle-SymbolicName: cipm.consistency.initialisers +Bundle-Version: 1.0.0.qualifier +Automatic-Module-Name: cipm.consistency.initialisers +Bundle-RequiredExecutionEnvironment: JavaSE-11 +Require-Bundle: org.junit, + org.junit.jupiter.api, + org.apache.log4j, + org.eclipse.emf.ecore, + org.emftext.language.java +Export-Package: cipm.consistency.initialisers, + cipm.consistency.initialisers.eobject, + cipm.consistency.initialisers.jamopp, + cipm.consistency.initialisers.jamopp.annotations, + cipm.consistency.initialisers.jamopp.arrays, + cipm.consistency.initialisers.jamopp.classifiers, + cipm.consistency.initialisers.jamopp.commons, + cipm.consistency.initialisers.jamopp.containers, + cipm.consistency.initialisers.jamopp.expressions, + cipm.consistency.initialisers.jamopp.generics, + cipm.consistency.initialisers.jamopp.imports, + cipm.consistency.initialisers.jamopp.initadapters, + cipm.consistency.initialisers.jamopp.instantiations, + cipm.consistency.initialisers.jamopp.literals, + cipm.consistency.initialisers.jamopp.members, + cipm.consistency.initialisers.jamopp.modifiers, + cipm.consistency.initialisers.jamopp.modules, + cipm.consistency.initialisers.jamopp.operators, + cipm.consistency.initialisers.jamopp.parameters, + cipm.consistency.initialisers.jamopp.references, + cipm.consistency.initialisers.jamopp.statements, + cipm.consistency.initialisers.jamopp.types, + cipm.consistency.initialisers.jamopp.variables diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/build.properties b/commit-based-cipm/initialisers/cipm.consistency.initialisers/build.properties new file mode 100644 index 0000000000..34d2e4d2da --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/build.properties @@ -0,0 +1,4 @@ +source.. = src/ +output.. = bin/ +bin.includes = META-INF/,\ + . From b621f05e43d239956ac53e3fcdc2ab0e88b372ec Mon Sep 17 00:00:00 2001 From: AlpTorac Date: Fri, 25 Oct 2024 16:11:58 +0200 Subject: [PATCH 02/55] Implement interfaces for (adaptable) initialisers --- .../initialisers/IInitialiser.java | 244 ++++++++++++++++++ .../IInitialiserAdapterStrategy.java | 29 +++ .../initialisers/IInitialiserBase.java | 97 +++++++ 3 files changed, 370 insertions(+) create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/IInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/IInitialiserAdapterStrategy.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/IInitialiserBase.java diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/IInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/IInitialiser.java new file mode 100644 index 0000000000..59f67ad167 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/IInitialiser.java @@ -0,0 +1,244 @@ +package cipm.consistency.initialisers; + +import java.util.function.BiFunction; + +/** + * An interface to be implemented by initialisers. Initialisers are interfaces + * or classes, which are meant to instantiate objects (designated objects) via + * {@link #instantiate()}. For intuition, their names can be used to denote what + * they instantiate.
+ *
+ * Initialisers can also implement (default) methods that modify their + * designated objects. It is suggested to have such modification methods return + * something that indicates whether they ran as expected. In general, + * modification methods DO NOT check, if the object that is being modified + * (modification target) is null. Attempting to use null as modification target + * will result in EXCEPTIONS. The reason behind this is the importance of + * knowing if the modification target is null, as this could hint towards faulty + * code.
+ *
+ * addSomething(...) methods have null checks for the passed parameters other + * than the modification target (i.e. modification parameters), which are used + * to perform modifications. By default, it is assumed that no null elements can + * be added to modification targets via addSomething(...). If modification + * parameters are null, no modification will be performed and the method will be + * assumed to have run as expected, since no modification was performed and + * failed. setSomething(...) methods, on the other hand, allow setting + * attributes of the modification target to null.
+ *
+ * It is recommended to separate instantiation and initialisation (modification) + * methods, as doing so will allow using the individual methods in sub-types. + * Implementing initialisers similar to their designated objects, in terms of + * type hierarchy and what modifications they allow from outside, may make + * initialisers more flexible and ease implementing them.
+ *
+ * A further suggestion is to not declare attributes in the concrete + * implementors, so that all functionality is present in form of methods. This + * alleviates having to declare unnecessary attributes in sub-types and makes + * overriding behaviour easier, since default methods can be overridden in + * interfaces. If initialisation of the designated objects is complex, consider + * realising it in form of initialiser adaptation strategies (see the links + * below).
+ *
+ * This interface also contains some static utility methods. + * + * @author Alp Torac Genc + * @see {@link IInitialiserBase} + * @see {@link IInitialiserAdapterStrategy} + */ +public interface IInitialiser { + /** + * Can be used to create a (deep) copy of this. + * + * @return A fresh instance of this initialiser's class. + */ + public IInitialiser newInitialiser(); + + /** + * Attempts to instantiate the class this {@link IInitialiser} is designated + * for. Depending on the returned object, additional initialisation may be + * necessary. + */ + public Object instantiate(); + + /** + * Attempts to initialise obj, so that it is "valid".
+ *
+ * It is recommended to only use this method where necessary, as it may + * introduce additional modifications that are not obvious from outside. + * + * @param obj The object that will be made valid + */ + public boolean initialise(Object obj); + + /** + * Checks whether a given {@link IInitialiser} type directly declares any + * methods that modify given object instances. Returns false, if + * {@code initCls == null}. + */ + public static boolean declaresModificationMethods(Class initCls) { + if (initCls == null) { + return false; + } + + var methods = initCls.getDeclaredMethods(); + + /* + * Instead of using a naming convention for modification methods, use the fact + * that modification methods take an object instance obj as a parameter, where + * initCls is capable of instantiating obj. + */ + for (var met : methods) { + + // A modification method must at least take obj as a parameter to modify it + if (met.getParameterCount() <= 0) + continue; + + // One of the parameters has to have the exact type of obj + // initCls should thus be able to instantiate the type obj + for (var p : met.getParameters()) { + var pType = p.getType(); + if (isInitialiserFor(initCls, pType)) { + return true; + } + } + } + + return false; + } + + /** + * A variant of {@link #declaresModificationMethods(Class)} for + * {@link IInitialiser} instances.
+ *
+ * Uses the type of the given parameter init. + */ + public static boolean declaresModificationMethods(IInitialiser init) { + return init != null && declaresModificationMethods(init.getClass()); + } + + /** + * An initialiser class is assumed to be able to instantiate the class objClass, + * if it has a method (instantiation method), whose return type is objClass and + * which has no parameters. Methods inherited by initCls will also be + * inspected.
+ *
+ * For the result to be true, initCls has to be able to instantiate + * exactly objClass, i.e. the return type of the instantiation + * method has to be exactly objClass.
+ *
+ * Methods that are generated internally by Java (synthetic methods and bridge + * methods) are excluded. + * + * @return True, if initCls is an initialiser type, which is meant to + * instantiate objects of class objClass (sub-types of objClass do not + * count). + */ + public static boolean isInitialiserFor(Class initCls, Class objClass) { + if (initCls == null || objClass == null) { + return false; + } + + /* + * Count inherited methods as well, in order to allow initialisers to be + * extended without having to explicitly declare/override their instantiation + * method. + */ + var methods = initCls.getMethods(); + + for (var m : methods) { + /* + * Instead of using name checks or annotations, use the fact that the + * instantiation method should have the return type objClass and that it should + * take no parameters. + * + * Also, make sure that the inspected methods are not generated internally by + * Java. + */ + if (!m.isBridge() && !m.isSynthetic() && m.getReturnType().equals(objClass) + && m.getParameters().length == 0) { + return true; + } + } + + return false; + } + + /** + * A variant of {@link #isInitialiserFor(Class, Class)}, where initCls is + * extracted from init. Returns false, if any parameter is null. + */ + public static boolean isInitialiserFor(IInitialiser init, Class objClass) { + return init != null && objClass != null && isInitialiserFor(init.getClass(), objClass); + } + + /** + * The dynamic variant of {@link #declaresModificationMethods(Class)}.
+ *
+ * Uses the class of this instance. + */ + public default boolean declaresModificationMethods() { + return declaresModificationMethods(this.getClass()); + } + + /** + * The dynamic variant of {@link #isInitialiserFor(IInitialiser, Class)}.
+ *
+ * Uses this initialiser as the initialiser parameter. + */ + public default boolean isInitialiserFor(Class objClass) { + return objClass != null && isInitialiserFor(this, objClass); + } + + /** + * A helper method for implementors, which provides them with a template for + * versions of their modification methods, which take arrays of parameters + * rather than singular ones, and perform multiple modifications. The purpose of + * this method is to help keep consistency across the said versions of the + * modification methods.
+ *
+ * If modificationFunction returns false for an element x of xs, the method + * will FAIL EARLY and return false. This means, modificationFunction WILL + * NOT be called for the remaining xs once it fails. Because of this, it is + * important to perform modifications one by one, if performing the said + * modifications is expected to fail for some x.
+ *
+ * This method is not intended to be used directly from outside. + * + * @param The type of the object being modified + * @param The parameter passed to the modification function + * (modificationFunction) + * @param obj The object being modified. {@code obj == null} + * will cause null pointer exceptions, if xs has at + * least one element. + * @param xs Array of parameters that will be passed to + * modificationFunction + * @param modificationFunction The modification function that will be run on + * obj, using xs as parameters (one + * modificationFunction call each x in xs) + * + * @return + *
    + *
  • True, if either: + *
      + *
    • xs is null (because no modifications were performed and nothing + * can fail) + *
    • All modification method calls returned true (i.e. all + * modifications were successfully performed) + *
    + *
  • Otherwise false, i.e. if {@code xs != null} and a modification + * method call returned false. + *
+ */ + public default boolean doMultipleModifications(T obj, X[] xs, + BiFunction modificationFunction) { + if (xs != null) { + for (var x : xs) { + if (!modificationFunction.apply(obj, x)) + return false; + } + } + + return true; + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/IInitialiserAdapterStrategy.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/IInitialiserAdapterStrategy.java new file mode 100644 index 0000000000..480e88777c --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/IInitialiserAdapterStrategy.java @@ -0,0 +1,29 @@ +package cipm.consistency.initialisers; + +/** + * An interface for classes and interfaces to implement, which encapsulate + * initialisation logic for complex objects instantiated by + * {@link IInitialiserBase} implementors.
+ *
+ * Although it is ultimately {@link IInitialiser}'s responsibility to + * instantiate and initialise objects, this interface allows extracting parts of + * it, especially the parts that revolve around other {@link IInitialiser}s. By + * extracting that logic from {@link IInitialiser} implementors, dependencies to + * other {@link IInitialiser}s can be spared. + * + * @author Alp Torac Genc + */ +public interface IInitialiserAdapterStrategy { + /** + * Applies the initialisation logic contained in this instance to the given + * object. + * + * @return Whether the method did what it was supposed to do. + */ + public boolean apply(IInitialiser init, Object obj); + + /** + * @return Creates a deep clone of this instance. + */ + public IInitialiserAdapterStrategy newStrategy(); +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/IInitialiserBase.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/IInitialiserBase.java new file mode 100644 index 0000000000..d7629d4ac5 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/IInitialiserBase.java @@ -0,0 +1,97 @@ +package cipm.consistency.initialisers; + +import java.util.Collection; + +/** + * An interface meant to be implemented by {@link IInitialiser} implementors, + * which are supposed to be adaptable by {@link IInitialiserAdapterStrategy} + * instances. + * + * @author Alp Torac Genc + */ +public interface IInitialiserBase extends IInitialiser { + /** + * Adds the given {@link IInitialiserAdapterStrategy} to this instance. Does not + * add null, if {@code strat == null}. + */ + public void addAdaptingStrategy(IInitialiserAdapterStrategy strat); + + /** + * Removes the given {@link IInitialiserAdapterStrategy} from this instance. + * Does nothing, if {@code strat == null}. + */ + public void removeAdaptingStrategy(IInitialiserAdapterStrategy strat); + + /** + * Removes all stored {@link IInitialiserAdapterStrategy} instances from this. + */ + public void cleanAdaptingStrategy(); + + /** + * @return All {@link IInitialiserAdapterStrategy} instances added to this. + * Returns an empty collection if there are none. Modifying the elements + * of the collection will modify the adaptation strategies adapting + * this. Modifying the returned collection itself will have no effect on + * this. + */ + public Collection getAdaptingStrategies(); + + /** + * The variant of {@link #addAdaptingStrategy(IInitialiserAdapterStrategy)} for + * arrays. Does nothing if {@code strats == null}. + */ + public default void addAdaptingStrategies(IInitialiserAdapterStrategy[] strats) { + if (strats != null) { + for (var i : strats) { + this.addAdaptingStrategy(i); + } + } + } + + /** + * @return Number of {@link IInitialiserAdapterStrategy} instances that are + * currently adapting this. + */ + public default int getAdaptingStrategyCount() { + return this.getAdaptingStrategies().size(); + } + + /** + * @return Whether any {@link IInitialiserAdapterStrategy} instances are + * currently adapting this. + */ + public default boolean isAdapted() { + return !this.getAdaptingStrategies().isEmpty(); + } + + /** + * For the sake of clarity, only use this method, if adaptation strategies + * are meant to be used.
+ *
+ * {@inheritDoc} + */ + @Override + public default boolean initialise(Object obj) { + boolean result = true; + + for (var strat : this.getAdaptingStrategies()) { + result = result && strat.apply(this, obj); + } + + return result; + } + + /** + * @return A new instance of this {@link IInitialiserBase} along with clones of + * adaptation strategies currently adapting it. + */ + public default IInitialiserBase newInitialiserWithStrategies() { + var newInit = (IInitialiserBase) this.newInitialiser(); + + // Create a new strategy for the new initialiser, so that neither the original + // strategy nor its copy are modified by the other one. + this.getAdaptingStrategies().forEach((s) -> newInit.addAdaptingStrategy(s.newStrategy())); + + return newInit; + } +} \ No newline at end of file From c381689a1d527306132779f0bd36c55dccab2398 Mon Sep 17 00:00:00 2001 From: AlpTorac Date: Fri, 25 Oct 2024 16:13:23 +0200 Subject: [PATCH 03/55] Implement abstract class for adaptable initialisers The abstract class encapsulates the logic behind storing adaptation strategies for initialisers --- .../initialisers/AbstractInitialiserBase.java | 69 +++++++++++++++++++ 1 file changed, 69 insertions(+) create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/AbstractInitialiserBase.java diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/AbstractInitialiserBase.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/AbstractInitialiserBase.java new file mode 100644 index 0000000000..c631057bc5 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/AbstractInitialiserBase.java @@ -0,0 +1,69 @@ +package cipm.consistency.initialisers; + +import java.util.ArrayList; +import java.util.Collection; + +/** + * An abstract class for {@link IInitialiserBase} implementors, which extends + * them with infrastructure and concrete methods for + * {@link IInitialiserAdapterStrategy}. + * + * @author Alp Torac Genc + */ +public abstract class AbstractInitialiserBase implements IInitialiserBase { + /** + * Stores the added {@link IInitialiserAdapterStrategy} instances. + */ + private Collection adaptingStrats; + + /** + * A variant of {@link #AbstractInitialiserBase(IInitialiserAdapterStrategy[])} + * that takes no {@link IInitialiserAdapterStrategy} instances. + */ + public AbstractInitialiserBase() { + this(null); + } + + /** + * Constructs an instance, which is adapted by the passed + * {@link IInitialiserAdapterStrategy} array. + */ + public AbstractInitialiserBase(IInitialiserAdapterStrategy[] adaptingStrats) { + this.adaptingStrats = this.createAdaptingStrategyCol(); + this.addAdaptingStrategies(adaptingStrats); + } + + /** + * @return A collection to store the added {@link IInitialiserAdapterStrategy} + * instances. Only creates and returns a collection instance, it still + * has to be assigned to relevant attributes and undergo additional + * setup steps (if any). + */ + protected Collection createAdaptingStrategyCol() { + return new ArrayList(); + } + + @Override + public void addAdaptingStrategy(IInitialiserAdapterStrategy strat) { + if (strat != null) + this.adaptingStrats.add(strat); + } + + @Override + public void removeAdaptingStrategy(IInitialiserAdapterStrategy strat) { + if (strat != null) + this.adaptingStrats.remove(strat); + } + + @Override + public void cleanAdaptingStrategy() { + this.adaptingStrats.clear(); + } + + @Override + public Collection getAdaptingStrategies() { + var res = this.createAdaptingStrategyCol(); + res.addAll(this.adaptingStrats); + return res; + } +} From a78aa9134b64b7871e8d30e11ab17f9d8c85c6ae Mon Sep 17 00:00:00 2001 From: AlpTorac Date: Fri, 25 Oct 2024 16:17:57 +0200 Subject: [PATCH 04/55] Implement an interface for initialiser discovery Initialiser packages (IInitialiserPackage implementors) can be used to grant centralised access to related groups of initialisers. They mimic org.emftext.language.java.JavaPackage and allow package-based access to initialisers. The content of initialiser packages is to be defined by overriding certain methods (refer to the documentation within the IInitialiserPackage interface). --- .../initialisers/IInitialiserPackage.java | 168 ++++++++++++++++++ 1 file changed, 168 insertions(+) create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/IInitialiserPackage.java diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/IInitialiserPackage.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/IInitialiserPackage.java new file mode 100644 index 0000000000..9d1d64c5fd --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/IInitialiserPackage.java @@ -0,0 +1,168 @@ +package cipm.consistency.initialisers; + +import java.util.ArrayList; +import java.util.Collection; + +/** + * An interface meant to be implemented by classes that provide access to groups + * of instances, classes and interfaces that implement {@link IInitialiser}. Can + * be used to discover which initialisers are present and to allow centralised + * access to initialisers.
+ *
+ * Override {@link #getInitialiserInstances()}, + * {@link #getInitialiserInterfaceTypes()} and {@link #getSubPackages()} to + * change what the implementors encompass. The default implementations of the + * methods only return an empty collection of their respective return type. + * + * @author Alp Torac Genc + */ +public interface IInitialiserPackage { + /** + * @return {@link IInitialiser} instances that are contained in this instance. + * + * @see {@link #getAllInitialiserInstances()} for all such initialisers that are + * accessible from this. + */ + public default Collection getInitialiserInstances() { + return this.initCol(); + } + + /** + * @return Class objects of {@link IInitialiser} types that are contained in + * this instance. + * + * @see {@link #getAllInitialiserInterfaceTypes()} for all such initialiser + * types that are accessible from this. + */ + public default Collection> getInitialiserInterfaceTypes() { + return this.initCol(); + } + + /** + * @return All {@link IInitialiserPackage} instances nested in this. + */ + public default Collection getSubPackages() { + return this.initCol(); + } + + /** + * @return An empty collection that will be used to store objects of type T. + */ + public default Collection initCol() { + return new ArrayList(); + } + + /** + * A variant of {@link #initCol()} that also adds the given elems to the created + * collection. + * + * @return A collection containing elems. + */ + public default Collection initCol(T[] elems) { + Collection res = this.initCol(); + + for (var e : elems) { + res.add(e); + } + + return res; + } + + /** + * Recursively discovers all nested {@link IInitialiserPackage} instances + * reachable from this instance. + * + * @return All {@link IInitialiserPackage} instances accessible from this. + * + * @see {@link #getSubPackages()} for initialiser packages that are contained in + * this. + */ + public default Collection getAllSubPackages() { + var result = this.getSubPackages(); + + for (var pac : this.getSubPackages()) { + result.addAll(pac.getSubPackages()); + } + + return result; + } + + /** + * Recursively discovers all nested {@link IInitialiserPackage} instances + * reachable from this instance. + * + * @return All {@link IInitialiser} instances accessible from this. + * + * @see {@link #getInitialiserInstances()} for initialiser instances that are + * contained in this. + */ + public default Collection getAllInitialiserInstances() { + var result = this.getInitialiserInstances(); + + for (var pac : this.getAllSubPackages()) { + result.addAll(pac.getInitialiserInstances()); + } + + return result; + } + + /** + * Recursively discovers all nested {@link IInitialiserPackage} instances + * reachable from this instance. + * + * @return All initialiser types that are accessible from this. + * + * @see {@link #getInitialiserInterfaceTypes()} for initialiser types that are + * contained in this. + */ + public default Collection> getAllInitialiserInterfaceTypes() { + var result = this.getInitialiserInterfaceTypes(); + + for (var pac : this.getAllSubPackages()) { + result.addAll(pac.getInitialiserInterfaceTypes()); + } + + return result; + } + + /** + * Recursively looks through all nested {@link IInitialiserPackage} instances + * for an {@link IInitialiser} type, which is capable of instantiating the given + * cls. + * + * @return The class object of the {@link IInitialiser} type meant to + * instantiate the given cls. Null, if there is no such + * {@link IInitialiser} reachable from this. + */ + public default Class getInitialiserInterfaceTypeFor(Class cls) { + var initClss = this.getAllInitialiserInterfaceTypes(); + + for (var initCls : initClss) { + if (IInitialiser.isInitialiserFor(initCls, cls)) { + return initCls; + } + } + + return null; + } + + /** + * Recursively looks for an {@link IInitialiser} instance, which is capable of + * instantiating the given cls. + * + * @return An instance of the {@link IInitialiser} that is meant to instantiate + * cls. Null, if there is no such {@link IInitialiser} reachable from + * this. + */ + public default IInitialiser getInitialiserInstanceFor(Class cls) { + var init = this.getAllInitialiserInstances(); + + for (var i : init) { + if (i.isInitialiserFor(cls)) { + return i; + } + } + + return null; + } +} From ddce2482c74f9ca531c9e6afed9bfeee2bcaed4b Mon Sep 17 00:00:00 2001 From: AlpTorac Date: Fri, 25 Oct 2024 16:18:40 +0200 Subject: [PATCH 05/55] Add package commentary for top-level interfaces --- .../initialisers/package-info.java | 31 +++++++++++++++++++ 1 file changed, 31 insertions(+) create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/package-info.java diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/package-info.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/package-info.java new file mode 100644 index 0000000000..5dadf2e394 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/package-info.java @@ -0,0 +1,31 @@ +/** + * Contains interfaces for initialiser implementations (such as + * {@link cipm.consistency.initialisers.IInitialiser} as well as for classes + * that can be used to adapt them. Also has an interface + * {@link cipm.consistency.initialisers.IInitialiserPackage}, which can be + * implemented to access initialiser types and instances easier.
+ *
+ * Initialisers are classes/interfaces, whose purpose is to instantiate, + * initialise and modify certain objects. Implementing initialisers similar to + * their designated objects, may help making the initialisers more flexible and + * can ease adding further initialisers later on. It is strongly recommended to + * define atomic modification methods in initialisers and re-using them, rather + * than defining complex modification methods.
+ *
+ * In order to make parameterised tests using initialisers as parameters + * possible, one can use + * {@link cipm.consistency.initialisers.IInitialiserAdapterStrategy} to adapt + * certain initialisers. This way, they can be used in such tests without + * throwing exceptions and without the need of type checking. The most common + * cause of such exceptions is initialisers not setting the required attributes + * while instantiating objects. In such cases, the said adapters can be used to + * have them set those attributes, so that using the instances in tests do not + * throw exceptions, due to their essential attributes not being set.
+ *
+ * {@link cipm.consistency.initialisers.IInitialiserPackage} defines a nestable + * structure that enables finding the proper initialisers as well as certain + * groups of initialisers. It is recommended to implement that interface for + * each package containing initialisers and to add all initialisers to that + * implementation. + */ +package cipm.consistency.initialisers; \ No newline at end of file From 850a5088b805e6abe0405cc9f036ac0b12839bd2 Mon Sep 17 00:00:00 2001 From: AlpTorac Date: Fri, 25 Oct 2024 16:21:47 +0200 Subject: [PATCH 06/55] Implement an interface to extend IInitialiser for EObject --- .../eobject/IEObjectInitialiser.java | 29 +++++++++++++++++++ 1 file changed, 29 insertions(+) create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/eobject/IEObjectInitialiser.java diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/eobject/IEObjectInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/eobject/IEObjectInitialiser.java new file mode 100644 index 0000000000..50bfb2c59c --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/eobject/IEObjectInitialiser.java @@ -0,0 +1,29 @@ +package cipm.consistency.initialisers.eobject; + +import org.eclipse.emf.ecore.EObject; + +import cipm.consistency.initialisers.IInitialiser; +import cipm.consistency.initialisers.IInitialiserAdapterStrategy; + +/** + * An interface for {@link IInitialiser} sub-types, whose purpose is to create + * and modify {@link EObject} instances. + * + * @author Alp Torac Genc + */ +public interface IEObjectInitialiser extends IInitialiser { + /** + * {@inheritDoc}
+ *
+ * Note: The created instance may not be "valid" due to certain attributes + * not being set. Using proper {@link IInitialiserAdapter} instances on + * implementors can circumvent potential issues. + * + * @see {@link IInitialiserAdapter}, {@link IInitialiserAdapterStrategy} + */ + @Override + public EObject instantiate(); + + @Override + public IEObjectInitialiser newInitialiser(); +} From ff64132693fa1c5d059154dd935ea231f0daf536 Mon Sep 17 00:00:00 2001 From: AlpTorac Date: Fri, 25 Oct 2024 16:26:27 +0200 Subject: [PATCH 07/55] Add package commentary --- .../cipm/consistency/initialisers/eobject/package-info.java | 5 +++++ 1 file changed, 5 insertions(+) create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/eobject/package-info.java diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/eobject/package-info.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/eobject/package-info.java new file mode 100644 index 0000000000..fff1daa7f3 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/eobject/package-info.java @@ -0,0 +1,5 @@ +/** + * Contains the means to extend {@link IInitialiser} for {@link EObject} + * implementors. + */ +package cipm.consistency.initialisers.eobject; \ No newline at end of file From 2b8042d0afd376d1b0330724d1661503d9b85382 Mon Sep 17 00:00:00 2001 From: AlpTorac Date: Fri, 25 Oct 2024 16:30:29 +0200 Subject: [PATCH 08/55] Implement an interface to adapt IEObjectInitialiser for Java-related classes (all of them extend EObject) used by JaMoPP. The main purpose of this interface is to make it easier to declare methods for the said classes. This interface can also be used to filter JaMoPP-related initialisers from EObject initialisers, if initialisers for other EObject utilising techologies are implemented in the future. --- .../jamopp/IJaMoPPEObjectInitialiser.java | 15 +++++++++++++++ 1 file changed, 15 insertions(+) create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/IJaMoPPEObjectInitialiser.java diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/IJaMoPPEObjectInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/IJaMoPPEObjectInitialiser.java new file mode 100644 index 0000000000..567d02c076 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/IJaMoPPEObjectInitialiser.java @@ -0,0 +1,15 @@ +package cipm.consistency.initialisers.jamopp; + +import cipm.consistency.initialisers.eobject.IEObjectInitialiser; + +/** + * An interface meant to be implemented by {@link IEObjectInitialiser} + * sub-types, whose purpose is to create {@link EObject} implementors within + * JaMoPP. + * + * @author Alp Torac Genc + */ +public interface IJaMoPPEObjectInitialiser extends IEObjectInitialiser { + @Override + public IJaMoPPEObjectInitialiser newInitialiser(); +} From daaeca5a06e92108fc32c264304e760ec64408b3 Mon Sep 17 00:00:00 2001 From: AlpTorac Date: Fri, 25 Oct 2024 16:33:23 +0200 Subject: [PATCH 09/55] Implement initialiser package for org.emftext.language.java.commons --- .../commons/CommonsInitialiserPackage.java | 15 ++++++ .../commons/ICommentableInitialiser.java | 11 +++++ .../commons/INamedElementInitialiser.java | 49 +++++++++++++++++++ .../INamespaceAwareElementInitialiser.java | 20 ++++++++ .../jamopp/commons/package-info.java | 5 ++ 5 files changed, 100 insertions(+) create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/commons/CommonsInitialiserPackage.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/commons/ICommentableInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/commons/INamedElementInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/commons/INamespaceAwareElementInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/commons/package-info.java diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/commons/CommonsInitialiserPackage.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/commons/CommonsInitialiserPackage.java new file mode 100644 index 0000000000..f8c470efe3 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/commons/CommonsInitialiserPackage.java @@ -0,0 +1,15 @@ +package cipm.consistency.initialisers.jamopp.commons; + +import java.util.Collection; + +import cipm.consistency.initialisers.IInitialiser; +import cipm.consistency.initialisers.IInitialiserPackage; + +public class CommonsInitialiserPackage implements IInitialiserPackage { + @SuppressWarnings("unchecked") + @Override + public Collection> getInitialiserInterfaceTypes() { + return this.initCol(new Class[] { ICommentableInitialiser.class, INamedElementInitialiser.class, + INamespaceAwareElementInitialiser.class }); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/commons/ICommentableInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/commons/ICommentableInitialiser.java new file mode 100644 index 0000000000..4a7aabc787 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/commons/ICommentableInitialiser.java @@ -0,0 +1,11 @@ +package cipm.consistency.initialisers.jamopp.commons; + +import org.emftext.language.java.commons.Commentable; + +import cipm.consistency.initialisers.jamopp.IJaMoPPEObjectInitialiser; + +public interface ICommentableInitialiser extends IJaMoPPEObjectInitialiser { + @Override + public Commentable instantiate(); + +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/commons/INamedElementInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/commons/INamedElementInitialiser.java new file mode 100644 index 0000000000..ea1de18495 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/commons/INamedElementInitialiser.java @@ -0,0 +1,49 @@ +package cipm.consistency.initialisers.jamopp.commons; + +import org.emftext.language.java.commons.NamedElement; + +/** + * An interface meant to be implemented by initialisers, which are meant to + * create {@link NamedElement} instances.
+ *
+ * Since some {@link NamedElement} implementations' name attribute cannot be + * modified as expected, {@link #canSetName(NamedElement)} can be used to + * determine the modifiability of the name attribute in implementors. + * + * @author Alp Torac Genc + */ +public interface INamedElementInitialiser extends ICommentableInitialiser { + @Override + public NamedElement instantiate(); + + /** + * Sets the name attribute of the given element to the given name, if its name + * can be set.
+ *
+ * Note: If {@code name == null}, the return value will be true, regardless of + * the name attribute being modifiable. + * + * @see {@link #canSetName(NamedElement)} + */ + public default boolean setName(NamedElement ne, String name) { + if (!this.canSetName(ne)) { + return false; + } + ne.setName(name); + return (name == null && ne.getName() == null) || ne.getName().equals(name); + } + + /** + * Extracted from {@link #setName(NamedElement, String)} because there are + * implementors, whose name cannot be modified via + * {@link #setName(NamedElement, String)}. This way, such implementors can + * override this method to indicate, whether their name attribute can be + * modified. + * + * @return Whether {@link #setName(NamedElement, String)} can be used to modify + * the given {@link NamedElement} instance ne. + */ + public default boolean canSetName(NamedElement ne) { + return true; + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/commons/INamespaceAwareElementInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/commons/INamespaceAwareElementInitialiser.java new file mode 100644 index 0000000000..bb739cddf0 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/commons/INamespaceAwareElementInitialiser.java @@ -0,0 +1,20 @@ +package cipm.consistency.initialisers.jamopp.commons; + +import org.emftext.language.java.commons.NamespaceAwareElement; + +public interface INamespaceAwareElementInitialiser extends ICommentableInitialiser { + @Override + public NamespaceAwareElement instantiate(); + + public default boolean addNamespaces(NamespaceAwareElement nae, String[] namespaces) { + return this.doMultipleModifications(nae, namespaces, this::addNamespace); + } + + public default boolean addNamespace(NamespaceAwareElement nae, String namespace) { + if (namespace != null) { + nae.getNamespaces().add(namespace); + return nae.getNamespaces().contains(namespace); + } + return true; + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/commons/package-info.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/commons/package-info.java new file mode 100644 index 0000000000..18bb567649 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/commons/package-info.java @@ -0,0 +1,5 @@ +/** + * Contains {@link IInitialiser} implementations for + * {@link org.emftext.language.java.commons}. + */ +package cipm.consistency.initialisers.jamopp.commons; \ No newline at end of file From 47f8f8f4f1ca3f2e5d6adf96d85ca2ecf3765093 Mon Sep 17 00:00:00 2001 From: AlpTorac Date: Fri, 25 Oct 2024 16:36:26 +0200 Subject: [PATCH 10/55] Implement initialiser package for org.emftext.language.java.annotations --- ...AnnotationAttributeSettingInitialiser.java | 19 +++++++++++++++ .../AnnotationInstanceInitialiser.java | 20 ++++++++++++++++ .../AnnotationParameterListInitialiser.java | 20 ++++++++++++++++ .../AnnotationsInitialiserPackage.java | 24 +++++++++++++++++++ .../annotations/IAnnotableInitialiser.java | 24 +++++++++++++++++++ ...AnnotationAttributeSettingInitialiser.java | 22 +++++++++++++++++ .../IAnnotationInstanceInitialiser.java | 22 +++++++++++++++++ .../IAnnotationParameterInitialiser.java | 11 +++++++++ .../IAnnotationParameterListInitialiser.java | 21 ++++++++++++++++ .../IAnnotationValueInitialiser.java | 11 +++++++++ ...ISingleAnnotationParameterInitialiser.java | 14 +++++++++++ .../SingleAnnotationParameterInitialiser.java | 19 +++++++++++++++ .../jamopp/annotations/package-info.java | 5 ++++ 13 files changed, 232 insertions(+) create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/annotations/AnnotationAttributeSettingInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/annotations/AnnotationInstanceInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/annotations/AnnotationParameterListInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/annotations/AnnotationsInitialiserPackage.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/annotations/IAnnotableInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/annotations/IAnnotationAttributeSettingInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/annotations/IAnnotationInstanceInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/annotations/IAnnotationParameterInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/annotations/IAnnotationParameterListInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/annotations/IAnnotationValueInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/annotations/ISingleAnnotationParameterInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/annotations/SingleAnnotationParameterInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/annotations/package-info.java diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/annotations/AnnotationAttributeSettingInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/annotations/AnnotationAttributeSettingInitialiser.java new file mode 100644 index 0000000000..25793b9fb5 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/annotations/AnnotationAttributeSettingInitialiser.java @@ -0,0 +1,19 @@ +package cipm.consistency.initialisers.jamopp.annotations; + +import org.emftext.language.java.annotations.AnnotationAttributeSetting; +import org.emftext.language.java.annotations.AnnotationsFactory; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class AnnotationAttributeSettingInitialiser extends AbstractInitialiserBase + implements IAnnotationAttributeSettingInitialiser { + @Override + public IAnnotationAttributeSettingInitialiser newInitialiser() { + return new AnnotationAttributeSettingInitialiser(); + } + + @Override + public AnnotationAttributeSetting instantiate() { + return AnnotationsFactory.eINSTANCE.createAnnotationAttributeSetting(); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/annotations/AnnotationInstanceInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/annotations/AnnotationInstanceInitialiser.java new file mode 100644 index 0000000000..1aa1eca795 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/annotations/AnnotationInstanceInitialiser.java @@ -0,0 +1,20 @@ +package cipm.consistency.initialisers.jamopp.annotations; + +import org.emftext.language.java.annotations.AnnotationsFactory; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +import org.emftext.language.java.annotations.AnnotationInstance; + +public class AnnotationInstanceInitialiser extends AbstractInitialiserBase implements IAnnotationInstanceInitialiser { + @Override + public AnnotationInstance instantiate() { + var fac = AnnotationsFactory.eINSTANCE; + return fac.createAnnotationInstance(); + } + + @Override + public IAnnotationInstanceInitialiser newInitialiser() { + return new AnnotationInstanceInitialiser(); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/annotations/AnnotationParameterListInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/annotations/AnnotationParameterListInitialiser.java new file mode 100644 index 0000000000..0c5197ef9a --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/annotations/AnnotationParameterListInitialiser.java @@ -0,0 +1,20 @@ +package cipm.consistency.initialisers.jamopp.annotations; + +import org.emftext.language.java.annotations.AnnotationsFactory; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +import org.emftext.language.java.annotations.AnnotationParameterList; + +public class AnnotationParameterListInitialiser extends AbstractInitialiserBase + implements IAnnotationParameterListInitialiser { + @Override + public IAnnotationParameterListInitialiser newInitialiser() { + return new AnnotationParameterListInitialiser(); + } + + @Override + public AnnotationParameterList instantiate() { + return AnnotationsFactory.eINSTANCE.createAnnotationParameterList(); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/annotations/AnnotationsInitialiserPackage.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/annotations/AnnotationsInitialiserPackage.java new file mode 100644 index 0000000000..52d37e8eb2 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/annotations/AnnotationsInitialiserPackage.java @@ -0,0 +1,24 @@ +package cipm.consistency.initialisers.jamopp.annotations; + +import java.util.Collection; + +import cipm.consistency.initialisers.IInitialiser; +import cipm.consistency.initialisers.IInitialiserPackage; + +public class AnnotationsInitialiserPackage implements IInitialiserPackage { + @Override + public Collection getInitialiserInstances() { + return this.initCol( + new IInitialiser[] { new AnnotationAttributeSettingInitialiser(), new AnnotationInstanceInitialiser(), + new AnnotationParameterListInitialiser(), new SingleAnnotationParameterInitialiser() }); + } + + @SuppressWarnings("unchecked") + @Override + public Collection> getInitialiserInterfaceTypes() { + return this.initCol(new Class[] { IAnnotableInitialiser.class, IAnnotationAttributeSettingInitialiser.class, + IAnnotationInstanceInitialiser.class, IAnnotationParameterInitialiser.class, + IAnnotationParameterListInitialiser.class, IAnnotationValueInitialiser.class, + ISingleAnnotationParameterInitialiser.class }); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/annotations/IAnnotableInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/annotations/IAnnotableInitialiser.java new file mode 100644 index 0000000000..8aa528e96d --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/annotations/IAnnotableInitialiser.java @@ -0,0 +1,24 @@ +package cipm.consistency.initialisers.jamopp.annotations; + +import org.emftext.language.java.annotations.Annotable; +import org.emftext.language.java.annotations.AnnotationInstance; + +import cipm.consistency.initialisers.jamopp.commons.ICommentableInitialiser; + +public interface IAnnotableInitialiser extends ICommentableInitialiser { + @Override + public Annotable instantiate(); + + public default boolean addAnnotation(Annotable aObj, AnnotationInstance anno) { + if (anno != null) { + aObj.getAnnotations().add(anno); + return aObj.getAnnotations().contains(anno); + } + + return true; + } + + public default boolean addAnnotations(Annotable aObj, AnnotationInstance[] annos) { + return this.doMultipleModifications(aObj, annos, this::addAnnotation); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/annotations/IAnnotationAttributeSettingInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/annotations/IAnnotationAttributeSettingInitialiser.java new file mode 100644 index 0000000000..9d44645a05 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/annotations/IAnnotationAttributeSettingInitialiser.java @@ -0,0 +1,22 @@ +package cipm.consistency.initialisers.jamopp.annotations; + +import org.emftext.language.java.annotations.AnnotationAttributeSetting; +import org.emftext.language.java.annotations.AnnotationValue; +import org.emftext.language.java.members.InterfaceMethod; + +import cipm.consistency.initialisers.jamopp.commons.ICommentableInitialiser; + +public interface IAnnotationAttributeSettingInitialiser extends ICommentableInitialiser { + @Override + public AnnotationAttributeSetting instantiate(); + + public default boolean setAttribute(AnnotationAttributeSetting aas, InterfaceMethod attr) { + aas.setAttribute(attr); + return (attr == null && aas.getAttribute() == null) || aas.getAttribute().equals(attr); + } + + public default boolean setValue(AnnotationAttributeSetting aas, AnnotationValue val) { + aas.setValue(val); + return (val == null && aas.getValue() == null) || aas.getValue().equals(val); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/annotations/IAnnotationInstanceInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/annotations/IAnnotationInstanceInitialiser.java new file mode 100644 index 0000000000..bcd71e1e69 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/annotations/IAnnotationInstanceInitialiser.java @@ -0,0 +1,22 @@ +package cipm.consistency.initialisers.jamopp.annotations; + +import org.emftext.language.java.annotations.AnnotationInstance; +import org.emftext.language.java.annotations.AnnotationParameter; +import org.emftext.language.java.classifiers.Classifier; + +import cipm.consistency.initialisers.jamopp.commons.INamespaceAwareElementInitialiser; + +public interface IAnnotationInstanceInitialiser extends INamespaceAwareElementInitialiser { + @Override + public AnnotationInstance instantiate(); + + public default boolean setAnnotation(AnnotationInstance ai, Classifier anno) { + ai.setAnnotation(anno); + return (anno == null && ai.getAnnotation() == null) || ai.getAnnotation().equals(anno); + } + + public default boolean setParameter(AnnotationInstance ai, AnnotationParameter param) { + ai.setParameter(param); + return (param == null && ai.getParameter() == null) || ai.getParameter().equals(param); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/annotations/IAnnotationParameterInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/annotations/IAnnotationParameterInitialiser.java new file mode 100644 index 0000000000..fcc8df3021 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/annotations/IAnnotationParameterInitialiser.java @@ -0,0 +1,11 @@ +package cipm.consistency.initialisers.jamopp.annotations; + +import org.emftext.language.java.annotations.AnnotationParameter; + +import cipm.consistency.initialisers.jamopp.commons.ICommentableInitialiser; + +public interface IAnnotationParameterInitialiser extends ICommentableInitialiser { + @Override + public AnnotationParameter instantiate(); + +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/annotations/IAnnotationParameterListInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/annotations/IAnnotationParameterListInitialiser.java new file mode 100644 index 0000000000..98f57efb0d --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/annotations/IAnnotationParameterListInitialiser.java @@ -0,0 +1,21 @@ +package cipm.consistency.initialisers.jamopp.annotations; + +import org.emftext.language.java.annotations.AnnotationAttributeSetting; +import org.emftext.language.java.annotations.AnnotationParameterList; + +public interface IAnnotationParameterListInitialiser extends IAnnotationParameterInitialiser { + @Override + public AnnotationParameterList instantiate(); + + public default boolean addSetting(AnnotationParameterList apl, AnnotationAttributeSetting setting) { + if (setting != null) { + apl.getSettings().add(setting); + return apl.getSettings().contains(setting); + } + return true; + } + + public default boolean addSettings(AnnotationParameterList apl, AnnotationAttributeSetting[] settings) { + return this.doMultipleModifications(apl, settings, this::addSetting); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/annotations/IAnnotationValueInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/annotations/IAnnotationValueInitialiser.java new file mode 100644 index 0000000000..a7816d9346 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/annotations/IAnnotationValueInitialiser.java @@ -0,0 +1,11 @@ +package cipm.consistency.initialisers.jamopp.annotations; + +import org.emftext.language.java.annotations.AnnotationValue; + +import cipm.consistency.initialisers.jamopp.commons.ICommentableInitialiser; + +public interface IAnnotationValueInitialiser extends ICommentableInitialiser { + @Override + public AnnotationValue instantiate(); + +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/annotations/ISingleAnnotationParameterInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/annotations/ISingleAnnotationParameterInitialiser.java new file mode 100644 index 0000000000..6c2ddf03e2 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/annotations/ISingleAnnotationParameterInitialiser.java @@ -0,0 +1,14 @@ +package cipm.consistency.initialisers.jamopp.annotations; + +import org.emftext.language.java.annotations.AnnotationValue; +import org.emftext.language.java.annotations.SingleAnnotationParameter; + +public interface ISingleAnnotationParameterInitialiser extends IAnnotationParameterInitialiser { + @Override + public SingleAnnotationParameter instantiate(); + + public default boolean setValue(SingleAnnotationParameter sap, AnnotationValue val) { + sap.setValue(val); + return (val == null && sap.getValue() == null) || sap.getValue().equals(val); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/annotations/SingleAnnotationParameterInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/annotations/SingleAnnotationParameterInitialiser.java new file mode 100644 index 0000000000..185f00118a --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/annotations/SingleAnnotationParameterInitialiser.java @@ -0,0 +1,19 @@ +package cipm.consistency.initialisers.jamopp.annotations; + +import org.emftext.language.java.annotations.AnnotationsFactory; +import org.emftext.language.java.annotations.SingleAnnotationParameter; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class SingleAnnotationParameterInitialiser extends AbstractInitialiserBase + implements ISingleAnnotationParameterInitialiser { + @Override + public ISingleAnnotationParameterInitialiser newInitialiser() { + return new SingleAnnotationParameterInitialiser(); + } + + @Override + public SingleAnnotationParameter instantiate() { + return AnnotationsFactory.eINSTANCE.createSingleAnnotationParameter(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/annotations/package-info.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/annotations/package-info.java new file mode 100644 index 0000000000..5796ca11e9 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/annotations/package-info.java @@ -0,0 +1,5 @@ +/** + * Contains {@link IInitialiser} implementations for + * {@link org.emftext.language.java.annotations}. + */ +package cipm.consistency.initialisers.jamopp.annotations; \ No newline at end of file From a1d7836bcd56b3d55848adf7d780b8549111e034 Mon Sep 17 00:00:00 2001 From: AlpTorac Date: Fri, 25 Oct 2024 16:45:41 +0200 Subject: [PATCH 11/55] Implement initialiser package for org.emftext.language.java.imports --- .../imports/ClassifierImportInitialiser.java | 18 +++++++++++++++ .../imports/IClassifierImportInitialiser.java | 9 ++++++++ .../jamopp/imports/IImportInitialiser.java | 16 +++++++++++++ .../imports/IImportingElementInitialiser.java | 23 +++++++++++++++++++ .../imports/IPackageImportInitialiser.java | 9 ++++++++ .../IStaticClassifierImportInitialiser.java | 8 +++++++ .../imports/IStaticImportInitialiser.java | 14 +++++++++++ .../IStaticMemberImportInitialiser.java | 21 +++++++++++++++++ .../imports/ImportsInitialiserPackage.java | 22 ++++++++++++++++++ .../imports/PackageImportInitialiser.java | 18 +++++++++++++++ .../StaticClassifierImportInitialiser.java | 19 +++++++++++++++ .../StaticMemberImportInitialiser.java | 18 +++++++++++++++ .../jamopp/imports/package-info.java | 5 ++++ 13 files changed, 200 insertions(+) create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/imports/ClassifierImportInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/imports/IClassifierImportInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/imports/IImportInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/imports/IImportingElementInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/imports/IPackageImportInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/imports/IStaticClassifierImportInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/imports/IStaticImportInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/imports/IStaticMemberImportInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/imports/ImportsInitialiserPackage.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/imports/PackageImportInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/imports/StaticClassifierImportInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/imports/StaticMemberImportInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/imports/package-info.java diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/imports/ClassifierImportInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/imports/ClassifierImportInitialiser.java new file mode 100644 index 0000000000..b50a83041b --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/imports/ClassifierImportInitialiser.java @@ -0,0 +1,18 @@ +package cipm.consistency.initialisers.jamopp.imports; + +import org.emftext.language.java.imports.ClassifierImport; +import org.emftext.language.java.imports.ImportsFactory; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class ClassifierImportInitialiser extends AbstractInitialiserBase implements IClassifierImportInitialiser { + @Override + public IClassifierImportInitialiser newInitialiser() { + return new ClassifierImportInitialiser(); + } + + @Override + public ClassifierImport instantiate() { + return ImportsFactory.eINSTANCE.createClassifierImport(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/imports/IClassifierImportInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/imports/IClassifierImportInitialiser.java new file mode 100644 index 0000000000..d340c1d59e --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/imports/IClassifierImportInitialiser.java @@ -0,0 +1,9 @@ +package cipm.consistency.initialisers.jamopp.imports; + +import org.emftext.language.java.imports.ClassifierImport; + +public interface IClassifierImportInitialiser extends IImportInitialiser { + @Override + public ClassifierImport instantiate(); + +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/imports/IImportInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/imports/IImportInitialiser.java new file mode 100644 index 0000000000..96599398cb --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/imports/IImportInitialiser.java @@ -0,0 +1,16 @@ +package cipm.consistency.initialisers.jamopp.imports; + +import org.emftext.language.java.classifiers.ConcreteClassifier; +import org.emftext.language.java.imports.Import; + +import cipm.consistency.initialisers.jamopp.commons.INamespaceAwareElementInitialiser; + +public interface IImportInitialiser extends INamespaceAwareElementInitialiser { + @Override + public Import instantiate(); + + public default boolean setClassifier(Import imp, ConcreteClassifier cls) { + imp.setClassifier(cls); + return (cls == null && imp.getClassifier() == null) || imp.getClassifier().equals(cls); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/imports/IImportingElementInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/imports/IImportingElementInitialiser.java new file mode 100644 index 0000000000..d697652b01 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/imports/IImportingElementInitialiser.java @@ -0,0 +1,23 @@ +package cipm.consistency.initialisers.jamopp.imports; + +import org.emftext.language.java.imports.Import; +import org.emftext.language.java.imports.ImportingElement; + +import cipm.consistency.initialisers.jamopp.commons.ICommentableInitialiser; + +public interface IImportingElementInitialiser extends ICommentableInitialiser { + @Override + public ImportingElement instantiate(); + + public default boolean addImport(ImportingElement ie, Import imp) { + if (imp != null) { + ie.getImports().add(imp); + return ie.getImports().contains(imp); + } + return true; + } + + public default boolean addImports(ImportingElement ie, Import[] imps) { + return this.doMultipleModifications(ie, imps, this::addImport); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/imports/IPackageImportInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/imports/IPackageImportInitialiser.java new file mode 100644 index 0000000000..fe4e5b6a4f --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/imports/IPackageImportInitialiser.java @@ -0,0 +1,9 @@ +package cipm.consistency.initialisers.jamopp.imports; + +import org.emftext.language.java.imports.PackageImport; + +public interface IPackageImportInitialiser extends IImportInitialiser { + @Override + public PackageImport instantiate(); + +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/imports/IStaticClassifierImportInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/imports/IStaticClassifierImportInitialiser.java new file mode 100644 index 0000000000..c5a95ed255 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/imports/IStaticClassifierImportInitialiser.java @@ -0,0 +1,8 @@ +package cipm.consistency.initialisers.jamopp.imports; + +import org.emftext.language.java.imports.StaticClassifierImport; + +public interface IStaticClassifierImportInitialiser extends IStaticImportInitialiser { + @Override + public StaticClassifierImport instantiate(); +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/imports/IStaticImportInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/imports/IStaticImportInitialiser.java new file mode 100644 index 0000000000..23db2c82d7 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/imports/IStaticImportInitialiser.java @@ -0,0 +1,14 @@ +package cipm.consistency.initialisers.jamopp.imports; + +import org.emftext.language.java.imports.StaticImport; +import org.emftext.language.java.modifiers.Static; + +public interface IStaticImportInitialiser extends IImportInitialiser { + @Override + public StaticImport instantiate(); + + public default boolean setStatic(StaticImport sImp, Static st) { + sImp.setStatic(st); + return (st == null && sImp.getStatic() == null) || sImp.getStatic().equals(st); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/imports/IStaticMemberImportInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/imports/IStaticMemberImportInitialiser.java new file mode 100644 index 0000000000..79c1552ecc --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/imports/IStaticMemberImportInitialiser.java @@ -0,0 +1,21 @@ +package cipm.consistency.initialisers.jamopp.imports; + +import org.emftext.language.java.imports.StaticMemberImport; +import org.emftext.language.java.references.ReferenceableElement; + +public interface IStaticMemberImportInitialiser extends IStaticImportInitialiser { + @Override + public StaticMemberImport instantiate(); + + public default boolean addStaticMember(StaticMemberImport smi, ReferenceableElement staticMem) { + if (staticMem != null) { + smi.getStaticMembers().add(staticMem); + return smi.getStaticMembers().contains(staticMem); + } + return true; + } + + public default boolean addStaticMembers(StaticMemberImport smi, ReferenceableElement[] staticMems) { + return this.doMultipleModifications(smi, staticMems, this::addStaticMember); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/imports/ImportsInitialiserPackage.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/imports/ImportsInitialiserPackage.java new file mode 100644 index 0000000000..c40c859db8 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/imports/ImportsInitialiserPackage.java @@ -0,0 +1,22 @@ +package cipm.consistency.initialisers.jamopp.imports; + +import java.util.Collection; + +import cipm.consistency.initialisers.IInitialiser; +import cipm.consistency.initialisers.IInitialiserPackage; + +public class ImportsInitialiserPackage implements IInitialiserPackage { + @Override + public Collection getInitialiserInstances() { + return this.initCol(new IInitialiser[] { new ClassifierImportInitialiser(), new PackageImportInitialiser(), + new StaticClassifierImportInitialiser(), new StaticMemberImportInitialiser(), }); + } + + @SuppressWarnings("unchecked") + @Override + public Collection> getInitialiserInterfaceTypes() { + return this.initCol(new Class[] { IClassifierImportInitialiser.class, IImportingElementInitialiser.class, + IImportInitialiser.class, IPackageImportInitialiser.class, IStaticClassifierImportInitialiser.class, + IStaticImportInitialiser.class, IStaticMemberImportInitialiser.class, }); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/imports/PackageImportInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/imports/PackageImportInitialiser.java new file mode 100644 index 0000000000..7ede42f682 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/imports/PackageImportInitialiser.java @@ -0,0 +1,18 @@ +package cipm.consistency.initialisers.jamopp.imports; + +import org.emftext.language.java.imports.ImportsFactory; +import org.emftext.language.java.imports.PackageImport; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class PackageImportInitialiser extends AbstractInitialiserBase implements IPackageImportInitialiser { + @Override + public IPackageImportInitialiser newInitialiser() { + return new PackageImportInitialiser(); + } + + @Override + public PackageImport instantiate() { + return ImportsFactory.eINSTANCE.createPackageImport(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/imports/StaticClassifierImportInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/imports/StaticClassifierImportInitialiser.java new file mode 100644 index 0000000000..f6fde342c4 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/imports/StaticClassifierImportInitialiser.java @@ -0,0 +1,19 @@ +package cipm.consistency.initialisers.jamopp.imports; + +import org.emftext.language.java.imports.ImportsFactory; +import org.emftext.language.java.imports.StaticClassifierImport; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class StaticClassifierImportInitialiser extends AbstractInitialiserBase + implements IStaticClassifierImportInitialiser { + @Override + public IStaticClassifierImportInitialiser newInitialiser() { + return new StaticClassifierImportInitialiser(); + } + + @Override + public StaticClassifierImport instantiate() { + return ImportsFactory.eINSTANCE.createStaticClassifierImport(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/imports/StaticMemberImportInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/imports/StaticMemberImportInitialiser.java new file mode 100644 index 0000000000..4fb7c7ef7a --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/imports/StaticMemberImportInitialiser.java @@ -0,0 +1,18 @@ +package cipm.consistency.initialisers.jamopp.imports; + +import org.emftext.language.java.imports.ImportsFactory; +import org.emftext.language.java.imports.StaticMemberImport; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class StaticMemberImportInitialiser extends AbstractInitialiserBase implements IStaticMemberImportInitialiser { + @Override + public IStaticMemberImportInitialiser newInitialiser() { + return new StaticMemberImportInitialiser(); + } + + @Override + public StaticMemberImport instantiate() { + return ImportsFactory.eINSTANCE.createStaticMemberImport(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/imports/package-info.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/imports/package-info.java new file mode 100644 index 0000000000..d8e4cf29c0 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/imports/package-info.java @@ -0,0 +1,5 @@ +/** + * Contains {@link IInitialiser} implementations for + * {@link org.emftext.language.java.imports}. + */ +package cipm.consistency.initialisers.jamopp.imports; \ No newline at end of file From f40ad6d8ffeedcea981735f026694bb897c33a9e Mon Sep 17 00:00:00 2001 From: AlpTorac Date: Fri, 25 Oct 2024 16:49:38 +0200 Subject: [PATCH 12/55] Implement initialiser package for org.emftext.language.java.modifiers --- .../jamopp/modifiers/AbstractInitialiser.java | 18 +++++++ .../jamopp/modifiers/DefaultInitialiser.java | 18 +++++++ .../jamopp/modifiers/FinalInitialiser.java | 18 +++++++ .../modifiers/IAbstractInitialiser.java | 9 ++++ .../IAnnotableAndModifiableInitialiser.java | 53 +++++++++++++++++++ ...notationInstanceOrModifierInitialiser.java | 11 ++++ .../jamopp/modifiers/IDefaultInitialiser.java | 9 ++++ .../jamopp/modifiers/IFinalInitialiser.java | 9 ++++ .../modifiers/IModifiableInitialiser.java | 23 ++++++++ .../modifiers/IModifierInitialiser.java | 9 ++++ .../IModuleRequiresModifierInitialiser.java | 11 ++++ .../jamopp/modifiers/INativeInitialiser.java | 9 ++++ .../jamopp/modifiers/IOpenInitialiser.java | 11 ++++ .../jamopp/modifiers/IPrivateInitialiser.java | 9 ++++ .../modifiers/IProtectedInitialiser.java | 9 ++++ .../jamopp/modifiers/IPublicInitialiser.java | 9 ++++ .../jamopp/modifiers/IStaticInitialiser.java | 8 +++ .../modifiers/IStrictfpInitialiser.java | 9 ++++ .../modifiers/ISynchronizedInitialiser.java | 9 ++++ .../modifiers/ITransientInitialiser.java | 9 ++++ .../modifiers/ITransitiveInitialiser.java | 9 ++++ .../modifiers/IVolatileInitialiser.java | 9 ++++ .../ModifiersInitialiserPackage.java | 29 ++++++++++ .../jamopp/modifiers/NativeInitialiser.java | 18 +++++++ .../jamopp/modifiers/OpenInitialiser.java | 18 +++++++ .../jamopp/modifiers/PrivateInitialiser.java | 18 +++++++ .../modifiers/ProtectedInitialiser.java | 18 +++++++ .../jamopp/modifiers/PublicInitialiser.java | 18 +++++++ .../jamopp/modifiers/StaticInitialiser.java | 18 +++++++ .../jamopp/modifiers/StrictfpInitialiser.java | 18 +++++++ .../modifiers/SynchronizedInitialiser.java | 18 +++++++ .../modifiers/TransientInitialiser.java | 18 +++++++ .../modifiers/TransitiveInitialiser.java | 18 +++++++ .../jamopp/modifiers/VolatileInitialiser.java | 18 +++++++ .../jamopp/modifiers/package-info.java | 5 ++ 35 files changed, 520 insertions(+) create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modifiers/AbstractInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modifiers/DefaultInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modifiers/FinalInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modifiers/IAbstractInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modifiers/IAnnotableAndModifiableInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modifiers/IAnnotationInstanceOrModifierInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modifiers/IDefaultInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modifiers/IFinalInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modifiers/IModifiableInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modifiers/IModifierInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modifiers/IModuleRequiresModifierInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modifiers/INativeInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modifiers/IOpenInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modifiers/IPrivateInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modifiers/IProtectedInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modifiers/IPublicInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modifiers/IStaticInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modifiers/IStrictfpInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modifiers/ISynchronizedInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modifiers/ITransientInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modifiers/ITransitiveInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modifiers/IVolatileInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modifiers/ModifiersInitialiserPackage.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modifiers/NativeInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modifiers/OpenInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modifiers/PrivateInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modifiers/ProtectedInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modifiers/PublicInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modifiers/StaticInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modifiers/StrictfpInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modifiers/SynchronizedInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modifiers/TransientInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modifiers/TransitiveInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modifiers/VolatileInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modifiers/package-info.java diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modifiers/AbstractInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modifiers/AbstractInitialiser.java new file mode 100644 index 0000000000..a6f4ecab5b --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modifiers/AbstractInitialiser.java @@ -0,0 +1,18 @@ +package cipm.consistency.initialisers.jamopp.modifiers; + +import org.emftext.language.java.modifiers.Abstract; +import org.emftext.language.java.modifiers.ModifiersFactory; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class AbstractInitialiser extends AbstractInitialiserBase implements IAbstractInitialiser { + @Override + public IAbstractInitialiser newInitialiser() { + return new AbstractInitialiser(); + } + + @Override + public Abstract instantiate() { + return ModifiersFactory.eINSTANCE.createAbstract(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modifiers/DefaultInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modifiers/DefaultInitialiser.java new file mode 100644 index 0000000000..66df255205 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modifiers/DefaultInitialiser.java @@ -0,0 +1,18 @@ +package cipm.consistency.initialisers.jamopp.modifiers; + +import org.emftext.language.java.modifiers.Default; +import org.emftext.language.java.modifiers.ModifiersFactory; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class DefaultInitialiser extends AbstractInitialiserBase implements IDefaultInitialiser { + @Override + public IDefaultInitialiser newInitialiser() { + return new DefaultInitialiser(); + } + + @Override + public Default instantiate() { + return ModifiersFactory.eINSTANCE.createDefault(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modifiers/FinalInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modifiers/FinalInitialiser.java new file mode 100644 index 0000000000..3a383d5d44 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modifiers/FinalInitialiser.java @@ -0,0 +1,18 @@ +package cipm.consistency.initialisers.jamopp.modifiers; + +import org.emftext.language.java.modifiers.Final; +import org.emftext.language.java.modifiers.ModifiersFactory; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class FinalInitialiser extends AbstractInitialiserBase implements IFinalInitialiser { + @Override + public IFinalInitialiser newInitialiser() { + return new FinalInitialiser(); + } + + @Override + public Final instantiate() { + return ModifiersFactory.eINSTANCE.createFinal(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modifiers/IAbstractInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modifiers/IAbstractInitialiser.java new file mode 100644 index 0000000000..09877b9896 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modifiers/IAbstractInitialiser.java @@ -0,0 +1,9 @@ +package cipm.consistency.initialisers.jamopp.modifiers; + +import org.emftext.language.java.modifiers.Abstract; + +public interface IAbstractInitialiser extends IModifierInitialiser { + @Override + public Abstract instantiate(); + +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modifiers/IAnnotableAndModifiableInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modifiers/IAnnotableAndModifiableInitialiser.java new file mode 100644 index 0000000000..e9fee2ccbc --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modifiers/IAnnotableAndModifiableInitialiser.java @@ -0,0 +1,53 @@ +package cipm.consistency.initialisers.jamopp.modifiers; + +import org.emftext.language.java.annotations.AnnotationInstance; +import org.emftext.language.java.modifiers.AnnotableAndModifiable; +import org.emftext.language.java.modifiers.Modifier; + +import cipm.consistency.initialisers.jamopp.commons.ICommentableInitialiser; + +public interface IAnnotableAndModifiableInitialiser extends ICommentableInitialiser { + @Override + public AnnotableAndModifiable instantiate(); + + public default boolean addModifier(AnnotableAndModifiable aam, Modifier modif) { + if (modif != null) { + aam.addModifier(modif); + return aam.getAnnotationsAndModifiers().contains(modif) && aam.hasModifier(modif.getClass()) + && aam.getModifiers().contains(modif); + } + return true; + } + + public default boolean addModifiers(AnnotableAndModifiable aam, Modifier[] modifs) { + return this.doMultipleModifications(aam, modifs, this::addModifier); + } + + public default boolean addAnnotationInstance(AnnotableAndModifiable aam, AnnotationInstance annoAndModif) { + if (aam != null) { + aam.getAnnotationsAndModifiers().add(annoAndModif); + return aam.getAnnotationsAndModifiers().contains(annoAndModif) + && aam.getAnnotationInstances().contains(annoAndModif); + } + return true; + } + + public default boolean addAnnotationInstances(AnnotableAndModifiable aam, AnnotationInstance[] annoAndModifArr) { + return this.doMultipleModifications(aam, annoAndModifArr, this::addAnnotationInstance); + } + + public default boolean makePrivate(AnnotableAndModifiable aam) { + aam.makePrivate(); + return aam.isPrivate(); + } + + public default boolean makeProtected(AnnotableAndModifiable aam) { + aam.makeProtected(); + return aam.isProtected(); + } + + public default boolean makePublic(AnnotableAndModifiable aam) { + aam.makePublic(); + return aam.isPublic(); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modifiers/IAnnotationInstanceOrModifierInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modifiers/IAnnotationInstanceOrModifierInitialiser.java new file mode 100644 index 0000000000..465882b611 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modifiers/IAnnotationInstanceOrModifierInitialiser.java @@ -0,0 +1,11 @@ +package cipm.consistency.initialisers.jamopp.modifiers; + +import org.emftext.language.java.modifiers.AnnotationInstanceOrModifier; + +import cipm.consistency.initialisers.jamopp.commons.ICommentableInitialiser; + +public interface IAnnotationInstanceOrModifierInitialiser extends ICommentableInitialiser { + @Override + public AnnotationInstanceOrModifier instantiate(); + +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modifiers/IDefaultInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modifiers/IDefaultInitialiser.java new file mode 100644 index 0000000000..03a7ec9693 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modifiers/IDefaultInitialiser.java @@ -0,0 +1,9 @@ +package cipm.consistency.initialisers.jamopp.modifiers; + +import org.emftext.language.java.modifiers.Default; + +public interface IDefaultInitialiser extends IModifierInitialiser { + @Override + public Default instantiate(); + +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modifiers/IFinalInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modifiers/IFinalInitialiser.java new file mode 100644 index 0000000000..ef4990dda1 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modifiers/IFinalInitialiser.java @@ -0,0 +1,9 @@ +package cipm.consistency.initialisers.jamopp.modifiers; + +import org.emftext.language.java.modifiers.Final; + +public interface IFinalInitialiser extends IModifierInitialiser { + @Override + public Final instantiate(); + +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modifiers/IModifiableInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modifiers/IModifiableInitialiser.java new file mode 100644 index 0000000000..661c72291d --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modifiers/IModifiableInitialiser.java @@ -0,0 +1,23 @@ +package cipm.consistency.initialisers.jamopp.modifiers; + +import org.emftext.language.java.modifiers.Modifiable; +import org.emftext.language.java.modifiers.Modifier; + +import cipm.consistency.initialisers.jamopp.commons.ICommentableInitialiser; + +public interface IModifiableInitialiser extends ICommentableInitialiser { + @Override + public Modifiable instantiate(); + + public default boolean addModifier(Modifiable modifiable, Modifier modifier) { + if (modifier != null) { + modifiable.getModifiers().add(modifier); + return modifiable.getModifiers().contains(modifier); + } + return true; + } + + public default boolean addModifiers(Modifiable modifiable, Modifier[] modifiers) { + return this.doMultipleModifications(modifiable, modifiers, this::addModifier); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modifiers/IModifierInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modifiers/IModifierInitialiser.java new file mode 100644 index 0000000000..27c5c5fa2e --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modifiers/IModifierInitialiser.java @@ -0,0 +1,9 @@ +package cipm.consistency.initialisers.jamopp.modifiers; + +import org.emftext.language.java.modifiers.Modifier; + +public interface IModifierInitialiser extends IAnnotationInstanceOrModifierInitialiser { + @Override + public Modifier instantiate(); + +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modifiers/IModuleRequiresModifierInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modifiers/IModuleRequiresModifierInitialiser.java new file mode 100644 index 0000000000..2aaffbf9ab --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modifiers/IModuleRequiresModifierInitialiser.java @@ -0,0 +1,11 @@ +package cipm.consistency.initialisers.jamopp.modifiers; + +import org.emftext.language.java.modifiers.ModuleRequiresModifier; + +import cipm.consistency.initialisers.jamopp.commons.ICommentableInitialiser; + +public interface IModuleRequiresModifierInitialiser extends ICommentableInitialiser { + @Override + public ModuleRequiresModifier instantiate(); + +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modifiers/INativeInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modifiers/INativeInitialiser.java new file mode 100644 index 0000000000..46cc6644c7 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modifiers/INativeInitialiser.java @@ -0,0 +1,9 @@ +package cipm.consistency.initialisers.jamopp.modifiers; + +import org.emftext.language.java.modifiers.Native; + +public interface INativeInitialiser extends IModifierInitialiser { + @Override + public Native instantiate(); + +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modifiers/IOpenInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modifiers/IOpenInitialiser.java new file mode 100644 index 0000000000..7e7bf42537 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modifiers/IOpenInitialiser.java @@ -0,0 +1,11 @@ +package cipm.consistency.initialisers.jamopp.modifiers; + +import org.emftext.language.java.modifiers.Open; + +import cipm.consistency.initialisers.jamopp.commons.ICommentableInitialiser; + +public interface IOpenInitialiser extends ICommentableInitialiser { + @Override + public Open instantiate(); + +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modifiers/IPrivateInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modifiers/IPrivateInitialiser.java new file mode 100644 index 0000000000..fd5e02c8ac --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modifiers/IPrivateInitialiser.java @@ -0,0 +1,9 @@ +package cipm.consistency.initialisers.jamopp.modifiers; + +import org.emftext.language.java.modifiers.Private; + +public interface IPrivateInitialiser extends IModifierInitialiser { + @Override + public Private instantiate(); + +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modifiers/IProtectedInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modifiers/IProtectedInitialiser.java new file mode 100644 index 0000000000..b065700663 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modifiers/IProtectedInitialiser.java @@ -0,0 +1,9 @@ +package cipm.consistency.initialisers.jamopp.modifiers; + +import org.emftext.language.java.modifiers.Protected; + +public interface IProtectedInitialiser extends IModifierInitialiser { + @Override + public Protected instantiate(); + +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modifiers/IPublicInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modifiers/IPublicInitialiser.java new file mode 100644 index 0000000000..167a7c7d0e --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modifiers/IPublicInitialiser.java @@ -0,0 +1,9 @@ +package cipm.consistency.initialisers.jamopp.modifiers; + +import org.emftext.language.java.modifiers.Public; + +public interface IPublicInitialiser extends IModifierInitialiser { + @Override + public Public instantiate(); + +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modifiers/IStaticInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modifiers/IStaticInitialiser.java new file mode 100644 index 0000000000..717eb299cd --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modifiers/IStaticInitialiser.java @@ -0,0 +1,8 @@ +package cipm.consistency.initialisers.jamopp.modifiers; + +import org.emftext.language.java.modifiers.Static; + +public interface IStaticInitialiser extends IModifierInitialiser, IModuleRequiresModifierInitialiser { + @Override + public Static instantiate(); +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modifiers/IStrictfpInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modifiers/IStrictfpInitialiser.java new file mode 100644 index 0000000000..6358b945b7 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modifiers/IStrictfpInitialiser.java @@ -0,0 +1,9 @@ +package cipm.consistency.initialisers.jamopp.modifiers; + +import org.emftext.language.java.modifiers.Strictfp; + +public interface IStrictfpInitialiser extends IModifierInitialiser { + @Override + public Strictfp instantiate(); + +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modifiers/ISynchronizedInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modifiers/ISynchronizedInitialiser.java new file mode 100644 index 0000000000..756db7b74f --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modifiers/ISynchronizedInitialiser.java @@ -0,0 +1,9 @@ +package cipm.consistency.initialisers.jamopp.modifiers; + +import org.emftext.language.java.modifiers.Synchronized; + +public interface ISynchronizedInitialiser extends IModifierInitialiser { + @Override + public Synchronized instantiate(); + +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modifiers/ITransientInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modifiers/ITransientInitialiser.java new file mode 100644 index 0000000000..79bebacc23 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modifiers/ITransientInitialiser.java @@ -0,0 +1,9 @@ +package cipm.consistency.initialisers.jamopp.modifiers; + +import org.emftext.language.java.modifiers.Transient; + +public interface ITransientInitialiser extends IModifierInitialiser { + @Override + public Transient instantiate(); + +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modifiers/ITransitiveInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modifiers/ITransitiveInitialiser.java new file mode 100644 index 0000000000..26fd343e6f --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modifiers/ITransitiveInitialiser.java @@ -0,0 +1,9 @@ +package cipm.consistency.initialisers.jamopp.modifiers; + +import org.emftext.language.java.modifiers.Transitive; + +public interface ITransitiveInitialiser extends IModuleRequiresModifierInitialiser { + @Override + public Transitive instantiate(); + +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modifiers/IVolatileInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modifiers/IVolatileInitialiser.java new file mode 100644 index 0000000000..f3e15c56c1 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modifiers/IVolatileInitialiser.java @@ -0,0 +1,9 @@ +package cipm.consistency.initialisers.jamopp.modifiers; + +import org.emftext.language.java.modifiers.Volatile; + +public interface IVolatileInitialiser extends IModifierInitialiser { + @Override + public Volatile instantiate(); + +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modifiers/ModifiersInitialiserPackage.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modifiers/ModifiersInitialiserPackage.java new file mode 100644 index 0000000000..9c9ceec4c6 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modifiers/ModifiersInitialiserPackage.java @@ -0,0 +1,29 @@ +package cipm.consistency.initialisers.jamopp.modifiers; + +import java.util.Collection; + +import cipm.consistency.initialisers.IInitialiser; +import cipm.consistency.initialisers.IInitialiserPackage; + +public class ModifiersInitialiserPackage implements IInitialiserPackage { + @Override + public Collection getInitialiserInstances() { + return this.initCol(new IInitialiser[] { new AbstractInitialiser(), new DefaultInitialiser(), + new FinalInitialiser(), new NativeInitialiser(), new OpenInitialiser(), new PrivateInitialiser(), + new ProtectedInitialiser(), new PublicInitialiser(), new StaticInitialiser(), new StrictfpInitialiser(), + new SynchronizedInitialiser(), new TransientInitialiser(), new TransitiveInitialiser(), + new VolatileInitialiser(), }); + } + + @SuppressWarnings("unchecked") + @Override + public Collection> getInitialiserInterfaceTypes() { + return this.initCol(new Class[] { IAbstractInitialiser.class, IAnnotableAndModifiableInitialiser.class, + IAnnotationInstanceOrModifierInitialiser.class, IDefaultInitialiser.class, IFinalInitialiser.class, + IModifiableInitialiser.class, IModifierInitialiser.class, IModuleRequiresModifierInitialiser.class, + INativeInitialiser.class, IOpenInitialiser.class, IPrivateInitialiser.class, + IProtectedInitialiser.class, IPublicInitialiser.class, IStaticInitialiser.class, + IStrictfpInitialiser.class, ISynchronizedInitialiser.class, ITransientInitialiser.class, + ITransitiveInitialiser.class, IVolatileInitialiser.class, }); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modifiers/NativeInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modifiers/NativeInitialiser.java new file mode 100644 index 0000000000..fe50335de2 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modifiers/NativeInitialiser.java @@ -0,0 +1,18 @@ +package cipm.consistency.initialisers.jamopp.modifiers; + +import org.emftext.language.java.modifiers.ModifiersFactory; +import org.emftext.language.java.modifiers.Native; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class NativeInitialiser extends AbstractInitialiserBase implements INativeInitialiser { + @Override + public INativeInitialiser newInitialiser() { + return new NativeInitialiser(); + } + + @Override + public Native instantiate() { + return ModifiersFactory.eINSTANCE.createNative(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modifiers/OpenInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modifiers/OpenInitialiser.java new file mode 100644 index 0000000000..3f6a736753 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modifiers/OpenInitialiser.java @@ -0,0 +1,18 @@ +package cipm.consistency.initialisers.jamopp.modifiers; + +import org.emftext.language.java.modifiers.ModifiersFactory; +import org.emftext.language.java.modifiers.Open; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class OpenInitialiser extends AbstractInitialiserBase implements IOpenInitialiser { + @Override + public IOpenInitialiser newInitialiser() { + return new OpenInitialiser(); + } + + @Override + public Open instantiate() { + return ModifiersFactory.eINSTANCE.createOpen(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modifiers/PrivateInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modifiers/PrivateInitialiser.java new file mode 100644 index 0000000000..30d2eacd08 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modifiers/PrivateInitialiser.java @@ -0,0 +1,18 @@ +package cipm.consistency.initialisers.jamopp.modifiers; + +import org.emftext.language.java.modifiers.ModifiersFactory; +import org.emftext.language.java.modifiers.Private; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class PrivateInitialiser extends AbstractInitialiserBase implements IPrivateInitialiser { + @Override + public IPrivateInitialiser newInitialiser() { + return new PrivateInitialiser(); + } + + @Override + public Private instantiate() { + return ModifiersFactory.eINSTANCE.createPrivate(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modifiers/ProtectedInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modifiers/ProtectedInitialiser.java new file mode 100644 index 0000000000..04d43fb70b --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modifiers/ProtectedInitialiser.java @@ -0,0 +1,18 @@ +package cipm.consistency.initialisers.jamopp.modifiers; + +import org.emftext.language.java.modifiers.ModifiersFactory; +import org.emftext.language.java.modifiers.Protected; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class ProtectedInitialiser extends AbstractInitialiserBase implements IProtectedInitialiser { + @Override + public IProtectedInitialiser newInitialiser() { + return new ProtectedInitialiser(); + } + + @Override + public Protected instantiate() { + return ModifiersFactory.eINSTANCE.createProtected(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modifiers/PublicInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modifiers/PublicInitialiser.java new file mode 100644 index 0000000000..359133dc9f --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modifiers/PublicInitialiser.java @@ -0,0 +1,18 @@ +package cipm.consistency.initialisers.jamopp.modifiers; + +import org.emftext.language.java.modifiers.ModifiersFactory; +import org.emftext.language.java.modifiers.Public; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class PublicInitialiser extends AbstractInitialiserBase implements IPublicInitialiser { + @Override + public IPublicInitialiser newInitialiser() { + return new PublicInitialiser(); + } + + @Override + public Public instantiate() { + return ModifiersFactory.eINSTANCE.createPublic(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modifiers/StaticInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modifiers/StaticInitialiser.java new file mode 100644 index 0000000000..a0e7a1c774 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modifiers/StaticInitialiser.java @@ -0,0 +1,18 @@ +package cipm.consistency.initialisers.jamopp.modifiers; + +import org.emftext.language.java.modifiers.ModifiersFactory; +import org.emftext.language.java.modifiers.Static; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class StaticInitialiser extends AbstractInitialiserBase implements IStaticInitialiser { + @Override + public IStaticInitialiser newInitialiser() { + return new StaticInitialiser(); + } + + @Override + public Static instantiate() { + return ModifiersFactory.eINSTANCE.createStatic(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modifiers/StrictfpInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modifiers/StrictfpInitialiser.java new file mode 100644 index 0000000000..959fb50843 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modifiers/StrictfpInitialiser.java @@ -0,0 +1,18 @@ +package cipm.consistency.initialisers.jamopp.modifiers; + +import org.emftext.language.java.modifiers.ModifiersFactory; +import org.emftext.language.java.modifiers.Strictfp; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class StrictfpInitialiser extends AbstractInitialiserBase implements IStrictfpInitialiser { + @Override + public IStrictfpInitialiser newInitialiser() { + return new StrictfpInitialiser(); + } + + @Override + public Strictfp instantiate() { + return ModifiersFactory.eINSTANCE.createStrictfp(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modifiers/SynchronizedInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modifiers/SynchronizedInitialiser.java new file mode 100644 index 0000000000..c34e647443 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modifiers/SynchronizedInitialiser.java @@ -0,0 +1,18 @@ +package cipm.consistency.initialisers.jamopp.modifiers; + +import org.emftext.language.java.modifiers.ModifiersFactory; +import org.emftext.language.java.modifiers.Synchronized; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class SynchronizedInitialiser extends AbstractInitialiserBase implements ISynchronizedInitialiser { + @Override + public ISynchronizedInitialiser newInitialiser() { + return new SynchronizedInitialiser(); + } + + @Override + public Synchronized instantiate() { + return ModifiersFactory.eINSTANCE.createSynchronized(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modifiers/TransientInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modifiers/TransientInitialiser.java new file mode 100644 index 0000000000..6306cb488c --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modifiers/TransientInitialiser.java @@ -0,0 +1,18 @@ +package cipm.consistency.initialisers.jamopp.modifiers; + +import org.emftext.language.java.modifiers.ModifiersFactory; +import org.emftext.language.java.modifiers.Transient; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class TransientInitialiser extends AbstractInitialiserBase implements ITransientInitialiser { + @Override + public ITransientInitialiser newInitialiser() { + return new TransientInitialiser(); + } + + @Override + public Transient instantiate() { + return ModifiersFactory.eINSTANCE.createTransient(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modifiers/TransitiveInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modifiers/TransitiveInitialiser.java new file mode 100644 index 0000000000..e26b3311ff --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modifiers/TransitiveInitialiser.java @@ -0,0 +1,18 @@ +package cipm.consistency.initialisers.jamopp.modifiers; + +import org.emftext.language.java.modifiers.ModifiersFactory; +import org.emftext.language.java.modifiers.Transitive; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class TransitiveInitialiser extends AbstractInitialiserBase implements ITransitiveInitialiser { + @Override + public ITransitiveInitialiser newInitialiser() { + return new TransitiveInitialiser(); + } + + @Override + public Transitive instantiate() { + return ModifiersFactory.eINSTANCE.createTransitive(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modifiers/VolatileInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modifiers/VolatileInitialiser.java new file mode 100644 index 0000000000..3083085f00 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modifiers/VolatileInitialiser.java @@ -0,0 +1,18 @@ +package cipm.consistency.initialisers.jamopp.modifiers; + +import org.emftext.language.java.modifiers.ModifiersFactory; +import org.emftext.language.java.modifiers.Volatile; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class VolatileInitialiser extends AbstractInitialiserBase implements IVolatileInitialiser { + @Override + public IVolatileInitialiser newInitialiser() { + return new VolatileInitialiser(); + } + + @Override + public Volatile instantiate() { + return ModifiersFactory.eINSTANCE.createVolatile(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modifiers/package-info.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modifiers/package-info.java new file mode 100644 index 0000000000..cb720cbcf9 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modifiers/package-info.java @@ -0,0 +1,5 @@ +/** + * Contains {@link IInitialiser} implementations for + * {@link org.emftext.language.java.modifiers}. + */ +package cipm.consistency.initialisers.jamopp.modifiers; \ No newline at end of file From ac840ae753cfe2fb9fea60569e382a10a4b81dac Mon Sep 17 00:00:00 2001 From: AlpTorac Date: Fri, 25 Oct 2024 16:52:24 +0200 Subject: [PATCH 13/55] Implement initialiser package for org.emftext.language.java.operators --- .../jamopp/operators/AdditionInitialiser.java | 18 ++++++++ .../operators/AssignmentAndInitialiser.java | 18 ++++++++ .../AssignmentDivisionInitialiser.java | 18 ++++++++ .../AssignmentExclusiveOrInitialiser.java | 19 ++++++++ .../operators/AssignmentInitialiser.java | 18 ++++++++ .../AssignmentLeftShiftInitialiser.java | 18 ++++++++ .../operators/AssignmentMinusInitialiser.java | 18 ++++++++ .../AssignmentModuloInitialiser.java | 18 ++++++++ .../AssignmentMultiplicationInitialiser.java | 19 ++++++++ .../operators/AssignmentOrInitialiser.java | 18 ++++++++ .../operators/AssignmentPlusInitialiser.java | 18 ++++++++ .../AssignmentRightShiftInitialiser.java | 19 ++++++++ ...signmentUnsignedRightShiftInitialiser.java | 19 ++++++++ .../operators/ComplementInitialiser.java | 18 ++++++++ .../jamopp/operators/DivisionInitialiser.java | 18 ++++++++ .../jamopp/operators/EqualInitialiser.java | 18 ++++++++ .../operators/GreaterThanInitialiser.java | 18 ++++++++ .../GreaterThanOrEqualInitialiser.java | 18 ++++++++ .../operators/IAdditionInitialiser.java | 9 ++++ .../IAdditiveOperatorInitialiser.java | 9 ++++ .../operators/IAssignmentAndInitialiser.java | 9 ++++ .../IAssignmentDivisionInitialiser.java | 9 ++++ .../IAssignmentExclusiveOrInitialiser.java | 9 ++++ .../operators/IAssignmentInitialiser.java | 9 ++++ .../IAssignmentLeftShiftInitialiser.java | 9 ++++ .../IAssignmentMinusInitialiser.java | 9 ++++ .../IAssignmentModuloInitialiser.java | 9 ++++ .../IAssignmentMultiplicationInitialiser.java | 9 ++++ .../IAssignmentOperatorInitialiser.java | 9 ++++ .../operators/IAssignmentOrInitialiser.java | 9 ++++ .../operators/IAssignmentPlusInitialiser.java | 9 ++++ .../IAssignmentRightShiftInitialiser.java | 9 ++++ ...signmentUnsignedRightShiftInitialiser.java | 9 ++++ .../operators/IComplementInitialiser.java | 9 ++++ .../operators/IDivisionInitialiser.java | 9 ++++ .../jamopp/operators/IEqualInitialiser.java | 9 ++++ .../IEqualityOperatorInitialiser.java | 9 ++++ .../operators/IGreaterThanInitialiser.java | 9 ++++ .../IGreaterThanOrEqualInitialiser.java | 9 ++++ .../operators/ILeftShiftInitialiser.java | 9 ++++ .../operators/ILessThanInitialiser.java | 9 ++++ .../ILessThanOrEqualInitialiser.java | 9 ++++ .../operators/IMinusMinusInitialiser.java | 9 ++++ .../operators/IMultiplicationInitialiser.java | 9 ++++ .../IMultiplicativeOperatorInitialiser.java | 9 ++++ .../jamopp/operators/INegateInitialiser.java | 9 ++++ .../operators/INotEqualInitialiser.java | 9 ++++ .../operators/IOperatorInitialiser.java | 11 +++++ .../operators/IPlusPlusInitialiser.java | 9 ++++ .../IRelationOperatorInitialiser.java | 9 ++++ .../operators/IRemainderInitialiser.java | 9 ++++ .../operators/IRightShiftInitialiser.java | 9 ++++ .../operators/IShiftOperatorInitialiser.java | 9 ++++ .../operators/ISubtractionInitialiser.java | 9 ++++ ...IUnaryModificationOperatorInitialiser.java | 9 ++++ .../operators/IUnaryOperatorInitialiser.java | 9 ++++ .../IUnsignedRightShiftInitialiser.java | 9 ++++ .../operators/LeftShiftInitialiser.java | 18 ++++++++ .../jamopp/operators/LessThanInitialiser.java | 18 ++++++++ .../operators/LessThanOrEqualInitialiser.java | 18 ++++++++ .../operators/MinusMinusInitialiser.java | 18 ++++++++ .../operators/MultiplicationInitialiser.java | 18 ++++++++ .../jamopp/operators/NegateInitialiser.java | 18 ++++++++ .../jamopp/operators/NotEqualInitialiser.java | 18 ++++++++ .../OperatorsInitialiserPackage.java | 44 +++++++++++++++++++ .../jamopp/operators/PlusPlusInitialiser.java | 18 ++++++++ .../operators/RemainderInitialiser.java | 18 ++++++++ .../operators/RightShiftInitialiser.java | 18 ++++++++ .../operators/SubtractionInitialiser.java | 18 ++++++++ .../UnsignedRightShiftInitialiser.java | 18 ++++++++ .../jamopp/operators/package-info.java | 5 +++ 71 files changed, 946 insertions(+) create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/AdditionInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/AssignmentAndInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/AssignmentDivisionInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/AssignmentExclusiveOrInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/AssignmentInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/AssignmentLeftShiftInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/AssignmentMinusInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/AssignmentModuloInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/AssignmentMultiplicationInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/AssignmentOrInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/AssignmentPlusInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/AssignmentRightShiftInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/AssignmentUnsignedRightShiftInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/ComplementInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/DivisionInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/EqualInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/GreaterThanInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/GreaterThanOrEqualInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/IAdditionInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/IAdditiveOperatorInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/IAssignmentAndInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/IAssignmentDivisionInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/IAssignmentExclusiveOrInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/IAssignmentInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/IAssignmentLeftShiftInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/IAssignmentMinusInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/IAssignmentModuloInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/IAssignmentMultiplicationInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/IAssignmentOperatorInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/IAssignmentOrInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/IAssignmentPlusInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/IAssignmentRightShiftInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/IAssignmentUnsignedRightShiftInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/IComplementInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/IDivisionInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/IEqualInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/IEqualityOperatorInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/IGreaterThanInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/IGreaterThanOrEqualInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/ILeftShiftInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/ILessThanInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/ILessThanOrEqualInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/IMinusMinusInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/IMultiplicationInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/IMultiplicativeOperatorInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/INegateInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/INotEqualInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/IOperatorInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/IPlusPlusInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/IRelationOperatorInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/IRemainderInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/IRightShiftInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/IShiftOperatorInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/ISubtractionInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/IUnaryModificationOperatorInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/IUnaryOperatorInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/IUnsignedRightShiftInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/LeftShiftInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/LessThanInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/LessThanOrEqualInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/MinusMinusInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/MultiplicationInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/NegateInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/NotEqualInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/OperatorsInitialiserPackage.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/PlusPlusInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/RemainderInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/RightShiftInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/SubtractionInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/UnsignedRightShiftInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/package-info.java diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/AdditionInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/AdditionInitialiser.java new file mode 100644 index 0000000000..4d471b6c58 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/AdditionInitialiser.java @@ -0,0 +1,18 @@ +package cipm.consistency.initialisers.jamopp.operators; + +import org.emftext.language.java.operators.Addition; +import org.emftext.language.java.operators.OperatorsFactory; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class AdditionInitialiser extends AbstractInitialiserBase implements IAdditionInitialiser { + @Override + public IAdditionInitialiser newInitialiser() { + return new AdditionInitialiser(); + } + + @Override + public Addition instantiate() { + return OperatorsFactory.eINSTANCE.createAddition(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/AssignmentAndInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/AssignmentAndInitialiser.java new file mode 100644 index 0000000000..6bf41b5fb2 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/AssignmentAndInitialiser.java @@ -0,0 +1,18 @@ +package cipm.consistency.initialisers.jamopp.operators; + +import org.emftext.language.java.operators.AssignmentAnd; +import org.emftext.language.java.operators.OperatorsFactory; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class AssignmentAndInitialiser extends AbstractInitialiserBase implements IAssignmentAndInitialiser { + @Override + public IAssignmentAndInitialiser newInitialiser() { + return new AssignmentAndInitialiser(); + } + + @Override + public AssignmentAnd instantiate() { + return OperatorsFactory.eINSTANCE.createAssignmentAnd(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/AssignmentDivisionInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/AssignmentDivisionInitialiser.java new file mode 100644 index 0000000000..87603fab53 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/AssignmentDivisionInitialiser.java @@ -0,0 +1,18 @@ +package cipm.consistency.initialisers.jamopp.operators; + +import org.emftext.language.java.operators.AssignmentDivision; +import org.emftext.language.java.operators.OperatorsFactory; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class AssignmentDivisionInitialiser extends AbstractInitialiserBase implements IAssignmentDivisionInitialiser { + @Override + public IAssignmentDivisionInitialiser newInitialiser() { + return new AssignmentDivisionInitialiser(); + } + + @Override + public AssignmentDivision instantiate() { + return OperatorsFactory.eINSTANCE.createAssignmentDivision(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/AssignmentExclusiveOrInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/AssignmentExclusiveOrInitialiser.java new file mode 100644 index 0000000000..87aa83cb5b --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/AssignmentExclusiveOrInitialiser.java @@ -0,0 +1,19 @@ +package cipm.consistency.initialisers.jamopp.operators; + +import org.emftext.language.java.operators.AssignmentExclusiveOr; +import org.emftext.language.java.operators.OperatorsFactory; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class AssignmentExclusiveOrInitialiser extends AbstractInitialiserBase + implements IAssignmentExclusiveOrInitialiser { + @Override + public IAssignmentExclusiveOrInitialiser newInitialiser() { + return new AssignmentExclusiveOrInitialiser(); + } + + @Override + public AssignmentExclusiveOr instantiate() { + return OperatorsFactory.eINSTANCE.createAssignmentExclusiveOr(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/AssignmentInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/AssignmentInitialiser.java new file mode 100644 index 0000000000..de14f68b75 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/AssignmentInitialiser.java @@ -0,0 +1,18 @@ +package cipm.consistency.initialisers.jamopp.operators; + +import org.emftext.language.java.operators.Assignment; +import org.emftext.language.java.operators.OperatorsFactory; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class AssignmentInitialiser extends AbstractInitialiserBase implements IAssignmentInitialiser { + @Override + public IAssignmentInitialiser newInitialiser() { + return new AssignmentInitialiser(); + } + + @Override + public Assignment instantiate() { + return OperatorsFactory.eINSTANCE.createAssignment(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/AssignmentLeftShiftInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/AssignmentLeftShiftInitialiser.java new file mode 100644 index 0000000000..cbeed302e5 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/AssignmentLeftShiftInitialiser.java @@ -0,0 +1,18 @@ +package cipm.consistency.initialisers.jamopp.operators; + +import org.emftext.language.java.operators.AssignmentLeftShift; +import org.emftext.language.java.operators.OperatorsFactory; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class AssignmentLeftShiftInitialiser extends AbstractInitialiserBase implements IAssignmentLeftShiftInitialiser { + @Override + public IAssignmentLeftShiftInitialiser newInitialiser() { + return new AssignmentLeftShiftInitialiser(); + } + + @Override + public AssignmentLeftShift instantiate() { + return OperatorsFactory.eINSTANCE.createAssignmentLeftShift(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/AssignmentMinusInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/AssignmentMinusInitialiser.java new file mode 100644 index 0000000000..0ccbe2d899 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/AssignmentMinusInitialiser.java @@ -0,0 +1,18 @@ +package cipm.consistency.initialisers.jamopp.operators; + +import org.emftext.language.java.operators.AssignmentMinus; +import org.emftext.language.java.operators.OperatorsFactory; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class AssignmentMinusInitialiser extends AbstractInitialiserBase implements IAssignmentMinusInitialiser { + @Override + public IAssignmentMinusInitialiser newInitialiser() { + return new AssignmentMinusInitialiser(); + } + + @Override + public AssignmentMinus instantiate() { + return OperatorsFactory.eINSTANCE.createAssignmentMinus(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/AssignmentModuloInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/AssignmentModuloInitialiser.java new file mode 100644 index 0000000000..9e14caa456 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/AssignmentModuloInitialiser.java @@ -0,0 +1,18 @@ +package cipm.consistency.initialisers.jamopp.operators; + +import org.emftext.language.java.operators.AssignmentModulo; +import org.emftext.language.java.operators.OperatorsFactory; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class AssignmentModuloInitialiser extends AbstractInitialiserBase implements IAssignmentModuloInitialiser { + @Override + public IAssignmentModuloInitialiser newInitialiser() { + return new AssignmentModuloInitialiser(); + } + + @Override + public AssignmentModulo instantiate() { + return OperatorsFactory.eINSTANCE.createAssignmentModulo(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/AssignmentMultiplicationInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/AssignmentMultiplicationInitialiser.java new file mode 100644 index 0000000000..758a4e6235 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/AssignmentMultiplicationInitialiser.java @@ -0,0 +1,19 @@ +package cipm.consistency.initialisers.jamopp.operators; + +import org.emftext.language.java.operators.AssignmentMultiplication; +import org.emftext.language.java.operators.OperatorsFactory; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class AssignmentMultiplicationInitialiser extends AbstractInitialiserBase + implements IAssignmentMultiplicationInitialiser { + @Override + public IAssignmentMultiplicationInitialiser newInitialiser() { + return new AssignmentMultiplicationInitialiser(); + } + + @Override + public AssignmentMultiplication instantiate() { + return OperatorsFactory.eINSTANCE.createAssignmentMultiplication(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/AssignmentOrInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/AssignmentOrInitialiser.java new file mode 100644 index 0000000000..48b44e3c6a --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/AssignmentOrInitialiser.java @@ -0,0 +1,18 @@ +package cipm.consistency.initialisers.jamopp.operators; + +import org.emftext.language.java.operators.AssignmentOr; +import org.emftext.language.java.operators.OperatorsFactory; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class AssignmentOrInitialiser extends AbstractInitialiserBase implements IAssignmentOrInitialiser { + @Override + public IAssignmentOrInitialiser newInitialiser() { + return new AssignmentOrInitialiser(); + } + + @Override + public AssignmentOr instantiate() { + return OperatorsFactory.eINSTANCE.createAssignmentOr(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/AssignmentPlusInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/AssignmentPlusInitialiser.java new file mode 100644 index 0000000000..9c2cf0ad20 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/AssignmentPlusInitialiser.java @@ -0,0 +1,18 @@ +package cipm.consistency.initialisers.jamopp.operators; + +import org.emftext.language.java.operators.AssignmentPlus; +import org.emftext.language.java.operators.OperatorsFactory; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class AssignmentPlusInitialiser extends AbstractInitialiserBase implements IAssignmentPlusInitialiser { + @Override + public IAssignmentPlusInitialiser newInitialiser() { + return new AssignmentPlusInitialiser(); + } + + @Override + public AssignmentPlus instantiate() { + return OperatorsFactory.eINSTANCE.createAssignmentPlus(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/AssignmentRightShiftInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/AssignmentRightShiftInitialiser.java new file mode 100644 index 0000000000..8ed66a0d9c --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/AssignmentRightShiftInitialiser.java @@ -0,0 +1,19 @@ +package cipm.consistency.initialisers.jamopp.operators; + +import org.emftext.language.java.operators.AssignmentRightShift; +import org.emftext.language.java.operators.OperatorsFactory; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class AssignmentRightShiftInitialiser extends AbstractInitialiserBase + implements IAssignmentRightShiftInitialiser { + @Override + public IAssignmentRightShiftInitialiser newInitialiser() { + return new AssignmentRightShiftInitialiser(); + } + + @Override + public AssignmentRightShift instantiate() { + return OperatorsFactory.eINSTANCE.createAssignmentRightShift(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/AssignmentUnsignedRightShiftInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/AssignmentUnsignedRightShiftInitialiser.java new file mode 100644 index 0000000000..ce7ac8df1b --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/AssignmentUnsignedRightShiftInitialiser.java @@ -0,0 +1,19 @@ +package cipm.consistency.initialisers.jamopp.operators; + +import org.emftext.language.java.operators.AssignmentUnsignedRightShift; +import org.emftext.language.java.operators.OperatorsFactory; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class AssignmentUnsignedRightShiftInitialiser extends AbstractInitialiserBase + implements IAssignmentUnsignedRightShiftInitialiser { + @Override + public IAssignmentUnsignedRightShiftInitialiser newInitialiser() { + return new AssignmentUnsignedRightShiftInitialiser(); + } + + @Override + public AssignmentUnsignedRightShift instantiate() { + return OperatorsFactory.eINSTANCE.createAssignmentUnsignedRightShift(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/ComplementInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/ComplementInitialiser.java new file mode 100644 index 0000000000..15e3705d12 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/ComplementInitialiser.java @@ -0,0 +1,18 @@ +package cipm.consistency.initialisers.jamopp.operators; + +import org.emftext.language.java.operators.Complement; +import org.emftext.language.java.operators.OperatorsFactory; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class ComplementInitialiser extends AbstractInitialiserBase implements IComplementInitialiser { + @Override + public IComplementInitialiser newInitialiser() { + return new ComplementInitialiser(); + } + + @Override + public Complement instantiate() { + return OperatorsFactory.eINSTANCE.createComplement(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/DivisionInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/DivisionInitialiser.java new file mode 100644 index 0000000000..57d18cd051 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/DivisionInitialiser.java @@ -0,0 +1,18 @@ +package cipm.consistency.initialisers.jamopp.operators; + +import org.emftext.language.java.operators.Division; +import org.emftext.language.java.operators.OperatorsFactory; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class DivisionInitialiser extends AbstractInitialiserBase implements IDivisionInitialiser { + @Override + public IDivisionInitialiser newInitialiser() { + return new DivisionInitialiser(); + } + + @Override + public Division instantiate() { + return OperatorsFactory.eINSTANCE.createDivision(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/EqualInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/EqualInitialiser.java new file mode 100644 index 0000000000..b21d2851c3 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/EqualInitialiser.java @@ -0,0 +1,18 @@ +package cipm.consistency.initialisers.jamopp.operators; + +import org.emftext.language.java.operators.Equal; +import org.emftext.language.java.operators.OperatorsFactory; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class EqualInitialiser extends AbstractInitialiserBase implements IEqualInitialiser { + @Override + public IEqualInitialiser newInitialiser() { + return new EqualInitialiser(); + } + + @Override + public Equal instantiate() { + return OperatorsFactory.eINSTANCE.createEqual(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/GreaterThanInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/GreaterThanInitialiser.java new file mode 100644 index 0000000000..27524974c5 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/GreaterThanInitialiser.java @@ -0,0 +1,18 @@ +package cipm.consistency.initialisers.jamopp.operators; + +import org.emftext.language.java.operators.GreaterThan; +import org.emftext.language.java.operators.OperatorsFactory; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class GreaterThanInitialiser extends AbstractInitialiserBase implements IGreaterThanInitialiser { + @Override + public IGreaterThanInitialiser newInitialiser() { + return new GreaterThanInitialiser(); + } + + @Override + public GreaterThan instantiate() { + return OperatorsFactory.eINSTANCE.createGreaterThan(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/GreaterThanOrEqualInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/GreaterThanOrEqualInitialiser.java new file mode 100644 index 0000000000..bc864b1fa5 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/GreaterThanOrEqualInitialiser.java @@ -0,0 +1,18 @@ +package cipm.consistency.initialisers.jamopp.operators; + +import org.emftext.language.java.operators.GreaterThanOrEqual; +import org.emftext.language.java.operators.OperatorsFactory; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class GreaterThanOrEqualInitialiser extends AbstractInitialiserBase implements IGreaterThanOrEqualInitialiser { + @Override + public IGreaterThanOrEqualInitialiser newInitialiser() { + return new GreaterThanOrEqualInitialiser(); + } + + @Override + public GreaterThanOrEqual instantiate() { + return OperatorsFactory.eINSTANCE.createGreaterThanOrEqual(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/IAdditionInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/IAdditionInitialiser.java new file mode 100644 index 0000000000..5e63e082d3 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/IAdditionInitialiser.java @@ -0,0 +1,9 @@ +package cipm.consistency.initialisers.jamopp.operators; + +import org.emftext.language.java.operators.Addition; + +public interface IAdditionInitialiser extends IAdditiveOperatorInitialiser { + @Override + public Addition instantiate(); + +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/IAdditiveOperatorInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/IAdditiveOperatorInitialiser.java new file mode 100644 index 0000000000..d48d8334d5 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/IAdditiveOperatorInitialiser.java @@ -0,0 +1,9 @@ +package cipm.consistency.initialisers.jamopp.operators; + +import org.emftext.language.java.operators.AdditiveOperator; + +public interface IAdditiveOperatorInitialiser extends IOperatorInitialiser { + @Override + public AdditiveOperator instantiate(); + +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/IAssignmentAndInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/IAssignmentAndInitialiser.java new file mode 100644 index 0000000000..405817a773 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/IAssignmentAndInitialiser.java @@ -0,0 +1,9 @@ +package cipm.consistency.initialisers.jamopp.operators; + +import org.emftext.language.java.operators.AssignmentAnd; + +public interface IAssignmentAndInitialiser extends IAssignmentOperatorInitialiser { + @Override + public AssignmentAnd instantiate(); + +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/IAssignmentDivisionInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/IAssignmentDivisionInitialiser.java new file mode 100644 index 0000000000..52686c2d48 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/IAssignmentDivisionInitialiser.java @@ -0,0 +1,9 @@ +package cipm.consistency.initialisers.jamopp.operators; + +import org.emftext.language.java.operators.AssignmentDivision; + +public interface IAssignmentDivisionInitialiser extends IAssignmentOperatorInitialiser { + @Override + public AssignmentDivision instantiate(); + +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/IAssignmentExclusiveOrInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/IAssignmentExclusiveOrInitialiser.java new file mode 100644 index 0000000000..54501a8ce5 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/IAssignmentExclusiveOrInitialiser.java @@ -0,0 +1,9 @@ +package cipm.consistency.initialisers.jamopp.operators; + +import org.emftext.language.java.operators.AssignmentExclusiveOr; + +public interface IAssignmentExclusiveOrInitialiser extends IAssignmentOperatorInitialiser { + @Override + public AssignmentExclusiveOr instantiate(); + +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/IAssignmentInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/IAssignmentInitialiser.java new file mode 100644 index 0000000000..f893c2c8e8 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/IAssignmentInitialiser.java @@ -0,0 +1,9 @@ +package cipm.consistency.initialisers.jamopp.operators; + +import org.emftext.language.java.operators.Assignment; + +public interface IAssignmentInitialiser extends IAssignmentOperatorInitialiser { + @Override + public Assignment instantiate(); + +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/IAssignmentLeftShiftInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/IAssignmentLeftShiftInitialiser.java new file mode 100644 index 0000000000..45101827f7 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/IAssignmentLeftShiftInitialiser.java @@ -0,0 +1,9 @@ +package cipm.consistency.initialisers.jamopp.operators; + +import org.emftext.language.java.operators.AssignmentLeftShift; + +public interface IAssignmentLeftShiftInitialiser extends IAssignmentOperatorInitialiser { + @Override + public AssignmentLeftShift instantiate(); + +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/IAssignmentMinusInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/IAssignmentMinusInitialiser.java new file mode 100644 index 0000000000..dbefdf1ee5 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/IAssignmentMinusInitialiser.java @@ -0,0 +1,9 @@ +package cipm.consistency.initialisers.jamopp.operators; + +import org.emftext.language.java.operators.AssignmentMinus; + +public interface IAssignmentMinusInitialiser extends IAssignmentOperatorInitialiser { + @Override + public AssignmentMinus instantiate(); + +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/IAssignmentModuloInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/IAssignmentModuloInitialiser.java new file mode 100644 index 0000000000..4a62118c8d --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/IAssignmentModuloInitialiser.java @@ -0,0 +1,9 @@ +package cipm.consistency.initialisers.jamopp.operators; + +import org.emftext.language.java.operators.AssignmentModulo; + +public interface IAssignmentModuloInitialiser extends IAssignmentOperatorInitialiser { + @Override + public AssignmentModulo instantiate(); + +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/IAssignmentMultiplicationInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/IAssignmentMultiplicationInitialiser.java new file mode 100644 index 0000000000..d594065636 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/IAssignmentMultiplicationInitialiser.java @@ -0,0 +1,9 @@ +package cipm.consistency.initialisers.jamopp.operators; + +import org.emftext.language.java.operators.AssignmentMultiplication; + +public interface IAssignmentMultiplicationInitialiser extends IAssignmentOperatorInitialiser { + @Override + public AssignmentMultiplication instantiate(); + +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/IAssignmentOperatorInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/IAssignmentOperatorInitialiser.java new file mode 100644 index 0000000000..1a8e008305 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/IAssignmentOperatorInitialiser.java @@ -0,0 +1,9 @@ +package cipm.consistency.initialisers.jamopp.operators; + +import org.emftext.language.java.operators.AssignmentOperator; + +public interface IAssignmentOperatorInitialiser extends IOperatorInitialiser { + @Override + public AssignmentOperator instantiate(); + +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/IAssignmentOrInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/IAssignmentOrInitialiser.java new file mode 100644 index 0000000000..3512ef3531 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/IAssignmentOrInitialiser.java @@ -0,0 +1,9 @@ +package cipm.consistency.initialisers.jamopp.operators; + +import org.emftext.language.java.operators.AssignmentOr; + +public interface IAssignmentOrInitialiser extends IAssignmentOperatorInitialiser { + @Override + public AssignmentOr instantiate(); + +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/IAssignmentPlusInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/IAssignmentPlusInitialiser.java new file mode 100644 index 0000000000..b8b0125c7c --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/IAssignmentPlusInitialiser.java @@ -0,0 +1,9 @@ +package cipm.consistency.initialisers.jamopp.operators; + +import org.emftext.language.java.operators.AssignmentPlus; + +public interface IAssignmentPlusInitialiser extends IAssignmentOperatorInitialiser { + @Override + public AssignmentPlus instantiate(); + +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/IAssignmentRightShiftInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/IAssignmentRightShiftInitialiser.java new file mode 100644 index 0000000000..1328e71eab --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/IAssignmentRightShiftInitialiser.java @@ -0,0 +1,9 @@ +package cipm.consistency.initialisers.jamopp.operators; + +import org.emftext.language.java.operators.AssignmentRightShift; + +public interface IAssignmentRightShiftInitialiser extends IAssignmentOperatorInitialiser { + @Override + public AssignmentRightShift instantiate(); + +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/IAssignmentUnsignedRightShiftInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/IAssignmentUnsignedRightShiftInitialiser.java new file mode 100644 index 0000000000..a119eaeb6f --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/IAssignmentUnsignedRightShiftInitialiser.java @@ -0,0 +1,9 @@ +package cipm.consistency.initialisers.jamopp.operators; + +import org.emftext.language.java.operators.AssignmentUnsignedRightShift; + +public interface IAssignmentUnsignedRightShiftInitialiser extends IAssignmentOperatorInitialiser { + @Override + public AssignmentUnsignedRightShift instantiate(); + +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/IComplementInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/IComplementInitialiser.java new file mode 100644 index 0000000000..54956de8d0 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/IComplementInitialiser.java @@ -0,0 +1,9 @@ +package cipm.consistency.initialisers.jamopp.operators; + +import org.emftext.language.java.operators.Complement; + +public interface IComplementInitialiser extends IUnaryOperatorInitialiser { + @Override + public Complement instantiate(); + +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/IDivisionInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/IDivisionInitialiser.java new file mode 100644 index 0000000000..2af6f49a07 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/IDivisionInitialiser.java @@ -0,0 +1,9 @@ +package cipm.consistency.initialisers.jamopp.operators; + +import org.emftext.language.java.operators.Division; + +public interface IDivisionInitialiser extends IMultiplicativeOperatorInitialiser { + @Override + public Division instantiate(); + +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/IEqualInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/IEqualInitialiser.java new file mode 100644 index 0000000000..2206d5158e --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/IEqualInitialiser.java @@ -0,0 +1,9 @@ +package cipm.consistency.initialisers.jamopp.operators; + +import org.emftext.language.java.operators.Equal; + +public interface IEqualInitialiser extends IEqualityOperatorInitialiser { + @Override + public Equal instantiate(); + +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/IEqualityOperatorInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/IEqualityOperatorInitialiser.java new file mode 100644 index 0000000000..24f7cb4671 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/IEqualityOperatorInitialiser.java @@ -0,0 +1,9 @@ +package cipm.consistency.initialisers.jamopp.operators; + +import org.emftext.language.java.operators.EqualityOperator; + +public interface IEqualityOperatorInitialiser extends IOperatorInitialiser { + @Override + public EqualityOperator instantiate(); + +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/IGreaterThanInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/IGreaterThanInitialiser.java new file mode 100644 index 0000000000..06eb70aaa2 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/IGreaterThanInitialiser.java @@ -0,0 +1,9 @@ +package cipm.consistency.initialisers.jamopp.operators; + +import org.emftext.language.java.operators.GreaterThan; + +public interface IGreaterThanInitialiser extends IRelationOperatorInitialiser { + @Override + public GreaterThan instantiate(); + +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/IGreaterThanOrEqualInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/IGreaterThanOrEqualInitialiser.java new file mode 100644 index 0000000000..fe3d7ea663 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/IGreaterThanOrEqualInitialiser.java @@ -0,0 +1,9 @@ +package cipm.consistency.initialisers.jamopp.operators; + +import org.emftext.language.java.operators.GreaterThanOrEqual; + +public interface IGreaterThanOrEqualInitialiser extends IRelationOperatorInitialiser { + @Override + public GreaterThanOrEqual instantiate(); + +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/ILeftShiftInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/ILeftShiftInitialiser.java new file mode 100644 index 0000000000..a6a98db588 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/ILeftShiftInitialiser.java @@ -0,0 +1,9 @@ +package cipm.consistency.initialisers.jamopp.operators; + +import org.emftext.language.java.operators.LeftShift; + +public interface ILeftShiftInitialiser extends IShiftOperatorInitialiser { + @Override + public LeftShift instantiate(); + +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/ILessThanInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/ILessThanInitialiser.java new file mode 100644 index 0000000000..8fcc9ec1c7 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/ILessThanInitialiser.java @@ -0,0 +1,9 @@ +package cipm.consistency.initialisers.jamopp.operators; + +import org.emftext.language.java.operators.LessThan; + +public interface ILessThanInitialiser extends IRelationOperatorInitialiser { + @Override + public LessThan instantiate(); + +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/ILessThanOrEqualInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/ILessThanOrEqualInitialiser.java new file mode 100644 index 0000000000..81315c9718 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/ILessThanOrEqualInitialiser.java @@ -0,0 +1,9 @@ +package cipm.consistency.initialisers.jamopp.operators; + +import org.emftext.language.java.operators.LessThanOrEqual; + +public interface ILessThanOrEqualInitialiser extends IRelationOperatorInitialiser { + @Override + public LessThanOrEqual instantiate(); + +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/IMinusMinusInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/IMinusMinusInitialiser.java new file mode 100644 index 0000000000..cd93169c27 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/IMinusMinusInitialiser.java @@ -0,0 +1,9 @@ +package cipm.consistency.initialisers.jamopp.operators; + +import org.emftext.language.java.operators.MinusMinus; + +public interface IMinusMinusInitialiser extends IUnaryModificationOperatorInitialiser { + @Override + public MinusMinus instantiate(); + +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/IMultiplicationInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/IMultiplicationInitialiser.java new file mode 100644 index 0000000000..35c57996f7 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/IMultiplicationInitialiser.java @@ -0,0 +1,9 @@ +package cipm.consistency.initialisers.jamopp.operators; + +import org.emftext.language.java.operators.Multiplication; + +public interface IMultiplicationInitialiser extends IMultiplicativeOperatorInitialiser { + @Override + public Multiplication instantiate(); + +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/IMultiplicativeOperatorInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/IMultiplicativeOperatorInitialiser.java new file mode 100644 index 0000000000..e0ae532330 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/IMultiplicativeOperatorInitialiser.java @@ -0,0 +1,9 @@ +package cipm.consistency.initialisers.jamopp.operators; + +import org.emftext.language.java.operators.MultiplicativeOperator; + +public interface IMultiplicativeOperatorInitialiser extends IOperatorInitialiser { + @Override + public MultiplicativeOperator instantiate(); + +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/INegateInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/INegateInitialiser.java new file mode 100644 index 0000000000..6de5066283 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/INegateInitialiser.java @@ -0,0 +1,9 @@ +package cipm.consistency.initialisers.jamopp.operators; + +import org.emftext.language.java.operators.Negate; + +public interface INegateInitialiser extends IUnaryOperatorInitialiser { + @Override + public Negate instantiate(); + +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/INotEqualInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/INotEqualInitialiser.java new file mode 100644 index 0000000000..83c5a9696a --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/INotEqualInitialiser.java @@ -0,0 +1,9 @@ +package cipm.consistency.initialisers.jamopp.operators; + +import org.emftext.language.java.operators.NotEqual; + +public interface INotEqualInitialiser extends IEqualityOperatorInitialiser { + @Override + public NotEqual instantiate(); + +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/IOperatorInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/IOperatorInitialiser.java new file mode 100644 index 0000000000..c74f5a476a --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/IOperatorInitialiser.java @@ -0,0 +1,11 @@ +package cipm.consistency.initialisers.jamopp.operators; + +import org.emftext.language.java.operators.Operator; + +import cipm.consistency.initialisers.jamopp.commons.ICommentableInitialiser; + +public interface IOperatorInitialiser extends ICommentableInitialiser { + @Override + public Operator instantiate(); + +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/IPlusPlusInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/IPlusPlusInitialiser.java new file mode 100644 index 0000000000..7d28bc4bc4 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/IPlusPlusInitialiser.java @@ -0,0 +1,9 @@ +package cipm.consistency.initialisers.jamopp.operators; + +import org.emftext.language.java.operators.PlusPlus; + +public interface IPlusPlusInitialiser extends IUnaryModificationOperatorInitialiser { + @Override + public PlusPlus instantiate(); + +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/IRelationOperatorInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/IRelationOperatorInitialiser.java new file mode 100644 index 0000000000..5f7998fe22 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/IRelationOperatorInitialiser.java @@ -0,0 +1,9 @@ +package cipm.consistency.initialisers.jamopp.operators; + +import org.emftext.language.java.operators.RelationOperator; + +public interface IRelationOperatorInitialiser extends IOperatorInitialiser { + @Override + public RelationOperator instantiate(); + +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/IRemainderInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/IRemainderInitialiser.java new file mode 100644 index 0000000000..2c635a05d5 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/IRemainderInitialiser.java @@ -0,0 +1,9 @@ +package cipm.consistency.initialisers.jamopp.operators; + +import org.emftext.language.java.operators.Remainder; + +public interface IRemainderInitialiser extends IMultiplicativeOperatorInitialiser { + @Override + public Remainder instantiate(); + +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/IRightShiftInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/IRightShiftInitialiser.java new file mode 100644 index 0000000000..cd18544d14 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/IRightShiftInitialiser.java @@ -0,0 +1,9 @@ +package cipm.consistency.initialisers.jamopp.operators; + +import org.emftext.language.java.operators.RightShift; + +public interface IRightShiftInitialiser extends IShiftOperatorInitialiser { + @Override + public RightShift instantiate(); + +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/IShiftOperatorInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/IShiftOperatorInitialiser.java new file mode 100644 index 0000000000..e18dc95028 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/IShiftOperatorInitialiser.java @@ -0,0 +1,9 @@ +package cipm.consistency.initialisers.jamopp.operators; + +import org.emftext.language.java.operators.ShiftOperator; + +public interface IShiftOperatorInitialiser extends IOperatorInitialiser { + @Override + public ShiftOperator instantiate(); + +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/ISubtractionInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/ISubtractionInitialiser.java new file mode 100644 index 0000000000..c0776b0995 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/ISubtractionInitialiser.java @@ -0,0 +1,9 @@ +package cipm.consistency.initialisers.jamopp.operators; + +import org.emftext.language.java.operators.Subtraction; + +public interface ISubtractionInitialiser extends IAdditiveOperatorInitialiser { + @Override + public Subtraction instantiate(); + +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/IUnaryModificationOperatorInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/IUnaryModificationOperatorInitialiser.java new file mode 100644 index 0000000000..efd06dc63d --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/IUnaryModificationOperatorInitialiser.java @@ -0,0 +1,9 @@ +package cipm.consistency.initialisers.jamopp.operators; + +import org.emftext.language.java.operators.UnaryModificationOperator; + +public interface IUnaryModificationOperatorInitialiser extends IOperatorInitialiser { + @Override + public UnaryModificationOperator instantiate(); + +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/IUnaryOperatorInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/IUnaryOperatorInitialiser.java new file mode 100644 index 0000000000..ef4e219488 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/IUnaryOperatorInitialiser.java @@ -0,0 +1,9 @@ +package cipm.consistency.initialisers.jamopp.operators; + +import org.emftext.language.java.operators.UnaryOperator; + +public interface IUnaryOperatorInitialiser extends IOperatorInitialiser { + @Override + public UnaryOperator instantiate(); + +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/IUnsignedRightShiftInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/IUnsignedRightShiftInitialiser.java new file mode 100644 index 0000000000..cada84eed8 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/IUnsignedRightShiftInitialiser.java @@ -0,0 +1,9 @@ +package cipm.consistency.initialisers.jamopp.operators; + +import org.emftext.language.java.operators.UnsignedRightShift; + +public interface IUnsignedRightShiftInitialiser extends IShiftOperatorInitialiser { + @Override + public UnsignedRightShift instantiate(); + +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/LeftShiftInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/LeftShiftInitialiser.java new file mode 100644 index 0000000000..a92d5e138a --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/LeftShiftInitialiser.java @@ -0,0 +1,18 @@ +package cipm.consistency.initialisers.jamopp.operators; + +import org.emftext.language.java.operators.LeftShift; +import org.emftext.language.java.operators.OperatorsFactory; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class LeftShiftInitialiser extends AbstractInitialiserBase implements ILeftShiftInitialiser { + @Override + public ILeftShiftInitialiser newInitialiser() { + return new LeftShiftInitialiser(); + } + + @Override + public LeftShift instantiate() { + return OperatorsFactory.eINSTANCE.createLeftShift(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/LessThanInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/LessThanInitialiser.java new file mode 100644 index 0000000000..e2e5b39add --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/LessThanInitialiser.java @@ -0,0 +1,18 @@ +package cipm.consistency.initialisers.jamopp.operators; + +import org.emftext.language.java.operators.LessThan; +import org.emftext.language.java.operators.OperatorsFactory; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class LessThanInitialiser extends AbstractInitialiserBase implements ILessThanInitialiser { + @Override + public ILessThanInitialiser newInitialiser() { + return new LessThanInitialiser(); + } + + @Override + public LessThan instantiate() { + return OperatorsFactory.eINSTANCE.createLessThan(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/LessThanOrEqualInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/LessThanOrEqualInitialiser.java new file mode 100644 index 0000000000..aa0519d3ca --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/LessThanOrEqualInitialiser.java @@ -0,0 +1,18 @@ +package cipm.consistency.initialisers.jamopp.operators; + +import org.emftext.language.java.operators.LessThanOrEqual; +import org.emftext.language.java.operators.OperatorsFactory; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class LessThanOrEqualInitialiser extends AbstractInitialiserBase implements ILessThanOrEqualInitialiser { + @Override + public ILessThanOrEqualInitialiser newInitialiser() { + return new LessThanOrEqualInitialiser(); + } + + @Override + public LessThanOrEqual instantiate() { + return OperatorsFactory.eINSTANCE.createLessThanOrEqual(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/MinusMinusInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/MinusMinusInitialiser.java new file mode 100644 index 0000000000..eb22f66029 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/MinusMinusInitialiser.java @@ -0,0 +1,18 @@ +package cipm.consistency.initialisers.jamopp.operators; + +import org.emftext.language.java.operators.MinusMinus; +import org.emftext.language.java.operators.OperatorsFactory; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class MinusMinusInitialiser extends AbstractInitialiserBase implements IMinusMinusInitialiser { + @Override + public IMinusMinusInitialiser newInitialiser() { + return new MinusMinusInitialiser(); + } + + @Override + public MinusMinus instantiate() { + return OperatorsFactory.eINSTANCE.createMinusMinus(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/MultiplicationInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/MultiplicationInitialiser.java new file mode 100644 index 0000000000..559e213443 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/MultiplicationInitialiser.java @@ -0,0 +1,18 @@ +package cipm.consistency.initialisers.jamopp.operators; + +import org.emftext.language.java.operators.Multiplication; +import org.emftext.language.java.operators.OperatorsFactory; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class MultiplicationInitialiser extends AbstractInitialiserBase implements IMultiplicationInitialiser { + @Override + public IMultiplicationInitialiser newInitialiser() { + return new MultiplicationInitialiser(); + } + + @Override + public Multiplication instantiate() { + return OperatorsFactory.eINSTANCE.createMultiplication(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/NegateInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/NegateInitialiser.java new file mode 100644 index 0000000000..25386a661c --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/NegateInitialiser.java @@ -0,0 +1,18 @@ +package cipm.consistency.initialisers.jamopp.operators; + +import org.emftext.language.java.operators.Negate; +import org.emftext.language.java.operators.OperatorsFactory; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class NegateInitialiser extends AbstractInitialiserBase implements INegateInitialiser { + @Override + public INegateInitialiser newInitialiser() { + return new NegateInitialiser(); + } + + @Override + public Negate instantiate() { + return OperatorsFactory.eINSTANCE.createNegate(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/NotEqualInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/NotEqualInitialiser.java new file mode 100644 index 0000000000..93cc16b45b --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/NotEqualInitialiser.java @@ -0,0 +1,18 @@ +package cipm.consistency.initialisers.jamopp.operators; + +import org.emftext.language.java.operators.NotEqual; +import org.emftext.language.java.operators.OperatorsFactory; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class NotEqualInitialiser extends AbstractInitialiserBase implements INotEqualInitialiser { + @Override + public INotEqualInitialiser newInitialiser() { + return new NotEqualInitialiser(); + } + + @Override + public NotEqual instantiate() { + return OperatorsFactory.eINSTANCE.createNotEqual(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/OperatorsInitialiserPackage.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/OperatorsInitialiserPackage.java new file mode 100644 index 0000000000..f84c06fddb --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/OperatorsInitialiserPackage.java @@ -0,0 +1,44 @@ +package cipm.consistency.initialisers.jamopp.operators; + +import java.util.Collection; + +import cipm.consistency.initialisers.IInitialiser; +import cipm.consistency.initialisers.IInitialiserPackage; + +public class OperatorsInitialiserPackage implements IInitialiserPackage { + @Override + public Collection getInitialiserInstances() { + return this.initCol(new IInitialiser[] { new AdditionInitialiser(), new AssignmentAndInitialiser(), + new AssignmentDivisionInitialiser(), new AssignmentExclusiveOrInitialiser(), + new AssignmentInitialiser(), new AssignmentLeftShiftInitialiser(), new AssignmentMinusInitialiser(), + new AssignmentModuloInitialiser(), new AssignmentMultiplicationInitialiser(), + new AssignmentOrInitialiser(), new AssignmentPlusInitialiser(), new AssignmentRightShiftInitialiser(), + new AssignmentUnsignedRightShiftInitialiser(), new ComplementInitialiser(), new DivisionInitialiser(), + new EqualInitialiser(), new GreaterThanInitialiser(), new GreaterThanOrEqualInitialiser(), + new LeftShiftInitialiser(), new LessThanInitialiser(), new LessThanOrEqualInitialiser(), + new MinusMinusInitialiser(), new MultiplicationInitialiser(), new NegateInitialiser(), + new NotEqualInitialiser(), new PlusPlusInitialiser(), new RemainderInitialiser(), + new RightShiftInitialiser(), new SubtractionInitialiser(), new UnsignedRightShiftInitialiser(), }); + } + + @SuppressWarnings("unchecked") + @Override + public Collection> getInitialiserInterfaceTypes() { + return this.initCol(new Class[] { IAdditionInitialiser.class, IAdditiveOperatorInitialiser.class, + IAssignmentAndInitialiser.class, IAssignmentDivisionInitialiser.class, + IAssignmentExclusiveOrInitialiser.class, IAssignmentInitialiser.class, + IAssignmentLeftShiftInitialiser.class, IAssignmentMinusInitialiser.class, + IAssignmentModuloInitialiser.class, IAssignmentMultiplicationInitialiser.class, + IAssignmentOperatorInitialiser.class, IAssignmentOrInitialiser.class, IAssignmentPlusInitialiser.class, + IAssignmentRightShiftInitialiser.class, IAssignmentUnsignedRightShiftInitialiser.class, + IComplementInitialiser.class, IDivisionInitialiser.class, IEqualInitialiser.class, + IEqualityOperatorInitialiser.class, IGreaterThanInitialiser.class, IGreaterThanOrEqualInitialiser.class, + ILeftShiftInitialiser.class, ILessThanInitialiser.class, ILessThanOrEqualInitialiser.class, + IMinusMinusInitialiser.class, IMultiplicationInitialiser.class, + IMultiplicativeOperatorInitialiser.class, INegateInitialiser.class, INotEqualInitialiser.class, + IOperatorInitialiser.class, IPlusPlusInitialiser.class, IRelationOperatorInitialiser.class, + IRemainderInitialiser.class, IRightShiftInitialiser.class, IShiftOperatorInitialiser.class, + ISubtractionInitialiser.class, IUnaryModificationOperatorInitialiser.class, + IUnaryOperatorInitialiser.class, IUnsignedRightShiftInitialiser.class, }); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/PlusPlusInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/PlusPlusInitialiser.java new file mode 100644 index 0000000000..520890cb30 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/PlusPlusInitialiser.java @@ -0,0 +1,18 @@ +package cipm.consistency.initialisers.jamopp.operators; + +import org.emftext.language.java.operators.OperatorsFactory; +import org.emftext.language.java.operators.PlusPlus; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class PlusPlusInitialiser extends AbstractInitialiserBase implements IPlusPlusInitialiser { + @Override + public IPlusPlusInitialiser newInitialiser() { + return new PlusPlusInitialiser(); + } + + @Override + public PlusPlus instantiate() { + return OperatorsFactory.eINSTANCE.createPlusPlus(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/RemainderInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/RemainderInitialiser.java new file mode 100644 index 0000000000..4445daa0d9 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/RemainderInitialiser.java @@ -0,0 +1,18 @@ +package cipm.consistency.initialisers.jamopp.operators; + +import org.emftext.language.java.operators.OperatorsFactory; +import org.emftext.language.java.operators.Remainder; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class RemainderInitialiser extends AbstractInitialiserBase implements IRemainderInitialiser { + @Override + public IRemainderInitialiser newInitialiser() { + return new RemainderInitialiser(); + } + + @Override + public Remainder instantiate() { + return OperatorsFactory.eINSTANCE.createRemainder(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/RightShiftInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/RightShiftInitialiser.java new file mode 100644 index 0000000000..b5f2ca2e96 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/RightShiftInitialiser.java @@ -0,0 +1,18 @@ +package cipm.consistency.initialisers.jamopp.operators; + +import org.emftext.language.java.operators.OperatorsFactory; +import org.emftext.language.java.operators.RightShift; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class RightShiftInitialiser extends AbstractInitialiserBase implements IRightShiftInitialiser { + @Override + public IRightShiftInitialiser newInitialiser() { + return new RightShiftInitialiser(); + } + + @Override + public RightShift instantiate() { + return OperatorsFactory.eINSTANCE.createRightShift(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/SubtractionInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/SubtractionInitialiser.java new file mode 100644 index 0000000000..d50fb0e26b --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/SubtractionInitialiser.java @@ -0,0 +1,18 @@ +package cipm.consistency.initialisers.jamopp.operators; + +import org.emftext.language.java.operators.OperatorsFactory; +import org.emftext.language.java.operators.Subtraction; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class SubtractionInitialiser extends AbstractInitialiserBase implements ISubtractionInitialiser { + @Override + public ISubtractionInitialiser newInitialiser() { + return new SubtractionInitialiser(); + } + + @Override + public Subtraction instantiate() { + return OperatorsFactory.eINSTANCE.createSubtraction(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/UnsignedRightShiftInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/UnsignedRightShiftInitialiser.java new file mode 100644 index 0000000000..74cf34179c --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/UnsignedRightShiftInitialiser.java @@ -0,0 +1,18 @@ +package cipm.consistency.initialisers.jamopp.operators; + +import org.emftext.language.java.operators.OperatorsFactory; +import org.emftext.language.java.operators.UnsignedRightShift; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class UnsignedRightShiftInitialiser extends AbstractInitialiserBase implements IUnsignedRightShiftInitialiser { + @Override + public IUnsignedRightShiftInitialiser newInitialiser() { + return new UnsignedRightShiftInitialiser(); + } + + @Override + public UnsignedRightShift instantiate() { + return OperatorsFactory.eINSTANCE.createUnsignedRightShift(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/package-info.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/package-info.java new file mode 100644 index 0000000000..cf32b47e60 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/operators/package-info.java @@ -0,0 +1,5 @@ +/** + * Contains {@link IInitialiser} implementations for + * {@link org.emftext.language.java.operators}. + */ +package cipm.consistency.initialisers.jamopp.operators; \ No newline at end of file From dd7089a2ad1b5307d1bc5f70c4b399f237e41b7f Mon Sep 17 00:00:00 2001 From: AlpTorac Date: Fri, 25 Oct 2024 17:34:43 +0200 Subject: [PATCH 14/55] (WIP) Implement initialiser package for org.emftext.language.java.arrays --- .../arrays/ArrayDimensionInitialiser.java | 19 ++++++++++ .../arrays/ArrayInitializerInitialiser.java | 19 ++++++++++ .../ArrayInstantiationBySizeInitialiser.java | 19 ++++++++++ ...InstantiationByValuesTypedInitialiser.java | 19 ++++++++++ ...stantiationByValuesUntypedInitialiser.java | 19 ++++++++++ .../arrays/ArraySelectorInitialiser.java | 18 ++++++++++ .../arrays/ArraysInitialiserPackage.java | 25 +++++++++++++ .../arrays/IArrayDimensionInitialiser.java | 11 ++++++ .../IArrayInitializationValueInitialiser.java | 11 ++++++ .../arrays/IArrayInitializerInitialiser.java | 24 +++++++++++++ .../IArrayInstantiationBySizeInitialiser.java | 24 +++++++++++++ ...ArrayInstantiationByValuesInitialiser.java | 16 +++++++++ ...InstantiationByValuesTypedInitialiser.java | 11 ++++++ ...stantiationByValuesUntypedInitialiser.java | 8 +++++ .../IArrayInstantiationInitialiser.java | 10 ++++++ .../arrays/IArraySelectorInitialiser.java | 17 +++++++++ .../arrays/IArrayTypeableInitialiser.java | 35 +++++++++++++++++++ .../jamopp/arrays/package-info.java | 5 +++ 18 files changed, 310 insertions(+) create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/arrays/ArrayDimensionInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/arrays/ArrayInitializerInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/arrays/ArrayInstantiationBySizeInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/arrays/ArrayInstantiationByValuesTypedInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/arrays/ArrayInstantiationByValuesUntypedInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/arrays/ArraySelectorInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/arrays/ArraysInitialiserPackage.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/arrays/IArrayDimensionInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/arrays/IArrayInitializationValueInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/arrays/IArrayInitializerInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/arrays/IArrayInstantiationBySizeInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/arrays/IArrayInstantiationByValuesInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/arrays/IArrayInstantiationByValuesTypedInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/arrays/IArrayInstantiationByValuesUntypedInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/arrays/IArrayInstantiationInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/arrays/IArraySelectorInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/arrays/IArrayTypeableInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/arrays/package-info.java diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/arrays/ArrayDimensionInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/arrays/ArrayDimensionInitialiser.java new file mode 100644 index 0000000000..858fb0c149 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/arrays/ArrayDimensionInitialiser.java @@ -0,0 +1,19 @@ +package cipm.consistency.initialisers.jamopp.arrays; + +import org.emftext.language.java.arrays.ArraysFactory; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +import org.emftext.language.java.arrays.ArrayDimension; + +public class ArrayDimensionInitialiser extends AbstractInitialiserBase implements IArrayDimensionInitialiser { + @Override + public IArrayDimensionInitialiser newInitialiser() { + return new ArrayDimensionInitialiser(); + } + + @Override + public ArrayDimension instantiate() { + return ArraysFactory.eINSTANCE.createArrayDimension(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/arrays/ArrayInitializerInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/arrays/ArrayInitializerInitialiser.java new file mode 100644 index 0000000000..91a244f67c --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/arrays/ArrayInitializerInitialiser.java @@ -0,0 +1,19 @@ +package cipm.consistency.initialisers.jamopp.arrays; + +import org.emftext.language.java.arrays.ArraysFactory; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +import org.emftext.language.java.arrays.ArrayInitializer; + +public class ArrayInitializerInitialiser extends AbstractInitialiserBase implements IArrayInitializerInitialiser { + @Override + public IArrayInitializerInitialiser newInitialiser() { + return new ArrayInitializerInitialiser(); + } + + @Override + public ArrayInitializer instantiate() { + return ArraysFactory.eINSTANCE.createArrayInitializer(); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/arrays/ArrayInstantiationBySizeInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/arrays/ArrayInstantiationBySizeInitialiser.java new file mode 100644 index 0000000000..cc199d7aac --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/arrays/ArrayInstantiationBySizeInitialiser.java @@ -0,0 +1,19 @@ +package cipm.consistency.initialisers.jamopp.arrays; + +import org.emftext.language.java.arrays.ArrayInstantiationBySize; +import org.emftext.language.java.arrays.ArraysFactory; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class ArrayInstantiationBySizeInitialiser extends AbstractInitialiserBase + implements IArrayInstantiationBySizeInitialiser { + @Override + public IArrayInstantiationBySizeInitialiser newInitialiser() { + return new ArrayInstantiationBySizeInitialiser(); + } + + @Override + public ArrayInstantiationBySize instantiate() { + return ArraysFactory.eINSTANCE.createArrayInstantiationBySize(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/arrays/ArrayInstantiationByValuesTypedInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/arrays/ArrayInstantiationByValuesTypedInitialiser.java new file mode 100644 index 0000000000..d6d53022e2 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/arrays/ArrayInstantiationByValuesTypedInitialiser.java @@ -0,0 +1,19 @@ +package cipm.consistency.initialisers.jamopp.arrays; + +import org.emftext.language.java.arrays.ArrayInstantiationByValuesTyped; +import org.emftext.language.java.arrays.ArraysFactory; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class ArrayInstantiationByValuesTypedInitialiser extends AbstractInitialiserBase + implements IArrayInstantiationByValuesTypedInitialiser { + @Override + public IArrayInstantiationByValuesTypedInitialiser newInitialiser() { + return new ArrayInstantiationByValuesTypedInitialiser(); + } + + @Override + public ArrayInstantiationByValuesTyped instantiate() { + return ArraysFactory.eINSTANCE.createArrayInstantiationByValuesTyped(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/arrays/ArrayInstantiationByValuesUntypedInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/arrays/ArrayInstantiationByValuesUntypedInitialiser.java new file mode 100644 index 0000000000..ba8ee9e7e9 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/arrays/ArrayInstantiationByValuesUntypedInitialiser.java @@ -0,0 +1,19 @@ +package cipm.consistency.initialisers.jamopp.arrays; + +import org.emftext.language.java.arrays.ArrayInstantiationByValuesUntyped; +import org.emftext.language.java.arrays.ArraysFactory; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class ArrayInstantiationByValuesUntypedInitialiser extends AbstractInitialiserBase + implements IArrayInstantiationByValuesUntypedInitialiser { + @Override + public IArrayInstantiationByValuesUntypedInitialiser newInitialiser() { + return new ArrayInstantiationByValuesUntypedInitialiser(); + } + + @Override + public ArrayInstantiationByValuesUntyped instantiate() { + return ArraysFactory.eINSTANCE.createArrayInstantiationByValuesUntyped(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/arrays/ArraySelectorInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/arrays/ArraySelectorInitialiser.java new file mode 100644 index 0000000000..8433c8ca8b --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/arrays/ArraySelectorInitialiser.java @@ -0,0 +1,18 @@ +package cipm.consistency.initialisers.jamopp.arrays; + +import org.emftext.language.java.arrays.ArraySelector; +import org.emftext.language.java.arrays.ArraysFactory; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class ArraySelectorInitialiser extends AbstractInitialiserBase implements IArraySelectorInitialiser { + @Override + public IArraySelectorInitialiser newInitialiser() { + return new ArraySelectorInitialiser(); + } + + @Override + public ArraySelector instantiate() { + return ArraysFactory.eINSTANCE.createArraySelector(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/arrays/ArraysInitialiserPackage.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/arrays/ArraysInitialiserPackage.java new file mode 100644 index 0000000000..0af267885e --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/arrays/ArraysInitialiserPackage.java @@ -0,0 +1,25 @@ +package cipm.consistency.initialisers.jamopp.arrays; + +import java.util.Collection; + +import cipm.consistency.initialisers.IInitialiser; +import cipm.consistency.initialisers.IInitialiserPackage; + +public class ArraysInitialiserPackage implements IInitialiserPackage { + @Override + public Collection getInitialiserInstances() { + return this.initCol(new IInitialiser[] { new ArrayDimensionInitialiser(), new ArrayInitializerInitialiser(), + new ArrayInstantiationBySizeInitialiser(), new ArrayInstantiationByValuesTypedInitialiser(), + new ArrayInstantiationByValuesUntypedInitialiser(), new ArraySelectorInitialiser() }); + } + + @SuppressWarnings("unchecked") + @Override + public Collection> getInitialiserInterfaceTypes() { + return this.initCol(new Class[] { IArrayDimensionInitialiser.class, IArrayInitializationValueInitialiser.class, + IArrayInitializerInitialiser.class, IArrayInstantiationBySizeInitialiser.class, + IArrayInstantiationByValuesInitialiser.class, IArrayInstantiationByValuesTypedInitialiser.class, + IArrayInstantiationByValuesUntypedInitialiser.class, IArrayInstantiationInitialiser.class, + IArraySelectorInitialiser.class, IArrayTypeableInitialiser.class }); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/arrays/IArrayDimensionInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/arrays/IArrayDimensionInitialiser.java new file mode 100644 index 0000000000..806493e3b2 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/arrays/IArrayDimensionInitialiser.java @@ -0,0 +1,11 @@ +package cipm.consistency.initialisers.jamopp.arrays; + +import org.emftext.language.java.arrays.ArrayDimension; + +import cipm.consistency.initialisers.jamopp.annotations.IAnnotableInitialiser; +import cipm.consistency.initialisers.jamopp.commons.ICommentableInitialiser; + +public interface IArrayDimensionInitialiser extends IAnnotableInitialiser, ICommentableInitialiser { + @Override + public ArrayDimension instantiate(); +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/arrays/IArrayInitializationValueInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/arrays/IArrayInitializationValueInitialiser.java new file mode 100644 index 0000000000..4bf9ec4414 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/arrays/IArrayInitializationValueInitialiser.java @@ -0,0 +1,11 @@ +package cipm.consistency.initialisers.jamopp.arrays; + +import org.emftext.language.java.arrays.ArrayInitializationValue; + +import cipm.consistency.initialisers.jamopp.commons.ICommentableInitialiser; + +public interface IArrayInitializationValueInitialiser extends ICommentableInitialiser { + @Override + public ArrayInitializationValue instantiate(); + +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/arrays/IArrayInitializerInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/arrays/IArrayInitializerInitialiser.java new file mode 100644 index 0000000000..c7ea435d5e --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/arrays/IArrayInitializerInitialiser.java @@ -0,0 +1,24 @@ +package cipm.consistency.initialisers.jamopp.arrays; + +import org.emftext.language.java.arrays.ArrayInitializationValue; +import org.emftext.language.java.arrays.ArrayInitializer; + +import cipm.consistency.initialisers.jamopp.annotations.IAnnotationValueInitialiser; + +public interface IArrayInitializerInitialiser + extends IAnnotationValueInitialiser, IArrayInitializationValueInitialiser { + @Override + public ArrayInitializer instantiate(); + + public default boolean addInitialValue(ArrayInitializer ai, ArrayInitializationValue initVal) { + if (initVal != null) { + ai.getInitialValues().add(initVal); + return ai.getInitialValues().contains(initVal); + } + return true; + } + + public default boolean addInitialValues(ArrayInitializer ai, ArrayInitializationValue[] initVals) { + return this.doMultipleModifications(ai, initVals, this::addInitialValue); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/arrays/IArrayInstantiationBySizeInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/arrays/IArrayInstantiationBySizeInitialiser.java new file mode 100644 index 0000000000..38df6b44a1 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/arrays/IArrayInstantiationBySizeInitialiser.java @@ -0,0 +1,24 @@ +package cipm.consistency.initialisers.jamopp.arrays; + +import org.emftext.language.java.arrays.ArrayInstantiationBySize; +import org.emftext.language.java.expressions.Expression; + +import cipm.consistency.initialisers.jamopp.types.ITypedElementInitialiser; + +public interface IArrayInstantiationBySizeInitialiser extends IArrayInstantiationInitialiser, ITypedElementInitialiser { + + @Override + public ArrayInstantiationBySize instantiate(); + + public default boolean addSize(ArrayInstantiationBySize arrIns, Expression size) { + if (size != null) { + arrIns.getSizes().add(size); + return arrIns.getSizes().contains(size); + } + return true; + } + + public default boolean addSizes(ArrayInstantiationBySize arrIns, Expression[] sizes) { + return this.doMultipleModifications(arrIns, sizes, this::addSize); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/arrays/IArrayInstantiationByValuesInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/arrays/IArrayInstantiationByValuesInitialiser.java new file mode 100644 index 0000000000..128f2fd41c --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/arrays/IArrayInstantiationByValuesInitialiser.java @@ -0,0 +1,16 @@ +package cipm.consistency.initialisers.jamopp.arrays; + +import org.emftext.language.java.arrays.ArrayInitializer; +import org.emftext.language.java.arrays.ArrayInstantiationByValues; + +public interface IArrayInstantiationByValuesInitialiser extends IArrayInstantiationInitialiser { + + @Override + public ArrayInstantiationByValues instantiate(); + + public default boolean setArrayInitializer(ArrayInstantiationByValues arrIns, ArrayInitializer arrInit) { + arrIns.setArrayInitializer(arrInit); + return (arrInit == null && arrIns.getArrayInitializer() == null) + || arrIns.getArrayInitializer().equals(arrInit); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/arrays/IArrayInstantiationByValuesTypedInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/arrays/IArrayInstantiationByValuesTypedInitialiser.java new file mode 100644 index 0000000000..62dde8bfed --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/arrays/IArrayInstantiationByValuesTypedInitialiser.java @@ -0,0 +1,11 @@ +package cipm.consistency.initialisers.jamopp.arrays; + +import org.emftext.language.java.arrays.ArrayInstantiationByValuesTyped; + +import cipm.consistency.initialisers.jamopp.types.ITypedElementInitialiser; + +public interface IArrayInstantiationByValuesTypedInitialiser + extends IArrayInstantiationByValuesInitialiser, ITypedElementInitialiser { + @Override + public ArrayInstantiationByValuesTyped instantiate(); +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/arrays/IArrayInstantiationByValuesUntypedInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/arrays/IArrayInstantiationByValuesUntypedInitialiser.java new file mode 100644 index 0000000000..e9a6d68b5a --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/arrays/IArrayInstantiationByValuesUntypedInitialiser.java @@ -0,0 +1,8 @@ +package cipm.consistency.initialisers.jamopp.arrays; + +import org.emftext.language.java.arrays.ArrayInstantiationByValuesUntyped; + +public interface IArrayInstantiationByValuesUntypedInitialiser extends IArrayInstantiationByValuesInitialiser { + @Override + public ArrayInstantiationByValuesUntyped instantiate(); +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/arrays/IArrayInstantiationInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/arrays/IArrayInstantiationInitialiser.java new file mode 100644 index 0000000000..4af666ff1c --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/arrays/IArrayInstantiationInitialiser.java @@ -0,0 +1,10 @@ +package cipm.consistency.initialisers.jamopp.arrays; + +import org.emftext.language.java.arrays.ArrayInstantiation; + +import cipm.consistency.initialisers.jamopp.references.IReferenceInitialiser; + +public interface IArrayInstantiationInitialiser extends IReferenceInitialiser { + @Override + public ArrayInstantiation instantiate(); +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/arrays/IArraySelectorInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/arrays/IArraySelectorInitialiser.java new file mode 100644 index 0000000000..de628f49ca --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/arrays/IArraySelectorInitialiser.java @@ -0,0 +1,17 @@ +package cipm.consistency.initialisers.jamopp.arrays; + +import org.emftext.language.java.arrays.ArraySelector; +import org.emftext.language.java.expressions.Expression; + +import cipm.consistency.initialisers.jamopp.annotations.IAnnotableInitialiser; +import cipm.consistency.initialisers.jamopp.commons.ICommentableInitialiser; + +public interface IArraySelectorInitialiser extends IAnnotableInitialiser, ICommentableInitialiser { + @Override + public ArraySelector instantiate(); + + public default boolean setPosition(ArraySelector as, Expression pos) { + as.setPosition(pos); + return (pos == null && as.getPosition() == null) || as.getPosition().equals(pos); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/arrays/IArrayTypeableInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/arrays/IArrayTypeableInitialiser.java new file mode 100644 index 0000000000..4456f650f2 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/arrays/IArrayTypeableInitialiser.java @@ -0,0 +1,35 @@ +package cipm.consistency.initialisers.jamopp.arrays; + +import org.emftext.language.java.arrays.ArrayDimension; +import org.emftext.language.java.arrays.ArrayTypeable; + +import cipm.consistency.initialisers.jamopp.commons.ICommentableInitialiser; + +public interface IArrayTypeableInitialiser extends ICommentableInitialiser { + @Override + public ArrayTypeable instantiate(); + + public default boolean addArrayDimensionAfter(ArrayTypeable at, ArrayDimension arrDimAfter) { + if (arrDimAfter != null) { + at.getArrayDimensionsAfter().add(arrDimAfter); + return at.getArrayDimensionsAfter().contains(arrDimAfter); + } + return true; + } + + public default boolean addArrayDimensionBefore(ArrayTypeable at, ArrayDimension arrDimBefore) { + if (arrDimBefore != null) { + at.getArrayDimensionsBefore().add(arrDimBefore); + return at.getArrayDimensionsBefore().contains(arrDimBefore); + } + return true; + } + + public default boolean addArrayDimensionsAfter(ArrayTypeable at, ArrayDimension[] arrDimsAfter) { + return this.doMultipleModifications(at, arrDimsAfter, this::addArrayDimensionAfter); + } + + public default boolean addArrayDimensionsBefore(ArrayTypeable at, ArrayDimension[] arrDimsBefore) { + return this.doMultipleModifications(at, arrDimsBefore, this::addArrayDimensionBefore); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/arrays/package-info.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/arrays/package-info.java new file mode 100644 index 0000000000..81b6e0ef3b --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/arrays/package-info.java @@ -0,0 +1,5 @@ +/** + * Contains {@link IInitialiser} implementations for + * {@link org.emftext.language.java.arrays}. + */ +package cipm.consistency.initialisers.jamopp.arrays; \ No newline at end of file From 70aa32d4317f5e5e65e9b68a2b7a46248858501b Mon Sep 17 00:00:00 2001 From: AlpTorac Date: Fri, 25 Oct 2024 17:35:24 +0200 Subject: [PATCH 15/55] (WIP) Implement initialiser package for org.emftext.language.java.classifiers --- .../classifiers/AnnotationInitialiser.java | 20 ++++ .../AnonymousClassInitialiser.java | 19 ++++ .../jamopp/classifiers/ClassInitialiser.java | 20 ++++ .../ClassifierInitialiserPackage.java | 22 +++++ .../classifiers/EnumerationInitialiser.java | 19 ++++ .../classifiers/IAnnotationInitialiser.java | 8 ++ .../IAnonymousClassInitialiser.java | 11 +++ .../jamopp/classifiers/IClassInitialiser.java | 19 ++++ .../classifiers/IClassifierInitialiser.java | 93 +++++++++++++++++++ .../IConcreteClassifierInitialiser.java | 39 ++++++++ .../classifiers/IEnumerationInitialiser.java | 21 +++++ .../classifiers/IImplementorInitialiser.java | 23 +++++ .../classifiers/IInterfaceInitialiser.java | 33 +++++++ .../classifiers/InterfaceInitialiser.java | 19 ++++ .../jamopp/classifiers/package-info.java | 5 + 15 files changed, 371 insertions(+) create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/classifiers/AnnotationInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/classifiers/AnonymousClassInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/classifiers/ClassInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/classifiers/ClassifierInitialiserPackage.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/classifiers/EnumerationInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/classifiers/IAnnotationInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/classifiers/IAnonymousClassInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/classifiers/IClassInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/classifiers/IClassifierInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/classifiers/IConcreteClassifierInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/classifiers/IEnumerationInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/classifiers/IImplementorInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/classifiers/IInterfaceInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/classifiers/InterfaceInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/classifiers/package-info.java diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/classifiers/AnnotationInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/classifiers/AnnotationInitialiser.java new file mode 100644 index 0000000000..d9d9282819 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/classifiers/AnnotationInitialiser.java @@ -0,0 +1,20 @@ +package cipm.consistency.initialisers.jamopp.classifiers; + +import org.emftext.language.java.classifiers.Annotation; +import org.emftext.language.java.classifiers.ClassifiersFactory; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class AnnotationInitialiser extends AbstractInitialiserBase implements IAnnotationInitialiser { + @Override + public Annotation instantiate() { + var fac = ClassifiersFactory.eINSTANCE; + return fac.createAnnotation(); + } + + @Override + public AnnotationInitialiser newInitialiser() { + return new AnnotationInitialiser(); + } + +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/classifiers/AnonymousClassInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/classifiers/AnonymousClassInitialiser.java new file mode 100644 index 0000000000..8423d31510 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/classifiers/AnonymousClassInitialiser.java @@ -0,0 +1,19 @@ +package cipm.consistency.initialisers.jamopp.classifiers; + +import org.emftext.language.java.classifiers.ClassifiersFactory; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +import org.emftext.language.java.classifiers.AnonymousClass; + +public class AnonymousClassInitialiser extends AbstractInitialiserBase implements IAnonymousClassInitialiser { + @Override + public IAnonymousClassInitialiser newInitialiser() { + return new AnonymousClassInitialiser(); + } + + @Override + public AnonymousClass instantiate() { + return ClassifiersFactory.eINSTANCE.createAnonymousClass(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/classifiers/ClassInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/classifiers/ClassInitialiser.java new file mode 100644 index 0000000000..419c6de41b --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/classifiers/ClassInitialiser.java @@ -0,0 +1,20 @@ +package cipm.consistency.initialisers.jamopp.classifiers; + +import org.emftext.language.java.classifiers.ClassifiersFactory; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +import org.emftext.language.java.classifiers.Class; + +public class ClassInitialiser extends AbstractInitialiserBase implements IClassInitialiser { + @Override + public Class instantiate() { + var fac = ClassifiersFactory.eINSTANCE; + return fac.createClass(); + } + + @Override + public ClassInitialiser newInitialiser() { + return new ClassInitialiser(); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/classifiers/ClassifierInitialiserPackage.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/classifiers/ClassifierInitialiserPackage.java new file mode 100644 index 0000000000..80a09e1155 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/classifiers/ClassifierInitialiserPackage.java @@ -0,0 +1,22 @@ +package cipm.consistency.initialisers.jamopp.classifiers; + +import java.util.Collection; + +import cipm.consistency.initialisers.IInitialiser; +import cipm.consistency.initialisers.IInitialiserPackage; + +public class ClassifierInitialiserPackage implements IInitialiserPackage { + @Override + public Collection getInitialiserInstances() { + return this.initCol(new IInitialiser[] { new AnnotationInitialiser(), new AnonymousClassInitialiser(), + new ClassInitialiser(), new EnumerationInitialiser(), new InterfaceInitialiser() }); + } + + @SuppressWarnings("unchecked") + @Override + public Collection> getInitialiserInterfaceTypes() { + return this.initCol(new Class[] { IAnnotationInitialiser.class, IAnonymousClassInitialiser.class, + IClassifierInitialiser.class, IClassInitialiser.class, IConcreteClassifierInitialiser.class, + IEnumerationInitialiser.class, IImplementorInitialiser.class, IInterfaceInitialiser.class }); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/classifiers/EnumerationInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/classifiers/EnumerationInitialiser.java new file mode 100644 index 0000000000..c177fa3b87 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/classifiers/EnumerationInitialiser.java @@ -0,0 +1,19 @@ +package cipm.consistency.initialisers.jamopp.classifiers; + +import org.emftext.language.java.classifiers.ClassifiersFactory; +import org.emftext.language.java.classifiers.Enumeration; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class EnumerationInitialiser extends AbstractInitialiserBase implements IEnumerationInitialiser { + @Override + public Enumeration instantiate() { + var fac = ClassifiersFactory.eINSTANCE; + return fac.createEnumeration(); + } + + @Override + public EnumerationInitialiser newInitialiser() { + return new EnumerationInitialiser(); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/classifiers/IAnnotationInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/classifiers/IAnnotationInitialiser.java new file mode 100644 index 0000000000..e93400b262 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/classifiers/IAnnotationInitialiser.java @@ -0,0 +1,8 @@ +package cipm.consistency.initialisers.jamopp.classifiers; + +import org.emftext.language.java.classifiers.Annotation; + +public interface IAnnotationInitialiser extends IConcreteClassifierInitialiser { + @Override + public Annotation instantiate(); +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/classifiers/IAnonymousClassInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/classifiers/IAnonymousClassInitialiser.java new file mode 100644 index 0000000000..8e15726db6 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/classifiers/IAnonymousClassInitialiser.java @@ -0,0 +1,11 @@ +package cipm.consistency.initialisers.jamopp.classifiers; + +import org.emftext.language.java.classifiers.AnonymousClass; + +import cipm.consistency.initialisers.jamopp.members.IMemberContainerInitialiser; +import cipm.consistency.initialisers.jamopp.types.ITypeInitialiser; + +public interface IAnonymousClassInitialiser extends IMemberContainerInitialiser, ITypeInitialiser { + @Override + public AnonymousClass instantiate(); +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/classifiers/IClassInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/classifiers/IClassInitialiser.java new file mode 100644 index 0000000000..7f73eb9305 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/classifiers/IClassInitialiser.java @@ -0,0 +1,19 @@ +package cipm.consistency.initialisers.jamopp.classifiers; + +import org.emftext.language.java.classifiers.Class; +import org.emftext.language.java.types.TypeReference; + +public interface IClassInitialiser extends IConcreteClassifierInitialiser, IImplementorInitialiser { + @Override + public Class instantiate(); + + public default boolean setDefaultExtends(Class cls, TypeReference defExt) { + cls.setDefaultExtends(defExt); + return (defExt == null && cls.getDefaultExtends() == null) || cls.getDefaultExtends().equals(defExt); + } + + public default boolean setExtends(Class cls, TypeReference ext) { + cls.setExtends(ext); + return (ext == null && cls.getExtends() == null) || cls.getExtends().equals(ext); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/classifiers/IClassifierInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/classifiers/IClassifierInitialiser.java new file mode 100644 index 0000000000..67ca490b91 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/classifiers/IClassifierInitialiser.java @@ -0,0 +1,93 @@ +package cipm.consistency.initialisers.jamopp.classifiers; + +import org.emftext.language.java.classifiers.Classifier; +import org.emftext.language.java.imports.Import; +import org.emftext.language.java.imports.PackageImport; + +import cipm.consistency.initialisers.jamopp.references.IReferenceableElementInitialiser; +import cipm.consistency.initialisers.jamopp.types.ITypeInitialiser; + +/** + * An interface meant for {@link IInitialiser} implementors that are supposed to + * create {@link Classifier} instances.
+ *
+ * Note: The methods addImport/addPackageImport of {@link Classifier} add the + * imports to its {@link CompilationUnit}. {@link Classifier} has no attributes + * itself. The same holds for their corresponding methods in this + * initialiser.. Use the methods {@link #canAddImports(Classifier)} and + * {@link #canAddPackageImports(Classifier)} to determine, whether certain + * imports can be added. + * + * @author Alp Torac Genc + */ + +public interface IClassifierInitialiser extends ITypeInitialiser, IReferenceableElementInitialiser { + @Override + public Classifier instantiate(); + + /** + * Adds the given {@link Import} to the {@link CompilationUnit} containing the + * given {@link Classifier}.
+ *
+ * Attempting to add null imports will return true, since there is no + * modification to perform. + * + * @see {@link IClassifierInitialiser} + */ + public default boolean addImport(Classifier cls, Import imp) { + if (imp != null) { + if (!this.canAddImports(cls)) { + return false; + } + var cu = cls.getContainingCompilationUnit(); + cu.getImports().add(imp); + return cu.getImports().stream().anyMatch((i) -> i.equals(imp)); + } + return true; + } + + public default boolean addImports(Classifier cls, Import[] imps) { + return this.doMultipleModifications(cls, imps, this::addImport); + } + + /** + * Whether {@link Import}s can be added via + * {@link #addImport(Classifier, Import)} + */ + public default boolean canAddImports(Classifier cls) { + return cls.getContainingCompilationUnit() != null; + } + + /** + * Whether {@link PackageImport}s can be added via + * {@link #addPackageImport(Classifier, PackageImport)} + */ + public default boolean canAddPackageImports(Classifier cls) { + return cls.getContainingCompilationUnit() != null; + } + + /** + * Adds the given {@link PackageImport} to the {@link CompilationUnit} + * containing the given {@link Classifier}.
+ *
+ * Attempting to add null package imports will return true, since there is no + * modification to perform. + * + * @see {@link IClassifierInitialiser} + */ + public default boolean addPackageImport(Classifier cls, PackageImport imp) { + if (imp != null) { + if (!this.canAddPackageImports(cls)) { + return false; + } + var cu = cls.getContainingCompilationUnit(); + cu.getImports().add(imp); + return cu.getImports().stream().anyMatch((i) -> i.equals(imp)); + } + return true; + } + + public default boolean addPackageImports(Classifier cls, PackageImport[] imps) { + return this.doMultipleModifications(cls, imps, this::addPackageImport); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/classifiers/IConcreteClassifierInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/classifiers/IConcreteClassifierInitialiser.java new file mode 100644 index 0000000000..8026bc4ded --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/classifiers/IConcreteClassifierInitialiser.java @@ -0,0 +1,39 @@ +package cipm.consistency.initialisers.jamopp.classifiers; + +import org.emftext.language.java.classifiers.ConcreteClassifier; +import org.emftext.language.java.containers.Package; + +import cipm.consistency.initialisers.jamopp.generics.ITypeParametrizableInitialiser; +import cipm.consistency.initialisers.jamopp.members.IMemberContainerInitialiser; +import cipm.consistency.initialisers.jamopp.members.IMemberInitialiser; +import cipm.consistency.initialisers.jamopp.modifiers.IAnnotableAndModifiableInitialiser; +import cipm.consistency.initialisers.jamopp.statements.IStatementInitialiser; + +/** + * An interface meant for {@link IInitialiser} implementors that are supposed to + * create {@link ConcreteClassifier} instances.
+ *
+ * Note: {@link #setPackage(ConcreteClassifier, Package)} does not add the + * given {@link ConcreteClassifier} to the given {@link Package}. + * + * @author Alp Torac Genc + * + */ +public interface IConcreteClassifierInitialiser extends IAnnotableAndModifiableInitialiser, IMemberContainerInitialiser, + IMemberInitialiser, IStatementInitialiser, IClassifierInitialiser, ITypeParametrizableInitialiser { + + @Override + public ConcreteClassifier instantiate(); + + /** + * Sets the package of cls as pac.
+ *
+ * Note: DOES NOT modify the classifiers contained by pac. + * + * @see {@link IConcreteClassifierInitialiser} + */ + public default boolean setPackage(ConcreteClassifier cls, Package pac) { + cls.setPackage(pac); + return (pac == null && cls.getPackage() == null) || cls.getPackage().equals(pac); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/classifiers/IEnumerationInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/classifiers/IEnumerationInitialiser.java new file mode 100644 index 0000000000..3da9091378 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/classifiers/IEnumerationInitialiser.java @@ -0,0 +1,21 @@ +package cipm.consistency.initialisers.jamopp.classifiers; + +import org.emftext.language.java.classifiers.Enumeration; +import org.emftext.language.java.members.EnumConstant; + +public interface IEnumerationInitialiser extends IConcreteClassifierInitialiser, IImplementorInitialiser { + @Override + public Enumeration instantiate(); + + public default boolean addConstant(Enumeration enm, EnumConstant cnst) { + if (cnst != null) { + enm.getConstants().add(cnst); + return enm.getConstants().contains(cnst) && enm.getContainedConstant(cnst.getName()).equals(cnst); + } + return true; + } + + public default boolean addConstants(Enumeration enm, EnumConstant[] cnsts) { + return this.doMultipleModifications(enm, cnsts, this::addConstant); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/classifiers/IImplementorInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/classifiers/IImplementorInitialiser.java new file mode 100644 index 0000000000..f0fbdebd03 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/classifiers/IImplementorInitialiser.java @@ -0,0 +1,23 @@ +package cipm.consistency.initialisers.jamopp.classifiers; + +import org.emftext.language.java.classifiers.Implementor; +import org.emftext.language.java.types.TypeReference; + +import cipm.consistency.initialisers.jamopp.commons.ICommentableInitialiser; + +public interface IImplementorInitialiser extends ICommentableInitialiser { + @Override + public Implementor instantiate(); + + public default boolean addImplements(Implementor implementor, TypeReference impls) { + if (impls != null) { + implementor.getImplements().add(impls); + return implementor.getImplements().contains(impls); + } + return true; + } + + public default boolean addImplements(Implementor implementor, TypeReference[] implsArr) { + return this.doMultipleModifications(implementor, implsArr, this::addImplements); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/classifiers/IInterfaceInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/classifiers/IInterfaceInitialiser.java new file mode 100644 index 0000000000..33bafa69ce --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/classifiers/IInterfaceInitialiser.java @@ -0,0 +1,33 @@ +package cipm.consistency.initialisers.jamopp.classifiers; + +import org.emftext.language.java.classifiers.Interface; +import org.emftext.language.java.types.TypeReference; + +public interface IInterfaceInitialiser extends IConcreteClassifierInitialiser { + @Override + public Interface instantiate(); + + public default boolean addDefaultExtends(Interface intfc, TypeReference defExt) { + if (defExt != null) { + intfc.getDefaultExtends().add(defExt); + return intfc.getDefaultExtends().contains(defExt); + } + return true; + } + + public default boolean addDefaultExtends(Interface intfc, TypeReference[] defExts) { + return this.doMultipleModifications(intfc, defExts, this::addDefaultExtends); + } + + public default boolean addExtends(Interface intfc, TypeReference ext) { + if (ext != null) { + intfc.getExtends().add(ext); + return intfc.getExtends().contains(ext); + } + return true; + } + + public default boolean addExtends(Interface intfc, TypeReference[] exts) { + return this.doMultipleModifications(intfc, exts, this::addExtends); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/classifiers/InterfaceInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/classifiers/InterfaceInitialiser.java new file mode 100644 index 0000000000..da4fdb2809 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/classifiers/InterfaceInitialiser.java @@ -0,0 +1,19 @@ +package cipm.consistency.initialisers.jamopp.classifiers; + +import org.emftext.language.java.classifiers.ClassifiersFactory; +import org.emftext.language.java.classifiers.Interface; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class InterfaceInitialiser extends AbstractInitialiserBase implements IInterfaceInitialiser { + @Override + public Interface instantiate() { + var fac = ClassifiersFactory.eINSTANCE; + return fac.createInterface(); + } + + @Override + public InterfaceInitialiser newInitialiser() { + return new InterfaceInitialiser(); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/classifiers/package-info.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/classifiers/package-info.java new file mode 100644 index 0000000000..d93f4a1234 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/classifiers/package-info.java @@ -0,0 +1,5 @@ +/** + * Contains {@link IInitialiser} implementations for + * {@link org.emftext.language.java.classifiers}. + */ +package cipm.consistency.initialisers.jamopp.classifiers; \ No newline at end of file From cffe62385e62b51327d54511617b06d7b3cbad1c Mon Sep 17 00:00:00 2001 From: AlpTorac Date: Fri, 25 Oct 2024 17:35:43 +0200 Subject: [PATCH 16/55] (WIP) Implement initialiser package for org.emftext.language.java.containers --- .../CompilationUnitInitialiser.java | 19 +++++++ .../ContainersInitialiserPackage.java | 21 ++++++++ .../containers/EmptyModelInitialiser.java | 18 +++++++ .../ICompilationUnitInitialiser.java | 22 ++++++++ .../containers/IEmptyModelInitialiser.java | 9 ++++ .../containers/IJavaRootInitialiser.java | 20 +++++++ .../jamopp/containers/IModuleInitialiser.java | 40 ++++++++++++++ .../containers/IPackageInitialiser.java | 54 +++++++++++++++++++ .../jamopp/containers/ModuleInitialiser.java | 19 +++++++ .../jamopp/containers/PackageInitialiser.java | 19 +++++++ .../jamopp/containers/package-info.java | 5 ++ 11 files changed, 246 insertions(+) create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/containers/CompilationUnitInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/containers/ContainersInitialiserPackage.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/containers/EmptyModelInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/containers/ICompilationUnitInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/containers/IEmptyModelInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/containers/IJavaRootInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/containers/IModuleInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/containers/IPackageInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/containers/ModuleInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/containers/PackageInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/containers/package-info.java diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/containers/CompilationUnitInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/containers/CompilationUnitInitialiser.java new file mode 100644 index 0000000000..74180fcb86 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/containers/CompilationUnitInitialiser.java @@ -0,0 +1,19 @@ +package cipm.consistency.initialisers.jamopp.containers; + +import org.emftext.language.java.containers.CompilationUnit; +import org.emftext.language.java.containers.ContainersFactory; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class CompilationUnitInitialiser extends AbstractInitialiserBase implements ICompilationUnitInitialiser { + @Override + public CompilationUnit instantiate() { + var fac = ContainersFactory.eINSTANCE; + return fac.createCompilationUnit(); + } + + @Override + public ICompilationUnitInitialiser newInitialiser() { + return new CompilationUnitInitialiser(); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/containers/ContainersInitialiserPackage.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/containers/ContainersInitialiserPackage.java new file mode 100644 index 0000000000..e4297bcd3a --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/containers/ContainersInitialiserPackage.java @@ -0,0 +1,21 @@ +package cipm.consistency.initialisers.jamopp.containers; + +import java.util.Collection; + +import cipm.consistency.initialisers.IInitialiser; +import cipm.consistency.initialisers.IInitialiserPackage; + +public class ContainersInitialiserPackage implements IInitialiserPackage { + @Override + public Collection getInitialiserInstances() { + return this.initCol(new IInitialiser[] { new CompilationUnitInitialiser(), new EmptyModelInitialiser(), + new ModuleInitialiser(), new PackageInitialiser() }); + } + + @SuppressWarnings("unchecked") + @Override + public Collection> getInitialiserInterfaceTypes() { + return this.initCol(new Class[] { ICompilationUnitInitialiser.class, IEmptyModelInitialiser.class, + IJavaRootInitialiser.class, IModuleInitialiser.class, IPackageInitialiser.class }); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/containers/EmptyModelInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/containers/EmptyModelInitialiser.java new file mode 100644 index 0000000000..1589d25ca9 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/containers/EmptyModelInitialiser.java @@ -0,0 +1,18 @@ +package cipm.consistency.initialisers.jamopp.containers; + +import org.emftext.language.java.containers.ContainersFactory; +import org.emftext.language.java.containers.EmptyModel; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class EmptyModelInitialiser extends AbstractInitialiserBase implements IEmptyModelInitialiser { + @Override + public IEmptyModelInitialiser newInitialiser() { + return new EmptyModelInitialiser(); + } + + @Override + public EmptyModel instantiate() { + return ContainersFactory.eINSTANCE.createEmptyModel(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/containers/ICompilationUnitInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/containers/ICompilationUnitInitialiser.java new file mode 100644 index 0000000000..67414db54f --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/containers/ICompilationUnitInitialiser.java @@ -0,0 +1,22 @@ +package cipm.consistency.initialisers.jamopp.containers; + +import org.emftext.language.java.classifiers.ConcreteClassifier; +import org.emftext.language.java.containers.CompilationUnit; + +public interface ICompilationUnitInitialiser extends IJavaRootInitialiser { + @Override + public CompilationUnit instantiate(); + + public default boolean addClassifier(CompilationUnit cu, ConcreteClassifier cls) { + if (cls != null) { + cu.getClassifiers().add(cls); + return cu.getClassifiers().contains(cls) && cu.getContainedClassifier(cls.getQualifiedName()) != null + && cu.getContainedClassifier(cls.getQualifiedName()).equals(cls); + } + return true; + } + + public default boolean addClassifiers(CompilationUnit cu, ConcreteClassifier[] clss) { + return this.doMultipleModifications(cu, clss, this::addClassifier); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/containers/IEmptyModelInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/containers/IEmptyModelInitialiser.java new file mode 100644 index 0000000000..3f85c41b3f --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/containers/IEmptyModelInitialiser.java @@ -0,0 +1,9 @@ +package cipm.consistency.initialisers.jamopp.containers; + +import org.emftext.language.java.containers.EmptyModel; + +public interface IEmptyModelInitialiser extends IJavaRootInitialiser { + @Override + public EmptyModel instantiate(); + +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/containers/IJavaRootInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/containers/IJavaRootInitialiser.java new file mode 100644 index 0000000000..ba6b8d2941 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/containers/IJavaRootInitialiser.java @@ -0,0 +1,20 @@ +package cipm.consistency.initialisers.jamopp.containers; + +import org.emftext.language.java.containers.JavaRoot; +import org.emftext.language.java.containers.Origin; + +import cipm.consistency.initialisers.jamopp.annotations.IAnnotableInitialiser; +import cipm.consistency.initialisers.jamopp.commons.INamedElementInitialiser; +import cipm.consistency.initialisers.jamopp.commons.INamespaceAwareElementInitialiser; +import cipm.consistency.initialisers.jamopp.imports.IImportingElementInitialiser; + +public interface IJavaRootInitialiser extends INamedElementInitialiser, INamespaceAwareElementInitialiser, + IAnnotableInitialiser, IImportingElementInitialiser { + @Override + public JavaRoot instantiate(); + + public default boolean setOrigin(JavaRoot jr, Origin origin) { + jr.setOrigin(origin); + return (origin == null && jr.getOrigin() == null) || jr.getOrigin().equals(origin); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/containers/IModuleInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/containers/IModuleInitialiser.java new file mode 100644 index 0000000000..2509f04c44 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/containers/IModuleInitialiser.java @@ -0,0 +1,40 @@ +package cipm.consistency.initialisers.jamopp.containers; + +import org.emftext.language.java.containers.Module; +import org.emftext.language.java.containers.Package; +import org.emftext.language.java.modifiers.Open; +import org.emftext.language.java.modules.ModuleDirective; + +public interface IModuleInitialiser extends IJavaRootInitialiser { + @Override + public Module instantiate(); + + public default boolean setOpen(Module mod, Open open) { + mod.setOpen(open); + return (open == null && mod.getOpen() == null) || mod.getOpen().equals(open); + } + + public default boolean addTarget(Module mod, ModuleDirective target) { + if (target != null) { + mod.getTarget().add(target); + return mod.getTarget().contains(target); + } + return true; + } + + public default boolean addTargets(Module mod, ModuleDirective[] targets) { + return this.doMultipleModifications(mod, targets, this::addTarget); + } + + public default boolean addPackage(Module mod, Package pac) { + if (pac != null) { + mod.getPackages().add(pac); + return mod.getPackages().contains(pac); + } + return true; + } + + public default boolean addPackages(Module mod, Package[] pacs) { + return this.doMultipleModifications(mod, pacs, this::addPackage); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/containers/IPackageInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/containers/IPackageInitialiser.java new file mode 100644 index 0000000000..a7e605cbf5 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/containers/IPackageInitialiser.java @@ -0,0 +1,54 @@ +package cipm.consistency.initialisers.jamopp.containers; + +import org.emftext.language.java.classifiers.ConcreteClassifier; +import org.emftext.language.java.commons.NamedElement; +import org.emftext.language.java.containers.Module; +import org.emftext.language.java.containers.Package; + +import cipm.consistency.initialisers.jamopp.references.IReferenceableElementInitialiser; + +/** + * An interface meant to be implemented by {@link IInitialiser} implementors + * that are supposed to create {@link Package} instances.
+ *
+ * Note: Package names {@code package.getName()} is supposed to be left + * empty. Changing it HAS NO EFFECT on the name of the package in similarity + * checking. Package's name consists of the concatenation of its namespaces with + * dots ".". Therefore, use + * {@link #addNamespace(org.emftext.language.java.commons.NamespaceAwareElement, String)} + * to modify its name. + * + * @author Alp Torac Genc + */ +public interface IPackageInitialiser extends IJavaRootInitialiser, IReferenceableElementInitialiser { + @Override + public Package instantiate(); + + /** + * @return False, because the return value of {@code package.getName()} is + * determined by the namespaces of the package instead. + * + * @see {@link IPackageInitialiser} + */ + @Override + public default boolean canSetName(NamedElement ne) { + return false; + } + + public default boolean setModule(Package pac, Module mod) { + pac.setModule(mod); + return (mod == null && pac.getModule() == null) || pac.getModule().equals(mod); + } + + public default boolean addClassifier(Package pac, ConcreteClassifier cls) { + if (cls != null) { + pac.getClassifiers().add(cls); + return pac.getClassifiers().contains(cls); + } + return true; + } + + public default boolean addClassifiers(Package pac, ConcreteClassifier[] clss) { + return this.doMultipleModifications(pac, clss, this::addClassifier); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/containers/ModuleInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/containers/ModuleInitialiser.java new file mode 100644 index 0000000000..b3fae657d8 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/containers/ModuleInitialiser.java @@ -0,0 +1,19 @@ +package cipm.consistency.initialisers.jamopp.containers; + +import org.emftext.language.java.containers.ContainersFactory; +import org.emftext.language.java.containers.Module; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class ModuleInitialiser extends AbstractInitialiserBase implements IModuleInitialiser { + @Override + public Module instantiate() { + var fac = ContainersFactory.eINSTANCE; + return fac.createModule(); + } + + @Override + public IModuleInitialiser newInitialiser() { + return new ModuleInitialiser(); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/containers/PackageInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/containers/PackageInitialiser.java new file mode 100644 index 0000000000..d7703c1dc0 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/containers/PackageInitialiser.java @@ -0,0 +1,19 @@ +package cipm.consistency.initialisers.jamopp.containers; + +import org.emftext.language.java.containers.ContainersFactory; +import org.emftext.language.java.containers.Package; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class PackageInitialiser extends AbstractInitialiserBase implements IPackageInitialiser { + @Override + public Package instantiate() { + var fac = ContainersFactory.eINSTANCE; + return fac.createPackage(); + } + + @Override + public IPackageInitialiser newInitialiser() { + return new PackageInitialiser(); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/containers/package-info.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/containers/package-info.java new file mode 100644 index 0000000000..38e5ae774d --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/containers/package-info.java @@ -0,0 +1,5 @@ +/** + * Contains {@link IInitialiser} implementations for + * {@link org.emftext.language.java.containers}. + */ +package cipm.consistency.initialisers.jamopp.containers; \ No newline at end of file From 29b158f9b9a2ae63857b0c622d5eff3b0d3559d0 Mon Sep 17 00:00:00 2001 From: AlpTorac Date: Fri, 25 Oct 2024 17:36:01 +0200 Subject: [PATCH 17/55] (WIP) Implement initialiser package for org.emftext.language.java.expressions --- .../AdditiveExpressionInitialiser.java | 19 +++++++ .../expressions/AndExpressionInitialiser.java | 18 +++++++ ...tructorReferenceExpressionInitialiser.java | 19 +++++++ .../AssignmentExpressionInitialiser.java | 20 +++++++ .../CastExpressionInitialiser.java | 18 +++++++ ...tructorReferenceExpressionInitialiser.java | 19 +++++++ .../ConditionalAndExpressionInitialiser.java | 19 +++++++ .../ConditionalExpressionInitialiser.java | 19 +++++++ .../ConditionalOrExpressionInitialiser.java | 19 +++++++ .../EqualityExpressionInitialiser.java | 18 +++++++ .../ExclusiveOrExpressionInitialiser.java | 19 +++++++ ...citlyTypedLambdaParametersInitialiser.java | 19 +++++++ .../ExpressionListInitialiser.java | 18 +++++++ .../ExpressionsInitialiserPackage.java | 54 +++++++++++++++++++ .../IAdditiveExpressionChildInitialiser.java | 9 ++++ .../IAdditiveExpressionInitialiser.java | 34 ++++++++++++ .../IAndExpressionChildInitialiser.java | 9 ++++ .../IAndExpressionInitialiser.java | 21 ++++++++ ...tructorReferenceExpressionInitialiser.java | 11 ++++ ...IAssignmentExpressionChildInitialiser.java | 10 ++++ .../IAssignmentExpressionInitialiser.java | 26 +++++++++ .../ICastExpressionInitialiser.java | 49 +++++++++++++++++ ...tructorReferenceExpressionInitialiser.java | 12 +++++ ...ditionalAndExpressionChildInitialiser.java | 9 ++++ .../IConditionalAndExpressionInitialiser.java | 21 ++++++++ ...ConditionalExpressionChildInitialiser.java | 9 ++++ .../IConditionalExpressionInitialiser.java | 32 +++++++++++ ...nditionalOrExpressionChildInitialiser.java | 9 ++++ .../IConditionalOrExpressionInitialiser.java | 21 ++++++++ .../IEqualityExpressionChildInitialiser.java | 9 ++++ .../IEqualityExpressionInitialiser.java | 34 ++++++++++++ ...ExclusiveOrExpressionChildInitialiser.java | 9 ++++ .../IExclusiveOrExpressionInitialiser.java | 21 ++++++++ ...citlyTypedLambdaParametersInitialiser.java | 8 +++ .../expressions/IExpressionInitialiser.java | 10 ++++ .../IExpressionListInitialiser.java | 23 ++++++++ ...citlyTypedLambdaParametersInitialiser.java | 8 +++ ...InclusiveOrExpressionChildInitialiser.java | 9 ++++ .../IInclusiveOrExpressionInitialiser.java | 21 ++++++++ ...IInstanceOfExpressionChildInitialiser.java | 9 ++++ .../IInstanceOfExpressionInitialiser.java | 17 ++++++ .../expressions/ILambdaBodyInitialiser.java | 11 ++++ .../ILambdaExpressionInitialiser.java | 20 +++++++ .../ILambdaParametersInitialiser.java | 11 ++++ ...odReferenceExpressionChildInitialiser.java | 9 ++++ ...IMethodReferenceExpressionInitialiser.java | 9 ++++ ...tiplicativeExpressionChildInitialiser.java | 9 ++++ .../IMultiplicativeExpressionInitialiser.java | 34 ++++++++++++ .../INestedExpressionInitialiser.java | 16 ++++++ ...naryModificationExpressionInitialiser.java | 9 ++++ .../IPrimaryExpressionInitialiser.java | 9 ++++ ...ressionReferenceExpressionInitialiser.java | 23 ++++++++ .../IRelationExpressionChildInitialiser.java | 9 ++++ .../IRelationExpressionInitialiser.java | 34 ++++++++++++ .../IShiftExpressionChildInitialiser.java | 9 ++++ .../IShiftExpressionInitialiser.java | 34 ++++++++++++ ...gleImplicitLambdaParameterInitialiser.java | 8 +++ ...naryModificationExpressionInitialiser.java | 9 ++++ .../IUnaryExpressionChildInitialiser.java | 9 ++++ .../IUnaryExpressionInitialiser.java | 27 ++++++++++ ...odificationExpressionChildInitialiser.java | 9 ++++ ...naryModificationExpressionInitialiser.java | 20 +++++++ ...citlyTypedLambdaParametersInitialiser.java | 19 +++++++ .../InclusiveOrExpressionInitialiser.java | 19 +++++++ .../InstanceOfExpressionInitialiser.java | 19 +++++++ .../LambdaExpressionInitialiser.java | 20 +++++++ .../MultiplicativeExpressionInitialiser.java | 19 +++++++ .../NestedExpressionInitialiser.java | 18 +++++++ ...naryModificationExpressionInitialiser.java | 19 +++++++ ...ressionReferenceExpressionInitialiser.java | 19 +++++++ .../RelationExpressionInitialiser.java | 18 +++++++ .../ShiftExpressionInitialiser.java | 18 +++++++ ...gleImplicitLambdaParameterInitialiser.java | 19 +++++++ ...naryModificationExpressionInitialiser.java | 19 +++++++ .../UnaryExpressionInitialiser.java | 18 +++++++ .../jamopp/expressions/package-info.java | 5 ++ 76 files changed, 1335 insertions(+) create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/AdditiveExpressionInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/AndExpressionInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/ArrayConstructorReferenceExpressionInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/AssignmentExpressionInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/CastExpressionInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/ClassTypeConstructorReferenceExpressionInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/ConditionalAndExpressionInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/ConditionalExpressionInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/ConditionalOrExpressionInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/EqualityExpressionInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/ExclusiveOrExpressionInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/ExplicitlyTypedLambdaParametersInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/ExpressionListInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/ExpressionsInitialiserPackage.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IAdditiveExpressionChildInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IAdditiveExpressionInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IAndExpressionChildInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IAndExpressionInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IArrayConstructorReferenceExpressionInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IAssignmentExpressionChildInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IAssignmentExpressionInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/ICastExpressionInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IClassTypeConstructorReferenceExpressionInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IConditionalAndExpressionChildInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IConditionalAndExpressionInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IConditionalExpressionChildInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IConditionalExpressionInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IConditionalOrExpressionChildInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IConditionalOrExpressionInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IEqualityExpressionChildInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IEqualityExpressionInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IExclusiveOrExpressionChildInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IExclusiveOrExpressionInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IExplicitlyTypedLambdaParametersInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IExpressionInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IExpressionListInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IImplicitlyTypedLambdaParametersInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IInclusiveOrExpressionChildInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IInclusiveOrExpressionInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IInstanceOfExpressionChildInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IInstanceOfExpressionInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/ILambdaBodyInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/ILambdaExpressionInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/ILambdaParametersInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IMethodReferenceExpressionChildInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IMethodReferenceExpressionInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IMultiplicativeExpressionChildInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IMultiplicativeExpressionInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/INestedExpressionInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IPrefixUnaryModificationExpressionInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IPrimaryExpressionInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IPrimaryExpressionReferenceExpressionInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IRelationExpressionChildInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IRelationExpressionInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IShiftExpressionChildInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IShiftExpressionInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/ISingleImplicitLambdaParameterInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/ISuffixUnaryModificationExpressionInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IUnaryExpressionChildInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IUnaryExpressionInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IUnaryModificationExpressionChildInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IUnaryModificationExpressionInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/ImplicitlyTypedLambdaParametersInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/InclusiveOrExpressionInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/InstanceOfExpressionInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/LambdaExpressionInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/MultiplicativeExpressionInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/NestedExpressionInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/PrefixUnaryModificationExpressionInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/PrimaryExpressionReferenceExpressionInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/RelationExpressionInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/ShiftExpressionInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/SingleImplicitLambdaParameterInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/SuffixUnaryModificationExpressionInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/UnaryExpressionInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/package-info.java diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/AdditiveExpressionInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/AdditiveExpressionInitialiser.java new file mode 100644 index 0000000000..ff852e645e --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/AdditiveExpressionInitialiser.java @@ -0,0 +1,19 @@ +package cipm.consistency.initialisers.jamopp.expressions; + +import org.emftext.language.java.expressions.ExpressionsFactory; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +import org.emftext.language.java.expressions.AdditiveExpression; + +public class AdditiveExpressionInitialiser extends AbstractInitialiserBase implements IAdditiveExpressionInitialiser { + @Override + public IAdditiveExpressionInitialiser newInitialiser() { + return new AdditiveExpressionInitialiser(); + } + + @Override + public AdditiveExpression instantiate() { + return ExpressionsFactory.eINSTANCE.createAdditiveExpression(); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/AndExpressionInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/AndExpressionInitialiser.java new file mode 100644 index 0000000000..2aea4bd856 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/AndExpressionInitialiser.java @@ -0,0 +1,18 @@ +package cipm.consistency.initialisers.jamopp.expressions; + +import org.emftext.language.java.expressions.AndExpression; +import org.emftext.language.java.expressions.ExpressionsFactory; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class AndExpressionInitialiser extends AbstractInitialiserBase implements IAndExpressionInitialiser { + @Override + public IAndExpressionInitialiser newInitialiser() { + return new AndExpressionInitialiser(); + } + + @Override + public AndExpression instantiate() { + return ExpressionsFactory.eINSTANCE.createAndExpression(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/ArrayConstructorReferenceExpressionInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/ArrayConstructorReferenceExpressionInitialiser.java new file mode 100644 index 0000000000..d93075cbea --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/ArrayConstructorReferenceExpressionInitialiser.java @@ -0,0 +1,19 @@ +package cipm.consistency.initialisers.jamopp.expressions; + +import org.emftext.language.java.expressions.ArrayConstructorReferenceExpression; +import org.emftext.language.java.expressions.ExpressionsFactory; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class ArrayConstructorReferenceExpressionInitialiser extends AbstractInitialiserBase + implements IArrayConstructorReferenceExpressionInitialiser { + @Override + public IArrayConstructorReferenceExpressionInitialiser newInitialiser() { + return new ArrayConstructorReferenceExpressionInitialiser(); + } + + @Override + public ArrayConstructorReferenceExpression instantiate() { + return ExpressionsFactory.eINSTANCE.createArrayConstructorReferenceExpression(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/AssignmentExpressionInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/AssignmentExpressionInitialiser.java new file mode 100644 index 0000000000..128b436f8f --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/AssignmentExpressionInitialiser.java @@ -0,0 +1,20 @@ +package cipm.consistency.initialisers.jamopp.expressions; + +import org.emftext.language.java.expressions.ExpressionsFactory; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +import org.emftext.language.java.expressions.AssignmentExpression; + +public class AssignmentExpressionInitialiser extends AbstractInitialiserBase + implements IAssignmentExpressionInitialiser { + @Override + public IAssignmentExpressionInitialiser newInitialiser() { + return new AssignmentExpressionInitialiser(); + } + + @Override + public AssignmentExpression instantiate() { + return ExpressionsFactory.eINSTANCE.createAssignmentExpression(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/CastExpressionInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/CastExpressionInitialiser.java new file mode 100644 index 0000000000..d92d254e8a --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/CastExpressionInitialiser.java @@ -0,0 +1,18 @@ +package cipm.consistency.initialisers.jamopp.expressions; + +import org.emftext.language.java.expressions.CastExpression; +import org.emftext.language.java.expressions.ExpressionsFactory; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class CastExpressionInitialiser extends AbstractInitialiserBase implements ICastExpressionInitialiser { + @Override + public ICastExpressionInitialiser newInitialiser() { + return new CastExpressionInitialiser(); + } + + @Override + public CastExpression instantiate() { + return ExpressionsFactory.eINSTANCE.createCastExpression(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/ClassTypeConstructorReferenceExpressionInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/ClassTypeConstructorReferenceExpressionInitialiser.java new file mode 100644 index 0000000000..79ac600d35 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/ClassTypeConstructorReferenceExpressionInitialiser.java @@ -0,0 +1,19 @@ +package cipm.consistency.initialisers.jamopp.expressions; + +import org.emftext.language.java.expressions.ClassTypeConstructorReferenceExpression; +import org.emftext.language.java.expressions.ExpressionsFactory; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class ClassTypeConstructorReferenceExpressionInitialiser extends AbstractInitialiserBase + implements IClassTypeConstructorReferenceExpressionInitialiser { + @Override + public IClassTypeConstructorReferenceExpressionInitialiser newInitialiser() { + return new ClassTypeConstructorReferenceExpressionInitialiser(); + } + + @Override + public ClassTypeConstructorReferenceExpression instantiate() { + return ExpressionsFactory.eINSTANCE.createClassTypeConstructorReferenceExpression(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/ConditionalAndExpressionInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/ConditionalAndExpressionInitialiser.java new file mode 100644 index 0000000000..00db270c26 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/ConditionalAndExpressionInitialiser.java @@ -0,0 +1,19 @@ +package cipm.consistency.initialisers.jamopp.expressions; + +import org.emftext.language.java.expressions.ConditionalAndExpression; +import org.emftext.language.java.expressions.ExpressionsFactory; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class ConditionalAndExpressionInitialiser extends AbstractInitialiserBase + implements IConditionalAndExpressionInitialiser { + @Override + public IConditionalAndExpressionInitialiser newInitialiser() { + return new ConditionalAndExpressionInitialiser(); + } + + @Override + public ConditionalAndExpression instantiate() { + return ExpressionsFactory.eINSTANCE.createConditionalAndExpression(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/ConditionalExpressionInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/ConditionalExpressionInitialiser.java new file mode 100644 index 0000000000..4f49051bf7 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/ConditionalExpressionInitialiser.java @@ -0,0 +1,19 @@ +package cipm.consistency.initialisers.jamopp.expressions; + +import org.emftext.language.java.expressions.ConditionalExpression; +import org.emftext.language.java.expressions.ExpressionsFactory; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class ConditionalExpressionInitialiser extends AbstractInitialiserBase + implements IConditionalExpressionInitialiser { + @Override + public IConditionalExpressionInitialiser newInitialiser() { + return new ConditionalExpressionInitialiser(); + } + + @Override + public ConditionalExpression instantiate() { + return ExpressionsFactory.eINSTANCE.createConditionalExpression(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/ConditionalOrExpressionInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/ConditionalOrExpressionInitialiser.java new file mode 100644 index 0000000000..5fd7e9b375 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/ConditionalOrExpressionInitialiser.java @@ -0,0 +1,19 @@ +package cipm.consistency.initialisers.jamopp.expressions; + +import org.emftext.language.java.expressions.ConditionalOrExpression; +import org.emftext.language.java.expressions.ExpressionsFactory; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class ConditionalOrExpressionInitialiser extends AbstractInitialiserBase + implements IConditionalOrExpressionInitialiser { + @Override + public IConditionalOrExpressionInitialiser newInitialiser() { + return new ConditionalOrExpressionInitialiser(); + } + + @Override + public ConditionalOrExpression instantiate() { + return ExpressionsFactory.eINSTANCE.createConditionalOrExpression(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/EqualityExpressionInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/EqualityExpressionInitialiser.java new file mode 100644 index 0000000000..8658bbe0e2 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/EqualityExpressionInitialiser.java @@ -0,0 +1,18 @@ +package cipm.consistency.initialisers.jamopp.expressions; + +import org.emftext.language.java.expressions.EqualityExpression; +import org.emftext.language.java.expressions.ExpressionsFactory; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class EqualityExpressionInitialiser extends AbstractInitialiserBase implements IEqualityExpressionInitialiser { + @Override + public IEqualityExpressionInitialiser newInitialiser() { + return new EqualityExpressionInitialiser(); + } + + @Override + public EqualityExpression instantiate() { + return ExpressionsFactory.eINSTANCE.createEqualityExpression(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/ExclusiveOrExpressionInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/ExclusiveOrExpressionInitialiser.java new file mode 100644 index 0000000000..81695281a5 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/ExclusiveOrExpressionInitialiser.java @@ -0,0 +1,19 @@ +package cipm.consistency.initialisers.jamopp.expressions; + +import org.emftext.language.java.expressions.ExclusiveOrExpression; +import org.emftext.language.java.expressions.ExpressionsFactory; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class ExclusiveOrExpressionInitialiser extends AbstractInitialiserBase + implements IExclusiveOrExpressionInitialiser { + @Override + public IExclusiveOrExpressionInitialiser newInitialiser() { + return new ExclusiveOrExpressionInitialiser(); + } + + @Override + public ExclusiveOrExpression instantiate() { + return ExpressionsFactory.eINSTANCE.createExclusiveOrExpression(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/ExplicitlyTypedLambdaParametersInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/ExplicitlyTypedLambdaParametersInitialiser.java new file mode 100644 index 0000000000..7de0a674fb --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/ExplicitlyTypedLambdaParametersInitialiser.java @@ -0,0 +1,19 @@ +package cipm.consistency.initialisers.jamopp.expressions; + +import org.emftext.language.java.expressions.ExplicitlyTypedLambdaParameters; +import org.emftext.language.java.expressions.ExpressionsFactory; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class ExplicitlyTypedLambdaParametersInitialiser extends AbstractInitialiserBase + implements IExplicitlyTypedLambdaParametersInitialiser { + @Override + public IExplicitlyTypedLambdaParametersInitialiser newInitialiser() { + return new ExplicitlyTypedLambdaParametersInitialiser(); + } + + @Override + public ExplicitlyTypedLambdaParameters instantiate() { + return ExpressionsFactory.eINSTANCE.createExplicitlyTypedLambdaParameters(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/ExpressionListInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/ExpressionListInitialiser.java new file mode 100644 index 0000000000..26697a7211 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/ExpressionListInitialiser.java @@ -0,0 +1,18 @@ +package cipm.consistency.initialisers.jamopp.expressions; + +import org.emftext.language.java.expressions.ExpressionList; +import org.emftext.language.java.expressions.ExpressionsFactory; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class ExpressionListInitialiser extends AbstractInitialiserBase implements IExpressionListInitialiser { + @Override + public IExpressionListInitialiser newInitialiser() { + return new ExpressionListInitialiser(); + } + + @Override + public ExpressionList instantiate() { + return ExpressionsFactory.eINSTANCE.createExpressionList(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/ExpressionsInitialiserPackage.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/ExpressionsInitialiserPackage.java new file mode 100644 index 0000000000..73461eb5aa --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/ExpressionsInitialiserPackage.java @@ -0,0 +1,54 @@ +package cipm.consistency.initialisers.jamopp.expressions; + +import java.util.Collection; + +import cipm.consistency.initialisers.IInitialiser; +import cipm.consistency.initialisers.IInitialiserPackage; + +public class ExpressionsInitialiserPackage implements IInitialiserPackage { + @Override + public Collection getInitialiserInstances() { + return this.initCol(new IInitialiser[] { new AdditiveExpressionInitialiser(), new AndExpressionInitialiser(), + new ArrayConstructorReferenceExpressionInitialiser(), new AssignmentExpressionInitialiser(), + new CastExpressionInitialiser(), new ClassTypeConstructorReferenceExpressionInitialiser(), + new ConditionalAndExpressionInitialiser(), new ConditionalExpressionInitialiser(), + new ConditionalOrExpressionInitialiser(), new EqualityExpressionInitialiser(), + new ExclusiveOrExpressionInitialiser(), new ExplicitlyTypedLambdaParametersInitialiser(), + new ExpressionListInitialiser(), new ImplicitlyTypedLambdaParametersInitialiser(), + new InclusiveOrExpressionInitialiser(), new InstanceOfExpressionInitialiser(), + new LambdaExpressionInitialiser(), new MultiplicativeExpressionInitialiser(), + new NestedExpressionInitialiser(), new PrefixUnaryModificationExpressionInitialiser(), + new PrimaryExpressionReferenceExpressionInitialiser(), new RelationExpressionInitialiser(), + new ShiftExpressionInitialiser(), new SingleImplicitLambdaParameterInitialiser(), + new SuffixUnaryModificationExpressionInitialiser(), new UnaryExpressionInitialiser(), }); + } + + @SuppressWarnings("unchecked") + @Override + public Collection> getInitialiserInterfaceTypes() { + return this.initCol(new Class[] { IAdditiveExpressionChildInitialiser.class, + IAdditiveExpressionInitialiser.class, IAndExpressionChildInitialiser.class, + IAndExpressionInitialiser.class, IArrayConstructorReferenceExpressionInitialiser.class, + IAssignmentExpressionChildInitialiser.class, IAssignmentExpressionInitialiser.class, + ICastExpressionInitialiser.class, IClassTypeConstructorReferenceExpressionInitialiser.class, + IConditionalAndExpressionChildInitialiser.class, IConditionalAndExpressionInitialiser.class, + IConditionalExpressionChildInitialiser.class, IConditionalExpressionInitialiser.class, + IConditionalOrExpressionChildInitialiser.class, IConditionalOrExpressionInitialiser.class, + IEqualityExpressionChildInitialiser.class, IEqualityExpressionInitialiser.class, + IExclusiveOrExpressionChildInitialiser.class, IExclusiveOrExpressionInitialiser.class, + IExplicitlyTypedLambdaParametersInitialiser.class, IExpressionInitialiser.class, + IExpressionListInitialiser.class, IImplicitlyTypedLambdaParametersInitialiser.class, + IInclusiveOrExpressionChildInitialiser.class, IInclusiveOrExpressionInitialiser.class, + IInstanceOfExpressionChildInitialiser.class, IInstanceOfExpressionInitialiser.class, + ILambdaBodyInitialiser.class, ILambdaExpressionInitialiser.class, ILambdaParametersInitialiser.class, + IMethodReferenceExpressionChildInitialiser.class, IMethodReferenceExpressionInitialiser.class, + IMultiplicativeExpressionChildInitialiser.class, IMultiplicativeExpressionInitialiser.class, + INestedExpressionInitialiser.class, IPrefixUnaryModificationExpressionInitialiser.class, + IPrimaryExpressionInitialiser.class, IPrimaryExpressionReferenceExpressionInitialiser.class, + IRelationExpressionChildInitialiser.class, IRelationExpressionInitialiser.class, + IShiftExpressionChildInitialiser.class, IShiftExpressionInitialiser.class, + ISingleImplicitLambdaParameterInitialiser.class, ISuffixUnaryModificationExpressionInitialiser.class, + IUnaryExpressionChildInitialiser.class, IUnaryExpressionInitialiser.class, + IUnaryModificationExpressionChildInitialiser.class, IUnaryModificationExpressionInitialiser.class, }); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IAdditiveExpressionChildInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IAdditiveExpressionChildInitialiser.java new file mode 100644 index 0000000000..979101f307 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IAdditiveExpressionChildInitialiser.java @@ -0,0 +1,9 @@ +package cipm.consistency.initialisers.jamopp.expressions; + +import org.emftext.language.java.expressions.AdditiveExpressionChild; + +public interface IAdditiveExpressionChildInitialiser extends IShiftExpressionChildInitialiser { + @Override + public AdditiveExpressionChild instantiate(); + +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IAdditiveExpressionInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IAdditiveExpressionInitialiser.java new file mode 100644 index 0000000000..169acc2732 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IAdditiveExpressionInitialiser.java @@ -0,0 +1,34 @@ +package cipm.consistency.initialisers.jamopp.expressions; + +import org.emftext.language.java.expressions.AdditiveExpression; +import org.emftext.language.java.expressions.AdditiveExpressionChild; +import org.emftext.language.java.operators.AdditiveOperator; + +public interface IAdditiveExpressionInitialiser extends IShiftExpressionChildInitialiser { + @Override + public AdditiveExpression instantiate(); + + public default boolean addAdditiveOperator(AdditiveExpression ae, AdditiveOperator op) { + if (op != null) { + ae.getAdditiveOperators().add(op); + return ae.getAdditiveOperators().contains(op); + } + return true; + } + + public default boolean addAdditiveOperators(AdditiveExpression ae, AdditiveOperator[] ops) { + return this.doMultipleModifications(ae, ops, this::addAdditiveOperator); + } + + public default boolean addChild(AdditiveExpression ae, AdditiveExpressionChild child) { + if (child != null) { + ae.getChildren().add(child); + return ae.getChildren().contains(child); + } + return true; + } + + public default boolean addChildren(AdditiveExpression ae, AdditiveExpressionChild[] children) { + return this.doMultipleModifications(ae, children, this::addChild); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IAndExpressionChildInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IAndExpressionChildInitialiser.java new file mode 100644 index 0000000000..a7343a1151 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IAndExpressionChildInitialiser.java @@ -0,0 +1,9 @@ +package cipm.consistency.initialisers.jamopp.expressions; + +import org.emftext.language.java.expressions.AndExpressionChild; + +public interface IAndExpressionChildInitialiser extends IExclusiveOrExpressionChildInitialiser { + @Override + public AndExpressionChild instantiate(); + +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IAndExpressionInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IAndExpressionInitialiser.java new file mode 100644 index 0000000000..2b7f69aa32 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IAndExpressionInitialiser.java @@ -0,0 +1,21 @@ +package cipm.consistency.initialisers.jamopp.expressions; + +import org.emftext.language.java.expressions.AndExpression; +import org.emftext.language.java.expressions.AndExpressionChild; + +public interface IAndExpressionInitialiser extends IExclusiveOrExpressionChildInitialiser { + @Override + public AndExpression instantiate(); + + public default boolean addChild(AndExpression ae, AndExpressionChild child) { + if (child != null) { + ae.getChildren().add(child); + return ae.getChildren().contains(child); + } + return true; + } + + public default boolean addChildren(AndExpression ae, AndExpressionChild[] children) { + return this.doMultipleModifications(ae, children, this::addChild); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IArrayConstructorReferenceExpressionInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IArrayConstructorReferenceExpressionInitialiser.java new file mode 100644 index 0000000000..8a6367ab26 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IArrayConstructorReferenceExpressionInitialiser.java @@ -0,0 +1,11 @@ +package cipm.consistency.initialisers.jamopp.expressions; + +import org.emftext.language.java.expressions.ArrayConstructorReferenceExpression; + +import cipm.consistency.initialisers.jamopp.types.ITypedElementInitialiser; + +public interface IArrayConstructorReferenceExpressionInitialiser + extends IMethodReferenceExpressionInitialiser, ITypedElementInitialiser { + @Override + public ArrayConstructorReferenceExpression instantiate(); +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IAssignmentExpressionChildInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IAssignmentExpressionChildInitialiser.java new file mode 100644 index 0000000000..1b8e2f5928 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IAssignmentExpressionChildInitialiser.java @@ -0,0 +1,10 @@ +package cipm.consistency.initialisers.jamopp.expressions; + +import org.emftext.language.java.expressions.AssignmentExpressionChild; + +import cipm.consistency.initialisers.jamopp.annotations.IAnnotationValueInitialiser; + +public interface IAssignmentExpressionChildInitialiser extends IAnnotationValueInitialiser, IExpressionInitialiser { + @Override + public AssignmentExpressionChild instantiate(); +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IAssignmentExpressionInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IAssignmentExpressionInitialiser.java new file mode 100644 index 0000000000..89fbd8b5b5 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IAssignmentExpressionInitialiser.java @@ -0,0 +1,26 @@ +package cipm.consistency.initialisers.jamopp.expressions; + +import org.emftext.language.java.expressions.AssignmentExpression; +import org.emftext.language.java.expressions.AssignmentExpressionChild; +import org.emftext.language.java.expressions.Expression; +import org.emftext.language.java.operators.AssignmentOperator; + +public interface IAssignmentExpressionInitialiser extends IExpressionInitialiser { + @Override + public AssignmentExpression instantiate(); + + public default boolean setAssignmentOperator(AssignmentExpression ae, AssignmentOperator op) { + ae.setAssignmentOperator(op); + return (op == null && ae.getAssignmentOperator() == null) || ae.getAssignmentOperator().equals(op); + } + + public default boolean setChild(AssignmentExpression ae, AssignmentExpressionChild child) { + ae.setChild(child); + return (child == null && ae.getChild() == null) || ae.getChild().equals(child); + } + + public default boolean setValue(AssignmentExpression ae, Expression val) { + ae.setValue(val); + return (val == null && ae.getValue() == null) || ae.getValue().equals(val); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/ICastExpressionInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/ICastExpressionInitialiser.java new file mode 100644 index 0000000000..c77cfb6296 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/ICastExpressionInitialiser.java @@ -0,0 +1,49 @@ +package cipm.consistency.initialisers.jamopp.expressions; + +import org.emftext.language.java.expressions.CastExpression; +import org.emftext.language.java.expressions.MultiplicativeExpressionChild; +import org.emftext.language.java.types.TypeReference; + +import cipm.consistency.initialisers.jamopp.types.ITypedElementInitialiser; + +/** + * An interface meant to be implemented by initialisers, which are supposed to + * create {@link CastExpression} instances.
+ *
+ * For a {@link CastExpression} instance ce, {@code ce.getChild()} has the same + * return value as {@code ce.getGeneralChild()}, it merely returns the child + * attribute as {@link Expression} rather than + * {@link MultiplicativeExpressionChild}.
+ *
+ * Similarly, {@code ce.setGeneralChild(...)} is equivalent to + * {@code ce.setChild(...)}, just with a more general parameter type. + * + * @author Alp Torac Genc + */ +public interface ICastExpressionInitialiser + extends ITypedElementInitialiser, IUnaryModificationExpressionChildInitialiser { + @Override + public CastExpression instantiate(); + + public default boolean addAdditionalBound(CastExpression ce, TypeReference additionalBounds) { + if (additionalBounds != null) { + ce.getAdditionalBounds().add(additionalBounds); + return ce.getAdditionalBounds().contains(additionalBounds); + } + return true; + } + + public default boolean addAdditionalBounds(CastExpression ce, TypeReference[] additionalBoundsArr) { + return this.doMultipleModifications(ce, additionalBoundsArr, this::addAdditionalBound); + } + + /** + * Adds the given child to ce. Uses {@code ce.setChild(...)} to do so. + * + * @see {@link ICastExpressionInitialiser} + */ + public default boolean setChild(CastExpression ce, MultiplicativeExpressionChild child) { + ce.setChild(child); + return (child == null && ce.getChild() == null) || ce.getChild().equals(child); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IClassTypeConstructorReferenceExpressionInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IClassTypeConstructorReferenceExpressionInitialiser.java new file mode 100644 index 0000000000..9f3c882f1b --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IClassTypeConstructorReferenceExpressionInitialiser.java @@ -0,0 +1,12 @@ +package cipm.consistency.initialisers.jamopp.expressions; + +import org.emftext.language.java.expressions.ClassTypeConstructorReferenceExpression; + +import cipm.consistency.initialisers.jamopp.generics.ICallTypeArgumentableInitialiser; +import cipm.consistency.initialisers.jamopp.types.ITypedElementInitialiser; + +public interface IClassTypeConstructorReferenceExpressionInitialiser + extends ICallTypeArgumentableInitialiser, IMethodReferenceExpressionInitialiser, ITypedElementInitialiser { + @Override + public ClassTypeConstructorReferenceExpression instantiate(); +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IConditionalAndExpressionChildInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IConditionalAndExpressionChildInitialiser.java new file mode 100644 index 0000000000..3386c67b3e --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IConditionalAndExpressionChildInitialiser.java @@ -0,0 +1,9 @@ +package cipm.consistency.initialisers.jamopp.expressions; + +import org.emftext.language.java.expressions.ConditionalAndExpressionChild; + +public interface IConditionalAndExpressionChildInitialiser extends IConditionalOrExpressionChildInitialiser { + @Override + public ConditionalAndExpressionChild instantiate(); + +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IConditionalAndExpressionInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IConditionalAndExpressionInitialiser.java new file mode 100644 index 0000000000..6cfc77f3b1 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IConditionalAndExpressionInitialiser.java @@ -0,0 +1,21 @@ +package cipm.consistency.initialisers.jamopp.expressions; + +import org.emftext.language.java.expressions.ConditionalAndExpression; +import org.emftext.language.java.expressions.ConditionalAndExpressionChild; + +public interface IConditionalAndExpressionInitialiser extends IConditionalOrExpressionChildInitialiser { + @Override + public ConditionalAndExpression instantiate(); + + public default boolean addChild(ConditionalAndExpression cae, ConditionalAndExpressionChild child) { + if (child != null) { + cae.getChildren().add(child); + return cae.getChildren().contains(child); + } + return true; + } + + public default boolean addChildren(ConditionalAndExpression cae, ConditionalAndExpressionChild[] children) { + return this.doMultipleModifications(cae, children, this::addChild); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IConditionalExpressionChildInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IConditionalExpressionChildInitialiser.java new file mode 100644 index 0000000000..6ae4d3b1cc --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IConditionalExpressionChildInitialiser.java @@ -0,0 +1,9 @@ +package cipm.consistency.initialisers.jamopp.expressions; + +import org.emftext.language.java.expressions.ConditionalExpressionChild; + +public interface IConditionalExpressionChildInitialiser extends IAssignmentExpressionChildInitialiser { + @Override + public ConditionalExpressionChild instantiate(); + +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IConditionalExpressionInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IConditionalExpressionInitialiser.java new file mode 100644 index 0000000000..00f51ddb77 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IConditionalExpressionInitialiser.java @@ -0,0 +1,32 @@ +package cipm.consistency.initialisers.jamopp.expressions; + +import org.emftext.language.java.expressions.AssignmentExpressionChild; +import org.emftext.language.java.expressions.ConditionalExpression; +import org.emftext.language.java.expressions.ConditionalExpressionChild; +import org.emftext.language.java.expressions.Expression; + +public interface IConditionalExpressionInitialiser extends IAssignmentExpressionChildInitialiser { + @Override + public ConditionalExpression instantiate(); + + public default boolean setChild(ConditionalExpression ce, ConditionalExpressionChild child) { + ce.setChild(child); + return (child == null && ce.getChild() == null) || ce.getChild().equals(child); + } + + public default boolean setExpressionChild(ConditionalExpression ce, AssignmentExpressionChild exprChild) { + ce.setExpressionChild(exprChild); + return (exprChild == null && ce.getExpressionElse() == null) || ce.getExpressionElse().equals(exprChild); + } + + public default boolean setExpressionIf(ConditionalExpression ce, Expression exprIf) { + ce.setExpressionIf(exprIf); + return (exprIf == null && ce.getExpressionIf() == null) || ce.getExpressionIf().equals(exprIf); + } + + public default boolean setGeneralExpressionElse(ConditionalExpression ce, Expression generalExprElse) { + ce.setGeneralExpressionElse(generalExprElse); + return (generalExprElse == null && ce.getGeneralExpressionElse() == null) + || ce.getGeneralExpressionElse().equals(generalExprElse); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IConditionalOrExpressionChildInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IConditionalOrExpressionChildInitialiser.java new file mode 100644 index 0000000000..52c8f44f9d --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IConditionalOrExpressionChildInitialiser.java @@ -0,0 +1,9 @@ +package cipm.consistency.initialisers.jamopp.expressions; + +import org.emftext.language.java.expressions.ConditionalOrExpressionChild; + +public interface IConditionalOrExpressionChildInitialiser extends IConditionalExpressionChildInitialiser { + @Override + public ConditionalOrExpressionChild instantiate(); + +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IConditionalOrExpressionInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IConditionalOrExpressionInitialiser.java new file mode 100644 index 0000000000..fd5400d256 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IConditionalOrExpressionInitialiser.java @@ -0,0 +1,21 @@ +package cipm.consistency.initialisers.jamopp.expressions; + +import org.emftext.language.java.expressions.ConditionalOrExpression; +import org.emftext.language.java.expressions.ConditionalOrExpressionChild; + +public interface IConditionalOrExpressionInitialiser extends IConditionalExpressionChildInitialiser { + @Override + public ConditionalOrExpression instantiate(); + + public default boolean addChild(ConditionalOrExpression coe, ConditionalOrExpressionChild child) { + if (child != null) { + coe.getChildren().add(child); + return coe.getChildren().contains(child); + } + return true; + } + + public default boolean addChildren(ConditionalOrExpression coe, ConditionalOrExpressionChild[] children) { + return this.doMultipleModifications(coe, children, this::addChild); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IEqualityExpressionChildInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IEqualityExpressionChildInitialiser.java new file mode 100644 index 0000000000..783d40ebf0 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IEqualityExpressionChildInitialiser.java @@ -0,0 +1,9 @@ +package cipm.consistency.initialisers.jamopp.expressions; + +import org.emftext.language.java.expressions.EqualityExpressionChild; + +public interface IEqualityExpressionChildInitialiser extends IAndExpressionChildInitialiser { + @Override + public EqualityExpressionChild instantiate(); + +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IEqualityExpressionInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IEqualityExpressionInitialiser.java new file mode 100644 index 0000000000..f71c43da54 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IEqualityExpressionInitialiser.java @@ -0,0 +1,34 @@ +package cipm.consistency.initialisers.jamopp.expressions; + +import org.emftext.language.java.expressions.EqualityExpression; +import org.emftext.language.java.expressions.EqualityExpressionChild; +import org.emftext.language.java.operators.EqualityOperator; + +public interface IEqualityExpressionInitialiser extends IAndExpressionChildInitialiser { + @Override + public EqualityExpression instantiate(); + + public default boolean addEqualityOperator(EqualityExpression eqEx, EqualityOperator op) { + if (op != null) { + eqEx.getEqualityOperators().add(op); + return eqEx.getEqualityOperators().contains(op); + } + return true; + } + + public default boolean addChild(EqualityExpression eqEx, EqualityExpressionChild child) { + if (child != null) { + eqEx.getChildren().add(child); + return eqEx.getChildren().contains(child); + } + return true; + } + + public default boolean addEqualityOperators(EqualityExpression eqEx, EqualityOperator[] ops) { + return this.doMultipleModifications(eqEx, ops, this::addEqualityOperator); + } + + public default boolean addChildren(EqualityExpression eqEx, EqualityExpressionChild[] children) { + return this.doMultipleModifications(eqEx, children, this::addChild); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IExclusiveOrExpressionChildInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IExclusiveOrExpressionChildInitialiser.java new file mode 100644 index 0000000000..08415382a9 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IExclusiveOrExpressionChildInitialiser.java @@ -0,0 +1,9 @@ +package cipm.consistency.initialisers.jamopp.expressions; + +import org.emftext.language.java.expressions.ExclusiveOrExpressionChild; + +public interface IExclusiveOrExpressionChildInitialiser extends IInclusiveOrExpressionChildInitialiser { + @Override + public ExclusiveOrExpressionChild instantiate(); + +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IExclusiveOrExpressionInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IExclusiveOrExpressionInitialiser.java new file mode 100644 index 0000000000..98fde0fdeb --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IExclusiveOrExpressionInitialiser.java @@ -0,0 +1,21 @@ +package cipm.consistency.initialisers.jamopp.expressions; + +import org.emftext.language.java.expressions.ExclusiveOrExpression; +import org.emftext.language.java.expressions.ExclusiveOrExpressionChild; + +public interface IExclusiveOrExpressionInitialiser extends IInclusiveOrExpressionChildInitialiser { + @Override + public ExclusiveOrExpression instantiate(); + + public default boolean addChild(ExclusiveOrExpression eoe, ExclusiveOrExpressionChild child) { + if (child != null) { + eoe.getChildren().add(child); + return eoe.getChildren().contains(child); + } + return true; + } + + public default boolean addChildren(ExclusiveOrExpression eoe, ExclusiveOrExpressionChild[] children) { + return this.doMultipleModifications(eoe, children, this::addChild); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IExplicitlyTypedLambdaParametersInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IExplicitlyTypedLambdaParametersInitialiser.java new file mode 100644 index 0000000000..34f21301c2 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IExplicitlyTypedLambdaParametersInitialiser.java @@ -0,0 +1,8 @@ +package cipm.consistency.initialisers.jamopp.expressions; + +import org.emftext.language.java.expressions.ExplicitlyTypedLambdaParameters; + +public interface IExplicitlyTypedLambdaParametersInitialiser extends ILambdaParametersInitialiser { + @Override + public ExplicitlyTypedLambdaParameters instantiate(); +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IExpressionInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IExpressionInitialiser.java new file mode 100644 index 0000000000..d9e72faf47 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IExpressionInitialiser.java @@ -0,0 +1,10 @@ +package cipm.consistency.initialisers.jamopp.expressions; + +import org.emftext.language.java.expressions.Expression; + +import cipm.consistency.initialisers.jamopp.arrays.IArrayInitializationValueInitialiser; + +public interface IExpressionInitialiser extends IArrayInitializationValueInitialiser, ILambdaBodyInitialiser { + @Override + public Expression instantiate(); +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IExpressionListInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IExpressionListInitialiser.java new file mode 100644 index 0000000000..cc94f34132 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IExpressionListInitialiser.java @@ -0,0 +1,23 @@ +package cipm.consistency.initialisers.jamopp.expressions; + +import org.emftext.language.java.expressions.Expression; +import org.emftext.language.java.expressions.ExpressionList; + +import cipm.consistency.initialisers.jamopp.statements.IForLoopInitializerInitialiser; + +public interface IExpressionListInitialiser extends IForLoopInitializerInitialiser { + @Override + public ExpressionList instantiate(); + + public default boolean addExpression(ExpressionList exprList, Expression expr) { + if (expr != null) { + exprList.getExpressions().add(expr); + return exprList.getExpressions().contains(expr); + } + return true; + } + + public default boolean addExpressions(ExpressionList exprList, Expression[] exprs) { + return this.doMultipleModifications(exprList, exprs, this::addExpression); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IImplicitlyTypedLambdaParametersInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IImplicitlyTypedLambdaParametersInitialiser.java new file mode 100644 index 0000000000..83f877410a --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IImplicitlyTypedLambdaParametersInitialiser.java @@ -0,0 +1,8 @@ +package cipm.consistency.initialisers.jamopp.expressions; + +import org.emftext.language.java.expressions.ImplicitlyTypedLambdaParameters; + +public interface IImplicitlyTypedLambdaParametersInitialiser extends ILambdaParametersInitialiser { + @Override + public ImplicitlyTypedLambdaParameters instantiate(); +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IInclusiveOrExpressionChildInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IInclusiveOrExpressionChildInitialiser.java new file mode 100644 index 0000000000..934a69644e --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IInclusiveOrExpressionChildInitialiser.java @@ -0,0 +1,9 @@ +package cipm.consistency.initialisers.jamopp.expressions; + +import org.emftext.language.java.expressions.InclusiveOrExpressionChild; + +public interface IInclusiveOrExpressionChildInitialiser extends IConditionalAndExpressionChildInitialiser { + @Override + public InclusiveOrExpressionChild instantiate(); + +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IInclusiveOrExpressionInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IInclusiveOrExpressionInitialiser.java new file mode 100644 index 0000000000..6158dbd89f --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IInclusiveOrExpressionInitialiser.java @@ -0,0 +1,21 @@ +package cipm.consistency.initialisers.jamopp.expressions; + +import org.emftext.language.java.expressions.InclusiveOrExpression; +import org.emftext.language.java.expressions.InclusiveOrExpressionChild; + +public interface IInclusiveOrExpressionInitialiser extends IConditionalAndExpressionChildInitialiser { + @Override + public InclusiveOrExpression instantiate(); + + public default boolean addChild(InclusiveOrExpression ioe, InclusiveOrExpressionChild child) { + if (child != null) { + ioe.getChildren().add(child); + return ioe.getChildren().contains(child); + } + return true; + } + + public default boolean addChildren(InclusiveOrExpression ioe, InclusiveOrExpressionChild[] children) { + return this.doMultipleModifications(ioe, children, this::addChild); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IInstanceOfExpressionChildInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IInstanceOfExpressionChildInitialiser.java new file mode 100644 index 0000000000..dbeb44c250 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IInstanceOfExpressionChildInitialiser.java @@ -0,0 +1,9 @@ +package cipm.consistency.initialisers.jamopp.expressions; + +import org.emftext.language.java.expressions.InstanceOfExpressionChild; + +public interface IInstanceOfExpressionChildInitialiser extends IEqualityExpressionChildInitialiser { + @Override + public InstanceOfExpressionChild instantiate(); + +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IInstanceOfExpressionInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IInstanceOfExpressionInitialiser.java new file mode 100644 index 0000000000..d6fd448497 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IInstanceOfExpressionInitialiser.java @@ -0,0 +1,17 @@ +package cipm.consistency.initialisers.jamopp.expressions; + +import org.emftext.language.java.expressions.InstanceOfExpression; +import org.emftext.language.java.expressions.InstanceOfExpressionChild; + +import cipm.consistency.initialisers.jamopp.types.ITypedElementInitialiser; + +public interface IInstanceOfExpressionInitialiser + extends IEqualityExpressionChildInitialiser, ITypedElementInitialiser { + @Override + public InstanceOfExpression instantiate(); + + public default boolean setChild(InstanceOfExpression ioe, InstanceOfExpressionChild child) { + ioe.setChild(child); + return (child == null && ioe.getChild() == null) || ioe.getChild().equals(child); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/ILambdaBodyInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/ILambdaBodyInitialiser.java new file mode 100644 index 0000000000..d7498f5c9a --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/ILambdaBodyInitialiser.java @@ -0,0 +1,11 @@ +package cipm.consistency.initialisers.jamopp.expressions; + +import org.emftext.language.java.expressions.LambdaBody; + +import cipm.consistency.initialisers.jamopp.commons.ICommentableInitialiser; + +public interface ILambdaBodyInitialiser extends ICommentableInitialiser { + @Override + public LambdaBody instantiate(); + +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/ILambdaExpressionInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/ILambdaExpressionInitialiser.java new file mode 100644 index 0000000000..a055acaef7 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/ILambdaExpressionInitialiser.java @@ -0,0 +1,20 @@ +package cipm.consistency.initialisers.jamopp.expressions; + +import org.emftext.language.java.expressions.LambdaBody; +import org.emftext.language.java.expressions.LambdaExpression; +import org.emftext.language.java.expressions.LambdaParameters; + +public interface ILambdaExpressionInitialiser extends IExpressionInitialiser { + @Override + public LambdaExpression instantiate(); + + public default boolean setBody(LambdaExpression le, LambdaBody body) { + le.setBody(body); + return (body == null && le.getBody() == null) || le.getBody().equals(body); + } + + public default boolean setParameters(LambdaExpression le, LambdaParameters param) { + le.setParameters(param); + return (param == null && le.getParameters() == null) || le.getParameters().equals(param); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/ILambdaParametersInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/ILambdaParametersInitialiser.java new file mode 100644 index 0000000000..fc78f7336d --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/ILambdaParametersInitialiser.java @@ -0,0 +1,11 @@ +package cipm.consistency.initialisers.jamopp.expressions; + +import org.emftext.language.java.expressions.LambdaParameters; + +import cipm.consistency.initialisers.jamopp.parameters.IParametrizableInitialiser; + +public interface ILambdaParametersInitialiser extends IParametrizableInitialiser { + @Override + public LambdaParameters instantiate(); + +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IMethodReferenceExpressionChildInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IMethodReferenceExpressionChildInitialiser.java new file mode 100644 index 0000000000..ebd83fc9a2 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IMethodReferenceExpressionChildInitialiser.java @@ -0,0 +1,9 @@ +package cipm.consistency.initialisers.jamopp.expressions; + +import org.emftext.language.java.expressions.MethodReferenceExpressionChild; + +public interface IMethodReferenceExpressionChildInitialiser extends IUnaryModificationExpressionChildInitialiser { + @Override + public MethodReferenceExpressionChild instantiate(); + +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IMethodReferenceExpressionInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IMethodReferenceExpressionInitialiser.java new file mode 100644 index 0000000000..73bb7aaca3 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IMethodReferenceExpressionInitialiser.java @@ -0,0 +1,9 @@ +package cipm.consistency.initialisers.jamopp.expressions; + +import org.emftext.language.java.expressions.MethodReferenceExpression; + +public interface IMethodReferenceExpressionInitialiser extends IUnaryModificationExpressionChildInitialiser { + @Override + public MethodReferenceExpression instantiate(); + +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IMultiplicativeExpressionChildInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IMultiplicativeExpressionChildInitialiser.java new file mode 100644 index 0000000000..1373fe3155 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IMultiplicativeExpressionChildInitialiser.java @@ -0,0 +1,9 @@ +package cipm.consistency.initialisers.jamopp.expressions; + +import org.emftext.language.java.expressions.MultiplicativeExpressionChild; + +public interface IMultiplicativeExpressionChildInitialiser extends IAdditiveExpressionChildInitialiser { + @Override + public MultiplicativeExpressionChild instantiate(); + +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IMultiplicativeExpressionInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IMultiplicativeExpressionInitialiser.java new file mode 100644 index 0000000000..c0e1270feb --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IMultiplicativeExpressionInitialiser.java @@ -0,0 +1,34 @@ +package cipm.consistency.initialisers.jamopp.expressions; + +import org.emftext.language.java.expressions.MultiplicativeExpression; +import org.emftext.language.java.expressions.MultiplicativeExpressionChild; +import org.emftext.language.java.operators.MultiplicativeOperator; + +public interface IMultiplicativeExpressionInitialiser extends IAdditiveExpressionChildInitialiser { + @Override + public MultiplicativeExpression instantiate(); + + public default boolean addMultiplicativeOperator(MultiplicativeExpression ae, MultiplicativeOperator op) { + if (op != null) { + ae.getMultiplicativeOperators().add(op); + return ae.getMultiplicativeOperators().contains(op); + } + return true; + } + + public default boolean addMultiplicativeOperators(MultiplicativeExpression ae, MultiplicativeOperator[] ops) { + return this.doMultipleModifications(ae, ops, this::addMultiplicativeOperator); + } + + public default boolean addChild(MultiplicativeExpression ae, MultiplicativeExpressionChild child) { + if (child != null) { + ae.getChildren().add(child); + return ae.getChildren().contains(child); + } + return true; + } + + public default boolean addChildren(MultiplicativeExpression ae, MultiplicativeExpressionChild[] children) { + return this.doMultipleModifications(ae, children, this::addChild); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/INestedExpressionInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/INestedExpressionInitialiser.java new file mode 100644 index 0000000000..20f759c777 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/INestedExpressionInitialiser.java @@ -0,0 +1,16 @@ +package cipm.consistency.initialisers.jamopp.expressions; + +import org.emftext.language.java.expressions.Expression; +import org.emftext.language.java.expressions.NestedExpression; + +import cipm.consistency.initialisers.jamopp.references.IReferenceInitialiser; + +public interface INestedExpressionInitialiser extends IReferenceInitialiser { + @Override + public NestedExpression instantiate(); + + public default boolean setExpression(NestedExpression ne, Expression expr) { + ne.setExpression(expr); + return (expr == null && ne.getExpression() == null) || ne.getExpression().equals(expr); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IPrefixUnaryModificationExpressionInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IPrefixUnaryModificationExpressionInitialiser.java new file mode 100644 index 0000000000..2cb783c114 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IPrefixUnaryModificationExpressionInitialiser.java @@ -0,0 +1,9 @@ +package cipm.consistency.initialisers.jamopp.expressions; + +import org.emftext.language.java.expressions.PrefixUnaryModificationExpression; + +public interface IPrefixUnaryModificationExpressionInitialiser extends IUnaryModificationExpressionInitialiser { + @Override + public PrefixUnaryModificationExpression instantiate(); + +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IPrimaryExpressionInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IPrimaryExpressionInitialiser.java new file mode 100644 index 0000000000..1ec6a0d9fb --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IPrimaryExpressionInitialiser.java @@ -0,0 +1,9 @@ +package cipm.consistency.initialisers.jamopp.expressions; + +import org.emftext.language.java.expressions.PrimaryExpression; + +public interface IPrimaryExpressionInitialiser extends IMethodReferenceExpressionChildInitialiser { + @Override + public PrimaryExpression instantiate(); + +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IPrimaryExpressionReferenceExpressionInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IPrimaryExpressionReferenceExpressionInitialiser.java new file mode 100644 index 0000000000..03cd0b9e8a --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IPrimaryExpressionReferenceExpressionInitialiser.java @@ -0,0 +1,23 @@ +package cipm.consistency.initialisers.jamopp.expressions; + +import org.emftext.language.java.expressions.MethodReferenceExpressionChild; +import org.emftext.language.java.expressions.PrimaryExpressionReferenceExpression; +import org.emftext.language.java.references.Reference; + +import cipm.consistency.initialisers.jamopp.generics.ICallTypeArgumentableInitialiser; + +public interface IPrimaryExpressionReferenceExpressionInitialiser + extends ICallTypeArgumentableInitialiser, IMethodReferenceExpressionInitialiser { + @Override + public PrimaryExpressionReferenceExpression instantiate(); + + public default boolean setChild(PrimaryExpressionReferenceExpression pere, MethodReferenceExpressionChild mrec) { + pere.setChild(mrec); + return (mrec == null && pere.getChild() == null) || pere.getChild().equals(mrec); + } + + public default boolean setMethodReference(PrimaryExpressionReferenceExpression pere, Reference metRef) { + pere.setMethodReference(metRef); + return (metRef == null && pere.getMethodReference() == null) || pere.getMethodReference().equals(metRef); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IRelationExpressionChildInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IRelationExpressionChildInitialiser.java new file mode 100644 index 0000000000..51ce44e741 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IRelationExpressionChildInitialiser.java @@ -0,0 +1,9 @@ +package cipm.consistency.initialisers.jamopp.expressions; + +import org.emftext.language.java.expressions.RelationExpressionChild; + +public interface IRelationExpressionChildInitialiser extends IInstanceOfExpressionChildInitialiser { + @Override + public RelationExpressionChild instantiate(); + +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IRelationExpressionInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IRelationExpressionInitialiser.java new file mode 100644 index 0000000000..78c8870353 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IRelationExpressionInitialiser.java @@ -0,0 +1,34 @@ +package cipm.consistency.initialisers.jamopp.expressions; + +import org.emftext.language.java.expressions.RelationExpression; +import org.emftext.language.java.expressions.RelationExpressionChild; +import org.emftext.language.java.operators.RelationOperator; + +public interface IRelationExpressionInitialiser extends IInstanceOfExpressionChildInitialiser { + @Override + public RelationExpression instantiate(); + + public default boolean addRelationOperator(RelationExpression re, RelationOperator op) { + if (op != null) { + re.getRelationOperators().add(op); + return re.getRelationOperators().contains(op); + } + return true; + } + + public default boolean addRelationOperators(RelationExpression re, RelationOperator[] ops) { + return this.doMultipleModifications(re, ops, this::addRelationOperator); + } + + public default boolean addChild(RelationExpression cae, RelationExpressionChild child) { + if (child != null) { + cae.getChildren().add(child); + return cae.getChildren().contains(child); + } + return true; + } + + public default boolean addChildren(RelationExpression cae, RelationExpressionChild[] children) { + return this.doMultipleModifications(cae, children, this::addChild); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IShiftExpressionChildInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IShiftExpressionChildInitialiser.java new file mode 100644 index 0000000000..bef581a0b2 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IShiftExpressionChildInitialiser.java @@ -0,0 +1,9 @@ +package cipm.consistency.initialisers.jamopp.expressions; + +import org.emftext.language.java.expressions.ShiftExpressionChild; + +public interface IShiftExpressionChildInitialiser extends IRelationExpressionChildInitialiser { + @Override + public ShiftExpressionChild instantiate(); + +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IShiftExpressionInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IShiftExpressionInitialiser.java new file mode 100644 index 0000000000..c27fc8225b --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IShiftExpressionInitialiser.java @@ -0,0 +1,34 @@ +package cipm.consistency.initialisers.jamopp.expressions; + +import org.emftext.language.java.expressions.ShiftExpression; +import org.emftext.language.java.expressions.ShiftExpressionChild; +import org.emftext.language.java.operators.ShiftOperator; + +public interface IShiftExpressionInitialiser extends IRelationExpressionChildInitialiser { + @Override + public ShiftExpression instantiate(); + + public default boolean addShiftOperator(ShiftExpression se, ShiftOperator op) { + if (op != null) { + se.getShiftOperators().add(op); + return se.getShiftOperators().contains(op); + } + return true; + } + + public default boolean addShiftOperators(ShiftExpression se, ShiftOperator[] ops) { + return this.doMultipleModifications(se, ops, this::addShiftOperator); + } + + public default boolean addChild(ShiftExpression se, ShiftExpressionChild child) { + if (child != null) { + se.getChildren().add(child); + return se.getChildren().contains(child); + } + return true; + } + + public default boolean addChildren(ShiftExpression se, ShiftExpressionChild[] children) { + return this.doMultipleModifications(se, children, this::addChild); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/ISingleImplicitLambdaParameterInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/ISingleImplicitLambdaParameterInitialiser.java new file mode 100644 index 0000000000..0a42080df4 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/ISingleImplicitLambdaParameterInitialiser.java @@ -0,0 +1,8 @@ +package cipm.consistency.initialisers.jamopp.expressions; + +import org.emftext.language.java.expressions.SingleImplicitLambdaParameter; + +public interface ISingleImplicitLambdaParameterInitialiser extends IImplicitlyTypedLambdaParametersInitialiser { + @Override + public SingleImplicitLambdaParameter instantiate(); +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/ISuffixUnaryModificationExpressionInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/ISuffixUnaryModificationExpressionInitialiser.java new file mode 100644 index 0000000000..6cf7f829f2 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/ISuffixUnaryModificationExpressionInitialiser.java @@ -0,0 +1,9 @@ +package cipm.consistency.initialisers.jamopp.expressions; + +import org.emftext.language.java.expressions.SuffixUnaryModificationExpression; + +public interface ISuffixUnaryModificationExpressionInitialiser extends IUnaryModificationExpressionInitialiser { + @Override + public SuffixUnaryModificationExpression instantiate(); + +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IUnaryExpressionChildInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IUnaryExpressionChildInitialiser.java new file mode 100644 index 0000000000..08dc42d671 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IUnaryExpressionChildInitialiser.java @@ -0,0 +1,9 @@ +package cipm.consistency.initialisers.jamopp.expressions; + +import org.emftext.language.java.expressions.UnaryExpressionChild; + +public interface IUnaryExpressionChildInitialiser extends IMultiplicativeExpressionChildInitialiser { + @Override + public UnaryExpressionChild instantiate(); + +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IUnaryExpressionInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IUnaryExpressionInitialiser.java new file mode 100644 index 0000000000..ec57e30f85 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IUnaryExpressionInitialiser.java @@ -0,0 +1,27 @@ +package cipm.consistency.initialisers.jamopp.expressions; + +import org.emftext.language.java.expressions.UnaryExpression; +import org.emftext.language.java.expressions.UnaryExpressionChild; +import org.emftext.language.java.operators.UnaryOperator; + +public interface IUnaryExpressionInitialiser extends IMultiplicativeExpressionChildInitialiser { + @Override + public UnaryExpression instantiate(); + + public default boolean addOperator(UnaryExpression ue, UnaryOperator op) { + if (op != null) { + ue.getOperators().add(op); + return ue.getOperators().contains(op); + } + return true; + } + + public default boolean addOperators(UnaryExpression ue, UnaryOperator[] ops) { + return this.doMultipleModifications(ue, ops, this::addOperator); + } + + public default boolean setChild(UnaryExpression ue, UnaryExpressionChild child) { + ue.setChild(child); + return (child == null && ue.getChild() == null) || ue.getChild().equals(child); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IUnaryModificationExpressionChildInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IUnaryModificationExpressionChildInitialiser.java new file mode 100644 index 0000000000..0c7bbee94f --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IUnaryModificationExpressionChildInitialiser.java @@ -0,0 +1,9 @@ +package cipm.consistency.initialisers.jamopp.expressions; + +import org.emftext.language.java.expressions.UnaryModificationExpressionChild; + +public interface IUnaryModificationExpressionChildInitialiser extends IUnaryExpressionChildInitialiser { + @Override + public UnaryModificationExpressionChild instantiate(); + +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IUnaryModificationExpressionInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IUnaryModificationExpressionInitialiser.java new file mode 100644 index 0000000000..913501f924 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/IUnaryModificationExpressionInitialiser.java @@ -0,0 +1,20 @@ +package cipm.consistency.initialisers.jamopp.expressions; + +import org.emftext.language.java.expressions.UnaryModificationExpression; +import org.emftext.language.java.expressions.UnaryModificationExpressionChild; +import org.emftext.language.java.operators.UnaryModificationOperator; + +public interface IUnaryModificationExpressionInitialiser extends IUnaryExpressionChildInitialiser { + @Override + public UnaryModificationExpression instantiate(); + + public default boolean setChild(UnaryModificationExpression ume, UnaryModificationExpressionChild child) { + ume.setChild(child); + return (child == null && ume.getChild() == null) || ume.getChild().equals(child); + } + + public default boolean setOperator(UnaryModificationExpression ume, UnaryModificationOperator op) { + ume.setOperator(op); + return (op == null && ume.getOperator() == null) || ume.getOperator().equals(op); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/ImplicitlyTypedLambdaParametersInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/ImplicitlyTypedLambdaParametersInitialiser.java new file mode 100644 index 0000000000..3fbe2cbada --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/ImplicitlyTypedLambdaParametersInitialiser.java @@ -0,0 +1,19 @@ +package cipm.consistency.initialisers.jamopp.expressions; + +import org.emftext.language.java.expressions.ExpressionsFactory; +import org.emftext.language.java.expressions.ImplicitlyTypedLambdaParameters; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class ImplicitlyTypedLambdaParametersInitialiser extends AbstractInitialiserBase + implements IImplicitlyTypedLambdaParametersInitialiser { + @Override + public IImplicitlyTypedLambdaParametersInitialiser newInitialiser() { + return new ImplicitlyTypedLambdaParametersInitialiser(); + } + + @Override + public ImplicitlyTypedLambdaParameters instantiate() { + return ExpressionsFactory.eINSTANCE.createImplicitlyTypedLambdaParameters(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/InclusiveOrExpressionInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/InclusiveOrExpressionInitialiser.java new file mode 100644 index 0000000000..2d6381b150 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/InclusiveOrExpressionInitialiser.java @@ -0,0 +1,19 @@ +package cipm.consistency.initialisers.jamopp.expressions; + +import org.emftext.language.java.expressions.ExpressionsFactory; +import org.emftext.language.java.expressions.InclusiveOrExpression; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class InclusiveOrExpressionInitialiser extends AbstractInitialiserBase + implements IInclusiveOrExpressionInitialiser { + @Override + public IInclusiveOrExpressionInitialiser newInitialiser() { + return new InclusiveOrExpressionInitialiser(); + } + + @Override + public InclusiveOrExpression instantiate() { + return ExpressionsFactory.eINSTANCE.createInclusiveOrExpression(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/InstanceOfExpressionInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/InstanceOfExpressionInitialiser.java new file mode 100644 index 0000000000..a1869c8e97 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/InstanceOfExpressionInitialiser.java @@ -0,0 +1,19 @@ +package cipm.consistency.initialisers.jamopp.expressions; + +import org.emftext.language.java.expressions.ExpressionsFactory; +import org.emftext.language.java.expressions.InstanceOfExpression; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class InstanceOfExpressionInitialiser extends AbstractInitialiserBase + implements IInstanceOfExpressionInitialiser { + @Override + public IInstanceOfExpressionInitialiser newInitialiser() { + return new InstanceOfExpressionInitialiser(); + } + + @Override + public InstanceOfExpression instantiate() { + return ExpressionsFactory.eINSTANCE.createInstanceOfExpression(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/LambdaExpressionInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/LambdaExpressionInitialiser.java new file mode 100644 index 0000000000..7da443c16e --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/LambdaExpressionInitialiser.java @@ -0,0 +1,20 @@ +package cipm.consistency.initialisers.jamopp.expressions; + +import org.emftext.language.java.expressions.ExpressionsFactory; +import org.emftext.language.java.expressions.LambdaExpression; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class LambdaExpressionInitialiser extends AbstractInitialiserBase implements ILambdaExpressionInitialiser { + + @Override + public ILambdaExpressionInitialiser newInitialiser() { + return new LambdaExpressionInitialiser(); + } + + @Override + public LambdaExpression instantiate() { + return ExpressionsFactory.eINSTANCE.createLambdaExpression(); + } + +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/MultiplicativeExpressionInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/MultiplicativeExpressionInitialiser.java new file mode 100644 index 0000000000..d0b8a5bc30 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/MultiplicativeExpressionInitialiser.java @@ -0,0 +1,19 @@ +package cipm.consistency.initialisers.jamopp.expressions; + +import org.emftext.language.java.expressions.ExpressionsFactory; +import org.emftext.language.java.expressions.MultiplicativeExpression; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class MultiplicativeExpressionInitialiser extends AbstractInitialiserBase + implements IMultiplicativeExpressionInitialiser { + @Override + public IMultiplicativeExpressionInitialiser newInitialiser() { + return new MultiplicativeExpressionInitialiser(); + } + + @Override + public MultiplicativeExpression instantiate() { + return ExpressionsFactory.eINSTANCE.createMultiplicativeExpression(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/NestedExpressionInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/NestedExpressionInitialiser.java new file mode 100644 index 0000000000..3dab5684bf --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/NestedExpressionInitialiser.java @@ -0,0 +1,18 @@ +package cipm.consistency.initialisers.jamopp.expressions; + +import org.emftext.language.java.expressions.ExpressionsFactory; +import org.emftext.language.java.expressions.NestedExpression; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class NestedExpressionInitialiser extends AbstractInitialiserBase implements INestedExpressionInitialiser { + @Override + public INestedExpressionInitialiser newInitialiser() { + return new NestedExpressionInitialiser(); + } + + @Override + public NestedExpression instantiate() { + return ExpressionsFactory.eINSTANCE.createNestedExpression(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/PrefixUnaryModificationExpressionInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/PrefixUnaryModificationExpressionInitialiser.java new file mode 100644 index 0000000000..091028a319 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/PrefixUnaryModificationExpressionInitialiser.java @@ -0,0 +1,19 @@ +package cipm.consistency.initialisers.jamopp.expressions; + +import org.emftext.language.java.expressions.ExpressionsFactory; +import org.emftext.language.java.expressions.PrefixUnaryModificationExpression; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class PrefixUnaryModificationExpressionInitialiser extends AbstractInitialiserBase + implements IPrefixUnaryModificationExpressionInitialiser { + @Override + public IPrefixUnaryModificationExpressionInitialiser newInitialiser() { + return new PrefixUnaryModificationExpressionInitialiser(); + } + + @Override + public PrefixUnaryModificationExpression instantiate() { + return ExpressionsFactory.eINSTANCE.createPrefixUnaryModificationExpression(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/PrimaryExpressionReferenceExpressionInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/PrimaryExpressionReferenceExpressionInitialiser.java new file mode 100644 index 0000000000..bc959ae2c0 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/PrimaryExpressionReferenceExpressionInitialiser.java @@ -0,0 +1,19 @@ +package cipm.consistency.initialisers.jamopp.expressions; + +import org.emftext.language.java.expressions.ExpressionsFactory; +import org.emftext.language.java.expressions.PrimaryExpressionReferenceExpression; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class PrimaryExpressionReferenceExpressionInitialiser extends AbstractInitialiserBase + implements IPrimaryExpressionReferenceExpressionInitialiser { + @Override + public IPrimaryExpressionReferenceExpressionInitialiser newInitialiser() { + return new PrimaryExpressionReferenceExpressionInitialiser(); + } + + @Override + public PrimaryExpressionReferenceExpression instantiate() { + return ExpressionsFactory.eINSTANCE.createPrimaryExpressionReferenceExpression(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/RelationExpressionInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/RelationExpressionInitialiser.java new file mode 100644 index 0000000000..d2e56f1c7b --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/RelationExpressionInitialiser.java @@ -0,0 +1,18 @@ +package cipm.consistency.initialisers.jamopp.expressions; + +import org.emftext.language.java.expressions.ExpressionsFactory; +import org.emftext.language.java.expressions.RelationExpression; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class RelationExpressionInitialiser extends AbstractInitialiserBase implements IRelationExpressionInitialiser { + @Override + public IRelationExpressionInitialiser newInitialiser() { + return new RelationExpressionInitialiser(); + } + + @Override + public RelationExpression instantiate() { + return ExpressionsFactory.eINSTANCE.createRelationExpression(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/ShiftExpressionInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/ShiftExpressionInitialiser.java new file mode 100644 index 0000000000..561f3365ae --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/ShiftExpressionInitialiser.java @@ -0,0 +1,18 @@ +package cipm.consistency.initialisers.jamopp.expressions; + +import org.emftext.language.java.expressions.ExpressionsFactory; +import org.emftext.language.java.expressions.ShiftExpression; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class ShiftExpressionInitialiser extends AbstractInitialiserBase implements IShiftExpressionInitialiser { + @Override + public IShiftExpressionInitialiser newInitialiser() { + return new ShiftExpressionInitialiser(); + } + + @Override + public ShiftExpression instantiate() { + return ExpressionsFactory.eINSTANCE.createShiftExpression(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/SingleImplicitLambdaParameterInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/SingleImplicitLambdaParameterInitialiser.java new file mode 100644 index 0000000000..dc24929276 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/SingleImplicitLambdaParameterInitialiser.java @@ -0,0 +1,19 @@ +package cipm.consistency.initialisers.jamopp.expressions; + +import org.emftext.language.java.expressions.ExpressionsFactory; +import org.emftext.language.java.expressions.SingleImplicitLambdaParameter; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class SingleImplicitLambdaParameterInitialiser extends AbstractInitialiserBase + implements ISingleImplicitLambdaParameterInitialiser { + @Override + public ISingleImplicitLambdaParameterInitialiser newInitialiser() { + return new SingleImplicitLambdaParameterInitialiser(); + } + + @Override + public SingleImplicitLambdaParameter instantiate() { + return ExpressionsFactory.eINSTANCE.createSingleImplicitLambdaParameter(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/SuffixUnaryModificationExpressionInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/SuffixUnaryModificationExpressionInitialiser.java new file mode 100644 index 0000000000..bee3478537 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/SuffixUnaryModificationExpressionInitialiser.java @@ -0,0 +1,19 @@ +package cipm.consistency.initialisers.jamopp.expressions; + +import org.emftext.language.java.expressions.ExpressionsFactory; +import org.emftext.language.java.expressions.SuffixUnaryModificationExpression; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class SuffixUnaryModificationExpressionInitialiser extends AbstractInitialiserBase + implements ISuffixUnaryModificationExpressionInitialiser { + @Override + public ISuffixUnaryModificationExpressionInitialiser newInitialiser() { + return new SuffixUnaryModificationExpressionInitialiser(); + } + + @Override + public SuffixUnaryModificationExpression instantiate() { + return ExpressionsFactory.eINSTANCE.createSuffixUnaryModificationExpression(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/UnaryExpressionInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/UnaryExpressionInitialiser.java new file mode 100644 index 0000000000..1bda0b4eb3 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/UnaryExpressionInitialiser.java @@ -0,0 +1,18 @@ +package cipm.consistency.initialisers.jamopp.expressions; + +import org.emftext.language.java.expressions.ExpressionsFactory; +import org.emftext.language.java.expressions.UnaryExpression; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class UnaryExpressionInitialiser extends AbstractInitialiserBase implements IUnaryExpressionInitialiser { + @Override + public IUnaryExpressionInitialiser newInitialiser() { + return new UnaryExpressionInitialiser(); + } + + @Override + public UnaryExpression instantiate() { + return ExpressionsFactory.eINSTANCE.createUnaryExpression(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/package-info.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/package-info.java new file mode 100644 index 0000000000..7ad2105963 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/expressions/package-info.java @@ -0,0 +1,5 @@ +/** + * Contains {@link IInitialiser} implementations for + * {@link org.emftext.language.java.expressions}. + */ +package cipm.consistency.initialisers.jamopp.expressions; \ No newline at end of file From 280d2fcbaaadb399ec90d380d6814952dc8886e3 Mon Sep 17 00:00:00 2001 From: AlpTorac Date: Fri, 25 Oct 2024 17:36:18 +0200 Subject: [PATCH 18/55] (WIP) Implement initialiser package for org.emftext.language.java.generics --- .../ExtendsTypeArgumentInitialiser.java | 18 ++++++ .../generics/GenericsInitialiserPackage.java | 24 ++++++++ .../ICallTypeArgumentableInitialiser.java | 23 +++++++ .../IExtendsTypeArgumentInitialiser.java | 32 ++++++++++ .../IQualifiedTypeArgumentInitialiser.java | 10 ++++ .../ISuperTypeArgumentInitialiser.java | 16 +++++ .../generics/ITypeArgumentInitialiser.java | 11 ++++ .../ITypeArgumentableInitialiser.java | 23 +++++++ .../generics/ITypeParameterInitialiser.java | 60 +++++++++++++++++++ .../ITypeParametrizableInitialiser.java | 23 +++++++ .../IUnknownTypeArgumentInitialiser.java | 10 ++++ .../QualifiedTypeArgumentInitialiser.java | 19 ++++++ .../SuperTypeArgumentInitialiser.java | 18 ++++++ .../generics/TypeParameterInitialiser.java | 19 ++++++ .../UnknownTypeArgumentInitialiser.java | 18 ++++++ .../jamopp/generics/package-info.java | 5 ++ 16 files changed, 329 insertions(+) create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/generics/ExtendsTypeArgumentInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/generics/GenericsInitialiserPackage.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/generics/ICallTypeArgumentableInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/generics/IExtendsTypeArgumentInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/generics/IQualifiedTypeArgumentInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/generics/ISuperTypeArgumentInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/generics/ITypeArgumentInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/generics/ITypeArgumentableInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/generics/ITypeParameterInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/generics/ITypeParametrizableInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/generics/IUnknownTypeArgumentInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/generics/QualifiedTypeArgumentInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/generics/SuperTypeArgumentInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/generics/TypeParameterInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/generics/UnknownTypeArgumentInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/generics/package-info.java diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/generics/ExtendsTypeArgumentInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/generics/ExtendsTypeArgumentInitialiser.java new file mode 100644 index 0000000000..9d651b1c41 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/generics/ExtendsTypeArgumentInitialiser.java @@ -0,0 +1,18 @@ +package cipm.consistency.initialisers.jamopp.generics; + +import org.emftext.language.java.generics.ExtendsTypeArgument; +import org.emftext.language.java.generics.GenericsFactory; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class ExtendsTypeArgumentInitialiser extends AbstractInitialiserBase implements IExtendsTypeArgumentInitialiser { + @Override + public IExtendsTypeArgumentInitialiser newInitialiser() { + return new ExtendsTypeArgumentInitialiser(); + } + + @Override + public ExtendsTypeArgument instantiate() { + return GenericsFactory.eINSTANCE.createExtendsTypeArgument(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/generics/GenericsInitialiserPackage.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/generics/GenericsInitialiserPackage.java new file mode 100644 index 0000000000..aee7de7ad0 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/generics/GenericsInitialiserPackage.java @@ -0,0 +1,24 @@ +package cipm.consistency.initialisers.jamopp.generics; + +import java.util.Collection; + +import cipm.consistency.initialisers.IInitialiser; +import cipm.consistency.initialisers.IInitialiserPackage; + +public class GenericsInitialiserPackage implements IInitialiserPackage { + @Override + public Collection getInitialiserInstances() { + return this.initCol(new IInitialiser[] { new ExtendsTypeArgumentInitialiser(), + new QualifiedTypeArgumentInitialiser(), new SuperTypeArgumentInitialiser(), + new TypeParameterInitialiser(), new UnknownTypeArgumentInitialiser(), }); + } + + @SuppressWarnings("unchecked") + @Override + public Collection> getInitialiserInterfaceTypes() { + return this.initCol(new Class[] { ICallTypeArgumentableInitialiser.class, IExtendsTypeArgumentInitialiser.class, + IQualifiedTypeArgumentInitialiser.class, ISuperTypeArgumentInitialiser.class, + ITypeArgumentableInitialiser.class, ITypeArgumentInitialiser.class, ITypeParameterInitialiser.class, + ITypeParametrizableInitialiser.class, IUnknownTypeArgumentInitialiser.class, }); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/generics/ICallTypeArgumentableInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/generics/ICallTypeArgumentableInitialiser.java new file mode 100644 index 0000000000..fec3a9d20b --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/generics/ICallTypeArgumentableInitialiser.java @@ -0,0 +1,23 @@ +package cipm.consistency.initialisers.jamopp.generics; + +import org.emftext.language.java.generics.CallTypeArgumentable; +import org.emftext.language.java.generics.TypeArgument; + +import cipm.consistency.initialisers.jamopp.commons.ICommentableInitialiser; + +public interface ICallTypeArgumentableInitialiser extends ICommentableInitialiser { + @Override + public CallTypeArgumentable instantiate(); + + public default boolean addCallTypeArgument(CallTypeArgumentable cta, TypeArgument callTypeArg) { + if (callTypeArg != null) { + cta.getCallTypeArguments().add(callTypeArg); + return cta.getCallTypeArguments().contains(callTypeArg); + } + return true; + } + + public default boolean addCallTypeArguments(CallTypeArgumentable cta, TypeArgument[] callTypeArgs) { + return this.doMultipleModifications(cta, callTypeArgs, this::addCallTypeArgument); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/generics/IExtendsTypeArgumentInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/generics/IExtendsTypeArgumentInitialiser.java new file mode 100644 index 0000000000..7c985fc808 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/generics/IExtendsTypeArgumentInitialiser.java @@ -0,0 +1,32 @@ +package cipm.consistency.initialisers.jamopp.generics; + +import org.emftext.language.java.generics.ExtendsTypeArgument; +import org.emftext.language.java.types.TypeReference; + +import cipm.consistency.initialisers.jamopp.annotations.IAnnotableInitialiser; + +/** + * An interface meant to be implemented by initialisers, which are supposed to + * create {@link ExtendsTypeArgument} instances.
+ *
+ * For an {@link ExtendsTypeArgument} instance eta, + * {@code eta.getExtendTypes().add(...)} does not modify eta. + * + * @author Alp Torac Genc + */ +public interface IExtendsTypeArgumentInitialiser extends IAnnotableInitialiser, ITypeArgumentInitialiser { + @Override + public ExtendsTypeArgument instantiate(); + + /** + * Sets the extend type of the given {@link ExtendsTypeArgument} to extType. + * Uses {@code eta.setExtendType(...)} to do so. + * + * @see {@link IExtendsTypeArgumentInitialiser} + */ + public default boolean setExtendType(ExtendsTypeArgument eta, TypeReference extType) { + eta.setExtendType(extType); + return (extType == null && eta.getExtendType() == null) + || eta.getExtendType().equals(extType) && eta.getExtendTypes().contains(extType); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/generics/IQualifiedTypeArgumentInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/generics/IQualifiedTypeArgumentInitialiser.java new file mode 100644 index 0000000000..f913899c9b --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/generics/IQualifiedTypeArgumentInitialiser.java @@ -0,0 +1,10 @@ +package cipm.consistency.initialisers.jamopp.generics; + +import org.emftext.language.java.generics.QualifiedTypeArgument; + +import cipm.consistency.initialisers.jamopp.types.ITypedElementInitialiser; + +public interface IQualifiedTypeArgumentInitialiser extends ITypeArgumentInitialiser, ITypedElementInitialiser { + @Override + public QualifiedTypeArgument instantiate(); +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/generics/ISuperTypeArgumentInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/generics/ISuperTypeArgumentInitialiser.java new file mode 100644 index 0000000000..9ba6065db6 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/generics/ISuperTypeArgumentInitialiser.java @@ -0,0 +1,16 @@ +package cipm.consistency.initialisers.jamopp.generics; + +import org.emftext.language.java.generics.SuperTypeArgument; +import org.emftext.language.java.types.TypeReference; + +import cipm.consistency.initialisers.jamopp.annotations.IAnnotableInitialiser; + +public interface ISuperTypeArgumentInitialiser extends IAnnotableInitialiser, ITypeArgumentInitialiser { + @Override + public SuperTypeArgument instantiate(); + + public default boolean setSuperType(SuperTypeArgument sta, TypeReference superType) { + sta.setSuperType(superType); + return (superType == null && sta.getSuperType() == null) || sta.getSuperType().equals(superType); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/generics/ITypeArgumentInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/generics/ITypeArgumentInitialiser.java new file mode 100644 index 0000000000..136509941b --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/generics/ITypeArgumentInitialiser.java @@ -0,0 +1,11 @@ +package cipm.consistency.initialisers.jamopp.generics; + +import org.emftext.language.java.generics.TypeArgument; + +import cipm.consistency.initialisers.jamopp.arrays.IArrayTypeableInitialiser; + +public interface ITypeArgumentInitialiser extends IArrayTypeableInitialiser { + @Override + public TypeArgument instantiate(); + +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/generics/ITypeArgumentableInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/generics/ITypeArgumentableInitialiser.java new file mode 100644 index 0000000000..bd4a733d06 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/generics/ITypeArgumentableInitialiser.java @@ -0,0 +1,23 @@ +package cipm.consistency.initialisers.jamopp.generics; + +import org.emftext.language.java.generics.TypeArgument; +import org.emftext.language.java.generics.TypeArgumentable; + +import cipm.consistency.initialisers.jamopp.commons.ICommentableInitialiser; + +public interface ITypeArgumentableInitialiser extends ICommentableInitialiser { + @Override + public TypeArgumentable instantiate(); + + public default boolean addTypeArgument(TypeArgumentable ta, TypeArgument tArg) { + if (tArg != null) { + ta.getTypeArguments().add(tArg); + return ta.getTypeArguments().contains(tArg); + } + return true; + } + + public default boolean addTypeArguments(TypeArgumentable ta, TypeArgument[] tArgs) { + return this.doMultipleModifications(ta, tArgs, this::addTypeArgument); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/generics/ITypeParameterInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/generics/ITypeParameterInitialiser.java new file mode 100644 index 0000000000..6663b9cc2e --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/generics/ITypeParameterInitialiser.java @@ -0,0 +1,60 @@ +package cipm.consistency.initialisers.jamopp.generics; + +import org.emftext.language.java.classifiers.Classifier; +import org.emftext.language.java.generics.TypeParameter; +import org.emftext.language.java.types.TypeReference; + +import cipm.consistency.initialisers.jamopp.annotations.IAnnotableInitialiser; +import cipm.consistency.initialisers.jamopp.classifiers.IClassifierInitialiser; + +/** + * An interface meant for {@link IInitialiser} implementors that are supposed to + * create {@link TypeParameter} instances.
+ *
+ * Note: {@link TypeParameter} cannot add imports to its container, so + * attempting to add imports to it has no effect. This is caused by the + * inconsistency in the {@link Classifier} sub-hierarchy. + * + * @author Alp Torac Genc + * + */ +public interface ITypeParameterInitialiser extends IClassifierInitialiser, IAnnotableInitialiser { + @Override + public TypeParameter instantiate(); + + public default boolean addExtendType(TypeParameter tp, TypeReference extType) { + if (extType != null) { + tp.getExtendTypes().add(extType); + return tp.getExtendTypes().contains(extType); + } + return true; + } + + /** + * {@inheritDoc} + * + * @return Returns false in case of {@link TypeParameter}. + * + * @see {@link ITypeParameterInitialiser} + */ + @Override + public default boolean canAddImports(Classifier cls) { + return false; + } + + /** + * {@inheritDoc} + * + * @return Returns false in case of {@link TypeParameter}. + * + * @see {@link ITypeParameterInitialiser} + */ + @Override + public default boolean canAddPackageImports(Classifier cls) { + return false; + } + + public default boolean addExtendTypes(TypeParameter tp, TypeReference[] extTypes) { + return this.doMultipleModifications(tp, extTypes, this::addExtendType); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/generics/ITypeParametrizableInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/generics/ITypeParametrizableInitialiser.java new file mode 100644 index 0000000000..b7368a9e94 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/generics/ITypeParametrizableInitialiser.java @@ -0,0 +1,23 @@ +package cipm.consistency.initialisers.jamopp.generics; + +import org.emftext.language.java.generics.TypeParameter; +import org.emftext.language.java.generics.TypeParametrizable; + +import cipm.consistency.initialisers.jamopp.commons.ICommentableInitialiser; + +public interface ITypeParametrizableInitialiser extends ICommentableInitialiser { + @Override + public TypeParametrizable instantiate(); + + public default boolean addTypeParameter(TypeParametrizable tp, TypeParameter typeParam) { + if (typeParam != null) { + tp.getTypeParameters().add(typeParam); + return tp.getTypeParameters().contains(typeParam); + } + return true; + } + + public default boolean addTypeParameters(TypeParametrizable tp, TypeParameter[] typeParams) { + return this.doMultipleModifications(tp, typeParams, this::addTypeParameter); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/generics/IUnknownTypeArgumentInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/generics/IUnknownTypeArgumentInitialiser.java new file mode 100644 index 0000000000..12478c656b --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/generics/IUnknownTypeArgumentInitialiser.java @@ -0,0 +1,10 @@ +package cipm.consistency.initialisers.jamopp.generics; + +import org.emftext.language.java.generics.UnknownTypeArgument; + +import cipm.consistency.initialisers.jamopp.annotations.IAnnotableInitialiser; + +public interface IUnknownTypeArgumentInitialiser extends IAnnotableInitialiser, ITypeArgumentInitialiser { + @Override + public UnknownTypeArgument instantiate(); +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/generics/QualifiedTypeArgumentInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/generics/QualifiedTypeArgumentInitialiser.java new file mode 100644 index 0000000000..ad032fa859 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/generics/QualifiedTypeArgumentInitialiser.java @@ -0,0 +1,19 @@ +package cipm.consistency.initialisers.jamopp.generics; + +import org.emftext.language.java.generics.GenericsFactory; +import org.emftext.language.java.generics.QualifiedTypeArgument; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class QualifiedTypeArgumentInitialiser extends AbstractInitialiserBase + implements IQualifiedTypeArgumentInitialiser { + @Override + public IQualifiedTypeArgumentInitialiser newInitialiser() { + return new QualifiedTypeArgumentInitialiser(); + } + + @Override + public QualifiedTypeArgument instantiate() { + return GenericsFactory.eINSTANCE.createQualifiedTypeArgument(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/generics/SuperTypeArgumentInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/generics/SuperTypeArgumentInitialiser.java new file mode 100644 index 0000000000..c5f10edc64 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/generics/SuperTypeArgumentInitialiser.java @@ -0,0 +1,18 @@ +package cipm.consistency.initialisers.jamopp.generics; + +import org.emftext.language.java.generics.GenericsFactory; +import org.emftext.language.java.generics.SuperTypeArgument; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class SuperTypeArgumentInitialiser extends AbstractInitialiserBase implements ISuperTypeArgumentInitialiser { + @Override + public ISuperTypeArgumentInitialiser newInitialiser() { + return new SuperTypeArgumentInitialiser(); + } + + @Override + public SuperTypeArgument instantiate() { + return GenericsFactory.eINSTANCE.createSuperTypeArgument(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/generics/TypeParameterInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/generics/TypeParameterInitialiser.java new file mode 100644 index 0000000000..482d894d90 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/generics/TypeParameterInitialiser.java @@ -0,0 +1,19 @@ +package cipm.consistency.initialisers.jamopp.generics; + +import org.emftext.language.java.generics.TypeParameter; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +import org.emftext.language.java.generics.GenericsFactory; + +public class TypeParameterInitialiser extends AbstractInitialiserBase implements ITypeParameterInitialiser { + @Override + public TypeParameter instantiate() { + return GenericsFactory.eINSTANCE.createTypeParameter(); + } + + @Override + public ITypeParameterInitialiser newInitialiser() { + return new TypeParameterInitialiser(); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/generics/UnknownTypeArgumentInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/generics/UnknownTypeArgumentInitialiser.java new file mode 100644 index 0000000000..f662c6676e --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/generics/UnknownTypeArgumentInitialiser.java @@ -0,0 +1,18 @@ +package cipm.consistency.initialisers.jamopp.generics; + +import org.emftext.language.java.generics.GenericsFactory; +import org.emftext.language.java.generics.UnknownTypeArgument; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class UnknownTypeArgumentInitialiser extends AbstractInitialiserBase implements IUnknownTypeArgumentInitialiser { + @Override + public IUnknownTypeArgumentInitialiser newInitialiser() { + return new UnknownTypeArgumentInitialiser(); + } + + @Override + public UnknownTypeArgument instantiate() { + return GenericsFactory.eINSTANCE.createUnknownTypeArgument(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/generics/package-info.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/generics/package-info.java new file mode 100644 index 0000000000..7d369e81bd --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/generics/package-info.java @@ -0,0 +1,5 @@ +/** + * Contains {@link IInitialiser} implementations for + * {@link org.emftext.language.java.generics}. + */ +package cipm.consistency.initialisers.jamopp.generics; \ No newline at end of file From 5f65531c10769f1a4ba4bb45de4b2ed6c8dc8391 Mon Sep 17 00:00:00 2001 From: AlpTorac Date: Fri, 25 Oct 2024 17:36:42 +0200 Subject: [PATCH 19/55] (WIP) Implement initialiser package for org.emftext.language.java.instantiations --- .../ExplicitConstructorCallInitialiser.java | 19 ++++++++++++++++ .../IExplicitConstructorCallInitialiser.java | 14 ++++++++++++ .../IInitializableInitialiser.java | 17 ++++++++++++++ .../IInstantiationInitialiser.java | 13 +++++++++++ .../INewConstructorCallInitialiser.java | 18 +++++++++++++++ ...lWithInferredTypeArgumentsInitialiser.java | 8 +++++++ .../InstantiationsInitialiserPackage.java | 22 +++++++++++++++++++ .../NewConstructorCallInitialiser.java | 18 +++++++++++++++ ...lWithInferredTypeArgumentsInitialiser.java | 19 ++++++++++++++++ .../jamopp/instantiations/package-info.java | 5 +++++ 10 files changed, 153 insertions(+) create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/instantiations/ExplicitConstructorCallInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/instantiations/IExplicitConstructorCallInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/instantiations/IInitializableInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/instantiations/IInstantiationInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/instantiations/INewConstructorCallInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/instantiations/INewConstructorCallWithInferredTypeArgumentsInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/instantiations/InstantiationsInitialiserPackage.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/instantiations/NewConstructorCallInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/instantiations/NewConstructorCallWithInferredTypeArgumentsInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/instantiations/package-info.java diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/instantiations/ExplicitConstructorCallInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/instantiations/ExplicitConstructorCallInitialiser.java new file mode 100644 index 0000000000..7a3af10fd6 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/instantiations/ExplicitConstructorCallInitialiser.java @@ -0,0 +1,19 @@ +package cipm.consistency.initialisers.jamopp.instantiations; + +import org.emftext.language.java.instantiations.ExplicitConstructorCall; +import org.emftext.language.java.instantiations.InstantiationsFactory; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class ExplicitConstructorCallInitialiser extends AbstractInitialiserBase + implements IExplicitConstructorCallInitialiser { + @Override + public IExplicitConstructorCallInitialiser newInitialiser() { + return new ExplicitConstructorCallInitialiser(); + } + + @Override + public ExplicitConstructorCall instantiate() { + return InstantiationsFactory.eINSTANCE.createExplicitConstructorCall(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/instantiations/IExplicitConstructorCallInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/instantiations/IExplicitConstructorCallInitialiser.java new file mode 100644 index 0000000000..7aac9f9de6 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/instantiations/IExplicitConstructorCallInitialiser.java @@ -0,0 +1,14 @@ +package cipm.consistency.initialisers.jamopp.instantiations; + +import org.emftext.language.java.instantiations.ExplicitConstructorCall; +import org.emftext.language.java.literals.Self; + +public interface IExplicitConstructorCallInitialiser extends IInstantiationInitialiser { + @Override + public ExplicitConstructorCall instantiate(); + + public default boolean setCallTarget(ExplicitConstructorCall ecc, Self callTarget) { + ecc.setCallTarget(callTarget); + return (callTarget == null && ecc.getCallTarget() == null) || ecc.getCallTarget().equals(callTarget); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/instantiations/IInitializableInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/instantiations/IInitializableInitialiser.java new file mode 100644 index 0000000000..536c5b1c79 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/instantiations/IInitializableInitialiser.java @@ -0,0 +1,17 @@ +package cipm.consistency.initialisers.jamopp.instantiations; + +import org.emftext.language.java.expressions.Expression; +import org.emftext.language.java.instantiations.Initializable; + +import cipm.consistency.initialisers.jamopp.commons.ICommentableInitialiser; + +public interface IInitializableInitialiser extends ICommentableInitialiser { + @Override + public Initializable instantiate(); + + public default boolean setInitialValue(Initializable initializable, Expression initVal) { + initializable.setInitialValue(initVal); + return (initVal == null && initializable.getInitialValue() == null) + || initializable.getInitialValue().equals(initVal); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/instantiations/IInstantiationInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/instantiations/IInstantiationInitialiser.java new file mode 100644 index 0000000000..b44d598e0e --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/instantiations/IInstantiationInitialiser.java @@ -0,0 +1,13 @@ +package cipm.consistency.initialisers.jamopp.instantiations; + +import org.emftext.language.java.instantiations.Instantiation; + +import cipm.consistency.initialisers.jamopp.generics.ICallTypeArgumentableInitialiser; +import cipm.consistency.initialisers.jamopp.references.IArgumentableInitialiser; +import cipm.consistency.initialisers.jamopp.references.IReferenceInitialiser; + +public interface IInstantiationInitialiser + extends IArgumentableInitialiser, IReferenceInitialiser, ICallTypeArgumentableInitialiser { + @Override + public Instantiation instantiate(); +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/instantiations/INewConstructorCallInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/instantiations/INewConstructorCallInitialiser.java new file mode 100644 index 0000000000..355f91d3e2 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/instantiations/INewConstructorCallInitialiser.java @@ -0,0 +1,18 @@ +package cipm.consistency.initialisers.jamopp.instantiations; + +import org.emftext.language.java.classifiers.AnonymousClass; +import org.emftext.language.java.instantiations.NewConstructorCall; + +import cipm.consistency.initialisers.jamopp.types.ITypedElementInitialiser; + +public interface INewConstructorCallInitialiser extends IInstantiationInitialiser, ITypedElementInitialiser { + + @Override + public NewConstructorCall instantiate(); + + public default boolean setAnonymousClass(NewConstructorCall ncc, AnonymousClass anonymousCls) { + ncc.setAnonymousClass(anonymousCls); + return (anonymousCls == null && ncc.getAnonymousClass() == null) + || ncc.getAnonymousClass().equals(anonymousCls); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/instantiations/INewConstructorCallWithInferredTypeArgumentsInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/instantiations/INewConstructorCallWithInferredTypeArgumentsInitialiser.java new file mode 100644 index 0000000000..ed7bdfb060 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/instantiations/INewConstructorCallWithInferredTypeArgumentsInitialiser.java @@ -0,0 +1,8 @@ +package cipm.consistency.initialisers.jamopp.instantiations; + +import org.emftext.language.java.instantiations.NewConstructorCallWithInferredTypeArguments; + +public interface INewConstructorCallWithInferredTypeArgumentsInitialiser extends INewConstructorCallInitialiser { + @Override + public NewConstructorCallWithInferredTypeArguments instantiate(); +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/instantiations/InstantiationsInitialiserPackage.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/instantiations/InstantiationsInitialiserPackage.java new file mode 100644 index 0000000000..20545c4d1f --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/instantiations/InstantiationsInitialiserPackage.java @@ -0,0 +1,22 @@ +package cipm.consistency.initialisers.jamopp.instantiations; + +import java.util.Collection; + +import cipm.consistency.initialisers.IInitialiser; +import cipm.consistency.initialisers.IInitialiserPackage; + +public class InstantiationsInitialiserPackage implements IInitialiserPackage { + @Override + public Collection getInitialiserInstances() { + return this.initCol(new IInitialiser[] { new ExplicitConstructorCallInitialiser(), + new NewConstructorCallInitialiser(), new NewConstructorCallWithInferredTypeArgumentsInitialiser(), }); + } + + @SuppressWarnings("unchecked") + @Override + public Collection> getInitialiserInterfaceTypes() { + return this.initCol(new Class[] { IExplicitConstructorCallInitialiser.class, IInitializableInitialiser.class, + IInstantiationInitialiser.class, INewConstructorCallInitialiser.class, + INewConstructorCallWithInferredTypeArgumentsInitialiser.class, }); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/instantiations/NewConstructorCallInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/instantiations/NewConstructorCallInitialiser.java new file mode 100644 index 0000000000..5e36611fbd --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/instantiations/NewConstructorCallInitialiser.java @@ -0,0 +1,18 @@ +package cipm.consistency.initialisers.jamopp.instantiations; + +import org.emftext.language.java.instantiations.InstantiationsFactory; +import org.emftext.language.java.instantiations.NewConstructorCall; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class NewConstructorCallInitialiser extends AbstractInitialiserBase implements INewConstructorCallInitialiser { + @Override + public INewConstructorCallInitialiser newInitialiser() { + return new NewConstructorCallInitialiser(); + } + + @Override + public NewConstructorCall instantiate() { + return InstantiationsFactory.eINSTANCE.createNewConstructorCall(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/instantiations/NewConstructorCallWithInferredTypeArgumentsInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/instantiations/NewConstructorCallWithInferredTypeArgumentsInitialiser.java new file mode 100644 index 0000000000..04585b6e5c --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/instantiations/NewConstructorCallWithInferredTypeArgumentsInitialiser.java @@ -0,0 +1,19 @@ +package cipm.consistency.initialisers.jamopp.instantiations; + +import org.emftext.language.java.instantiations.InstantiationsFactory; +import org.emftext.language.java.instantiations.NewConstructorCallWithInferredTypeArguments; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class NewConstructorCallWithInferredTypeArgumentsInitialiser extends AbstractInitialiserBase + implements INewConstructorCallWithInferredTypeArgumentsInitialiser { + @Override + public INewConstructorCallWithInferredTypeArgumentsInitialiser newInitialiser() { + return new NewConstructorCallWithInferredTypeArgumentsInitialiser(); + } + + @Override + public NewConstructorCallWithInferredTypeArguments instantiate() { + return InstantiationsFactory.eINSTANCE.createNewConstructorCallWithInferredTypeArguments(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/instantiations/package-info.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/instantiations/package-info.java new file mode 100644 index 0000000000..c4670a11b1 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/instantiations/package-info.java @@ -0,0 +1,5 @@ +/** + * Contains {@link IInitialiser} implementations for + * {@link org.emftext.language.java.instantiations}. + */ +package cipm.consistency.initialisers.jamopp.instantiations; \ No newline at end of file From 3a71c74addb7bc1b15f2f44fd31324dfc9294f18 Mon Sep 17 00:00:00 2001 From: AlpTorac Date: Fri, 25 Oct 2024 17:37:07 +0200 Subject: [PATCH 20/55] (WIP) Implement initialiser package for org.emftext.language.java.literals --- .../BinaryIntegerLiteralInitialiser.java | 19 +++++++++++ .../BinaryLongLiteralInitialiser.java | 18 ++++++++++ .../literals/BooleanLiteralInitialiser.java | 18 ++++++++++ .../literals/CharacterLiteralInitialiser.java | 18 ++++++++++ .../DecimalDoubleLiteralInitialiser.java | 19 +++++++++++ .../DecimalFloatLiteralInitialiser.java | 18 ++++++++++ .../DecimalIntegerLiteralInitialiser.java | 19 +++++++++++ .../DecimalLongLiteralInitialiser.java | 18 ++++++++++ .../literals/HexDoubleLiteralInitialiser.java | 18 ++++++++++ .../literals/HexFloatLiteralInitialiser.java | 18 ++++++++++ .../HexIntegerLiteralInitialiser.java | 18 ++++++++++ .../literals/HexLongLiteralInitialiser.java | 18 ++++++++++ .../IBinaryIntegerLiteralInitialiser.java | 19 +++++++++++ .../IBinaryLongLiteralInitialiser.java | 19 +++++++++++ .../literals/IBooleanLiteralInitialiser.java | 13 +++++++ .../ICharacterLiteralInitialiser.java | 13 +++++++ .../IDecimalDoubleLiteralInitialiser.java | 13 +++++++ .../IDecimalFloatLiteralInitialiser.java | 13 +++++++ .../IDecimalIntegerLiteralInitialiser.java | 19 +++++++++++ .../IDecimalLongLiteralInitialiser.java | 19 +++++++++++ .../literals/IDoubleLiteralInitialiser.java | 9 +++++ .../literals/IFloatLiteralInitialiser.java | 9 +++++ .../IHexDoubleLiteralInitialiser.java | 13 +++++++ .../literals/IHexFloatLiteralInitialiser.java | 13 +++++++ .../IHexIntegerLiteralInitialiser.java | 19 +++++++++++ .../literals/IHexLongLiteralInitialiser.java | 19 +++++++++++ .../literals/IIntegerLiteralInitialiser.java | 9 +++++ .../jamopp/literals/ILiteralInitialiser.java | 11 ++++++ .../literals/ILongLiteralInitialiser.java | 9 +++++ .../literals/INullLiteralInitialiser.java | 9 +++++ .../IOctalIntegerLiteralInitialiser.java | 19 +++++++++++ .../IOctalLongLiteralInitialiser.java | 19 +++++++++++ .../jamopp/literals/ISelfInitialiser.java | 11 ++++++ .../jamopp/literals/ISuperInitialiser.java | 9 +++++ .../jamopp/literals/IThisInitialiser.java | 9 +++++ .../literals/LiteralsInitialiserPackage.java | 34 +++++++++++++++++++ .../literals/NullLiteralInitialiser.java | 18 ++++++++++ .../OctalIntegerLiteralInitialiser.java | 18 ++++++++++ .../literals/OctalLongLiteralInitialiser.java | 18 ++++++++++ .../jamopp/literals/SuperInitialiser.java | 18 ++++++++++ .../jamopp/literals/ThisInitialiser.java | 18 ++++++++++ .../jamopp/literals/package-info.java | 5 +++ 42 files changed, 663 insertions(+) create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/BinaryIntegerLiteralInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/BinaryLongLiteralInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/BooleanLiteralInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/CharacterLiteralInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/DecimalDoubleLiteralInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/DecimalFloatLiteralInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/DecimalIntegerLiteralInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/DecimalLongLiteralInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/HexDoubleLiteralInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/HexFloatLiteralInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/HexIntegerLiteralInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/HexLongLiteralInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/IBinaryIntegerLiteralInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/IBinaryLongLiteralInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/IBooleanLiteralInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/ICharacterLiteralInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/IDecimalDoubleLiteralInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/IDecimalFloatLiteralInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/IDecimalIntegerLiteralInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/IDecimalLongLiteralInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/IDoubleLiteralInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/IFloatLiteralInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/IHexDoubleLiteralInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/IHexFloatLiteralInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/IHexIntegerLiteralInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/IHexLongLiteralInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/IIntegerLiteralInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/ILiteralInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/ILongLiteralInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/INullLiteralInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/IOctalIntegerLiteralInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/IOctalLongLiteralInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/ISelfInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/ISuperInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/IThisInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/LiteralsInitialiserPackage.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/NullLiteralInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/OctalIntegerLiteralInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/OctalLongLiteralInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/SuperInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/ThisInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/package-info.java diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/BinaryIntegerLiteralInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/BinaryIntegerLiteralInitialiser.java new file mode 100644 index 0000000000..d46a2d4c60 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/BinaryIntegerLiteralInitialiser.java @@ -0,0 +1,19 @@ +package cipm.consistency.initialisers.jamopp.literals; + +import org.emftext.language.java.literals.BinaryIntegerLiteral; +import org.emftext.language.java.literals.LiteralsFactory; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class BinaryIntegerLiteralInitialiser extends AbstractInitialiserBase + implements IBinaryIntegerLiteralInitialiser { + @Override + public IBinaryIntegerLiteralInitialiser newInitialiser() { + return new BinaryIntegerLiteralInitialiser(); + } + + @Override + public BinaryIntegerLiteral instantiate() { + return LiteralsFactory.eINSTANCE.createBinaryIntegerLiteral(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/BinaryLongLiteralInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/BinaryLongLiteralInitialiser.java new file mode 100644 index 0000000000..32508ceed4 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/BinaryLongLiteralInitialiser.java @@ -0,0 +1,18 @@ +package cipm.consistency.initialisers.jamopp.literals; + +import org.emftext.language.java.literals.BinaryLongLiteral; +import org.emftext.language.java.literals.LiteralsFactory; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class BinaryLongLiteralInitialiser extends AbstractInitialiserBase implements IBinaryLongLiteralInitialiser { + @Override + public IBinaryLongLiteralInitialiser newInitialiser() { + return new BinaryLongLiteralInitialiser(); + } + + @Override + public BinaryLongLiteral instantiate() { + return LiteralsFactory.eINSTANCE.createBinaryLongLiteral(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/BooleanLiteralInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/BooleanLiteralInitialiser.java new file mode 100644 index 0000000000..2bc55e6f96 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/BooleanLiteralInitialiser.java @@ -0,0 +1,18 @@ +package cipm.consistency.initialisers.jamopp.literals; + +import org.emftext.language.java.literals.BooleanLiteral; +import org.emftext.language.java.literals.LiteralsFactory; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class BooleanLiteralInitialiser extends AbstractInitialiserBase implements IBooleanLiteralInitialiser { + @Override + public IBooleanLiteralInitialiser newInitialiser() { + return new BooleanLiteralInitialiser(); + } + + @Override + public BooleanLiteral instantiate() { + return LiteralsFactory.eINSTANCE.createBooleanLiteral(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/CharacterLiteralInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/CharacterLiteralInitialiser.java new file mode 100644 index 0000000000..431a95b23b --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/CharacterLiteralInitialiser.java @@ -0,0 +1,18 @@ +package cipm.consistency.initialisers.jamopp.literals; + +import org.emftext.language.java.literals.CharacterLiteral; +import org.emftext.language.java.literals.LiteralsFactory; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class CharacterLiteralInitialiser extends AbstractInitialiserBase implements ICharacterLiteralInitialiser { + @Override + public ICharacterLiteralInitialiser newInitialiser() { + return new CharacterLiteralInitialiser(); + } + + @Override + public CharacterLiteral instantiate() { + return LiteralsFactory.eINSTANCE.createCharacterLiteral(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/DecimalDoubleLiteralInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/DecimalDoubleLiteralInitialiser.java new file mode 100644 index 0000000000..4e361e2a80 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/DecimalDoubleLiteralInitialiser.java @@ -0,0 +1,19 @@ +package cipm.consistency.initialisers.jamopp.literals; + +import org.emftext.language.java.literals.DecimalDoubleLiteral; +import org.emftext.language.java.literals.LiteralsFactory; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class DecimalDoubleLiteralInitialiser extends AbstractInitialiserBase + implements IDecimalDoubleLiteralInitialiser { + @Override + public IDecimalDoubleLiteralInitialiser newInitialiser() { + return new DecimalDoubleLiteralInitialiser(); + } + + @Override + public DecimalDoubleLiteral instantiate() { + return LiteralsFactory.eINSTANCE.createDecimalDoubleLiteral(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/DecimalFloatLiteralInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/DecimalFloatLiteralInitialiser.java new file mode 100644 index 0000000000..167c6b5ceb --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/DecimalFloatLiteralInitialiser.java @@ -0,0 +1,18 @@ +package cipm.consistency.initialisers.jamopp.literals; + +import org.emftext.language.java.literals.DecimalFloatLiteral; +import org.emftext.language.java.literals.LiteralsFactory; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class DecimalFloatLiteralInitialiser extends AbstractInitialiserBase implements IDecimalFloatLiteralInitialiser { + @Override + public IDecimalFloatLiteralInitialiser newInitialiser() { + return new DecimalFloatLiteralInitialiser(); + } + + @Override + public DecimalFloatLiteral instantiate() { + return LiteralsFactory.eINSTANCE.createDecimalFloatLiteral(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/DecimalIntegerLiteralInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/DecimalIntegerLiteralInitialiser.java new file mode 100644 index 0000000000..edfbb5220b --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/DecimalIntegerLiteralInitialiser.java @@ -0,0 +1,19 @@ +package cipm.consistency.initialisers.jamopp.literals; + +import org.emftext.language.java.literals.DecimalIntegerLiteral; +import org.emftext.language.java.literals.LiteralsFactory; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class DecimalIntegerLiteralInitialiser extends AbstractInitialiserBase + implements IDecimalIntegerLiteralInitialiser { + @Override + public IDecimalIntegerLiteralInitialiser newInitialiser() { + return new DecimalIntegerLiteralInitialiser(); + } + + @Override + public DecimalIntegerLiteral instantiate() { + return LiteralsFactory.eINSTANCE.createDecimalIntegerLiteral(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/DecimalLongLiteralInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/DecimalLongLiteralInitialiser.java new file mode 100644 index 0000000000..01cc1744b1 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/DecimalLongLiteralInitialiser.java @@ -0,0 +1,18 @@ +package cipm.consistency.initialisers.jamopp.literals; + +import org.emftext.language.java.literals.DecimalLongLiteral; +import org.emftext.language.java.literals.LiteralsFactory; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class DecimalLongLiteralInitialiser extends AbstractInitialiserBase implements IDecimalLongLiteralInitialiser { + @Override + public IDecimalLongLiteralInitialiser newInitialiser() { + return new DecimalLongLiteralInitialiser(); + } + + @Override + public DecimalLongLiteral instantiate() { + return LiteralsFactory.eINSTANCE.createDecimalLongLiteral(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/HexDoubleLiteralInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/HexDoubleLiteralInitialiser.java new file mode 100644 index 0000000000..f0e1095075 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/HexDoubleLiteralInitialiser.java @@ -0,0 +1,18 @@ +package cipm.consistency.initialisers.jamopp.literals; + +import org.emftext.language.java.literals.HexDoubleLiteral; +import org.emftext.language.java.literals.LiteralsFactory; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class HexDoubleLiteralInitialiser extends AbstractInitialiserBase implements IHexDoubleLiteralInitialiser { + @Override + public IHexDoubleLiteralInitialiser newInitialiser() { + return new HexDoubleLiteralInitialiser(); + } + + @Override + public HexDoubleLiteral instantiate() { + return LiteralsFactory.eINSTANCE.createHexDoubleLiteral(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/HexFloatLiteralInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/HexFloatLiteralInitialiser.java new file mode 100644 index 0000000000..721b620fe4 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/HexFloatLiteralInitialiser.java @@ -0,0 +1,18 @@ +package cipm.consistency.initialisers.jamopp.literals; + +import org.emftext.language.java.literals.HexFloatLiteral; +import org.emftext.language.java.literals.LiteralsFactory; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class HexFloatLiteralInitialiser extends AbstractInitialiserBase implements IHexFloatLiteralInitialiser { + @Override + public IHexFloatLiteralInitialiser newInitialiser() { + return new HexFloatLiteralInitialiser(); + } + + @Override + public HexFloatLiteral instantiate() { + return LiteralsFactory.eINSTANCE.createHexFloatLiteral(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/HexIntegerLiteralInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/HexIntegerLiteralInitialiser.java new file mode 100644 index 0000000000..ae1be06c31 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/HexIntegerLiteralInitialiser.java @@ -0,0 +1,18 @@ +package cipm.consistency.initialisers.jamopp.literals; + +import org.emftext.language.java.literals.HexIntegerLiteral; +import org.emftext.language.java.literals.LiteralsFactory; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class HexIntegerLiteralInitialiser extends AbstractInitialiserBase implements IHexIntegerLiteralInitialiser { + @Override + public IHexIntegerLiteralInitialiser newInitialiser() { + return new HexIntegerLiteralInitialiser(); + } + + @Override + public HexIntegerLiteral instantiate() { + return LiteralsFactory.eINSTANCE.createHexIntegerLiteral(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/HexLongLiteralInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/HexLongLiteralInitialiser.java new file mode 100644 index 0000000000..02181156db --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/HexLongLiteralInitialiser.java @@ -0,0 +1,18 @@ +package cipm.consistency.initialisers.jamopp.literals; + +import org.emftext.language.java.literals.HexLongLiteral; +import org.emftext.language.java.literals.LiteralsFactory; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class HexLongLiteralInitialiser extends AbstractInitialiserBase implements IHexLongLiteralInitialiser { + @Override + public IHexLongLiteralInitialiser newInitialiser() { + return new HexLongLiteralInitialiser(); + } + + @Override + public HexLongLiteral instantiate() { + return LiteralsFactory.eINSTANCE.createHexLongLiteral(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/IBinaryIntegerLiteralInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/IBinaryIntegerLiteralInitialiser.java new file mode 100644 index 0000000000..cbba52710b --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/IBinaryIntegerLiteralInitialiser.java @@ -0,0 +1,19 @@ +package cipm.consistency.initialisers.jamopp.literals; + +import java.math.BigInteger; + +import org.emftext.language.java.literals.BinaryIntegerLiteral; + +public interface IBinaryIntegerLiteralInitialiser extends IIntegerLiteralInitialiser { + @Override + public BinaryIntegerLiteral instantiate(); + + public default boolean setBinaryValue(BinaryIntegerLiteral bil, BigInteger val) { + bil.setBinaryValue(val); + return (val == null && bil.getBinaryValue() == null) || bil.getBinaryValue().equals(val); + } + + public default boolean setBinaryValue(BinaryIntegerLiteral bil, int val) { + return this.setBinaryValue(bil, BigInteger.valueOf(val)); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/IBinaryLongLiteralInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/IBinaryLongLiteralInitialiser.java new file mode 100644 index 0000000000..b5bdd3d114 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/IBinaryLongLiteralInitialiser.java @@ -0,0 +1,19 @@ +package cipm.consistency.initialisers.jamopp.literals; + +import java.math.BigInteger; + +import org.emftext.language.java.literals.BinaryLongLiteral; + +public interface IBinaryLongLiteralInitialiser extends ILongLiteralInitialiser { + @Override + public BinaryLongLiteral instantiate(); + + public default boolean setBinaryValue(BinaryLongLiteral bil, BigInteger val) { + bil.setBinaryValue(val); + return (val == null && bil.getBinaryValue() == null) || bil.getBinaryValue().equals(val); + } + + public default boolean setBinaryValue(BinaryLongLiteral bil, long val) { + return this.setBinaryValue(bil, BigInteger.valueOf(val)); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/IBooleanLiteralInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/IBooleanLiteralInitialiser.java new file mode 100644 index 0000000000..929c76a85d --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/IBooleanLiteralInitialiser.java @@ -0,0 +1,13 @@ +package cipm.consistency.initialisers.jamopp.literals; + +import org.emftext.language.java.literals.BooleanLiteral; + +public interface IBooleanLiteralInitialiser extends ILiteralInitialiser { + @Override + public BooleanLiteral instantiate(); + + public default boolean setValue(BooleanLiteral bl, boolean val) { + bl.setValue(val); + return bl.isValue() == val; + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/ICharacterLiteralInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/ICharacterLiteralInitialiser.java new file mode 100644 index 0000000000..62fead3428 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/ICharacterLiteralInitialiser.java @@ -0,0 +1,13 @@ +package cipm.consistency.initialisers.jamopp.literals; + +import org.emftext.language.java.literals.CharacterLiteral; + +public interface ICharacterLiteralInitialiser extends ILiteralInitialiser { + @Override + public CharacterLiteral instantiate(); + + public default boolean setValue(CharacterLiteral cl, String val) { + cl.setValue(val); + return (val == null && cl.getValue() == null) || cl.getValue().equals(val); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/IDecimalDoubleLiteralInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/IDecimalDoubleLiteralInitialiser.java new file mode 100644 index 0000000000..f96d324f62 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/IDecimalDoubleLiteralInitialiser.java @@ -0,0 +1,13 @@ +package cipm.consistency.initialisers.jamopp.literals; + +import org.emftext.language.java.literals.DecimalDoubleLiteral; + +public interface IDecimalDoubleLiteralInitialiser extends IDoubleLiteralInitialiser { + @Override + public DecimalDoubleLiteral instantiate(); + + public default boolean setDecimalValue(DecimalDoubleLiteral ddl, double val) { + ddl.setDecimalValue(val); + return ddl.getDecimalValue() == val; + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/IDecimalFloatLiteralInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/IDecimalFloatLiteralInitialiser.java new file mode 100644 index 0000000000..dce2edba88 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/IDecimalFloatLiteralInitialiser.java @@ -0,0 +1,13 @@ +package cipm.consistency.initialisers.jamopp.literals; + +import org.emftext.language.java.literals.DecimalFloatLiteral; + +public interface IDecimalFloatLiteralInitialiser extends IFloatLiteralInitialiser { + @Override + public DecimalFloatLiteral instantiate(); + + public default boolean setDecimalValue(DecimalFloatLiteral dfl, float val) { + dfl.setDecimalValue(val); + return dfl.getDecimalValue() == val; + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/IDecimalIntegerLiteralInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/IDecimalIntegerLiteralInitialiser.java new file mode 100644 index 0000000000..e087787f4e --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/IDecimalIntegerLiteralInitialiser.java @@ -0,0 +1,19 @@ +package cipm.consistency.initialisers.jamopp.literals; + +import java.math.BigInteger; + +import org.emftext.language.java.literals.DecimalIntegerLiteral; + +public interface IDecimalIntegerLiteralInitialiser extends IIntegerLiteralInitialiser { + @Override + public DecimalIntegerLiteral instantiate(); + + public default boolean setDecimalValue(DecimalIntegerLiteral dil, BigInteger val) { + dil.setDecimalValue(val); + return (val == null && dil.getDecimalValue() == null) || dil.getDecimalValue().equals(val); + } + + public default boolean setDecimalValue(DecimalIntegerLiteral dil, int val) { + return this.setDecimalValue(dil, BigInteger.valueOf(val)); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/IDecimalLongLiteralInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/IDecimalLongLiteralInitialiser.java new file mode 100644 index 0000000000..3266d6b667 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/IDecimalLongLiteralInitialiser.java @@ -0,0 +1,19 @@ +package cipm.consistency.initialisers.jamopp.literals; + +import java.math.BigInteger; + +import org.emftext.language.java.literals.DecimalLongLiteral; + +public interface IDecimalLongLiteralInitialiser extends ILongLiteralInitialiser { + @Override + public DecimalLongLiteral instantiate(); + + public default boolean setDecimalValue(DecimalLongLiteral dll, BigInteger val) { + dll.setDecimalValue(val); + return (val == null && dll.getDecimalValue() == null) || dll.getDecimalValue().equals(val); + } + + public default boolean setDecimalValue(DecimalLongLiteral dll, long val) { + return this.setDecimalValue(dll, BigInteger.valueOf(val)); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/IDoubleLiteralInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/IDoubleLiteralInitialiser.java new file mode 100644 index 0000000000..1414cbbe1a --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/IDoubleLiteralInitialiser.java @@ -0,0 +1,9 @@ +package cipm.consistency.initialisers.jamopp.literals; + +import org.emftext.language.java.literals.DoubleLiteral; + +public interface IDoubleLiteralInitialiser extends ILiteralInitialiser { + @Override + public DoubleLiteral instantiate(); + +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/IFloatLiteralInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/IFloatLiteralInitialiser.java new file mode 100644 index 0000000000..7ae0d44abd --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/IFloatLiteralInitialiser.java @@ -0,0 +1,9 @@ +package cipm.consistency.initialisers.jamopp.literals; + +import org.emftext.language.java.literals.FloatLiteral; + +public interface IFloatLiteralInitialiser extends ILiteralInitialiser { + @Override + public FloatLiteral instantiate(); + +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/IHexDoubleLiteralInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/IHexDoubleLiteralInitialiser.java new file mode 100644 index 0000000000..7d40b01fd9 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/IHexDoubleLiteralInitialiser.java @@ -0,0 +1,13 @@ +package cipm.consistency.initialisers.jamopp.literals; + +import org.emftext.language.java.literals.HexDoubleLiteral; + +public interface IHexDoubleLiteralInitialiser extends IDoubleLiteralInitialiser { + @Override + public HexDoubleLiteral instantiate(); + + public default boolean setHexValue(HexDoubleLiteral hdl, double val) { + hdl.setHexValue(val); + return hdl.getHexValue() == val; + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/IHexFloatLiteralInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/IHexFloatLiteralInitialiser.java new file mode 100644 index 0000000000..36318bcca6 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/IHexFloatLiteralInitialiser.java @@ -0,0 +1,13 @@ +package cipm.consistency.initialisers.jamopp.literals; + +import org.emftext.language.java.literals.HexFloatLiteral; + +public interface IHexFloatLiteralInitialiser extends IFloatLiteralInitialiser { + @Override + public HexFloatLiteral instantiate(); + + public default boolean setHexValue(HexFloatLiteral hdl, float val) { + hdl.setHexValue(val); + return hdl.getHexValue() == val; + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/IHexIntegerLiteralInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/IHexIntegerLiteralInitialiser.java new file mode 100644 index 0000000000..40eb272eef --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/IHexIntegerLiteralInitialiser.java @@ -0,0 +1,19 @@ +package cipm.consistency.initialisers.jamopp.literals; + +import java.math.BigInteger; + +import org.emftext.language.java.literals.HexIntegerLiteral; + +public interface IHexIntegerLiteralInitialiser extends IIntegerLiteralInitialiser { + @Override + public HexIntegerLiteral instantiate(); + + public default boolean setHexValue(HexIntegerLiteral hil, BigInteger val) { + hil.setHexValue(val); + return (val == null && hil.getHexValue() == null) || hil.getHexValue().equals(val); + } + + public default boolean setHexValue(HexIntegerLiteral hil, int val) { + return this.setHexValue(hil, BigInteger.valueOf(val)); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/IHexLongLiteralInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/IHexLongLiteralInitialiser.java new file mode 100644 index 0000000000..08b986bf81 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/IHexLongLiteralInitialiser.java @@ -0,0 +1,19 @@ +package cipm.consistency.initialisers.jamopp.literals; + +import java.math.BigInteger; + +import org.emftext.language.java.literals.HexLongLiteral; + +public interface IHexLongLiteralInitialiser extends ILongLiteralInitialiser { + @Override + public HexLongLiteral instantiate(); + + public default boolean setHexValue(HexLongLiteral hll, BigInteger val) { + hll.setHexValue(val); + return (val == null && hll.getHexValue() == null) || hll.getHexValue().equals(val); + } + + public default boolean setHexValue(HexLongLiteral hll, long val) { + return this.setHexValue(hll, BigInteger.valueOf(val)); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/IIntegerLiteralInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/IIntegerLiteralInitialiser.java new file mode 100644 index 0000000000..635a2ff193 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/IIntegerLiteralInitialiser.java @@ -0,0 +1,9 @@ +package cipm.consistency.initialisers.jamopp.literals; + +import org.emftext.language.java.literals.IntegerLiteral; + +public interface IIntegerLiteralInitialiser extends ILiteralInitialiser { + @Override + public IntegerLiteral instantiate(); + +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/ILiteralInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/ILiteralInitialiser.java new file mode 100644 index 0000000000..6c34f41483 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/ILiteralInitialiser.java @@ -0,0 +1,11 @@ +package cipm.consistency.initialisers.jamopp.literals; + +import org.emftext.language.java.literals.Literal; + +import cipm.consistency.initialisers.jamopp.expressions.IPrimaryExpressionInitialiser; + +public interface ILiteralInitialiser extends IPrimaryExpressionInitialiser { + @Override + public Literal instantiate(); + +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/ILongLiteralInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/ILongLiteralInitialiser.java new file mode 100644 index 0000000000..ef1072d750 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/ILongLiteralInitialiser.java @@ -0,0 +1,9 @@ +package cipm.consistency.initialisers.jamopp.literals; + +import org.emftext.language.java.literals.LongLiteral; + +public interface ILongLiteralInitialiser extends ILiteralInitialiser { + @Override + public LongLiteral instantiate(); + +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/INullLiteralInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/INullLiteralInitialiser.java new file mode 100644 index 0000000000..03c4ac6128 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/INullLiteralInitialiser.java @@ -0,0 +1,9 @@ +package cipm.consistency.initialisers.jamopp.literals; + +import org.emftext.language.java.literals.NullLiteral; + +public interface INullLiteralInitialiser extends ILiteralInitialiser { + @Override + public NullLiteral instantiate(); + +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/IOctalIntegerLiteralInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/IOctalIntegerLiteralInitialiser.java new file mode 100644 index 0000000000..abdbb6eae4 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/IOctalIntegerLiteralInitialiser.java @@ -0,0 +1,19 @@ +package cipm.consistency.initialisers.jamopp.literals; + +import java.math.BigInteger; + +import org.emftext.language.java.literals.OctalIntegerLiteral; + +public interface IOctalIntegerLiteralInitialiser extends IIntegerLiteralInitialiser { + @Override + public OctalIntegerLiteral instantiate(); + + public default boolean setOctalValue(OctalIntegerLiteral oil, BigInteger val) { + oil.setOctalValue(val); + return (val == null && oil.getOctalValue() == null) || oil.getOctalValue().equals(val); + } + + public default boolean setOctalValue(OctalIntegerLiteral oil, int val) { + return this.setOctalValue(oil, BigInteger.valueOf(val)); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/IOctalLongLiteralInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/IOctalLongLiteralInitialiser.java new file mode 100644 index 0000000000..6e1f039e20 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/IOctalLongLiteralInitialiser.java @@ -0,0 +1,19 @@ +package cipm.consistency.initialisers.jamopp.literals; + +import java.math.BigInteger; + +import org.emftext.language.java.literals.OctalLongLiteral; + +public interface IOctalLongLiteralInitialiser extends ILongLiteralInitialiser { + @Override + public OctalLongLiteral instantiate(); + + public default boolean setOctalValue(OctalLongLiteral oll, BigInteger val) { + oll.setOctalValue(val); + return (val == null && oll.getOctalValue() == null) || oll.getOctalValue().equals(val); + } + + public default boolean setOctalValue(OctalLongLiteral oll, long val) { + return this.setOctalValue(oll, BigInteger.valueOf(val)); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/ISelfInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/ISelfInitialiser.java new file mode 100644 index 0000000000..80ba9fc0a2 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/ISelfInitialiser.java @@ -0,0 +1,11 @@ +package cipm.consistency.initialisers.jamopp.literals; + +import org.emftext.language.java.literals.Self; + +import cipm.consistency.initialisers.jamopp.commons.ICommentableInitialiser; + +public interface ISelfInitialiser extends ICommentableInitialiser { + @Override + public Self instantiate(); + +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/ISuperInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/ISuperInitialiser.java new file mode 100644 index 0000000000..572c609cd0 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/ISuperInitialiser.java @@ -0,0 +1,9 @@ +package cipm.consistency.initialisers.jamopp.literals; + +import org.emftext.language.java.literals.Super; + +public interface ISuperInitialiser extends ISelfInitialiser { + @Override + public Super instantiate(); + +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/IThisInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/IThisInitialiser.java new file mode 100644 index 0000000000..4f6cf1d876 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/IThisInitialiser.java @@ -0,0 +1,9 @@ +package cipm.consistency.initialisers.jamopp.literals; + +import org.emftext.language.java.literals.This; + +public interface IThisInitialiser extends ISelfInitialiser { + @Override + public This instantiate(); + +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/LiteralsInitialiserPackage.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/LiteralsInitialiserPackage.java new file mode 100644 index 0000000000..54128509bd --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/LiteralsInitialiserPackage.java @@ -0,0 +1,34 @@ +package cipm.consistency.initialisers.jamopp.literals; + +import java.util.Collection; + +import cipm.consistency.initialisers.IInitialiser; +import cipm.consistency.initialisers.IInitialiserPackage; + +public class LiteralsInitialiserPackage implements IInitialiserPackage { + @Override + public Collection getInitialiserInstances() { + return this.initCol(new IInitialiser[] { new BinaryIntegerLiteralInitialiser(), + new BinaryLongLiteralInitialiser(), new BooleanLiteralInitialiser(), new CharacterLiteralInitialiser(), + new DecimalDoubleLiteralInitialiser(), new DecimalFloatLiteralInitialiser(), + new DecimalIntegerLiteralInitialiser(), new DecimalLongLiteralInitialiser(), + new HexDoubleLiteralInitialiser(), new HexFloatLiteralInitialiser(), new HexIntegerLiteralInitialiser(), + new HexLongLiteralInitialiser(), new NullLiteralInitialiser(), new OctalIntegerLiteralInitialiser(), + new OctalLongLiteralInitialiser(), new SuperInitialiser(), new ThisInitialiser(), }); + } + + @SuppressWarnings("unchecked") + @Override + public Collection> getInitialiserInterfaceTypes() { + return this.initCol(new Class[] { IBinaryIntegerLiteralInitialiser.class, IBinaryLongLiteralInitialiser.class, + IBooleanLiteralInitialiser.class, ICharacterLiteralInitialiser.class, + IDecimalDoubleLiteralInitialiser.class, IDecimalFloatLiteralInitialiser.class, + IDecimalIntegerLiteralInitialiser.class, IDecimalLongLiteralInitialiser.class, + IDoubleLiteralInitialiser.class, IFloatLiteralInitialiser.class, IHexDoubleLiteralInitialiser.class, + IHexFloatLiteralInitialiser.class, IHexIntegerLiteralInitialiser.class, + IHexLongLiteralInitialiser.class, IIntegerLiteralInitialiser.class, ILiteralInitialiser.class, + ILongLiteralInitialiser.class, INullLiteralInitialiser.class, IOctalIntegerLiteralInitialiser.class, + IOctalLongLiteralInitialiser.class, ISelfInitialiser.class, ISuperInitialiser.class, + IThisInitialiser.class, }); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/NullLiteralInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/NullLiteralInitialiser.java new file mode 100644 index 0000000000..c1c0347de7 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/NullLiteralInitialiser.java @@ -0,0 +1,18 @@ +package cipm.consistency.initialisers.jamopp.literals; + +import org.emftext.language.java.literals.LiteralsFactory; +import org.emftext.language.java.literals.NullLiteral; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class NullLiteralInitialiser extends AbstractInitialiserBase implements INullLiteralInitialiser { + @Override + public INullLiteralInitialiser newInitialiser() { + return new NullLiteralInitialiser(); + } + + @Override + public NullLiteral instantiate() { + return LiteralsFactory.eINSTANCE.createNullLiteral(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/OctalIntegerLiteralInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/OctalIntegerLiteralInitialiser.java new file mode 100644 index 0000000000..16651f562b --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/OctalIntegerLiteralInitialiser.java @@ -0,0 +1,18 @@ +package cipm.consistency.initialisers.jamopp.literals; + +import org.emftext.language.java.literals.LiteralsFactory; +import org.emftext.language.java.literals.OctalIntegerLiteral; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class OctalIntegerLiteralInitialiser extends AbstractInitialiserBase implements IOctalIntegerLiteralInitialiser { + @Override + public IOctalIntegerLiteralInitialiser newInitialiser() { + return new OctalIntegerLiteralInitialiser(); + } + + @Override + public OctalIntegerLiteral instantiate() { + return LiteralsFactory.eINSTANCE.createOctalIntegerLiteral(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/OctalLongLiteralInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/OctalLongLiteralInitialiser.java new file mode 100644 index 0000000000..bd58a855f4 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/OctalLongLiteralInitialiser.java @@ -0,0 +1,18 @@ +package cipm.consistency.initialisers.jamopp.literals; + +import org.emftext.language.java.literals.LiteralsFactory; +import org.emftext.language.java.literals.OctalLongLiteral; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class OctalLongLiteralInitialiser extends AbstractInitialiserBase implements IOctalLongLiteralInitialiser { + @Override + public IOctalLongLiteralInitialiser newInitialiser() { + return new OctalLongLiteralInitialiser(); + } + + @Override + public OctalLongLiteral instantiate() { + return LiteralsFactory.eINSTANCE.createOctalLongLiteral(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/SuperInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/SuperInitialiser.java new file mode 100644 index 0000000000..659d39cbb8 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/SuperInitialiser.java @@ -0,0 +1,18 @@ +package cipm.consistency.initialisers.jamopp.literals; + +import org.emftext.language.java.literals.LiteralsFactory; +import org.emftext.language.java.literals.Super; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class SuperInitialiser extends AbstractInitialiserBase implements ISuperInitialiser { + @Override + public ISuperInitialiser newInitialiser() { + return new SuperInitialiser(); + } + + @Override + public Super instantiate() { + return LiteralsFactory.eINSTANCE.createSuper(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/ThisInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/ThisInitialiser.java new file mode 100644 index 0000000000..190b6d0183 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/ThisInitialiser.java @@ -0,0 +1,18 @@ +package cipm.consistency.initialisers.jamopp.literals; + +import org.emftext.language.java.literals.LiteralsFactory; +import org.emftext.language.java.literals.This; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class ThisInitialiser extends AbstractInitialiserBase implements IThisInitialiser { + @Override + public IThisInitialiser newInitialiser() { + return new ThisInitialiser(); + } + + @Override + public This instantiate() { + return LiteralsFactory.eINSTANCE.createThis(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/package-info.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/package-info.java new file mode 100644 index 0000000000..8eb5b75ed8 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/package-info.java @@ -0,0 +1,5 @@ +/** + * Contains {@link IInitialiser} implementations for + * {@link org.emftext.language.java.literals}. + */ +package cipm.consistency.initialisers.jamopp.literals; \ No newline at end of file From 73e5d7aa93b920aa8ef25debdf53b901f5dd0f59 Mon Sep 17 00:00:00 2001 From: AlpTorac Date: Fri, 25 Oct 2024 17:37:25 +0200 Subject: [PATCH 21/55] (WIP) Implement initialiser package for org.emftext.language.java.members --- .../members/AdditionalFieldInitialiser.java | 19 +++++++ .../members/ClassMethodInitialiser.java | 19 +++++++ .../members/ConstructorInitialiser.java | 19 +++++++ .../members/EmptyMemberInitialiser.java | 18 ++++++ .../members/EnumConstantInitialiser.java | 19 +++++++ .../jamopp/members/FieldInitialiser.java | 18 ++++++ .../members/IAdditionalFieldInitialiser.java | 13 +++++ .../members/IClassMethodInitialiser.java | 57 +++++++++++++++++++ .../members/IConstructorInitialiser.java | 23 ++++++++ .../members/IEmptyMemberInitialiser.java | 9 +++ .../members/IEnumConstantInitialiser.java | 19 +++++++ .../members/IExceptionThrowerInitialiser.java | 23 ++++++++ .../jamopp/members/IFieldInitialiser.java | 26 +++++++++ .../members/IInterfaceMethodInitialiser.java | 14 +++++ .../members/IMemberContainerInitialiser.java | 48 ++++++++++++++++ .../jamopp/members/IMemberInitialiser.java | 10 ++++ .../jamopp/members/IMethodInitialiser.java | 17 ++++++ .../members/InterfaceMethodInitialiser.java | 19 +++++++ .../members/MembersInitialiserPackage.java | 24 ++++++++ .../jamopp/members/package-info.java | 5 ++ 20 files changed, 419 insertions(+) create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/members/AdditionalFieldInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/members/ClassMethodInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/members/ConstructorInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/members/EmptyMemberInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/members/EnumConstantInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/members/FieldInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/members/IAdditionalFieldInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/members/IClassMethodInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/members/IConstructorInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/members/IEmptyMemberInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/members/IEnumConstantInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/members/IExceptionThrowerInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/members/IFieldInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/members/IInterfaceMethodInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/members/IMemberContainerInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/members/IMemberInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/members/IMethodInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/members/InterfaceMethodInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/members/MembersInitialiserPackage.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/members/package-info.java diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/members/AdditionalFieldInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/members/AdditionalFieldInitialiser.java new file mode 100644 index 0000000000..91e7fac024 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/members/AdditionalFieldInitialiser.java @@ -0,0 +1,19 @@ +package cipm.consistency.initialisers.jamopp.members; + +import org.emftext.language.java.members.MembersFactory; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +import org.emftext.language.java.members.AdditionalField; + +public class AdditionalFieldInitialiser extends AbstractInitialiserBase implements IAdditionalFieldInitialiser { + @Override + public IAdditionalFieldInitialiser newInitialiser() { + return new AdditionalFieldInitialiser(); + } + + @Override + public AdditionalField instantiate() { + return MembersFactory.eINSTANCE.createAdditionalField(); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/members/ClassMethodInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/members/ClassMethodInitialiser.java new file mode 100644 index 0000000000..f7511ca2d8 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/members/ClassMethodInitialiser.java @@ -0,0 +1,19 @@ +package cipm.consistency.initialisers.jamopp.members; + +import org.emftext.language.java.members.MembersFactory; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +import org.emftext.language.java.members.ClassMethod; + +public class ClassMethodInitialiser extends AbstractInitialiserBase implements IClassMethodInitialiser { + @Override + public ClassMethod instantiate() { + return MembersFactory.eINSTANCE.createClassMethod(); + } + + @Override + public ClassMethodInitialiser newInitialiser() { + return new ClassMethodInitialiser(); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/members/ConstructorInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/members/ConstructorInitialiser.java new file mode 100644 index 0000000000..8f24387404 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/members/ConstructorInitialiser.java @@ -0,0 +1,19 @@ +package cipm.consistency.initialisers.jamopp.members; + +import org.emftext.language.java.members.MembersFactory; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +import org.emftext.language.java.members.Constructor; + +public class ConstructorInitialiser extends AbstractInitialiserBase implements IConstructorInitialiser { + @Override + public Constructor instantiate() { + return MembersFactory.eINSTANCE.createConstructor(); + } + + @Override + public ConstructorInitialiser newInitialiser() { + return new ConstructorInitialiser(); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/members/EmptyMemberInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/members/EmptyMemberInitialiser.java new file mode 100644 index 0000000000..75ae9bfb76 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/members/EmptyMemberInitialiser.java @@ -0,0 +1,18 @@ +package cipm.consistency.initialisers.jamopp.members; + +import org.emftext.language.java.members.EmptyMember; +import org.emftext.language.java.members.MembersFactory; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class EmptyMemberInitialiser extends AbstractInitialiserBase implements IEmptyMemberInitialiser { + @Override + public IEmptyMemberInitialiser newInitialiser() { + return new EmptyMemberInitialiser(); + } + + @Override + public EmptyMember instantiate() { + return MembersFactory.eINSTANCE.createEmptyMember(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/members/EnumConstantInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/members/EnumConstantInitialiser.java new file mode 100644 index 0000000000..034568dc67 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/members/EnumConstantInitialiser.java @@ -0,0 +1,19 @@ +package cipm.consistency.initialisers.jamopp.members; + +import org.emftext.language.java.members.MembersFactory; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +import org.emftext.language.java.members.EnumConstant; + +public class EnumConstantInitialiser extends AbstractInitialiserBase implements IEnumConstantInitialiser { + @Override + public EnumConstant instantiate() { + return MembersFactory.eINSTANCE.createEnumConstant(); + } + + @Override + public IEnumConstantInitialiser newInitialiser() { + return new EnumConstantInitialiser(); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/members/FieldInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/members/FieldInitialiser.java new file mode 100644 index 0000000000..4285301f7c --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/members/FieldInitialiser.java @@ -0,0 +1,18 @@ +package cipm.consistency.initialisers.jamopp.members; + +import org.emftext.language.java.members.Field; +import org.emftext.language.java.members.MembersFactory; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class FieldInitialiser extends AbstractInitialiserBase implements IFieldInitialiser { + @Override + public Field instantiate() { + return MembersFactory.eINSTANCE.createField(); + } + + @Override + public FieldInitialiser newInitialiser() { + return new FieldInitialiser(); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/members/IAdditionalFieldInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/members/IAdditionalFieldInitialiser.java new file mode 100644 index 0000000000..7e76c708de --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/members/IAdditionalFieldInitialiser.java @@ -0,0 +1,13 @@ +package cipm.consistency.initialisers.jamopp.members; + +import org.emftext.language.java.members.AdditionalField; + +import cipm.consistency.initialisers.jamopp.instantiations.IInitializableInitialiser; +import cipm.consistency.initialisers.jamopp.references.IReferenceableElementInitialiser; +import cipm.consistency.initialisers.jamopp.types.ITypedElementInitialiser; + +public interface IAdditionalFieldInitialiser + extends IInitializableInitialiser, IReferenceableElementInitialiser, ITypedElementInitialiser { + @Override + public AdditionalField instantiate(); +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/members/IClassMethodInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/members/IClassMethodInitialiser.java new file mode 100644 index 0000000000..ee2cb6b255 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/members/IClassMethodInitialiser.java @@ -0,0 +1,57 @@ +package cipm.consistency.initialisers.jamopp.members; + +import org.emftext.language.java.members.ClassMethod; +import org.emftext.language.java.statements.Statement; +import org.emftext.language.java.statements.StatementListContainer; + +import cipm.consistency.initialisers.jamopp.statements.IStatementListContainerInitialiser; + +/** + * An interface meant for {@link IInitialiser} implementors that are supposed to + * create {@link ClassMethod} instances.
+ *
+ * Due to inconsistencies regarding {@link ClassMethod}, it provides 2 methods + * for adding {@link Statement} instances to it. Adding multiple statements is + * only possible via {@code classMethod.getStatement().add(...)}, which only + * works if classMethod has a {@link Block} set as its statement. This can be + * achieved by passing a {@link Block} instance to + * {@link #setStatement(org.emftext.language.java.statements.StatementContainer, Statement)}. + *
+ *
+ * Otherwise, one may only add a single statement to {@link ClassMethod} via + * {@code classMethod.setStatement(...)}. Note that the said method will + * REPLACE the former statement when used. + * + * @author Alp Torac Genc + * + */ +public interface IClassMethodInitialiser extends IMethodInitialiser, IStatementListContainerInitialiser { + @Override + public ClassMethod instantiate(); + + /** + * A {@link Block} instance must be added to slc (a {@link ClassMethod} in this + * case) for this method to function as intended. This can be done via + * {@link #setStatement(org.emftext.language.java.statements.StatementContainer, Statement)}. + * If slc already has its {@link Statement} set via + * {@link #setStatement(org.emftext.language.java.statements.StatementContainer, Statement)}, + * that statement must be saved in a temporal variable before calling the said + * method. It can then be re-added to slc via calling this method.
+ *
+ * Otherwise, {@code slc.setStatement(st)} can be used to add a single + * {@link Statement} to slc. Note that the {@link Statement} added to slc + * this way WILL BE REPLACED, if {@code slc.setStatement(anotherSt)} is + * called.
+ *
+ * Overridden only to provide commentary. + */ + @Override + public default boolean addStatement(StatementListContainer slc, Statement st) { + return IStatementListContainerInitialiser.super.addStatement(slc, st); + } + + @Override + public default boolean canContainStatements(StatementListContainer slc) { + return ((ClassMethod) slc).getBlock() != null; + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/members/IConstructorInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/members/IConstructorInitialiser.java new file mode 100644 index 0000000000..6dc7082e0f --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/members/IConstructorInitialiser.java @@ -0,0 +1,23 @@ +package cipm.consistency.initialisers.jamopp.members; + +import org.emftext.language.java.members.Constructor; +import org.emftext.language.java.statements.StatementListContainer; + +import cipm.consistency.initialisers.jamopp.generics.ITypeParametrizableInitialiser; +import cipm.consistency.initialisers.jamopp.modifiers.IAnnotableAndModifiableInitialiser; +import cipm.consistency.initialisers.jamopp.parameters.IParametrizableInitialiser; +import cipm.consistency.initialisers.jamopp.statements.IBlockContainerInitialiser; +import cipm.consistency.initialisers.jamopp.statements.IStatementListContainerInitialiser; + +public interface IConstructorInitialiser extends IAnnotableAndModifiableInitialiser, IBlockContainerInitialiser, + IExceptionThrowerInitialiser, IMemberInitialiser, IParametrizableInitialiser, + IStatementListContainerInitialiser, ITypeParametrizableInitialiser { + + @Override + public Constructor instantiate(); + + @Override + public default boolean canContainStatements(StatementListContainer slc) { + return ((Constructor) slc).getBlock() != null; + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/members/IEmptyMemberInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/members/IEmptyMemberInitialiser.java new file mode 100644 index 0000000000..252f86424b --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/members/IEmptyMemberInitialiser.java @@ -0,0 +1,9 @@ +package cipm.consistency.initialisers.jamopp.members; + +import org.emftext.language.java.members.EmptyMember; + +public interface IEmptyMemberInitialiser extends IMemberInitialiser { + @Override + public EmptyMember instantiate(); + +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/members/IEnumConstantInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/members/IEnumConstantInitialiser.java new file mode 100644 index 0000000000..52bf696e49 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/members/IEnumConstantInitialiser.java @@ -0,0 +1,19 @@ +package cipm.consistency.initialisers.jamopp.members; + +import org.emftext.language.java.classifiers.AnonymousClass; +import org.emftext.language.java.members.EnumConstant; + +import cipm.consistency.initialisers.jamopp.annotations.IAnnotableInitialiser; +import cipm.consistency.initialisers.jamopp.references.IArgumentableInitialiser; +import cipm.consistency.initialisers.jamopp.references.IReferenceableElementInitialiser; + +public interface IEnumConstantInitialiser + extends IArgumentableInitialiser, IAnnotableInitialiser, IReferenceableElementInitialiser { + @Override + public EnumConstant instantiate(); + + public default boolean setAnonymousClass(EnumConstant ec, AnonymousClass anonymousCls) { + ec.setAnonymousClass(anonymousCls); + return (anonymousCls == null && ec.getAnonymousClass() == null) || ec.getAnonymousClass().equals(anonymousCls); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/members/IExceptionThrowerInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/members/IExceptionThrowerInitialiser.java new file mode 100644 index 0000000000..514a657f92 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/members/IExceptionThrowerInitialiser.java @@ -0,0 +1,23 @@ +package cipm.consistency.initialisers.jamopp.members; + +import org.emftext.language.java.members.ExceptionThrower; +import org.emftext.language.java.types.NamespaceClassifierReference; + +import cipm.consistency.initialisers.jamopp.commons.ICommentableInitialiser; + +public interface IExceptionThrowerInitialiser extends ICommentableInitialiser { + @Override + public ExceptionThrower instantiate(); + + public default boolean addException(ExceptionThrower extt, NamespaceClassifierReference exception) { + if (exception != null) { + extt.getExceptions().add(exception); + return extt.getExceptions().contains(exception); + } + return true; + } + + public default boolean addExceptions(ExceptionThrower extt, NamespaceClassifierReference[] exceptions) { + return this.doMultipleModifications(extt, exceptions, this::addException); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/members/IFieldInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/members/IFieldInitialiser.java new file mode 100644 index 0000000000..0ce8522e30 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/members/IFieldInitialiser.java @@ -0,0 +1,26 @@ +package cipm.consistency.initialisers.jamopp.members; + +import org.emftext.language.java.members.AdditionalField; +import org.emftext.language.java.members.Field; + +import cipm.consistency.initialisers.jamopp.instantiations.IInitializableInitialiser; +import cipm.consistency.initialisers.jamopp.modifiers.IAnnotableAndModifiableInitialiser; +import cipm.consistency.initialisers.jamopp.variables.IVariableInitialiser; + +public interface IFieldInitialiser extends IAnnotableAndModifiableInitialiser, IInitializableInitialiser, + IMemberInitialiser, IVariableInitialiser { + @Override + public Field instantiate(); + + public default boolean addAdditionalField(Field field, AdditionalField additionalField) { + if (additionalField != null) { + field.getAdditionalFields().add(additionalField); + return field.getAdditionalFields().contains(additionalField); + } + return true; + } + + public default boolean addAdditionalFields(Field field, AdditionalField[] additionalFields) { + return this.doMultipleModifications(field, additionalFields, this::addAdditionalField); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/members/IInterfaceMethodInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/members/IInterfaceMethodInitialiser.java new file mode 100644 index 0000000000..f109eb2128 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/members/IInterfaceMethodInitialiser.java @@ -0,0 +1,14 @@ +package cipm.consistency.initialisers.jamopp.members; + +import org.emftext.language.java.annotations.AnnotationValue; +import org.emftext.language.java.members.InterfaceMethod; + +public interface IInterfaceMethodInitialiser extends IMethodInitialiser { + @Override + public InterfaceMethod instantiate(); + + public default boolean setDefaultValue(InterfaceMethod im, AnnotationValue defVal) { + im.setDefaultValue(defVal); + return (defVal == null && im.getDefaultValue() == null) || im.getDefaultValue().equals(defVal); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/members/IMemberContainerInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/members/IMemberContainerInitialiser.java new file mode 100644 index 0000000000..065629a33b --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/members/IMemberContainerInitialiser.java @@ -0,0 +1,48 @@ +package cipm.consistency.initialisers.jamopp.members; + +import org.emftext.language.java.members.Member; +import org.emftext.language.java.members.MemberContainer; + +import cipm.consistency.initialisers.jamopp.commons.ICommentableInitialiser; + +/** + * An interface meant to be implemented by initialisers, which are supposed to + * create {@link MemberContainer} instances.
+ *
+ * {@code mc.createField(...)} method internally creates a {@link Field}, adds + * it to the calling member container mc and returns the said field. It + * introduces no new ways to modify the calling member container.
+ *
+ * Getter methods of {@link MemberContainer} do not return modifiable lists, + * except for {@code mc.getMembers()} and {@code mc.getDefaultMembers()}. + * + * @author Alp Torac Genc + */ +public interface IMemberContainerInitialiser extends ICommentableInitialiser { + @Override + public MemberContainer instantiate(); + + public default boolean addMember(MemberContainer mc, Member mem) { + if (mem != null) { + mc.getMembers().add(mem); + return mc.getMembers().contains(mem); + } + return true; + } + + public default boolean addMembers(MemberContainer mc, Member[] mems) { + return this.doMultipleModifications(mc, mems, this::addMember); + } + + public default boolean addDefaultMember(MemberContainer mc, Member defMem) { + if (defMem != null) { + mc.getDefaultMembers().add(defMem); + return mc.getDefaultMembers().contains(defMem); + } + return true; + } + + public default boolean addDefaultMembers(MemberContainer mc, Member[] defMems) { + return this.doMultipleModifications(mc, defMems, this::addDefaultMember); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/members/IMemberInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/members/IMemberInitialiser.java new file mode 100644 index 0000000000..90a0527ee9 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/members/IMemberInitialiser.java @@ -0,0 +1,10 @@ +package cipm.consistency.initialisers.jamopp.members; + +import org.emftext.language.java.members.Member; + +import cipm.consistency.initialisers.jamopp.commons.INamedElementInitialiser; + +public interface IMemberInitialiser extends INamedElementInitialiser { + @Override + public Member instantiate(); +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/members/IMethodInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/members/IMethodInitialiser.java new file mode 100644 index 0000000000..49b6d0887f --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/members/IMethodInitialiser.java @@ -0,0 +1,17 @@ +package cipm.consistency.initialisers.jamopp.members; + +import org.emftext.language.java.members.Method; + +import cipm.consistency.initialisers.jamopp.generics.ITypeParametrizableInitialiser; +import cipm.consistency.initialisers.jamopp.modifiers.IAnnotableAndModifiableInitialiser; +import cipm.consistency.initialisers.jamopp.parameters.IParametrizableInitialiser; +import cipm.consistency.initialisers.jamopp.references.IReferenceableElementInitialiser; +import cipm.consistency.initialisers.jamopp.statements.IStatementContainerInitialiser; +import cipm.consistency.initialisers.jamopp.types.ITypedElementInitialiser; + +public interface IMethodInitialiser extends IAnnotableAndModifiableInitialiser, IExceptionThrowerInitialiser, + IMemberInitialiser, IReferenceableElementInitialiser, IParametrizableInitialiser, + IStatementContainerInitialiser, ITypedElementInitialiser, ITypeParametrizableInitialiser { + @Override + public Method instantiate(); +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/members/InterfaceMethodInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/members/InterfaceMethodInitialiser.java new file mode 100644 index 0000000000..b4e8a25467 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/members/InterfaceMethodInitialiser.java @@ -0,0 +1,19 @@ +package cipm.consistency.initialisers.jamopp.members; + +import org.emftext.language.java.members.MembersFactory; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +import org.emftext.language.java.members.InterfaceMethod; + +public class InterfaceMethodInitialiser extends AbstractInitialiserBase implements IInterfaceMethodInitialiser { + @Override + public InterfaceMethod instantiate() { + return MembersFactory.eINSTANCE.createInterfaceMethod(); + } + + @Override + public InterfaceMethodInitialiser newInitialiser() { + return new InterfaceMethodInitialiser(); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/members/MembersInitialiserPackage.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/members/MembersInitialiserPackage.java new file mode 100644 index 0000000000..f3ad53c127 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/members/MembersInitialiserPackage.java @@ -0,0 +1,24 @@ +package cipm.consistency.initialisers.jamopp.members; + +import java.util.Collection; + +import cipm.consistency.initialisers.IInitialiser; +import cipm.consistency.initialisers.IInitialiserPackage; + +public class MembersInitialiserPackage implements IInitialiserPackage { + @Override + public Collection getInitialiserInstances() { + return this.initCol(new IInitialiser[] { new AdditionalFieldInitialiser(), new ClassMethodInitialiser(), + new ConstructorInitialiser(), new EmptyMemberInitialiser(), new EnumConstantInitialiser(), + new FieldInitialiser(), new InterfaceMethodInitialiser(), }); + } + + @SuppressWarnings("unchecked") + @Override + public Collection> getInitialiserInterfaceTypes() { + return this.initCol(new Class[] { IAdditionalFieldInitialiser.class, IClassMethodInitialiser.class, + IConstructorInitialiser.class, IEmptyMemberInitialiser.class, IEnumConstantInitialiser.class, + IExceptionThrowerInitialiser.class, IFieldInitialiser.class, IInterfaceMethodInitialiser.class, + IMemberContainerInitialiser.class, IMemberInitialiser.class, IMethodInitialiser.class, }); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/members/package-info.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/members/package-info.java new file mode 100644 index 0000000000..c43905ba82 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/members/package-info.java @@ -0,0 +1,5 @@ +/** + * Contains {@link IInitialiser} implementations for + * {@link org.emftext.language.java.members}. + */ +package cipm.consistency.initialisers.jamopp.members; \ No newline at end of file From 4f51e33ae0f503f93afaf0b6e184eef4b34bfbbf Mon Sep 17 00:00:00 2001 From: AlpTorac Date: Fri, 25 Oct 2024 17:37:43 +0200 Subject: [PATCH 22/55] (WIP) Implement initialiser package for org.emftext.language.java.modules --- .../ExportsModuleDirectiveInitialiser.java | 20 ++++++++++++ ...ssProvidingModuleDirectiveInitialiser.java | 31 +++++++++++++++++++ .../IExportsModuleDirectiveInitialiser.java | 8 +++++ .../modules/IModuleDirectiveInitialiser.java | 11 +++++++ .../modules/IModuleReferenceInitialiser.java | 16 ++++++++++ .../IOpensModuleDirectiveInitialiser.java | 9 ++++++ .../IProvidesModuleDirectiveInitialiser.java | 23 ++++++++++++++ .../IRequiresModuleDirectiveInitialiser.java | 20 ++++++++++++ .../IUsesModuleDirectiveInitialiser.java | 10 ++++++ .../modules/ModuleReferenceInitialiser.java | 18 +++++++++++ .../modules/ModulesInitialiserPackage.java | 26 ++++++++++++++++ .../OpensModuleDirectiveInitialiser.java | 19 ++++++++++++ .../ProvidesModuleDirectiveInitialiser.java | 19 ++++++++++++ .../RequiresModuleDirectiveInitialiser.java | 19 ++++++++++++ .../UsesModuleDirectiveInitialiser.java | 18 +++++++++++ .../jamopp/modules/package-info.java | 5 +++ 16 files changed, 272 insertions(+) create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modules/ExportsModuleDirectiveInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modules/IAccessProvidingModuleDirectiveInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modules/IExportsModuleDirectiveInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modules/IModuleDirectiveInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modules/IModuleReferenceInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modules/IOpensModuleDirectiveInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modules/IProvidesModuleDirectiveInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modules/IRequiresModuleDirectiveInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modules/IUsesModuleDirectiveInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modules/ModuleReferenceInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modules/ModulesInitialiserPackage.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modules/OpensModuleDirectiveInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modules/ProvidesModuleDirectiveInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modules/RequiresModuleDirectiveInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modules/UsesModuleDirectiveInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modules/package-info.java diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modules/ExportsModuleDirectiveInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modules/ExportsModuleDirectiveInitialiser.java new file mode 100644 index 0000000000..4e6a5f7640 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modules/ExportsModuleDirectiveInitialiser.java @@ -0,0 +1,20 @@ +package cipm.consistency.initialisers.jamopp.modules; + +import org.emftext.language.java.modules.ModulesFactory; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +import org.emftext.language.java.modules.ExportsModuleDirective; + +public class ExportsModuleDirectiveInitialiser extends AbstractInitialiserBase + implements IExportsModuleDirectiveInitialiser { + @Override + public IExportsModuleDirectiveInitialiser newInitialiser() { + return new ExportsModuleDirectiveInitialiser(); + } + + @Override + public ExportsModuleDirective instantiate() { + return ModulesFactory.eINSTANCE.createExportsModuleDirective(); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modules/IAccessProvidingModuleDirectiveInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modules/IAccessProvidingModuleDirectiveInitialiser.java new file mode 100644 index 0000000000..a5cebd8d4f --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modules/IAccessProvidingModuleDirectiveInitialiser.java @@ -0,0 +1,31 @@ +package cipm.consistency.initialisers.jamopp.modules; + +import org.emftext.language.java.containers.Package; +import org.emftext.language.java.modules.AccessProvidingModuleDirective; +import org.emftext.language.java.modules.ModuleReference; + +import cipm.consistency.initialisers.jamopp.commons.INamespaceAwareElementInitialiser; + +public interface IAccessProvidingModuleDirectiveInitialiser + extends IModuleDirectiveInitialiser, INamespaceAwareElementInitialiser { + @Override + public AccessProvidingModuleDirective instantiate(); + + public default boolean setAccessablePackage(AccessProvidingModuleDirective apmd, Package accessablePac) { + apmd.setAccessablePackage(accessablePac); + return (accessablePac == null && apmd.getAccessablePackage() == null) + || apmd.getAccessablePackage().equals(accessablePac); + } + + public default boolean addModule(AccessProvidingModuleDirective apmd, ModuleReference mod) { + if (mod != null) { + apmd.getModules().add(mod); + return apmd.getModules().contains(mod); + } + return true; + } + + public default boolean addModules(AccessProvidingModuleDirective apmd, ModuleReference[] mods) { + return this.doMultipleModifications(apmd, mods, this::addModule); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modules/IExportsModuleDirectiveInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modules/IExportsModuleDirectiveInitialiser.java new file mode 100644 index 0000000000..fb47a93778 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modules/IExportsModuleDirectiveInitialiser.java @@ -0,0 +1,8 @@ +package cipm.consistency.initialisers.jamopp.modules; + +import org.emftext.language.java.modules.ExportsModuleDirective; + +public interface IExportsModuleDirectiveInitialiser extends IAccessProvidingModuleDirectiveInitialiser { + @Override + public ExportsModuleDirective instantiate(); +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modules/IModuleDirectiveInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modules/IModuleDirectiveInitialiser.java new file mode 100644 index 0000000000..de2f1b1183 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modules/IModuleDirectiveInitialiser.java @@ -0,0 +1,11 @@ +package cipm.consistency.initialisers.jamopp.modules; + +import org.emftext.language.java.modules.ModuleDirective; + +import cipm.consistency.initialisers.jamopp.commons.ICommentableInitialiser; + +public interface IModuleDirectiveInitialiser extends ICommentableInitialiser { + @Override + public ModuleDirective instantiate(); + +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modules/IModuleReferenceInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modules/IModuleReferenceInitialiser.java new file mode 100644 index 0000000000..5d9f4cbf20 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modules/IModuleReferenceInitialiser.java @@ -0,0 +1,16 @@ +package cipm.consistency.initialisers.jamopp.modules; + +import org.emftext.language.java.containers.Module; +import org.emftext.language.java.modules.ModuleReference; + +import cipm.consistency.initialisers.jamopp.commons.INamespaceAwareElementInitialiser; + +public interface IModuleReferenceInitialiser extends INamespaceAwareElementInitialiser { + @Override + public ModuleReference instantiate(); + + public default boolean setTarget(ModuleReference mref, Module target) { + mref.setTarget(target); + return (target == null && mref.getTarget() == null) || mref.getTarget().equals(target); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modules/IOpensModuleDirectiveInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modules/IOpensModuleDirectiveInitialiser.java new file mode 100644 index 0000000000..c70121f14d --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modules/IOpensModuleDirectiveInitialiser.java @@ -0,0 +1,9 @@ +package cipm.consistency.initialisers.jamopp.modules; + +import org.emftext.language.java.modules.OpensModuleDirective; + +public interface IOpensModuleDirectiveInitialiser extends IAccessProvidingModuleDirectiveInitialiser { + @Override + public OpensModuleDirective instantiate(); + +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modules/IProvidesModuleDirectiveInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modules/IProvidesModuleDirectiveInitialiser.java new file mode 100644 index 0000000000..a868d73fe9 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modules/IProvidesModuleDirectiveInitialiser.java @@ -0,0 +1,23 @@ +package cipm.consistency.initialisers.jamopp.modules; + +import org.emftext.language.java.modules.ProvidesModuleDirective; +import org.emftext.language.java.types.TypeReference; + +import cipm.consistency.initialisers.jamopp.types.ITypedElementInitialiser; + +public interface IProvidesModuleDirectiveInitialiser extends IModuleDirectiveInitialiser, ITypedElementInitialiser { + @Override + public ProvidesModuleDirective instantiate(); + + public default boolean addServiceProvider(ProvidesModuleDirective pmd, TypeReference serviceProvider) { + if (serviceProvider != null) { + pmd.getServiceProviders().add(serviceProvider); + return pmd.getServiceProviders().contains(serviceProvider); + } + return true; + } + + public default boolean addServiceProviders(ProvidesModuleDirective pmd, TypeReference[] serviceProviders) { + return this.doMultipleModifications(pmd, serviceProviders, this::addServiceProvider); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modules/IRequiresModuleDirectiveInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modules/IRequiresModuleDirectiveInitialiser.java new file mode 100644 index 0000000000..06611071c6 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modules/IRequiresModuleDirectiveInitialiser.java @@ -0,0 +1,20 @@ +package cipm.consistency.initialisers.jamopp.modules; + +import org.emftext.language.java.modifiers.ModuleRequiresModifier; +import org.emftext.language.java.modules.ModuleReference; +import org.emftext.language.java.modules.RequiresModuleDirective; + +public interface IRequiresModuleDirectiveInitialiser extends IModuleDirectiveInitialiser { + @Override + public RequiresModuleDirective instantiate(); + + public default boolean setModifier(RequiresModuleDirective rmd, ModuleRequiresModifier modif) { + rmd.setModifier(modif); + return (modif == null && rmd.getModifier() == null) || rmd.getModifier().equals(modif); + } + + public default boolean setRequiredModule(RequiresModuleDirective rmd, ModuleReference reqMod) { + rmd.setRequiredModule(reqMod); + return (reqMod == null && rmd.getRequiredModule() == null) || rmd.getRequiredModule().equals(reqMod); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modules/IUsesModuleDirectiveInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modules/IUsesModuleDirectiveInitialiser.java new file mode 100644 index 0000000000..79f73e7bfc --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modules/IUsesModuleDirectiveInitialiser.java @@ -0,0 +1,10 @@ +package cipm.consistency.initialisers.jamopp.modules; + +import org.emftext.language.java.modules.UsesModuleDirective; + +import cipm.consistency.initialisers.jamopp.types.ITypedElementInitialiser; + +public interface IUsesModuleDirectiveInitialiser extends IModuleDirectiveInitialiser, ITypedElementInitialiser { + @Override + public UsesModuleDirective instantiate(); +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modules/ModuleReferenceInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modules/ModuleReferenceInitialiser.java new file mode 100644 index 0000000000..6236cc2b31 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modules/ModuleReferenceInitialiser.java @@ -0,0 +1,18 @@ +package cipm.consistency.initialisers.jamopp.modules; + +import org.emftext.language.java.modules.ModuleReference; +import org.emftext.language.java.modules.ModulesFactory; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class ModuleReferenceInitialiser extends AbstractInitialiserBase implements IModuleReferenceInitialiser { + @Override + public IModuleReferenceInitialiser newInitialiser() { + return new ModuleReferenceInitialiser(); + } + + @Override + public ModuleReference instantiate() { + return ModulesFactory.eINSTANCE.createModuleReference(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modules/ModulesInitialiserPackage.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modules/ModulesInitialiserPackage.java new file mode 100644 index 0000000000..6d2fa8da89 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modules/ModulesInitialiserPackage.java @@ -0,0 +1,26 @@ +package cipm.consistency.initialisers.jamopp.modules; + +import java.util.Collection; + +import cipm.consistency.initialisers.IInitialiser; +import cipm.consistency.initialisers.IInitialiserPackage; + +public class ModulesInitialiserPackage implements IInitialiserPackage { + @Override + public Collection getInitialiserInstances() { + return this + .initCol(new IInitialiser[] { new ExportsModuleDirectiveInitialiser(), new ModuleReferenceInitialiser(), + new OpensModuleDirectiveInitialiser(), new ProvidesModuleDirectiveInitialiser(), + new RequiresModuleDirectiveInitialiser(), new UsesModuleDirectiveInitialiser(), }); + } + + @SuppressWarnings("unchecked") + @Override + public Collection> getInitialiserInterfaceTypes() { + return this.initCol(new Class[] { IAccessProvidingModuleDirectiveInitialiser.class, + IExportsModuleDirectiveInitialiser.class, IModuleDirectiveInitialiser.class, + IModuleReferenceInitialiser.class, IOpensModuleDirectiveInitialiser.class, + IProvidesModuleDirectiveInitialiser.class, IRequiresModuleDirectiveInitialiser.class, + IUsesModuleDirectiveInitialiser.class, }); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modules/OpensModuleDirectiveInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modules/OpensModuleDirectiveInitialiser.java new file mode 100644 index 0000000000..ecabb28de7 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modules/OpensModuleDirectiveInitialiser.java @@ -0,0 +1,19 @@ +package cipm.consistency.initialisers.jamopp.modules; + +import org.emftext.language.java.modules.ModulesFactory; +import org.emftext.language.java.modules.OpensModuleDirective; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class OpensModuleDirectiveInitialiser extends AbstractInitialiserBase + implements IOpensModuleDirectiveInitialiser { + @Override + public IOpensModuleDirectiveInitialiser newInitialiser() { + return new OpensModuleDirectiveInitialiser(); + } + + @Override + public OpensModuleDirective instantiate() { + return ModulesFactory.eINSTANCE.createOpensModuleDirective(); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modules/ProvidesModuleDirectiveInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modules/ProvidesModuleDirectiveInitialiser.java new file mode 100644 index 0000000000..3dca94bcd9 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modules/ProvidesModuleDirectiveInitialiser.java @@ -0,0 +1,19 @@ +package cipm.consistency.initialisers.jamopp.modules; + +import org.emftext.language.java.modules.ModulesFactory; +import org.emftext.language.java.modules.ProvidesModuleDirective; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class ProvidesModuleDirectiveInitialiser extends AbstractInitialiserBase + implements IProvidesModuleDirectiveInitialiser { + @Override + public IProvidesModuleDirectiveInitialiser newInitialiser() { + return new ProvidesModuleDirectiveInitialiser(); + } + + @Override + public ProvidesModuleDirective instantiate() { + return ModulesFactory.eINSTANCE.createProvidesModuleDirective(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modules/RequiresModuleDirectiveInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modules/RequiresModuleDirectiveInitialiser.java new file mode 100644 index 0000000000..d698fa74bd --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modules/RequiresModuleDirectiveInitialiser.java @@ -0,0 +1,19 @@ +package cipm.consistency.initialisers.jamopp.modules; + +import org.emftext.language.java.modules.ModulesFactory; +import org.emftext.language.java.modules.RequiresModuleDirective; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class RequiresModuleDirectiveInitialiser extends AbstractInitialiserBase + implements IRequiresModuleDirectiveInitialiser { + @Override + public IRequiresModuleDirectiveInitialiser newInitialiser() { + return new RequiresModuleDirectiveInitialiser(); + } + + @Override + public RequiresModuleDirective instantiate() { + return ModulesFactory.eINSTANCE.createRequiresModuleDirective(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modules/UsesModuleDirectiveInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modules/UsesModuleDirectiveInitialiser.java new file mode 100644 index 0000000000..3784a49959 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modules/UsesModuleDirectiveInitialiser.java @@ -0,0 +1,18 @@ +package cipm.consistency.initialisers.jamopp.modules; + +import org.emftext.language.java.modules.ModulesFactory; +import org.emftext.language.java.modules.UsesModuleDirective; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class UsesModuleDirectiveInitialiser extends AbstractInitialiserBase implements IUsesModuleDirectiveInitialiser { + @Override + public IUsesModuleDirectiveInitialiser newInitialiser() { + return new UsesModuleDirectiveInitialiser(); + } + + @Override + public UsesModuleDirective instantiate() { + return ModulesFactory.eINSTANCE.createUsesModuleDirective(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modules/package-info.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modules/package-info.java new file mode 100644 index 0000000000..c47531f1d7 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/modules/package-info.java @@ -0,0 +1,5 @@ +/** + * Contains {@link IInitialiser} implementations for + * {@link org.emftext.language.java.modules}. + */ +package cipm.consistency.initialisers.jamopp.modules; \ No newline at end of file From 5011c45d7eda9c6140b49d1cf3fd8784edc9dc22 Mon Sep 17 00:00:00 2001 From: AlpTorac Date: Fri, 25 Oct 2024 17:37:58 +0200 Subject: [PATCH 23/55] (WIP) Implement initialiser package for org.emftext.language.java.parameters --- .../parameters/CatchParameterInitialiser.java | 19 +++++++++++++++ .../ICatchParameterInitialiser.java | 21 +++++++++++++++++ .../IOrdinaryParameterInitialiser.java | 8 +++++++ .../parameters/IParameterInitialiser.java | 11 +++++++++ .../IParametrizableInitialiser.java | 23 +++++++++++++++++++ .../IReceiverParameterInitialiser.java | 22 ++++++++++++++++++ .../IVariableLengthParameterInitialiser.java | 10 ++++++++ .../OrdinaryParameterInitialiser.java | 19 +++++++++++++++ .../ParametersInitialiserPackage.java | 22 ++++++++++++++++++ .../ReceiverParameterInitialiser.java | 18 +++++++++++++++ .../VariableLengthParameterInitialiser.java | 19 +++++++++++++++ .../jamopp/parameters/package-info.java | 5 ++++ 12 files changed, 197 insertions(+) create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/parameters/CatchParameterInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/parameters/ICatchParameterInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/parameters/IOrdinaryParameterInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/parameters/IParameterInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/parameters/IParametrizableInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/parameters/IReceiverParameterInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/parameters/IVariableLengthParameterInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/parameters/OrdinaryParameterInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/parameters/ParametersInitialiserPackage.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/parameters/ReceiverParameterInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/parameters/VariableLengthParameterInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/parameters/package-info.java diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/parameters/CatchParameterInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/parameters/CatchParameterInitialiser.java new file mode 100644 index 0000000000..ca4b3746cd --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/parameters/CatchParameterInitialiser.java @@ -0,0 +1,19 @@ +package cipm.consistency.initialisers.jamopp.parameters; + +import org.emftext.language.java.parameters.ParametersFactory; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +import org.emftext.language.java.parameters.CatchParameter; + +public class CatchParameterInitialiser extends AbstractInitialiserBase implements ICatchParameterInitialiser { + @Override + public CatchParameter instantiate() { + return ParametersFactory.eINSTANCE.createCatchParameter(); + } + + @Override + public ICatchParameterInitialiser newInitialiser() { + return new CatchParameterInitialiser(); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/parameters/ICatchParameterInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/parameters/ICatchParameterInitialiser.java new file mode 100644 index 0000000000..635d2c97eb --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/parameters/ICatchParameterInitialiser.java @@ -0,0 +1,21 @@ +package cipm.consistency.initialisers.jamopp.parameters; + +import org.emftext.language.java.parameters.CatchParameter; +import org.emftext.language.java.types.TypeReference; + +public interface ICatchParameterInitialiser extends IOrdinaryParameterInitialiser { + @Override + public CatchParameter instantiate(); + + public default boolean addTypeReference(CatchParameter cp, TypeReference tRef) { + if (tRef != null) { + cp.getTypeReferences().add(tRef); + return cp.getTypeReferences().contains(tRef); + } + return true; + } + + public default boolean addTypeReferences(CatchParameter cp, TypeReference[] tRefs) { + return this.doMultipleModifications(cp, tRefs, this::addTypeReference); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/parameters/IOrdinaryParameterInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/parameters/IOrdinaryParameterInitialiser.java new file mode 100644 index 0000000000..b831bd0828 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/parameters/IOrdinaryParameterInitialiser.java @@ -0,0 +1,8 @@ +package cipm.consistency.initialisers.jamopp.parameters; + +import org.emftext.language.java.parameters.OrdinaryParameter; + +public interface IOrdinaryParameterInitialiser extends IParameterInitialiser { + @Override + public OrdinaryParameter instantiate(); +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/parameters/IParameterInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/parameters/IParameterInitialiser.java new file mode 100644 index 0000000000..fd25c1bfc1 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/parameters/IParameterInitialiser.java @@ -0,0 +1,11 @@ +package cipm.consistency.initialisers.jamopp.parameters; + +import org.emftext.language.java.parameters.Parameter; + +import cipm.consistency.initialisers.jamopp.modifiers.IAnnotableAndModifiableInitialiser; +import cipm.consistency.initialisers.jamopp.variables.IVariableInitialiser; + +public interface IParameterInitialiser extends IAnnotableAndModifiableInitialiser, IVariableInitialiser { + @Override + public Parameter instantiate(); +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/parameters/IParametrizableInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/parameters/IParametrizableInitialiser.java new file mode 100644 index 0000000000..8c6d958efc --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/parameters/IParametrizableInitialiser.java @@ -0,0 +1,23 @@ +package cipm.consistency.initialisers.jamopp.parameters; + +import org.emftext.language.java.parameters.Parameter; +import org.emftext.language.java.parameters.Parametrizable; + +import cipm.consistency.initialisers.jamopp.commons.ICommentableInitialiser; + +public interface IParametrizableInitialiser extends ICommentableInitialiser { + @Override + public Parametrizable instantiate(); + + public default boolean addParameter(Parametrizable parametrizable, Parameter param) { + if (param != null) { + parametrizable.getParameters().add(param); + return parametrizable.getParameters().contains(param); + } + return true; + } + + public default boolean addParameters(Parametrizable parametrizable, Parameter[] params) { + return this.doMultipleModifications(parametrizable, params, this::addParameter); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/parameters/IReceiverParameterInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/parameters/IReceiverParameterInitialiser.java new file mode 100644 index 0000000000..fc2f373c85 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/parameters/IReceiverParameterInitialiser.java @@ -0,0 +1,22 @@ +package cipm.consistency.initialisers.jamopp.parameters; + +import org.emftext.language.java.literals.This; +import org.emftext.language.java.parameters.ReceiverParameter; +import org.emftext.language.java.types.TypeReference; + +import cipm.consistency.initialisers.jamopp.annotations.IAnnotableInitialiser; + +public interface IReceiverParameterInitialiser extends IAnnotableInitialiser, IParameterInitialiser { + @Override + public ReceiverParameter instantiate(); + + public default boolean setOuterTypeReference(ReceiverParameter rp, TypeReference otRef) { + rp.setOuterTypeReference(otRef); + return (otRef == null && rp.getOuterTypeReference() == null) || rp.getOuterTypeReference().equals(otRef); + } + + public default boolean setThisReference(ReceiverParameter rp, This thisRef) { + rp.setThisReference(thisRef); + return (thisRef == null && rp.getThisReference() == null) || rp.getThisReference().equals(thisRef); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/parameters/IVariableLengthParameterInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/parameters/IVariableLengthParameterInitialiser.java new file mode 100644 index 0000000000..47e04cbfbc --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/parameters/IVariableLengthParameterInitialiser.java @@ -0,0 +1,10 @@ +package cipm.consistency.initialisers.jamopp.parameters; + +import org.emftext.language.java.parameters.VariableLengthParameter; + +import cipm.consistency.initialisers.jamopp.annotations.IAnnotableInitialiser; + +public interface IVariableLengthParameterInitialiser extends IAnnotableInitialiser, IParameterInitialiser { + @Override + public VariableLengthParameter instantiate(); +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/parameters/OrdinaryParameterInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/parameters/OrdinaryParameterInitialiser.java new file mode 100644 index 0000000000..6bc970f605 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/parameters/OrdinaryParameterInitialiser.java @@ -0,0 +1,19 @@ +package cipm.consistency.initialisers.jamopp.parameters; + +import org.emftext.language.java.parameters.ParametersFactory; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +import org.emftext.language.java.parameters.OrdinaryParameter; + +public class OrdinaryParameterInitialiser extends AbstractInitialiserBase implements IOrdinaryParameterInitialiser { + @Override + public OrdinaryParameter instantiate() { + return ParametersFactory.eINSTANCE.createOrdinaryParameter(); + } + + @Override + public IOrdinaryParameterInitialiser newInitialiser() { + return new OrdinaryParameterInitialiser(); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/parameters/ParametersInitialiserPackage.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/parameters/ParametersInitialiserPackage.java new file mode 100644 index 0000000000..d94531ce06 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/parameters/ParametersInitialiserPackage.java @@ -0,0 +1,22 @@ +package cipm.consistency.initialisers.jamopp.parameters; + +import java.util.Collection; + +import cipm.consistency.initialisers.IInitialiser; +import cipm.consistency.initialisers.IInitialiserPackage; + +public class ParametersInitialiserPackage implements IInitialiserPackage { + @Override + public Collection getInitialiserInstances() { + return this.initCol(new IInitialiser[] { new CatchParameterInitialiser(), new OrdinaryParameterInitialiser(), + new ReceiverParameterInitialiser(), new VariableLengthParameterInitialiser(), }); + } + + @SuppressWarnings("unchecked") + @Override + public Collection> getInitialiserInterfaceTypes() { + return this.initCol(new Class[] { ICatchParameterInitialiser.class, IOrdinaryParameterInitialiser.class, + IParameterInitialiser.class, IParametrizableInitialiser.class, IReceiverParameterInitialiser.class, + IVariableLengthParameterInitialiser.class, }); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/parameters/ReceiverParameterInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/parameters/ReceiverParameterInitialiser.java new file mode 100644 index 0000000000..89bb051bbb --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/parameters/ReceiverParameterInitialiser.java @@ -0,0 +1,18 @@ +package cipm.consistency.initialisers.jamopp.parameters; + +import org.emftext.language.java.parameters.ParametersFactory; +import org.emftext.language.java.parameters.ReceiverParameter; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class ReceiverParameterInitialiser extends AbstractInitialiserBase implements IReceiverParameterInitialiser { + @Override + public ReceiverParameter instantiate() { + return ParametersFactory.eINSTANCE.createReceiverParameter(); + } + + @Override + public IReceiverParameterInitialiser newInitialiser() { + return new ReceiverParameterInitialiser(); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/parameters/VariableLengthParameterInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/parameters/VariableLengthParameterInitialiser.java new file mode 100644 index 0000000000..486a338bc8 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/parameters/VariableLengthParameterInitialiser.java @@ -0,0 +1,19 @@ +package cipm.consistency.initialisers.jamopp.parameters; + +import org.emftext.language.java.parameters.ParametersFactory; +import org.emftext.language.java.parameters.VariableLengthParameter; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class VariableLengthParameterInitialiser extends AbstractInitialiserBase + implements IVariableLengthParameterInitialiser { + @Override + public VariableLengthParameter instantiate() { + return ParametersFactory.eINSTANCE.createVariableLengthParameter(); + } + + @Override + public IVariableLengthParameterInitialiser newInitialiser() { + return new VariableLengthParameterInitialiser(); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/parameters/package-info.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/parameters/package-info.java new file mode 100644 index 0000000000..a8f067bfae --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/parameters/package-info.java @@ -0,0 +1,5 @@ +/** + * Contains {@link IInitialiser} implementations for + * {@link org.emftext.language.java.parameters}. + */ +package cipm.consistency.initialisers.jamopp.parameters; \ No newline at end of file From 4e265fa54f8e9c9718caaa7372e7e0839c49782f Mon Sep 17 00:00:00 2001 From: AlpTorac Date: Fri, 25 Oct 2024 17:39:02 +0200 Subject: [PATCH 24/55] (WIP) Implement initialiser package for org.emftext.language.java.references --- .../references/IArgumentableInitialiser.java | 37 +++++++++++++++++++ .../IElementReferenceInitialiser.java | 19 ++++++++++ .../IIdentifierReferenceInitialiser.java | 12 ++++++ .../references/IMethodCallInitialiser.java | 11 ++++++ .../IPackageReferenceInitialiser.java | 11 ++++++ .../IPrimitiveTypeReferenceInitialiser.java | 16 ++++++++ .../references/IReferenceInitialiser.java | 34 +++++++++++++++++ .../IReferenceableElementInitialiser.java | 10 +++++ .../IReflectiveClassReferenceInitialiser.java | 9 +++++ .../references/ISelfReferenceInitialiser.java | 14 +++++++ .../IStringReferenceInitialiser.java | 13 +++++++ .../ITextBlockReferenceInitialiser.java | 13 +++++++ .../IdentifierReferenceInitialiser.java | 18 +++++++++ .../references/MethodCallInitialiser.java | 18 +++++++++ .../PackageReferenceInitialiser.java | 18 +++++++++ .../PrimitiveTypeReferenceInitialiser.java | 19 ++++++++++ .../ReferencesInitialiserPackage.java | 27 ++++++++++++++ .../ReflectiveClassReferenceInitialiser.java | 19 ++++++++++ .../references/SelfReferenceInitialiser.java | 18 +++++++++ .../StringReferenceInitialiser.java | 18 +++++++++ .../TextBlockReferenceInitialiser.java | 18 +++++++++ .../jamopp/references/package-info.java | 5 +++ 22 files changed, 377 insertions(+) create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/references/IArgumentableInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/references/IElementReferenceInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/references/IIdentifierReferenceInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/references/IMethodCallInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/references/IPackageReferenceInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/references/IPrimitiveTypeReferenceInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/references/IReferenceInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/references/IReferenceableElementInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/references/IReflectiveClassReferenceInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/references/ISelfReferenceInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/references/IStringReferenceInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/references/ITextBlockReferenceInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/references/IdentifierReferenceInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/references/MethodCallInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/references/PackageReferenceInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/references/PrimitiveTypeReferenceInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/references/ReferencesInitialiserPackage.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/references/ReflectiveClassReferenceInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/references/SelfReferenceInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/references/StringReferenceInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/references/TextBlockReferenceInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/references/package-info.java diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/references/IArgumentableInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/references/IArgumentableInitialiser.java new file mode 100644 index 0000000000..0064816943 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/references/IArgumentableInitialiser.java @@ -0,0 +1,37 @@ +package cipm.consistency.initialisers.jamopp.references; + +import org.emftext.language.java.expressions.Expression; +import org.emftext.language.java.references.Argumentable; + +import cipm.consistency.initialisers.jamopp.commons.ICommentableInitialiser; + +/** + * An interface meant for {@link IInitialiser} implementors that are supposed to + * create {@link Argumentable} instances.
+ *
+ * {@code argable.getArgumentTypes().add(...)} cannot be used to modify argable. + * + * @author Alp Torac Genc + */ +public interface IArgumentableInitialiser extends ICommentableInitialiser { + @Override + public Argumentable instantiate(); + + /** + * Adds the given expression arg to argable as an argument. Uses + * {@code argable.getArguments().add(...)} to do so. + * + * @see {@link IArgumentableInitialiser} + */ + public default boolean addArgument(Argumentable argable, Expression arg) { + if (arg != null) { + argable.getArguments().add(arg); + return argable.getArguments().contains(arg); + } + return true; + } + + public default boolean addArguments(Argumentable argable, Expression[] args) { + return this.doMultipleModifications(argable, args, this::addArgument); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/references/IElementReferenceInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/references/IElementReferenceInitialiser.java new file mode 100644 index 0000000000..76280b6bd6 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/references/IElementReferenceInitialiser.java @@ -0,0 +1,19 @@ +package cipm.consistency.initialisers.jamopp.references; + +import org.emftext.language.java.references.ElementReference; +import org.emftext.language.java.references.ReferenceableElement; + +public interface IElementReferenceInitialiser extends IReferenceInitialiser { + @Override + public ElementReference instantiate(); + + public default boolean setContainedTarget(ElementReference eref, ReferenceableElement conTarget) { + eref.setContainedTarget(conTarget); + return (conTarget == null && eref.getContainedTarget() == null) || eref.getContainedTarget().equals(conTarget); + } + + public default boolean setTarget(ElementReference eref, ReferenceableElement target) { + eref.setTarget(target); + return (target == null && eref.getTarget() == null) || eref.getTarget().equals(target); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/references/IIdentifierReferenceInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/references/IIdentifierReferenceInitialiser.java new file mode 100644 index 0000000000..87e073b44c --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/references/IIdentifierReferenceInitialiser.java @@ -0,0 +1,12 @@ +package cipm.consistency.initialisers.jamopp.references; + +import org.emftext.language.java.references.IdentifierReference; + +import cipm.consistency.initialisers.jamopp.annotations.IAnnotableInitialiser; +import cipm.consistency.initialisers.jamopp.arrays.IArrayTypeableInitialiser; + +public interface IIdentifierReferenceInitialiser + extends IAnnotableInitialiser, IArrayTypeableInitialiser, IElementReferenceInitialiser { + @Override + public IdentifierReference instantiate(); +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/references/IMethodCallInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/references/IMethodCallInitialiser.java new file mode 100644 index 0000000000..4bb409b0e8 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/references/IMethodCallInitialiser.java @@ -0,0 +1,11 @@ +package cipm.consistency.initialisers.jamopp.references; + +import org.emftext.language.java.references.MethodCall; + +import cipm.consistency.initialisers.jamopp.generics.ICallTypeArgumentableInitialiser; + +public interface IMethodCallInitialiser + extends IElementReferenceInitialiser, IArgumentableInitialiser, ICallTypeArgumentableInitialiser { + @Override + public MethodCall instantiate(); +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/references/IPackageReferenceInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/references/IPackageReferenceInitialiser.java new file mode 100644 index 0000000000..56f511fb1c --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/references/IPackageReferenceInitialiser.java @@ -0,0 +1,11 @@ +package cipm.consistency.initialisers.jamopp.references; + +import org.emftext.language.java.references.PackageReference; + +import cipm.consistency.initialisers.jamopp.commons.INamespaceAwareElementInitialiser; + +public interface IPackageReferenceInitialiser + extends INamespaceAwareElementInitialiser, IReferenceableElementInitialiser { + @Override + public PackageReference instantiate(); +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/references/IPrimitiveTypeReferenceInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/references/IPrimitiveTypeReferenceInitialiser.java new file mode 100644 index 0000000000..34a58ea332 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/references/IPrimitiveTypeReferenceInitialiser.java @@ -0,0 +1,16 @@ +package cipm.consistency.initialisers.jamopp.references; + +import org.emftext.language.java.references.PrimitiveTypeReference; +import org.emftext.language.java.types.PrimitiveType; + +import cipm.consistency.initialisers.jamopp.arrays.IArrayTypeableInitialiser; + +public interface IPrimitiveTypeReferenceInitialiser extends IArrayTypeableInitialiser, IReferenceInitialiser { + @Override + public PrimitiveTypeReference instantiate(); + + public default boolean setPrimitiveType(PrimitiveTypeReference ptr, PrimitiveType pt) { + ptr.setPrimitiveType(pt); + return (pt == null && ptr.getPrimitiveType() == null) || ptr.getPrimitiveType().equals(pt); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/references/IReferenceInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/references/IReferenceInitialiser.java new file mode 100644 index 0000000000..8d15264afb --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/references/IReferenceInitialiser.java @@ -0,0 +1,34 @@ +package cipm.consistency.initialisers.jamopp.references; + +import org.emftext.language.java.arrays.ArraySelector; +import org.emftext.language.java.references.Reference; + +import cipm.consistency.initialisers.jamopp.expressions.IPrimaryExpressionInitialiser; +import cipm.consistency.initialisers.jamopp.generics.ITypeArgumentableInitialiser; +import cipm.consistency.initialisers.jamopp.types.ITypedElementExtensionInitialiser; + +public interface IReferenceInitialiser + extends IPrimaryExpressionInitialiser, ITypeArgumentableInitialiser, ITypedElementExtensionInitialiser { + + @Override + public Reference instantiate(); + + public default boolean addArraySelector(Reference ref, ArraySelector arrSel) { + if (arrSel != null) { + ref.getArraySelectors().add(arrSel); + return ref.getArraySelectors().contains(arrSel); + } + return true; + } + + public default boolean addArraySelectors(Reference ref, ArraySelector[] arrSels) { + return this.doMultipleModifications(ref, arrSels, this::addArraySelector); + } + + public default boolean setNext(Reference ref, Reference next) { + ref.setNext(next); + return (next == null && ref.getNext() == null) + || (ref.getNext().equals(next) && ref.getNext().getPrevious().equals(ref) + && next.getPrevious().equals(ref) && next.getPrevious().getNext().equals(next)); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/references/IReferenceableElementInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/references/IReferenceableElementInitialiser.java new file mode 100644 index 0000000000..22aeb4f6a0 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/references/IReferenceableElementInitialiser.java @@ -0,0 +1,10 @@ +package cipm.consistency.initialisers.jamopp.references; + +import org.emftext.language.java.references.ReferenceableElement; + +import cipm.consistency.initialisers.jamopp.commons.INamedElementInitialiser; + +public interface IReferenceableElementInitialiser extends INamedElementInitialiser { + @Override + public ReferenceableElement instantiate(); +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/references/IReflectiveClassReferenceInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/references/IReflectiveClassReferenceInitialiser.java new file mode 100644 index 0000000000..0683251183 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/references/IReflectiveClassReferenceInitialiser.java @@ -0,0 +1,9 @@ +package cipm.consistency.initialisers.jamopp.references; + +import org.emftext.language.java.references.ReflectiveClassReference; + +public interface IReflectiveClassReferenceInitialiser extends IReferenceInitialiser { + @Override + public ReflectiveClassReference instantiate(); + +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/references/ISelfReferenceInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/references/ISelfReferenceInitialiser.java new file mode 100644 index 0000000000..82a1453360 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/references/ISelfReferenceInitialiser.java @@ -0,0 +1,14 @@ +package cipm.consistency.initialisers.jamopp.references; + +import org.emftext.language.java.literals.Self; +import org.emftext.language.java.references.SelfReference; + +public interface ISelfReferenceInitialiser extends IReferenceInitialiser { + @Override + public SelfReference instantiate(); + + public default boolean setSelf(SelfReference sref, Self self) { + sref.setSelf(self); + return (self == null && sref.getSelf() == null) || sref.getSelf().equals(self); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/references/IStringReferenceInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/references/IStringReferenceInitialiser.java new file mode 100644 index 0000000000..877ce754d3 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/references/IStringReferenceInitialiser.java @@ -0,0 +1,13 @@ +package cipm.consistency.initialisers.jamopp.references; + +import org.emftext.language.java.references.StringReference; + +public interface IStringReferenceInitialiser extends IReferenceInitialiser { + @Override + public StringReference instantiate(); + + public default boolean setValue(StringReference sref, String val) { + sref.setValue(val); + return (val == null && sref.getValue() == null) || sref.getValue().equals(val); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/references/ITextBlockReferenceInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/references/ITextBlockReferenceInitialiser.java new file mode 100644 index 0000000000..3d5c954823 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/references/ITextBlockReferenceInitialiser.java @@ -0,0 +1,13 @@ +package cipm.consistency.initialisers.jamopp.references; + +import org.emftext.language.java.references.TextBlockReference; + +public interface ITextBlockReferenceInitialiser extends IReferenceInitialiser { + @Override + public TextBlockReference instantiate(); + + public default boolean setValue(TextBlockReference tbref, String val) { + tbref.setValue(val); + return (val == null && tbref.getValue() == null) || tbref.getValue().equals(val); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/references/IdentifierReferenceInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/references/IdentifierReferenceInitialiser.java new file mode 100644 index 0000000000..4d29328559 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/references/IdentifierReferenceInitialiser.java @@ -0,0 +1,18 @@ +package cipm.consistency.initialisers.jamopp.references; + +import org.emftext.language.java.references.IdentifierReference; +import org.emftext.language.java.references.ReferencesFactory; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class IdentifierReferenceInitialiser extends AbstractInitialiserBase implements IIdentifierReferenceInitialiser { + @Override + public IIdentifierReferenceInitialiser newInitialiser() { + return new IdentifierReferenceInitialiser(); + } + + @Override + public IdentifierReference instantiate() { + return ReferencesFactory.eINSTANCE.createIdentifierReference(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/references/MethodCallInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/references/MethodCallInitialiser.java new file mode 100644 index 0000000000..3a32a11a52 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/references/MethodCallInitialiser.java @@ -0,0 +1,18 @@ +package cipm.consistency.initialisers.jamopp.references; + +import org.emftext.language.java.references.MethodCall; +import org.emftext.language.java.references.ReferencesFactory; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class MethodCallInitialiser extends AbstractInitialiserBase implements IMethodCallInitialiser { + @Override + public IMethodCallInitialiser newInitialiser() { + return new MethodCallInitialiser(); + } + + @Override + public MethodCall instantiate() { + return ReferencesFactory.eINSTANCE.createMethodCall(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/references/PackageReferenceInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/references/PackageReferenceInitialiser.java new file mode 100644 index 0000000000..ba4e23bc0e --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/references/PackageReferenceInitialiser.java @@ -0,0 +1,18 @@ +package cipm.consistency.initialisers.jamopp.references; + +import org.emftext.language.java.references.PackageReference; +import org.emftext.language.java.references.ReferencesFactory; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class PackageReferenceInitialiser extends AbstractInitialiserBase implements IPackageReferenceInitialiser { + @Override + public IPackageReferenceInitialiser newInitialiser() { + return new PackageReferenceInitialiser(); + } + + @Override + public PackageReference instantiate() { + return ReferencesFactory.eINSTANCE.createPackageReference(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/references/PrimitiveTypeReferenceInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/references/PrimitiveTypeReferenceInitialiser.java new file mode 100644 index 0000000000..030fd1b9f1 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/references/PrimitiveTypeReferenceInitialiser.java @@ -0,0 +1,19 @@ +package cipm.consistency.initialisers.jamopp.references; + +import org.emftext.language.java.references.PrimitiveTypeReference; +import org.emftext.language.java.references.ReferencesFactory; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class PrimitiveTypeReferenceInitialiser extends AbstractInitialiserBase + implements IPrimitiveTypeReferenceInitialiser { + @Override + public IPrimitiveTypeReferenceInitialiser newInitialiser() { + return new PrimitiveTypeReferenceInitialiser(); + } + + @Override + public PrimitiveTypeReference instantiate() { + return ReferencesFactory.eINSTANCE.createPrimitiveTypeReference(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/references/ReferencesInitialiserPackage.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/references/ReferencesInitialiserPackage.java new file mode 100644 index 0000000000..21812110f5 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/references/ReferencesInitialiserPackage.java @@ -0,0 +1,27 @@ +package cipm.consistency.initialisers.jamopp.references; + +import java.util.Collection; + +import cipm.consistency.initialisers.IInitialiser; +import cipm.consistency.initialisers.IInitialiserPackage; + +public class ReferencesInitialiserPackage implements IInitialiserPackage { + @Override + public Collection getInitialiserInstances() { + return this.initCol(new IInitialiser[] { new IdentifierReferenceInitialiser(), new MethodCallInitialiser(), + new PackageReferenceInitialiser(), new PrimitiveTypeReferenceInitialiser(), + new ReflectiveClassReferenceInitialiser(), new SelfReferenceInitialiser(), + new StringReferenceInitialiser(), new TextBlockReferenceInitialiser(), }); + } + + @SuppressWarnings("unchecked") + @Override + public Collection> getInitialiserInterfaceTypes() { + return this.initCol(new Class[] { IArgumentableInitialiser.class, IElementReferenceInitialiser.class, + IIdentifierReferenceInitialiser.class, IMethodCallInitialiser.class, IPackageReferenceInitialiser.class, + IPrimitiveTypeReferenceInitialiser.class, IReferenceableElementInitialiser.class, + IReferenceInitialiser.class, IReflectiveClassReferenceInitialiser.class, + ISelfReferenceInitialiser.class, IStringReferenceInitialiser.class, + ITextBlockReferenceInitialiser.class, }); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/references/ReflectiveClassReferenceInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/references/ReflectiveClassReferenceInitialiser.java new file mode 100644 index 0000000000..e80574f949 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/references/ReflectiveClassReferenceInitialiser.java @@ -0,0 +1,19 @@ +package cipm.consistency.initialisers.jamopp.references; + +import org.emftext.language.java.references.ReferencesFactory; +import org.emftext.language.java.references.ReflectiveClassReference; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class ReflectiveClassReferenceInitialiser extends AbstractInitialiserBase + implements IReflectiveClassReferenceInitialiser { + @Override + public IReflectiveClassReferenceInitialiser newInitialiser() { + return new ReflectiveClassReferenceInitialiser(); + } + + @Override + public ReflectiveClassReference instantiate() { + return ReferencesFactory.eINSTANCE.createReflectiveClassReference(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/references/SelfReferenceInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/references/SelfReferenceInitialiser.java new file mode 100644 index 0000000000..bd74cbce4e --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/references/SelfReferenceInitialiser.java @@ -0,0 +1,18 @@ +package cipm.consistency.initialisers.jamopp.references; + +import org.emftext.language.java.references.ReferencesFactory; +import org.emftext.language.java.references.SelfReference; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class SelfReferenceInitialiser extends AbstractInitialiserBase implements ISelfReferenceInitialiser { + @Override + public ISelfReferenceInitialiser newInitialiser() { + return new SelfReferenceInitialiser(); + } + + @Override + public SelfReference instantiate() { + return ReferencesFactory.eINSTANCE.createSelfReference(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/references/StringReferenceInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/references/StringReferenceInitialiser.java new file mode 100644 index 0000000000..297e697e2d --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/references/StringReferenceInitialiser.java @@ -0,0 +1,18 @@ +package cipm.consistency.initialisers.jamopp.references; + +import org.emftext.language.java.references.ReferencesFactory; +import org.emftext.language.java.references.StringReference; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class StringReferenceInitialiser extends AbstractInitialiserBase implements IStringReferenceInitialiser { + @Override + public IStringReferenceInitialiser newInitialiser() { + return new StringReferenceInitialiser(); + } + + @Override + public StringReference instantiate() { + return ReferencesFactory.eINSTANCE.createStringReference(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/references/TextBlockReferenceInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/references/TextBlockReferenceInitialiser.java new file mode 100644 index 0000000000..84058618fc --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/references/TextBlockReferenceInitialiser.java @@ -0,0 +1,18 @@ +package cipm.consistency.initialisers.jamopp.references; + +import org.emftext.language.java.references.ReferencesFactory; +import org.emftext.language.java.references.TextBlockReference; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class TextBlockReferenceInitialiser extends AbstractInitialiserBase implements ITextBlockReferenceInitialiser { + @Override + public ITextBlockReferenceInitialiser newInitialiser() { + return new TextBlockReferenceInitialiser(); + } + + @Override + public TextBlockReference instantiate() { + return ReferencesFactory.eINSTANCE.createTextBlockReference(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/references/package-info.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/references/package-info.java new file mode 100644 index 0000000000..054472ee11 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/references/package-info.java @@ -0,0 +1,5 @@ +/** + * Contains {@link IInitialiser} implementations for + * {@link org.emftext.language.java.references}. + */ +package cipm.consistency.initialisers.jamopp.references; \ No newline at end of file From a69f5e7d04837f1e24f22b60b708eff1148d0af7 Mon Sep 17 00:00:00 2001 From: AlpTorac Date: Fri, 25 Oct 2024 17:39:39 +0200 Subject: [PATCH 25/55] (WIP) Implement initialiser package for org.emftext.language.java.statements --- .../jamopp/statements/AssertInitialiser.java | 19 ++++++ .../jamopp/statements/BlockInitialiser.java | 19 ++++++ .../jamopp/statements/BreakInitialiser.java | 18 ++++++ .../statements/CatchBlockInitialiser.java | 18 ++++++ .../statements/ConditionInitialiser.java | 18 ++++++ .../statements/ContinueInitialiser.java | 18 ++++++ .../DefaultSwitchCaseInitialiser.java | 18 ++++++ .../DefaultSwitchRuleInitialiser.java | 18 ++++++ .../statements/DoWhileLoopInitialiser.java | 18 ++++++ .../statements/EmptyStatementInitialiser.java | 18 ++++++ .../ExpressionStatementInitialiser.java | 18 ++++++ .../statements/ForEachLoopInitialiser.java | 18 ++++++ .../jamopp/statements/ForLoopInitialiser.java | 18 ++++++ .../jamopp/statements/IAssertInitialiser.java | 14 +++++ .../IBlockContainerInitialiser.java | 16 +++++ .../jamopp/statements/IBlockInitialiser.java | 18 ++++++ .../jamopp/statements/IBreakInitialiser.java | 9 +++ .../statements/ICatchBlockInitialiser.java | 21 +++++++ .../statements/IConditionInitialiser.java | 16 +++++ .../statements/IConditionalInitialiser.java | 16 +++++ .../statements/IContinueInitialiser.java | 9 +++ .../IDefaultSwitchCaseInitialiser.java | 9 +++ .../IDefaultSwitchRuleInitialiser.java | 9 +++ .../statements/IDoWhileLoopInitialiser.java | 9 +++ .../IEmptyStatementInitialiser.java | 9 +++ .../IExpressionStatementInitialiser.java | 14 +++++ .../statements/IForEachLoopInitialiser.java | 20 ++++++ .../statements/IForLoopInitialiser.java | 28 +++++++++ .../IForLoopInitializerInitialiser.java | 11 ++++ .../jamopp/statements/IJumpInitialiser.java | 14 +++++ .../statements/IJumpLabelInitialiser.java | 12 ++++ .../ILocalVariableStatementInitialiser.java | 14 +++++ .../INormalSwitchCaseInitialiser.java | 21 +++++++ .../INormalSwitchRuleInitialiser.java | 21 +++++++ .../jamopp/statements/IReturnInitialiser.java | 14 +++++ .../IStatementContainerInitialiser.java | 16 +++++ .../statements/IStatementInitialiser.java | 10 +++ .../IStatementListContainerInitialiser.java | 63 +++++++++++++++++++ .../statements/ISwitchCaseInitialiser.java | 14 +++++ .../jamopp/statements/ISwitchInitialiser.java | 29 +++++++++ .../statements/ISwitchRuleInitialiser.java | 9 +++ .../ISynchronizedBlockInitialiser.java | 22 +++++++ .../jamopp/statements/IThrowInitialiser.java | 14 +++++ .../statements/ITryBlockInitialiser.java | 47 ++++++++++++++ .../statements/IWhileLoopInitialiser.java | 10 +++ .../IYieldStatementInitialiser.java | 14 +++++ .../statements/JumpLabelInitialiser.java | 18 ++++++ .../LocalVariableStatementInitialiser.java | 19 ++++++ .../NormalSwitchCaseInitialiser.java | 18 ++++++ .../NormalSwitchRuleInitialiser.java | 18 ++++++ .../jamopp/statements/ReturnInitialiser.java | 18 ++++++ .../StatementsInitialiserPackage.java | 38 +++++++++++ .../jamopp/statements/SwitchInitialiser.java | 18 ++++++ .../SynchronizedBlockInitialiser.java | 18 ++++++ .../jamopp/statements/ThrowInitialiser.java | 18 ++++++ .../statements/TryBlockInitialiser.java | 18 ++++++ .../statements/WhileLoopInitialiser.java | 18 ++++++ .../statements/YieldStatementInitialiser.java | 18 ++++++ .../jamopp/statements/package-info.java | 5 ++ 59 files changed, 1050 insertions(+) create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/AssertInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/BlockInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/BreakInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/CatchBlockInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/ConditionInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/ContinueInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/DefaultSwitchCaseInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/DefaultSwitchRuleInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/DoWhileLoopInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/EmptyStatementInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/ExpressionStatementInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/ForEachLoopInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/ForLoopInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/IAssertInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/IBlockContainerInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/IBlockInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/IBreakInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/ICatchBlockInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/IConditionInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/IConditionalInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/IContinueInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/IDefaultSwitchCaseInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/IDefaultSwitchRuleInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/IDoWhileLoopInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/IEmptyStatementInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/IExpressionStatementInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/IForEachLoopInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/IForLoopInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/IForLoopInitializerInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/IJumpInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/IJumpLabelInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/ILocalVariableStatementInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/INormalSwitchCaseInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/INormalSwitchRuleInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/IReturnInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/IStatementContainerInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/IStatementInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/IStatementListContainerInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/ISwitchCaseInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/ISwitchInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/ISwitchRuleInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/ISynchronizedBlockInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/IThrowInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/ITryBlockInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/IWhileLoopInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/IYieldStatementInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/JumpLabelInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/LocalVariableStatementInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/NormalSwitchCaseInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/NormalSwitchRuleInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/ReturnInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/StatementsInitialiserPackage.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/SwitchInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/SynchronizedBlockInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/ThrowInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/TryBlockInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/WhileLoopInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/YieldStatementInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/package-info.java diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/AssertInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/AssertInitialiser.java new file mode 100644 index 0000000000..0cb92ea3fc --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/AssertInitialiser.java @@ -0,0 +1,19 @@ +package cipm.consistency.initialisers.jamopp.statements; + +import org.emftext.language.java.statements.StatementsFactory; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +import org.emftext.language.java.statements.Assert; + +public class AssertInitialiser extends AbstractInitialiserBase implements IAssertInitialiser { + @Override + public IAssertInitialiser newInitialiser() { + return new AssertInitialiser(); + } + + @Override + public Assert instantiate() { + return StatementsFactory.eINSTANCE.createAssert(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/BlockInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/BlockInitialiser.java new file mode 100644 index 0000000000..b670690848 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/BlockInitialiser.java @@ -0,0 +1,19 @@ +package cipm.consistency.initialisers.jamopp.statements; + +import org.emftext.language.java.statements.StatementsFactory; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +import org.emftext.language.java.statements.Block; + +public class BlockInitialiser extends AbstractInitialiserBase implements IBlockInitialiser { + @Override + public Block instantiate() { + return StatementsFactory.eINSTANCE.createBlock(); + } + + @Override + public BlockInitialiser newInitialiser() { + return new BlockInitialiser(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/BreakInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/BreakInitialiser.java new file mode 100644 index 0000000000..37ce6d458f --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/BreakInitialiser.java @@ -0,0 +1,18 @@ +package cipm.consistency.initialisers.jamopp.statements; + +import org.emftext.language.java.statements.Break; +import org.emftext.language.java.statements.StatementsFactory; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class BreakInitialiser extends AbstractInitialiserBase implements IBreakInitialiser { + @Override + public IBreakInitialiser newInitialiser() { + return new BreakInitialiser(); + } + + @Override + public Break instantiate() { + return StatementsFactory.eINSTANCE.createBreak(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/CatchBlockInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/CatchBlockInitialiser.java new file mode 100644 index 0000000000..740a0c2d29 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/CatchBlockInitialiser.java @@ -0,0 +1,18 @@ +package cipm.consistency.initialisers.jamopp.statements; + +import org.emftext.language.java.statements.CatchBlock; +import org.emftext.language.java.statements.StatementsFactory; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class CatchBlockInitialiser extends AbstractInitialiserBase implements ICatchBlockInitialiser { + @Override + public CatchBlock instantiate() { + return StatementsFactory.eINSTANCE.createCatchBlock(); + } + + @Override + public CatchBlockInitialiser newInitialiser() { + return new CatchBlockInitialiser(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/ConditionInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/ConditionInitialiser.java new file mode 100644 index 0000000000..11dad2b732 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/ConditionInitialiser.java @@ -0,0 +1,18 @@ +package cipm.consistency.initialisers.jamopp.statements; + +import org.emftext.language.java.statements.Condition; +import org.emftext.language.java.statements.StatementsFactory; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class ConditionInitialiser extends AbstractInitialiserBase implements IConditionInitialiser { + @Override + public IConditionInitialiser newInitialiser() { + return new ConditionInitialiser(); + } + + @Override + public Condition instantiate() { + return StatementsFactory.eINSTANCE.createCondition(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/ContinueInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/ContinueInitialiser.java new file mode 100644 index 0000000000..e418655993 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/ContinueInitialiser.java @@ -0,0 +1,18 @@ +package cipm.consistency.initialisers.jamopp.statements; + +import org.emftext.language.java.statements.Continue; +import org.emftext.language.java.statements.StatementsFactory; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class ContinueInitialiser extends AbstractInitialiserBase implements IContinueInitialiser { + @Override + public IContinueInitialiser newInitialiser() { + return new ContinueInitialiser(); + } + + @Override + public Continue instantiate() { + return StatementsFactory.eINSTANCE.createContinue(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/DefaultSwitchCaseInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/DefaultSwitchCaseInitialiser.java new file mode 100644 index 0000000000..58fe39deef --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/DefaultSwitchCaseInitialiser.java @@ -0,0 +1,18 @@ +package cipm.consistency.initialisers.jamopp.statements; + +import org.emftext.language.java.statements.DefaultSwitchCase; +import org.emftext.language.java.statements.StatementsFactory; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class DefaultSwitchCaseInitialiser extends AbstractInitialiserBase implements IDefaultSwitchCaseInitialiser { + @Override + public IDefaultSwitchCaseInitialiser newInitialiser() { + return new DefaultSwitchCaseInitialiser(); + } + + @Override + public DefaultSwitchCase instantiate() { + return StatementsFactory.eINSTANCE.createDefaultSwitchCase(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/DefaultSwitchRuleInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/DefaultSwitchRuleInitialiser.java new file mode 100644 index 0000000000..1b0e9bb27f --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/DefaultSwitchRuleInitialiser.java @@ -0,0 +1,18 @@ +package cipm.consistency.initialisers.jamopp.statements; + +import org.emftext.language.java.statements.DefaultSwitchRule; +import org.emftext.language.java.statements.StatementsFactory; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class DefaultSwitchRuleInitialiser extends AbstractInitialiserBase implements IDefaultSwitchRuleInitialiser { + @Override + public IDefaultSwitchRuleInitialiser newInitialiser() { + return new DefaultSwitchRuleInitialiser(); + } + + @Override + public DefaultSwitchRule instantiate() { + return StatementsFactory.eINSTANCE.createDefaultSwitchRule(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/DoWhileLoopInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/DoWhileLoopInitialiser.java new file mode 100644 index 0000000000..ee9ad76e93 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/DoWhileLoopInitialiser.java @@ -0,0 +1,18 @@ +package cipm.consistency.initialisers.jamopp.statements; + +import org.emftext.language.java.statements.DoWhileLoop; +import org.emftext.language.java.statements.StatementsFactory; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class DoWhileLoopInitialiser extends AbstractInitialiserBase implements IDoWhileLoopInitialiser { + @Override + public IDoWhileLoopInitialiser newInitialiser() { + return new DoWhileLoopInitialiser(); + } + + @Override + public DoWhileLoop instantiate() { + return StatementsFactory.eINSTANCE.createDoWhileLoop(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/EmptyStatementInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/EmptyStatementInitialiser.java new file mode 100644 index 0000000000..a17ca76ebc --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/EmptyStatementInitialiser.java @@ -0,0 +1,18 @@ +package cipm.consistency.initialisers.jamopp.statements; + +import org.emftext.language.java.statements.EmptyStatement; +import org.emftext.language.java.statements.StatementsFactory; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class EmptyStatementInitialiser extends AbstractInitialiserBase implements IEmptyStatementInitialiser { + @Override + public IEmptyStatementInitialiser newInitialiser() { + return new EmptyStatementInitialiser(); + } + + @Override + public EmptyStatement instantiate() { + return StatementsFactory.eINSTANCE.createEmptyStatement(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/ExpressionStatementInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/ExpressionStatementInitialiser.java new file mode 100644 index 0000000000..b6f75cf026 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/ExpressionStatementInitialiser.java @@ -0,0 +1,18 @@ +package cipm.consistency.initialisers.jamopp.statements; + +import org.emftext.language.java.statements.ExpressionStatement; +import org.emftext.language.java.statements.StatementsFactory; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class ExpressionStatementInitialiser extends AbstractInitialiserBase implements IExpressionStatementInitialiser { + @Override + public IExpressionStatementInitialiser newInitialiser() { + return new ExpressionStatementInitialiser(); + } + + @Override + public ExpressionStatement instantiate() { + return StatementsFactory.eINSTANCE.createExpressionStatement(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/ForEachLoopInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/ForEachLoopInitialiser.java new file mode 100644 index 0000000000..8304afc693 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/ForEachLoopInitialiser.java @@ -0,0 +1,18 @@ +package cipm.consistency.initialisers.jamopp.statements; + +import org.emftext.language.java.statements.ForEachLoop; +import org.emftext.language.java.statements.StatementsFactory; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class ForEachLoopInitialiser extends AbstractInitialiserBase implements IForEachLoopInitialiser { + @Override + public IForEachLoopInitialiser newInitialiser() { + return new ForEachLoopInitialiser(); + } + + @Override + public ForEachLoop instantiate() { + return StatementsFactory.eINSTANCE.createForEachLoop(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/ForLoopInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/ForLoopInitialiser.java new file mode 100644 index 0000000000..0e436c73a0 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/ForLoopInitialiser.java @@ -0,0 +1,18 @@ +package cipm.consistency.initialisers.jamopp.statements; + +import org.emftext.language.java.statements.ForLoop; +import org.emftext.language.java.statements.StatementsFactory; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class ForLoopInitialiser extends AbstractInitialiserBase implements IForLoopInitialiser { + @Override + public IForLoopInitialiser newInitialiser() { + return new ForLoopInitialiser(); + } + + @Override + public ForLoop instantiate() { + return StatementsFactory.eINSTANCE.createForLoop(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/IAssertInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/IAssertInitialiser.java new file mode 100644 index 0000000000..27d9d01c51 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/IAssertInitialiser.java @@ -0,0 +1,14 @@ +package cipm.consistency.initialisers.jamopp.statements; + +import org.emftext.language.java.expressions.Expression; +import org.emftext.language.java.statements.Assert; + +public interface IAssertInitialiser extends IConditionalInitialiser, IStatementInitialiser { + @Override + public Assert instantiate(); + + public default boolean setErrorMessage(Assert asrt, Expression errMsg) { + asrt.setErrorMessage(errMsg); + return (errMsg == null && asrt.getErrorMessage() == null) || asrt.getErrorMessage().equals(errMsg); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/IBlockContainerInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/IBlockContainerInitialiser.java new file mode 100644 index 0000000000..5a4cdd242e --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/IBlockContainerInitialiser.java @@ -0,0 +1,16 @@ +package cipm.consistency.initialisers.jamopp.statements; + +import org.emftext.language.java.statements.Block; +import org.emftext.language.java.statements.BlockContainer; + +import cipm.consistency.initialisers.jamopp.commons.ICommentableInitialiser; + +public interface IBlockContainerInitialiser extends ICommentableInitialiser { + @Override + public BlockContainer instantiate(); + + public default boolean setBlock(BlockContainer bc, Block block) { + bc.setBlock(block); + return (block == null && bc.getBlock() == null) || bc.getBlock().equals(block); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/IBlockInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/IBlockInitialiser.java new file mode 100644 index 0000000000..207c1fdd41 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/IBlockInitialiser.java @@ -0,0 +1,18 @@ +package cipm.consistency.initialisers.jamopp.statements; + +import org.emftext.language.java.statements.Block; +import org.emftext.language.java.statements.StatementListContainer; + +import cipm.consistency.initialisers.jamopp.members.IMemberInitialiser; +import cipm.consistency.initialisers.jamopp.modifiers.IModifiableInitialiser; + +public interface IBlockInitialiser + extends IModifiableInitialiser, IMemberInitialiser, IStatementInitialiser, IStatementListContainerInitialiser { + @Override + public Block instantiate(); + + @Override + public default boolean canContainStatements(StatementListContainer slc) { + return true; + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/IBreakInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/IBreakInitialiser.java new file mode 100644 index 0000000000..b72b475730 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/IBreakInitialiser.java @@ -0,0 +1,9 @@ +package cipm.consistency.initialisers.jamopp.statements; + +import org.emftext.language.java.statements.Break; + +public interface IBreakInitialiser extends IJumpInitialiser { + @Override + public Break instantiate(); + +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/ICatchBlockInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/ICatchBlockInitialiser.java new file mode 100644 index 0000000000..98f65532cb --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/ICatchBlockInitialiser.java @@ -0,0 +1,21 @@ +package cipm.consistency.initialisers.jamopp.statements; + +import org.emftext.language.java.parameters.OrdinaryParameter; +import org.emftext.language.java.statements.CatchBlock; +import org.emftext.language.java.statements.StatementListContainer; + +public interface ICatchBlockInitialiser extends IBlockContainerInitialiser, IStatementListContainerInitialiser { + + @Override + public CatchBlock instantiate(); + + public default boolean setParameter(CatchBlock cb, OrdinaryParameter param) { + cb.setParameter(param); + return (param == null && cb.getParameter() == null) || cb.getParameter().equals(param); + } + + @Override + public default boolean canContainStatements(StatementListContainer slc) { + return ((CatchBlock) slc).getBlock() != null; + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/IConditionInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/IConditionInitialiser.java new file mode 100644 index 0000000000..ae6a2e1582 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/IConditionInitialiser.java @@ -0,0 +1,16 @@ +package cipm.consistency.initialisers.jamopp.statements; + +import org.emftext.language.java.statements.Condition; +import org.emftext.language.java.statements.Statement; + +public interface IConditionInitialiser + extends IConditionalInitialiser, IStatementInitialiser, IStatementContainerInitialiser { + + @Override + public Condition instantiate(); + + public default boolean setElseStatement(Condition cond, Statement elseSt) { + cond.setElseStatement(elseSt); + return (elseSt == null && cond.getElseStatement() == null) || cond.getElseStatement().equals(elseSt); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/IConditionalInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/IConditionalInitialiser.java new file mode 100644 index 0000000000..8db3161981 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/IConditionalInitialiser.java @@ -0,0 +1,16 @@ +package cipm.consistency.initialisers.jamopp.statements; + +import org.emftext.language.java.expressions.Expression; +import org.emftext.language.java.statements.Conditional; + +import cipm.consistency.initialisers.jamopp.commons.ICommentableInitialiser; + +public interface IConditionalInitialiser extends ICommentableInitialiser { + @Override + public Conditional instantiate(); + + public default boolean setCondition(Conditional cond, Expression condExpr) { + cond.setCondition(condExpr); + return (condExpr == null && cond.getCondition() == null) || cond.getCondition().equals(condExpr); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/IContinueInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/IContinueInitialiser.java new file mode 100644 index 0000000000..dd81b69440 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/IContinueInitialiser.java @@ -0,0 +1,9 @@ +package cipm.consistency.initialisers.jamopp.statements; + +import org.emftext.language.java.statements.Continue; + +public interface IContinueInitialiser extends IJumpInitialiser { + @Override + public Continue instantiate(); + +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/IDefaultSwitchCaseInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/IDefaultSwitchCaseInitialiser.java new file mode 100644 index 0000000000..8f07ba5570 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/IDefaultSwitchCaseInitialiser.java @@ -0,0 +1,9 @@ +package cipm.consistency.initialisers.jamopp.statements; + +import org.emftext.language.java.statements.DefaultSwitchCase; + +public interface IDefaultSwitchCaseInitialiser extends ISwitchCaseInitialiser { + @Override + public DefaultSwitchCase instantiate(); + +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/IDefaultSwitchRuleInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/IDefaultSwitchRuleInitialiser.java new file mode 100644 index 0000000000..86e44431dc --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/IDefaultSwitchRuleInitialiser.java @@ -0,0 +1,9 @@ +package cipm.consistency.initialisers.jamopp.statements; + +import org.emftext.language.java.statements.DefaultSwitchRule; + +public interface IDefaultSwitchRuleInitialiser extends ISwitchRuleInitialiser { + @Override + public DefaultSwitchRule instantiate(); + +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/IDoWhileLoopInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/IDoWhileLoopInitialiser.java new file mode 100644 index 0000000000..caae9d7f27 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/IDoWhileLoopInitialiser.java @@ -0,0 +1,9 @@ +package cipm.consistency.initialisers.jamopp.statements; + +import org.emftext.language.java.statements.DoWhileLoop; + +public interface IDoWhileLoopInitialiser extends IWhileLoopInitialiser { + @Override + public DoWhileLoop instantiate(); + +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/IEmptyStatementInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/IEmptyStatementInitialiser.java new file mode 100644 index 0000000000..fa070eaecb --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/IEmptyStatementInitialiser.java @@ -0,0 +1,9 @@ +package cipm.consistency.initialisers.jamopp.statements; + +import org.emftext.language.java.statements.EmptyStatement; + +public interface IEmptyStatementInitialiser extends IStatementInitialiser { + @Override + public EmptyStatement instantiate(); + +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/IExpressionStatementInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/IExpressionStatementInitialiser.java new file mode 100644 index 0000000000..3791acdb73 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/IExpressionStatementInitialiser.java @@ -0,0 +1,14 @@ +package cipm.consistency.initialisers.jamopp.statements; + +import org.emftext.language.java.expressions.Expression; +import org.emftext.language.java.statements.ExpressionStatement; + +public interface IExpressionStatementInitialiser extends IStatementInitialiser { + @Override + public ExpressionStatement instantiate(); + + public default boolean setExpression(ExpressionStatement es, Expression expr) { + es.setExpression(expr); + return (expr == null && es.getExpression() == null) || es.getExpression().equals(expr); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/IForEachLoopInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/IForEachLoopInitialiser.java new file mode 100644 index 0000000000..38e92f8cdc --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/IForEachLoopInitialiser.java @@ -0,0 +1,20 @@ +package cipm.consistency.initialisers.jamopp.statements; + +import org.emftext.language.java.expressions.Expression; +import org.emftext.language.java.parameters.OrdinaryParameter; +import org.emftext.language.java.statements.ForEachLoop; + +public interface IForEachLoopInitialiser extends IStatementInitialiser, IStatementContainerInitialiser { + @Override + public ForEachLoop instantiate(); + + public default boolean setCollection(ForEachLoop fel, Expression col) { + fel.setCollection(col); + return (col == null && fel.getCollection() == null) || fel.getCollection().equals(col); + } + + public default boolean setNext(ForEachLoop fel, OrdinaryParameter next) { + fel.setNext(next); + return (next == null && fel.getNext() == null) || fel.getNext().equals(next); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/IForLoopInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/IForLoopInitialiser.java new file mode 100644 index 0000000000..e2dee19392 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/IForLoopInitialiser.java @@ -0,0 +1,28 @@ +package cipm.consistency.initialisers.jamopp.statements; + +import org.emftext.language.java.expressions.Expression; +import org.emftext.language.java.statements.ForLoop; +import org.emftext.language.java.statements.ForLoopInitializer; + +public interface IForLoopInitialiser + extends IConditionalInitialiser, IStatementInitialiser, IStatementContainerInitialiser { + @Override + public ForLoop instantiate(); + + public default boolean setInit(ForLoop fl, ForLoopInitializer init) { + fl.setInit(init); + return (init == null && fl.getInit() == null) || fl.getInit().equals(init); + } + + public default boolean addUpdate(ForLoop fl, Expression update) { + if (update != null) { + fl.getUpdates().add(update); + return fl.getUpdates().contains(update); + } + return true; + } + + public default boolean addUpdates(ForLoop fl, Expression[] updates) { + return this.doMultipleModifications(fl, updates, this::addUpdate); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/IForLoopInitializerInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/IForLoopInitializerInitialiser.java new file mode 100644 index 0000000000..2218814fe6 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/IForLoopInitializerInitialiser.java @@ -0,0 +1,11 @@ +package cipm.consistency.initialisers.jamopp.statements; + +import org.emftext.language.java.statements.ForLoopInitializer; + +import cipm.consistency.initialisers.jamopp.commons.ICommentableInitialiser; + +public interface IForLoopInitializerInitialiser extends ICommentableInitialiser { + @Override + public ForLoopInitializer instantiate(); + +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/IJumpInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/IJumpInitialiser.java new file mode 100644 index 0000000000..153371d275 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/IJumpInitialiser.java @@ -0,0 +1,14 @@ +package cipm.consistency.initialisers.jamopp.statements; + +import org.emftext.language.java.statements.Jump; +import org.emftext.language.java.statements.JumpLabel; + +public interface IJumpInitialiser extends IStatementInitialiser { + @Override + public Jump instantiate(); + + public default boolean setTarget(Jump jump, JumpLabel target) { + jump.setTarget(target); + return (target == null && jump.getTarget() == null) || jump.getTarget().equals(target); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/IJumpLabelInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/IJumpLabelInitialiser.java new file mode 100644 index 0000000000..dc511cfd1e --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/IJumpLabelInitialiser.java @@ -0,0 +1,12 @@ +package cipm.consistency.initialisers.jamopp.statements; + +import org.emftext.language.java.statements.JumpLabel; + +import cipm.consistency.initialisers.jamopp.commons.INamedElementInitialiser; + +public interface IJumpLabelInitialiser + extends INamedElementInitialiser, IStatementInitialiser, IStatementContainerInitialiser { + @Override + public JumpLabel instantiate(); + +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/ILocalVariableStatementInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/ILocalVariableStatementInitialiser.java new file mode 100644 index 0000000000..a4c09a2c4f --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/ILocalVariableStatementInitialiser.java @@ -0,0 +1,14 @@ +package cipm.consistency.initialisers.jamopp.statements; + +import org.emftext.language.java.statements.LocalVariableStatement; +import org.emftext.language.java.variables.LocalVariable; + +public interface ILocalVariableStatementInitialiser extends IStatementInitialiser { + @Override + public LocalVariableStatement instantiate(); + + public default boolean setVariable(LocalVariableStatement lvs, LocalVariable var) { + lvs.setVariable(var); + return (var == null && lvs.getVariable() == null) || lvs.getVariable().equals(var); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/INormalSwitchCaseInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/INormalSwitchCaseInitialiser.java new file mode 100644 index 0000000000..6a1cf39269 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/INormalSwitchCaseInitialiser.java @@ -0,0 +1,21 @@ +package cipm.consistency.initialisers.jamopp.statements; + +import org.emftext.language.java.expressions.Expression; +import org.emftext.language.java.statements.NormalSwitchCase; + +public interface INormalSwitchCaseInitialiser extends IConditionalInitialiser, ISwitchCaseInitialiser { + @Override + public NormalSwitchCase instantiate(); + + public default boolean addAdditionalCondition(NormalSwitchCase nsc, Expression additionalCond) { + if (additionalCond != null) { + nsc.getAdditionalConditions().add(additionalCond); + return nsc.getAdditionalConditions().contains(additionalCond); + } + return true; + } + + public default boolean addAdditionalConditions(NormalSwitchCase nsc, Expression[] additionalConds) { + return this.doMultipleModifications(nsc, additionalConds, this::addAdditionalCondition); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/INormalSwitchRuleInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/INormalSwitchRuleInitialiser.java new file mode 100644 index 0000000000..fceb95bc6b --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/INormalSwitchRuleInitialiser.java @@ -0,0 +1,21 @@ +package cipm.consistency.initialisers.jamopp.statements; + +import org.emftext.language.java.expressions.Expression; +import org.emftext.language.java.statements.NormalSwitchRule; + +public interface INormalSwitchRuleInitialiser extends IConditionalInitialiser, ISwitchRuleInitialiser { + @Override + public NormalSwitchRule instantiate(); + + public default boolean addAdditionalCondition(NormalSwitchRule nsr, Expression additionalCond) { + if (additionalCond != null) { + nsr.getAdditionalConditions().add(additionalCond); + return nsr.getAdditionalConditions().contains(additionalCond); + } + return true; + } + + public default boolean addAdditionalConditions(NormalSwitchRule nsr, Expression[] additionalConds) { + return this.doMultipleModifications(nsr, additionalConds, this::addAdditionalCondition); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/IReturnInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/IReturnInitialiser.java new file mode 100644 index 0000000000..37f860918c --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/IReturnInitialiser.java @@ -0,0 +1,14 @@ +package cipm.consistency.initialisers.jamopp.statements; + +import org.emftext.language.java.expressions.Expression; +import org.emftext.language.java.statements.Return; + +public interface IReturnInitialiser extends IStatementInitialiser { + @Override + public Return instantiate(); + + public default boolean setReturnValue(Return ret, Expression retVal) { + ret.setReturnValue(retVal); + return (retVal == null && ret.getReturnValue() == null) || ret.getReturnValue().equals(retVal); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/IStatementContainerInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/IStatementContainerInitialiser.java new file mode 100644 index 0000000000..f48279bbb6 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/IStatementContainerInitialiser.java @@ -0,0 +1,16 @@ +package cipm.consistency.initialisers.jamopp.statements; + +import org.emftext.language.java.statements.Statement; +import org.emftext.language.java.statements.StatementContainer; + +import cipm.consistency.initialisers.jamopp.commons.ICommentableInitialiser; + +public interface IStatementContainerInitialiser extends ICommentableInitialiser { + @Override + public StatementContainer instantiate(); + + public default boolean setStatement(StatementContainer sc, Statement st) { + sc.setStatement(st); + return (st == null && sc.getStatement() == null) || sc.getStatement().equals(st); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/IStatementInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/IStatementInitialiser.java new file mode 100644 index 0000000000..d42ae16503 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/IStatementInitialiser.java @@ -0,0 +1,10 @@ +package cipm.consistency.initialisers.jamopp.statements; + +import org.emftext.language.java.statements.Statement; + +import cipm.consistency.initialisers.jamopp.commons.ICommentableInitialiser; + +public interface IStatementInitialiser extends ICommentableInitialiser { + @Override + public Statement instantiate(); +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/IStatementListContainerInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/IStatementListContainerInitialiser.java new file mode 100644 index 0000000000..e0d241ab4e --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/IStatementListContainerInitialiser.java @@ -0,0 +1,63 @@ +package cipm.consistency.initialisers.jamopp.statements; + +import org.emftext.language.java.statements.Statement; +import org.emftext.language.java.statements.StatementListContainer; + +import cipm.consistency.initialisers.jamopp.commons.ICommentableInitialiser; + +/** + * An interface meant to be implemented by initialisers, which are supposed to + * create {@link StatementListContainer} instances.
+ *
+ * Not all implementors of {@link StatementListContainer} allow adding + * statements via {@code .getStatements().add(...)} as expected. Attempting to + * add statements that way can result in exceptions under circumstances. The + * method {@link #canContainStatements(StatementListContainer)} can be used to + * determine, whether this is possible. + * + * @author Alp Torac Genc + */ +public interface IStatementListContainerInitialiser extends ICommentableInitialiser { + @Override + public StatementListContainer instantiate(); + + /** + * Attempts to add the given {@link Statement} st to the given + * {@link StatementListContainer} slc. Uses {@code slc.getStatements().add(st)} + * to do so.
+ *
+ * Note: Attempting to add a null statement will still return true, since there + * is no modification to be performed. + * + * @see {@link IStatementListContainerInitialiser} + * @see {@link #addStatementAssertion(StatementListContainer, Statement)} + */ + public default boolean addStatement(StatementListContainer slc, Statement st) { + if (st != null) { + if (!this.canContainStatements(slc)) { + return false; + } + slc.getStatements().add(st); + return slc.getStatements().contains(st); + } + return true; + } + + /** + * Extracted from {@link #addStatement(StatementListContainer, Statement)} + * because there are some implementors of {@link StatementListContainer}, which + * throw {@link NullPointerException} if {@code slc.getStatements().add(...)} is + * called without proper initialisation. Extracting this method allows such + * implementors to indicate, whether {@link Statement}s can be added to them via + * {@link #addStatement(StatementListContainer, Statement)} without issues. + * + * @return Whether {@link Statement}s can be added to the given + * {@link StatementListContainer} via + * {@link #addStatement(StatementListContainer, Statement)}. + */ + public boolean canContainStatements(StatementListContainer slc); + + public default boolean addStatements(StatementListContainer slc, Statement[] sts) { + return this.doMultipleModifications(slc, sts, this::addStatement); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/ISwitchCaseInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/ISwitchCaseInitialiser.java new file mode 100644 index 0000000000..4703854963 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/ISwitchCaseInitialiser.java @@ -0,0 +1,14 @@ +package cipm.consistency.initialisers.jamopp.statements; + +import org.emftext.language.java.statements.StatementListContainer; +import org.emftext.language.java.statements.SwitchCase; + +public interface ISwitchCaseInitialiser extends IStatementListContainerInitialiser { + @Override + public SwitchCase instantiate(); + + @Override + public default boolean canContainStatements(StatementListContainer slc) { + return true; + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/ISwitchInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/ISwitchInitialiser.java new file mode 100644 index 0000000000..66d349f11f --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/ISwitchInitialiser.java @@ -0,0 +1,29 @@ +package cipm.consistency.initialisers.jamopp.statements; + +import org.emftext.language.java.expressions.Expression; +import org.emftext.language.java.statements.Switch; +import org.emftext.language.java.statements.SwitchCase; + +import cipm.consistency.initialisers.jamopp.expressions.IUnaryModificationExpressionChildInitialiser; + +public interface ISwitchInitialiser extends IStatementInitialiser, IUnaryModificationExpressionChildInitialiser { + @Override + public Switch instantiate(); + + public default boolean addCase(Switch sw, SwitchCase swCase) { + if (swCase != null) { + sw.getCases().add(swCase); + return sw.getCases().contains(swCase); + } + return true; + } + + public default boolean addCases(Switch sw, SwitchCase[] swCases) { + return this.doMultipleModifications(sw, swCases, this::addCase); + } + + public default boolean setVariable(Switch sw, Expression var) { + sw.setVariable(var); + return (var == null && sw.getVariable() == null) || sw.getVariable().equals(var); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/ISwitchRuleInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/ISwitchRuleInitialiser.java new file mode 100644 index 0000000000..63c08ecce6 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/ISwitchRuleInitialiser.java @@ -0,0 +1,9 @@ +package cipm.consistency.initialisers.jamopp.statements; + +import org.emftext.language.java.statements.SwitchRule; + +public interface ISwitchRuleInitialiser extends ISwitchCaseInitialiser { + @Override + public SwitchRule instantiate(); + +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/ISynchronizedBlockInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/ISynchronizedBlockInitialiser.java new file mode 100644 index 0000000000..384587e36c --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/ISynchronizedBlockInitialiser.java @@ -0,0 +1,22 @@ +package cipm.consistency.initialisers.jamopp.statements; + +import org.emftext.language.java.expressions.Expression; +import org.emftext.language.java.statements.StatementListContainer; +import org.emftext.language.java.statements.SynchronizedBlock; + +public interface ISynchronizedBlockInitialiser + extends IBlockContainerInitialiser, IStatementInitialiser, IStatementListContainerInitialiser { + @Override + public SynchronizedBlock instantiate(); + + public default boolean setLockProvider(SynchronizedBlock sb, Expression lockProvider) { + sb.setLockProvider(lockProvider); + return (lockProvider == null && sb.getLockProvider() == null) || sb.getLockProvider().equals(lockProvider); + + } + + @Override + public default boolean canContainStatements(StatementListContainer slc) { + return ((SynchronizedBlock) slc).getBlock() != null; + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/IThrowInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/IThrowInitialiser.java new file mode 100644 index 0000000000..9657f4950c --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/IThrowInitialiser.java @@ -0,0 +1,14 @@ +package cipm.consistency.initialisers.jamopp.statements; + +import org.emftext.language.java.expressions.Expression; +import org.emftext.language.java.statements.Throw; + +public interface IThrowInitialiser extends IStatementInitialiser { + @Override + public Throw instantiate(); + + public default boolean setThrowable(Throw th, Expression throwable) { + th.setThrowable(throwable); + return (throwable == null && th.getThrowable() == null) || th.getThrowable().equals(throwable); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/ITryBlockInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/ITryBlockInitialiser.java new file mode 100644 index 0000000000..e072c15912 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/ITryBlockInitialiser.java @@ -0,0 +1,47 @@ +package cipm.consistency.initialisers.jamopp.statements; + +import org.emftext.language.java.statements.Block; +import org.emftext.language.java.statements.CatchBlock; +import org.emftext.language.java.statements.StatementListContainer; +import org.emftext.language.java.statements.TryBlock; +import org.emftext.language.java.variables.Resource; + +public interface ITryBlockInitialiser + extends IBlockContainerInitialiser, IStatementInitialiser, IStatementListContainerInitialiser { + @Override + public TryBlock instantiate(); + + public default boolean setFinallyBlock(TryBlock tb, Block finallyBlock) { + tb.setFinallyBlock(finallyBlock); + return (finallyBlock == null && tb.getFinallyBlock() == null) || tb.getFinallyBlock().equals(finallyBlock); + } + + public default boolean addCatchBlock(TryBlock tb, CatchBlock cb) { + if (cb != null) { + tb.getCatchBlocks().add(cb); + return tb.getCatchBlocks().contains(cb); + } + return true; + } + + public default boolean addCatchBlocks(TryBlock tb, CatchBlock[] cbs) { + return this.doMultipleModifications(tb, cbs, this::addCatchBlock); + } + + public default boolean addResource(TryBlock tb, Resource res) { + if (res != null) { + tb.getResources().add(res); + return tb.getResources().contains(res); + } + return true; + } + + public default boolean addResources(TryBlock tb, Resource[] ress) { + return this.doMultipleModifications(tb, ress, this::addResource); + } + + @Override + public default boolean canContainStatements(StatementListContainer slc) { + return ((TryBlock) slc).getBlock() != null; + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/IWhileLoopInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/IWhileLoopInitialiser.java new file mode 100644 index 0000000000..a809a2ceed --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/IWhileLoopInitialiser.java @@ -0,0 +1,10 @@ +package cipm.consistency.initialisers.jamopp.statements; + +import org.emftext.language.java.statements.WhileLoop; + +public interface IWhileLoopInitialiser + extends IConditionalInitialiser, IStatementInitialiser, IStatementContainerInitialiser { + @Override + public WhileLoop instantiate(); + +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/IYieldStatementInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/IYieldStatementInitialiser.java new file mode 100644 index 0000000000..ecc8972db9 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/IYieldStatementInitialiser.java @@ -0,0 +1,14 @@ +package cipm.consistency.initialisers.jamopp.statements; + +import org.emftext.language.java.expressions.Expression; +import org.emftext.language.java.statements.YieldStatement; + +public interface IYieldStatementInitialiser extends IStatementInitialiser { + @Override + public YieldStatement instantiate(); + + public default boolean setYieldExpression(YieldStatement ys, Expression yieldExpr) { + ys.setYieldExpression(yieldExpr); + return (yieldExpr == null && ys.getYieldExpression() == null) || ys.getYieldExpression().equals(yieldExpr); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/JumpLabelInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/JumpLabelInitialiser.java new file mode 100644 index 0000000000..9d6e125b79 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/JumpLabelInitialiser.java @@ -0,0 +1,18 @@ +package cipm.consistency.initialisers.jamopp.statements; + +import org.emftext.language.java.statements.JumpLabel; +import org.emftext.language.java.statements.StatementsFactory; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class JumpLabelInitialiser extends AbstractInitialiserBase implements IJumpLabelInitialiser { + @Override + public IJumpLabelInitialiser newInitialiser() { + return new JumpLabelInitialiser(); + } + + @Override + public JumpLabel instantiate() { + return StatementsFactory.eINSTANCE.createJumpLabel(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/LocalVariableStatementInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/LocalVariableStatementInitialiser.java new file mode 100644 index 0000000000..42bdfa0eeb --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/LocalVariableStatementInitialiser.java @@ -0,0 +1,19 @@ +package cipm.consistency.initialisers.jamopp.statements; + +import org.emftext.language.java.statements.LocalVariableStatement; +import org.emftext.language.java.statements.StatementsFactory; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class LocalVariableStatementInitialiser extends AbstractInitialiserBase + implements ILocalVariableStatementInitialiser { + @Override + public ILocalVariableStatementInitialiser newInitialiser() { + return new LocalVariableStatementInitialiser(); + } + + @Override + public LocalVariableStatement instantiate() { + return StatementsFactory.eINSTANCE.createLocalVariableStatement(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/NormalSwitchCaseInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/NormalSwitchCaseInitialiser.java new file mode 100644 index 0000000000..676e591ca4 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/NormalSwitchCaseInitialiser.java @@ -0,0 +1,18 @@ +package cipm.consistency.initialisers.jamopp.statements; + +import org.emftext.language.java.statements.NormalSwitchCase; +import org.emftext.language.java.statements.StatementsFactory; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class NormalSwitchCaseInitialiser extends AbstractInitialiserBase implements INormalSwitchCaseInitialiser { + @Override + public INormalSwitchCaseInitialiser newInitialiser() { + return new NormalSwitchCaseInitialiser(); + } + + @Override + public NormalSwitchCase instantiate() { + return StatementsFactory.eINSTANCE.createNormalSwitchCase(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/NormalSwitchRuleInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/NormalSwitchRuleInitialiser.java new file mode 100644 index 0000000000..490d73eecc --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/NormalSwitchRuleInitialiser.java @@ -0,0 +1,18 @@ +package cipm.consistency.initialisers.jamopp.statements; + +import org.emftext.language.java.statements.NormalSwitchRule; +import org.emftext.language.java.statements.StatementsFactory; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class NormalSwitchRuleInitialiser extends AbstractInitialiserBase implements INormalSwitchRuleInitialiser { + @Override + public INormalSwitchRuleInitialiser newInitialiser() { + return new NormalSwitchRuleInitialiser(); + } + + @Override + public NormalSwitchRule instantiate() { + return StatementsFactory.eINSTANCE.createNormalSwitchRule(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/ReturnInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/ReturnInitialiser.java new file mode 100644 index 0000000000..f090c97614 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/ReturnInitialiser.java @@ -0,0 +1,18 @@ +package cipm.consistency.initialisers.jamopp.statements; + +import org.emftext.language.java.statements.Return; +import org.emftext.language.java.statements.StatementsFactory; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class ReturnInitialiser extends AbstractInitialiserBase implements IReturnInitialiser { + @Override + public IReturnInitialiser newInitialiser() { + return new ReturnInitialiser(); + } + + @Override + public Return instantiate() { + return StatementsFactory.eINSTANCE.createReturn(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/StatementsInitialiserPackage.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/StatementsInitialiserPackage.java new file mode 100644 index 0000000000..31064592f1 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/StatementsInitialiserPackage.java @@ -0,0 +1,38 @@ +package cipm.consistency.initialisers.jamopp.statements; + +import java.util.Collection; + +import cipm.consistency.initialisers.IInitialiser; +import cipm.consistency.initialisers.IInitialiserPackage; + +public class StatementsInitialiserPackage implements IInitialiserPackage { + @Override + public Collection getInitialiserInstances() { + return this.initCol(new IInitialiser[] { new AssertInitialiser(), new BlockInitialiser(), + new BreakInitialiser(), new CatchBlockInitialiser(), new ConditionInitialiser(), + new ContinueInitialiser(), new DefaultSwitchCaseInitialiser(), new DefaultSwitchRuleInitialiser(), + new DoWhileLoopInitialiser(), new EmptyStatementInitialiser(), new ExpressionStatementInitialiser(), + new ForEachLoopInitialiser(), new ForLoopInitialiser(), new JumpLabelInitialiser(), + new LocalVariableStatementInitialiser(), new NormalSwitchCaseInitialiser(), + new NormalSwitchRuleInitialiser(), new ReturnInitialiser(), new SwitchInitialiser(), + new SynchronizedBlockInitialiser(), new ThrowInitialiser(), new TryBlockInitialiser(), + new WhileLoopInitialiser(), new YieldStatementInitialiser(), }); + } + + @SuppressWarnings("unchecked") + @Override + public Collection> getInitialiserInterfaceTypes() { + return this.initCol(new Class[] { IAssertInitialiser.class, IBlockContainerInitialiser.class, + IBlockInitialiser.class, IBreakInitialiser.class, ICatchBlockInitialiser.class, + IConditionalInitialiser.class, IConditionInitialiser.class, IContinueInitialiser.class, + IDefaultSwitchCaseInitialiser.class, IDefaultSwitchRuleInitialiser.class, IDoWhileLoopInitialiser.class, + IEmptyStatementInitialiser.class, IExpressionStatementInitialiser.class, IForEachLoopInitialiser.class, + IForLoopInitialiser.class, IForLoopInitializerInitialiser.class, IJumpInitialiser.class, + IJumpLabelInitialiser.class, ILocalVariableStatementInitialiser.class, + INormalSwitchCaseInitialiser.class, INormalSwitchRuleInitialiser.class, IReturnInitialiser.class, + IStatementContainerInitialiser.class, IStatementInitialiser.class, + IStatementListContainerInitialiser.class, ISwitchCaseInitialiser.class, ISwitchInitialiser.class, + ISwitchRuleInitialiser.class, ISynchronizedBlockInitialiser.class, IThrowInitialiser.class, + ITryBlockInitialiser.class, IWhileLoopInitialiser.class, IYieldStatementInitialiser.class, }); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/SwitchInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/SwitchInitialiser.java new file mode 100644 index 0000000000..23900854d3 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/SwitchInitialiser.java @@ -0,0 +1,18 @@ +package cipm.consistency.initialisers.jamopp.statements; + +import org.emftext.language.java.statements.StatementsFactory; +import org.emftext.language.java.statements.Switch; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class SwitchInitialiser extends AbstractInitialiserBase implements ISwitchInitialiser { + @Override + public ISwitchInitialiser newInitialiser() { + return new SwitchInitialiser(); + } + + @Override + public Switch instantiate() { + return StatementsFactory.eINSTANCE.createSwitch(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/SynchronizedBlockInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/SynchronizedBlockInitialiser.java new file mode 100644 index 0000000000..e69411fe4f --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/SynchronizedBlockInitialiser.java @@ -0,0 +1,18 @@ +package cipm.consistency.initialisers.jamopp.statements; + +import org.emftext.language.java.statements.StatementsFactory; +import org.emftext.language.java.statements.SynchronizedBlock; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class SynchronizedBlockInitialiser extends AbstractInitialiserBase implements ISynchronizedBlockInitialiser { + @Override + public SynchronizedBlock instantiate() { + return StatementsFactory.eINSTANCE.createSynchronizedBlock(); + } + + @Override + public SynchronizedBlockInitialiser newInitialiser() { + return new SynchronizedBlockInitialiser(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/ThrowInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/ThrowInitialiser.java new file mode 100644 index 0000000000..6e1f83a558 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/ThrowInitialiser.java @@ -0,0 +1,18 @@ +package cipm.consistency.initialisers.jamopp.statements; + +import org.emftext.language.java.statements.StatementsFactory; +import org.emftext.language.java.statements.Throw; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class ThrowInitialiser extends AbstractInitialiserBase implements IThrowInitialiser { + @Override + public IThrowInitialiser newInitialiser() { + return new ThrowInitialiser(); + } + + @Override + public Throw instantiate() { + return StatementsFactory.eINSTANCE.createThrow(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/TryBlockInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/TryBlockInitialiser.java new file mode 100644 index 0000000000..bd47c7fefd --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/TryBlockInitialiser.java @@ -0,0 +1,18 @@ +package cipm.consistency.initialisers.jamopp.statements; + +import org.emftext.language.java.statements.StatementsFactory; +import org.emftext.language.java.statements.TryBlock; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class TryBlockInitialiser extends AbstractInitialiserBase implements ITryBlockInitialiser { + @Override + public TryBlock instantiate() { + return StatementsFactory.eINSTANCE.createTryBlock(); + } + + @Override + public TryBlockInitialiser newInitialiser() { + return new TryBlockInitialiser(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/WhileLoopInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/WhileLoopInitialiser.java new file mode 100644 index 0000000000..99cb95be48 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/WhileLoopInitialiser.java @@ -0,0 +1,18 @@ +package cipm.consistency.initialisers.jamopp.statements; + +import org.emftext.language.java.statements.StatementsFactory; +import org.emftext.language.java.statements.WhileLoop; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class WhileLoopInitialiser extends AbstractInitialiserBase implements IWhileLoopInitialiser { + @Override + public IWhileLoopInitialiser newInitialiser() { + return new WhileLoopInitialiser(); + } + + @Override + public WhileLoop instantiate() { + return StatementsFactory.eINSTANCE.createWhileLoop(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/YieldStatementInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/YieldStatementInitialiser.java new file mode 100644 index 0000000000..ee424b5f10 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/YieldStatementInitialiser.java @@ -0,0 +1,18 @@ +package cipm.consistency.initialisers.jamopp.statements; + +import org.emftext.language.java.statements.StatementsFactory; +import org.emftext.language.java.statements.YieldStatement; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class YieldStatementInitialiser extends AbstractInitialiserBase implements IYieldStatementInitialiser { + @Override + public IYieldStatementInitialiser newInitialiser() { + return new YieldStatementInitialiser(); + } + + @Override + public YieldStatement instantiate() { + return StatementsFactory.eINSTANCE.createYieldStatement(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/package-info.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/package-info.java new file mode 100644 index 0000000000..b7cc4f581b --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/statements/package-info.java @@ -0,0 +1,5 @@ +/** + * Contains {@link IInitialiser} implementations for + * {@link org.emftext.language.java.statements}. + */ +package cipm.consistency.initialisers.jamopp.statements; \ No newline at end of file From 5c0a46ae38c1bdb6063397b586a1f58a61d578cc Mon Sep 17 00:00:00 2001 From: AlpTorac Date: Fri, 25 Oct 2024 17:39:56 +0200 Subject: [PATCH 26/55] (WIP) Implement initialiser package for org.emftext.language.java.types --- .../jamopp/types/BooleanInitialiser.java | 18 +++ .../jamopp/types/ByteInitialiser.java | 18 +++ .../jamopp/types/CharInitialiser.java | 18 +++ .../types/ClassifierReferenceInitialiser.java | 18 +++ .../jamopp/types/DoubleInitialiser.java | 18 +++ .../jamopp/types/FloatInitialiser.java | 18 +++ .../jamopp/types/IBooleanInitialiser.java | 9 ++ .../jamopp/types/IByteInitialiser.java | 9 ++ .../jamopp/types/ICharInitialiser.java | 9 ++ .../IClassifierReferenceInitialiser.java | 18 +++ .../jamopp/types/IDoubleInitialiser.java | 9 ++ .../jamopp/types/IFloatInitialiser.java | 9 ++ .../types/IInferableTypeInitialiser.java | 14 +++ .../jamopp/types/IIntInitialiser.java | 9 ++ .../jamopp/types/ILongInitialiser.java | 9 ++ ...mespaceClassifierReferenceInitialiser.java | 103 ++++++++++++++++++ .../types/IPrimitiveTypeInitialiser.java | 46 ++++++++ .../jamopp/types/IShortInitialiser.java | 9 ++ .../jamopp/types/ITypeInitialiser.java | 10 ++ .../types/ITypeReferenceInitialiser.java | 76 +++++++++++++ .../ITypedElementExtensionInitialiser.java | 23 ++++ .../types/ITypedElementInitialiser.java | 16 +++ .../jamopp/types/IVoidInitialiser.java | 9 ++ .../types/InferableTypeInitialiser.java | 18 +++ .../jamopp/types/IntInitialiser.java | 18 +++ .../jamopp/types/LongInitialiser.java | 18 +++ ...mespaceClassifierReferenceInitialiser.java | 19 ++++ .../jamopp/types/ShortInitialiser.java | 18 +++ .../jamopp/types/TypesInitialiserPackage.java | 27 +++++ .../jamopp/types/VoidInitialiser.java | 18 +++ .../jamopp/types/package-info.java | 5 + 31 files changed, 636 insertions(+) create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/types/BooleanInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/types/ByteInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/types/CharInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/types/ClassifierReferenceInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/types/DoubleInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/types/FloatInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/types/IBooleanInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/types/IByteInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/types/ICharInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/types/IClassifierReferenceInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/types/IDoubleInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/types/IFloatInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/types/IInferableTypeInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/types/IIntInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/types/ILongInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/types/INamespaceClassifierReferenceInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/types/IPrimitiveTypeInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/types/IShortInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/types/ITypeInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/types/ITypeReferenceInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/types/ITypedElementExtensionInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/types/ITypedElementInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/types/IVoidInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/types/InferableTypeInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/types/IntInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/types/LongInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/types/NamespaceClassifierReferenceInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/types/ShortInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/types/TypesInitialiserPackage.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/types/VoidInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/types/package-info.java diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/types/BooleanInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/types/BooleanInitialiser.java new file mode 100644 index 0000000000..83a7386521 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/types/BooleanInitialiser.java @@ -0,0 +1,18 @@ +package cipm.consistency.initialisers.jamopp.types; + +import org.emftext.language.java.types.Boolean; +import org.emftext.language.java.types.TypesFactory; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class BooleanInitialiser extends AbstractInitialiserBase implements IBooleanInitialiser { + @Override + public IBooleanInitialiser newInitialiser() { + return new BooleanInitialiser(); + } + + @Override + public Boolean instantiate() { + return TypesFactory.eINSTANCE.createBoolean(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/types/ByteInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/types/ByteInitialiser.java new file mode 100644 index 0000000000..211e79bc08 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/types/ByteInitialiser.java @@ -0,0 +1,18 @@ +package cipm.consistency.initialisers.jamopp.types; + +import org.emftext.language.java.types.Byte; +import org.emftext.language.java.types.TypesFactory; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class ByteInitialiser extends AbstractInitialiserBase implements IByteInitialiser { + @Override + public IByteInitialiser newInitialiser() { + return new ByteInitialiser(); + } + + @Override + public Byte instantiate() { + return TypesFactory.eINSTANCE.createByte(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/types/CharInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/types/CharInitialiser.java new file mode 100644 index 0000000000..2c77c2b86f --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/types/CharInitialiser.java @@ -0,0 +1,18 @@ +package cipm.consistency.initialisers.jamopp.types; + +import org.emftext.language.java.types.Char; +import org.emftext.language.java.types.TypesFactory; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class CharInitialiser extends AbstractInitialiserBase implements ICharInitialiser { + @Override + public ICharInitialiser newInitialiser() { + return new CharInitialiser(); + } + + @Override + public Char instantiate() { + return TypesFactory.eINSTANCE.createChar(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/types/ClassifierReferenceInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/types/ClassifierReferenceInitialiser.java new file mode 100644 index 0000000000..206be0b1f3 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/types/ClassifierReferenceInitialiser.java @@ -0,0 +1,18 @@ +package cipm.consistency.initialisers.jamopp.types; + +import org.emftext.language.java.types.ClassifierReference; +import org.emftext.language.java.types.TypesFactory; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class ClassifierReferenceInitialiser extends AbstractInitialiserBase implements IClassifierReferenceInitialiser { + @Override + public IClassifierReferenceInitialiser newInitialiser() { + return new ClassifierReferenceInitialiser(); + } + + @Override + public ClassifierReference instantiate() { + return TypesFactory.eINSTANCE.createClassifierReference(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/types/DoubleInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/types/DoubleInitialiser.java new file mode 100644 index 0000000000..0a3d473594 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/types/DoubleInitialiser.java @@ -0,0 +1,18 @@ +package cipm.consistency.initialisers.jamopp.types; + +import org.emftext.language.java.types.Double; +import org.emftext.language.java.types.TypesFactory; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class DoubleInitialiser extends AbstractInitialiserBase implements IDoubleInitialiser { + @Override + public IDoubleInitialiser newInitialiser() { + return new DoubleInitialiser(); + } + + @Override + public Double instantiate() { + return TypesFactory.eINSTANCE.createDouble(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/types/FloatInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/types/FloatInitialiser.java new file mode 100644 index 0000000000..4604a8c690 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/types/FloatInitialiser.java @@ -0,0 +1,18 @@ +package cipm.consistency.initialisers.jamopp.types; + +import org.emftext.language.java.types.Float; +import org.emftext.language.java.types.TypesFactory; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class FloatInitialiser extends AbstractInitialiserBase implements IFloatInitialiser { + @Override + public IFloatInitialiser newInitialiser() { + return new FloatInitialiser(); + } + + @Override + public Float instantiate() { + return TypesFactory.eINSTANCE.createFloat(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/types/IBooleanInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/types/IBooleanInitialiser.java new file mode 100644 index 0000000000..cd9283a50b --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/types/IBooleanInitialiser.java @@ -0,0 +1,9 @@ +package cipm.consistency.initialisers.jamopp.types; + +import org.emftext.language.java.types.Boolean; + +public interface IBooleanInitialiser extends IPrimitiveTypeInitialiser { + @Override + public Boolean instantiate(); + +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/types/IByteInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/types/IByteInitialiser.java new file mode 100644 index 0000000000..49b6ab9d60 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/types/IByteInitialiser.java @@ -0,0 +1,9 @@ +package cipm.consistency.initialisers.jamopp.types; + +import org.emftext.language.java.types.Byte; + +public interface IByteInitialiser extends IPrimitiveTypeInitialiser { + @Override + public Byte instantiate(); + +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/types/ICharInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/types/ICharInitialiser.java new file mode 100644 index 0000000000..14ecb2aa30 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/types/ICharInitialiser.java @@ -0,0 +1,9 @@ +package cipm.consistency.initialisers.jamopp.types; + +import org.emftext.language.java.types.Char; + +public interface ICharInitialiser extends IPrimitiveTypeInitialiser { + @Override + public Char instantiate(); + +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/types/IClassifierReferenceInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/types/IClassifierReferenceInitialiser.java new file mode 100644 index 0000000000..2a2045f616 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/types/IClassifierReferenceInitialiser.java @@ -0,0 +1,18 @@ +package cipm.consistency.initialisers.jamopp.types; + +import org.emftext.language.java.types.ClassifierReference; +import org.emftext.language.java.types.TypeReference; + +import cipm.consistency.initialisers.jamopp.annotations.IAnnotableInitialiser; +import cipm.consistency.initialisers.jamopp.generics.ITypeArgumentableInitialiser; + +public interface IClassifierReferenceInitialiser + extends ITypeArgumentableInitialiser, IAnnotableInitialiser, ITypeReferenceInitialiser { + @Override + public ClassifierReference instantiate(); + + @Override + public default boolean canSetTarget(TypeReference tref) { + return true; + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/types/IDoubleInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/types/IDoubleInitialiser.java new file mode 100644 index 0000000000..50e651be63 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/types/IDoubleInitialiser.java @@ -0,0 +1,9 @@ +package cipm.consistency.initialisers.jamopp.types; + +import org.emftext.language.java.types.Double; + +public interface IDoubleInitialiser extends IPrimitiveTypeInitialiser { + @Override + public Double instantiate(); + +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/types/IFloatInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/types/IFloatInitialiser.java new file mode 100644 index 0000000000..9976df7438 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/types/IFloatInitialiser.java @@ -0,0 +1,9 @@ +package cipm.consistency.initialisers.jamopp.types; + +import org.emftext.language.java.types.Float; + +public interface IFloatInitialiser extends IPrimitiveTypeInitialiser { + @Override + public Float instantiate(); + +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/types/IInferableTypeInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/types/IInferableTypeInitialiser.java new file mode 100644 index 0000000000..cf80eaa051 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/types/IInferableTypeInitialiser.java @@ -0,0 +1,14 @@ +package cipm.consistency.initialisers.jamopp.types; + +import org.emftext.language.java.types.InferableType; +import org.emftext.language.java.types.TypeReference; + +public interface IInferableTypeInitialiser extends ITypedElementExtensionInitialiser, ITypeReferenceInitialiser { + @Override + public InferableType instantiate(); + + @Override + public default boolean canSetTarget(TypeReference tref) { + return true; + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/types/IIntInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/types/IIntInitialiser.java new file mode 100644 index 0000000000..6c573d4f45 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/types/IIntInitialiser.java @@ -0,0 +1,9 @@ +package cipm.consistency.initialisers.jamopp.types; + +import org.emftext.language.java.types.Int; + +public interface IIntInitialiser extends IPrimitiveTypeInitialiser { + @Override + public Int instantiate(); + +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/types/ILongInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/types/ILongInitialiser.java new file mode 100644 index 0000000000..3836ab4ddb --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/types/ILongInitialiser.java @@ -0,0 +1,9 @@ +package cipm.consistency.initialisers.jamopp.types; + +import org.emftext.language.java.types.Long; + +public interface ILongInitialiser extends IPrimitiveTypeInitialiser { + @Override + public Long instantiate(); + +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/types/INamespaceClassifierReferenceInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/types/INamespaceClassifierReferenceInitialiser.java new file mode 100644 index 0000000000..86fe428c1b --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/types/INamespaceClassifierReferenceInitialiser.java @@ -0,0 +1,103 @@ +package cipm.consistency.initialisers.jamopp.types; + +import org.emftext.language.java.classifiers.Classifier; +import org.emftext.language.java.types.ClassifierReference; +import org.emftext.language.java.types.NamespaceClassifierReference; +import org.emftext.language.java.types.TypeReference; + +import cipm.consistency.initialisers.jamopp.commons.INamespaceAwareElementInitialiser; + +public interface INamespaceClassifierReferenceInitialiser + extends INamespaceAwareElementInitialiser, ITypeReferenceInitialiser { + @Override + public NamespaceClassifierReference instantiate(); + + @Override + public default boolean setTargetAssertion(TypeReference tref, Classifier target) { + if (target == null && tref.getTarget() == null) { + return true; + } else if (target == null) { + return false; + } + + var castedTref = (NamespaceClassifierReference) tref; + var containerName = target.getContainingContainerName(); + var nss = castedTref.getNamespaces(); + var clsRefs = castedTref.getClassifierReferences(); + + /* + * Assertions for the implementation at + * https://github.com/DevBoost/JaMoPP/blob/master/Core/org.emftext.language.java + * /src/org/emftext/language/java/extensions/types/TypeReferenceExtension.java + */ + return ITypeReferenceInitialiser.super.setTargetAssertion(tref, target) && nss != null && containerName != null + && nss.size() == containerName.size() && nss.containsAll(containerName) && clsRefs != null + && clsRefs.size() == 1 && clsRefs.stream().anyMatch((cr) -> cr.getTarget().equals(target)); + } + + /** + * {@inheritDoc}
+ *
+ * In the case of {@link NamespaceClassifierReference}, this method: + *
    + *
  • Clears ALL {@link ClassifierReference} instances stored in tref, + *
  • Sets target of tref ({@code tref.getTarget()}) to target, + *
  • Internally constructs and adds a {@link ClassifierReference} pointing at + * target to tref. + *
+ * The overridden version of this method in {@link NamespaceClassifierReference} + * introduces no changes to its super version in + * {@link ITypeReferenceInitialiser}. It is overridden for the sake of providing + * commentary.
+ *
+ * + * @see {@link #canSetTarget(TypeReference)} + * @see {@link #canSetTargetTo(TypeReference, Classifier)} + * @see {@link #setTargetAssertion(TypeReference, Classifier)} + * @see {@link #addClassifierReference(NamespaceClassifierReference, ClassifierReference)} + */ + @Override + public default boolean setTarget(TypeReference tref, Classifier target) { + return ITypeReferenceInitialiser.super.setTarget(tref, target); + } + + /** + * This method: + * + *
    + *
  • Adds the given clsRef to {@code ncr.getClassifierReferences()}, + *
  • Replaces the target of ncr ({@code ncr.getTarget()}) with + * {@code clsRef.getTarget()}. + *
+ * + * Using this method modifies the target attribute of ncr + * ({@code ncr.getTarget()}). Therefore, it should normally NOT be used + * along with {@link #setTarget(TypeReference, Classifier)}, as they will modify + * the said target attribute in conflicting ways.
+ *
+ * + * @see {@link #setTarget(TypeReference, Classifier)} + */ + public default boolean addClassifierReference(NamespaceClassifierReference ncr, ClassifierReference clsRef) { + if (clsRef != null) { + ncr.getClassifierReferences().add(clsRef); + return ncr.getClassifierReferences().contains(clsRef); + } + return true; + } + + @Override + public default boolean canSetTarget(TypeReference tref) { + return true; + } + + @Override + public default boolean canSetTargetTo(TypeReference tref, Classifier target) { + return ITypeReferenceInitialiser.super.canSetTargetTo(tref, target) + && target.getContainingContainerName() != null; + } + + public default boolean addClassifierReferences(NamespaceClassifierReference ncr, ClassifierReference[] clsRefs) { + return this.doMultipleModifications(ncr, clsRefs, this::addClassifierReference); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/types/IPrimitiveTypeInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/types/IPrimitiveTypeInitialiser.java new file mode 100644 index 0000000000..e649812315 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/types/IPrimitiveTypeInitialiser.java @@ -0,0 +1,46 @@ +package cipm.consistency.initialisers.jamopp.types; + +import org.emftext.language.java.classifiers.Classifier; +import org.emftext.language.java.types.PrimitiveType; +import org.emftext.language.java.types.TypeReference; + +import cipm.consistency.initialisers.jamopp.annotations.IAnnotableInitialiser; + +/** + * An interface meant to be implemented by initialisers, which are supposed to + * instantiate {@link PrimitiveType}.
+ *
+ * The target attribute of primitive types ({@code tref.getTarget()}) are (as + * their name imply) primitives and thus not adjustable. + * + * @author Alp Torac Genc + */ +public interface IPrimitiveTypeInitialiser extends IAnnotableInitialiser, ITypeInitialiser, ITypeReferenceInitialiser { + @Override + public PrimitiveType instantiate(); + + /** + * {@inheritDoc}
+ *
+ * In the case of {@link PrimitiveType}, this method does nothing, since the + * target attribute of primitive types ({@code tref.getTarget()}) are (as their + * name imply) primitives and thus not adjustable.
+ *
+ * This method is overridden to provide commentary, it introduces no changes to + * its super version in {@link ITypeReferenceInitialiser}. + */ + @Override + public default boolean setTarget(TypeReference tref, Classifier target) { + return ITypeReferenceInitialiser.super.setTarget(tref, target); + } + + /** + * {@inheritDoc} + * + * @see {@link IPrimitiveTypeInitialiser} + */ + @Override + public default boolean canSetTarget(TypeReference tref) { + return false; + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/types/IShortInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/types/IShortInitialiser.java new file mode 100644 index 0000000000..8cbe7f0650 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/types/IShortInitialiser.java @@ -0,0 +1,9 @@ +package cipm.consistency.initialisers.jamopp.types; + +import org.emftext.language.java.types.Short; + +public interface IShortInitialiser extends IPrimitiveTypeInitialiser { + @Override + public Short instantiate(); + +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/types/ITypeInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/types/ITypeInitialiser.java new file mode 100644 index 0000000000..84ae8d086f --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/types/ITypeInitialiser.java @@ -0,0 +1,10 @@ +package cipm.consistency.initialisers.jamopp.types; + +import org.emftext.language.java.types.Type; + +import cipm.consistency.initialisers.jamopp.commons.ICommentableInitialiser; + +public interface ITypeInitialiser extends ICommentableInitialiser { + @Override + public Type instantiate(); +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/types/ITypeReferenceInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/types/ITypeReferenceInitialiser.java new file mode 100644 index 0000000000..639c10ca38 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/types/ITypeReferenceInitialiser.java @@ -0,0 +1,76 @@ +package cipm.consistency.initialisers.jamopp.types; + +import org.emftext.language.java.classifiers.Classifier; +import org.emftext.language.java.types.TypeReference; + +import cipm.consistency.initialisers.jamopp.arrays.IArrayTypeableInitialiser; + +/** + * An interface meant to be implemented by initialisers, which are supposed to + * instantiate {@link TypeReference}.
+ *
+ * {@link TypeReference} itself does not have the target attribute, yet its + * implementors do. Its implementors' relations to that attribute vary. + * Therefore, whether the said attribute is modifiable in the individual + * implementors and the acceptable target types differ. Because of this, 2 + * methods {@link #canSetTarget(TypeReference)} and + * {@link #canSetTargetTo(TypeReference, Classifier)} are provided. + * + * @author Alp Torac Genc + */ +public interface ITypeReferenceInitialiser extends IArrayTypeableInitialiser { + @Override + public TypeReference instantiate(); + + /** + * Since {@link TypeReference} itself does not have the "target" attribute and + * its implementors' relations to that attribute vary, this method is + * implemented as a template.
+ *
+ * Therefore, what this method does can change immensely between different + * implementors. Check the concrete implementations within implementors for + * further details.
+ *
+ * Attempting to set null as target will return true, regardless of the concrete + * implementor, since there is no modification to perform. + * + * @see {@link #canSetTarget(TypeReference)} + * @see {@link #canSetTargetTo(TypeReference, Classifier)} + * @see {@link #setTargetAssertion(TypeReference, Classifier)} + */ + public default boolean setTarget(TypeReference tref, Classifier target) { + if (target != null && !this.canSetTargetTo(tref, target)) { + return false; + } + + tref.setTarget(target); + return this.setTargetAssertion(tref, target); + } + + /** + * @return Whether calling {@link #setTarget(TypeReference, Classifier)} with + * the given parameters results in the expected behaviour. + */ + public default boolean setTargetAssertion(TypeReference tref, Classifier target) { + var cTarget = tref.getTarget(); + return (target == null && cTarget == null) || cTarget.equals(target); + } + + /** + * @return Whether {@code tref.setTarget(...)} method can be used to modify + * tref. + */ + public boolean canSetTarget(TypeReference tref); + + /** + * Expects {@link #canSetTarget(TypeReference)} to return true for tref, since + * otherwise its target attribute cannot be changed in the first place. + * + * @return Whether {@code tref.setTarget(target)} method can be used in the + * context of the given target parameter. Returns false if + * {@code target == null}. + */ + public default boolean canSetTargetTo(TypeReference tref, Classifier target) { + return target != null && this.canSetTarget(tref); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/types/ITypedElementExtensionInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/types/ITypedElementExtensionInitialiser.java new file mode 100644 index 0000000000..8a698e8f41 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/types/ITypedElementExtensionInitialiser.java @@ -0,0 +1,23 @@ +package cipm.consistency.initialisers.jamopp.types; + +import org.emftext.language.java.types.TypeReference; +import org.emftext.language.java.types.TypedElementExtension; + +import cipm.consistency.initialisers.jamopp.commons.ICommentableInitialiser; + +public interface ITypedElementExtensionInitialiser extends ICommentableInitialiser { + @Override + public TypedElementExtension instantiate(); + + public default boolean addActualTarget(TypedElementExtension tee, TypeReference actualTarget) { + if (actualTarget != null) { + tee.getActualTargets().add(actualTarget); + return tee.getActualTargets().contains(actualTarget); + } + return true; + } + + public default boolean addActualTargets(TypedElementExtension tee, TypeReference[] actualTargets) { + return this.doMultipleModifications(tee, actualTargets, this::addActualTarget); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/types/ITypedElementInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/types/ITypedElementInitialiser.java new file mode 100644 index 0000000000..df52424487 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/types/ITypedElementInitialiser.java @@ -0,0 +1,16 @@ +package cipm.consistency.initialisers.jamopp.types; + +import org.emftext.language.java.types.TypeReference; +import org.emftext.language.java.types.TypedElement; + +import cipm.consistency.initialisers.jamopp.commons.ICommentableInitialiser; + +public interface ITypedElementInitialiser extends ICommentableInitialiser { + @Override + public TypedElement instantiate(); + + public default boolean setTypeReference(TypedElement te, TypeReference tRef) { + te.setTypeReference(tRef); + return (tRef == null && te.getTypeReference() == null) || te.getTypeReference().equals(tRef); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/types/IVoidInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/types/IVoidInitialiser.java new file mode 100644 index 0000000000..d5d1f3b3a3 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/types/IVoidInitialiser.java @@ -0,0 +1,9 @@ +package cipm.consistency.initialisers.jamopp.types; + +import org.emftext.language.java.types.Void; + +public interface IVoidInitialiser extends IPrimitiveTypeInitialiser { + @Override + public Void instantiate(); + +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/types/InferableTypeInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/types/InferableTypeInitialiser.java new file mode 100644 index 0000000000..bbb6a942d8 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/types/InferableTypeInitialiser.java @@ -0,0 +1,18 @@ +package cipm.consistency.initialisers.jamopp.types; + +import org.emftext.language.java.types.InferableType; +import org.emftext.language.java.types.TypesFactory; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class InferableTypeInitialiser extends AbstractInitialiserBase implements IInferableTypeInitialiser { + @Override + public IInferableTypeInitialiser newInitialiser() { + return new InferableTypeInitialiser(); + } + + @Override + public InferableType instantiate() { + return TypesFactory.eINSTANCE.createInferableType(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/types/IntInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/types/IntInitialiser.java new file mode 100644 index 0000000000..129df2ac9b --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/types/IntInitialiser.java @@ -0,0 +1,18 @@ +package cipm.consistency.initialisers.jamopp.types; + +import org.emftext.language.java.types.Int; +import org.emftext.language.java.types.TypesFactory; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class IntInitialiser extends AbstractInitialiserBase implements IIntInitialiser { + @Override + public IIntInitialiser newInitialiser() { + return new IntInitialiser(); + } + + @Override + public Int instantiate() { + return TypesFactory.eINSTANCE.createInt(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/types/LongInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/types/LongInitialiser.java new file mode 100644 index 0000000000..1725712870 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/types/LongInitialiser.java @@ -0,0 +1,18 @@ +package cipm.consistency.initialisers.jamopp.types; + +import org.emftext.language.java.types.Long; +import org.emftext.language.java.types.TypesFactory; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class LongInitialiser extends AbstractInitialiserBase implements ILongInitialiser { + @Override + public ILongInitialiser newInitialiser() { + return new LongInitialiser(); + } + + @Override + public Long instantiate() { + return TypesFactory.eINSTANCE.createLong(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/types/NamespaceClassifierReferenceInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/types/NamespaceClassifierReferenceInitialiser.java new file mode 100644 index 0000000000..0bfacb3583 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/types/NamespaceClassifierReferenceInitialiser.java @@ -0,0 +1,19 @@ +package cipm.consistency.initialisers.jamopp.types; + +import org.emftext.language.java.types.NamespaceClassifierReference; +import org.emftext.language.java.types.TypesFactory; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class NamespaceClassifierReferenceInitialiser extends AbstractInitialiserBase + implements INamespaceClassifierReferenceInitialiser { + @Override + public INamespaceClassifierReferenceInitialiser newInitialiser() { + return new NamespaceClassifierReferenceInitialiser(); + } + + @Override + public NamespaceClassifierReference instantiate() { + return TypesFactory.eINSTANCE.createNamespaceClassifierReference(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/types/ShortInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/types/ShortInitialiser.java new file mode 100644 index 0000000000..d877da4470 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/types/ShortInitialiser.java @@ -0,0 +1,18 @@ +package cipm.consistency.initialisers.jamopp.types; + +import org.emftext.language.java.types.Short; +import org.emftext.language.java.types.TypesFactory; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class ShortInitialiser extends AbstractInitialiserBase implements IShortInitialiser { + @Override + public IShortInitialiser newInitialiser() { + return new ShortInitialiser(); + } + + @Override + public Short instantiate() { + return TypesFactory.eINSTANCE.createShort(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/types/TypesInitialiserPackage.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/types/TypesInitialiserPackage.java new file mode 100644 index 0000000000..59c5691beb --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/types/TypesInitialiserPackage.java @@ -0,0 +1,27 @@ +package cipm.consistency.initialisers.jamopp.types; + +import java.util.Collection; + +import cipm.consistency.initialisers.IInitialiser; +import cipm.consistency.initialisers.IInitialiserPackage; + +public class TypesInitialiserPackage implements IInitialiserPackage { + @Override + public Collection getInitialiserInstances() { + return this.initCol(new IInitialiser[] { new BooleanInitialiser(), new ByteInitialiser(), new CharInitialiser(), + new ClassifierReferenceInitialiser(), new DoubleInitialiser(), new FloatInitialiser(), + new InferableTypeInitialiser(), new IntInitialiser(), new LongInitialiser(), + new NamespaceClassifierReferenceInitialiser(), new ShortInitialiser(), new VoidInitialiser(), }); + } + + @SuppressWarnings("unchecked") + @Override + public Collection> getInitialiserInterfaceTypes() { + return this.initCol(new Class[] { IBooleanInitialiser.class, IByteInitialiser.class, ICharInitialiser.class, + IClassifierReferenceInitialiser.class, IDoubleInitialiser.class, IFloatInitialiser.class, + IInferableTypeInitialiser.class, IIntInitialiser.class, ILongInitialiser.class, + INamespaceClassifierReferenceInitialiser.class, IPrimitiveTypeInitialiser.class, + IShortInitialiser.class, ITypedElementExtensionInitialiser.class, ITypedElementInitialiser.class, + ITypeInitialiser.class, ITypeReferenceInitialiser.class, IVoidInitialiser.class, }); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/types/VoidInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/types/VoidInitialiser.java new file mode 100644 index 0000000000..fd67f75983 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/types/VoidInitialiser.java @@ -0,0 +1,18 @@ +package cipm.consistency.initialisers.jamopp.types; + +import org.emftext.language.java.types.TypesFactory; +import org.emftext.language.java.types.Void; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class VoidInitialiser extends AbstractInitialiserBase implements IVoidInitialiser { + @Override + public IVoidInitialiser newInitialiser() { + return new VoidInitialiser(); + } + + @Override + public Void instantiate() { + return TypesFactory.eINSTANCE.createVoid(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/types/package-info.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/types/package-info.java new file mode 100644 index 0000000000..5ca4bd3583 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/types/package-info.java @@ -0,0 +1,5 @@ +/** + * Contains {@link IInitialiser} implementations for + * {@link org.emftext.language.java.types}. + */ +package cipm.consistency.initialisers.jamopp.types; \ No newline at end of file From 497971b6564739eed7f7434d96b5794c55e30cce Mon Sep 17 00:00:00 2001 From: AlpTorac Date: Fri, 25 Oct 2024 17:40:15 +0200 Subject: [PATCH 27/55] Implement initialiser package for org.emftext.language.java.variables --- .../AdditionalLocalVariableInitialiser.java | 20 +++++++++++++++ .../IAdditionalLocalVariableInitialiser.java | 13 ++++++++++ .../variables/ILocalVariableInitialiser.java | 25 +++++++++++++++++++ .../variables/IResourceInitialiser.java | 11 ++++++++ .../variables/IVariableInitialiser.java | 22 ++++++++++++++++ .../variables/LocalVariableInitialiser.java | 18 +++++++++++++ .../VariablesInitialiserPackage.java | 21 ++++++++++++++++ .../jamopp/variables/package-info.java | 5 ++++ 8 files changed, 135 insertions(+) create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/variables/AdditionalLocalVariableInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/variables/IAdditionalLocalVariableInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/variables/ILocalVariableInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/variables/IResourceInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/variables/IVariableInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/variables/LocalVariableInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/variables/VariablesInitialiserPackage.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/variables/package-info.java diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/variables/AdditionalLocalVariableInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/variables/AdditionalLocalVariableInitialiser.java new file mode 100644 index 0000000000..76a66bf48c --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/variables/AdditionalLocalVariableInitialiser.java @@ -0,0 +1,20 @@ +package cipm.consistency.initialisers.jamopp.variables; + +import org.emftext.language.java.variables.VariablesFactory; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +import org.emftext.language.java.variables.AdditionalLocalVariable; + +public class AdditionalLocalVariableInitialiser extends AbstractInitialiserBase + implements IAdditionalLocalVariableInitialiser { + @Override + public AdditionalLocalVariable instantiate() { + return VariablesFactory.eINSTANCE.createAdditionalLocalVariable(); + } + + @Override + public IAdditionalLocalVariableInitialiser newInitialiser() { + return new AdditionalLocalVariableInitialiser(); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/variables/IAdditionalLocalVariableInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/variables/IAdditionalLocalVariableInitialiser.java new file mode 100644 index 0000000000..13e776a491 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/variables/IAdditionalLocalVariableInitialiser.java @@ -0,0 +1,13 @@ +package cipm.consistency.initialisers.jamopp.variables; + +import org.emftext.language.java.variables.AdditionalLocalVariable; + +import cipm.consistency.initialisers.jamopp.instantiations.IInitializableInitialiser; +import cipm.consistency.initialisers.jamopp.references.IReferenceableElementInitialiser; +import cipm.consistency.initialisers.jamopp.types.ITypedElementInitialiser; + +public interface IAdditionalLocalVariableInitialiser + extends IInitializableInitialiser, IReferenceableElementInitialiser, ITypedElementInitialiser { + @Override + public AdditionalLocalVariable instantiate(); +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/variables/ILocalVariableInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/variables/ILocalVariableInitialiser.java new file mode 100644 index 0000000000..4120c4cd3e --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/variables/ILocalVariableInitialiser.java @@ -0,0 +1,25 @@ +package cipm.consistency.initialisers.jamopp.variables; + +import org.emftext.language.java.variables.AdditionalLocalVariable; +import org.emftext.language.java.variables.LocalVariable; + +import cipm.consistency.initialisers.jamopp.instantiations.IInitializableInitialiser; +import cipm.consistency.initialisers.jamopp.modifiers.IAnnotableAndModifiableInitialiser; + +public interface ILocalVariableInitialiser + extends IAnnotableAndModifiableInitialiser, IInitializableInitialiser, IVariableInitialiser { + @Override + public LocalVariable instantiate(); + + public default boolean addAdditionalLocalVariable(LocalVariable lv, AdditionalLocalVariable alv) { + if (alv != null) { + lv.getAdditionalLocalVariables().add(alv); + return lv.getAdditionalLocalVariables().contains(alv); + } + return true; + } + + public default boolean addAdditionalLocalVariables(LocalVariable lv, AdditionalLocalVariable[] alvs) { + return this.doMultipleModifications(lv, alvs, this::addAdditionalLocalVariable); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/variables/IResourceInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/variables/IResourceInitialiser.java new file mode 100644 index 0000000000..910b7b24f9 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/variables/IResourceInitialiser.java @@ -0,0 +1,11 @@ +package cipm.consistency.initialisers.jamopp.variables; + +import org.emftext.language.java.variables.Resource; + +import cipm.consistency.initialisers.jamopp.commons.ICommentableInitialiser; + +public interface IResourceInitialiser extends ICommentableInitialiser { + @Override + public Resource instantiate(); + +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/variables/IVariableInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/variables/IVariableInitialiser.java new file mode 100644 index 0000000000..6805d0b414 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/variables/IVariableInitialiser.java @@ -0,0 +1,22 @@ +package cipm.consistency.initialisers.jamopp.variables; + +import org.emftext.language.java.variables.Variable; + +import cipm.consistency.initialisers.jamopp.generics.ITypeArgumentableInitialiser; +import cipm.consistency.initialisers.jamopp.references.IReferenceableElementInitialiser; +import cipm.consistency.initialisers.jamopp.types.ITypedElementInitialiser; + +/** + * An interface meant for {@link IInitialiser} implementors that are supposed to + * create {@link Variable} instances.
+ *
+ * Note: "createMethodCall..." methods in {@link Variable} do not modify + * {@link Variable} instances. + * + * @author Alp Torac Genc + */ +public interface IVariableInitialiser + extends IReferenceableElementInitialiser, ITypeArgumentableInitialiser, ITypedElementInitialiser { + @Override + public Variable instantiate(); +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/variables/LocalVariableInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/variables/LocalVariableInitialiser.java new file mode 100644 index 0000000000..e878847187 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/variables/LocalVariableInitialiser.java @@ -0,0 +1,18 @@ +package cipm.consistency.initialisers.jamopp.variables; + +import org.emftext.language.java.variables.LocalVariable; +import org.emftext.language.java.variables.VariablesFactory; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +public class LocalVariableInitialiser extends AbstractInitialiserBase implements ILocalVariableInitialiser { + @Override + public LocalVariable instantiate() { + return VariablesFactory.eINSTANCE.createLocalVariable(); + } + + @Override + public ILocalVariableInitialiser newInitialiser() { + return new LocalVariableInitialiser(); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/variables/VariablesInitialiserPackage.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/variables/VariablesInitialiserPackage.java new file mode 100644 index 0000000000..0081e1b4d1 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/variables/VariablesInitialiserPackage.java @@ -0,0 +1,21 @@ +package cipm.consistency.initialisers.jamopp.variables; + +import java.util.Collection; + +import cipm.consistency.initialisers.IInitialiser; +import cipm.consistency.initialisers.IInitialiserPackage; + +public class VariablesInitialiserPackage implements IInitialiserPackage { + @Override + public Collection getInitialiserInstances() { + return this.initCol( + new IInitialiser[] { new AdditionalLocalVariableInitialiser(), new LocalVariableInitialiser(), }); + } + + @SuppressWarnings("unchecked") + @Override + public Collection> getInitialiserInterfaceTypes() { + return this.initCol(new Class[] { IAdditionalLocalVariableInitialiser.class, ILocalVariableInitialiser.class, + IResourceInitialiser.class, IVariableInitialiser.class, }); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/variables/package-info.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/variables/package-info.java new file mode 100644 index 0000000000..63280c4546 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/variables/package-info.java @@ -0,0 +1,5 @@ +/** + * Contains {@link IInitialiser} implementations for + * {@link org.emftext.language.java.variables}. + */ +package cipm.consistency.initialisers.jamopp.variables; \ No newline at end of file From 3fe125d5c414961f897cf95ec87d05fbc95bc1ef Mon Sep 17 00:00:00 2001 From: AlpTorac Date: Fri, 25 Oct 2024 17:41:59 +0200 Subject: [PATCH 28/55] Implement initialiser package for all JaMoPP-related initialisers --- .../jamopp/JaMoPPInitialiserPackage.java | 45 +++++++++++++++++++ 1 file changed, 45 insertions(+) create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/JaMoPPInitialiserPackage.java diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/JaMoPPInitialiserPackage.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/JaMoPPInitialiserPackage.java new file mode 100644 index 0000000000..13f201a97d --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/JaMoPPInitialiserPackage.java @@ -0,0 +1,45 @@ +package cipm.consistency.initialisers.jamopp; + +import java.util.Collection; + +import cipm.consistency.initialisers.IInitialiserPackage; +import cipm.consistency.initialisers.jamopp.annotations.AnnotationsInitialiserPackage; +import cipm.consistency.initialisers.jamopp.arrays.ArraysInitialiserPackage; +import cipm.consistency.initialisers.jamopp.classifiers.ClassifierInitialiserPackage; +import cipm.consistency.initialisers.jamopp.commons.CommonsInitialiserPackage; +import cipm.consistency.initialisers.jamopp.containers.ContainersInitialiserPackage; +import cipm.consistency.initialisers.jamopp.expressions.ExpressionsInitialiserPackage; +import cipm.consistency.initialisers.jamopp.generics.GenericsInitialiserPackage; +import cipm.consistency.initialisers.jamopp.imports.ImportsInitialiserPackage; +import cipm.consistency.initialisers.jamopp.instantiations.InstantiationsInitialiserPackage; +import cipm.consistency.initialisers.jamopp.literals.LiteralsInitialiserPackage; +import cipm.consistency.initialisers.jamopp.members.MembersInitialiserPackage; +import cipm.consistency.initialisers.jamopp.modifiers.ModifiersInitialiserPackage; +import cipm.consistency.initialisers.jamopp.modules.ModulesInitialiserPackage; +import cipm.consistency.initialisers.jamopp.operators.OperatorsInitialiserPackage; +import cipm.consistency.initialisers.jamopp.parameters.ParametersInitialiserPackage; +import cipm.consistency.initialisers.jamopp.references.ReferencesInitialiserPackage; +import cipm.consistency.initialisers.jamopp.statements.StatementsInitialiserPackage; +import cipm.consistency.initialisers.jamopp.types.TypesInitialiserPackage; +import cipm.consistency.initialisers.jamopp.variables.VariablesInitialiserPackage; + +/** + * The topmost implementor of {@link IInitialiserPackage} for EObject + * implementors used by JaMoPP. + * + * @author Alp Torac Genc + */ +public class JaMoPPInitialiserPackage implements IInitialiserPackage { + @Override + public Collection getSubPackages() { + return this.initCol(new IInitialiserPackage[] { new AnnotationsInitialiserPackage(), + new ArraysInitialiserPackage(), new ClassifierInitialiserPackage(), new CommonsInitialiserPackage(), + new ContainersInitialiserPackage(), new ExpressionsInitialiserPackage(), + new GenericsInitialiserPackage(), new ImportsInitialiserPackage(), + new InstantiationsInitialiserPackage(), new LiteralsInitialiserPackage(), + new MembersInitialiserPackage(), new ModifiersInitialiserPackage(), new ModulesInitialiserPackage(), + new OperatorsInitialiserPackage(), new ParametersInitialiserPackage(), + new ReferencesInitialiserPackage(), new StatementsInitialiserPackage(), new TypesInitialiserPackage(), + new VariablesInitialiserPackage() }); + } +} From 850b4e905c7589d208b0bc810729c7553d27b757 Mon Sep 17 00:00:00 2001 From: AlpTorac Date: Fri, 25 Oct 2024 17:45:54 +0200 Subject: [PATCH 29/55] Add adaptation strategies for some initialisers These strategies can be used to adapt the initialisers, so that they can successfully initialise the objects they create within tests (to be implemented in another plug-in in the future). --- .../BlockContainerInitialiserAdapter.java | 64 +++++++++++++ .../ClassMethodInitialiserAdapter.java | 84 +++++++++++++++++ .../ConcreteClassifierInitialiserAdapter.java | 63 +++++++++++++ .../MemberInitialiserAdapter.java | 62 +++++++++++++ .../NamedElementInitialiserAdapter.java | 46 ++++++++++ .../NewConstructorCallInitialiserAdapter.java | 90 +++++++++++++++++++ .../jamopp/initadapters/package-info.java | 10 +++ 7 files changed, 419 insertions(+) create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/initadapters/BlockContainerInitialiserAdapter.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/initadapters/ClassMethodInitialiserAdapter.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/initadapters/ConcreteClassifierInitialiserAdapter.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/initadapters/MemberInitialiserAdapter.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/initadapters/NamedElementInitialiserAdapter.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/initadapters/NewConstructorCallInitialiserAdapter.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/initadapters/package-info.java diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/initadapters/BlockContainerInitialiserAdapter.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/initadapters/BlockContainerInitialiserAdapter.java new file mode 100644 index 0000000000..238cac8386 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/initadapters/BlockContainerInitialiserAdapter.java @@ -0,0 +1,64 @@ +package cipm.consistency.initialisers.jamopp.initadapters; + +import org.emftext.language.java.statements.BlockContainer; + +import cipm.consistency.initialisers.IInitialiser; +import cipm.consistency.initialisers.IInitialiserAdapterStrategy; +import cipm.consistency.initialisers.jamopp.statements.IBlockContainerInitialiser; +import cipm.consistency.initialisers.jamopp.statements.IBlockInitialiser; + +/** + * An {@link IInitialiserAdapterStrategy} implementation that can be used with + * {@link IInitialiserBase} implementors that instantiate + * {@link BlockContainer}.
+ *
+ * Adds a {@link Block} to the created {@link BlockContainer}. If the + * {@link BlockContainer} instance already has a {@link Block}, does not modify + * it. This way, similarity checking should not cause exceptions while comparing + * 2 {@link BlockContainer} instances, because of them not having a + * {@link Block}. + * + * @author Alp Torac Genc + */ +public class BlockContainerInitialiserAdapter implements IInitialiserAdapterStrategy { + /** + * The initialiser that creates {@link Block}s to realise the functionality of + * this instance. + */ + private IBlockInitialiser bInit; + + /** + * Constructs an instance with the given {@link IBlockInitialiser}. + */ + public BlockContainerInitialiserAdapter(IBlockInitialiser bInit) { + this.bInit = bInit; + } + + /** + * @return The initialiser contained in this instance, which is responsible for + * creating {@link Block}s. + */ + public IBlockInitialiser getBInit() { + return this.bInit; + } + + @Override + public boolean apply(IInitialiser init, Object obj) { + var castedInit = (IBlockContainerInitialiser) init; + var castedO = (BlockContainer) obj; + + if (castedO.getBlock() == null) { + var bInit = this.getBInit(); + + var block = bInit.instantiate(); + return bInit.initialise(block) && castedInit.setBlock(castedO, block); + } + + return true; + } + + @Override + public IInitialiserAdapterStrategy newStrategy() { + return new BlockContainerInitialiserAdapter((IBlockInitialiser) this.getBInit().newInitialiser()); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/initadapters/ClassMethodInitialiserAdapter.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/initadapters/ClassMethodInitialiserAdapter.java new file mode 100644 index 0000000000..8cfe3f38b0 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/initadapters/ClassMethodInitialiserAdapter.java @@ -0,0 +1,84 @@ +package cipm.consistency.initialisers.jamopp.initadapters; + +import org.emftext.language.java.members.ClassMethod; + +import cipm.consistency.initialisers.IInitialiser; +import cipm.consistency.initialisers.IInitialiserAdapterStrategy; +import cipm.consistency.initialisers.jamopp.members.IClassMethodInitialiser; +import cipm.consistency.initialisers.jamopp.statements.IBlockInitialiser; + +/** + * An {@link IInitialiserAdapterStrategy} implementation that can be used with + * {@link IInitialiserBase} implementors that instantiate {@link ClassMethod}. + *
+ *
+ * Adds a {@link Block} instance to the {@link ClassMethod} via + * {@code classMethod.setStatement(...)}, if its statement accessed via + * {@code classMethod.getStatement()} is not a {@link Block} (in that case + * {@code classMethod.getBlock()} will return null). If the {@link ClassMethod} + * has its {@link Statement} st set, st will be added to the added block + * instance.
+ *
+ * Due to inconsistencies regarding {@link ClassMethod}, it provides 2 methods + * for adding {@link Statement} instances to it. Since adding multiple + * statements is only possible via {@code classMethod.getStatement().add(...)}, + * which only works if classMethod has a block as its statement, this adaptation + * is necessary. Otherwise, one may only add a single statement to + * {@link ClassMethod} via {@code classMethod.setStatement(...)}.
+ *
+ * Note that the said method will REPLACE the former statement when used. + * + * + * @author Alp Torac Genc + * + */ +public class ClassMethodInitialiserAdapter implements IInitialiserAdapterStrategy { + /** + * The initialiser that creates {@link Block}s to realise the functionality of + * this instance. + */ + private IBlockInitialiser bInit; + + /** + * Constructs an instance with the given {@link IBlockInitialiser}. + */ + public ClassMethodInitialiserAdapter(IBlockInitialiser bInit) { + this.bInit = bInit; + } + + /** + * @return The initialiser contained in this instance, which is responsible for + * creating {@link Block}s. + */ + public IBlockInitialiser getBInit() { + return this.bInit; + } + + @Override + public boolean apply(IInitialiser init, Object obj) { + var castedInit = (IClassMethodInitialiser) init; + var castedO = (ClassMethod) obj; + + if (castedO.getBlock() == null) { + var formerSt = castedO.getStatement(); + + var bInit = this.getBInit(); + var block = bInit.instantiate(); + + var res = bInit.initialise(block) && castedInit.setStatement(castedO, block); + + if (formerSt != null) { + res = res && castedInit.addStatement(castedO, formerSt); + } + + return res; + } + + return true; + } + + @Override + public IInitialiserAdapterStrategy newStrategy() { + return new ClassMethodInitialiserAdapter((IBlockInitialiser) this.getBInit().newInitialiser()); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/initadapters/ConcreteClassifierInitialiserAdapter.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/initadapters/ConcreteClassifierInitialiserAdapter.java new file mode 100644 index 0000000000..63c157e3cc --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/initadapters/ConcreteClassifierInitialiserAdapter.java @@ -0,0 +1,63 @@ +package cipm.consistency.initialisers.jamopp.initadapters; + +import org.emftext.language.java.classifiers.ConcreteClassifier; +import org.emftext.language.java.containers.CompilationUnit; + +import cipm.consistency.initialisers.IInitialiser; +import cipm.consistency.initialisers.IInitialiserAdapterStrategy; +import cipm.consistency.initialisers.jamopp.containers.ICompilationUnitInitialiser; + +/** + * An {@link IInitialiserAdapterStrategy} implementation that can be used with + * {@link IInitialiserBase} implementors that instantiate + * {@link ConcreteClassifier}.
+ *
+ * Adds the {@link ConcreteClassifier} instance to a {@link CompilationUnit}. + * Does not modify the {@link ConcreteClassifier} instance, if it already is + * contained in a {@link CompilationUnit}. This way, similarity checking 2 + * {@link ConcreteClassifier} instances does not throw exceptions, due to them + * not having a container. + * + * @author Alp Torac Genc + */ +public class ConcreteClassifierInitialiserAdapter implements IInitialiserAdapterStrategy { + /** + * The initialiser responsible for creating {@link CompilationUnit}s to fulfil + * this instance's functionality. + */ + private ICompilationUnitInitialiser cuInit; + + /** + * Constructs an instance with the given {@link ICompilationUnitInitialiser}. + */ + public ConcreteClassifierInitialiserAdapter(ICompilationUnitInitialiser cuInit) { + this.cuInit = cuInit; + } + + /** + * @return The initialiser responsible for creating {@link CompilationUnit}s. + */ + public ICompilationUnitInitialiser getCUInit() { + return this.cuInit; + } + + @Override + public boolean apply(IInitialiser init, Object obj) { + var castedO = (ConcreteClassifier) obj; + + if (castedO.getContainingCompilationUnit() == null) { + var cuInit = this.getCUInit(); + + CompilationUnit unit = cuInit.instantiate(); + return cuInit.initialise(unit) && cuInit.addClassifier(unit, castedO); + } + + return true; + } + + @Override + public ConcreteClassifierInitialiserAdapter newStrategy() { + return new ConcreteClassifierInitialiserAdapter( + (ICompilationUnitInitialiser) this.getCUInit().newInitialiser()); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/initadapters/MemberInitialiserAdapter.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/initadapters/MemberInitialiserAdapter.java new file mode 100644 index 0000000000..c3a6b9b2ed --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/initadapters/MemberInitialiserAdapter.java @@ -0,0 +1,62 @@ +package cipm.consistency.initialisers.jamopp.initadapters; + +import org.emftext.language.java.members.Member; +import org.emftext.language.java.members.MemberContainer; + +import cipm.consistency.initialisers.IInitialiser; +import cipm.consistency.initialisers.IInitialiserAdapterStrategy; +import cipm.consistency.initialisers.jamopp.members.IMemberContainerInitialiser; + +/** + * An {@link IInitialiserAdapterStrategy} implementation that can be used with + * {@link IInitialiserBase} implementors that instantiate {@link Member}.
+ *
+ * Adds the created {@link Member} to a {@link MemberContainer}. Does not modify + * the {@link Member} instance, if it is already in a {@link MemberContainer}. + * This way, similarity checking 2 {@link Member} instances does not throw an + * exception, due to them not being contained by a {@link MemberContainer}. + * + * @author Alp Torac Genc + * + */ +public class MemberInitialiserAdapter implements IInitialiserAdapterStrategy { + /** + * The initialiser responsible for creating {@link MemberContainer}s to fulfil + * this instance's functionality. + */ + private IMemberContainerInitialiser mcInit; + + /** + * Constructs an instance with the given {@link IMemberContainerInitialiser}. + */ + public MemberInitialiserAdapter(IMemberContainerInitialiser mcInit) { + this.mcInit = mcInit; + } + + /** + * @return The initialiser in this instance that creates + * {@link MemberContainer}s. + */ + public IMemberContainerInitialiser getMCInit() { + return this.mcInit; + } + + @Override + public boolean apply(IInitialiser init, Object obj) { + var castedO = (Member) obj; + + if (castedO.eContainer() == null) { + var mcInit = this.getMCInit(); + + MemberContainer mc = mcInit.instantiate(); + return mcInit.initialise(mc) && mcInit.addMember(mc, castedO); + } + + return true; + } + + @Override + public MemberInitialiserAdapter newStrategy() { + return new MemberInitialiserAdapter((IMemberContainerInitialiser) this.getMCInit().newInitialiser()); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/initadapters/NamedElementInitialiserAdapter.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/initadapters/NamedElementInitialiserAdapter.java new file mode 100644 index 0000000000..5402f65d99 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/initadapters/NamedElementInitialiserAdapter.java @@ -0,0 +1,46 @@ +package cipm.consistency.initialisers.jamopp.initadapters; + +import org.emftext.language.java.commons.NamedElement; + +import cipm.consistency.initialisers.IInitialiser; +import cipm.consistency.initialisers.IInitialiserAdapterStrategy; +import cipm.consistency.initialisers.jamopp.commons.INamedElementInitialiser; + +/** + * An {@link IInitialiserAdapterStrategy} implementation that can be used with + * {@link IInitialiserBase} implementors that instantiate {@link NamedElement}. + *
+ *
+ * Sets the name of the created {@link NamedElement} to a default name, if it + * has no name. This way, similarity checking 2 {@link NamedElement} instances + * does not throw exceptions, due to them not having a name. + * + * @author Alp Torac Genc + * + */ +public class NamedElementInitialiserAdapter implements IInitialiserAdapterStrategy { + /** + * @return The default name, to which the name of the created + * {@link NamedElement} instances will be set. + */ + public String getDefaultName() { + return ""; + } + + @Override + public boolean apply(IInitialiser init, Object obj) { + var castedInit = (INamedElementInitialiser) init; + var castedO = (NamedElement) obj; + + if (castedInit.canSetName(castedO) && castedO.getName() == null) { + return castedInit.setName(castedO, this.getDefaultName()); + } + + return true; + } + + @Override + public IInitialiserAdapterStrategy newStrategy() { + return new NamedElementInitialiserAdapter(); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/initadapters/NewConstructorCallInitialiserAdapter.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/initadapters/NewConstructorCallInitialiserAdapter.java new file mode 100644 index 0000000000..5756df414f --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/initadapters/NewConstructorCallInitialiserAdapter.java @@ -0,0 +1,90 @@ +package cipm.consistency.initialisers.jamopp.initadapters; + +import org.emftext.language.java.instantiations.NewConstructorCall; + +import cipm.consistency.initialisers.IInitialiser; +import cipm.consistency.initialisers.IInitialiserAdapterStrategy; +import cipm.consistency.initialisers.jamopp.classifiers.IClassifierInitialiser; +import cipm.consistency.initialisers.jamopp.instantiations.INewConstructorCallInitialiser; +import cipm.consistency.initialisers.jamopp.types.ITypeReferenceInitialiser; + +/** + * An {@link IInitialiserAdapterStrategy} implementation that can be used with + * {@link IInitialiserBase} implementors that instantiate + * {@link NewConstructorCall}.
+ *
+ * Adds a {@link TypeReference} to the created {@link NewConstructorCall} + * ncc. The steps it takes are: + *
    + *
  1. Checks whether ncc has a {@link TypeReference}. If yes, stops. + * Otherwise continues. + *
  2. Creates a {@link Classifier} instance cls + *
  3. Creates a {@link TypeReference} instance tref + *
  4. Sets tref's target to cls + *
  5. Sets ncc's type reference to tref + *
+ * Does not modify the created {@link NewConstructorCall}, if it already has a + * {@link TypeReference}. + * + * @author Alp Torac Genc + * + */ +public class NewConstructorCallInitialiserAdapter implements IInitialiserAdapterStrategy { + + /** + * The initialiser responsible for creating {@link TypeReference} to fulfil this + * instance's functionality. + */ + private ITypeReferenceInitialiser tRefInit; + /** + * The initialiser responsible for creating {@link Classifier} to fulfil this + * instance's functionality. + */ + private IClassifierInitialiser clsInit; + + /** + * Constructs an instance with the given parameters. + */ + public NewConstructorCallInitialiserAdapter(ITypeReferenceInitialiser tRefInit, IClassifierInitialiser clsInit) { + this.tRefInit = tRefInit; + this.clsInit = clsInit; + } + + /** + * @return The initialiser responsible for creating {@link TypeReference}. + */ + public ITypeReferenceInitialiser gettRefInit() { + return tRefInit; + } + + /** + * @return The initialiser responsible for creating {@link Classifier}. + */ + public IClassifierInitialiser getClsInit() { + return clsInit; + } + + @Override + public boolean apply(IInitialiser init, Object obj) { + var castedInit = (INewConstructorCallInitialiser) init; + var castedO = (NewConstructorCall) obj; + + if (castedO.getTypeReference() == null) { + var cls = this.getClsInit().instantiate(); + + var tref = this.gettRefInit().instantiate(); + + return this.getClsInit().initialise(cls) && this.gettRefInit().initialise(tref) + && this.gettRefInit().setTarget(tref, cls) && castedInit.setTypeReference(castedO, tref) + && castedO.getTypeReference().equals(tref); + } + + return true; + } + + @Override + public IInitialiserAdapterStrategy newStrategy() { + return new NewConstructorCallInitialiserAdapter((ITypeReferenceInitialiser) this.gettRefInit().newInitialiser(), + (IClassifierInitialiser) this.getClsInit().newInitialiser()); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/initadapters/package-info.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/initadapters/package-info.java new file mode 100644 index 0000000000..a9f4007062 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/initadapters/package-info.java @@ -0,0 +1,10 @@ +/** + * Contains classes that help adapt initialisers in ways that lets them + * instantiate valid objects without additional method calls. This is + * particularly useful for parameterized tests, as there may be initialisers + * extending mutual interfaces/classes, which may need to perform additional + * modifications of the objects they instantiate. If this is the case, such + * initialisers can be adapted to automatically perform those modifications, + * without large if or instanceof blocks in tests. + */ +package cipm.consistency.initialisers.jamopp.initadapters; \ No newline at end of file From 79533d862c571c6053b090561cdfeb716022b1fe Mon Sep 17 00:00:00 2001 From: AlpTorac Date: Fri, 25 Oct 2024 17:46:45 +0200 Subject: [PATCH 30/55] Add package commentary --- .../cipm/consistency/initialisers/jamopp/package-info.java | 7 +++++++ 1 file changed, 7 insertions(+) create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/package-info.java diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/package-info.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/package-info.java new file mode 100644 index 0000000000..d1ece94497 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/package-info.java @@ -0,0 +1,7 @@ +/** + * Contains {@link IInitialiser} implementations for Java-related + * {@link EObject} implementors used by JaMoPP. Sub-packages contain concrete + * implementations and interfaces of concrete initialisers for their + * corresponding {@link EObject} implementor. + */ +package cipm.consistency.initialisers.jamopp; \ No newline at end of file From 2f8a7e7a018b239ccf10750fec5d7792cab0271b Mon Sep 17 00:00:00 2001 From: AlpTorac Date: Fri, 25 Oct 2024 17:50:08 +0200 Subject: [PATCH 31/55] Add an interface for utility tests Implemented to extract some mutual method implementations. Provides default methods that can be used by tests, which check whether necessary initialisers are present and can be accessed. --- .../initialisers/IInitialiserUtilityTest.java | 107 ++++++++++++++++++ 1 file changed, 107 insertions(+) create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/IInitialiserUtilityTest.java diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/IInitialiserUtilityTest.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/IInitialiserUtilityTest.java new file mode 100644 index 0000000000..49f972ef63 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/IInitialiserUtilityTest.java @@ -0,0 +1,107 @@ +package cipm.consistency.initialisers; + +import java.io.File; +import java.util.ArrayList; +import java.util.Collection; +import java.util.List; +import java.util.function.Function; +import java.util.stream.Stream; + +/** + * An interface that contains various methods that can be used in utility tests, + * which ensure that all initialisers and/or tests associated with them are + * present. Not implemented as an abstract class, since utility tests are likely + * to have to inherit from an abstract test class anyway. + * + * @author Alp Torac Genc + */ +public interface IInitialiserUtilityTest { + + /** + * @return A list of all files under the root directory. + */ + public Collection getAllFiles(); + + /** + * @return The {@link IInitialiserPackage} that will be used within the utility + * test. + */ + public IInitialiserPackage getUsedInitialiserPackage(); + + /** + * @return A list of all files under the given path and its sub-directories. + */ + public default Collection getAllFiles(File currentPath) { + var result = new ArrayList(); + + if (currentPath.isFile()) { + result.add(currentPath); + } else { + var files = currentPath.listFiles(); + if (files != null) { + for (var f : files) { + result.addAll(this.getAllFiles(f)); + } + } + } + + return result; + } + + /** + * @return Whether the given file's name (without extension) is equal to the + * given fileName. + */ + public default boolean fileNameEquals(File file, String fileName) { + return file != null && file.getName().split("\\.")[0].equals(fileName); + } + + /** + * @return A String representing the given stream. The provided toStringFunc + * will be used to transform stream elements into Strings. + */ + public default String streamToString(Stream stream, Function toStringFunc) { + return stream.map((e) -> toStringFunc.apply(e)).reduce("", (s1, s2) -> s1 + ", " + s2).substring(2); + } + + /** + * Opens a stream on the given list and delegates to + * {@link #clsStreamToString(Stream)}. + */ + public default String clsListToString(List> list) { + return this.clsStreamToString(list.stream()); + } + + /** + * A variant of {@link #streamToString(Stream, Function)} for Class streams. + * + * Maps stream elements (classes) to String by returning their simple name. + */ + public default String clsStreamToString(Stream> list) { + return this.streamToString(list, (cls) -> cls.getSimpleName()); + } + + /** + * @return An instance of all initialisers accessible from + * {@link #getUsedInitialiserPackage()}. + */ + public default Collection getAllInitialiserInstances() { + return this.getUsedInitialiserPackage().getAllInitialiserInstances(); + } + + /** + * @return Types of all initialisers accessible from + * {@link #getUsedInitialiserPackage()}. + */ + public default Collection> getAllInitialiserInterfaceTypes() { + return this.getUsedInitialiserPackage().getAllInitialiserInterfaceTypes(); + } + + /** + * @return The type of the initialiser meant to instantiate objClass, which is + * accessible from {@link #getUsedInitialiserPackage()}.. + */ + public default Class getInitialiserInterfaceFor(Class objClass) { + return this.getUsedInitialiserPackage().getInitialiserInterfaceTypeFor(objClass); + } +} \ No newline at end of file From af40e6781e810796c478c6e70c8d0ce600c2477e Mon Sep 17 00:00:00 2001 From: AlpTorac Date: Fri, 25 Oct 2024 18:02:49 +0200 Subject: [PATCH 32/55] Add a utility class Contains information about the naming convention used while naming initialisers --- .../eobject/InitialiserNameHelper.java | 41 +++++++++++++++++++ 1 file changed, 41 insertions(+) create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/eobject/InitialiserNameHelper.java diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/eobject/InitialiserNameHelper.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/eobject/InitialiserNameHelper.java new file mode 100644 index 0000000000..4f211dbc8f --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/eobject/InitialiserNameHelper.java @@ -0,0 +1,41 @@ +package cipm.consistency.initialisers.eobject; + +/** + * A utility class that contains information about the naming convention used + * within the sub-packages of this package.
+ *
+ * This class is intended to be used from tests, which ensure that all necessary + * initialisers are implemented and are accessible. + * + * @author Alp Torac Genc + */ +public class InitialiserNameHelper { + + /** + * @return The name of the concrete initialiser corresponding to cls. + */ + public String getConcreteInitialiserName(Class cls) { + return cls.getSimpleName() + this.getInitialiserSuffix(); + } + + /** + * @return The name of the initialiser interface corresponding to cls. + */ + public String getInitialiserInterfaceName(Class cls) { + return getInitialiserInterfacePrefix() + cls.getSimpleName() + this.getInitialiserSuffix(); + } + + /** + * The prefix used in initialiser interfaces. + */ + public String getInitialiserInterfacePrefix() { + return "I"; + } + + /** + * The suffix used in initialisers. + */ + public String getInitialiserSuffix() { + return "Initialiser"; + } +} From ad2936a6fd62ca6a50e8640afdd316e39f6a24ff Mon Sep 17 00:00:00 2001 From: AlpTorac Date: Fri, 25 Oct 2024 18:04:01 +0200 Subject: [PATCH 33/55] Add an interface for utility tests that focus on EObject --- .../eobject/IEObjectUtilityTest.java | 33 +++++++++++++++++++ 1 file changed, 33 insertions(+) create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/eobject/IEObjectUtilityTest.java diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/eobject/IEObjectUtilityTest.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/eobject/IEObjectUtilityTest.java new file mode 100644 index 0000000000..0d92727943 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/eobject/IEObjectUtilityTest.java @@ -0,0 +1,33 @@ +package cipm.consistency.initialisers.eobject; + +import cipm.consistency.initialisers.IInitialiserUtilityTest; + +/** + * An interface that extends {@link IInitialiserUtilityTest} with further + * utility methods, focusing on EObject. + * + * @author Alp Torac Genc + */ +public interface IEObjectUtilityTest extends IInitialiserUtilityTest { + /** + * @return The {@link InitialiserNameHelper} instance that will be used in the + * other methods. + */ + public default InitialiserNameHelper getInitialiserNameHelper() { + return new InitialiserNameHelper(); + } + + /** + * {@link InitialiserNameHelper#getInitialiserInterfaceName(Class)} + */ + public default String getInitialiserInterfaceName(Class cls) { + return this.getInitialiserNameHelper().getInitialiserInterfaceName(cls); + } + + /** + * {@link InitialiserNameHelper#getConcreteInitialiserName(Class)} + */ + public default String getConcreteInitialiserName(Class ifc) { + return this.getInitialiserNameHelper().getConcreteInitialiserName(ifc); + } +} \ No newline at end of file From b10cab2fefb750ef9326fe09223d4ddb12969f1e Mon Sep 17 00:00:00 2001 From: AlpTorac Date: Fri, 25 Oct 2024 18:07:47 +0200 Subject: [PATCH 34/55] Add a utility class Contains some information about the naming convention used in JaMoPP Provides methods to access EObject implementations of Java-related elements in JaMoPP. Includes methods that can be used to retrieve initialisers corresponding to those JaMoPP-elements by using the name of the objects they are supposed to create. --- .../initialisers/jamopp/JaMoPPHelper.java | 132 ++++++++++++++++++ 1 file changed, 132 insertions(+) create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/JaMoPPHelper.java diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/JaMoPPHelper.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/JaMoPPHelper.java new file mode 100644 index 0000000000..b13a715e8a --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/JaMoPPHelper.java @@ -0,0 +1,132 @@ +package cipm.consistency.initialisers.jamopp; + +import java.util.Collection; +import java.util.HashSet; +import java.util.List; +import java.util.Set; + +import org.eclipse.emf.ecore.EClass; +import org.eclipse.emf.ecore.EPackage; +import org.emftext.language.java.JavaPackage; +import org.emftext.language.java.commons.Commentable; + +/** + * A utility class that provides information about EObjects used by JaMoPP, as + * well as methods to access their types. There are further methods, which map + * their types to the initialisers implemented in sub-packages.
+ *
+ * This class is intended to be used in tests, which ensure that all necessary + * initialisers are implemented and can be accessed. + * + * @author Alp Torac Genc + */ +public class JaMoPPHelper { + + /** + * The suffix used in the concrete implementation of EObject classes in JaMoPP. + */ + public String getImplSuffix() { + return "Impl"; + } + + /** + * @return Types of concrete implementations and interfaces of all Java-Model + * elements. + */ + public Set> getAllPossibleTypes() { + return this.getAllPossibleTypes(JavaPackage.eINSTANCE.getESubpackages()); + } + + /** + * Recursively discovers sub-packages of cPac (including cPac) for + * {@link EClassifier}s contained within, aggregates the types represented by + * the EClassifiers as a Set and returns the Set. + * + * @param cPac The package, which is the start point of the discovery. + * @return All types represented by EClassifiers contained in cPac and its + * sub-packages. Includes types of interfaces as well as concrete + * implementation classes. + */ + public Set> getAllPossibleTypes(EPackage cPac) { + var clss = cPac.getEClassifiers(); + var subPacs = cPac.getESubpackages(); + + var foundClss = new HashSet>(); + + if (clss != null) { + for (var cls : clss) { + foundClss.add(cls.getInstanceClass()); + + /* + * Although cls is technically of type EClassifier, it also implements EClass + */ + if (cls instanceof EClass) { + var castedCls = (EClass) cls; + + /* + * Add the concrete implementation class, if cls represents a concrete class + */ + if (!castedCls.isAbstract()) { + foundClss.add(cPac.getEFactoryInstance().create(castedCls).getClass()); + } + } + } + } + + if (subPacs != null) { + foundClss.addAll(this.getAllPossibleTypes(subPacs)); + } + + return foundClss; + } + + /** + * @return All types represented by {@link EClassifiers} contained in pacs and + * their sub-packages. Includes types of interfaces as well as concrete + * implementation classes. + * @see {@link #getAllPossibleTypes(EPackage)}} + */ + public Set> getAllPossibleTypes(Collection pacs) { + var foundClss = new HashSet>(); + + for (var pac : pacs) { + foundClss.addAll(this.getAllPossibleTypes(pac)); + } + + return foundClss; + } + + /** + * Used to determine which EObject implementors should have an initialiser.
+ *
+ * Here, such implementors (initialiser candidates) implement + * {@link Commentable} and their names do not end with {@link #implSuffix}. + * + * @return The classes from {@link #getAllPossibleTypes()}, which should have a + * corresponding initialiser interface. + */ + public Collection> getAllInitialiserCandidates() { + var fullHierarchy = getAllPossibleTypes(); + + var intfcs = fullHierarchy.stream().filter((c) -> Commentable.class.isAssignableFrom(c)) + .filter((c) -> !c.getSimpleName().endsWith(this.getImplSuffix())).toArray(Class[]::new); + + return List.of(intfcs); + } + + /** + * @return The EObject types from {@link #getAllPossibleTypes()}, which should + * have a corresponding concrete initialiser that can instantiate the + * said type. + */ + public Collection> getAllConcreteInitialiserCandidates() { + var fullHierarchy = getAllPossibleTypes(); + + var intfcs = fullHierarchy.stream().filter((c) -> Commentable.class.isAssignableFrom(c)) + .filter((c) -> fullHierarchy.stream() + .anyMatch((c2) -> c2.getSimpleName().equals(c.getSimpleName() + this.getImplSuffix()))) + .toArray(Class[]::new); + + return List.of(intfcs); + } +} From 780d1bdeea7ef304a25b59f5a92250a745fe5292 Mon Sep 17 00:00:00 2001 From: AlpTorac Date: Fri, 25 Oct 2024 18:08:20 +0200 Subject: [PATCH 35/55] Add an interface for utility tests that focus on JaMoPP --- .../jamopp/IJaMoPPUtilityTest.java | 42 +++++++++++++++++++ 1 file changed, 42 insertions(+) create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/IJaMoPPUtilityTest.java diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/IJaMoPPUtilityTest.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/IJaMoPPUtilityTest.java new file mode 100644 index 0000000000..534bdcc371 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/IJaMoPPUtilityTest.java @@ -0,0 +1,42 @@ +package cipm.consistency.initialisers.jamopp; + +import java.util.Collection; +import java.util.Set; + +import cipm.consistency.initialisers.eobject.IEObjectUtilityTest; + +/** + * An interface that extends {@link IEObjectUtilityTest} with further utility + * methods, focusing on EObject types used within JaMoPP. + * + * @author Alp Torac Genc + */ +public interface IJaMoPPUtilityTest extends IEObjectUtilityTest { + /** + * @return The {@link JaMoPPHelper} instance that will be used in other methods. + */ + public default JaMoPPHelper getJaMoPPHelper() { + return new JaMoPPHelper(); + } + + /** + * {@link JaMoPPHelper#getAllPossibleTypes()} + */ + public default Set> getAllPossibleJaMoPPEObjectTypes() { + return this.getJaMoPPHelper().getAllPossibleTypes(); + } + + /** + * {@link JaMoPPHelper#getAllInitialiserCandidates()} + */ + public default Collection> getAllInitialiserCandidates() { + return this.getJaMoPPHelper().getAllInitialiserCandidates(); + } + + /** + * {@link JaMoPPHelper#getAllConcreteInitialiserCandidates()} + */ + public default Collection> getAllConcreteInitialiserCandidates() { + return this.getJaMoPPHelper().getAllConcreteInitialiserCandidates(); + } +} From 86c73d0350f58accefd130d86976aaf4e5f73957 Mon Sep 17 00:00:00 2001 From: AlpTorac Date: Fri, 25 Oct 2024 18:12:32 +0200 Subject: [PATCH 36/55] Add utility tests These tests can be run to ensure that there are initialisers for each Java-related element in JaMoPP. Note: Relative paths are used within tests to access initialiser files. Therefore, if the position of cipm.consistency.initialisers.jamopp.utiltests changes relatively to the initialiser files, the said path will have to be changed for tests to work. --- .../jamopp/utiltests/UtilityTests.java | 178 ++++++++++++++++++ 1 file changed, 178 insertions(+) create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/utiltests/UtilityTests.java diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/utiltests/UtilityTests.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/utiltests/UtilityTests.java new file mode 100644 index 0000000000..2b0de86add --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/utiltests/UtilityTests.java @@ -0,0 +1,178 @@ +package cipm.consistency.initialisers.jamopp.utiltests; + +import java.io.File; +import java.nio.file.Paths; +import java.util.Collection; +import java.util.List; + +import org.apache.log4j.ConsoleAppender; +import org.apache.log4j.Level; +import org.apache.log4j.Logger; +import org.apache.log4j.PatternLayout; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +import cipm.consistency.initialisers.IInitialiserPackage; +import cipm.consistency.initialisers.jamopp.IJaMoPPUtilityTest; +import cipm.consistency.initialisers.jamopp.JaMoPPInitialiserPackage; + +/** + * A test class, whose tests can be used to make sure no initialiser interfaces + * or concrete initialisers are missing. + * + * @author Alp Torac Genc + */ +public class UtilityTests implements IJaMoPPUtilityTest { + private static final Logger LOGGER = Logger.getLogger(UtilityTests.class); + /** + * Points at the parent package. Used by discovering methods in this class. + */ + private static final File root = new File(Paths + .get(new File("").toPath().toString(), "src", UtilityTests.class.getPackageName() + .substring(0, UtilityTests.class.getPackageName().lastIndexOf(".")).replace(".", File.separator)) + .toAbsolutePath().toUri()); + + @BeforeEach + public void setUp() { + Logger logger = this.getLogger(); + logger.setLevel(Level.ALL); + + logger = Logger.getRootLogger(); + logger.removeAllAppenders(); + ConsoleAppender ap = new ConsoleAppender(new PatternLayout("[%d{DATE}] %-5p: %c - %m%n"), + ConsoleAppender.SYSTEM_OUT); + logger.addAppender(ap); + } + + public Logger getLogger() { + return LOGGER; + } + + @Override + public IInitialiserPackage getUsedInitialiserPackage() { + return new JaMoPPInitialiserPackage(); + } + + @Override + public Collection getAllFiles() { + return this.getAllFiles(root); + } + + /** + * Prints all interface types from {@link #getAllPossibleJaMoPPEObjectTypes()}. + *
+ *
+ * Does not test anything, just prints the said types. + */ + @Test + public void printFullHierarchy() { + var hSet = this.getAllPossibleJaMoPPEObjectTypes(); + this.getLogger().info(this.clsStreamToString(hSet.stream())); + } + + /** + * Checks if all necessary concrete initialisers can be accessed under the used + * initialiser package, which is used in initialiser tests.
+ *
+ * Prints the amount of accessible/registered initialiser types. The missing + * types can be found in the assertion message. + */ + @Test + public void testAllConcreteInitialisersRegistered() { + var clss = this.getAllConcreteInitialiserCandidates(); + var registeredInits = this.getAllInitialiserInstances(); + + var matches = List.of( + clss.stream().filter((cls) -> registeredInits.stream().anyMatch((init) -> init.isInitialiserFor(cls))) + .toArray(Class[]::new)); + + this.getLogger().info(matches.size() + " out of " + clss.size() + " concrete initialisers are registered"); + + if (matches.size() != clss.size()) { + Assertions.fail("Concrete initialisers not registered: " + + this.clsStreamToString(clss.stream().filter((cls) -> !matches.contains(cls)))); + } + } + + /** + * Checks if all necessary initialiser interface types can be accessed under the + * used initialiser package, which is used in initialiser tests.
+ *
+ * Prints the amount of accessible/registered initialiser interface types. The + * missing types can be found in the assertion message. + */ + @Test + public void testAllInitialiserInterfacesRegistered() { + var clss = this.getAllInitialiserCandidates(); + var registeredInits = this.getAllInitialiserInterfaceTypes(); + + var matches = List.of(clss.stream() + .filter((cls) -> registeredInits.stream() + .anyMatch((init) -> this.getInitialiserInterfaceName(cls).equals(init.getSimpleName()))) + .toArray(Class[]::new)); + + this.getLogger().info(matches.size() + " out of " + clss.size() + " initialiser interfaces are registered"); + + if (matches.size() != clss.size()) { + Assertions.fail("Initialiser interfaces not registered: " + + this.clsStreamToString(clss.stream().filter((cls) -> !matches.contains(cls)))); + } + } + + /** + * Checks if all concrete initialisers (SomethingInitialiser.java) files are + * implemented and present under {@link #root}.
+ *
+ * Prints the number of present concrete initialiser files. Information on the + * missing files can be found in the assertion message.
+ *
+ * Only checks whether the said files are present, does not inspect their + * content at all. + */ + @Test + public void testAllConcreteInitialisersPresent() { + var intfcs = this.getAllConcreteInitialiserCandidates(); + var files = this.getAllFiles(); + + var matches = List.of(intfcs.stream().filter( + (ifc) -> files.stream().anyMatch((f) -> this.fileNameEquals(f, this.getConcreteInitialiserName(ifc)))) + .toArray(Class[]::new)); + var count = matches.size(); + + this.getLogger().info(count + " out of " + intfcs.size() + " concrete initialiser files are present"); + + if (count != intfcs.size()) { + Assertions.fail("Concrete initialiser files missing for: " + + this.clsStreamToString(intfcs.stream().filter((ifc) -> !matches.contains(ifc)))); + } + } + + /** + * Checks if all interface initialisers (ISomethingInitialiser.java) files are + * implemented and present under {@link #root}.
+ *
+ * Prints the number of present initialiser files. Information on the missing + * files can be found in the assertion message.
+ *
+ * Only checks whether the said files are present, does not inspect their + * content at all. + */ + @Test + public void testAllInitialiserInterfacesPresent() { + var intfcs = this.getAllInitialiserCandidates(); + var files = this.getAllFiles(); + + var matches = List.of(intfcs.stream().filter( + (ifc) -> files.stream().anyMatch((f) -> this.fileNameEquals(f, this.getInitialiserInterfaceName(ifc)))) + .toArray(Class[]::new)); + var count = matches.size(); + + this.getLogger().info(count + " out of " + intfcs.size() + " initialiser files are present"); + + if (count != intfcs.size()) { + Assertions.fail("Initialiser files missing for: " + + this.clsStreamToString(intfcs.stream().filter((ifc) -> !matches.contains(ifc)))); + } + } +} From 7415df32ca130ab6f48e01791141b8d092a631db Mon Sep 17 00:00:00 2001 From: AlpTorac Date: Fri, 25 Oct 2024 18:12:48 +0200 Subject: [PATCH 37/55] Add package commentary --- .../initialisers/jamopp/utiltests/package-info.java | 5 +++++ 1 file changed, 5 insertions(+) create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/utiltests/package-info.java diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/utiltests/package-info.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/utiltests/package-info.java new file mode 100644 index 0000000000..14b60e3558 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/utiltests/package-info.java @@ -0,0 +1,5 @@ +/** + * Contains tests that check whether {@link IInitialiser}s are setup properly, + * i.e. if their source files are present and they can be accessed. + */ +package cipm.consistency.initialisers.jamopp.utiltests; \ No newline at end of file From 829f03214a3f6f19c8f690682d609b0cf5912c53 Mon Sep 17 00:00:00 2001 From: AlpTorac Date: Fri, 25 Oct 2024 18:15:11 +0200 Subject: [PATCH 38/55] Implement dummy constructs for future tests Those tests will aim to ensure that initialiser discovery by using initialiser packages works as intended. They will furthermore check, whether initialiser adaptation works as expected. --- .../AbstractDummyAdaptationStrategy.java | 45 +++++++++++++++ .../DummyAggregateInitialiserPackageOne.java | 33 +++++++++++ .../DummyAggregateInitialiserPackageTwo.java | 20 +++++++ .../dummy/packages/DummyInitialiserA.java | 22 ++++++++ .../dummy/packages/DummyInitialiserB.java | 32 +++++++++++ .../dummy/packages/DummyInitialiserC.java | 38 +++++++++++++ .../dummy/packages/DummyInitialiserD.java | 32 +++++++++++ .../dummy/packages/DummyInitialiserE.java | 32 +++++++++++ .../packages/DummyInitialiserPackageA.java | 27 +++++++++ .../packages/DummyInitialiserPackageB.java | 27 +++++++++ .../packages/DummyInitialiserPackageCD.java | 27 +++++++++ .../tests/dummy/packages/DummyObjA.java | 30 ++++++++++ .../tests/dummy/packages/DummyObjB.java | 10 ++++ .../tests/dummy/packages/DummyObjC.java | 50 +++++++++++++++++ .../tests/dummy/packages/DummyObjD.java | 10 ++++ .../tests/dummy/packages/DummyObjE.java | 10 ++++ .../DummyTopLevelInitialiserPackage.java | 21 +++++++ .../tests/dummy/packages/ObjAInitStrat.java | 53 ++++++++++++++++++ .../packages/ObjCFirstInitStepStrat.java | 55 +++++++++++++++++++ .../packages/ObjCSecondInitStepStrat.java | 55 +++++++++++++++++++ .../tests/dummy/packages/package-info.java | 36 ++++++++++++ 21 files changed, 665 insertions(+) create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/packages/AbstractDummyAdaptationStrategy.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/packages/DummyAggregateInitialiserPackageOne.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/packages/DummyAggregateInitialiserPackageTwo.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/packages/DummyInitialiserA.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/packages/DummyInitialiserB.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/packages/DummyInitialiserC.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/packages/DummyInitialiserD.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/packages/DummyInitialiserE.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/packages/DummyInitialiserPackageA.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/packages/DummyInitialiserPackageB.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/packages/DummyInitialiserPackageCD.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/packages/DummyObjA.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/packages/DummyObjB.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/packages/DummyObjC.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/packages/DummyObjD.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/packages/DummyObjE.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/packages/DummyTopLevelInitialiserPackage.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/packages/ObjAInitStrat.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/packages/ObjCFirstInitStepStrat.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/packages/ObjCSecondInitStepStrat.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/packages/package-info.java diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/packages/AbstractDummyAdaptationStrategy.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/packages/AbstractDummyAdaptationStrategy.java new file mode 100644 index 0000000000..6c4dc90bbf --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/packages/AbstractDummyAdaptationStrategy.java @@ -0,0 +1,45 @@ +package cipm.consistency.initialisers.tests.dummy.packages; + +import cipm.consistency.initialisers.IInitialiserAdapterStrategy; + +/** + * An abstract class for simple dummy implementations of + * {@link IInitialiserAdapterStrategy} that are used in tests. + * + * @author Alp Torac Genc + */ +public abstract class AbstractDummyAdaptationStrategy implements IInitialiserAdapterStrategy { + /** + * @see {@link #doesInitialiseSuccessfully()} + */ + private boolean initSuccessfully; + + /** + * A variant of {@link #AbstractDummyAdaptationStrategy(boolean)} with "true" as + * boolean parameter. + */ + public AbstractDummyAdaptationStrategy() { + this(true); + } + + /** + * Constructs an instance with the given parameter that determines the success + * of the adaptation strategy. + * + * @param initSuccessfully Whether + * {@link #apply(cipm.consistency.initialisers.IInitialiser, Object)} + * performs the initialisation as expected. + */ + public AbstractDummyAdaptationStrategy(boolean initSuccessfully) { + this.initSuccessfully = initSuccessfully; + } + + /** + * @return Whether + * {@link #apply(cipm.consistency.initialisers.IInitialiser, Object)} + * performs the initialisation as expected. + */ + public boolean doesInitialiseSuccessfully() { + return this.initSuccessfully; + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/packages/DummyAggregateInitialiserPackageOne.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/packages/DummyAggregateInitialiserPackageOne.java new file mode 100644 index 0000000000..2781dd0714 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/packages/DummyAggregateInitialiserPackageOne.java @@ -0,0 +1,33 @@ +package cipm.consistency.initialisers.tests.dummy.packages; + +import java.util.Collection; + +import cipm.consistency.initialisers.IInitialiser; +import cipm.consistency.initialisers.IInitialiserPackage; + +/** + * An {@link IInitialiserPackage} implementation, which simulates a package + * containing 1 initialiser implementation and 2 further sub-packages. + * + * @author Alp Torac Genc + * @see {@link cipm.consistency.initialisers.tests.dummy.packages} for the + * package layout. + */ +public class DummyAggregateInitialiserPackageOne implements IInitialiserPackage { + @Override + public Collection getSubPackages() { + return this + .initCol(new IInitialiserPackage[] { new DummyInitialiserPackageA(), new DummyInitialiserPackageB() }); + } + + @Override + public Collection getInitialiserInstances() { + return this.initCol(new IInitialiser[] { new DummyInitialiserE() }); + } + + @SuppressWarnings("unchecked") + @Override + public Collection> getInitialiserInterfaceTypes() { + return this.initCol(new Class[] { DummyInitialiserE.class }); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/packages/DummyAggregateInitialiserPackageTwo.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/packages/DummyAggregateInitialiserPackageTwo.java new file mode 100644 index 0000000000..ac485de879 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/packages/DummyAggregateInitialiserPackageTwo.java @@ -0,0 +1,20 @@ +package cipm.consistency.initialisers.tests.dummy.packages; + +import java.util.Collection; + +import cipm.consistency.initialisers.IInitialiserPackage; + +/** + * An {@link IInitialiserPackage} implementation, which simulates a package + * containing 1 further sub-package and no initialiser implementations. + * + * @author Alp Torac Genc + * @see {@link cipm.consistency.initialisers.tests.dummy.packages} for the + * package layout. + */ +public class DummyAggregateInitialiserPackageTwo implements IInitialiserPackage { + @Override + public Collection getSubPackages() { + return this.initCol(new IInitialiserPackage[] { new DummyInitialiserPackageCD() }); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/packages/DummyInitialiserA.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/packages/DummyInitialiserA.java new file mode 100644 index 0000000000..6fffd11731 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/packages/DummyInitialiserA.java @@ -0,0 +1,22 @@ +package cipm.consistency.initialisers.tests.dummy.packages; + +import cipm.consistency.initialisers.AbstractInitialiserBase; + +/** + * A dummy initialiser for {@link DummyObjA}. + * + * @author Alp Torac Genc + * @see {@link ObjAInitStrat} + */ +public class DummyInitialiserA extends AbstractInitialiserBase { + + @Override + public DummyInitialiserA newInitialiser() { + return new DummyInitialiserA(); + } + + @Override + public DummyObjA instantiate() { + return new DummyObjA(); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/packages/DummyInitialiserB.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/packages/DummyInitialiserB.java new file mode 100644 index 0000000000..b93bc8dadc --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/packages/DummyInitialiserB.java @@ -0,0 +1,32 @@ +package cipm.consistency.initialisers.tests.dummy.packages; + +import cipm.consistency.initialisers.IInitialiser; + +/** + * A dummy initialiser for {@link DummyObjB}, whose {@link #initialise(Object)} + * method always returns true. + * + * @author Alp Torac Genc + */ +public class DummyInitialiserB implements IInitialiser { + + @Override + public DummyInitialiserB newInitialiser() { + return new DummyInitialiserB(); + } + + @Override + public DummyObjB instantiate() { + return new DummyObjB(); + } + + /** + * {@inheritDoc}
+ *
+ * For this implementor, does nothing and returns true. + */ + @Override + public boolean initialise(Object obj) { + return true; + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/packages/DummyInitialiserC.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/packages/DummyInitialiserC.java new file mode 100644 index 0000000000..be3e1c8526 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/packages/DummyInitialiserC.java @@ -0,0 +1,38 @@ +package cipm.consistency.initialisers.tests.dummy.packages; + +import cipm.consistency.initialisers.AbstractInitialiserBase; +import cipm.consistency.initialisers.IInitialiserAdapterStrategy; + +/** + * A dummy initialiser for {@link DummyObjC}. + * + * @author Alp Torac Genc + * @see {@link ObjCFirstInitStepStrat} + * @see {@link ObjCSecondInitStepStrat} + */ +public class DummyInitialiserC extends AbstractInitialiserBase { + + /** + * @see {@link AbstractInitialiserBase#AbstractInitialiserBase()} + */ + public DummyInitialiserC() { + super(); + } + + /** + * @see {@link AbstractInitialiserBase#AbstractInitialiserBase(IInitialiserAdapterStrategy[])} + */ + public DummyInitialiserC(IInitialiserAdapterStrategy[] adaptingInits) { + super(adaptingInits); + } + + @Override + public DummyInitialiserC newInitialiser() { + return new DummyInitialiserC(); + } + + @Override + public DummyObjC instantiate() { + return new DummyObjC(); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/packages/DummyInitialiserD.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/packages/DummyInitialiserD.java new file mode 100644 index 0000000000..17535bdde9 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/packages/DummyInitialiserD.java @@ -0,0 +1,32 @@ +package cipm.consistency.initialisers.tests.dummy.packages; + +import cipm.consistency.initialisers.IInitialiser; + +/** + * A dummy initialiser for {@link DummyObjD}, whose {@link #initialise(Object)} + * method always returns true. + * + * @author Alp Torac Genc + */ +public class DummyInitialiserD implements IInitialiser { + + @Override + public DummyInitialiserD newInitialiser() { + return new DummyInitialiserD(); + } + + @Override + public DummyObjD instantiate() { + return new DummyObjD(); + } + + /** + * {@inheritDoc}
+ *
+ * For this implementor, does nothing and returns true. + */ + @Override + public boolean initialise(Object obj) { + return true; + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/packages/DummyInitialiserE.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/packages/DummyInitialiserE.java new file mode 100644 index 0000000000..0707e0ee60 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/packages/DummyInitialiserE.java @@ -0,0 +1,32 @@ +package cipm.consistency.initialisers.tests.dummy.packages; + +import cipm.consistency.initialisers.IInitialiser; + +/** + * A dummy initialiser for {@link DummyObjE}, whose {@link #initialise(Object)} + * method always returns false. + * + * @author Alp Torac Genc + */ +public class DummyInitialiserE implements IInitialiser { + + @Override + public DummyInitialiserE newInitialiser() { + return new DummyInitialiserE(); + } + + @Override + public DummyObjE instantiate() { + return new DummyObjE(); + } + + /** + * {@inheritDoc}
+ *
+ * For this implementor, does nothing and returns false. + */ + @Override + public boolean initialise(Object obj) { + return false; + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/packages/DummyInitialiserPackageA.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/packages/DummyInitialiserPackageA.java new file mode 100644 index 0000000000..a530191a23 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/packages/DummyInitialiserPackageA.java @@ -0,0 +1,27 @@ +package cipm.consistency.initialisers.tests.dummy.packages; + +import java.util.Collection; + +import cipm.consistency.initialisers.IInitialiser; +import cipm.consistency.initialisers.IInitialiserPackage; + +/** + * An {@link IInitialiserPackage} implementation, which simulates a package + * containing 1 initialiser implementation and no further sub-packages. + * + * @author Alp Torac Genc + * @see {@link cipm.consistency.initialisers.tests.dummy.packages} for the + * package layout. + */ +public class DummyInitialiserPackageA implements IInitialiserPackage { + @Override + public Collection getInitialiserInstances() { + return this.initCol(new IInitialiser[] { new DummyInitialiserA() }); + } + + @SuppressWarnings("unchecked") + @Override + public Collection> getInitialiserInterfaceTypes() { + return this.initCol(new Class[] { DummyInitialiserA.class }); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/packages/DummyInitialiserPackageB.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/packages/DummyInitialiserPackageB.java new file mode 100644 index 0000000000..b57467588c --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/packages/DummyInitialiserPackageB.java @@ -0,0 +1,27 @@ +package cipm.consistency.initialisers.tests.dummy.packages; + +import java.util.Collection; + +import cipm.consistency.initialisers.IInitialiser; +import cipm.consistency.initialisers.IInitialiserPackage; + +/** + * An {@link IInitialiserPackage} implementation, which simulates a package + * containing 1 initialiser implementation and no further sub-packages. + * + * @author Alp Torac Genc + * @see {@link cipm.consistency.initialisers.tests.dummy.packages} for the + * package layout. + */ +public class DummyInitialiserPackageB implements IInitialiserPackage { + @Override + public Collection getInitialiserInstances() { + return this.initCol(new IInitialiser[] { new DummyInitialiserB() }); + } + + @SuppressWarnings("unchecked") + @Override + public Collection> getInitialiserInterfaceTypes() { + return this.initCol(new Class[] { DummyInitialiserB.class }); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/packages/DummyInitialiserPackageCD.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/packages/DummyInitialiserPackageCD.java new file mode 100644 index 0000000000..85a130e4e6 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/packages/DummyInitialiserPackageCD.java @@ -0,0 +1,27 @@ +package cipm.consistency.initialisers.tests.dummy.packages; + +import java.util.Collection; + +import cipm.consistency.initialisers.IInitialiser; +import cipm.consistency.initialisers.IInitialiserPackage; + +/** + * An {@link IInitialiserPackage} implementation, which simulates a package + * containing 2 initialiser implementation and no further sub-packages. + * + * @author Alp Torac Genc + * @see {@link cipm.consistency.initialisers.tests.dummy.packages} for the + * package layout. + */ +public class DummyInitialiserPackageCD implements IInitialiserPackage { + @Override + public Collection getInitialiserInstances() { + return this.initCol(new IInitialiser[] { new DummyInitialiserC(), new DummyInitialiserD() }); + } + + @SuppressWarnings("unchecked") + @Override + public Collection> getInitialiserInterfaceTypes() { + return this.initCol(new Class[] { DummyInitialiserC.class, DummyInitialiserD.class }); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/packages/DummyObjA.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/packages/DummyObjA.java new file mode 100644 index 0000000000..d9ea4b8846 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/packages/DummyObjA.java @@ -0,0 +1,30 @@ +package cipm.consistency.initialisers.tests.dummy.packages; + +/** + * A dummy object that can be initialised via {@link #initStep()}. Note that the + * said initialisation does not do any vital changes on the object, it only + * simulates an initialisation. + * + * @author Alp Torac Genc + */ +public class DummyObjA { + /** + * @see {@link #isInitialisationStepDone()} + */ + private boolean initialisationStepDone = false; + + /** + * Performs the initialisation + */ + public void initStep() { + this.initialisationStepDone = true; + } + + /** + * @return Whether initialisation was done + * @see {@link #initStep()} + */ + public boolean isInitialisationStepDone() { + return initialisationStepDone; + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/packages/DummyObjB.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/packages/DummyObjB.java new file mode 100644 index 0000000000..bcca0f9975 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/packages/DummyObjB.java @@ -0,0 +1,10 @@ +package cipm.consistency.initialisers.tests.dummy.packages; + +/** + * A dummy object that needs no initialisation. + * + * @author Alp Torac Genc + */ +public class DummyObjB { + +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/packages/DummyObjC.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/packages/DummyObjC.java new file mode 100644 index 0000000000..5f47d0ae01 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/packages/DummyObjC.java @@ -0,0 +1,50 @@ +package cipm.consistency.initialisers.tests.dummy.packages; + +/** + * A dummy object that can be initialised via 2 methods {@link #initStepOne()} + * and {@link #initStepTwo()}. Note that the said initialisation methods do not + * do any vital changes on the object, they only simulate an initialisation with + * multiple steps. The order of the steps do not matter. + * + * @author Alp Torac Genc + */ +public class DummyObjC { + /** + * @see {@link #isInitialisationStepOneDone()} + */ + private boolean initialisationStepOneDone = false; + /** + * @see {@link #isInitialisationStepTwoDone()} + */ + private boolean initialisationStepTwoDone = false; + + /** + * Performs the step one of the initialisation. + */ + public void initStepOne() { + this.initialisationStepOneDone = true; + } + + /** + * Performs the step two of the initialisation. + */ + public void initStepTwo() { + this.initialisationStepTwoDone = true; + } + + /** + * @return Whether the step one of the initialisation is performed. + * @see {@link #initStepOne()} + */ + public boolean isInitialisationStepOneDone() { + return initialisationStepOneDone; + } + + /** + * @return Whether the step two of the initialisation is performed. + * @see {@link #initStepTwo()} + */ + public boolean isInitialisationStepTwoDone() { + return initialisationStepTwoDone; + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/packages/DummyObjD.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/packages/DummyObjD.java new file mode 100644 index 0000000000..c2b95d2495 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/packages/DummyObjD.java @@ -0,0 +1,10 @@ +package cipm.consistency.initialisers.tests.dummy.packages; + +/** + * A dummy object that needs no initialisation. + * + * @author Alp Torac Genc + */ +public class DummyObjD { + +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/packages/DummyObjE.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/packages/DummyObjE.java new file mode 100644 index 0000000000..ede2a85f92 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/packages/DummyObjE.java @@ -0,0 +1,10 @@ +package cipm.consistency.initialisers.tests.dummy.packages; + +/** + * A dummy object that needs no initialisation. + * + * @author Alp Torac Genc + */ +public class DummyObjE { + +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/packages/DummyTopLevelInitialiserPackage.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/packages/DummyTopLevelInitialiserPackage.java new file mode 100644 index 0000000000..c262efe44a --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/packages/DummyTopLevelInitialiserPackage.java @@ -0,0 +1,21 @@ +package cipm.consistency.initialisers.tests.dummy.packages; + +import java.util.Collection; + +import cipm.consistency.initialisers.IInitialiserPackage; + +/** + * An {@link IInitialiserPackage} implementation, which simulates a top-level + * package containing 2 further sub-packages. + * + * @author Alp Torac Genc + * @see {@link cipm.consistency.initialisers.tests.dummy.packages} for the + * package layout. + */ +public class DummyTopLevelInitialiserPackage implements IInitialiserPackage { + @Override + public Collection getSubPackages() { + return this.initCol(new IInitialiserPackage[] { new DummyAggregateInitialiserPackageOne(), + new DummyAggregateInitialiserPackageTwo() }); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/packages/ObjAInitStrat.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/packages/ObjAInitStrat.java new file mode 100644 index 0000000000..d29952ec08 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/packages/ObjAInitStrat.java @@ -0,0 +1,53 @@ +package cipm.consistency.initialisers.tests.dummy.packages; + +import cipm.consistency.initialisers.IInitialiser; + +/** + * An {@link AbstractDummyAdaptationStrategy} implementation that initialises + * {@link DummyObjA} instances, provided its constructor is given parameters + * that allow it. + * + * @author Alp Torac Genc + */ +public class ObjAInitStrat extends AbstractDummyAdaptationStrategy { + /** + * A variant of {@link #ObjAInitStrat(boolean)} with "true" as the boolean + * parameter. + */ + public ObjAInitStrat() { + super(); + } + + /** + * @see {@link AbstractDummyAdaptationStrategy#AbstractDummyAdaptationStrategy(boolean)} + */ + public ObjAInitStrat(boolean initSuccessfully) { + super(initSuccessfully); + } + + /** + * {@inheritDoc}
+ *
+ * Initialises the given {@link DummyObjA} instance, if + * {@link #doesInitialiseSuccessfully()} is true. + */ + @Override + public boolean apply(IInitialiser init, Object obj) { + if (obj instanceof DummyObjA) { + var castedO = (DummyObjA) obj; + + if (this.doesInitialiseSuccessfully()) { + castedO.initStep(); + } + + return castedO.isInitialisationStepDone(); + } + + return true; + } + + @Override + public ObjAInitStrat newStrategy() { + return new ObjAInitStrat(); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/packages/ObjCFirstInitStepStrat.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/packages/ObjCFirstInitStepStrat.java new file mode 100644 index 0000000000..2b984b3cea --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/packages/ObjCFirstInitStepStrat.java @@ -0,0 +1,55 @@ +package cipm.consistency.initialisers.tests.dummy.packages; + +import cipm.consistency.initialisers.IInitialiser; + +/** + * An {@link AbstractDummyAdaptationStrategy} implementation that partially + * initialises {@link DummyObjC} instances, provided its constructor is given + * parameters that allow it. This implementation is complemented with + * {@link ObjCSecondInitStepStrat}, which performs the remaining part of the + * said initialisation. + * + * @author Alp Torac Genc + */ +public class ObjCFirstInitStepStrat extends AbstractDummyAdaptationStrategy { + /** + * A variant of {@link #ObjCFirstInitStepStrat(boolean)} with "true" as the + * boolean parameter. + */ + public ObjCFirstInitStepStrat() { + super(); + } + + /** + * @see {@link AbstractDummyAdaptationStrategy#AbstractDummyAdaptationStrategy(boolean)} + */ + public ObjCFirstInitStepStrat(boolean initSuccessfully) { + super(initSuccessfully); + } + + /** + * {@inheritDoc}
+ *
+ * Performs {@link DummyObjC#initStepOne()} on the given {@link DummyObjC} + * instance, if {@link #doesInitialiseSuccessfully()} is true. + */ + @Override + public boolean apply(IInitialiser init, Object obj) { + if (obj instanceof DummyObjC) { + var castedO = (DummyObjC) obj; + + if (this.doesInitialiseSuccessfully()) { + castedO.initStepOne(); + } + + return castedO.isInitialisationStepOneDone(); + } + + return true; + } + + @Override + public ObjCFirstInitStepStrat newStrategy() { + return new ObjCFirstInitStepStrat(); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/packages/ObjCSecondInitStepStrat.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/packages/ObjCSecondInitStepStrat.java new file mode 100644 index 0000000000..5b6a2c2aa9 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/packages/ObjCSecondInitStepStrat.java @@ -0,0 +1,55 @@ +package cipm.consistency.initialisers.tests.dummy.packages; + +import cipm.consistency.initialisers.IInitialiser; + +/** + * An {@link AbstractDummyAdaptationStrategy} implementation that partially + * initialises {@link DummyObjC} instances, provided its constructor is given + * parameters that allow it. This implementation is complemented with + * {@link ObjCFirstInitStepStrat}, which performs the remaining part of the said + * initialisation. + * + * @author Alp Torac Genc + */ +public class ObjCSecondInitStepStrat extends AbstractDummyAdaptationStrategy { + /** + * A variant of {@link #ObjCSecondInitStepStrat(boolean)} with "true" as the + * boolean parameter. + */ + public ObjCSecondInitStepStrat() { + super(); + } + + /** + * @see {@link AbstractDummyAdaptationStrategy#AbstractDummyAdaptationStrategy(boolean)} + */ + public ObjCSecondInitStepStrat(boolean initSuccessfully) { + super(initSuccessfully); + } + + /** + * {@inheritDoc}
+ *
+ * Performs {@link DummyObjC#initStepTwo()} on the given {@link DummyObjC} + * instance, if {@link #doesInitialiseSuccessfully()} is true. + */ + @Override + public boolean apply(IInitialiser init, Object obj) { + if (obj instanceof DummyObjC) { + var castedO = (DummyObjC) obj; + + if (this.doesInitialiseSuccessfully()) { + castedO.initStepTwo(); + } + + return castedO.isInitialisationStepTwoDone(); + } + + return true; + } + + @Override + public ObjCSecondInitStepStrat newStrategy() { + return new ObjCSecondInitStepStrat(); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/packages/package-info.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/packages/package-info.java new file mode 100644 index 0000000000..bb61fa3c31 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/packages/package-info.java @@ -0,0 +1,36 @@ +/** + * Contains dummy implementations of initialiser packages as well as their + * content. They are used in tests for initialiser packages and initialiser + * adaptation. Through these tests, the recursive discovery of sub-packages and + * their content is tested. The current package/initialiser layout is as + * follows:
+ *
+ *
    + *
  • {@link DummyTopLevelInitialiserPackage} + *
      + *
    • {@link DummyAggregateInitialiserPackageOne} + *
        + *
      • {@link DummyInitialiserE} + *
      • {@link DummyInitialiserPackageA} + *
          + *
        • {@link DummyInitialiserA} + *
        + *
      • {@link DummyInitialiserPackageB} + *
          + *
        • {@link DummyInitialiserB} + *
        + *
      + *
    • {@link DummyAggregateInitialiserPackageTwo} + *
        + *
      • {@link DummyInitialiserPackageCD} + *
          + *
        • {@link DummyInitialiserC} + *
        • {@link DummyInitialiserD} + *
        + *
      + *
    + *
+ * + * @author Alp Torac Genc + */ +package cipm.consistency.initialisers.tests.dummy.packages; \ No newline at end of file From 64dbb99077afa6c40c5ce521ca815ba17c02a0ba Mon Sep 17 00:00:00 2001 From: AlpTorac Date: Fri, 25 Oct 2024 18:23:35 +0200 Subject: [PATCH 39/55] Implement dummy constructs for future tests Their purpose is to be used to verify that initialisers can modify the objects they create as intended. They can also be used to test some static methods of IInitialiser (the top-level initialiser interface). The said dummy constructs also include a re-usable abstract class for further dummy constructs (to be implemented in the following commits). --- ...DummyTriviallyInitialisingInitialiser.java | 49 +++++++++++++++++++ .../tests/dummy/types/DummyModifiableObj.java | 37 ++++++++++++++ .../types/DummyModifiableObjInitialiser.java | 48 ++++++++++++++++++ .../IDummyInitialiserWithoutMethods.java | 13 +++++ 4 files changed, 147 insertions(+) create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/types/AbstractDummyTriviallyInitialisingInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/types/DummyModifiableObj.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/types/DummyModifiableObjInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/types/IDummyInitialiserWithoutMethods.java diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/types/AbstractDummyTriviallyInitialisingInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/types/AbstractDummyTriviallyInitialisingInitialiser.java new file mode 100644 index 0000000000..a4ce23e2b5 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/types/AbstractDummyTriviallyInitialisingInitialiser.java @@ -0,0 +1,49 @@ +package cipm.consistency.initialisers.tests.dummy.types; + +import cipm.consistency.initialisers.IInitialiser; + +/** + * An abstract dummy {@link IInitialiser}, which either always succeeds or + * always fails initialising via {@link #initialise(Object)}. + * + * @author Alp Torac Genc + */ +public abstract class AbstractDummyTriviallyInitialisingInitialiser implements IInitialiser { + + /** + * @see {@link AbstractDummyTriviallyInitialisingInitialiser#AbstractDummyTriviallyInitialisingInitialiser(boolean)} + */ + private boolean isInitialiseSuccessful; + + /** + * A variant of + * {@link AbstractDummyTriviallyInitialisingInitialiser#AbstractDummyTriviallyInitialisingInitialiser(boolean)} + * with "true" as the boolean parameter. + */ + public AbstractDummyTriviallyInitialisingInitialiser() { + this(true); + } + + /** + * Constructs an instance, which either always succeeds or always fails + * initialising via {@link #initialise(Object)}. + * + * @param isInitialiseSuccessful The return value of {@link #initialise(Object)} + * (i.e. whether initialisation succeeds). + */ + public AbstractDummyTriviallyInitialisingInitialiser(boolean isInitialiseSuccessful) { + this.isInitialiseSuccessful = isInitialiseSuccessful; + } + + /** + * {@inheritDoc}
+ *
+ * For this implementation, does nothing to the given object. Check + * {@link AbstractDummyTriviallyInitialisingInitialiser#AbstractDummyTriviallyInitialisingInitialiser(boolean)} + * for the return value. + */ + @Override + public boolean initialise(Object obj) { + return this.isInitialiseSuccessful; + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/types/DummyModifiableObj.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/types/DummyModifiableObj.java new file mode 100644 index 0000000000..b98c07a556 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/types/DummyModifiableObj.java @@ -0,0 +1,37 @@ +package cipm.consistency.initialisers.tests.dummy.types; + +import java.util.HashSet; +import java.util.Set; + +/** + * A dummy object, to which modifiable attributes can be added. The said + * attributes are then stored in a {@link Set}. + * + * @author Alp Torac Genc + */ +public class DummyModifiableObj { + /** + * A set of modifiable attributes. + */ + private final Set someModifiableAttrCol = new HashSet(); + + /** + * @param attrToAdd An attribute to be added to this + * @return Whether the given attibute was added successfully + */ + public boolean addAttr(Object attrToAdd) { + return attrToAdd != null && this.someModifiableAttrCol.add(attrToAdd); + } + + /** + * @return A set containing all attributes stored in this. Modifying the + * returned attributes will affect the attributes stored in this. + * Modifying the returned set will not affect the stored values, + * however. + */ + public Set getAttrs() { + var attrs = new HashSet(); + this.someModifiableAttrCol.forEach((attr) -> attrs.add(attr)); + return attrs; + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/types/DummyModifiableObjInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/types/DummyModifiableObjInitialiser.java new file mode 100644 index 0000000000..f623942e8f --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/types/DummyModifiableObjInitialiser.java @@ -0,0 +1,48 @@ +package cipm.consistency.initialisers.tests.dummy.types; + +import cipm.consistency.initialisers.IInitialiser; + +/** + * A dummy {@link IInitialiser} implementation for {@link DummyModifiableObj}, + * which also offers methods to add them attributes. + * + * @author Alp Torac Genc + */ +public class DummyModifiableObjInitialiser implements IInitialiser { + + @Override + public DummyModifiableObjInitialiser newInitialiser() { + return new DummyModifiableObjInitialiser(); + } + + @Override + public DummyModifiableObj instantiate() { + return new DummyModifiableObj(); + } + + /** + * {@inheritDoc}
+ *
+ * For this implementor, does nothing and returns true. + */ + @Override + public boolean initialise(Object obj) { + return true; + } + + /** + * @see {@link DummyModifiableObj#addAttr(Object)} + */ + public boolean addAttr(DummyModifiableObj obj, Object attrToAdd) { + return obj.addAttr(attrToAdd); + } + + /** + * A variant of {@link #addAttr(DummyModifiableObj, Object)} for adding an array + * of attributes (each element within the given array will be added + * individually). + */ + public boolean addAttrs(DummyModifiableObj obj, Object[] attrsToAdd) { + return this.doMultipleModifications(obj, attrsToAdd, this::addAttr); + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/types/IDummyInitialiserWithoutMethods.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/types/IDummyInitialiserWithoutMethods.java new file mode 100644 index 0000000000..68086fb874 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/types/IDummyInitialiserWithoutMethods.java @@ -0,0 +1,13 @@ +package cipm.consistency.initialisers.tests.dummy.types; + +import cipm.consistency.initialisers.IInitialiser; + +/** + * A dummy interface that extends {@link IInitialiser} without introducing + * anything new. + * + * @author Alp Torac Genc + */ +public interface IDummyInitialiserWithoutMethods extends IInitialiser { + +} From 771609b16bc3c1fab4bc78bf9e8fdac51a7a4077 Mon Sep 17 00:00:00 2001 From: AlpTorac Date: Fri, 25 Oct 2024 18:26:56 +0200 Subject: [PATCH 40/55] Implement dummy constructs for future tests Add a package that contains 4 dummy objects, as well as their dummy initialisers. Neither the said objects nor their initialisers form a type hierarchy (i.e. they do not extend one another). They are meant to be used in tests, which verify some static methods of IInitialiser (the top-level initialiser interface). --- .../types/flathierarchy/DummyObjFour.java | 9 ++++ .../DummyObjFourInitialiser.java | 43 +++++++++++++++++++ .../types/flathierarchy/DummyObjOne.java | 9 ++++ .../flathierarchy/DummyObjOneInitialiser.java | 31 +++++++++++++ .../types/flathierarchy/DummyObjThree.java | 9 ++++ .../DummyObjThreeInitialiser.java | 31 +++++++++++++ .../types/flathierarchy/DummyObjTwo.java | 9 ++++ .../flathierarchy/DummyObjTwoInitialiser.java | 36 ++++++++++++++++ .../IDummyObjFourInitialiser.java | 25 +++++++++++ .../IDummyObjOneInitialiser.java | 18 ++++++++ .../IDummyObjThreeInitialiser.java | 14 ++++++ .../IDummyObjTwoInitialiser.java | 14 ++++++ .../types/flathierarchy/package-info.java | 11 +++++ 13 files changed, 259 insertions(+) create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/types/flathierarchy/DummyObjFour.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/types/flathierarchy/DummyObjFourInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/types/flathierarchy/DummyObjOne.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/types/flathierarchy/DummyObjOneInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/types/flathierarchy/DummyObjThree.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/types/flathierarchy/DummyObjThreeInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/types/flathierarchy/DummyObjTwo.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/types/flathierarchy/DummyObjTwoInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/types/flathierarchy/IDummyObjFourInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/types/flathierarchy/IDummyObjOneInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/types/flathierarchy/IDummyObjThreeInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/types/flathierarchy/IDummyObjTwoInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/types/flathierarchy/package-info.java diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/types/flathierarchy/DummyObjFour.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/types/flathierarchy/DummyObjFour.java new file mode 100644 index 0000000000..501a1fc233 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/types/flathierarchy/DummyObjFour.java @@ -0,0 +1,9 @@ +package cipm.consistency.initialisers.tests.dummy.types.flathierarchy; + +/** + * A dummy object that needs no initialisation. + * + * @author Alp Torac Genc + */ +public class DummyObjFour { +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/types/flathierarchy/DummyObjFourInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/types/flathierarchy/DummyObjFourInitialiser.java new file mode 100644 index 0000000000..fba03e8e18 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/types/flathierarchy/DummyObjFourInitialiser.java @@ -0,0 +1,43 @@ +package cipm.consistency.initialisers.tests.dummy.types.flathierarchy; + +import cipm.consistency.initialisers.tests.dummy.types.AbstractDummyTriviallyInitialisingInitialiser; + +/** + * A dummy initialiser implementation of {@link IDummyObjFourInitialiser} that + * introduces some further utility methods: + *
    + *
  • One with an object parameter + *
  • Another one without parameters + *
+ * + * @author Alp Torac Genc + */ +public class DummyObjFourInitialiser extends AbstractDummyTriviallyInitialisingInitialiser + implements IDummyObjFourInitialiser { + + public DummyObjFourInitialiser() { + super(); + } + + public DummyObjFourInitialiser(boolean isInitialiseSuccessful) { + super(isInitialiseSuccessful); + } + + @Override + public DummyObjFourInitialiser newInitialiser() { + return new DummyObjFourInitialiser(); + } + + @Override + public DummyObjFour instantiate() { + return new DummyObjFour(); + } + + public boolean someUtilityMethodInClass(Object param) { + return true; + } + + public boolean someUtilityMethodInClassWithoutParam() { + return true; + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/types/flathierarchy/DummyObjOne.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/types/flathierarchy/DummyObjOne.java new file mode 100644 index 0000000000..78ef06da84 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/types/flathierarchy/DummyObjOne.java @@ -0,0 +1,9 @@ +package cipm.consistency.initialisers.tests.dummy.types.flathierarchy; + +/** + * A dummy object that needs no initialisation. + * + * @author Alp Torac Genc + */ +public class DummyObjOne { +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/types/flathierarchy/DummyObjOneInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/types/flathierarchy/DummyObjOneInitialiser.java new file mode 100644 index 0000000000..5ff0a852a8 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/types/flathierarchy/DummyObjOneInitialiser.java @@ -0,0 +1,31 @@ +package cipm.consistency.initialisers.tests.dummy.types.flathierarchy; + +import cipm.consistency.initialisers.tests.dummy.types.AbstractDummyTriviallyInitialisingInitialiser; + +/** + * A dummy initialiser implementation of {@link IDummyObjOneInitialiser} that + * introduces no new methods. + * + * @author Alp Torac Genc + */ +public class DummyObjOneInitialiser extends AbstractDummyTriviallyInitialisingInitialiser + implements IDummyObjOneInitialiser { + + public DummyObjOneInitialiser() { + super(); + } + + public DummyObjOneInitialiser(boolean isInitialiseSuccessful) { + super(isInitialiseSuccessful); + } + + @Override + public DummyObjOneInitialiser newInitialiser() { + return new DummyObjOneInitialiser(); + } + + @Override + public DummyObjOne instantiate() { + return new DummyObjOne(); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/types/flathierarchy/DummyObjThree.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/types/flathierarchy/DummyObjThree.java new file mode 100644 index 0000000000..4bfadf7005 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/types/flathierarchy/DummyObjThree.java @@ -0,0 +1,9 @@ +package cipm.consistency.initialisers.tests.dummy.types.flathierarchy; + +/** + * A dummy object that needs no initialisation. + * + * @author Alp Torac Genc + */ +public class DummyObjThree { +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/types/flathierarchy/DummyObjThreeInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/types/flathierarchy/DummyObjThreeInitialiser.java new file mode 100644 index 0000000000..810aab7d30 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/types/flathierarchy/DummyObjThreeInitialiser.java @@ -0,0 +1,31 @@ +package cipm.consistency.initialisers.tests.dummy.types.flathierarchy; + +import cipm.consistency.initialisers.tests.dummy.types.AbstractDummyTriviallyInitialisingInitialiser; + +/** + * A dummy initialiser implementation of {@link IDummyObjThreeInitialiser} that + * introduces no new methods. + * + * @author Alp Torac Genc + */ +public class DummyObjThreeInitialiser extends AbstractDummyTriviallyInitialisingInitialiser + implements IDummyObjThreeInitialiser { + + public DummyObjThreeInitialiser() { + super(); + } + + public DummyObjThreeInitialiser(boolean isInitialiseSuccessful) { + super(isInitialiseSuccessful); + } + + @Override + public DummyObjThreeInitialiser newInitialiser() { + return new DummyObjThreeInitialiser(); + } + + @Override + public DummyObjThree instantiate() { + return new DummyObjThree(); + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/types/flathierarchy/DummyObjTwo.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/types/flathierarchy/DummyObjTwo.java new file mode 100644 index 0000000000..80ceee57df --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/types/flathierarchy/DummyObjTwo.java @@ -0,0 +1,9 @@ +package cipm.consistency.initialisers.tests.dummy.types.flathierarchy; + +/** + * A dummy object that needs no initialisation. + * + * @author Alp Torac Genc + */ +public class DummyObjTwo { +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/types/flathierarchy/DummyObjTwoInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/types/flathierarchy/DummyObjTwoInitialiser.java new file mode 100644 index 0000000000..b27989437a --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/types/flathierarchy/DummyObjTwoInitialiser.java @@ -0,0 +1,36 @@ +package cipm.consistency.initialisers.tests.dummy.types.flathierarchy; + +import cipm.consistency.initialisers.tests.dummy.types.AbstractDummyTriviallyInitialisingInitialiser; + +/** + * A dummy initialiser implementation of {@link IDummyObjTwoInitialiser} that + * introduces a new modification method, which takes an object parameter as well + * as the object to be modified. + * + * @author Alp Torac Genc + */ +public class DummyObjTwoInitialiser extends AbstractDummyTriviallyInitialisingInitialiser + implements IDummyObjTwoInitialiser { + + public DummyObjTwoInitialiser() { + super(); + } + + public DummyObjTwoInitialiser(boolean isInitialiseSuccessful) { + super(isInitialiseSuccessful); + } + + @Override + public DummyObjTwoInitialiser newInitialiser() { + return new DummyObjTwoInitialiser(); + } + + @Override + public DummyObjTwo instantiate() { + return new DummyObjTwo(); + } + + public boolean modificationMethodInClass(DummyObjTwo obj, Object param) { + return true; + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/types/flathierarchy/IDummyObjFourInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/types/flathierarchy/IDummyObjFourInitialiser.java new file mode 100644 index 0000000000..21781b6a17 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/types/flathierarchy/IDummyObjFourInitialiser.java @@ -0,0 +1,25 @@ +package cipm.consistency.initialisers.tests.dummy.types.flathierarchy; + +import cipm.consistency.initialisers.IInitialiser; + +/** + * A dummy initialiser interface with some default utility methods: + *
    + *
  • One with an object parameter + *
  • Another one without parameters + *
+ * + * @author Alp Torac Genc + */ +public interface IDummyObjFourInitialiser extends IInitialiser { + @Override + public DummyObjFour instantiate(); + + public default boolean someUtilityMethodInInterface(Object someParam) { + return true; + } + + public default boolean someUtilityMethodInInterfaceWithoutParam() { + return true; + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/types/flathierarchy/IDummyObjOneInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/types/flathierarchy/IDummyObjOneInitialiser.java new file mode 100644 index 0000000000..cdd150c0f7 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/types/flathierarchy/IDummyObjOneInitialiser.java @@ -0,0 +1,18 @@ +package cipm.consistency.initialisers.tests.dummy.types.flathierarchy; + +import cipm.consistency.initialisers.IInitialiser; + +/** + * A dummy initialiser interface with a default modification method taking + * multiple parameters, as well as the object to be modified. + * + * @author Alp Torac Genc + */ +public interface IDummyObjOneInitialiser extends IInitialiser { + @Override + public DummyObjOne instantiate(); + + public default boolean modificationMethodInInterface(DummyObjOne obj, Object param1, Object param2) { + return true; + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/types/flathierarchy/IDummyObjThreeInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/types/flathierarchy/IDummyObjThreeInitialiser.java new file mode 100644 index 0000000000..4ec1a796f4 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/types/flathierarchy/IDummyObjThreeInitialiser.java @@ -0,0 +1,14 @@ +package cipm.consistency.initialisers.tests.dummy.types.flathierarchy; + +import cipm.consistency.initialisers.IInitialiser; + +/** + * A dummy initialiser interface that introduces nothing new. It only overrides + * the return type of {@link IDummyObjThreeInitialiser#instantiate()}. + * + * @author Alp Torac Genc + */ +public interface IDummyObjThreeInitialiser extends IInitialiser { + @Override + public DummyObjThree instantiate(); +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/types/flathierarchy/IDummyObjTwoInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/types/flathierarchy/IDummyObjTwoInitialiser.java new file mode 100644 index 0000000000..c4849e9384 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/types/flathierarchy/IDummyObjTwoInitialiser.java @@ -0,0 +1,14 @@ +package cipm.consistency.initialisers.tests.dummy.types.flathierarchy; + +import cipm.consistency.initialisers.IInitialiser; + +/** + * A dummy initialiser interface that introduces nothing new. It only overrides + * the return type of {@link IDummyObjThreeInitialiser#instantiate()}. + * + * @author Alp Torac Genc + */ +public interface IDummyObjTwoInitialiser extends IInitialiser { + @Override + public DummyObjTwo instantiate(); +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/types/flathierarchy/package-info.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/types/flathierarchy/package-info.java new file mode 100644 index 0000000000..41bc7f2487 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/types/flathierarchy/package-info.java @@ -0,0 +1,11 @@ +/** + * This package contains dummy objects without members and one initialiser for + * each of those objects (both an initialiser class and an initialiser + * interface). Neither the dummy objects nor their initialisers depend on one + * another.
+ *
+ * The constructs defined within this package can be used to test interactions + * of some {@link IInitialiser} methods with objects/initialisers that are + * independent of one another. + */ +package cipm.consistency.initialisers.tests.dummy.types.flathierarchy; \ No newline at end of file From 01d1b809a0dfd8f029c932c7aeabb684c34189ce Mon Sep 17 00:00:00 2001 From: AlpTorac Date: Fri, 25 Oct 2024 18:28:27 +0200 Subject: [PATCH 41/55] Implement dummy constructs for future tests Add a package that contains some dummy objects and their dummy initialisers, which extend one another. They are to be used in tests that verify some static methods of IInitialiser (the top-level initialiser interface). --- .../DummyAlternateInitialiser.java | 26 ++++++++++++++ .../DummyNonTerminalObj.java | 14 ++++++++ .../DummyNonTerminalObjInitialiser.java | 24 +++++++++++++ .../verticalhierarchy/DummyTerminalObj.java | 11 ++++++ .../DummyTerminalObjInitialiser.java | 24 +++++++++++++ .../verticalhierarchy/DummyTopLevelObj.java | 11 ++++++ .../DummyTopLevelObjInitialiser.java | 24 +++++++++++++ .../IDummyAlternateInitialiser.java | 16 +++++++++ .../IDummyNonTerminalObjInitialiser.java | 19 +++++++++++ .../IDummyTerminalObjInitialiser.java | 19 +++++++++++ .../IDummyTopLevelObjInitialiser.java | 19 +++++++++++ .../types/verticalhierarchy/package-info.java | 34 +++++++++++++++++++ 12 files changed, 241 insertions(+) create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/types/verticalhierarchy/DummyAlternateInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/types/verticalhierarchy/DummyNonTerminalObj.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/types/verticalhierarchy/DummyNonTerminalObjInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/types/verticalhierarchy/DummyTerminalObj.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/types/verticalhierarchy/DummyTerminalObjInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/types/verticalhierarchy/DummyTopLevelObj.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/types/verticalhierarchy/DummyTopLevelObjInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/types/verticalhierarchy/IDummyAlternateInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/types/verticalhierarchy/IDummyNonTerminalObjInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/types/verticalhierarchy/IDummyTerminalObjInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/types/verticalhierarchy/IDummyTopLevelObjInitialiser.java create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/types/verticalhierarchy/package-info.java diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/types/verticalhierarchy/DummyAlternateInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/types/verticalhierarchy/DummyAlternateInitialiser.java new file mode 100644 index 0000000000..4adca9a9e3 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/types/verticalhierarchy/DummyAlternateInitialiser.java @@ -0,0 +1,26 @@ +package cipm.consistency.initialisers.tests.dummy.types.verticalhierarchy; + +/** + * A dummy implementation of {@link IDummyAlternateInitialiser} that introduces + * nothing new. Serves as an alternative to + * {@link DummyNonTerminalObjInitialiser} (does not have any dependencies to + * it). + * + * @author Alp Torac Genc + */ +public class DummyAlternateInitialiser implements IDummyAlternateInitialiser { + @Override + public DummyAlternateInitialiser newInitialiser() { + return new DummyAlternateInitialiser(); + } + + @Override + public DummyNonTerminalObj instantiate() { + return new DummyNonTerminalObj(); + } + + @Override + public boolean initialise(Object obj) { + return true; + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/types/verticalhierarchy/DummyNonTerminalObj.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/types/verticalhierarchy/DummyNonTerminalObj.java new file mode 100644 index 0000000000..6d433a9178 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/types/verticalhierarchy/DummyNonTerminalObj.java @@ -0,0 +1,14 @@ +package cipm.consistency.initialisers.tests.dummy.types.verticalhierarchy; + +/** + * A dummy object in the middle of the type hierarchy defined within this + * package. Does not need initialisation.
+ *
+ * Can be instantiated by 2 separate initialisers: + * {@link DummyAlternateInitialiser} and {@link DummyNonTerminalObjInitialiser}. + * + * @author Alp Torac Genc + */ +public class DummyNonTerminalObj extends DummyTopLevelObj { + +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/types/verticalhierarchy/DummyNonTerminalObjInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/types/verticalhierarchy/DummyNonTerminalObjInitialiser.java new file mode 100644 index 0000000000..bf31e4a2ac --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/types/verticalhierarchy/DummyNonTerminalObjInitialiser.java @@ -0,0 +1,24 @@ +package cipm.consistency.initialisers.tests.dummy.types.verticalhierarchy; + +/** + * A dummy implementation of {@link IDummyNonTerminalObjInitialiser} that + * introduces nothing new. + * + * @author Alp Torac Genc + */ +public class DummyNonTerminalObjInitialiser implements IDummyNonTerminalObjInitialiser { + @Override + public DummyNonTerminalObjInitialiser newInitialiser() { + return new DummyNonTerminalObjInitialiser(); + } + + @Override + public DummyNonTerminalObj instantiate() { + return new DummyNonTerminalObj(); + } + + @Override + public boolean initialise(Object obj) { + return true; + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/types/verticalhierarchy/DummyTerminalObj.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/types/verticalhierarchy/DummyTerminalObj.java new file mode 100644 index 0000000000..d9bb5ad98a --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/types/verticalhierarchy/DummyTerminalObj.java @@ -0,0 +1,11 @@ +package cipm.consistency.initialisers.tests.dummy.types.verticalhierarchy; + +/** + * A dummy object at the bottom of the type hierarchy defined within this + * package. Does not need initialisation. + * + * @author Alp Torac Genc + */ +public class DummyTerminalObj extends DummyNonTerminalObj { + +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/types/verticalhierarchy/DummyTerminalObjInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/types/verticalhierarchy/DummyTerminalObjInitialiser.java new file mode 100644 index 0000000000..7e81765a19 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/types/verticalhierarchy/DummyTerminalObjInitialiser.java @@ -0,0 +1,24 @@ +package cipm.consistency.initialisers.tests.dummy.types.verticalhierarchy; + +/** + * A dummy implementation of {@link IDummyTerminalObjInitialiser} that + * introduces nothing new. + * + * @author Alp Torac Genc + */ +public class DummyTerminalObjInitialiser implements IDummyTerminalObjInitialiser { + @Override + public DummyTerminalObjInitialiser newInitialiser() { + return new DummyTerminalObjInitialiser(); + } + + @Override + public DummyTerminalObj instantiate() { + return new DummyTerminalObj(); + } + + @Override + public boolean initialise(Object obj) { + return true; + } +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/types/verticalhierarchy/DummyTopLevelObj.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/types/verticalhierarchy/DummyTopLevelObj.java new file mode 100644 index 0000000000..8d0b78839e --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/types/verticalhierarchy/DummyTopLevelObj.java @@ -0,0 +1,11 @@ +package cipm.consistency.initialisers.tests.dummy.types.verticalhierarchy; + +/** + * A dummy object at the top of the type hierarchy defined within this package. + * Does not need initialisation. + * + * @author Alp Torac Genc + */ +public class DummyTopLevelObj { + +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/types/verticalhierarchy/DummyTopLevelObjInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/types/verticalhierarchy/DummyTopLevelObjInitialiser.java new file mode 100644 index 0000000000..f3d31bfeda --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/types/verticalhierarchy/DummyTopLevelObjInitialiser.java @@ -0,0 +1,24 @@ +package cipm.consistency.initialisers.tests.dummy.types.verticalhierarchy; + +/** + * A dummy implementation of {@link IDummyTopLevelObjInitialiser} that + * introduces nothing new. + * + * @author Alp Torac Genc + */ +public class DummyTopLevelObjInitialiser implements IDummyTopLevelObjInitialiser { + @Override + public DummyTopLevelObjInitialiser newInitialiser() { + return new DummyTopLevelObjInitialiser(); + } + + @Override + public DummyTopLevelObj instantiate() { + return new DummyTopLevelObj(); + } + + @Override + public boolean initialise(Object obj) { + return true; + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/types/verticalhierarchy/IDummyAlternateInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/types/verticalhierarchy/IDummyAlternateInitialiser.java new file mode 100644 index 0000000000..c621ca4cea --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/types/verticalhierarchy/IDummyAlternateInitialiser.java @@ -0,0 +1,16 @@ +package cipm.consistency.initialisers.tests.dummy.types.verticalhierarchy; + +import cipm.consistency.initialisers.IInitialiser; + +/** + * A dummy {@link IInitialiser} interface that is in the middle of the type + * hierarchy defined within this package. It represents an alternative for + * {@link IDummyNonTerminalObjInitialiser} (does not have any dependencies to + * it). + * + * @author Alp Torac Genc + */ +public interface IDummyAlternateInitialiser extends IDummyTopLevelObjInitialiser { + @Override + public DummyNonTerminalObj instantiate(); +} \ No newline at end of file diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/types/verticalhierarchy/IDummyNonTerminalObjInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/types/verticalhierarchy/IDummyNonTerminalObjInitialiser.java new file mode 100644 index 0000000000..bbcae24f5f --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/types/verticalhierarchy/IDummyNonTerminalObjInitialiser.java @@ -0,0 +1,19 @@ +package cipm.consistency.initialisers.tests.dummy.types.verticalhierarchy; + +import cipm.consistency.initialisers.IInitialiser; + +/** + * A dummy {@link IInitialiser} interface that is in the middle of the type + * hierarchy defined within this package. Introduces one default modification + * method that only takes the object to be modified. + * + * @author Alp Torac Genc + */ +public interface IDummyNonTerminalObjInitialiser extends IDummyTopLevelObjInitialiser { + @Override + public DummyNonTerminalObj instantiate(); + + public default boolean someNonTerminalObjModificationMethod(DummyNonTerminalObj obj) { + return true; + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/types/verticalhierarchy/IDummyTerminalObjInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/types/verticalhierarchy/IDummyTerminalObjInitialiser.java new file mode 100644 index 0000000000..bffab357ae --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/types/verticalhierarchy/IDummyTerminalObjInitialiser.java @@ -0,0 +1,19 @@ +package cipm.consistency.initialisers.tests.dummy.types.verticalhierarchy; + +import cipm.consistency.initialisers.IInitialiser; + +/** + * A dummy {@link IInitialiser} interface that is at the bottom of the type + * hierarchy defined within this package. Introduces one default modification + * method that only takes the object to be modified. + * + * @author Alp Torac Genc + */ +public interface IDummyTerminalObjInitialiser extends IDummyNonTerminalObjInitialiser { + @Override + public DummyTerminalObj instantiate(); + + public default boolean someTerminalObjModificationMethod(DummyTerminalObj obj) { + return true; + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/types/verticalhierarchy/IDummyTopLevelObjInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/types/verticalhierarchy/IDummyTopLevelObjInitialiser.java new file mode 100644 index 0000000000..6ee199965d --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/types/verticalhierarchy/IDummyTopLevelObjInitialiser.java @@ -0,0 +1,19 @@ +package cipm.consistency.initialisers.tests.dummy.types.verticalhierarchy; + +import cipm.consistency.initialisers.IInitialiser; + +/** + * A dummy {@link IInitialiser} interface that is at the top of the type + * hierarchy defined within this package. Introduces one default modification + * method that only takes the object to be modified. + * + * @author Alp Torac Genc + */ +public interface IDummyTopLevelObjInitialiser extends IInitialiser { + @Override + public DummyTopLevelObj instantiate(); + + public default boolean someTopLevelObjModificationMethod(DummyTopLevelObj obj) { + return true; + } +} diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/types/verticalhierarchy/package-info.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/types/verticalhierarchy/package-info.java new file mode 100644 index 0000000000..83f17570ca --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/types/verticalhierarchy/package-info.java @@ -0,0 +1,34 @@ +/** + * This package contains dummy objects without members and initialisers for each + * of those objects (both an initialiser class and an initialiser interface). + * These objects and initialisers extend one another and form a type hierarchy. + *
+ *
+ * The constructs defined within this package can be used to test interactions + * of some {@link IInitialiser} methods with objects/initialisers that inherit + * from one another.
+ *
+ * The current layout of the type hierarchy for the objects is as follows: + *
    + *
  • {@link DummyTopLevelObj} + *
      + *
    • {@link DummyNonTerminalObj} + *
        + *
      • {@link DummyTerminalObj} + *
      + *
    + *
+ * The current layout of the type hierarchy for the initialisers is as follows + * (similar for initialiser interfaces): + *
    + *
  • {@link DummyTopLevelObjInitialiser} + *
      + *
    • {@link DummyNonTerminalObjInitialiser} + *
        + *
      • {@link DummyTerminalObjInitialiser} + *
      + *
    • {@link DummyAlternateInitialiser} + *
    + *
+ */ +package cipm.consistency.initialisers.tests.dummy.types.verticalhierarchy; \ No newline at end of file From 81b959a9445aeb5718f21657fe5f306b7b096781 Mon Sep 17 00:00:00 2001 From: AlpTorac Date: Fri, 25 Oct 2024 18:28:50 +0200 Subject: [PATCH 42/55] Add package commentary --- .../initialisers/tests/dummy/types/package-info.java | 11 +++++++++++ 1 file changed, 11 insertions(+) create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/types/package-info.java diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/types/package-info.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/types/package-info.java new file mode 100644 index 0000000000..0eaa0a1c70 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/types/package-info.java @@ -0,0 +1,11 @@ +/** + * This package, as well as its sub-packages, contain dummy object and + * initialiser implementations for tests. They can be used to test various + * methods of the {@link IInitialiser} interface, especially the static utility + * methods within.
+ *
+ * The sub-packages feature different initialiser (and object) hierarchies, so + * that the interaction of initialiser methods with different type hierarchies + * can be tested. + */ +package cipm.consistency.initialisers.tests.dummy.types; \ No newline at end of file From 61f228a356e62d789404e71e2b4fe12a0733fa0c Mon Sep 17 00:00:00 2001 From: AlpTorac Date: Fri, 25 Oct 2024 18:29:01 +0200 Subject: [PATCH 43/55] Add package commentary --- .../consistency/initialisers/tests/dummy/package-info.java | 5 +++++ 1 file changed, 5 insertions(+) create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/package-info.java diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/package-info.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/package-info.java new file mode 100644 index 0000000000..661d3e0147 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/dummy/package-info.java @@ -0,0 +1,5 @@ +/** + * Sub-packages contain various dummy elements designed to test interfaces and + * abstract classes used by initialisers. + */ +package cipm.consistency.initialisers.tests.dummy; \ No newline at end of file From cdb1d95acdef01d74efe2460d35ab9a887de5561 Mon Sep 17 00:00:00 2001 From: AlpTorac Date: Fri, 25 Oct 2024 18:30:36 +0200 Subject: [PATCH 44/55] Add tests for initialiser discovery via initialiser packages --- .../tests/InitialiserPackageTests.java | 199 ++++++++++++++++++ 1 file changed, 199 insertions(+) create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/InitialiserPackageTests.java diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/InitialiserPackageTests.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/InitialiserPackageTests.java new file mode 100644 index 0000000000..8f8db7ac7f --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/InitialiserPackageTests.java @@ -0,0 +1,199 @@ +package cipm.consistency.initialisers.tests; + +import java.util.Collection; + +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; + +import cipm.consistency.initialisers.IInitialiser; +import cipm.consistency.initialisers.IInitialiserPackage; +import cipm.consistency.initialisers.tests.dummy.packages.DummyAggregateInitialiserPackageOne; +import cipm.consistency.initialisers.tests.dummy.packages.DummyAggregateInitialiserPackageTwo; +import cipm.consistency.initialisers.tests.dummy.packages.DummyInitialiserA; +import cipm.consistency.initialisers.tests.dummy.packages.DummyInitialiserB; +import cipm.consistency.initialisers.tests.dummy.packages.DummyInitialiserC; +import cipm.consistency.initialisers.tests.dummy.packages.DummyInitialiserD; +import cipm.consistency.initialisers.tests.dummy.packages.DummyInitialiserE; +import cipm.consistency.initialisers.tests.dummy.packages.DummyInitialiserPackageA; +import cipm.consistency.initialisers.tests.dummy.packages.DummyInitialiserPackageB; +import cipm.consistency.initialisers.tests.dummy.packages.DummyInitialiserPackageCD; +import cipm.consistency.initialisers.tests.dummy.packages.DummyObjA; +import cipm.consistency.initialisers.tests.dummy.packages.DummyObjB; +import cipm.consistency.initialisers.tests.dummy.packages.DummyObjC; +import cipm.consistency.initialisers.tests.dummy.packages.DummyObjD; +import cipm.consistency.initialisers.tests.dummy.packages.DummyObjE; +import cipm.consistency.initialisers.tests.dummy.packages.DummyTopLevelInitialiserPackage; + +/** + * Contains tests for {@link IInitialiserPackage} over dummy elements. The aim + * is to ensure that initialiser discovery works on certain package structures + * as intended.
+ *
+ * Check the used dummy elements to get more information on their structure. + * + * @author Alp Torac Genc + */ +public class InitialiserPackageTests { + /** + * Assert that the initialiser for objects of type cls is/is not reachable from + * pac. + */ + private void assertInitialiserReachableFrom(Class cls, IInitialiserPackage pac, boolean isReachable) { + var init = pac.getInitialiserInstanceFor(cls); + var initCls = pac.getInitialiserInterfaceTypeFor(cls); + + Assertions.assertEquals(isReachable, init != null); + Assertions.assertEquals(isReachable, initCls != null); + + if (isReachable) { + Assertions.assertTrue(init.isInitialiserFor(cls)); + Assertions.assertTrue(init.getClass().equals(initCls)); + } + } + + /** + * A variant of + * {@link #assertInitialiserReachableFrom(Class, IInitialiserPackage, boolean)}, + * where the final parameter is true. + */ + private void assertInitialiserReachableFrom(Class cls, IInitialiserPackage pac) { + this.assertInitialiserReachableFrom(cls, pac, true); + } + + /** + * Asserts either that the expected elements are in col or that col contains + * elements of same types as expected elements. + */ + private void assertContentEqualsByClass(T[] expectedElems, Collection col) { + if (expectedElems != null) { + Assertions.assertEquals(expectedElems.length, col.size()); + + for (var elem : expectedElems) { + Assertions.assertTrue( + col.contains(elem) || col.stream().anyMatch((e) -> e.getClass().equals(elem.getClass()))); + } + } else { + Assertions.assertEquals(0, col.size()); + } + } + + /** + * Asserts that all inits are present within initInsCol (as instance) and in + * initClsCol (as class object). + */ + @SuppressWarnings("unchecked") + private void assertInitialiserContentEquals(IInitialiser[] inits, Collection initInsCol, + Collection> initClsCol) { + this.assertContentEqualsByClass(inits, initInsCol); + this.assertContentEqualsByClass(initInsCol.stream().map((i) -> i.getClass()).toArray(Class[]::new), initClsCol); + } + + /** + * Asserts that direct contents (i.e. contents of pac that can be found without + * discovering its sub-packages) of pac are equal to inits. + */ + private void assertDirectPackageContentEquals(IInitialiser[] inits, IInitialiserPackage pac) { + this.assertInitialiserContentEquals(inits, pac.getInitialiserInstances(), pac.getInitialiserInterfaceTypes()); + } + + /** + * Asserts that all contents accessible from pac are equal to inits. + */ + private void assertAllPackageContentEquals(IInitialiser[] inits, IInitialiserPackage pac) { + this.assertInitialiserContentEquals(inits, pac.getAllInitialiserInstances(), + pac.getAllInitialiserInterfaceTypes()); + } + + @Test + public void test_TopLevelPackage_Content() { + var pac = new DummyTopLevelInitialiserPackage(); + + this.assertDirectPackageContentEquals(null, pac); + this.assertAllPackageContentEquals(new IInitialiser[] { new DummyInitialiserA(), new DummyInitialiserB(), + new DummyInitialiserC(), new DummyInitialiserD(), new DummyInitialiserE() }, pac); + } + + @Test + public void test_AggregateOnePackage_Content() { + var pac = new DummyAggregateInitialiserPackageOne(); + + this.assertDirectPackageContentEquals(new IInitialiser[] { new DummyInitialiserE() }, pac); + this.assertAllPackageContentEquals( + new IInitialiser[] { new DummyInitialiserE(), new DummyInitialiserA(), new DummyInitialiserB() }, pac); + } + + @Test + public void test_AggregateTwoPackage_Content() { + var pac = new DummyAggregateInitialiserPackageTwo(); + + this.assertDirectPackageContentEquals(null, pac); + this.assertAllPackageContentEquals(new IInitialiser[] { new DummyInitialiserC(), new DummyInitialiserD() }, + pac); + } + + @Test + public void test_TopLevelPackage_GetInitialiser() { + var pac = new DummyTopLevelInitialiserPackage(); + + this.assertInitialiserReachableFrom(DummyObjA.class, pac); + this.assertInitialiserReachableFrom(DummyObjB.class, pac); + this.assertInitialiserReachableFrom(DummyObjC.class, pac); + this.assertInitialiserReachableFrom(DummyObjD.class, pac); + this.assertInitialiserReachableFrom(DummyObjE.class, pac); + } + + @Test + public void test_AggregateOnePackage_GetInitialiser() { + var pac = new DummyAggregateInitialiserPackageOne(); + + this.assertInitialiserReachableFrom(DummyObjA.class, pac); + this.assertInitialiserReachableFrom(DummyObjB.class, pac); + this.assertInitialiserReachableFrom(DummyObjC.class, pac, false); + this.assertInitialiserReachableFrom(DummyObjD.class, pac, false); + this.assertInitialiserReachableFrom(DummyObjE.class, pac); + } + + @Test + public void test_AggregateTwoPackage_GetInitialiser() { + var pac = new DummyAggregateInitialiserPackageTwo(); + + this.assertInitialiserReachableFrom(DummyObjA.class, pac, false); + this.assertInitialiserReachableFrom(DummyObjB.class, pac, false); + this.assertInitialiserReachableFrom(DummyObjC.class, pac); + this.assertInitialiserReachableFrom(DummyObjD.class, pac); + this.assertInitialiserReachableFrom(DummyObjE.class, pac, false); + } + + @Test + public void test_PackageA_GetInitialiser() { + var pac = new DummyInitialiserPackageA(); + + this.assertInitialiserReachableFrom(DummyObjA.class, pac); + this.assertInitialiserReachableFrom(DummyObjB.class, pac, false); + this.assertInitialiserReachableFrom(DummyObjC.class, pac, false); + this.assertInitialiserReachableFrom(DummyObjD.class, pac, false); + this.assertInitialiserReachableFrom(DummyObjE.class, pac, false); + } + + @Test + public void test_PackageB_GetInitialiser() { + var pac = new DummyInitialiserPackageB(); + + this.assertInitialiserReachableFrom(DummyObjA.class, pac, false); + this.assertInitialiserReachableFrom(DummyObjB.class, pac); + this.assertInitialiserReachableFrom(DummyObjC.class, pac, false); + this.assertInitialiserReachableFrom(DummyObjD.class, pac, false); + this.assertInitialiserReachableFrom(DummyObjE.class, pac, false); + } + + @Test + public void test_PackageCD_GetInitialiser() { + var pac = new DummyInitialiserPackageCD(); + + this.assertInitialiserReachableFrom(DummyObjA.class, pac, false); + this.assertInitialiserReachableFrom(DummyObjB.class, pac, false); + this.assertInitialiserReachableFrom(DummyObjC.class, pac); + this.assertInitialiserReachableFrom(DummyObjD.class, pac); + this.assertInitialiserReachableFrom(DummyObjE.class, pac, false); + } +} From 5e64400183629c66d9a812db19cbf99cc83b6f6d Mon Sep 17 00:00:00 2001 From: AlpTorac Date: Fri, 25 Oct 2024 18:31:18 +0200 Subject: [PATCH 45/55] Add tests for methods in IInitialiser --- .../initialisers/tests/IInitialiserTests.java | 353 ++++++++++++++++++ 1 file changed, 353 insertions(+) create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/IInitialiserTests.java diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/IInitialiserTests.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/IInitialiserTests.java new file mode 100644 index 0000000000..17c822ab98 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/IInitialiserTests.java @@ -0,0 +1,353 @@ +package cipm.consistency.initialisers.tests; + +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; + +import cipm.consistency.initialisers.IInitialiser; +import cipm.consistency.initialisers.tests.dummy.types.DummyModifiableObjInitialiser; +import cipm.consistency.initialisers.tests.dummy.types.IDummyInitialiserWithoutMethods; +import cipm.consistency.initialisers.tests.dummy.types.flathierarchy.DummyObjFour; +import cipm.consistency.initialisers.tests.dummy.types.flathierarchy.DummyObjFourInitialiser; +import cipm.consistency.initialisers.tests.dummy.types.flathierarchy.DummyObjOne; +import cipm.consistency.initialisers.tests.dummy.types.flathierarchy.DummyObjOneInitialiser; +import cipm.consistency.initialisers.tests.dummy.types.flathierarchy.DummyObjThree; +import cipm.consistency.initialisers.tests.dummy.types.flathierarchy.DummyObjThreeInitialiser; +import cipm.consistency.initialisers.tests.dummy.types.flathierarchy.DummyObjTwo; +import cipm.consistency.initialisers.tests.dummy.types.flathierarchy.DummyObjTwoInitialiser; +import cipm.consistency.initialisers.tests.dummy.types.flathierarchy.IDummyObjFourInitialiser; +import cipm.consistency.initialisers.tests.dummy.types.flathierarchy.IDummyObjOneInitialiser; +import cipm.consistency.initialisers.tests.dummy.types.flathierarchy.IDummyObjThreeInitialiser; +import cipm.consistency.initialisers.tests.dummy.types.flathierarchy.IDummyObjTwoInitialiser; +import cipm.consistency.initialisers.tests.dummy.types.verticalhierarchy.DummyAlternateInitialiser; +import cipm.consistency.initialisers.tests.dummy.types.verticalhierarchy.DummyNonTerminalObj; +import cipm.consistency.initialisers.tests.dummy.types.verticalhierarchy.DummyNonTerminalObjInitialiser; +import cipm.consistency.initialisers.tests.dummy.types.verticalhierarchy.DummyTerminalObj; +import cipm.consistency.initialisers.tests.dummy.types.verticalhierarchy.DummyTerminalObjInitialiser; +import cipm.consistency.initialisers.tests.dummy.types.verticalhierarchy.DummyTopLevelObj; +import cipm.consistency.initialisers.tests.dummy.types.verticalhierarchy.DummyTopLevelObjInitialiser; +import cipm.consistency.initialisers.tests.dummy.types.verticalhierarchy.IDummyAlternateInitialiser; + +/** + * Contains tests for (static/default) methods implemented in + * {@link IInitialiser} + * + * @author Alp Torac Genc + */ +public class IInitialiserTests { + /** + * Ensures that + * {@link IInitialiser#doMultipleModifications(Object, Object[], java.util.function.BiFunction)} + * throws null pointer exceptions if the object to be modified is null. + */ + @Test + public void test_doMultipleModifications_NullObject() { + var init = new DummyModifiableObjInitialiser(); + Assertions.assertThrows(NullPointerException.class, () -> { + init.addAttrs(null, new Object[] { 1 }); + }); + } + + /** + * Check whether + * {@link IInitialiser#doMultipleModifications(Object, Object[], java.util.function.BiFunction)} + * throws exceptions, if null is passed as array of modification parameters. + * Also ensures that true is returned. + */ + @Test + public void test_doMultipleModifications_NullModificationParams() { + var init = new DummyModifiableObjInitialiser(); + Assertions.assertTrue(init.addAttrs(init.instantiate(), null)); + } + + /** + * Check whether + * {@link IInitialiser#doMultipleModifications(Object, Object[], java.util.function.BiFunction)} + * throws exceptions, if array of modification parameters is empty. Also ensures + * that true is returned. + */ + @Test + public void test_doMultipleModifications_EmptyModificationParams() { + var init = new DummyModifiableObjInitialiser(); + Assertions.assertTrue(init.addAttrs(init.instantiate(), new Object[] {})); + } + + /** + * Check whether + * {@link IInitialiser#doMultipleModifications(Object, Object[], java.util.function.BiFunction)} + * works for 1 proper modification parameter (passed via an array of size 1). + */ + @Test + public void test_doMultipleModifications_SingleModification_Success() { + var init = new DummyModifiableObjInitialiser(); + Assertions.assertTrue(init.addAttrs(init.instantiate(), new Object[] { 1 })); + } + + /** + * Check whether + * {@link IInitialiser#doMultipleModifications(Object, Object[], java.util.function.BiFunction)} + * works for 1 inappropriate modification parameter (passed via an array of size + * 1). + */ + @Test + public void test_doMultipleModifications_SingleModification_Failure() { + var init = new DummyModifiableObjInitialiser(); + Assertions.assertFalse(init.addAttrs(init.instantiate(), new Object[] { null })); + } + + /** + * Check whether + * {@link IInitialiser#doMultipleModifications(Object, Object[], java.util.function.BiFunction)} + * works for its intended use case (i.e. summarising multiple modification + * method calls) with proper parameters. + */ + @Test + public void test_doMultipleModifications_MultipleModifications_Success() { + var init = new DummyModifiableObjInitialiser(); + Assertions.assertTrue(init.addAttrs(init.instantiate(), new Object[] { 1, 2, 3 })); + } + + /** + * Check whether + * {@link IInitialiser#doMultipleModifications(Object, Object[], java.util.function.BiFunction)} + * successfully performs modifications till it fails. + */ + @Test + public void test_doMultipleModifications_MultipleModifications_LateFailure() { + var init = new DummyModifiableObjInitialiser(); + var obj = init.instantiate(); + var attr1 = Integer.valueOf(1); + var attr2 = Integer.valueOf(2); + + Assertions.assertFalse(init.addAttrs(obj, new Object[] { attr1, attr2, attr1 })); + var attrs = obj.getAttrs(); + Assertions.assertTrue(attrs.contains(attr1)); + Assertions.assertTrue(attrs.contains(attr2)); + Assertions.assertEquals(2, attrs.size()); + } + + /** + * Check whether + * {@link IInitialiser#doMultipleModifications(Object, Object[], java.util.function.BiFunction)} + * fails early, if a modification fails, which is neither performed at the start + * nor at the end. + */ + @Test + public void test_doMultipleModifications_MultipleModifications_FailEarly() { + var init = new DummyModifiableObjInitialiser(); + var obj = init.instantiate(); + var attr1 = Integer.valueOf(1); + var attr2 = Integer.valueOf(2); + + Assertions.assertFalse(init.addAttrs(obj, new Object[] { attr1, attr1, attr2 })); + var attrs = obj.getAttrs(); + Assertions.assertTrue(attrs.contains(attr1)); + Assertions.assertFalse(attrs.contains(attr2)); + Assertions.assertEquals(1, attrs.size()); + } + + /** + * Checks whether {@link IInitialiser#declaresModificationMethods(Class)} + * circumvents null pointer exceptions. + */ + @Test + public void test_DeclaresModificationMethods_NullClass() { + Class cls = null; + Assertions.assertFalse(IInitialiser.declaresModificationMethods(cls)); + } + + /** + * Checks whether {@link IInitialiser#declaresModificationMethods(IInitialiser)} + * circumvents null pointer exceptions. + */ + @Test + public void test_DeclaresModificationMethods_NullInitialiser() { + IInitialiser init = null; + Assertions.assertFalse(IInitialiser.declaresModificationMethods(init)); + } + + /** + * Check whether a modification method implemented only in the interface of an + * initialiser can be found. + */ + @Test + public void test_DeclaresModificationMethods_InInterface() { + var init = new DummyObjOneInitialiser(); + Assertions.assertFalse(init.declaresModificationMethods()); + Assertions.assertFalse(IInitialiser.declaresModificationMethods(init)); + Assertions.assertTrue(IInitialiser.declaresModificationMethods(IDummyObjOneInitialiser.class)); + } + + /** + * Check whether a modification method implemented only in the concrete class of + * an initialiser can be found. + */ + @Test + public void test_DeclaresModificationMethods_InClass() { + var init = new DummyObjTwoInitialiser(); + Assertions.assertTrue(init.declaresModificationMethods()); + Assertions.assertTrue(IInitialiser.declaresModificationMethods(init)); + Assertions.assertFalse(IInitialiser.declaresModificationMethods(IDummyObjTwoInitialiser.class)); + } + + /** + * Check whether initialiser types with neither direct nor overridden methods + * cause exceptions. + */ + @Test + public void test_DeclaresModificationMethods_NoMethods() { + Assertions.assertFalse(IInitialiser.declaresModificationMethods(IDummyInitialiserWithoutMethods.class)); + } + + /** + * Check whether initialisers with only an overridden instantiate() method are + * detected as initialisers without modification methods. + */ + @Test + public void test_DeclaresModificationMethods_NoAdditionalMethods() { + var init = new DummyObjThreeInitialiser(); + Assertions.assertFalse(init.declaresModificationMethods()); + Assertions.assertFalse(IInitialiser.declaresModificationMethods(init)); + Assertions.assertFalse(IInitialiser.declaresModificationMethods(IDummyObjThreeInitialiser.class)); + } + + /** + * Check whether initialisers with no additional modification methods can be + * detected, even if they do have other methods. + */ + @Test + public void test_DeclaresModificationMethods_NoModificationMethods() { + var init = new DummyObjFourInitialiser(); + Assertions.assertFalse(init.declaresModificationMethods()); + Assertions.assertFalse(IInitialiser.declaresModificationMethods(init)); + Assertions.assertFalse(IInitialiser.declaresModificationMethods(IDummyObjFourInitialiser.class)); + } + + /** + * Check whether initialisers with no direct modification methods are detected, + * i.e. initialisers that do inherit modification methods yet do not implement + * any in their own body. + */ + @Test + public void test_DeclaresModificationMethods_NoDirectModificationMethods() { + var init = new DummyAlternateInitialiser(); + Assertions.assertFalse(init.declaresModificationMethods()); + Assertions.assertFalse(IInitialiser.declaresModificationMethods(init)); + Assertions.assertFalse(IInitialiser.declaresModificationMethods(IDummyAlternateInitialiser.class)); + } + + /** + * Check whether initialiser types with neither direct nor overridden methods + * cause exceptions. + */ + @Test + public void test_IsInitialiserFor_NoMethods() { + Assertions.assertFalse( + IInitialiser.isInitialiserFor(IDummyInitialiserWithoutMethods.class, DummyNonTerminalObj.class)); + Assertions.assertFalse(IInitialiser.isInitialiserFor(IDummyInitialiserWithoutMethods.class, null)); + } + + /** + * Check whether an initialiser, whose name does not contain the name of the + * object class it is supposed to instantiate, is still detected as its + * initialiser, if it has a proper instantiation method. + */ + @Test + public void test_IsInitialiserFor_NameMismatch() { + Assertions.assertTrue(new DummyAlternateInitialiser().isInitialiserFor(DummyNonTerminalObj.class)); + Assertions + .assertTrue(IInitialiser.isInitialiserFor(IDummyAlternateInitialiser.class, DummyNonTerminalObj.class)); + } + + /** + * Checks whether {@link IInitialiser#isInitialiserFor(Class, Class)} + * circumvents null pointer exceptions, which could be caused by the first + * parameter being null. + */ + @Test + public void test_IsInitialiserFor_NullInitialiserClass() { + Class initCls = null; + Assertions.assertFalse(IInitialiser.isInitialiserFor(initCls, DummyNonTerminalObj.class)); + } + + /** + * Checks whether {@link IInitialiser#isInitialiserFor(IInitialiser, Class)} + * circumvents null pointer exceptions, which could be caused by the first + * parameter being null. + */ + @Test + public void test_IsInitialiserFor_NullInitialiser() { + IInitialiser init = null; + Assertions.assertFalse(IInitialiser.isInitialiserFor(init, DummyNonTerminalObj.class)); + } + + /** + * Checks whether isInitialiserFor methods circumvent null pointer exceptions, + * which could be caused by the class object parameter being null. + */ + @Test + public void test_IsInitialiserFor_NullClass() { + Class cls = null; + + Assertions.assertFalse(IInitialiser.isInitialiserFor(new DummyObjOneInitialiser(), cls)); + Assertions.assertFalse(IInitialiser.isInitialiserFor(DummyObjOneInitialiser.class, cls)); + Assertions.assertFalse(new DummyObjOneInitialiser().isInitialiserFor(cls)); + } + + /** + * Check whether initialisers that are meant to instantiate certain objects can + * be detected, where the said objects (and their initialisers) have no type + * hierarchy. + */ + @SuppressWarnings("unchecked") + @Test + public void test_IsInitialiserFor_NoTypeHierarchy() { + var objClss = new Class[] { DummyObjOne.class, DummyObjTwo.class, DummyObjThree.class, DummyObjFour.class }; + var initInterfaceClss = new Class[] { IDummyObjOneInitialiser.class, IDummyObjTwoInitialiser.class, + IDummyObjThreeInitialiser.class, IDummyObjFourInitialiser.class }; + var initClss = new Class[] { DummyObjOneInitialiser.class, DummyObjTwoInitialiser.class, + DummyObjThreeInitialiser.class, DummyObjFourInitialiser.class }; + var inits = new IInitialiser[] { new DummyObjOneInitialiser(), new DummyObjTwoInitialiser(), + new DummyObjThreeInitialiser(), new DummyObjFourInitialiser() }; + + // Test over all the classes given above, in order to make sure that + // other methods implemented in the classes/interfaces do not cause issues + for (int i = 0; i < objClss.length; i++) { + var cInitInterfaceCls = initInterfaceClss[i]; + var cInitClss = initClss[i]; + var cInit = inits[i]; + + for (int j = 0; j < objClss.length; j++) { + var cObjCls = objClss[j]; + + Assertions.assertEquals(i == j, cInit.isInitialiserFor(cObjCls)); + Assertions.assertEquals(i == j, IInitialiser.isInitialiserFor(cInit, cObjCls)); + Assertions.assertEquals(i == j, IInitialiser.isInitialiserFor(cInitClss, cObjCls)); + Assertions.assertEquals(i == j, IInitialiser.isInitialiserFor(cInitInterfaceCls, cObjCls)); + } + } + } + + /** + * Check whether initialisers within a type hierarchy are correctly matched to + * the object class they are supposed to instantiate. + */ + @Test + public void test_IsInitialiserFor_WithTypeHierarchy() { + var tlInit = new DummyTopLevelObjInitialiser(); + var ntInit = new DummyNonTerminalObjInitialiser(); + var tInit = new DummyTerminalObjInitialiser(); + + Assertions.assertFalse(tlInit.isInitialiserFor(DummyTerminalObj.class)); + Assertions.assertFalse(tlInit.isInitialiserFor(DummyNonTerminalObj.class)); + Assertions.assertTrue(tlInit.isInitialiserFor(DummyTopLevelObj.class)); + + Assertions.assertFalse(ntInit.isInitialiserFor(DummyTerminalObj.class)); + Assertions.assertTrue(ntInit.isInitialiserFor(DummyNonTerminalObj.class)); + Assertions.assertFalse(ntInit.isInitialiserFor(DummyTopLevelObj.class)); + + Assertions.assertTrue(tInit.isInitialiserFor(DummyTerminalObj.class)); + Assertions.assertFalse(tInit.isInitialiserFor(DummyNonTerminalObj.class)); + Assertions.assertFalse(tInit.isInitialiserFor(DummyTopLevelObj.class)); + + } +} From 427e7bdad7c7b0da8a25ec9415a126176b9806c3 Mon Sep 17 00:00:00 2001 From: AlpTorac Date: Fri, 25 Oct 2024 18:31:49 +0200 Subject: [PATCH 46/55] Add tests for initialiser adaptation --- .../tests/InitialiserBaseTests.java | 446 ++++++++++++++++++ 1 file changed, 446 insertions(+) create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/InitialiserBaseTests.java diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/InitialiserBaseTests.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/InitialiserBaseTests.java new file mode 100644 index 0000000000..d7d68d6135 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/InitialiserBaseTests.java @@ -0,0 +1,446 @@ +package cipm.consistency.initialisers.tests; + +import java.util.ArrayList; + +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; + +import cipm.consistency.initialisers.IInitialiserAdapterStrategy; +import cipm.consistency.initialisers.IInitialiserBase; +import cipm.consistency.initialisers.tests.dummy.packages.DummyInitialiserA; +import cipm.consistency.initialisers.tests.dummy.packages.DummyInitialiserC; +import cipm.consistency.initialisers.tests.dummy.packages.ObjAInitStrat; +import cipm.consistency.initialisers.tests.dummy.packages.ObjCFirstInitStepStrat; +import cipm.consistency.initialisers.tests.dummy.packages.ObjCSecondInitStepStrat; + +/** + * Contains tests for {@link IInitialiserBase} over dummy elements, with a focus + * on the interaction with {@link IInitialiserAdapterStrategy}. + * + * @author Alp Torac Genc + */ +public class InitialiserBaseTests { + /** + * Shortcut for {@code assertAdapted(init, true)} + */ + private void assertAdapted(IInitialiserBase init) { + this.assertAdapted(init, true); + } + + /** + * Assert that the given initialiser is being adapted by at least one adaptation + * strategy. + */ + private void assertAdapted(IInitialiserBase init, boolean isAdapted) { + Assertions.assertEquals(init.getAdaptingStrategyCount(), init.getAdaptingStrategies().size()); + Assertions.assertEquals(isAdapted, init.isAdapted()); + Assertions.assertEquals(isAdapted, init.getAdaptingStrategyCount() > 0); + } + + /** + * Assert that all given adaptation strategies are adapting the given + * initialiser. + */ + private void assertAdaptedBy(IInitialiserAdapterStrategy[] strats, IInitialiserBase init) { + if (strats != null && strats.length > 0) { + var adaptingStrats = init.getAdaptingStrategies(); + Assertions.assertEquals(strats.length, adaptingStrats.size()); + this.assertAdapted(init); + for (var strat : strats) { + Assertions.assertTrue(adaptingStrats.contains(strat)); + } + } else { + this.assertAdapted(init, false); + } + } + + /** + * Add the given adaptation strategy to the given initialiser and make the + * necessary assertions before and after insertion. + */ + private void addAndAssertAdded(IInitialiserAdapterStrategy strat, IInitialiserBase init) { + var priorStrats = init.getAdaptingStrategies(); + Assertions.assertFalse(priorStrats.contains(strat)); + + var allStrats = new ArrayList(); + allStrats.addAll(priorStrats); + this.assertAdaptedBy(allStrats.toArray(IInitialiserAdapterStrategy[]::new), init); + + allStrats.add(strat); + init.addAdaptingStrategy(strat); + this.assertAdaptedBy(allStrats.toArray(IInitialiserAdapterStrategy[]::new), init); + + Assertions.assertEquals(priorStrats.size() + 1, init.getAdaptingStrategyCount()); + } + + /** + * Test adding a non-empty array of adaptation strategies to an initialiser + * during its construction. + */ + @Test + public void test_AddStrategiesToInitAtConstruction() { + var stratOne = new ObjCFirstInitStepStrat(); + var stratTwo = new ObjCSecondInitStepStrat(); + var stratArr = new IInitialiserAdapterStrategy[] { stratOne, stratTwo }; + + var init = new DummyInitialiserC(stratArr); + + this.assertAdaptedBy(stratArr, init); + } + + /** + * Test adding an empty array of adaptation strategies to an initialiser during + * its construction. + */ + @Test + public void test_AddStrategiesToInitAtConstruction_EmptyArray() { + var stratArr = new IInitialiserAdapterStrategy[] {}; + + var init = new DummyInitialiserC(stratArr); + + this.assertAdaptedBy(stratArr, init); + } + + /** + * Test adding a null array of adaptation strategies to an initialiser during + * its construction. + */ + @Test + public void test_AddStrategiesToInitAtConstruction_NullArray() { + var init = new DummyInitialiserC(null); + this.assertAdapted(init, false); + } + + /** + * Test adding adaptation strategies to an initialiser. Strategies are added one + * at a time. + */ + @Test + public void test_AddStrategy_OneAtATime() { + var init = new DummyInitialiserA(); + + this.assertAdapted(init, false); + + var stratOne = new ObjAInitStrat(); + init.addAdaptingStrategy(stratOne); + this.assertAdaptedBy(new IInitialiserAdapterStrategy[] { stratOne }, init); + + var stratTwo = new ObjAInitStrat(); + init.addAdaptingStrategy(stratTwo); + this.assertAdaptedBy(new IInitialiserAdapterStrategy[] { stratOne, stratTwo }, init); + } + + /** + * Test adding adaptation strategies to an initialiser. A strategy array is + * added to the initialiser. + */ + @Test + public void test_AddStrategy_StrategyArray() { + var init = new DummyInitialiserA(); + this.assertAdapted(init, false); + + var stratOne = new ObjAInitStrat(); + var stratTwo = new ObjAInitStrat(); + var stratArr = new IInitialiserAdapterStrategy[] { stratOne, stratTwo }; + + init.addAdaptingStrategies(stratArr); + this.assertAdaptedBy(stratArr, init); + } + + /** + * Test adding adaptation strategies to an initialiser. A strategy array with a + * null element is added to the initialiser. + */ + @Test + public void test_AddStrategy_StrategyArrayWithNull() { + var init = new DummyInitialiserA(); + this.assertAdapted(init, false); + + var stratOne = new ObjAInitStrat(); + var stratTwo = new ObjAInitStrat(); + var stratArr = new IInitialiserAdapterStrategy[] { stratOne, null, stratTwo }; + + init.addAdaptingStrategies(stratArr); + this.assertAdaptedBy(new IInitialiserAdapterStrategy[] { stratOne, stratTwo }, init); + } + + /** + * Test adding an empty array of adaptation strategies to an initialiser. + */ + @Test + public void test_AddStrategy_EmptyArray() { + var init = new DummyInitialiserA(); + this.assertAdapted(init, false); + + var stratArr = new IInitialiserAdapterStrategy[] {}; + + init.addAdaptingStrategies(stratArr); + this.assertAdapted(init, false); + } + + /** + * Test adding a null array (of adaptation strategies) to an initialiser. + */ + @Test + public void test_AddStrategy_NullArray() { + var init = new DummyInitialiserA(); + this.assertAdapted(init, false); + + init.addAdaptingStrategies(null); + this.assertAdapted(init, false); + } + + /** + * Test removing (existing) adaptation strategies from an initialiser. + */ + @Test + public void test_RemoveAdapterStrategy() { + var init = new DummyInitialiserA(); + var stratOne = new ObjAInitStrat(); + var stratTwo = new ObjAInitStrat(); + init.addAdaptingStrategy(stratOne); + init.addAdaptingStrategy(stratTwo); + this.assertAdaptedBy(new IInitialiserAdapterStrategy[] { stratOne, stratTwo }, init); + + init.removeAdaptingStrategy(stratOne); + this.assertAdaptedBy(new IInitialiserAdapterStrategy[] { stratTwo }, init); + + init.removeAdaptingStrategy(stratTwo); + this.assertAdaptedBy(null, init); + } + + /** + * Test removing a non-existent adaptation strategy from an initialiser. + */ + @Test + public void test_RemoveAdapterStrategy_NonExistent() { + var init = new DummyInitialiserA(); + var strat = new ObjAInitStrat(); + + this.assertAdapted(init, false); + init.removeAdaptingStrategy(strat); + this.assertAdapted(init, false); + } + + /** + * Test removing a non-existent adaptation strategy from an initialiser. + */ + @Test + public void test_RemoveAdapterStrategy_NullCheck() { + var init = new DummyInitialiserA(); + + this.assertAdapted(init, false); + init.removeAdaptingStrategy(null); + this.assertAdapted(init, false); + } + + /** + * Test removing an existing adaptation strategy from an initialiser twice. + */ + @Test + public void test_RemoveAdapterStrategy_Twice() { + var init = new DummyInitialiserA(); + var stratOne = new ObjAInitStrat(); + var stratTwo = new ObjAInitStrat(); + init.addAdaptingStrategy(stratOne); + init.addAdaptingStrategy(stratTwo); + this.assertAdaptedBy(new IInitialiserAdapterStrategy[] { stratOne, stratTwo }, init); + + init.removeAdaptingStrategy(stratOne); + this.assertAdaptedBy(new IInitialiserAdapterStrategy[] { stratTwo }, init); + var stratsAfterFirstRemoval = init.getAdaptingStrategies(); + + init.removeAdaptingStrategy(stratOne); + this.assertAdaptedBy(new IInitialiserAdapterStrategy[] { stratTwo }, init); + + // Make sure that all other adapting initialisers are still there after the + // second removal attempt + Assertions.assertTrue(init.getAdaptingStrategies().containsAll(stratsAfterFirstRemoval)); + } + + /** + * Test cleaning all adaptation strategies from an initialiser, i.e. removing + * all such strategies at once. + */ + @Test + public void test_CleanAdapterStrategy() { + var init = new DummyInitialiserA(); + var stratOne = new ObjAInitStrat(); + var stratTwo = new ObjAInitStrat(); + init.addAdaptingStrategy(stratOne); + init.addAdaptingStrategy(stratTwo); + this.assertAdaptedBy(new IInitialiserAdapterStrategy[] { stratOne, stratTwo }, init); + + init.cleanAdaptingStrategy(); + this.assertAdapted(init, false); + } + + /** + * Test new initialiser creation with adapting strategies, where the original + * initialiser has no adapting strategies. + */ + @Test + public void test_NewInitialiserWithStrategy_NoStrategies() { + var init = new DummyInitialiserC(); + this.assertAdapted(init, false); + var newInit = init.newInitialiserWithStrategies(); + this.assertAdapted(newInit, false); + + Assertions.assertFalse(init == newInit); + } + + /** + * Test new initialiser creation with adapting strategies. + */ + @Test + public void test_NewInitialiserWithStrategy() { + var init = new DummyInitialiserC(); + var stratOne = new ObjCFirstInitStepStrat(); + var stratTwo = new ObjCSecondInitStepStrat(); + + this.addAndAssertAdded(stratOne, init); + this.addAndAssertAdded(stratTwo, init); + this.assertAdapted(init, true); + + var newInit = init.newInitialiserWithStrategies(); + this.assertAdapted(newInit, true); + + Assertions.assertFalse(init == newInit); + Assertions.assertFalse(newInit.getAdaptingStrategies().contains(stratOne)); + Assertions.assertFalse(newInit.getAdaptingStrategies().contains(stratTwo)); + } + + /** + * Test new initialiser creation without adapting strategies, even though the + * original initialiser has adapting strategies. + */ + @Test + public void test_NewInitialiser_WithStrategies() { + var init = new DummyInitialiserC(); + var stratOne = new ObjCFirstInitStepStrat(); + var stratTwo = new ObjCSecondInitStepStrat(); + + this.addAndAssertAdded(stratOne, init); + this.addAndAssertAdded(stratTwo, init); + this.assertAdapted(init, true); + + var newInit = init.newInitialiser(); + this.assertAdapted(newInit, false); + + Assertions.assertFalse(init == newInit); + } + + /** + * Test initialising an object generated from an initialiser without adapting + * it. + */ + @Test + public void test_Initialisation_WithoutStrategy() { + var init = new DummyInitialiserC(); + var obj = init.instantiate(); + this.assertAdapted(init, false); + // No initialisation steps to fail here, so true + Assertions.assertTrue(init.initialise(obj)); + + Assertions.assertFalse(obj.isInitialisationStepOneDone()); + Assertions.assertFalse(obj.isInitialisationStepTwoDone()); + } + + /** + * Test initialising an object generated from an initialiser without adapting it + * all the way. + */ + @Test + public void test_SingleInitialisation_PartialSuccess() { + var init = new DummyInitialiserC(); + var obj = init.instantiate(); + + this.addAndAssertAdded(new ObjCFirstInitStepStrat(), init); + Assertions.assertTrue(init.initialise(obj)); + Assertions.assertTrue(obj.isInitialisationStepOneDone()); + Assertions.assertFalse(obj.isInitialisationStepTwoDone()); + } + + /** + * Test initialising an object generated from an initialiser with a failing + * adaptation strategy. + */ + @Test + public void test_SingleInitialisation_Failure() { + var init = new DummyInitialiserC(); + var obj = init.instantiate(); + + this.addAndAssertAdded(new ObjCFirstInitStepStrat(false), init); + Assertions.assertFalse(init.initialise(obj)); + Assertions.assertFalse(obj.isInitialisationStepOneDone()); + Assertions.assertFalse(obj.isInitialisationStepTwoDone()); + } + + /** + * Test initialising an object generated from an adapted initialiser, where the + * first adaptation strategy succeeds but the second one fails. + */ + @Test + public void test_SingleInitialisation_LateConflict() { + var init = new DummyInitialiserC(); + var obj = init.instantiate(); + + this.addAndAssertAdded(new ObjCFirstInitStepStrat(), init); + this.addAndAssertAdded(new ObjCSecondInitStepStrat(false), init); + Assertions.assertFalse(init.initialise(obj)); + Assertions.assertTrue(obj.isInitialisationStepOneDone()); + Assertions.assertFalse(obj.isInitialisationStepTwoDone()); + } + + /** + * Test initialising an object generated from an adapted initialiser, where the + * first adaptation strategy fails and stops the second one from working, even + * though the second one would succeed. + */ + @Test + public void test_SingleInitialisation_FailEarlyAtConflict() { + var init = new DummyInitialiserC(); + var obj = init.instantiate(); + + this.addAndAssertAdded(new ObjCFirstInitStepStrat(false), init); + this.addAndAssertAdded(new ObjCFirstInitStepStrat(), init); + Assertions.assertFalse(init.initialise(obj)); + Assertions.assertFalse(obj.isInitialisationStepOneDone()); + Assertions.assertFalse(obj.isInitialisationStepTwoDone()); + } + + /** + * Test initialising an object generated from a properly adapted initialiser. + */ + @Test + public void test_SingleInitialisation_AtOnce() { + var init = new DummyInitialiserC(); + var obj = init.instantiate(); + + this.addAndAssertAdded(new ObjCFirstInitStepStrat(), init); + this.addAndAssertAdded(new ObjCSecondInitStepStrat(), init); + Assertions.assertTrue(init.initialise(obj)); + Assertions.assertTrue(obj.isInitialisationStepOneDone()); + Assertions.assertTrue(obj.isInitialisationStepTwoDone()); + } + + /** + * Test initialising an object generated from an initialiser but add necessary + * adaptation strategies over multiple steps. + */ + @Test + public void test_MultipleInitialisations() { + var init = new DummyInitialiserC(); + var obj = init.instantiate(); + + this.addAndAssertAdded(new ObjCFirstInitStepStrat(), init); + Assertions.assertTrue(init.initialise(obj)); + Assertions.assertTrue(obj.isInitialisationStepOneDone()); + Assertions.assertFalse(obj.isInitialisationStepTwoDone()); + + this.addAndAssertAdded(new ObjCSecondInitStepStrat(), init); + Assertions.assertTrue(init.initialise(obj)); + Assertions.assertTrue(obj.isInitialisationStepOneDone()); + Assertions.assertTrue(obj.isInitialisationStepTwoDone()); + } +} From 32eb7cd9f488f32bc00d8080cb33b972708e6448 Mon Sep 17 00:00:00 2001 From: AlpTorac Date: Fri, 25 Oct 2024 18:31:58 +0200 Subject: [PATCH 47/55] Add package commentary --- .../cipm/consistency/initialisers/tests/package-info.java | 8 ++++++++ 1 file changed, 8 insertions(+) create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/package-info.java diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/package-info.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/package-info.java new file mode 100644 index 0000000000..87d99130a4 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/tests/package-info.java @@ -0,0 +1,8 @@ +/** + * Contains tests for top level {@link IInitialiser} classes and interfaces. + *
+ *
+ * Concrete initialisers are not tested, since there are already mechanisms + * implemented in them to ensure that they do what they are meant to do. + */ +package cipm.consistency.initialisers.tests; \ No newline at end of file From d613e7457f8448ddc11469f9c66e8b8fcc185b59 Mon Sep 17 00:00:00 2001 From: AlpTorac Date: Sun, 27 Oct 2024 18:03:52 +0100 Subject: [PATCH 48/55] Add missing IdentifierReferenceInitialiserAdapter --- ...IdentifierReferenceInitialiserAdapter.java | 76 +++++++++++++++++++ 1 file changed, 76 insertions(+) create mode 100644 commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/initadapters/IdentifierReferenceInitialiserAdapter.java diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/initadapters/IdentifierReferenceInitialiserAdapter.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/initadapters/IdentifierReferenceInitialiserAdapter.java new file mode 100644 index 0000000000..728e009b53 --- /dev/null +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/initadapters/IdentifierReferenceInitialiserAdapter.java @@ -0,0 +1,76 @@ +package cipm.consistency.initialisers.jamopp.initadapters; + +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.IdentifierReference; + +import cipm.consistency.initialisers.IInitialiser; +import cipm.consistency.initialisers.IInitialiserAdapterStrategy; +import cipm.consistency.initialisers.jamopp.instantiations.ExplicitConstructorCallInitialiser; +import cipm.consistency.initialisers.jamopp.statements.ExpressionStatementInitialiser; + +/** + * An {@link IInitialiserAdapterStrategy} implementation that can be used with + * {@link IInitialiserBase} implementors that instantiate + * {@link IdentifierReference}.
+ *
+ * Let IR be an {@link IdentifierReference} instance. + * {@link IdentifierReferenceInitialiserAdapter} then nests an uninitialised + * {@link ExpressionStatement} es instance within an uninitialised + * {@link ExplicitConstructorCall} ecc instance and sets IR's + * container to ecc. This way, IR will have a container, which is + * neither of type {@link Expression} nor {@link ArraySelector} (i.e. an + * eligible container).
+ *
+ * Note: IR's eligible container will be es. + * + * @author Alp Torac Genc + */ +public class IdentifierReferenceInitialiserAdapter implements IInitialiserAdapterStrategy { + + /** + * Realises the functionality of + * {@code JaMoPPElementUtil.getFirstContainerNotOfGivenType(...)} + */ + private EObject getFirstEligibleContainer(EObject obj) { + var firstEligibleContainer = obj.eContainer(); + + while (firstEligibleContainer != null) { + if (Expression.class.isAssignableFrom(firstEligibleContainer.getClass()) + || ArraySelector.class.isAssignableFrom(firstEligibleContainer.getClass())) { + firstEligibleContainer = firstEligibleContainer.eContainer(); + } else { + break; + } + } + + return firstEligibleContainer; + } + + @Override + public boolean apply(IInitialiser init, Object obj) { + var castedO = (IdentifierReference) obj; + + var firstEligibleContainer = this.getFirstEligibleContainer(castedO); + + if (firstEligibleContainer == null) { + var insInit = new ExplicitConstructorCallInitialiser(); + var ecc = insInit.instantiate(); + insInit.addArgument(ecc, castedO); + + var esInit = new ExpressionStatementInitialiser(); + var es = esInit.instantiate(); + esInit.setExpression(es, ecc); + + return this.getFirstEligibleContainer(castedO) == es; + } + + return this.getFirstEligibleContainer(castedO) != null; + } + + @Override + public IInitialiserAdapterStrategy newStrategy() { + return new IdentifierReferenceInitialiserAdapter(); + } +} From 445879c1bdd81c4cb924bf1f24259eb9b9d45444 Mon Sep 17 00:00:00 2001 From: AlpTorac Date: Mon, 10 Feb 2025 14:53:25 +0100 Subject: [PATCH 49/55] Change JUnit dependencies Use the same JUnit related dependencies as vsum tests Add JUnit Argument dependencies as well --- .../cipm.consistency.initialisers/META-INF/MANIFEST.MF | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/META-INF/MANIFEST.MF b/commit-based-cipm/initialisers/cipm.consistency.initialisers/META-INF/MANIFEST.MF index 217185e3c3..3645675d6f 100644 --- a/commit-based-cipm/initialisers/cipm.consistency.initialisers/META-INF/MANIFEST.MF +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/META-INF/MANIFEST.MF @@ -5,8 +5,9 @@ Bundle-SymbolicName: cipm.consistency.initialisers Bundle-Version: 1.0.0.qualifier Automatic-Module-Name: cipm.consistency.initialisers Bundle-RequiredExecutionEnvironment: JavaSE-11 -Require-Bundle: org.junit, - org.junit.jupiter.api, +Require-Bundle: junit-jupiter-api, + junit-jupiter-engine, + junit-jupiter-params, org.apache.log4j, org.eclipse.emf.ecore, org.emftext.language.java From b4c9e15424da5317d0077fdf0c4737eed8041ff5 Mon Sep 17 00:00:00 2001 From: AlpTorac Date: Tue, 4 Feb 2025 17:32:05 +0100 Subject: [PATCH 50/55] Fix return value of float/double literal initialisers --- .../jamopp/literals/IDecimalDoubleLiteralInitialiser.java | 2 +- .../jamopp/literals/IDecimalFloatLiteralInitialiser.java | 2 +- .../jamopp/literals/IHexDoubleLiteralInitialiser.java | 2 +- .../jamopp/literals/IHexFloatLiteralInitialiser.java | 2 +- 4 files changed, 4 insertions(+), 4 deletions(-) diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/IDecimalDoubleLiteralInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/IDecimalDoubleLiteralInitialiser.java index f96d324f62..dea8c21f53 100644 --- a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/IDecimalDoubleLiteralInitialiser.java +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/IDecimalDoubleLiteralInitialiser.java @@ -8,6 +8,6 @@ public interface IDecimalDoubleLiteralInitialiser extends IDoubleLiteralInitiali public default boolean setDecimalValue(DecimalDoubleLiteral ddl, double val) { ddl.setDecimalValue(val); - return ddl.getDecimalValue() == val; + return ddl.getDecimalValue() == val || (Double.isNaN(ddl.getDecimalValue()) && Double.isNaN(val)); } } diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/IDecimalFloatLiteralInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/IDecimalFloatLiteralInitialiser.java index dce2edba88..46bb8d0ab1 100644 --- a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/IDecimalFloatLiteralInitialiser.java +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/IDecimalFloatLiteralInitialiser.java @@ -8,6 +8,6 @@ public interface IDecimalFloatLiteralInitialiser extends IFloatLiteralInitialise public default boolean setDecimalValue(DecimalFloatLiteral dfl, float val) { dfl.setDecimalValue(val); - return dfl.getDecimalValue() == val; + return dfl.getDecimalValue() == val || (Float.isNaN(dfl.getDecimalValue()) && Float.isNaN(val)); } } diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/IHexDoubleLiteralInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/IHexDoubleLiteralInitialiser.java index 7d40b01fd9..43c564b3e8 100644 --- a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/IHexDoubleLiteralInitialiser.java +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/IHexDoubleLiteralInitialiser.java @@ -8,6 +8,6 @@ public interface IHexDoubleLiteralInitialiser extends IDoubleLiteralInitialiser public default boolean setHexValue(HexDoubleLiteral hdl, double val) { hdl.setHexValue(val); - return hdl.getHexValue() == val; + return hdl.getHexValue() == val || (Double.isNaN(hdl.getHexValue()) && Double.isNaN(val)); } } diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/IHexFloatLiteralInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/IHexFloatLiteralInitialiser.java index 36318bcca6..29ef53192e 100644 --- a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/IHexFloatLiteralInitialiser.java +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/literals/IHexFloatLiteralInitialiser.java @@ -8,6 +8,6 @@ public interface IHexFloatLiteralInitialiser extends IFloatLiteralInitialiser { public default boolean setHexValue(HexFloatLiteral hdl, float val) { hdl.setHexValue(val); - return hdl.getHexValue() == val; + return hdl.getHexValue() == val || (Float.isNaN(hdl.getHexValue()) && Float.isNaN(val)); } } From 78d6d8843147bda09374240c2b373b256445c3ab Mon Sep 17 00:00:00 2001 From: AlpTorac Date: Tue, 4 Feb 2025 17:36:29 +0100 Subject: [PATCH 51/55] Add utility method to initialisers Use the utility method in isInitialiserFor to retrieve the type of object they instantiate. Added to spare code duplication in tests --- .../consistency/initialisers/IInitialiser.java | 15 ++++++++++++++- .../initialisers/eobject/IEObjectInitialiser.java | 13 +++++++++++++ 2 files changed, 27 insertions(+), 1 deletion(-) diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/IInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/IInitialiser.java index 59f67ad167..534de34a31 100644 --- a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/IInitialiser.java +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/IInitialiser.java @@ -169,7 +169,20 @@ public static boolean isInitialiserFor(Class initCls, Cl * extracted from init. Returns false, if any parameter is null. */ public static boolean isInitialiserFor(IInitialiser init, Class objClass) { - return init != null && objClass != null && isInitialiserFor(init.getClass(), objClass); + return init != null && init.getInstanceClassOfInitialiser().equals(objClass); + } + + /** + * Uses the return value of {@link #instantiate()} to determine the outcome. + * This method should not return null, as long as {@link #instantiate()} does + * not return null. + * + * @return The {@link Class} object of the type this initialiser instantiates, + * or null if {@link #instantiate()} returns null. + */ + public default Class getInstanceClassOfInitialiser() { + var obj = this.instantiate(); + return obj != null ? obj.getClass() : null; } /** diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/eobject/IEObjectInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/eobject/IEObjectInitialiser.java index 50bfb2c59c..84f03c8ace 100644 --- a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/eobject/IEObjectInitialiser.java +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/eobject/IEObjectInitialiser.java @@ -26,4 +26,17 @@ public interface IEObjectInitialiser extends IInitialiser { @Override public IEObjectInitialiser newInitialiser(); + + /** + * {@inheritDoc} + * + * @return The instance class associated with the EClass of the return value of + * {@link #instantiate()}, or null if the said method returns null. + */ + @SuppressWarnings("unchecked") + @Override + public default Class getInstanceClassOfInitialiser() { + var obj = this.instantiate(); + return obj != null ? (Class) obj.eClass().getInstanceClass() : null; + } } From 8c629bfa1d7fab83f177064c297aa52b7c33d947 Mon Sep 17 00:00:00 2001 From: AlpTorac Date: Tue, 4 Feb 2025 17:40:31 +0100 Subject: [PATCH 52/55] Add hardcoded expected initialiser count in order to make sure that the tests are working as intended. Computing and determining this dynamically can lead to misleading results. It is better to synchronise initialiser counts upon adding new initialisers, since adding new initialisers is not expected to be common. --- .../jamopp/utiltests/UtilityTests.java | 25 +++++++++++++++++++ 1 file changed, 25 insertions(+) diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/utiltests/UtilityTests.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/utiltests/UtilityTests.java index 2b0de86add..59e0bec3b4 100644 --- a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/utiltests/UtilityTests.java +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/utiltests/UtilityTests.java @@ -59,6 +59,25 @@ public Collection getAllFiles() { return this.getAllFiles(root); } + /** + * The expected amount of concrete initialiser types.
+ *
+ * Note: Must be adapted, if new initialisers are added, which have concrete + * implementations. + */ + private int getExpectedConcreteInitialiserCount() { + return 181; + } + + /** + * The expected amount of initialiser types (abstract or concrete).
+ *
+ * Note: Must be adapted, if new initialisers are added. + */ + private int getExpectedInitialiserCount() { + return 274; + } + /** * Prints all interface types from {@link #getAllPossibleJaMoPPEObjectTypes()}. *
@@ -81,7 +100,9 @@ public void printFullHierarchy() { @Test public void testAllConcreteInitialisersRegistered() { var clss = this.getAllConcreteInitialiserCandidates(); + Assertions.assertEquals(this.getExpectedConcreteInitialiserCount(), clss.size()); var registeredInits = this.getAllInitialiserInstances(); + Assertions.assertEquals(this.getExpectedConcreteInitialiserCount(), registeredInits.size()); var matches = List.of( clss.stream().filter((cls) -> registeredInits.stream().anyMatch((init) -> init.isInitialiserFor(cls))) @@ -105,7 +126,9 @@ public void testAllConcreteInitialisersRegistered() { @Test public void testAllInitialiserInterfacesRegistered() { var clss = this.getAllInitialiserCandidates(); + Assertions.assertEquals(this.getExpectedInitialiserCount(), clss.size()); var registeredInits = this.getAllInitialiserInterfaceTypes(); + Assertions.assertEquals(this.getExpectedInitialiserCount(), registeredInits.size()); var matches = List.of(clss.stream() .filter((cls) -> registeredInits.stream() @@ -133,6 +156,7 @@ public void testAllInitialiserInterfacesRegistered() { @Test public void testAllConcreteInitialisersPresent() { var intfcs = this.getAllConcreteInitialiserCandidates(); + Assertions.assertEquals(this.getExpectedConcreteInitialiserCount(), intfcs.size()); var files = this.getAllFiles(); var matches = List.of(intfcs.stream().filter( @@ -161,6 +185,7 @@ public void testAllConcreteInitialisersPresent() { @Test public void testAllInitialiserInterfacesPresent() { var intfcs = this.getAllInitialiserCandidates(); + Assertions.assertEquals(this.getExpectedInitialiserCount(), intfcs.size()); var files = this.getAllFiles(); var matches = List.of(intfcs.stream().filter( From a3b9416feb82c7f0653704eddfd2be943face525 Mon Sep 17 00:00:00 2001 From: AlpTorac Date: Tue, 4 Feb 2025 17:48:05 +0100 Subject: [PATCH 53/55] Remove redundant methods --- .../consistency/initialisers/IInitialiserUtilityTest.java | 6 ------ .../initialisers/jamopp/utiltests/UtilityTests.java | 3 +-- 2 files changed, 1 insertion(+), 8 deletions(-) diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/IInitialiserUtilityTest.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/IInitialiserUtilityTest.java index 49f972ef63..763f0f2c00 100644 --- a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/IInitialiserUtilityTest.java +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/IInitialiserUtilityTest.java @@ -16,12 +16,6 @@ * @author Alp Torac Genc */ public interface IInitialiserUtilityTest { - - /** - * @return A list of all files under the root directory. - */ - public Collection getAllFiles(); - /** * @return The {@link IInitialiserPackage} that will be used within the utility * test. diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/utiltests/UtilityTests.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/utiltests/UtilityTests.java index 59e0bec3b4..7ef4411b58 100644 --- a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/utiltests/UtilityTests.java +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/utiltests/UtilityTests.java @@ -54,8 +54,7 @@ public IInitialiserPackage getUsedInitialiserPackage() { return new JaMoPPInitialiserPackage(); } - @Override - public Collection getAllFiles() { + private Collection getAllFiles() { return this.getAllFiles(root); } From 6d2adb2fa1dcba4aa4d95e5972c8ee524f138cbb Mon Sep 17 00:00:00 2001 From: AlpTorac Date: Tue, 4 Feb 2025 17:53:47 +0100 Subject: [PATCH 54/55] Use EObject methods in JaMoPPHelper to retrieve types, which should have a (concrete) initialiser. Although using the suffix each implementation has ("Impl") is possible, having a dynamic way of separating such types is more desirable. --- .../jamopp/IJaMoPPUtilityTest.java | 8 +- .../initialisers/jamopp/JaMoPPHelper.java | 178 ++++++++++++++---- 2 files changed, 147 insertions(+), 39 deletions(-) diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/IJaMoPPUtilityTest.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/IJaMoPPUtilityTest.java index 534bdcc371..0fcbe86451 100644 --- a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/IJaMoPPUtilityTest.java +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/IJaMoPPUtilityTest.java @@ -3,6 +3,8 @@ import java.util.Collection; import java.util.Set; +import org.eclipse.emf.ecore.EObject; + import cipm.consistency.initialisers.eobject.IEObjectUtilityTest; /** @@ -22,21 +24,21 @@ public default JaMoPPHelper getJaMoPPHelper() { /** * {@link JaMoPPHelper#getAllPossibleTypes()} */ - public default Set> getAllPossibleJaMoPPEObjectTypes() { + public default Set> getAllPossibleJaMoPPEObjectTypes() { return this.getJaMoPPHelper().getAllPossibleTypes(); } /** * {@link JaMoPPHelper#getAllInitialiserCandidates()} */ - public default Collection> getAllInitialiserCandidates() { + public default Collection> getAllInitialiserCandidates() { return this.getJaMoPPHelper().getAllInitialiserCandidates(); } /** * {@link JaMoPPHelper#getAllConcreteInitialiserCandidates()} */ - public default Collection> getAllConcreteInitialiserCandidates() { + public default Collection> getAllConcreteInitialiserCandidates() { return this.getJaMoPPHelper().getAllConcreteInitialiserCandidates(); } } diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/JaMoPPHelper.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/JaMoPPHelper.java index b13a715e8a..8d4149b6dc 100644 --- a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/JaMoPPHelper.java +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/jamopp/JaMoPPHelper.java @@ -1,14 +1,17 @@ package cipm.consistency.initialisers.jamopp; +import java.lang.reflect.Modifier; +import java.util.ArrayList; import java.util.Collection; import java.util.HashSet; -import java.util.List; import java.util.Set; +import java.util.function.Predicate; import org.eclipse.emf.ecore.EClass; +import org.eclipse.emf.ecore.EClassifier; +import org.eclipse.emf.ecore.EObject; import org.eclipse.emf.ecore.EPackage; import org.emftext.language.java.JavaPackage; -import org.emftext.language.java.commons.Commentable; /** * A utility class that provides information about EObjects used by JaMoPP, as @@ -21,19 +24,129 @@ * @author Alp Torac Genc */ public class JaMoPPHelper { + /** + * A variant of {@link #getAllClasses(Predicate)} with no given predicate. + */ + public Collection> getAllClasses() { + return this.getAllClasses(null); + } + + /** + * If the given predicate is null, does not filter the found types. + * + * @return All types accessible under the sub-packages of {@link JavaPackage} in + * form of {@link EClass}, whose instance class + * {@code eClass.getInstanceClass()} will be in the return value, which + * fulfill the given predicate. + */ + public Collection> getAllClasses(Predicate pred) { + var res = new ArrayList>(); + Predicate predToUse = pred != null ? pred : (a) -> true; + this.getAllEClasses().stream().filter(predToUse) + .forEach((eCls) -> res.add(this.getInstanceClassOfEClassifier(eCls))); + return res; + } /** - * The suffix used in the concrete implementation of EObject classes in JaMoPP. + * @return All {@link EClass}es accessible under the sub-packages of + * {@link JavaPackage}. */ - public String getImplSuffix() { - return "Impl"; + public Collection getAllEClasses() { + var res = new ArrayList(); + var ePacs = JavaPackage.eINSTANCE.getESubpackages(); + ePacs.forEach((pac) -> pac.getEClassifiers().stream().filter((eClsf) -> eClsf instanceof EClass) + .forEach((c) -> res.add((EClass) c))); + return res; + } + + protected Class getInstanceClassOfEObject(T obj) { + return this.getInstanceClassOfEClassifier(obj.eClass()); + } + + @SuppressWarnings("unchecked") + protected Class getInstanceClassOfEClassifier(EClassifier eClsfier) { + return (Class) eClsfier.getInstanceClass(); + } + + /** + * Finds the {@link EClass} corresponding to the given cls, whose instance class + * is equal to cls: {@code eCls.getInstanceClass().equals(cls)}. + * + * @param cls The type of the Java element, whose {@link EClass} will be + * returned, if cls is the type of a Java element. + * + * @return The {@link EClass} corresponding to the class represented by cls. + * Null, if no such {@link EClass} is found under {@link JavaPackage}. + */ + public EClass getEClassForJavaElement(Class cls) { + var ePacs = JavaPackage.eINSTANCE.getESubpackages(); + for (var ePac : ePacs) { + var eClss = ePac.getEClassifiers(); + for (var eCls : eClss) { + if (eCls.getInstanceClass().equals(cls)) { + return (EClass) eCls; + } + } + } + return null; + } + + /** + * Finds the {@link EClass} corresponding to the given cls, whose instance + * class' concrete type is equal to cls. + * + * @param cls The type of the concrete implementation of the Java element, whose + * corresponding {@link EClass} will be returned. + * + * @return The {@link EClass} corresponding to the interface type of cls. Null, + * if no such {@link EClass} is found under {@link JavaPackage}. Note + * that the returned {@link EClass} will be from the interface of cls. + * This means, if cls represents the type xImpl, the returned + * {@link EClass} will belong to x. + */ + public EClass getEClassForJavaElementImpl(Class cls) { + var interfaceType = this.getInterfaceTypeForJavaElementImpl(cls); + if (interfaceType != null) { + return this.getEClassForJavaElement(interfaceType); + } + return null; + } + + /** + * The interface {@code I} of the implementation of a Java element type + * {@code T} within JaMoPP is directly implemented by it and also contains its + * name, i.e.:
+ *
+ * T extends I directly and the simple name of T contains the simple name of I. + * T can neither be an interface nor abstract. + * + * @param The type of the passed parameter. Used to allow making assumptions + * on the return value. + * @param cls The type of an implementation of a Java element within JaMoPP. + * @return The interface of cls matching the description from above, if it + * exists. Otherwise null. + */ + @SuppressWarnings("unchecked") + public Class getInterfaceTypeForJavaElementImpl(Class cls) { + if (cls.isInterface() || Modifier.isAbstract(cls.getModifiers())) { + return null; + } + + var directIfcs = cls.getInterfaces(); + for (var ifc : directIfcs) { + if (cls.getSimpleName().contains(ifc.getSimpleName())) { + return (Class) ifc; + } + } + + return null; } /** * @return Types of concrete implementations and interfaces of all Java-Model * elements. */ - public Set> getAllPossibleTypes() { + public Set> getAllPossibleTypes() { return this.getAllPossibleTypes(JavaPackage.eINSTANCE.getESubpackages()); } @@ -47,15 +160,15 @@ public Set> getAllPossibleTypes() { * sub-packages. Includes types of interfaces as well as concrete * implementation classes. */ - public Set> getAllPossibleTypes(EPackage cPac) { + public Set> getAllPossibleTypes(EPackage cPac) { var clss = cPac.getEClassifiers(); var subPacs = cPac.getESubpackages(); - var foundClss = new HashSet>(); + var foundClss = new HashSet>(); if (clss != null) { for (var cls : clss) { - foundClss.add(cls.getInstanceClass()); + foundClss.add(this.getInstanceClassOfEClassifier(cls)); /* * Although cls is technically of type EClassifier, it also implements EClass @@ -86,8 +199,8 @@ public Set> getAllPossibleTypes(EPackage cPac) { * implementation classes. * @see {@link #getAllPossibleTypes(EPackage)}} */ - public Set> getAllPossibleTypes(Collection pacs) { - var foundClss = new HashSet>(); + public Set> getAllPossibleTypes(Collection pacs) { + var foundClss = new HashSet>(); for (var pac : pacs) { foundClss.addAll(this.getAllPossibleTypes(pac)); @@ -97,36 +210,29 @@ public Set> getAllPossibleTypes(Collection pacs) { } /** - * Used to determine which EObject implementors should have an initialiser.
- *
- * Here, such implementors (initialiser candidates) implement - * {@link Commentable} and their names do not end with {@link #implSuffix}. + * Used to determine which EObject implementors should have an initialiser + * interface. * - * @return The classes from {@link #getAllPossibleTypes()}, which should have a - * corresponding initialiser interface. + * @return The class objects within {@link #getAllEClasses()} which should have + * a corresponding initialiser interface. Currently, all of them. */ - public Collection> getAllInitialiserCandidates() { - var fullHierarchy = getAllPossibleTypes(); - - var intfcs = fullHierarchy.stream().filter((c) -> Commentable.class.isAssignableFrom(c)) - .filter((c) -> !c.getSimpleName().endsWith(this.getImplSuffix())).toArray(Class[]::new); - - return List.of(intfcs); + public Collection> getAllInitialiserCandidates() { + var result = new ArrayList>(); + this.getAllEClasses().stream().forEach((e) -> result.add(this.getInstanceClassOfEClassifier(e))); + return result; } /** - * @return The EObject types from {@link #getAllPossibleTypes()}, which should - * have a corresponding concrete initialiser that can instantiate the - * said type. + * Used to determine which EObject implementors should have a concrete + * initialiser implementation. + * + * @return The class objects within {@link #getAllEClasses()} which should have + * a corresponding concrete initialiser implementation. */ - public Collection> getAllConcreteInitialiserCandidates() { - var fullHierarchy = getAllPossibleTypes(); - - var intfcs = fullHierarchy.stream().filter((c) -> Commentable.class.isAssignableFrom(c)) - .filter((c) -> fullHierarchy.stream() - .anyMatch((c2) -> c2.getSimpleName().equals(c.getSimpleName() + this.getImplSuffix()))) - .toArray(Class[]::new); - - return List.of(intfcs); + public Collection> getAllConcreteInitialiserCandidates() { + var result = new ArrayList>(); + this.getAllEClasses().stream().filter((e) -> !e.isAbstract()) + .forEach((e) -> result.add(this.getInstanceClassOfEClassifier(e))); + return result; } } From 83188d2bdb4d15eca5ec2bb9ff42235e3c437908 Mon Sep 17 00:00:00 2001 From: AlpTorac Date: Tue, 4 Feb 2025 17:54:36 +0100 Subject: [PATCH 55/55] Edit commentary --- .../initialisers/IInitialiser.java | 39 +++++++++++++++---- .../IInitialiserAdapterStrategy.java | 5 ++- .../initialisers/IInitialiserBase.java | 8 +++- .../initialisers/IInitialiserPackage.java | 24 ++++++++---- .../initialisers/package-info.java | 15 ++++--- 5 files changed, 65 insertions(+), 26 deletions(-) diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/IInitialiser.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/IInitialiser.java index 534de34a31..b038a1ea01 100644 --- a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/IInitialiser.java +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/IInitialiser.java @@ -38,7 +38,9 @@ * overriding behaviour easier, since default methods can be overridden in * interfaces. If initialisation of the designated objects is complex, consider * realising it in form of initialiser adaptation strategies (see the links - * below).
+ * below). Note that calling {@link #initialise(Object)} in addition to + * {@link #instantiate()} is necessary for the said initialiser strategies to be + * used.
*
* This interface also contains some static utility methods. * @@ -48,16 +50,27 @@ */ public interface IInitialiser { /** - * Can be used to create a (deep) copy of this. + * Can be used to create a copy of this.
+ *
+ * Note that the returned initialiser will not have the initialiser + * adaptation strategies this initialiser has. * * @return A fresh instance of this initialiser's class. + * + * @see {@link IInitialiserBase} + * @see {@link IInitialiserAdapterStrategy} */ public IInitialiser newInitialiser(); /** * Attempts to instantiate the class this {@link IInitialiser} is designated - * for. Depending on the returned object, additional initialisation may be - * necessary. + * for. Depending on the returned object, additional initialisation via + * {@link #initialise(Object)} may be necessary. Note that the said method must + * be called upon the return value, in order for the initialiser adaptation + * strategies to take effect. + * + * @see {@link IInitialiserBase} + * @see {@link IInitialiserAdapterStrategy} */ public Object instantiate(); @@ -65,9 +78,17 @@ public interface IInitialiser { * Attempts to initialise obj, so that it is "valid".
*
* It is recommended to only use this method where necessary, as it may - * introduce additional modifications that are not obvious from outside. + * introduce additional modifications that are not obvious from outside. The + * said modifications originate from initialiser adaptation strategies and they + * will not take effect, unless this method is called upon the object created + * via {@link #instantiate()}. * * @param obj The object that will be made valid + * + * @return Whether the initialisation of obj was successful. + * + * @see {@link IInitialiserBase} + * @see {@link IInitialiserAdapterStrategy} */ public boolean initialise(Object obj); @@ -165,8 +186,12 @@ public static boolean isInitialiserFor(Class initCls, Cl } /** - * A variant of {@link #isInitialiserFor(Class, Class)}, where initCls is - * extracted from init. Returns false, if any parameter is null. + * Returns whether the given initialiser init instantiates objects of type + * objClass.
+ *
+ * For the result to be true, init has to be able to instantiate + * exactly objClass, i.e. the return type of the instantiation + * method has to be exactly objClass. */ public static boolean isInitialiserFor(IInitialiser init, Class objClass) { return init != null && init.getInstanceClassOfInitialiser().equals(objClass); diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/IInitialiserAdapterStrategy.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/IInitialiserAdapterStrategy.java index 480e88777c..32df15d328 100644 --- a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/IInitialiserAdapterStrategy.java +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/IInitialiserAdapterStrategy.java @@ -16,9 +16,10 @@ public interface IInitialiserAdapterStrategy { /** * Applies the initialisation logic contained in this instance to the given - * object. + * object. Check the concrete class' documentation for more information, since + * the semantics of this method is tightly coupled with it. * - * @return Whether the method did what it was supposed to do. + * @return Whether this method did what it was supposed to do. */ public boolean apply(IInitialiser init, Object obj); diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/IInitialiserBase.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/IInitialiserBase.java index d7629d4ac5..b821e99d7c 100644 --- a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/IInitialiserBase.java +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/IInitialiserBase.java @@ -12,7 +12,7 @@ public interface IInitialiserBase extends IInitialiser { /** * Adds the given {@link IInitialiserAdapterStrategy} to this instance. Does not - * add null, if {@code strat == null}. + * add, if {@code strat == null}. */ public void addAdaptingStrategy(IInitialiserAdapterStrategy strat); @@ -69,6 +69,12 @@ public default boolean isAdapted() { * are meant to be used.
*
* {@inheritDoc} + * + * @return Whether all initialiser adaptation strategies in this were applied + * successfully. If there are no such strategies; returns true, since no + * strategy was attempted to be applied and failed. + * + * @see {@link IInitialiserAdapterStrategy} */ @Override public default boolean initialise(Object obj) { diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/IInitialiserPackage.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/IInitialiserPackage.java index 9d1d64c5fd..84fcf6df64 100644 --- a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/IInitialiserPackage.java +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/IInitialiserPackage.java @@ -18,10 +18,11 @@ */ public interface IInitialiserPackage { /** - * @return {@link IInitialiser} instances that are contained in this instance. + * @return A freshly created instance of each {@link IInitialiser} sub-type, + * which this encompasses. * * @see {@link #getAllInitialiserInstances()} for all such initialisers that are - * accessible from this. + * accessible from sub-packages as well as this. */ public default Collection getInitialiserInstances() { return this.initCol(); @@ -29,7 +30,8 @@ public default Collection getInitialiserInstances() { /** * @return Class objects of {@link IInitialiser} types that are contained in - * this instance. + * this instance. Note that the returned types are not necessarily + * concrete, i.e. they can be interfaces and/or abstract classes. * * @see {@link #getAllInitialiserInterfaceTypes()} for all such initialiser * types that are accessible from this. @@ -39,13 +41,16 @@ public default Collection> getInitialiserInterface } /** - * @return All {@link IInitialiserPackage} instances nested in this. + * @return All {@link IInitialiserPackage} instances nested in this, i.e. the + * sub-packages of this. */ public default Collection getSubPackages() { return this.initCol(); } /** + * Meant to be used only by {@link IInitialiserPackage} implementors. + * * @return An empty collection that will be used to store objects of type T. */ public default Collection initCol() { @@ -53,6 +58,8 @@ public default Collection initCol() { } /** + * Meant to be used only by {@link IInitialiserPackage} implementors.
+ *
* A variant of {@link #initCol()} that also adds the given elems to the created * collection. * @@ -75,7 +82,7 @@ public default Collection initCol(T[] elems) { * @return All {@link IInitialiserPackage} instances accessible from this. * * @see {@link #getSubPackages()} for initialiser packages that are contained in - * this. + * this directly. */ public default Collection getAllSubPackages() { var result = this.getSubPackages(); @@ -91,10 +98,11 @@ public default Collection getAllSubPackages() { * Recursively discovers all nested {@link IInitialiserPackage} instances * reachable from this instance. * - * @return All {@link IInitialiser} instances accessible from this. + * @return Freshly created {@link IInitialiser} instances for each initialiser + * accessible from this. * * @see {@link #getInitialiserInstances()} for initialiser instances that are - * contained in this. + * contained in this directly. */ public default Collection getAllInitialiserInstances() { var result = this.getInitialiserInstances(); @@ -113,7 +121,7 @@ public default Collection getAllInitialiserInstances() { * @return All initialiser types that are accessible from this. * * @see {@link #getInitialiserInterfaceTypes()} for initialiser types that are - * contained in this. + * contained in this directly. */ public default Collection> getAllInitialiserInterfaceTypes() { var result = this.getInitialiserInterfaceTypes(); diff --git a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/package-info.java b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/package-info.java index 5dadf2e394..6904c86108 100644 --- a/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/package-info.java +++ b/commit-based-cipm/initialisers/cipm.consistency.initialisers/src/cipm/consistency/initialisers/package-info.java @@ -3,7 +3,12 @@ * {@link cipm.consistency.initialisers.IInitialiser} as well as for classes * that can be used to adapt them. Also has an interface * {@link cipm.consistency.initialisers.IInitialiserPackage}, which can be - * implemented to access initialiser types and instances easier.
+ * implemented to access initialiser types and instances easier. + * {@link cipm.consistency.initialisers.IInitialiserPackage} defines a nestable + * structure that enables finding the proper initialisers as well as certain + * groups of initialisers. It is recommended to implement that interface for + * each package containing initialisers and to add all initialisers to that + * implementation.
*
* Initialisers are classes/interfaces, whose purpose is to instantiate, * initialise and modify certain objects. Implementing initialisers similar to @@ -20,12 +25,6 @@ * cause of such exceptions is initialisers not setting the required attributes * while instantiating objects. In such cases, the said adapters can be used to * have them set those attributes, so that using the instances in tests do not - * throw exceptions, due to their essential attributes not being set.
- *
- * {@link cipm.consistency.initialisers.IInitialiserPackage} defines a nestable - * structure that enables finding the proper initialisers as well as certain - * groups of initialisers. It is recommended to implement that interface for - * each package containing initialisers and to add all initialisers to that - * implementation. + * throw exceptions, due to their essential attributes not being set. */ package cipm.consistency.initialisers; \ No newline at end of file