Merge branch '4344' into 'master'

Add preparation possibility for reuse providers (incl. specs cleaning)

Closes af3#4344

See merge request !218

org.fortiss.tooling.ext.reuse/META-INF/MANIFEST.MF

@@ -13,7 +13,8 @@ Bundle-Activator: org.fortiss.tooling.ext.reuse.ToolingReuseActivator
 Require-Bundle: org.eclipse.core.runtime,
  org.eclipse.emf.ecore;visibility:=reexport,
  org.fortiss.tooling.base;visibility:=reexport,
- org.fortiss.tooling.kernel;visibility:=reexport
+ org.fortiss.tooling.kernel;visibility:=reexport,
+ org.fortiss.tooling.ext.variability;bundle-version="2.24.0"
 Export-Package: org.fortiss.tooling.ext.reuse.model,
  org.fortiss.tooling.ext.reuse.model.impl,
  org.fortiss.tooling.ext.reuse.model.util,

org.fortiss.tooling.ext.reuse/src/org/fortiss/tooling/ext/reuse/service/.ratings

-IReuseProvider.java 51dd0df5954bff99b80244cae94403300c4aadb1 GREEN
-IReuseProviderService.java 6cf3ef4f67ab7515a1a78df2448439e8d6d97737 GREEN
+IReuseProvider.java 18d293f7f1f072883188f16fb6eeb52c8d6042cf GREEN
+IReuseProviderService.java bcc70de0bb8d39c330e3a25d884abc7092dc1b7e GREEN
 LayoutedReuseProviderBase.java b0e4ce3cda818b0723ec37b925a4c4c3d0c41909 GREEN
-ReuseProviderBase.java 0ee51474bda060f3d326094397bc0a7fd7247152 GREEN
-ReuseProviderService.java 748eea63e16d286f1738aa7091219dc63e7ad16e GREEN
+ReuseProviderBase.java ac47f5ecafed0bdef6ef5183c7194aa756f723fd GREEN
+ReuseProviderService.java c4ef33283002d6dac6167f9c6c8f71d2c2ce39d1 GREEN

