import org.eclipse.uml2.uml.Dependency; //导入依赖的package包/类
/**
 * @see org.eclipse.ui.IActionDelegate#selectionChanged(org.eclipse.jface.action.IAction,
 *      org.eclipse.jface.viewers.ISelection)
 */
public void selectionChanged(IAction action, ISelection selection) {
    objList.clear();
    objList = ProjectUtil.getSelectedEObjects(selection);

    if (objList == null || objList.size() < 1) {
        return;
    }

    for (EObject eobject : objList) {
        if (eobject instanceof Lifeline || eobject instanceof Abstraction || eobject instanceof Association
            || eobject instanceof BehaviorExecutionSpecification || eobject instanceof CombinedFragment
            || eobject instanceof Comment || eobject instanceof Connector || eobject instanceof ControlFlow
            || eobject instanceof Dependency || eobject instanceof ExecutionEvent
            || eobject instanceof ExecutionOccurrenceSpecification || eobject instanceof Extend
            || eobject instanceof Generalization || eobject instanceof Include
            || eobject instanceof InteractionOperand || eobject instanceof InterfaceRealization
            || eobject instanceof Message || eobject instanceof MessageOccurrenceSpecification
            || eobject instanceof ObjectFlow || eobject instanceof Realization
            || eobject instanceof ReceiveOperationEvent || eobject instanceof SendOperationEvent
            || eobject instanceof Usage) {
            objList.clear();
            return;
        }
    }
}
 

import org.eclipse.uml2.uml.Dependency; //导入依赖的package包/类
private Dependency createDependency(Package pkg, FHIMInformationModel.Dependency dependencyModel) {
    String name = dependencyModel.getName();
    LOG.debug("Dependency: " + name);

    // Client.
    FHIMInformationModel.Type clientModel = dependencyModel.getClient();
    Type client = getTypeForModel(clientModel);
    LOG.debug("    client: " + client.getName());

    // Supplier.
    FHIMInformationModel.Type supplierModel = dependencyModel.getSupplier();
    Type supplier = getTypeForModel(supplierModel);
    LOG.debug("    supplier: " + supplier.getName());

    Dependency dependency = client.createDependency(supplier);
    dependency.setName(name);

    return dependency;
}
 

import org.eclipse.uml2.uml.Dependency; //导入依赖的package包/类
public void testDependencyStereotypeApplication() throws CoreException {
    String profileSource = "";
    profileSource += "profile someProfile;\n";
    profileSource += "stereotype my_dep_stereotype extends UML::Dependency end;\n";
    profileSource += "end.\n";

    String modelSource = "";
    modelSource += "model someModel;\n";
    modelSource += "import base;\n";
    modelSource += "apply someProfile;\n";
    modelSource += "class SomeClass\n";
    modelSource += "  [my_dep_stereotype] dependency Integer;\n";
    modelSource += "end;\n";
    modelSource += "end.\n";
    parseAndCheck(profileSource, modelSource);
    Class class_ = (Class) getRepository().findNamedElement("someModel::SomeClass",
            IRepository.PACKAGE.getClassifier(), null);
    Dependency dependency = class_.getClientDependency(null);
    Stereotype stereotype = (Stereotype) getRepository().findNamedElement("someProfile::my_dep_stereotype",
            IRepository.PACKAGE.getStereotype(), null);
    assertNotNull(stereotype);
    assertTrue(dependency.isStereotypeApplied(stereotype));
}
 

import org.eclipse.uml2.uml.Dependency; //导入依赖的package包/类
/**
 * <!-- begin-user-doc -->
 * <!-- end-user-doc -->
 * 
 * @generated
 */
public void setBase_Dependency(Dependency newBase_Dependency) {
	Dependency oldBase_Dependency = base_Dependency;
	base_Dependency = newBase_Dependency;
	if (eNotificationRequired())
		eNotify(new ENotificationImpl(this, Notification.SET, ExtLibraryProfilePackage.BORROWS__BASE_DEPENDENCY, oldBase_Dependency, base_Dependency));
}
 

import org.eclipse.uml2.uml.Dependency; //导入依赖的package包/类
/**
 * <!-- begin-user-doc -->
 * <!-- end-user-doc -->
 * 
 * @generated
 */
@Override
public void eSet(int featureID, Object newValue) {
	switch (featureID) {
	case ExtLibraryProfilePackage.BORROWS__BASE_DEPENDENCY:
		setBase_Dependency((Dependency) newValue);
		return;
	}
	super.eSet(featureID, newValue);
}
 

