canDecompose is not recursive (decompose is)

refs 133

org.fortiss.tooling.base/trunk/src/org/fortiss/tooling/base/decompose/HierarchicElementCompositorBase.java

@@ -24,7 +24,6 @@ import org.eclipse.emf.ecore.EObject;
 import org.eclipse.emf.ecore.util.EcoreUtil;
 import org.fortiss.tooling.base.model.element.IConnection;
 import org.fortiss.tooling.base.model.element.IConnector;
-import org.fortiss.tooling.base.model.element.IHiddenSpecification;
 import org.fortiss.tooling.base.model.element.IHierarchicElement;
 import org.fortiss.tooling.base.model.element.IHierarchicElementContainer;
 import org.fortiss.tooling.base.model.element.IModelElement;
@@ -45,17 +44,6 @@ import org.fortiss.tooling.kernel.service.IElementCompositorService;
 public abstract class HierarchicElementCompositorBase<HE extends IHierarchicElementContainer>
 		implements IElementCompositor<HE> {
 
-	/**
-	 * Decomposition ability check that takes care of the whole model subtree.
-	 * Subclasses implement {@link #canDecompose*****()} instead.
-	 */
-	@SuppressWarnings("javadoc")
-	@Override
-	public final boolean canDecompose(EObject contained) {
-		// TODO remove
-		return iterateDecompose(contained, true);
-	}
-
 	/**
 	 * Decomposition that takes care of the whole model subtree. Subclasses
 	 * implement {@link #decompose*****()} instead.
@@ -63,15 +51,9 @@ public abstract class HierarchicElementCompositorBase<HE extends IHierarchicElem
 	@SuppressWarnings("javadoc")
 	@Override
 	public final boolean decompose(EObject contained) {
-		return iterateDecompose(contained, false);
+		return iterateDecompose(contained);
 	}
 
-	/**
-	 * Returns whether the compositor is able to decompose the given model
-	 * element
-	 */
-	protected abstract boolean canDecomposeSpecific(EObject contained);
-
 	/**
 	 * Base implementation for element removal using EcoreUtil.delete
 	 * (non-recursively). Subclasses may override.
@@ -82,137 +64,40 @@ public abstract class HierarchicElementCompositorBase<HE extends IHierarchicElem
 	}
 
 	/** recursive traversion of all model elements in subtree */
-	private boolean iterateDecompose(EObject contained, boolean can) {
-
-		if (!canDecomposeSpecific(contained)) {
-			return false;
-		}
-
-		if (can) {
-			if (contained instanceof IModelElement) {
-				if (!iterateCanDecomposeSpecifications((IModelElement) contained)) {
-					return false;
-				}
-				// TODO CD: handle references
-			}
-			if (contained instanceof IHierarchicElementContainer) {
-				if (!iterateCanDecomposeSubelements((IHierarchicElementContainer) contained)) {
-					return false;
-				}
-			}
-			if (contained instanceof IHierarchicElement) {
-				IHierarchicElement he = (IHierarchicElement) contained;
-
-				if (!iterateCanDecomposeConnections(he.getConnectionsList())) {
-					return false;
-				}
-
-				if (!iterateCanDecomposeConnectors((IHierarchicElement) contained)) {
-					return false;
-				}
-
-			}
-			if (contained instanceof IConnector) {
-				IConnector connector = (IConnector) contained;
-				if (!iterateCanDecomposeConnections(connector.getIncomingList())) {
-					return false;
-				}
-				if (!iterateCanDecomposeConnections(connector.getOutgoingList())) {
-					return false;
-				}
-			}
-		} else {
-			if (contained instanceof IModelElement) {
-				if (!iterateDecomposeSpecifications((IModelElement) contained)) {
-					return false;
-				}
-				// TODO CD: handle references
-			}
-			if (contained instanceof IHierarchicElementContainer) {
-				if (!iterateDecomposeSubelements((IHierarchicElementContainer) contained)) {
-					return false;
-				}
-			}
-			if (contained instanceof IHierarchicElement) {
-				IHierarchicElement he = (IHierarchicElement) contained;
-
-				if (!iterateDecomposeConnections(he.getConnectionsList())) {
-					return false;
-				}
-
-				if (!iterateDecomposeConnectors((IHierarchicElement) contained)) {
-					return false;
-				}
-
-			}
-			if (contained instanceof IConnector) {
-				IConnector connector = (IConnector) contained;
-				if (!iterateDecomposeConnections(connector.getIncomingList())) {
-					return false;
-				}
-				if (!iterateDecomposeConnections(connector.getOutgoingList())) {
-					return false;
-				}
+	private boolean iterateDecompose(EObject contained) {
+		if (contained instanceof IModelElement) {
+			if (!iterateDecomposeSpecifications((IModelElement) contained)) {
+				return false;
 			}
-			return decomposeSpecific(contained);
+			// TODO CD: handle references
 		}
-
-		return true;
-	}
-
-	/**
-	 * Iterates over specifications of given {@link IModelElement} and checks
-	 * for decomposition ability
-	 */
-	private boolean iterateCanDecomposeSpecifications(IModelElement me) {
-		for (IModelElementSpecification spec : me.getSpecificationsList()) {
-			if (!canDecomposeSpecification(spec)) {
+		if (contained instanceof IHierarchicElementContainer) {
+			if (!iterateDecomposeSubelements((IHierarchicElementContainer) contained)) {
 				return false;
 			}
 		}
-		return true;
-	}
+		if (contained instanceof IHierarchicElement) {
+			IHierarchicElement he = (IHierarchicElement) contained;
 
-	/**
-	 * Iterates over sub elements of given {@link IHierarchicElementContainer}
-	 * and checks for decomposition ability.
-	 */
-	private boolean iterateCanDecomposeSubelements(
-			IHierarchicElementContainer contained) {
-		for (IHierarchicElement subelement : contained
-				.getContainedElementsList()) {
-			if (!canDecomposeSubElement(subelement)) {
+			if (!iterateDecomposeConnections(he.getConnectionsList())) {
 				return false;
 			}
-		}
-		return true;
-	}
 
-	/**
-	 * Iterates over list of connections and checks for disconnection ability or
-	 * decomposition ability of sub elements respectively.
-	 */
-	private boolean iterateCanDecomposeConnections(
-			EList<IConnection> connectionsList) {
-		for (IConnection conn : connectionsList) {
-			if (!canDecomposeConnection(conn)) {
+			if (!iterateDecomposeConnectors((IHierarchicElement) contained)) {
 				return false;
 			}
-		}
-		return true;
-	}
 
-	/**
-	 * Iterates over connectors of given {@link IHierarchicElement} and checks
-	 * for decomposition ability.
-	 */
-	private boolean iterateCanDecomposeConnectors(IHierarchicElement contained) {
-		for (IConnector c : contained.getConnectorsList()) {
-			if (!canDecomposeConnector(c)) {
+		}
+		if (contained instanceof IConnector) {
+			IConnector connector = (IConnector) contained;
+			if (!iterateDecomposeConnections(connector.getIncomingList())) {
+				return false;
+			}
+			if (!iterateDecomposeConnections(connector.getOutgoingList())) {
 				return false;
 			}
 		}
-		return true;
+		return decomposeSpecific(contained);
 	}
 
 	/**
@@ -277,51 +162,6 @@ public abstract class HierarchicElementCompositorBase<HE extends IHierarchicElem
 		return true;
 	}
 
-	/**
-	 * Base implementation returns compositors' decision by default. Subclasses
-	 * may override.
-	 */
-	protected boolean canDecomposeSpecification(
-			IModelElementSpecification element) {
-		if (element instanceof IHiddenSpecification) {
-			return true;
-		}
-		return IElementCompositorService.INSTANCE.canDecompose(element);
-	}
-
-	/**
-	 * Base implementation yet empty.
-	 */
-	protected boolean canDecomposeReference(
-			@SuppressWarnings("unused") EObject element) {
-		// TODO implement reference removal
-		return true;
-	}
-
-	/**
-	 * Base implementation returns compositors' decision by default. Subclasses
-	 * may override.
-	 */
-	protected boolean canDecomposeSubElement(IHierarchicElement element) {
-		return IElementCompositorService.INSTANCE.canDecompose(element);
-	}
-
-	/**
-	 * Base implementation returns compositors' decision by default. Subclasses
-	 * may override.
-	 */
-	protected boolean canDecomposeConnector(IConnector element) {
-		return IElementCompositorService.INSTANCE.canDecompose(element);
-	}
-
-	/**
-	 * Base implementation returns compositors' decision by default. Subclasses
-	 * may override.
-	 */
-	protected boolean canDecomposeConnection(IConnection conn) {
-		return IConnectionCompositorService.INSTANCE.canDisconnect(conn);
-	}
-
 	/**
 	 * Base implementation returns compositors' decomposition by default and
 	 * invokes EcoreUtil.delete() otherwise. Subclasses may override.