org.eclipse.uml2.uml.internal.operations.ConnectableElementOperations Maven / Gradle / Ivy

Go to download
/*
 * Copyright (c) 2006, 2010 IBM Corporation and others.
 * All rights reserved.   This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *   IBM - initial API and implementation
 *   Kenn Hussey - 323181
 *
 * $Id: ConnectableElementOperations.java,v 1.7 2010/09/28 21:02:15 khussey Exp $
 */
package org.eclipse.uml2.uml.internal.operations;

import java.util.List;

import org.eclipse.emf.common.util.ECollections;
import org.eclipse.emf.common.util.EList;
import org.eclipse.emf.common.util.UniqueEList;
import org.eclipse.emf.ecore.EStructuralFeature;
import org.eclipse.emf.ecore.InternalEObject;
import org.eclipse.emf.ecore.util.DelegatingEcoreEList;
import org.eclipse.uml2.uml.Classifier;
import org.eclipse.uml2.uml.Component;
import org.eclipse.uml2.uml.ConnectableElement;
import org.eclipse.uml2.uml.ConnectorEnd;
import org.eclipse.uml2.uml.Interface;
import org.eclipse.uml2.uml.Port;
import org.eclipse.uml2.uml.Property;
import org.eclipse.uml2.uml.Type;
import org.eclipse.uml2.uml.UMLPackage;

/**
 * A static utility class that provides operations related to 'Connectable Element' model objects.
 */
public class ConnectableElementOperations
		extends NamedElementOperations {

	protected ConnectableElementOperations() {
		super();
	}

	protected static class EndEList
			extends DelegatingEcoreEList {

		private static final long serialVersionUID = 1L;

		protected final EStructuralFeature eStructuralFeature;

		protected final EList delegateList;

		protected EndEList(InternalEObject owner,
				EStructuralFeature eStructuralFeature,
				EList delegateList) {
			super(owner);

			this.eStructuralFeature = eStructuralFeature;
			this.delegateList = delegateList;
		}

		@Override
		public EStructuralFeature getEStructuralFeature() {
			return eStructuralFeature;
		}

		@Override
		public int getFeatureID() {
			return owner.eDerivedStructuralFeatureID(
				eStructuralFeature.getFeatureID(), ConnectableElement.class);
		}

		@Override
		protected List delegateList() {
			return delegateList;
		}

		@Override
		protected void delegateAdd(int index, ConnectorEnd connectorEnd) {
			int delegateIndex = delegateList.indexOf(connectorEnd);

			if (delegateIndex != -1) {

				if (index != delegateIndex) {
					delegateList.move(index, connectorEnd);
				}
			} else if (index < delegateList.size()) {
				delegateList.add(index, connectorEnd);
			} else {
				delegateList.add(connectorEnd);
			}
		}

		@Override
		protected void didAdd(int index, ConnectorEnd newConnectorEnd) {
			super.didAdd(index, newConnectorEnd);

			newConnectorEnd.setRole((ConnectableElement) owner);
		}

		@Override
		protected void didRemove(int index, ConnectorEnd oldConnectorEnd) {
			super.didRemove(index, oldConnectorEnd);

			oldConnectorEnd.setRole(null);
		}

		@Override
		protected void didSet(int index, ConnectorEnd newConnectorEnd,
				ConnectorEnd oldConnectorEnd) {
			super.didSet(index, newConnectorEnd, oldConnectorEnd);

			newConnectorEnd.setRole((ConnectableElement) owner);
			oldConnectorEnd.setRole(null);
		}

	}

	/**
	 * 
	 * 
	 * 
	 * result = ConnectorEnd.allInstances()->select(e | e.role=self)
	 * @param connectableElement The receiving 'Connectable Element' model object.
	 * 
	 * @generated NOT
	 */
	public static EList getEnds(
			ConnectableElement connectableElement) {
		EList ends = new UniqueEList.FastCompare();

		for (EStructuralFeature.Setting setting : getNonNavigableInverseReferences(connectableElement)) {

			if (setting.getEStructuralFeature() == UMLPackage.Literals.CONNECTOR_END__ROLE) {
				ends.add((ConnectorEnd) setting.getEObject());
			}
		}

		return new EndEList((InternalEObject) connectableElement,
			UMLPackage.Literals.CONNECTABLE_ELEMENT__END, ends);
	}

	protected static EList getRequiredInterfaces(
			ConnectableElement connectableElement) {
		EList requiredInterfaces = new UniqueEList.FastCompare();

		if (connectableElement instanceof Port) {
			requiredInterfaces.addAll(((Port) connectableElement)
				.getRequireds());
		} else if (connectableElement instanceof Property) {
			Type type = connectableElement.getType();

			if (type instanceof Component) {
				ComponentOperations.getAllRequireds((Component) type,
					requiredInterfaces);
			} else if (type instanceof Classifier) {
				Classifier classifier = (Classifier) type;
				ComponentOperations.usedInterfaces(null, classifier, true,
					requiredInterfaces);

				for (Classifier parent : classifier.allParents()) {
					ComponentOperations.usedInterfaces(null, parent, true,
						requiredInterfaces);
				}
			}
		}

		for (int i = 0, size = requiredInterfaces.size(); i < size; i++) {

			for (Classifier parent : requiredInterfaces.get(i).allParents()) {

				if (parent instanceof Interface) {
					requiredInterfaces.add((Interface) parent);
				}
			}
		}

		return ECollections.unmodifiableEList(requiredInterfaces);
	}

	protected static EList getProvidedInterfaces(
			ConnectableElement connectableElement) {
		EList providedInterfaces = new UniqueEList.FastCompare();

		if (connectableElement instanceof Port) {
			providedInterfaces.addAll(((Port) connectableElement)
				.getProvideds());
		} else if (connectableElement instanceof Property) {
			Type type = ((Property) connectableElement).getType();

			if (type instanceof Component) {
				ComponentOperations.getAllProvideds((Component) type,
					providedInterfaces);
			} else if (type instanceof Interface) {
				providedInterfaces.add((Interface) type);
			} else if (type instanceof Classifier) {
				Classifier classifier = (Classifier) type;
				ComponentOperations.realizedInterfaces(null, classifier, true,
					providedInterfaces);

				for (Classifier parent : classifier.allParents()) {
					ComponentOperations.realizedInterfaces(null, parent, true,
						providedInterfaces);
				}
			}
		}

		for (int i = 0, size = providedInterfaces.size(); i < size; i++) {

			for (Classifier parent : providedInterfaces.get(i).allParents()) {

				if (parent instanceof Interface) {
					providedInterfaces.add((Interface) parent);
				}
			}
		}

		return ECollections.unmodifiableEList(providedInterfaces);
	}

} // ConnectableElementOperations