import org.eclipse.uml2.uml.Dependency; //导入依赖的package包/类
/**
 * <!-- begin-user-doc -->
 * <!-- end-user-doc -->
 * 
 * @generated
 */
@Override
public void eUnset(int featureID) {
	switch (featureID) {
	case ExtLibraryProfilePackage.BORROWS__BASE_DEPENDENCY:
		setBase_Dependency((Dependency) null);
		return;
	}
	super.eUnset(featureID);
}
 

import org.eclipse.uml2.uml.Dependency; //导入依赖的package包/类
/**
 * 추가적인 연결정보 처리 필요. 종속성과 파라미터에 대한 정보 변경만 되고 있음.
 * 
 * @param elementList
 * @param before
 * @param targetClass
 *            void
 */
private void replaceRelatedModel(List<Element> elementList, Class before, Class targetClass) {
    if (elementList == null) {
        return;
    }

    for (Element element : elementList) {
        if (element instanceof Property) {
            if (before.equals(((Property) element).getType())) {
                ((Property) element).setType(targetClass);
            }

        } else if (element instanceof Dependency) {
            if (((Dependency) element).getClients().contains(before)) {
                before.getClientDependencies().remove(element);
                ((Dependency) element).getClients().remove(before);
                ((Dependency) element).getClients().add(targetClass);
            } else if (((Dependency) element).getSuppliers().contains(before)) {
                ((Dependency) element).getSuppliers().remove(before);
                ((Dependency) element).getSuppliers().add(targetClass);
            }
            if (element.eContainer().equals(before)) {
                before.getClientDependencies().remove(element);
                targetClass.getClientDependencies().add((Dependency) element);
            }
        } else if (element instanceof Parameter) {
            ((Parameter) element).setType(targetClass);
        }
    }
}
 

import org.eclipse.uml2.uml.Dependency; //导入依赖的package包/类
/**
 * relation의 source와 target이 같은지 검사
 * 
 * @param relationship
 * @param sourceElement
 * @param targetElement
 * @return boolean
 */
private static boolean checkRelationTarget(Relationship relationship, NamedElement targetElement) {
    if (relationship instanceof Dependency) {
        Dependency dependency = (Dependency) relationship;
        EList<NamedElement> suppliers = dependency.getSuppliers();
        for (NamedElement element : suppliers) {
            if (targetElement.equals(element)) {
                return true;
            }
        }

    } else if (relationship instanceof Generalization) {
        Generalization generalization = (Generalization) relationship;
        if (targetElement.equals(generalization.getGeneral())) {
            return true;
        }

    } else if (relationship instanceof Association) {
        Association association = (Association) relationship;
        EList<Type> endTypes = association.getEndTypes();
        for (Type type : endTypes) {
            if (targetElement.equals(type)) {
                return true;
            }
        }

    }

    return false;
}
 

import org.eclipse.uml2.uml.Dependency; //导入依赖的package包/类
/**
 * @see nexcore.tool.uml.manager.command.DeleteUMLDirectedRelationshipCommand#deleteDirectedAttributes()
 */
@Override
protected void deleteDirectedAttributes() {
    Dependency dependency = (Dependency) this.targetElement;
    // this.source = dependency.getSources().get(0);
    // this.target = dependency.getTargets().get(0);
    dependency.getClients().clear();
    dependency.getSuppliers().clear();
}
 

import org.eclipse.uml2.uml.Dependency; //导入依赖的package包/类
/**
 * getCommand
 *  
 * @param selectedElement
 * @return Command
 */
public static Command getCommand(Element selectedElement) {

    if (null == selectedElement.eContainer()) {
        return null;
    }
    Command deleteCommand = null;
    if (selectedElement instanceof Diagram) {
        deleteCommand = new DeleteUMLDiagramCommand((Diagram) selectedElement);
    } else if (selectedElement instanceof Association) {
        deleteCommand = new DeleteUMLAssociationCommand((Association) selectedElement);
    } else if (selectedElement instanceof Dependency) {
        deleteCommand = new DeleteUMLDependencyCommand(selectedElement);
    } else if (selectedElement instanceof Include) {
        deleteCommand = new DeleteUMLIncludeCommand(selectedElement);
    } else if (selectedElement instanceof Extend) {
        deleteCommand = new DeleteUMLExtendCommand(selectedElement);
    } else if (selectedElement instanceof Generalization) {
        deleteCommand = new DeleteUMLGeneralizationCommand(selectedElement);
    } else if (selectedElement instanceof InterfaceRealization) {
        deleteCommand = new DeleteUMLInterfaceRealizationCommand(selectedElement);
    } else if (selectedElement instanceof Realization) {
        deleteCommand = new DeleteUMLRealizationCommand(selectedElement);
    } else if (selectedElement instanceof Property) {
        deleteCommand = new DeleteUMLPropertyCommand((Property) selectedElement);
    } else if (selectedElement instanceof ActivityEdge) {
        deleteCommand = new DeleteUMLActivityEdgeCommand((ActivityEdge) selectedElement);
    } else if (selectedElement instanceof ActivityNode) {
        deleteCommand = new DeleteUMLActivityNodeCommand((ActivityNode) selectedElement);
    } else if ((selectedElement instanceof Lifeline) || (selectedElement instanceof Message)) {
        deleteCommand = new DeleteUMLSequenceElementCommand((NamedElement)selectedElement);
    } else if (selectedElement instanceof NamedElement) {
        deleteCommand = new DeleteUMLPackageableElementCommand((NamedElement) selectedElement);
    }//
    return deleteCommand;
}
 