org.fortiss.tooling.ext.reuse/src/org/fortiss/tooling/ext/reuse/service/IReuseProvider.java

 /*-------------------------------------------------------------------------+
-| Copyright 2021 fortiss GmbH                                              |
+| Copyright 2023 fortiss GmbH                                              |
 |                                                                          |
 | Licensed under the Apache License, Version 2.0 (the "License");          |
 | you may not use this file except in compliance with the License.         |
@@ -26,19 +26,32 @@ import org.fortiss.tooling.kernel.service.base.IEObjectAware;
  *
  * @author bergemann
  *
- * @param <T> The subclass of {@link EObject} for which this provider shall be
+ * @param <T>
+ *            The subclass of {@link EObject} for which this provider shall be
  *            invoked.
  */
 public interface IReuseProvider<T extends EObject> extends IEObjectAware<T> {
 
+	/**
+	 * Prepares the given <T> for its storage in a reuse library. This might e.g. include cleaning
+	 * it from attributes that are not needed anymore when "exported" into a library.
+	 * 
+	 * @param element
+	 *            The <T> that should be prepared.
+	 * @return True if preparation was successful, otherwise false.
+	 */
+	public boolean prepareReuseElementForLibrary(T element);
+
 	/**
 	 * Updates the first given <T>, which is a reuse element, based on the second
 	 * given <T>. The update is a replacement of the old element with the new one,
 	 * while also all references in depending elements are updated/replaced.
 	 *
-	 * @param elementToBeUpdated The <T> that should be updated/replaced.
-	 * @param newElement         The <T> with which the first one should be replaced
-	 *                           (updated).
+	 * @param elementToBeUpdated
+	 *            The <T> that should be updated/replaced.
+	 * @param newElement
+	 *            The <T> with which the first one should be replaced
+	 *            (updated).
 	 * @return True if update was successful, otherwise false
 	 */
 	public boolean updateReuseElement(T elementToBeUpdated, T newElement);
@@ -46,8 +59,10 @@ public interface IReuseProvider<T extends EObject> extends IEObjectAware<T> {
 	/**
 	 * Sets the name of the given <T> used for reuse with the given {@link String}.
 	 *
-	 * @param reuseElement The <T> whose name should be set.
-	 * @param name         The {@link String} for the name.
+	 * @param reuseElement
+	 *            The <T> whose name should be set.
+	 * @param name
+	 *            The {@link String} for the name.
 	 * @return True if update was successful, otherwise false
 	 */
 	public boolean setReuseElementName(T reuseElement, String name);
@@ -55,7 +70,8 @@ public interface IReuseProvider<T extends EObject> extends IEObjectAware<T> {
 	/**
 	 * Gets the name of the given <T> used for reuse.
 	 *
-	 * @param reuseElement The <T> whose name is requested.
+	 * @param reuseElement
+	 *            The <T> whose name is requested.
 	 * @return The name as {@link String}.
 	 */
 	public String getReuseElementName(T reuseElement);
@@ -64,8 +80,10 @@ public interface IReuseProvider<T extends EObject> extends IEObjectAware<T> {
 	 * Sets the comment of the given <T> used for reuse with the given
 	 * {@link String}.
 	 *
-	 * @param reuseElement The <T> whose name should be set.
-	 * @param comment      The {@link String} for the comment.
+	 * @param reuseElement
+	 *            The <T> whose name should be set.
+	 * @param comment
+	 *            The {@link String} for the comment.
 	 * @return True if update was successful, otherwise false
 	 */
 	public boolean setReuseElementComment(T reuseElement, String comment);
@@ -73,7 +91,8 @@ public interface IReuseProvider<T extends EObject> extends IEObjectAware<T> {
 	/**
 	 * Gets the comment of the given <T>} used for reuse.
 	 *
-	 * @param reuseElement The <T> whose name is requested.
+	 * @param reuseElement
+	 *            The <T> whose name is requested.
 	 * @return The comment as {@link String}.
 	 */
 	public String getReuseElementComment(T reuseElement);

org.fortiss.tooling.ext.reuse/src/org/fortiss/tooling/ext/reuse/service/IReuseProviderService.java

 /*-------------------------------------------------------------------------+
-| Copyright 2021 fortiss GmbH                                              |
+| Copyright 2023 fortiss GmbH                                              |
 |                                                                          |
 | Licensed under the Apache License, Version 2.0 (the "License");          |
 | you may not use this file except in compliance with the License.         |
@@ -36,7 +36,7 @@ public interface IReuseProviderService extends IIntrospectiveKernelService {
 	/**
 	 * Retrieves the singleton instance of {@link ReuseProviderService}.
 	 *
-	 * @return The singleton instance of this service
+	 * @return The singleton instance of this service.
 	 */
 	public static IReuseProviderService getInstance() {
 		return ReuseProviderService.getInstance();
@@ -45,23 +45,38 @@ public interface IReuseProviderService extends IIntrospectiveKernelService {
 	/**
 	 * Registers the given {@link IReuseProvider} in this service.
 	 *
-	 * @param provider The {@link IReuseProvider} to register.
-	 * @param cls      The subclass of {@link EObject} the given provider shall be
-	 *                 used for.
+	 * @param provider
+	 *            The {@link IReuseProvider} to register.
+	 * @param cls
+	 *            The subclass of {@link EObject} the given provider shall be
+	 *            used for.
 	 */
 	public <T extends EObject> void registerReuseProvider(IReuseProvider<T> provider, Class<T> cls);
 
+	/**
+	 * Prepares the given reuse element as {@link EObject} for storage in a reuse library. This
+	 * might include e.g. cleaning the reuse element from all attributes that are not needed anymore
+	 * when "exported" into a library.
+	 * 
+	 * @param reuseElement
+	 *            The reuse element that should be prepared.
+	 * @return True if preparation was successful, otherwise false.
+	 */
+	public boolean prepareReuseElementForLibrary(EObject reuseElement);
+
 	/**
 	 * Updates the first given {@link EObject}, which is a reuse element, based on
 	 * the second given {@link EObject}. The update is a replacement of the old
 	 * element with the new one, while also all references in depending elements are
 	 * updated/replaced.
 	 *
-	 * @param elementToBeUpdated The {@link EObject} that should be
-	 *                           updated/replaced.
-	 * @param newElement         The {@link EObject} with which the first one should
-	 *                           be replaced (updated).
-	 * @return True if update was successful, otherwise false
+	 * @param elementToBeUpdated
+	 *            The {@link EObject} that should be
+	 *            updated/replaced.
+	 * @param newElement
+	 *            The {@link EObject} with which the first one should
+	 *            be replaced (updated).
+	 * @return True if update was successful, otherwise false.
 	 */
 	public boolean updateReuseElement(EObject elementToBeUpdated, EObject newElement);
 
@@ -69,16 +84,19 @@ public interface IReuseProviderService extends IIntrospectiveKernelService {
 	 * Sets the name of the given {@link EObject} used for reuse with the given
 	 * {@link String}.
 	 *
-	 * @param reuseElement The {@link EObject} whose name should be set.
-	 * @param name         The {@link String} for the name.
-	 * @return True if update was successful, otherwise false
+	 * @param reuseElement
+	 *            The {@link EObject} whose name should be set.
+	 * @param name
+	 *            The {@link String} for the name.
+	 * @return True if update was successful, otherwise false.
 	 */
 	public boolean setReuseElementName(EObject reuseElement, String name);
 
 	/**
 	 * Gets the name of the given {@link EObject} used for reuse.
 	 *
-	 * @param reuseElement The {@link EObject} whose name is requested.
+	 * @param reuseElement
+	 *            The {@link EObject} whose name is requested.
 	 * @return The name as {@link String}.
 	 */
 	public String getReuseElementName(EObject reuseElement);
@@ -87,16 +105,19 @@ public interface IReuseProviderService extends IIntrospectiveKernelService {
 	 * Sets the comment of the given {@link EObject} used for reuse with the given
 	 * {@link String}.
 	 *
-	 * @param reuseElement The {@link EObject} whose name should be set.
-	 * @param comment      The {@link String} for the comment.
-	 * @return True if update was successful, otherwise false
+	 * @param reuseElement
+	 *            The {@link EObject} whose name should be set.
+	 * @param comment
+	 *            The {@link String} for the comment.
+	 * @return True if update was successful, otherwise false.
 	 */
 	public boolean setReuseElementComment(EObject reuseElement, String comment);
 
 	/**
 	 * Gets the comment of the given {@link EObject} used for reuse.
 	 *
-	 * @param reuseElement The {@link EObject} whose name is requested.
+	 * @param reuseElement
+	 *            The {@link EObject} whose name is requested.
 	 * @return The comment as {@link String}.
 	 */
 	public String getReuseElementComment(EObject reuseElement);

org.fortiss.tooling.ext.reuse/src/org/fortiss/tooling/ext/reuse/service/ReuseProviderBase.java

 /*-------------------------------------------------------------------------+
-| Copyright 2021 fortiss GmbH                                              |
+| Copyright 2023 fortiss GmbH                                              |
 |                                                                          |
 | Licensed under the Apache License, Version 2.0 (the "License");          |
 | you may not use this file except in compliance with the License.         |
@@ -16,12 +16,17 @@
 package org.fortiss.tooling.ext.reuse.service;
 
 import static org.eclipse.emf.ecore.util.EcoreUtil.replace;
+import static org.fortiss.tooling.ext.variability.util.VariabilityUtils.getOptVarPointSpecification;
 import static org.fortiss.tooling.kernel.utils.EcoreUtils.replaceEObjectReferences;
 
 import java.util.ArrayList;
 import java.util.List;
 
 import org.eclipse.emf.ecore.EObject;
+import org.fortiss.tooling.base.model.element.IHierarchicElement;
+import org.fortiss.tooling.base.model.element.IHierarchicElementContainer;
+import org.fortiss.tooling.base.model.element.IModelElement;
+import org.fortiss.tooling.ext.variability.model.OptionalVariationPointSpecification;
 import org.fortiss.tooling.kernel.model.INamedCommentedElement;
 import org.fortiss.tooling.kernel.model.INamedElement;
 
@@ -31,11 +36,21 @@ import org.fortiss.tooling.kernel.model.INamedElement;
  *
  * @author bergemann
  *
- * @param <T> The subclass of {@link EObject} for which this provider base shall
+ * @param <T>
+ *            The subclass of {@link EObject} for which this provider base shall
  *            be extended.
  */
 public class ReuseProviderBase<T extends EObject> implements IReuseProvider<T> {
 
+	/** {@inheritDoc} */
+	@Override
+	public boolean prepareReuseElementForLibrary(T reuseElement) {
+		if(reuseElement instanceof IModelElement) {
+			removeVariabilitySpecifications((IModelElement)reuseElement);
+		}
+		return true;
+	}
+
 	/** {@inheritDoc} */
 	@Override
 	public boolean updateReuseElement(T elementToBeUpdated, T newElement) {
@@ -47,8 +62,8 @@ public class ReuseProviderBase<T extends EObject> implements IReuseProvider<T> {
 	/** {@inheritDoc} */
 	@Override
 	public boolean setReuseElementName(T reuseElement, String name) {
-		if (reuseElement instanceof INamedElement) {
-			((INamedElement) reuseElement).setName(name);
+		if(reuseElement instanceof INamedElement) {
+			((INamedElement)reuseElement).setName(name);
 			return true;
 		}
 		return false;
@@ -57,8 +72,8 @@ public class ReuseProviderBase<T extends EObject> implements IReuseProvider<T> {
 	/** {@inheritDoc} */
 	@Override
 	public String getReuseElementName(T reuseElement) {
-		if (reuseElement instanceof INamedElement) {
-			return ((INamedElement) reuseElement).getName();
+		if(reuseElement instanceof INamedElement) {
+			return ((INamedElement)reuseElement).getName();
 		}
 		return null;
 	}
@@ -66,8 +81,8 @@ public class ReuseProviderBase<T extends EObject> implements IReuseProvider<T> {
 	/** {@inheritDoc} */
 	@Override
 	public boolean setReuseElementComment(T reuseElement, String comment) {
-		if (reuseElement instanceof INamedCommentedElement) {
-			((INamedCommentedElement) reuseElement).setComment(comment);
+		if(reuseElement instanceof INamedCommentedElement) {
+			((INamedCommentedElement)reuseElement).setComment(comment);
 			return true;
 		}
 		return false;
@@ -76,8 +91,8 @@ public class ReuseProviderBase<T extends EObject> implements IReuseProvider<T> {
 	/** {@inheritDoc} */
 	@Override
 	public String getReuseElementComment(T reuseElement) {
-		if (reuseElement instanceof INamedCommentedElement) {
-			return ((INamedCommentedElement) reuseElement).getComment();
+		if(reuseElement instanceof INamedCommentedElement) {
+			return ((INamedCommentedElement)reuseElement).getComment();
 		}
 		return null;
 	}
@@ -85,8 +100,28 @@ public class ReuseProviderBase<T extends EObject> implements IReuseProvider<T> {
 	/** {@inheritDoc} */
 	@Override
 	public List<Class<? extends EObject>> getPossibleExternalReferenceClasses() {
-		// can only be specified for specific elements (if wanted) --> here only empty
+		// Can only be specified for specific elements (if wanted) --> here only empty.
 		return new ArrayList<Class<? extends EObject>>();
 	}
 
+	/**
+	 * Removes unnecessary variability specifications from the given element and from all of its
+	 * contained elements. The method is recursion-based!
+	 */
+	private void removeVariabilitySpecifications(IModelElement nextElement) {
+		// Removal.
+		OptionalVariationPointSpecification unnecessarySpec =
+				getOptVarPointSpecification(nextElement);
+		if(unnecessarySpec != null) {
+			nextElement.getSpecifications().remove(unnecessarySpec);
+		}
+
+		// Recursion.
+		if(nextElement instanceof IHierarchicElementContainer) {
+			for(IHierarchicElement elem : ((IHierarchicElementContainer)nextElement)
+					.getContainedElements()) {
+				removeVariabilitySpecifications(elem);
+			}
+		}
+	}
 }

org.fortiss.tooling.ext.reuse/src/org/fortiss/tooling/ext/reuse/service/ReuseProviderService.java

 /*-------------------------------------------------------------------------+
-| Copyright 2021 fortiss GmbH                                              |
+| Copyright 2023 fortiss GmbH                                              |
 |                                                                          |
 | Licensed under the Apache License, Version 2.0 (the "License");          |
 | you may not use this file except in compliance with the License.         |
@@ -45,7 +45,8 @@ public class ReuseProviderService extends EObjectAwareServiceBase<IReuseProvider
 	 * List of {@link EObject} {@link Class}es that might exist inside reuse
 	 * elements as external references.
 	 */
-	private static List<Class<? extends EObject>> possibleExternalReferenceClasses = new ArrayList<>();
+	private static List<Class<? extends EObject>> possibleExternalReferenceClasses =
+			new ArrayList<>();
 
 	/**
 	 * Returns the singleton instance of {@link ReuseProviderService}.
@@ -79,22 +80,30 @@ public class ReuseProviderService extends EObjectAwareServiceBase<IReuseProvider
 	/** {@inheritDoc} */
 	@SuppressWarnings("unchecked")
 	@Override
-	public <T extends EObject> void registerReuseProvider(IReuseProvider<T> provider, Class<T> cls) {
-		addHandler(cls, (IReuseProvider<EObject>) provider);
-		if (!reuseElementClasses.contains(cls)) {
+	public <T extends EObject> void registerReuseProvider(IReuseProvider<T> provider,
+			Class<T> cls) {
+		addHandler(cls, (IReuseProvider<EObject>)provider);
+		if(!reuseElementClasses.contains(cls)) {
 			reuseElementClasses.add(cls);
 		}
 		possibleExternalReferenceClasses.addAll(provider.getPossibleExternalReferenceClasses());
 	}
 
+	/** {@inheritDoc} */
+	@Override
+	public boolean prepareReuseElementForLibrary(EObject reuseElement) {
+		IReuseProvider<EObject> provider = getReuseProvider(reuseElement);
+		if(provider != null) {
+			return provider.prepareReuseElementForLibrary(reuseElement);
+		}
+		return false;
+	}
+
 	/** {@inheritDoc} */
 	@Override
 	public boolean updateReuseElement(EObject elemToBeUpdated, EObject newElem) {
-		List<IReuseProvider<EObject>> registeredHandlers = getRegisteredHandlers(elemToBeUpdated.getClass());
-		// there should only be one handler registered per class for the reuse case
-		if (registeredHandlers != null && registeredHandlers.size() == 1) {
-			// get(0) is safe due to size check above
-			IReuseProvider<EObject> provider = registeredHandlers.get(0);
+		IReuseProvider<EObject> provider = getReuseProvider(elemToBeUpdated);
+		if(provider != null) {
 			return provider.updateReuseElement(elemToBeUpdated, newElem);
 		}
 		return false;
@@ -103,11 +112,8 @@ public class ReuseProviderService extends EObjectAwareServiceBase<IReuseProvider
 	/** {@inheritDoc} */
 	@Override
 	public boolean setReuseElementName(EObject reuseElement, String name) {
-		List<IReuseProvider<EObject>> registeredHandlers = getRegisteredHandlers(reuseElement.getClass());
-		// there should only be one handler registered per class for the reuse case
-		if (registeredHandlers != null && registeredHandlers.size() == 1) {
-			// get(0) is safe due to size check above
-			IReuseProvider<EObject> provider = registeredHandlers.get(0);
+		IReuseProvider<EObject> provider = getReuseProvider(reuseElement);
+		if(provider != null) {
 			return provider.setReuseElementName(reuseElement, name);
 		}
 		return false;
@@ -116,11 +122,8 @@ public class ReuseProviderService extends EObjectAwareServiceBase<IReuseProvider
 	/** {@inheritDoc} */
 	@Override
 	public String getReuseElementName(EObject reuseElement) {
-		List<IReuseProvider<EObject>> registeredHandlers = getRegisteredHandlers(reuseElement.getClass());
-		// there should only be one handler registered per class for the reuse case
-		if (registeredHandlers != null && registeredHandlers.size() == 1) {
-			// get(0) is safe due to size check above
-			IReuseProvider<EObject> provider = registeredHandlers.get(0);
+		IReuseProvider<EObject> provider = getReuseProvider(reuseElement);
+		if(provider != null) {
 			return provider.getReuseElementName(reuseElement);
 		}
 		return null;
@@ -129,11 +132,8 @@ public class ReuseProviderService extends EObjectAwareServiceBase<IReuseProvider
 	/** {@inheritDoc} */
 	@Override
 	public boolean setReuseElementComment(EObject reuseElement, String comment) {
-		List<IReuseProvider<EObject>> registeredHandlers = getRegisteredHandlers(reuseElement.getClass());
-		// there should only be one handler registered per class for the reuse case
-		if (registeredHandlers != null && registeredHandlers.size() == 1) {
-			// get(0) is safe due to size check above
-			IReuseProvider<EObject> provider = registeredHandlers.get(0);
+		IReuseProvider<EObject> provider = getReuseProvider(reuseElement);
+		if(provider != null) {
 			return provider.setReuseElementComment(reuseElement, comment);
 		}
 		return false;
@@ -142,11 +142,8 @@ public class ReuseProviderService extends EObjectAwareServiceBase<IReuseProvider
 	/** {@inheritDoc} */
 	@Override
 	public String getReuseElementComment(EObject reuseElement) {
-		List<IReuseProvider<EObject>> registeredHandlers = getRegisteredHandlers(reuseElement.getClass());
-		// there should only be one handler registered per class for the reuse case
-		if (registeredHandlers != null && registeredHandlers.size() == 1) {
-			// get(0) is safe due to size check above
-			IReuseProvider<EObject> provider = registeredHandlers.get(0);
+		IReuseProvider<EObject> provider = getReuseProvider(reuseElement);
+		if(provider != null) {
 			return provider.getReuseElementComment(reuseElement);
 		}
 		return null;
@@ -187,4 +184,19 @@ public class ReuseProviderService extends EObjectAwareServiceBase<IReuseProvider
 	public void startService() {
 		IKernelIntrospectionSystemService.getInstance().registerService(this);
 	}
-}
+
\ No newline at end of file
+	/**
+	 * Returns the reuse provider/handler for the class of the given element. If none can be found,
+	 * null is returned.
+	 */
+	private IReuseProvider<EObject> getReuseProvider(EObject element) {
+		List<IReuseProvider<EObject>> registeredHandlers =
+				getRegisteredHandlers(element.getClass());
+		// There should only be one handler registered per class for the reuse case.
+		if(registeredHandlers != null && registeredHandlers.size() == 1) {
+			// get(0) is safe due to size check above.
+			return registeredHandlers.get(0);
+		}
+		return null;
+	}
+}

org.fortiss.tooling.ext.reuse/src/org/fortiss/tooling/ext/reuse/utils/.ratings

 ReuseLibraryModelElementFactory.java 4ee3eb7449e212643992a3dec6cfb8f4278efb70 GREEN
 ReuseLibraryUtilsBasics.java 1d60936f98bd09e1ba1715192f5263f89b4942fe GREEN
-ReuseLibraryUtilsManipulation.java 77a646db5a63ba7c61664dbcaf34a9036003fde5 GREEN
+ReuseLibraryUtilsManipulation.java fbb36279eb20cb46a4f2b79fed33dd5395d6da3e GREEN

org.fortiss.tooling.ext.reuse/src/org/fortiss/tooling/ext/reuse/utils/ReuseLibraryUtilsManipulation.java

 /*-------------------------------------------------------------------------+
-| Copyright 2022 fortiss GmbH                                              |
+| Copyright 2023 fortiss GmbH                                              |
 |                                                                          |
 | Licensed under the Apache License, Version 2.0 (the "License");          |
 | you may not use this file except in compliance with the License.         |
@@ -22,6 +22,16 @@ import static org.fortiss.tooling.ext.reuse.storage.ReuseLibraryStorageManager.d
 import static org.fortiss.tooling.ext.reuse.storage.ReuseLibraryStorageManager.saveReuseLibrary;
 import static org.fortiss.tooling.ext.reuse.utils.ReuseLibraryModelElementFactory.createReuseElementSpec;
 import static org.fortiss.tooling.ext.reuse.utils.ReuseLibraryModelElementFactory.createReuseLibrary;
+import static org.fortiss.tooling.ext.reuse.utils.ReuseLibraryUtilsBasics.getAllReuseSpecs;
+import static org.fortiss.tooling.ext.reuse.utils.ReuseLibraryUtilsBasics.getDateAsString;
+import static org.fortiss.tooling.ext.reuse.utils.ReuseLibraryUtilsBasics.getFirstReuseElementUUID;
+import static org.fortiss.tooling.ext.reuse.utils.ReuseLibraryUtilsBasics.getFirstSourceLibraryOfElement;
+import static org.fortiss.tooling.ext.reuse.utils.ReuseLibraryUtilsBasics.getReuseElementName;
+import static org.fortiss.tooling.ext.reuse.utils.ReuseLibraryUtilsBasics.getReuseElementUUIDForLibrary;
+import static org.fortiss.tooling.ext.reuse.utils.ReuseLibraryUtilsBasics.getReuseSpecLinkedToThisLibraryElement;
+import static org.fortiss.tooling.ext.reuse.utils.ReuseLibraryUtilsBasics.setReuseElementComment;
+import static org.fortiss.tooling.ext.reuse.utils.ReuseLibraryUtilsBasics.setReuseElementLastUpdateNow;
+import static org.fortiss.tooling.ext.reuse.utils.ReuseLibraryUtilsBasics.setReuseElementName;
 import static org.fortiss.tooling.kernel.utils.EcoreUtils.copy;
 import static org.fortiss.tooling.kernel.utils.EcoreUtils.getAllReferencesSetting;
 import static org.fortiss.tooling.kernel.utils.EcoreUtils.replaceEObjectReferences;
@@ -62,11 +72,12 @@ public class ReuseLibraryUtilsManipulation {
 	 * Fixes the IDs of the model containing the given {@link EObject}, since
 	 * updating reuse elements can produce duplicated IDs.
 	 *
-	 * @param element A reuse element of the model
+	 * @param element
+	 *            A reuse element of the model
 	 */
 	public static void fixIDs(EObject element) {
 		EObject root = element;
-		while (root.eContainer() != null) {
+		while(root.eContainer() != null) {
 			root = root.eContainer();
 		}
 		removeDuplicateIds(root);
@@ -79,14 +90,16 @@ public class ReuseLibraryUtilsManipulation {
 	 * changes between reuse elements with the same origin. Returns null if given
 	 * element is invalid (e.g. not a reuse element).
 	 *
-	 * @param element    The element of which a hash code should be created
-	 * @param modifyDate The date of the last update/modification of the given
-	 *                   element
+	 * @param element
+	 *            The element of which a hash code should be created
+	 * @param modifyDate
+	 *            The date of the last update/modification of the given
+	 *            element
 	 * @return String of the created hash code integer (or null for an invalid
 	 *         input)
 	 */
 	public static String createReuseHashAsString(EObject element, ZonedDateTime modifyDate) {
-		if (element != null && modifyDate != null) {
+		if(element != null && modifyDate != null) {
 			// hashCode() does not change through element differences caused by simple
 			// changes like name or new ports, etc.
 			// Therefore, we are currently modifying the hash with the date of the last
@@ -94,8 +107,7 @@ public class ReuseLibraryUtilsManipulation {
 			// e.g. if the original reuse element in the library was updated by someone else
 			// in the meantime).
 			int hash = element.hashCode();
-			String hashString = String.valueOf(hash) + "__"
-					+ ReuseLibraryUtilsBasics.getDateAsString(modifyDate, false);
+			String hashString = String.valueOf(hash) + "__" + getDateAsString(modifyDate, false);
 			return hashString;
 		}
 		return null;
@@ -112,24 +124,27 @@ public class ReuseLibraryUtilsManipulation {
 	 * compare() method that returns 0 if both given {@link IConnector}s are
 	 * matching, otherwise +/-1.
 	 *
-	 * @param target                   The target element (e.g. the replaced
-	 *                                 element)
-	 * @param source                   The source element (e.g. the replacing
-	 *                                 element)
-	 * @param connectorMatchComparator A comparator that will return 0 with
-	 *                                 compare() if both given {@link IConnector}s
-	 *                                 are matching
+	 * @param target
+	 *            The target element (e.g. the replaced
+	 *            element)
+	 * @param source
+	 *            The source element (e.g. the replacing
+	 *            element)
+	 * @param connectorMatchComparator
+	 *            A comparator that will return 0 with
+	 *            compare() if both given {@link IConnector}s
+	 *            are matching
 	 */
-	public static void removeNonMatchingConnections(IHierarchicElement target, IHierarchicElement source,
-			Comparator<IConnector> connectorMatchComparator) {
+	public static void removeNonMatchingConnections(IHierarchicElement target,
+			IHierarchicElement source, Comparator<IConnector> connectorMatchComparator) {
 
 		IConnector matchedConnector = null;
-		for (IConnector targetConnector : target.getConnectors()) {
+		for(IConnector targetConnector : target.getConnectors()) {
 			// check if a matching connector can be found
 			boolean saveConnections = false;
-			for (IConnector sourceConnector : source.getConnectors()) {
+			for(IConnector sourceConnector : source.getConnectors()) {
 				// matching is done via custom compare method (individual comparators possible)
-				if (connectorMatchComparator.compare(targetConnector, sourceConnector) == 0) {
+				if(connectorMatchComparator.compare(targetConnector, sourceConnector) == 0) {
 					matchedConnector = sourceConnector;
 					saveConnections = true;
 					replaceEObjectReferences(targetConnector, matchedConnector);
@@ -139,27 +154,27 @@ public class ReuseLibraryUtilsManipulation {
 
 			// remove all connections or replace one end of them if a match was found
 			List<IConnection> connectionsToBeRemoved = new ArrayList<IConnection>();
-			for (IConnection incoming : targetConnector.getIncoming()) {
-				if (saveConnections) {
+			for(IConnection incoming : targetConnector.getIncoming()) {
+				if(saveConnections) {
 					incoming.setTarget(matchedConnector);
 				} else {
 					connectionsToBeRemoved.add(incoming);
 				}
 			}
-			for (IConnection outgoing : targetConnector.getOutgoing()) {
-				if (saveConnections) {
+			for(IConnection outgoing : targetConnector.getOutgoing()) {
+				if(saveConnections) {
 					outgoing.setSource(matchedConnector);
 				} else {
 					connectionsToBeRemoved.add(outgoing);
 				}
 			}
-			for (IConnection connection : connectionsToBeRemoved) {
+			for(IConnection connection : connectionsToBeRemoved) {
 				delete(connection);
 			}
 
 			// delete all external references
-			if (!saveConnections) {
-				for (Setting setting : getAllReferencesSetting(targetConnector)) {
+			if(!saveConnections) {
+				for(Setting setting : getAllReferencesSetting(targetConnector)) {
 					delete(setting.getEObject());
 				}
 			}
@@ -169,46 +184,54 @@ public class ReuseLibraryUtilsManipulation {
 	/**
 	 * Setups a given reuse element for its placement inside a {@link ReuseLibrary}.
 	 *
-	 * @param element        The target reuse element
-	 * @param connectingSpec The reuse specification used as link/trace/reference
+	 * @param element
+	 *            The target reuse element
+	 * @param connectingSpec
+	 *            The reuse specification used as link/trace/reference
 	 */
-	public static void setupElementForLibrary(IModelElement element, ReuseElementSpec connectingSpec) {
-		// currently, it is needed that only the original specification for this library
-		// should exist (and also only the newest one) -> remove all others
-		for (ReuseElementSpec spec : ReuseLibraryUtilsBasics.getAllReuseSpecs(element)) {
-			if (!(connectingSpec.getElementUUID().equals(spec.getElementUUID())
-					&& connectingSpec.getLastUpdate().equals(spec.getLastUpdate()))) {
+	public static void setupElementForLibrary(IModelElement element,
+			ReuseElementSpec connectingSpec) {
+		// Currently, it is needed that only the original specification for this library
+		// should exist (and also only the newest one) -> remove all others.
+		for(ReuseElementSpec spec : getAllReuseSpecs(element)) {
+			if(!(connectingSpec.getElementUUID().equals(spec.getElementUUID()) &&
+					connectingSpec.getLastUpdate().equals(spec.getLastUpdate()))) {
 				element.getSpecifications().remove(spec);
 			}
 		}
+		// Execute all other more specific preparations (type dependent).
+		IReuseProviderService.getInstance().prepareReuseElementForLibrary(element);
 	}
 
 	/**
 	 * Creates a reuse element based on a given {@link EObject} for its placement
 	 * inside a {@link ReuseLibrary}.
 	 *
-	 * @param originalElement The original element that should be used as base for
-	 *                        the new reuse element
-	 * @param library         The reuse library in which the new reuse element
-	 *                        should be added (later)
-	 * @param saveName        The name of the new reuse element with which it should
-	 *                        be saved in the library
+	 * @param originalElement
+	 *            The original element that should be used as base for
+	 *            the new reuse element
+	 * @param library
+	 *            The reuse library in which the new reuse element
+	 *            should be added (later)
+	 * @param saveName
+	 *            The name of the new reuse element with which it should
+	 *            be saved in the library
 	 *
 	 * @return The created reuse element for the library
 	 */
-	public static EObject createElementForLibrary(EObject originalElement, ReuseLibrary library, String saveName) {
+	public static EObject createElementForLibrary(EObject originalElement, ReuseLibrary library,
+			String saveName) {
 		// add to the original element a reuse reference to the new library
 		// (cast is safe: elements within the ReuseElementList are always IModelElement
 		// by design)
-		ReuseElementSpec spec = ReuseLibraryUtilsManipulation.addReuseSpecToElement((IModelElement) originalElement,
-				library);
+		ReuseElementSpec spec = addReuseSpecToElement((IModelElement)originalElement, library);
 		spec.setElementName(saveName);
-		ReuseLibraryUtilsManipulation.fixIDs(originalElement);
+		fixIDs(originalElement);
 
 		// copy, because origin should still exist further (but change name of copy)
 		EObject newElementForLibrary = copy(originalElement);
-		ReuseLibraryUtilsBasics.setReuseElementName(newElementForLibrary, saveName);
-		setupElementForLibrary((IModelElement) newElementForLibrary, spec);
+		setReuseElementName(newElementForLibrary, saveName);
+		setupElementForLibrary((IModelElement)newElementForLibrary, spec);
 
 		return newElementForLibrary;
 	}
@@ -217,11 +240,14 @@ public class ReuseLibraryUtilsManipulation {
 	 * Adds a {@link ReuseElementSpec} to the given element pointing to the given
 	 * {@link ReuseLibrary} (as source).
 	 *
-	 * @param element The target reuse element
-	 * @param library The connected reuse library
+	 * @param element
+	 *            The target reuse element
+	 * @param library
+	 *            The connected reuse library
 	 * @return The created reuse specification
 	 */
-	public static ReuseElementSpec addReuseSpecToElement(IModelElement element, ReuseLibrary library) {
+	public static ReuseElementSpec addReuseSpecToElement(IModelElement element,
+			ReuseLibrary library) {
 		ReuseElementSpec spec = createReuseElementSpec(element, library);
 		element.getSpecifications().add(spec);
 		return spec;
@@ -230,12 +256,15 @@ public class ReuseLibraryUtilsManipulation {
 	/**
 	 * Adds a given element to the given {@link ReuseLibrary}.
 	 *
-	 * @param element The reuse element that should be added
-	 * @param library The target reuse library
+	 * @param element
+	 *            The reuse element that should be added
+	 * @param library
+	 *            The target reuse library
 	 * @throws IOException
 	 * @throws CoreException
 	 */
-	public static void addElementToLibrary(EObject element, ReuseLibrary library) throws IOException, CoreException {
+	public static void addElementToLibrary(EObject element, ReuseLibrary library)
+			throws IOException, CoreException {
 		library.getReuseElementList().add(element);
 		saveReuseLibrary(library);
 	}
@@ -244,15 +273,15 @@ public class ReuseLibraryUtilsManipulation {
 	 * Creates a new {@link ReuseLibrary} with the given name. If no name is
 	 * received, the default library name will be used.
 	 *
-	 * @param libraryName The name of the new reuse library
+	 * @param libraryName
+	 *            The name of the new reuse library
 	 * @return The requested reuse library
 	 */
 	public static ReuseLibrary createAndAddReuseLibrary(String libraryName) {
-		if (libraryName == null || libraryName.equals("")) {
+		if(libraryName == null || libraryName.equals("")) {
 			return createReuseLibrary();
-		} else {
-			return createReuseLibrary(libraryName);
 		}
+		return createReuseLibrary(libraryName);
 	}
 
 	/**
@@ -261,15 +290,19 @@ public class ReuseLibraryUtilsManipulation {
 	 * given name in the end). The {@link ReuseElementSpec} references the original
 	 * element (with its library).
 	 *
-	 * @param originalElementInLibrary The target reuse element inside a reuse
-	 *                                 library that should be replace by the new
-	 *                                 reuse element
-	 * @param newElement               The new reuse element which is the
-	 *                                 replacement of the current element in the
-	 *                                 given library
-	 * @param referencingSpec          The reuse specification that points to the
-	 *                                 original reuse element in the library
-	 * @param newName                  The new name of the element after replacement
+	 * @param originalElementInLibrary
+	 *            The target reuse element inside a reuse
+	 *            library that should be replace by the new
+	 *            reuse element
+	 * @param newElement
+	 *            The new reuse element which is the
+	 *            replacement of the current element in the
+	 *            given library
+	 * @param referencingSpec
+	 *            The reuse specification that points to the
+	 *            original reuse element in the library
+	 * @param newName
+	 *            The new name of the element after replacement
 	 */
 	public static void replaceElementInLibrary(EObject originalElementInLibrary, EObject newElement,
 			ReuseElementSpec referencingSpec, String newName) {
@@ -278,11 +311,11 @@ public class ReuseLibraryUtilsManipulation {
 		ZonedDateTime now = ZonedDateTime.now();
 		referencingSpec.setLastUpdate(now);
 		referencingSpec.setElementName(newName);
-		referencingSpec.setElementHash(ReuseLibraryUtilsManipulation.createReuseHashAsString(newElement, now));
+		referencingSpec.setElementHash(createReuseHashAsString(newElement, now));
 
 		EObject newLibraryElement = copy(newElement);
-		ReuseLibraryUtilsBasics.setReuseElementName(newLibraryElement, newName);
-		setupElementForLibrary((IModelElement) newLibraryElement, referencingSpec);
+		setReuseElementName(newLibraryElement, newName);
+		setupElementForLibrary((IModelElement)newLibraryElement, referencingSpec);
 
 		replace(originalElementInLibrary, newLibraryElement);
 	}
@@ -293,54 +326,59 @@ public class ReuseLibraryUtilsManipulation {
 	 * the given name in the end). Returns the new element in the project if the
 	 * replacement/update was successful, otherwise null.
 	 *
-	 * @param elementInProject             The new reuse element which is the
-	 *                                     replacement of the current element in the
-	 *                                     given library
-	 * @param originalElementInLibrary     The target reuse element inside a reuse
-	 *                                     library that should be replace by the new
-	 *                                     reuse element
-	 * @param newName                      The new name of the element after
-	 *                                     replacement
-	 * @param overrideAdditionalReferences Flag whether all other possibly existing
-	 *                                     references in the (old) project element
-	 *                                     should be overridden/deleted (true) or if
-	 *                                     they should be kept (false)
+	 * @param elementInProject
+	 *            The new reuse element which is the
+	 *            replacement of the current element in the
+	 *            given library
+	 * @param originalElementInLibrary
+	 *            The target reuse element inside a reuse
+	 *            library that should be replace by the new
+	 *            reuse element
+	 * @param newName
+	 *            The new name of the element after
+	 *            replacement
+	 * @param keepAdditionalReferences
+	 *            Flag whether all other possibly existing
+	 *            references in the (old) project element
+	 *            should be overridden/deleted (false) or if
+	 *            they should be kept (true)
 	 *
 	 * @return The new element in the project if the replacement/update was
 	 *         successful, otherwise null.
 	 */
-	public static EObject replaceElementInProject(EObject elementInProject, EObject originalElementInLibrary,
-			String newName, boolean keepAdditionalReferences) {
-		if (originalElementInLibrary instanceof IModelElement && elementInProject instanceof IModelElement) {
-			IModelElement sourceElement = copy((IModelElement) originalElementInLibrary);
-			IModelElement modelElementInProject = (IModelElement) elementInProject;
+	public static EObject replaceElementInProject(EObject elementInProject,
+			EObject originalElementInLibrary, String newName, boolean keepAdditionalReferences) {
+		if(originalElementInLibrary instanceof IModelElement &&
+				elementInProject instanceof IModelElement) {
+			IModelElement sourceElement = copy((IModelElement)originalElementInLibrary);
+			IModelElement modelElementInProject = (IModelElement)elementInProject;
 			// first, the information of the reference and the new element
 			// needs to be updated and set up
-			List<ReuseElementSpec> specs = ReuseLibraryUtilsBasics.getAllReuseSpecs(sourceElement);
+			List<ReuseElementSpec> specs = getAllReuseSpecs(sourceElement);
 			ZonedDateTime now = ZonedDateTime.now();
-			if (specs.size() == 1) {
+			if(specs.size() == 1) {
 				// get(0) is safe due to size check
 				specs.get(0).setLastUpdate(now);
 			} else {
 				return null;
 			}
-			ReuseLibraryUtilsBasics.setReuseElementName(sourceElement, newName);
+			setReuseElementName(sourceElement, newName);
 
 			// if additional references should not be overridden but kept, they need to be
 			// saved/added in the source element (otherwise they will be overridden anyway)
-			if (keepAdditionalReferences) {
-				List<ReuseElementSpec> oldSpecs = ReuseLibraryUtilsBasics.getAllReuseSpecs(modelElementInProject);
+			if(keepAdditionalReferences) {
+				List<ReuseElementSpec> oldSpecs = getAllReuseSpecs(modelElementInProject);
 				// remove the specification of the current update/replacement (only additional
 				// ones added)
-				ReuseElementSpec mainSpec = ReuseLibraryUtilsBasics
-						.getReuseSpecLinkedToThisLibraryElement(modelElementInProject, sourceElement);
+				ReuseElementSpec mainSpec = getReuseSpecLinkedToThisLibraryElement(
+						modelElementInProject, sourceElement);
 				oldSpecs.remove(mainSpec);
 				sourceElement.getSpecifications().addAll(oldSpecs);
 			}
 
-			boolean success = IReuseProviderService.getInstance().updateReuseElement(modelElementInProject,
-					sourceElement);
-			if (success) {
+			boolean success = IReuseProviderService.getInstance()
+					.updateReuseElement(modelElementInProject, sourceElement);
+			if(success) {
 				return sourceElement;
 			}
 		}
@@ -350,16 +388,17 @@ public class ReuseLibraryUtilsManipulation {
 	/**
 	 * Deletes the given {@link ReuseLibrary}.
 	 *
-	 * @param library The target reuse library that should be deleted
+	 * @param library
+	 *            The target reuse library that should be deleted
 	 */
 	public static void deleteReuseLibrary(ReuseLibrary library) {
 		// currently, everything is based only on the reuse folder/file structure, which
 		// is why it is enough to just delete the local folder
 		try {
 			deleteReuseLibraryFolder(library);
-		} catch (CoreException e) {
+		} catch(CoreException e) {
 			error(getDefault(), "Error during deleting reuse library folder", e);
-			showError("Cannot delete reuse library: " + ReuseLibraryUtilsBasics.getReuseElementName(library));
+			showError("Cannot delete reuse library: " + getReuseElementName(library));
 		}
 	}
 
@@ -367,32 +406,35 @@ public class ReuseLibraryUtilsManipulation {
 	 * Deletes the given reuse element by deleting its entry in the local file of
 	 * the given {@link ReuseLibrary} (if it exists there).
 	 *
-	 * @param element       The target reuse element that should be deleted
-	 * @param sourceLibrary The reuse library in which the deletion should happen
+	 * @param element
+	 *            The target reuse element that should be deleted
+	 * @param sourceLibrary
+	 *            The reuse library in which the deletion should happen
 	 */
-	public static void deleteReuseElementInLibraryFile(EObject element, ReuseLibrary sourceLibrary) {
+	public static void deleteReuseElementInLibraryFile(EObject element,
+			ReuseLibrary sourceLibrary) {
 		// the objects might not be the same anymore, which is why we need to identify
 		// the correct object via the reuse UUID
 		EObject correctLibraryElement = null;
 		EList<EObject> libraryElementList = sourceLibrary.getReuseElementList();
-		for (EObject libraryElement : libraryElementList) {
-			if (ReuseLibraryUtilsBasics.getFirstReuseElementUUID(libraryElement)
-					.equals(ReuseLibraryUtilsBasics.getReuseElementUUIDForLibrary(element, sourceLibrary))) {
+		for(EObject libraryElement : libraryElementList) {
+			if(getFirstReuseElementUUID(libraryElement)
+					.equals(getReuseElementUUIDForLibrary(element, sourceLibrary))) {
 				correctLibraryElement = libraryElement;
 				break;
 			}
 		}
-		if (correctLibraryElement == null) {
+		if(correctLibraryElement == null) {
 			return;
 		}
 		libraryElementList.remove(correctLibraryElement);
 
 		try {
 			saveReuseLibrary(sourceLibrary);
-		} catch (IOException | CoreException e) {
+		} catch(IOException | CoreException e) {
 			error(getDefault(), "Error during removing reuse element from reuse library", e);
-			showError("Cannot remove reuse element: " + ReuseLibraryUtilsBasics.getReuseElementName(element)
-					+ " from this reuse library: " + ReuseLibraryUtilsBasics.getReuseElementName(sourceLibrary));
+			showError("Cannot remove reuse element: " + getReuseElementName(element) +
+					" from this reuse library: " + getReuseElementName(sourceLibrary));
 		}
 	}
 
@@ -401,11 +443,12 @@ public class ReuseLibraryUtilsManipulation {
 	 * the {@link ReuseLibrary} that is mentioned as first (or only) source library
 	 * for this reuse element (in its {link ReuseElementSpec}s).
 	 *
-	 * @param element The target reuse element that should be deleted
+	 * @param element
+	 *            The target reuse element that should be deleted
 	 */
 	public static void deleteReuseElementInLibraryFile(EObject element) {
-		ReuseLibrary sourceLibrary = ReuseLibraryUtilsBasics.getFirstSourceLibraryOfElement(element);
-		if (sourceLibrary != null) {
+		ReuseLibrary sourceLibrary = getFirstSourceLibraryOfElement(element);
+		if(sourceLibrary != null) {
 			deleteReuseElementInLibraryFile(element, sourceLibrary);
 		}
 	}
@@ -417,71 +460,73 @@ public class ReuseLibraryUtilsManipulation {
 	 * {@link ReuseLibrary} is where the reuse element will be updated with the new
 	 * name.
 	 *
-	 * @param element       The target reuse element that should be updated
-	 * @param newName       The new name as string
-	 * @param sourceLibrary The reuse library in which the update should happen
+	 * @param element
+	 *            The target reuse element that should be updated
+	 * @param newName
+	 *            The new name as string
+	 * @param sourceLibrary
+	 *            The reuse library in which the update should happen
 	 */
-	public static void updateReuseElementFileWithName(EObject element, String newName, ReuseLibrary sourceLibrary) {
-		if (element == null || newName == null || newName.isBlank()) {
+	public static void updateReuseElementFileWithName(EObject element, String newName,
+			ReuseLibrary sourceLibrary) {
+		if(element == null || newName == null || newName.isBlank()) {
 			return;
 		}
 
 		boolean modifiedLibrary = false;
 		ReuseLibrary libraryForDeletion = null;
 		String errorObject = "";
-		if (element instanceof ReuseLibrary) {
+		if(element instanceof ReuseLibrary) {
 			// since the folder and file names of a reuse library contain the library name
 			// (beside its UUID), the easiest way to rename it is to save it as new library
 			// (where only the name is changed, not UUID, etc.) and delete its previous
 			// library folder (save and deletion are done at the end of this method)
-			sourceLibrary = (ReuseLibrary) element;
+			sourceLibrary = (ReuseLibrary)element;
 			// copy, because origin should still exist further for deletion
 			libraryForDeletion = copy(sourceLibrary);
 
-			ReuseLibraryUtilsBasics.setReuseElementName(sourceLibrary, newName);
-			for (EObject libraryElement : sourceLibrary.getReuseElementList()) {
+			setReuseElementName(sourceLibrary, newName);
+			for(EObject libraryElement : sourceLibrary.getReuseElementList()) {
 				// cast is safe: elements within the ReuseElementList are always IModelElement
 				// by design
-				List<ReuseElementSpec> specList = ReuseLibraryUtilsBasics
-						.getAllReuseSpecs((IModelElement) libraryElement);
-				for (ReuseElementSpec reuseSpec : specList) {
+				List<ReuseElementSpec> specList = getAllReuseSpecs(libraryElement);
+				for(ReuseElementSpec reuseSpec : specList) {
 					reuseSpec.setSourceLibName(newName);
 				}
 			}
 
-			errorObject = "reuse library '" + ReuseLibraryUtilsBasics.getReuseElementName(sourceLibrary) + "'";
+			errorObject = "reuse library '" + getReuseElementName(sourceLibrary) + "'";
 			modifiedLibrary = true;
 		} else {
 			// the objects might not be the same anymore, which is why we need to identify
 			// the correct object via the reuse UUID
-			for (EObject libraryElement : sourceLibrary.getReuseElementList()) {
-				if (ReuseLibraryUtilsBasics.getFirstReuseElementUUID(libraryElement)
-						.equals(ReuseLibraryUtilsBasics.getReuseElementUUIDForLibrary(element, sourceLibrary))) {
-					ReuseLibraryUtilsBasics.setReuseElementName(libraryElement, newName);
+			for(EObject libraryElement : sourceLibrary.getReuseElementList()) {
+				if(getFirstReuseElementUUID(libraryElement)
+						.equals(getReuseElementUUIDForLibrary(element, sourceLibrary))) {
+					setReuseElementName(libraryElement, newName);
 					// cast is safe: elements within the ReuseElementList are always IModelElement
 					// by design
-					List<ReuseElementSpec> specList = ReuseLibraryUtilsBasics
-							.getAllReuseSpecs((IModelElement) libraryElement);
-					for (ReuseElementSpec reuseSpec : specList) {
+					List<ReuseElementSpec> specList = getAllReuseSpecs(libraryElement);
+					for(ReuseElementSpec reuseSpec : specList) {
 						reuseSpec.setElementName(newName);
 					}
-					ReuseLibraryUtilsBasics.setReuseElementLastUpdateNow(libraryElement);
+					setReuseElementLastUpdateNow(libraryElement);
 
-					errorObject = "reuse element '" + ReuseLibraryUtilsBasics.getReuseElementName(libraryElement)
-							+ "' in reuse library '" + ReuseLibraryUtilsBasics.getReuseElementName(sourceLibrary) + "'";
+					errorObject = "reuse element '" + getReuseElementName(libraryElement) +
+							"' in reuse library '" + getReuseElementName(sourceLibrary) + "'";
 					modifiedLibrary = true;
 					break;
 				}
 			}
 		}
 
-		if (modifiedLibrary) {
+		if(modifiedLibrary) {
 			try {
 				saveReuseLibrary(sourceLibrary);
-				if (libraryForDeletion != null) {
+				if(libraryForDeletion != null) {
 					deleteReuseLibraryFolder(libraryForDeletion);
 				}
-			} catch (IOException | CoreException e) {
+			} catch(IOException | CoreException e) {
 				error(getDefault(), "Error during renaming " + errorObject, e);
 				showError("Cannot rename " + errorObject);
 			}
@@ -495,15 +540,17 @@ public class ReuseLibraryUtilsManipulation {
 	 * {@link ReuseLibrary}, which is mentioned in its {link ReuseElementSpec}s, is
 	 * where the reuse element will be updated with the new name.
 	 *
-	 * @param element The target reuse element that should be updated
-	 * @param newName The new name as string
+	 * @param element
+	 *            The target reuse element that should be updated
+	 * @param newName
+	 *            The new name as string
 	 */
 	public static void updateReuseElementFileWithName(EObject element, String newName) {
-		if (element instanceof ReuseLibrary) {
+		if(element instanceof ReuseLibrary) {
 			updateReuseElementFileWithName(element, newName, null);
 		} else {
-			ReuseLibrary sourceLibrary = ReuseLibraryUtilsBasics.getFirstSourceLibraryOfElement(element);
-			if (sourceLibrary != null) {
+			ReuseLibrary sourceLibrary = getFirstSourceLibraryOfElement(element);
+			if(sourceLibrary != null) {
 				updateReuseElementFileWithName(element, newName, sourceLibrary);
 			}
 		}
@@ -516,42 +563,45 @@ public class ReuseLibraryUtilsManipulation {
 	 * {@link ReuseLibrary} is where the reuse element will be updated with the new
 	 * comment.
 	 *
-	 * @param element       The target reuse element that should be updated
-	 * @param newComment    The new comment as string
-	 * @param sourceLibrary The reuse library in which the update should happen
+	 * @param element
+	 *            The target reuse element that should be updated
+	 * @param newComment
+	 *            The new comment as string
+	 * @param sourceLibrary
+	 *            The reuse library in which the update should happen
 	 */
 	public static void updateReuseElementFileWithComment(EObject element, String newComment,
 			ReuseLibrary sourceLibrary) {
 		boolean modifiedLibrary = false;
 		String errorObject = "";
-		if (element instanceof ReuseLibrary) {
-			sourceLibrary = (ReuseLibrary) element;
-			ReuseLibraryUtilsBasics.setReuseElementComment(sourceLibrary, newComment);
+		if(element instanceof ReuseLibrary) {
+			sourceLibrary = (ReuseLibrary)element;
+			setReuseElementComment(sourceLibrary, newComment);
 
-			errorObject = "reuse library '" + ReuseLibraryUtilsBasics.getReuseElementName(sourceLibrary) + "'";
+			errorObject = "reuse library '" + getReuseElementName(sourceLibrary) + "'";
 			modifiedLibrary = true;
 		} else {
 			// the objects might not be the same anymore, which is why we need to identify
 			// the correct object via the reuse UUID
 			EList<EObject> libraryElementList = sourceLibrary.getReuseElementList();
-			for (EObject libraryElement : libraryElementList) {
-				if (ReuseLibraryUtilsBasics.getFirstReuseElementUUID(libraryElement)
-						.equals(ReuseLibraryUtilsBasics.getReuseElementUUIDForLibrary(element, sourceLibrary))) {
-					ReuseLibraryUtilsBasics.setReuseElementComment(libraryElement, newComment);
-					ReuseLibraryUtilsBasics.setReuseElementLastUpdateNow(libraryElement);
-
-					errorObject = "reuse element '" + ReuseLibraryUtilsBasics.getReuseElementName(libraryElement)
-							+ "' in reuse library '" + ReuseLibraryUtilsBasics.getReuseElementName(sourceLibrary) + "'";
+			for(EObject libraryElement : libraryElementList) {
+				if(getFirstReuseElementUUID(libraryElement)
+						.equals(getReuseElementUUIDForLibrary(element, sourceLibrary))) {
+					setReuseElementComment(libraryElement, newComment);
+					setReuseElementLastUpdateNow(libraryElement);
+
+					errorObject = "reuse element '" + getReuseElementName(libraryElement) +
+							"' in reuse library '" + getReuseElementName(sourceLibrary) + "'";
 					modifiedLibrary = true;
 					break;
 				}
 			}
 		}
 
-		if (modifiedLibrary) {
+		if(modifiedLibrary) {
 			try {
 				saveReuseLibrary(sourceLibrary);
-			} catch (IOException | CoreException e) {
+			} catch(IOException | CoreException e) {
 				error(getDefault(), "Error during modifying " + errorObject, e);
 				showError("Cannot modify " + errorObject);
 			}
@@ -565,15 +615,17 @@ public class ReuseLibraryUtilsManipulation {
 	 * {@link ReuseLibrary}, which is mentioned in its {link ReuseElementSpec}s, is
 	 * where the reuse element will be updated with the new comment.
 	 *
-	 * @param element    The target reuse element that should be updated
-	 * @param newComment The new comment as string
+	 * @param element
+	 *            The target reuse element that should be updated
+	 * @param newComment
+	 *            The new comment as string
 	 */
 	public static void updateReuseElementFileWithComment(EObject element, String newComment) {
-		if (element instanceof ReuseLibrary) {
+		if(element instanceof ReuseLibrary) {
 			updateReuseElementFileWithComment(element, newComment, null);
 		} else {
-			ReuseLibrary sourceLibrary = ReuseLibraryUtilsBasics.getFirstSourceLibraryOfElement(element);
-			if (sourceLibrary != null) {
+			ReuseLibrary sourceLibrary = getFirstSourceLibraryOfElement(element);
+			if(sourceLibrary != null) {
 				updateReuseElementFileWithComment(element, newComment, sourceLibrary);
 			}
 		}