core/profile/org.polarsys.esf.core.profile.esfarchitectureconcepts/src/main/java/org/polarsys/esf/esfarchitectureconcepts/impl/MSConnector.java - esf/esf-infra - Git at Google

 /*******************************************************************************
  * Copyright (c) 2016 ALL4TEC & CEA LIST.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License 2.0
  * which accompanies this distribution, and is available at
  * https://www.eclipse.org/legal/epl-2.0/
  *
  * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *     ALL4TEC & CEA LIST - initial API and implementation
  ******************************************************************************/
 package org.polarsys.esf.esfarchitectureconcepts.impl;

 import java.util.Collection;
 import org.eclipse.emf.common.util.BasicEList;
 import org.eclipse.emf.common.util.EList;
 import org.eclipse.emf.ecore.util.EcoreEList.UnmodifiableEList;
 import org.eclipse.uml2.uml.Connector;
 import org.eclipse.uml2.uml.ConnectorEnd;
 import org.eclipse.uml2.uml.Element;
 import org.eclipse.uml2.uml.util.UMLUtil;
 import org.polarsys.esf.esfarchitectureconcepts.IAbstractSConnectableElement;
 import org.polarsys.esf.esfarchitectureconcepts.IESFArchitectureConceptsFactory;
 import org.polarsys.esf.esfarchitectureconcepts.IMSConnector;
 import org.polarsys.esf.esfarchitectureconcepts.ISBlock;
 import org.polarsys.esf.esfarchitectureconcepts.ISPort;
 import org.polarsys.esf.esfarchitectureconcepts.SDirection;
 import org.polarsys.esf.esfcore.impl.GenericAbstractSElement;

 /**
  * This class can override the generated class {@link SConnector} and will be
  * used by the custom factory.
  *
  * @author $Author: ymunoz $
  * @version $Revision: 168 $
  */
 public class MSConnector extends SConnector implements IMSConnector {

 	/**
 	 * Default constructor.
 	 */
 	public MSConnector() {
 		super();
 	}

 	/**
 	 * {@inheritDoc}
 	 */
 	@Override
 	public String getName() {
 		return GenericAbstractSElement.getName(getBase_Connector());
 	}

 	/**
 	 * {@inheritDoc}
 	 */
 	@Override
 	public String getUUID() {
 		return GenericAbstractSElement.getUUID(getBase_Connector());
 	}

 	/**
 	 * {@inheritDoc}
 	 */
 	@Override
 	public EList<IAbstractSConnectableElement> getEndsList() {
 		EList<IAbstractSConnectableElement> vSConnectableElementsList = new BasicEList<IAbstractSConnectableElement>();
 		Connector vBase = getBase_Connector();

 		if (vBase != null) {
 			if (vBase.getEnds().size() >= 2) {
 				ConnectorEnd vEnd1 = vBase.getEnds().get(0);
 				ConnectorEnd vEnd2 = vBase.getEnds().get(1);
 				if ((vEnd1.getRole() != null) && (vEnd2.getRole() != null)) {
 					if ((UMLUtil.getStereotypeApplication(vEnd1.getRole(), SPort.class) != null)
 							&& (UMLUtil.getStereotypeApplication(vEnd2.getRole(), SPort.class) != null)) {
 						// Get the two Ports
 						ISPort vSPort1 = (ISPort) UMLUtil.getStereotypeApplication(vEnd1.getRole(), SPort.class);
 						ISPort vSPort2 = (ISPort) UMLUtil.getStereotypeApplication(vEnd2.getRole(), SPort.class);
 						vSConnectableElementsList.add(vSPort1);
 						vSConnectableElementsList.add(vSPort2);
 					}
 				}
 			}
 		}

 		UnmodifiableEList<IAbstractSConnectableElement> vUSConnectableElementsList = new UnmodifiableEList<IAbstractSConnectableElement>(
 				this, ESFArchitectureConceptsPackage.eINSTANCE.getSConnector_EndsList(),
 				vSConnectableElementsList.size(), vSConnectableElementsList.toArray());
 		return vUSConnectableElementsList;
 	}

 	/**
 	 * {@inheritDoc}
 	 */
 	@Override
 	public ISBlock basicGetOwner() {
 		Connector vBase = getBase_Connector();
 		ISBlock vSBlock = IESFArchitectureConceptsFactory.eINSTANCE.createSBlock();

 		if (vBase != null) {
 			Element vOwner = vBase.getOwner();
 			if ((vOwner != null) && (UMLUtil.getStereotypeApplication(vOwner, SBlock.class) != null)) {
 				vSBlock = (SBlock) UMLUtil.getStereotypeApplication(vOwner, SBlock.class);
 			}
 		}
 		return vSBlock;
 	}

 	/**
 	 * {@inheritDoc}
 	 */
 	@Override
 	public EList<IAbstractSConnectableElement> getSourcesList() {
 		EList<IAbstractSConnectableElement> vSourcesList = new BasicEList<IAbstractSConnectableElement>();
 		Connector vBase = getBase_Connector();

 		if (vBase != null) {
 			EList<IAbstractSConnectableElement> vEnds = getEndsList();
 			if (vEnds.size() >= 2) {
 				vSourcesList.addAll(getSourcePorts(vEnds));
 			}
 		}

 		UnmodifiableEList<IAbstractSConnectableElement> vUSourcesList = new UnmodifiableEList<IAbstractSConnectableElement>(
 				this, ESFArchitectureConceptsPackage.eINSTANCE.getSConnector_EndsList(), vSourcesList.size(),
 				vSourcesList.toArray());
 		return vUSourcesList;
 	}

 	/**
 	 * {@inheritDoc}
 	 */
 	@Override
 	public EList<IAbstractSConnectableElement> getTargetsList() {
 		EList<IAbstractSConnectableElement> vTargetsList = new BasicEList<IAbstractSConnectableElement>();
 		Connector vBase = getBase_Connector();

 		if (vBase != null) {
 			EList<IAbstractSConnectableElement> vEnds = getEndsList();
 			if (vEnds.size() >= 2) {
 				vTargetsList.addAll(getTargetPorts(vEnds));
 			}
 		}

 		UnmodifiableEList<IAbstractSConnectableElement> vUSTargetsList = new UnmodifiableEList<IAbstractSConnectableElement>(
 				this, ESFArchitectureConceptsPackage.eINSTANCE.getSConnector_EndsList(), vTargetsList.size(),
 				vTargetsList.toArray());
 		return vUSTargetsList;
 	}

 	/**
 	 * Verify what are the SPorts who play the source's role and get them.
 	 *
 	 * @param pSPorts
 	 *            The SPorts from the SConnector
 	 * @return The source SPorts
 	 */
 	private Collection<? extends IAbstractSConnectableElement> getSourcePorts(
 			final EList<IAbstractSConnectableElement> pSPorts) {

 		if (pSPorts.size() < 2) {
 			throw new IllegalArgumentException(Integer.toString(pSPorts.size()));
 		}

 		EList<IAbstractSConnectableElement> vSourcePortsList = new BasicEList<IAbstractSConnectableElement>();

 		// Get the two SPorts
 		ISPort vSPort1 = (ISPort) pSPorts.get(0);
 		ISPort vSPort2 = (ISPort) pSPorts.get(1);

 		// Get the direction for each SPort
 		SDirection vDirectionOfPort1 = vSPort1.getSDirection();
 		SDirection vDirectionOfPort2 = vSPort2.getSDirection();

 		// Get the owner for each Port
 		Element vOwnerOfPort1 = vSPort1.getBase_Port().getOwner();
 		Element vOwnerOfPort2 = vSPort2.getBase_Port().getOwner();

 		// Get the part with port for each ConnectorEnd
 		Element vPartWithPort1 = getBase_Connector().getEnds().get(0).getPartWithPort();
 		Element vPartWithPort2 = getBase_Connector().getEnds().get(1).getPartWithPort();

 		// 1. Verify if the connection is between SBlock and SPart
 		if (((vPartWithPort1 != null) && (vPartWithPort2 == null))
 				|| ((vPartWithPort1 == null) && (vPartWithPort2 != null))) {

 			// 1.1 Verify if the connection is between : [SBlock::SPort_IN] ->
 			// [SPart::SPort_IN]
 			if (SDirection.IN.equals(vDirectionOfPort1) && SDirection.IN.equals(vDirectionOfPort2)) {

 				// If "ownerOfPort1" contains "partWithPort2" than "SPort1" is
 				// the source
 				if ((vPartWithPort2 != null) && (vOwnerOfPort1.getOwnedElements().contains(vPartWithPort2))) {
 					vSourcePortsList.add(vSPort1);

 					// If "ownerOfPort2" contains "partWithPort1" than "SPort2"
 					// is the source
 				} else if ((vPartWithPort1 != null) && (vOwnerOfPort2.getOwnedElements().contains(vPartWithPort1))) {
 					vSourcePortsList.add(vSPort2);
 				}

 				// 1.2 If the connection is between : [SPart::SPort_OUT] ->
 				// [SBlock::SPort_OUT]
 			} else if (SDirection.OUT.equals(vDirectionOfPort1) && SDirection.OUT.equals(vDirectionOfPort2)) {

 				// If "partWithPort2" is child of "ownerOfPort1" than "SPort2"
 				// is the source
 				if ((vPartWithPort2 != null) && (vPartWithPort2.getOwner().equals(vOwnerOfPort1))) {
 					vSourcePortsList.add(vSPort2);

 					// If "partWithPort1" is child of "ownerOfPort2" than return
 					// "SPort1" is the source
 				} else if ((vPartWithPort1 != null) && (vPartWithPort1.getOwner().equals(vOwnerOfPort2))) {
 					vSourcePortsList.add(vSPort1);
 				}
 			}

 			// 2. If the connection is between : [SPart::SPort_OUT] ->
 			// [SPart::SPort_IN]
 		} else if ((vPartWithPort1 != null) && (vPartWithPort2 != null)) {

 			// If the direction of "SPort1" is OUT and the direction of "SPort2"
 			// is IN than "SPort1" is the source
 			if (SDirection.OUT.equals(vDirectionOfPort1) && SDirection.IN.equals(vDirectionOfPort2)) {
 				vSourcePortsList.add(vSPort1);

 				// If the direction of "SPort2" is OUT and the direction of
 				// "SPort1" is IN than "SPort2" is the source
 			} else if (SDirection.OUT.equals(vDirectionOfPort2) && SDirection.IN.equals(vDirectionOfPort1)) {
 				vSourcePortsList.add(vSPort2);
 			}
 		}
 		return vSourcePortsList;
 	}

 	/**
 	 * Verify what are the SPorts who play the target's role and get them.
 	 *
 	 * @param pSPorts
 	 *            The SPorts from the SConnector
 	 * @return The target SPorts
 	 */
 	private Collection<? extends IAbstractSConnectableElement> getTargetPorts(
 			final EList<IAbstractSConnectableElement> pSPorts) {

 		if (pSPorts.size() != 2) {
 			throw new IllegalArgumentException(Integer.toString(pSPorts.size()));
 		}

 		EList<IAbstractSConnectableElement> vTargetPortsList = new BasicEList<IAbstractSConnectableElement>();

 		// Get the two SPorts
 		ISPort vSPort1 = (ISPort) pSPorts.get(0);
 		ISPort vSPort2 = (ISPort) pSPorts.get(1);

 		// Get the type for each SPort
 		SDirection vDirectionOfPort1 = vSPort1.getSDirection();
 		SDirection vDirectionOfPort2 = vSPort2.getSDirection();

 		// Get the owner for each Port
 		Element vOwnerOfPort1 = vSPort1.getBase_Port().getOwner();
 		Element vOnerOfPort2 = vSPort2.getBase_Port().getOwner();

 		// Get the part with port for each ConnectorEnd
 		Element vParttWithPort1 = getBase_Connector().getEnds().get(0).getPartWithPort();
 		Element vPartWithPort2 = getBase_Connector().getEnds().get(1).getPartWithPort();

 		// 1. Verify if the connection is between Block and Part
 		if (((vParttWithPort1 != null) && (vPartWithPort2 == null))
 				|| ((vParttWithPort1 == null) && (vPartWithPort2 != null))) {
 			// 1.1 Verify if the connection is between : [SBlock::SPort_IN] ->
 			// [SPart::SPort_IN]
 			if (SDirection.IN.equals(vDirectionOfPort1) && SDirection.IN.equals(vDirectionOfPort2)) {

 				// If "ownerOfPort1" contains "partWithPort2" than return
 				// "SPort2" is the target
 				if ((vPartWithPort2 != null) && (vOwnerOfPort1.getOwnedElements().contains(vPartWithPort2))) {
 					vTargetPortsList.add(vSPort2);

 					// If "ownerOfPort2" contains "partWithPort1" than "SPort1"
 					// is the target
 				} else if ((vParttWithPort1 != null) && (vOnerOfPort2.getOwnedElements().contains(vParttWithPort1))) {
 					vTargetPortsList.add(vSPort1);
 				}

 				// 1.2 If the connection is between : [SPart::SPort_OUT] ->
 				// [SBlock::SPort_OUT]
 			} else if (SDirection.OUT.equals(vDirectionOfPort1) && SDirection.OUT.equals(vDirectionOfPort2)) {
 				// If "partWithPort2" is child of "ownerOfPort1" than "SPort1"
 				// is the target
 				if ((vPartWithPort2 != null) && (vPartWithPort2.getOwner().equals(vOwnerOfPort1))) {
 					vTargetPortsList.add(vSPort1);

 					// If "partWithPort1" is child of "ownerOfPort2" than
 					// "SPort2" is the target
 				} else if ((vParttWithPort1 != null) && (vParttWithPort1.getOwner().equals(vOnerOfPort2))) {
 					vTargetPortsList.add(vSPort2);
 				}
 			}

 			// 2. If the connection is between : [SPart::SPort_OUT] ->
 			// [SPart::SPort_IN]
 		} else if ((vParttWithPort1 != null) && (vPartWithPort2 != null)) {
 			// If the direction of "SPort1" is OUT and the direction of "SPort2"
 			// is IN than "SPort2" is the target
 			if (SDirection.OUT.equals(vDirectionOfPort1) && SDirection.IN.equals(vDirectionOfPort2)) {
 				vTargetPortsList.add(vSPort2);

 				// If the direction of "SPort2" is OUT and the direction of
 				// "SPort1" is IN than "SPort1" is the target
 			} else if (SDirection.OUT.equals(vDirectionOfPort2) && SDirection.IN.equals(vDirectionOfPort1)) {
 				vTargetPortsList.add(vSPort1);
 			}
 		}
 		return vTargetPortsList;
 	}
 }
	/*******************************************************************************
	* Copyright (c) 2016 ALL4TEC & CEA LIST.
	* All rights reserved. This program and the accompanying materials
	* are made available under the terms of the Eclipse Public License 2.0
	* which accompanies this distribution, and is available at
	* https://www.eclipse.org/legal/epl-2.0/
	*
	* SPDX-License-Identifier: EPL-2.0
	*
	* Contributors:
	* ALL4TEC & CEA LIST - initial API and implementation
	******************************************************************************/
	package org.polarsys.esf.esfarchitectureconcepts.impl;

	import java.util.Collection;
	import org.eclipse.emf.common.util.BasicEList;
	import org.eclipse.emf.common.util.EList;
	import org.eclipse.emf.ecore.util.EcoreEList.UnmodifiableEList;
	import org.eclipse.uml2.uml.Connector;
	import org.eclipse.uml2.uml.ConnectorEnd;
	import org.eclipse.uml2.uml.Element;
	import org.eclipse.uml2.uml.util.UMLUtil;
	import org.polarsys.esf.esfarchitectureconcepts.IAbstractSConnectableElement;
	import org.polarsys.esf.esfarchitectureconcepts.IESFArchitectureConceptsFactory;
	import org.polarsys.esf.esfarchitectureconcepts.IMSConnector;
	import org.polarsys.esf.esfarchitectureconcepts.ISBlock;
	import org.polarsys.esf.esfarchitectureconcepts.ISPort;
	import org.polarsys.esf.esfarchitectureconcepts.SDirection;
	import org.polarsys.esf.esfcore.impl.GenericAbstractSElement;

	/**
	* This class can override the generated class {@link SConnector} and will be
	* used by the custom factory.
	*
	* @author $Author: ymunoz $
	* @version $Revision: 168 $
	*/
	public class MSConnector extends SConnector implements IMSConnector {

	/**
	* Default constructor.
	*/
	public MSConnector() {
	super();
	}

	/**
	* {@inheritDoc}
	*/
	@Override
	public String getName() {
	return GenericAbstractSElement.getName(getBase_Connector());
	}

	/**
	* {@inheritDoc}
	*/
	@Override
	public String getUUID() {
	return GenericAbstractSElement.getUUID(getBase_Connector());
	}

	/**
	* {@inheritDoc}
	*/
	@Override
	public EList<IAbstractSConnectableElement> getEndsList() {
	EList<IAbstractSConnectableElement> vSConnectableElementsList = new BasicEList<IAbstractSConnectableElement>();
	Connector vBase = getBase_Connector();

	if (vBase != null) {
	if (vBase.getEnds().size() >= 2) {
	ConnectorEnd vEnd1 = vBase.getEnds().get(0);
	ConnectorEnd vEnd2 = vBase.getEnds().get(1);
	if ((vEnd1.getRole() != null) && (vEnd2.getRole() != null)) {
	if ((UMLUtil.getStereotypeApplication(vEnd1.getRole(), SPort.class) != null)
	&& (UMLUtil.getStereotypeApplication(vEnd2.getRole(), SPort.class) != null)) {
	// Get the two Ports
	ISPort vSPort1 = (ISPort) UMLUtil.getStereotypeApplication(vEnd1.getRole(), SPort.class);
	ISPort vSPort2 = (ISPort) UMLUtil.getStereotypeApplication(vEnd2.getRole(), SPort.class);
	vSConnectableElementsList.add(vSPort1);
	vSConnectableElementsList.add(vSPort2);
	}
	}
	}
	}

	UnmodifiableEList<IAbstractSConnectableElement> vUSConnectableElementsList = new UnmodifiableEList<IAbstractSConnectableElement>(
	this, ESFArchitectureConceptsPackage.eINSTANCE.getSConnector_EndsList(),
	vSConnectableElementsList.size(), vSConnectableElementsList.toArray());
	return vUSConnectableElementsList;
	}

	/**
	* {@inheritDoc}
	*/
	@Override
	public ISBlock basicGetOwner() {
	Connector vBase = getBase_Connector();
	ISBlock vSBlock = IESFArchitectureConceptsFactory.eINSTANCE.createSBlock();

	if (vBase != null) {
	Element vOwner = vBase.getOwner();
	if ((vOwner != null) && (UMLUtil.getStereotypeApplication(vOwner, SBlock.class) != null)) {
	vSBlock = (SBlock) UMLUtil.getStereotypeApplication(vOwner, SBlock.class);
	}
	}
	return vSBlock;
	}

	/**
	* {@inheritDoc}
	*/
	@Override
	public EList<IAbstractSConnectableElement> getSourcesList() {
	EList<IAbstractSConnectableElement> vSourcesList = new BasicEList<IAbstractSConnectableElement>();
	Connector vBase = getBase_Connector();

	if (vBase != null) {
	EList<IAbstractSConnectableElement> vEnds = getEndsList();
	if (vEnds.size() >= 2) {
	vSourcesList.addAll(getSourcePorts(vEnds));
	}
	}

	UnmodifiableEList<IAbstractSConnectableElement> vUSourcesList = new UnmodifiableEList<IAbstractSConnectableElement>(
	this, ESFArchitectureConceptsPackage.eINSTANCE.getSConnector_EndsList(), vSourcesList.size(),
	vSourcesList.toArray());
	return vUSourcesList;
	}

	/**
	* {@inheritDoc}
	*/
	@Override
	public EList<IAbstractSConnectableElement> getTargetsList() {
	EList<IAbstractSConnectableElement> vTargetsList = new BasicEList<IAbstractSConnectableElement>();
	Connector vBase = getBase_Connector();

	if (vBase != null) {
	EList<IAbstractSConnectableElement> vEnds = getEndsList();
	if (vEnds.size() >= 2) {
	vTargetsList.addAll(getTargetPorts(vEnds));
	}
	}

	UnmodifiableEList<IAbstractSConnectableElement> vUSTargetsList = new UnmodifiableEList<IAbstractSConnectableElement>(
	this, ESFArchitectureConceptsPackage.eINSTANCE.getSConnector_EndsList(), vTargetsList.size(),
	vTargetsList.toArray());
	return vUSTargetsList;
	}

	/**
	* Verify what are the SPorts who play the source's role and get them.
	*
	* @param pSPorts
	* The SPorts from the SConnector
	* @return The source SPorts
	*/
	private Collection<? extends IAbstractSConnectableElement> getSourcePorts(
	final EList<IAbstractSConnectableElement> pSPorts) {

	if (pSPorts.size() < 2) {
	throw new IllegalArgumentException(Integer.toString(pSPorts.size()));
	}

	EList<IAbstractSConnectableElement> vSourcePortsList = new BasicEList<IAbstractSConnectableElement>();

	// Get the two SPorts
	ISPort vSPort1 = (ISPort) pSPorts.get(0);
	ISPort vSPort2 = (ISPort) pSPorts.get(1);

	// Get the direction for each SPort
	SDirection vDirectionOfPort1 = vSPort1.getSDirection();
	SDirection vDirectionOfPort2 = vSPort2.getSDirection();

	// Get the owner for each Port
	Element vOwnerOfPort1 = vSPort1.getBase_Port().getOwner();
	Element vOwnerOfPort2 = vSPort2.getBase_Port().getOwner();

	// Get the part with port for each ConnectorEnd
	Element vPartWithPort1 = getBase_Connector().getEnds().get(0).getPartWithPort();
	Element vPartWithPort2 = getBase_Connector().getEnds().get(1).getPartWithPort();

	// 1. Verify if the connection is between SBlock and SPart
	if (((vPartWithPort1 != null) && (vPartWithPort2 == null))
	\|\| ((vPartWithPort1 == null) && (vPartWithPort2 != null))) {

	// 1.1 Verify if the connection is between : [SBlock::SPort_IN] ->
	// [SPart::SPort_IN]
	if (SDirection.IN.equals(vDirectionOfPort1) && SDirection.IN.equals(vDirectionOfPort2)) {

	// If "ownerOfPort1" contains "partWithPort2" than "SPort1" is
	// the source
	if ((vPartWithPort2 != null) && (vOwnerOfPort1.getOwnedElements().contains(vPartWithPort2))) {
	vSourcePortsList.add(vSPort1);

	// If "ownerOfPort2" contains "partWithPort1" than "SPort2"
	// is the source
	} else if ((vPartWithPort1 != null) && (vOwnerOfPort2.getOwnedElements().contains(vPartWithPort1))) {
	vSourcePortsList.add(vSPort2);
	}

	// 1.2 If the connection is between : [SPart::SPort_OUT] ->
	// [SBlock::SPort_OUT]
	} else if (SDirection.OUT.equals(vDirectionOfPort1) && SDirection.OUT.equals(vDirectionOfPort2)) {

	// If "partWithPort2" is child of "ownerOfPort1" than "SPort2"
	// is the source
	if ((vPartWithPort2 != null) && (vPartWithPort2.getOwner().equals(vOwnerOfPort1))) {
	vSourcePortsList.add(vSPort2);

	// If "partWithPort1" is child of "ownerOfPort2" than return
	// "SPort1" is the source
	} else if ((vPartWithPort1 != null) && (vPartWithPort1.getOwner().equals(vOwnerOfPort2))) {
	vSourcePortsList.add(vSPort1);
	}
	}

	// 2. If the connection is between : [SPart::SPort_OUT] ->
	// [SPart::SPort_IN]
	} else if ((vPartWithPort1 != null) && (vPartWithPort2 != null)) {

	// If the direction of "SPort1" is OUT and the direction of "SPort2"
	// is IN than "SPort1" is the source
	if (SDirection.OUT.equals(vDirectionOfPort1) && SDirection.IN.equals(vDirectionOfPort2)) {
	vSourcePortsList.add(vSPort1);

	// If the direction of "SPort2" is OUT and the direction of
	// "SPort1" is IN than "SPort2" is the source
	} else if (SDirection.OUT.equals(vDirectionOfPort2) && SDirection.IN.equals(vDirectionOfPort1)) {
	vSourcePortsList.add(vSPort2);
	}
	}
	return vSourcePortsList;
	}

	/**
	* Verify what are the SPorts who play the target's role and get them.
	*
	* @param pSPorts
	* The SPorts from the SConnector
	* @return The target SPorts
	*/
	private Collection<? extends IAbstractSConnectableElement> getTargetPorts(
	final EList<IAbstractSConnectableElement> pSPorts) {

	if (pSPorts.size() != 2) {
	throw new IllegalArgumentException(Integer.toString(pSPorts.size()));
	}

	EList<IAbstractSConnectableElement> vTargetPortsList = new BasicEList<IAbstractSConnectableElement>();

	// Get the two SPorts
	ISPort vSPort1 = (ISPort) pSPorts.get(0);
	ISPort vSPort2 = (ISPort) pSPorts.get(1);

	// Get the type for each SPort
	SDirection vDirectionOfPort1 = vSPort1.getSDirection();
	SDirection vDirectionOfPort2 = vSPort2.getSDirection();

	// Get the owner for each Port
	Element vOwnerOfPort1 = vSPort1.getBase_Port().getOwner();
	Element vOnerOfPort2 = vSPort2.getBase_Port().getOwner();

	// Get the part with port for each ConnectorEnd
	Element vParttWithPort1 = getBase_Connector().getEnds().get(0).getPartWithPort();
	Element vPartWithPort2 = getBase_Connector().getEnds().get(1).getPartWithPort();

	// 1. Verify if the connection is between Block and Part
	if (((vParttWithPort1 != null) && (vPartWithPort2 == null))
	\|\| ((vParttWithPort1 == null) && (vPartWithPort2 != null))) {
	// 1.1 Verify if the connection is between : [SBlock::SPort_IN] ->
	// [SPart::SPort_IN]
	if (SDirection.IN.equals(vDirectionOfPort1) && SDirection.IN.equals(vDirectionOfPort2)) {

	// If "ownerOfPort1" contains "partWithPort2" than return
	// "SPort2" is the target
	if ((vPartWithPort2 != null) && (vOwnerOfPort1.getOwnedElements().contains(vPartWithPort2))) {
	vTargetPortsList.add(vSPort2);

	// If "ownerOfPort2" contains "partWithPort1" than "SPort1"
	// is the target
	} else if ((vParttWithPort1 != null) && (vOnerOfPort2.getOwnedElements().contains(vParttWithPort1))) {
	vTargetPortsList.add(vSPort1);
	}

	// 1.2 If the connection is between : [SPart::SPort_OUT] ->
	// [SBlock::SPort_OUT]
	} else if (SDirection.OUT.equals(vDirectionOfPort1) && SDirection.OUT.equals(vDirectionOfPort2)) {
	// If "partWithPort2" is child of "ownerOfPort1" than "SPort1"
	// is the target
	if ((vPartWithPort2 != null) && (vPartWithPort2.getOwner().equals(vOwnerOfPort1))) {
	vTargetPortsList.add(vSPort1);

	// If "partWithPort1" is child of "ownerOfPort2" than
	// "SPort2" is the target
	} else if ((vParttWithPort1 != null) && (vParttWithPort1.getOwner().equals(vOnerOfPort2))) {
	vTargetPortsList.add(vSPort2);
	}
	}

	// 2. If the connection is between : [SPart::SPort_OUT] ->
	// [SPart::SPort_IN]
	} else if ((vParttWithPort1 != null) && (vPartWithPort2 != null)) {
	// If the direction of "SPort1" is OUT and the direction of "SPort2"
	// is IN than "SPort2" is the target
	if (SDirection.OUT.equals(vDirectionOfPort1) && SDirection.IN.equals(vDirectionOfPort2)) {
	vTargetPortsList.add(vSPort2);

	// If the direction of "SPort2" is OUT and the direction of
	// "SPort1" is IN than "SPort1" is the target
	} else if (SDirection.OUT.equals(vDirectionOfPort2) && SDirection.IN.equals(vDirectionOfPort1)) {
	vTargetPortsList.add(vSPort1);
	}
	}
	return vTargetPortsList;
	}
	}