import org.eclipse.uml2.uml.Dependency; //导入依赖的package包/类
/**
 * 타켓의 변경 처리 void
 */
private void handleNewTarget() {

    oldTarget = (AbstractNode) connection.getTarget();

    diagram.getConnectionList().remove(connection);
    Dimension targetAnchor = connection.getTargetAnchor();
    if (targetAnchor != null) {
        targetAnchor.setWidth(targetAnchorPoint.x);
        targetAnchor.setHeight(targetAnchorPoint.y);
    }
    reconnectTarget(newTarget);
    diagram.getConnectionList().add(connection);

    if (this.connection.getUmlModel() instanceof Relationship) {
        Relationship relationship = (Relationship) this.connection.getUmlModel();
        if (relationship != null) {
            switch (relationship.eClass().getClassifierID()) {
                case UMLPackage.ASSOCIATION:
                    handleReconnectForAssociation((Association) relationship, this.oldTarget, this.newTarget);
                    break;
                case UMLPackage.EXTEND:
                    handlerNewTargetForExtend((Extend) relationship);
                    break;
                case UMLPackage.INCLUDE:
                    handlerNewTargetForInclude((Include) relationship);
                    break;
                case UMLPackage.GENERALIZATION:
                    handlerNewTargetForGeneralization((Generalization) relationship);
                    break;
                default:
                    if (relationship instanceof Dependency) {
                        handleNewTargetForDependency((Dependency) relationship);
                    }
                    return;
            }
        }
    }
}
 

import org.eclipse.uml2.uml.Dependency; //导入依赖的package包/类
/**
 * 소스의 변경 처리. void
 */
private void handleNewSource() {
    oldSource = (AbstractNode) connection.getSource();

    diagram.getConnectionList().remove(connection);
    Dimension sourceAnchor = connection.getSourceAnchor();
    if (sourceAnchor != null) {
        sourceAnchor.setWidth(sourceAnchorPoint.x);
        sourceAnchor.setHeight(sourceAnchorPoint.y);
    }
    reconnectSource(newSource);
    diagram.getConnectionList().add(connection);

    if (this.connection.getUmlModel() instanceof Relationship) {
        Relationship relationship = (Relationship) this.connection.getUmlModel();
        if (relationship != null) {
            switch (relationship.eClass().getClassifierID()) {
                case UMLPackage.ASSOCIATION:
                    handleReconnectForAssociation((Association) relationship, this.oldSource, this.newSource);
                    break;
                case UMLPackage.EXTEND:
                case UMLPackage.INCLUDE:
                    if (relationship instanceof Include) {
                        handlerNewSourceForInclude((Include) relationship);
                    } else {
                        handlerNewSourceForExtend((Extend) relationship);
                    }
                    break;
                case UMLPackage.GENERALIZATION:
                    handlerNewSourceForGeneralization((Generalization) relationship);
                    break;
                default:
                    if (relationship instanceof Dependency) {
                        handleNewSourceForDependency((Dependency) relationship);
                    }
                    return;
            }
        }
    }
}
 

import org.eclipse.uml2.uml.Dependency; //导入依赖的package包/类
/**
 * 
 * @see org.eclipse.gef.commands.Command#undo()
 */
public void undo() {
    NamedElement client = (NamedElement) sourceNode.getUmlModel();
    NamedElement supplier = (NamedElement) targetNode.getUmlModel();
    RelationType relationType = this.connection.getRelationType();

    if (RelationType.ABSTRACTION.equals(relationType) || RelationType.USAGE.equals(relationType)
        || RelationType.DEPENDENCY.equals(relationType)) {
        UMLManager.unsetDependency((Dependency) connection.getUmlModel());
    } else if (RelationType.EXTEND.equals(relationType)) {
        UMLManager.unsetExtendDependency((Extend) connection.getUmlModel());
    } else if (RelationType.INCLUDE.equals(relationType)) {
        UMLManager.unsetIncludeDependency((Include) connection.getUmlModel());
    } else if (RelationType.ASSOCIATION.equals(relationType) || RelationType.AGGREGATION.equals(relationType)
        || RelationType.COMPOSITION.equals(relationType) || RelationType.DIRECTED_AGGREGATION.equals(relationType)
        || RelationType.DIRECTED_ASSOCIATION.equals(relationType)
        || RelationType.DIRECTED_COMPOSITION.equals(relationType)) {
        UMLManager.unsetAssociation((Association) connection.getUmlModel());
    } else if (RelationType.GENERALIZATION.equals(relationType)) {
        UMLManager.unsetGeneralization((Generalization) connection.getUmlModel(), (Classifier) client);
    } else if (RelationType.REALIZATION.equals(relationType)
        || RelationType.INTERFACE_REALIZATION.equals(relationType)
        || RelationType.COMPONENT_REALIZATION.equals(relationType)) {
        UMLManager.unsetRealization((Realization) connection.getUmlModel(), supplier, client);
    } else if (RelationType.CONTROL_FLOW.equals(relationType)) {
        // UMLManager.setControlFlow((ControlFlow)connection.getUmlModel(),supplier,
        // client);
    } else if (RelationType.OBJECT_FLOW.equals(relationType)) {
        // UMLManager.setObjectFlow((ObjectFlow)connection.getUmlModel(),supplier,
        // client);
    }

    DiagramUtil.detachSourceOfConnection(connection);
    DiagramUtil.detachTargetOfConnection(connection);
    if (parent instanceof Diagram) {
        ((Diagram) parent).getConnectionList().remove(connection);
    } else if (parent instanceof ContainerNode) {
        ((ContainerNode) parent).getConnectionList().remove(connection);
    }
}
 

import org.eclipse.uml2.uml.Dependency; //导入依赖的package包/类
private FHIMInformationModel.Dependency buildDependencyModel(Dependency dependency) {
    String name = dependency.getName();
    LOG.debug("Dependency: " + name);

    // Expect exactly one client.
    EList<NamedElement> clients = dependency.getClients();
    int clientCount = clients.size();
    if (clientCount != 1) {
        LOG.warn("Expected 1 client, found " + clientCount);
    }
    NamedElement client = clients.get(0);
    String clientName = client.getName();
    LOG.debug("    client: " + clientName);
    FHIMInformationModel.Type clientModel = getTypeModel(clientName);

    // Expect exactly one supplier.
    EList<NamedElement> suppliers = dependency.getSuppliers();
    int supplierCount = suppliers.size();
    if (supplierCount != 1) {
        LOG.warn("Expected 1 supplier, found " + supplierCount);
    }
    NamedElement supplier = suppliers.get(0);
    String supplierName = supplier.getName();
    LOG.debug("    supplier: " + supplierName);
    FHIMInformationModel.Type supplierModel = getTypeModel(supplierName);

    return new FHIMInformationModel.Dependency(name, clientModel, supplierModel);
}
 

import org.eclipse.uml2.uml.Dependency; //导入依赖的package包/类
public boolean renderObject(Dependency dependency, IndentedPrintWriter writer, IRenderingSession context) {
    if (dependency.getSuppliers().isEmpty())
        return false;
    writer.write("dependency ");
    writer.write(TextUMLRenderingUtils.getQualifiedNameIfNeeded(dependency.getSuppliers().get(0),
            dependency.getNamespace()));
    writer.println(";");
    return true;
}
 

import org.eclipse.uml2.uml.Dependency; //导入依赖的package包/类
@Override
public void caseADependencyDecl(ADependencyDecl node) {
    final Classifier referringClassifier = (Classifier) namespaceTracker.currentNamespace(null);
    final Dependency newDependency = (Dependency) referringClassifier.getNearestPackage().createPackagedElement(
            null, UMLPackage.Literals.DEPENDENCY);
    newDependency.getClients().add(referringClassifier);
    annotationProcessor.applyAnnotations(newDependency, node.getDependency());
    new DeferredCollectionFiller(sourceContext, referringClassifier, newDependency.getSuppliers()).process(node
            .getTypeIdentifier());
}
 

import org.eclipse.uml2.uml.Dependency; //导入依赖的package包/类
@Operation(contextual = true, kind = Operation.Kind.QUERY)
public static LinkedHashSet<Package> getPimConstraintModels(final Package self) {
    final LinkedHashSet<Package> pimConstraintModels = new LinkedHashSet<>();
    for (final Dependency d : self.getClientDependencies()) {
        if (UMLPackage.Literals.REALIZATION.isInstance(d) && getAppliedReferencesStereotype(d) != null) {
            pimConstraintModels
                    .addAll(EcoreUtil.<Package> getObjectsByType(d.getClients(), UMLPackage.Literals.PACKAGE));
        }
    }
    return pimConstraintModels;
}
 

import org.eclipse.uml2.uml.Dependency; //导入依赖的package包/类
/**
 * 해당 Type의 Operation을 리턴한다.
 * 
 * 
 * @param type
 * @return List<Operation>
 * @author 황선림
 */
public static List<Operation> getTypeOperations(Type type) {

    List<Operation> result = new ArrayList<Operation>();
    if (type == null) {
        return result;

    } else if (type instanceof org.eclipse.uml2.uml.Class) {
        org.eclipse.uml2.uml.Class c = (org.eclipse.uml2.uml.Class) type;

        result.addAll(getProperOperations(c.getAllOperations()));

        // operation within interface
        EList<Interface> list = c.getAllImplementedInterfaces();
        for (int i = 0; i < list.size(); i++) {
            result.addAll(getProperOperations(list.get(i).getAllOperations()));
        }

    } else if (type instanceof Interface) {
        result = getProperOperations(((Interface) type).getAllOperations());

    } else {
        return result;

    }

    // operation within Abstract class
    EList<Dependency> dependencyList = type.getClientDependencies();
    EList<NamedElement> suppliers = null;
    for (Dependency dependency : dependencyList) {
        if (dependency instanceof Abstraction) {
            suppliers = dependency.getSuppliers();
            for (NamedElement element : suppliers) {
                if (element instanceof Class) {
                    result.addAll(getProperOperations(((Class) element).getAllOperations()));
                }
            }
        }
    }

    return result;

}
 

import org.eclipse.uml2.uml.Dependency; //导入依赖的package包/类
/**
 * 
 * 
 * @param seqDgm
 * @param controlClassMap
 * @param voClassMap
 * @param seqElmtMap
 *            void
 */
public static void connectControlToVO(Diagram seqDgm, HashMap controlClassMap, HashMap voClassMap,
                                      HashMap seqElmtMap) {

    org.eclipse.uml2.uml.Class voClass = null;
    Dependency depend = null;
    NotationNode srcNode = null;
    NotationNode tgtNode = null;

    Set controlKeyset = controlClassMap.keySet();
    Set voKeyset = voClassMap.keySet();
    String controlKey = null;
    String voKey = null;
    org.eclipse.uml2.uml.Class controlClass = null;

    for (Iterator itr = controlKeyset.iterator(); itr.hasNext();) {
        controlKey = (String) itr.next();
        controlClass = (org.eclipse.uml2.uml.Class) controlClassMap.get(controlKey);

        for (Iterator itr2 = voKeyset.iterator(); itr2.hasNext();) {
            voKey = (String) itr2.next();
            voClass = (org.eclipse.uml2.uml.Class) voClassMap.get(voKey);

            try {
                depend = ClassDiagramUtil.getDependency(controlClass, voClass);
                srcNode = (NotationNode) seqElmtMap.get(controlClass.getName().toLowerCase());
                tgtNode = (NotationNode) seqElmtMap.get(voClass.getName().toLowerCase());

                if (srcNode != null && tgtNode != null && srcNode != tgtNode) {
                    // TODO: UMLModeler.getUMLDiagramHelper().createEdge()
                    // 개발
                    // UMLModeler.getUMLDiagramHelper().createEdge(srcNode,
                    // tgtNode, depend);
                }

            } catch (Exception e) {
                // Log.error("# " + seqDgm.getName() +
                // Messages.getString("CreateClassDiagram_LOG_MSG_ERROR_CREATEASSOC1")
                // + srcElmt.getName()+
                // Messages.getString("CreateClassDiagram_LOG_MSG_ERROR_CREATEASSOC2")
                // + tgtElmt.getName() +
                // Messages.getString("CreateClassDiagram_LOG_MSG_ERROR_CREATEASSOC3"));
                continue;
            }
        }
    }
}
 

import org.eclipse.uml2.uml.Dependency; //导入依赖的package包/类
@Operation(contextual = true, kind = Operation.Kind.QUERY)
public static LinkedHashSet<Dependency> getSupplierDependency(final NamedElement self) {
    return new LinkedHashSet<>(self.getClientDependencies());
}