Java Namespace类代码示例

import org.eclipse.uml2.uml.Namespace; //导入依赖的package包/类
/**
 * 요소 이름이 중복될 경우 유일한 이름을 가져오는 메소드
 * 
 * @param element
 * @param parent
 * @param name
 * @return
 */
private static String getCopiedUniqueName(NamedElement element, Namespace parent, String name) {
    int index = 1;
    String newName = null;

    while (true) {
        newName = UMLMessage.getMessage(UMLMessage.LABEL_COPYOF) + Integer.toString(index++)
            + ManagerConstant.UNDER_BAR + name;
        if (null == parent.getOwnedMember(newName)) {
            return newName;
        }

        if (10000 <= index) {
            return name + Integer.toString(UMLManager.NAME_INDEX++);
        }
    }
}
 

import org.eclipse.uml2.uml.Namespace; //导入依赖的package包/类
/**
 * 부모가 같고 이름이 같은 요소를 붙여넣었을 때 '사본_#_이름'의 형태로 만들어준다.
 * 
 * @param eobject
 *            void
 * @param parent
 */
public static String getCopiedUniqueName(NamedElement element, Namespace parent, String name) {

    int index = 1;
    String newName;
    while (true) {
        newName = UMLMessage.getMessage(UMLMessage.LABEL_COPYOF) + Integer.toString(index++)
            + UICoreConstant.PROJECT_CONSTANTS__UNDER_BAR + name;
        if (null == parent.getOwnedMember(newName)) {
            return newName;
        }

        if (10000 <= index) {
            return name + Integer.toString(UMLManager.NAME_INDEX++);
        }
    }
}
 

import org.eclipse.uml2.uml.Namespace; //导入依赖的package包/类
/**
 * getDiagramList
 *  
 * @param namespace
 * @param type
 * @return List<Diagram>
 */
public static List<Diagram> getDiagramList(Namespace namespace, DiagramType type) {
    List<Diagram> diagramModelList = new ArrayList<Diagram>();

    if (DiagramType.SEQUENCE_DIAGRAM.equals(type)) {
        diagramModelList.addAll(ModelManager.getAllDiagramList(namespace, type));

    } else {
        EAnnotation annotation = namespace.getEAnnotation(UICoreConstant.PROJECT_CONSTANTS__DIAGRAM);
        if (annotation != null) {
            Diagram diagram;
            for (EObject eobj : annotation.getContents()) {
                if (eobj.eClass() == UMLDiagramPackage.Literals.DIAGRAM) {
                    diagram = (Diagram) eobj;

                    if (type == diagram.getType()) {
                        diagramModelList.add(diagram);
                    }
                }
            }
        }
    }
    return ModelManager.sortDiagramList(diagramModelList);

}
 

import org.eclipse.uml2.uml.Namespace; //导入依赖的package包/类
/**
 * Lifeline의 Type에 새 Operation을 생성. (생성된 operation을 Type에 붙이는 것은 transaction
 * 때문에 execute()에서 처리) void
 * 
 * @param type
 */
public static Operation createOperation(Type pType) {

    Operation operation = null;
    CreateOperationDialog dialog = new CreateOperationDialog(RealizationPlugin.getShell(), pType);
    if (dialog.open() == Window.OK) {

        String operationName = dialog.getOperationName();
        Type type = dialog.getSelectedType();

        operation = UMLHelper.createOperation();
        if (operationName.equals(UICoreConstant.PROJECT_CONSTANTS__EMPTY_STRING)) {
            NamedElement namedElement = (NamedElement) operation;
            namedElement.setName(UMLManager.getPackagedUniqueName((Namespace) type, namedElement.getName()));
        } else {
            operation.setName(operationName);
        }
    }
    return operation;
}
 

import org.eclipse.uml2.uml.Namespace; //导入依赖的package包/类
/**
 * Lifeline의 Type에 새 클래스 생성. (생성된 클래스를 Type에 붙이는 것은 transaction 때문에
 * execute()에서 처리) void
 * 
 * @param parentNodeModel
 */
public static org.eclipse.uml2.uml.Class createClass(AbstractNode parentNodeModel) {

    PackageableElement parentElement = UMLManager.getParentPackage(parentNodeModel);
    org.eclipse.uml2.uml.Class umlClass = null;
    CreateClassDialog dialog = new CreateClassDialog(RealizationPlugin.getShell());
    if (dialog.open() == Window.OK) {

        String className = dialog.getClassName();

        umlClass = UMLHelper.createClass();
        if (className.equals(UICoreConstant.PROJECT_CONSTANTS__EMPTY_STRING)) {
            umlClass.setName(UMLManager.getPackagedUniqueName((Namespace) parentElement, umlClass.getName()));
        } else {
            umlClass.setName(className);
        }
    }
    return umlClass;
}
 

import org.eclipse.uml2.uml.Namespace; //导入依赖的package包/类
@Check
private void checkUniqueNamedElementInItsUMLNamespace(NamedElement element) {
    if (StringUtils.isEmpty(element.getName())) {
        return;
    }

    Optional<UMLReferencingElement<Element>> referencedUMLElement = Optional.ofNullable(element)
            .filter(UMLReferencingElement.class::isInstance).map(UMLReferencingElement.class::cast);
    Optional<Namespace> relevantUMLNamespace = referencedUMLElement
            .map(UMLReferencingElement::getUMLParentNamespace);
    if (!relevantUMLNamespace.isPresent()) {
        return;
    }

    if (relevantUMLNamespace.get().getMembers().stream().filter(org.eclipse.uml2.uml.NamedElement.class::isInstance)
            .map(org.eclipse.uml2.uml.NamedElement.class::cast)
            .filter(o -> o != referencedUMLElement.get().getReferencedElement())
            .anyMatch(elementToTest -> Objects.equals(element.getName(), elementToTest.getName()))) {
        error("\"" + element.getName() + "\"" + " no duplicates!",
                TextualCommonsPackage.Literals.NAMED_ELEMENT__NAME, NAME_TAKEN);
    }
}
 

import org.eclipse.uml2.uml.Namespace; //导入依赖的package包/类
public static Class createWildcardType(Namespace context, String name) {
	Class wildcardType = ClassifierUtils.createClassifier(context, null, Literals.CLASS);
	if (context.getNearestPackage() != context) {
		ElementImport elementImport = context.createElementImport(wildcardType);
		elementImport.setAlias(name);
	}
	Stereotype constraintStereotype = StereotypeUtils.findStereotype(WILDCARD_TYPE_STEREOTYPE);
	wildcardType.applyStereotype(constraintStereotype);
	wildcardType.setValue(constraintStereotype, WILDCARD_TYPE_CONTEXT, context);

	Stereotype contextStereotype = StereotypeUtils.findStereotype(WILDCARD_TYPE_CONTEXT_STEREOTYPE);
	List<Type> newTypes;
	if (!context.isStereotypeApplied(contextStereotype)) {
		context.applyStereotype(contextStereotype);
		newTypes = new ArrayList<Type>();
	} else
		newTypes = new ArrayList<Type>(
				(List<Type>) context.getValue(contextStereotype, WILDCARD_TYPE_CONTEXT_TYPES));
	newTypes.add(wildcardType);
	context.setValue(contextStereotype, WILDCARD_TYPE_CONTEXT_TYPES, newTypes);
	return wildcardType;
}
 

import org.eclipse.uml2.uml.Namespace; //导入依赖的package包/类
/**
 * Creates a template binding for the given template and parameters.
 * 
 * @param template
 * @param actualParam
 * @return the created bound element
 */
@SuppressWarnings("unchecked")
public static <TE extends TemplateableElement & NamedElement, PE extends ParameterableElement> TE createBinding(
        Namespace namespace, TE template, List<PE> actualParams) {
    TemplateSignature signature = template.getOwnedTemplateSignature();
    List<TemplateParameter> formalParameters = signature.getParameters();
    Assert.isTrue(formalParameters.size() == actualParams.size());
    TE result;
    if (template instanceof Classifier) {
        result = (TE) namespace.getNearestPackage().createOwnedType(null, template.eClass());
        result.setName(generateTemplateInstanceName(template, actualParams));
    } else if (template instanceof Operation)
        result = (TE) FeatureUtils.createOperation((Classifier) namespace, template.getName());
    else
        throw new IllegalArgumentException(template.eClass().getName());
    TemplateBinding binding = result.createTemplateBinding(signature);
    for (int i = 0; i < formalParameters.size(); i++) {
        TemplateParameterSubstitution substitution = binding.createParameterSubstitution();
        substitution.setFormal(signature.getOwnedParameters().get(i));
        UML2Compatibility.setActualParameter(substitution, actualParams.get(i));
    }
    return result;
}
 

import org.eclipse.uml2.uml.Namespace; //导入依赖的package包/类
public static Collection<Element> mapEquivalents(final Collection<EObject> referenceLibraryElements,
        final Package inThePIM) {
    final Collection<Element> pimEquivalents = new ArrayList<>();

    Namespace theCurrentOwner = null;
    Namespace theEquivalentOwnerInThePIM = null;
    for (final EObject visibleElement : referenceLibraryElements) {
        final Namespace theOwner = getOwner(visibleElement);
        if (theOwner != theCurrentOwner) {
            theCurrentOwner = theOwner;
            theEquivalentOwnerInThePIM = findEquivalent(theOwner, inThePIM);
        }
        if (theEquivalentOwnerInThePIM == null) {
            continue;
        }
        final NamedElement theElement = theEquivalentOwnerInThePIM.getMember(getName(visibleElement), false,
                getEClass(visibleElement));
        if (theElement != null) {
            pimEquivalents.add(theElement);
        }
    }

    return pimEquivalents;
}
 

import org.eclipse.uml2.uml.Namespace; //导入依赖的package包/类
@Override
protected void copyContainment(final EReference eReference, final EObject eObject, final EObject copyEObject) {
    if (UMLPackage.Literals.CLASSIFIER.isInstance(eObject) && eObject.eIsSet(eReference) && eReference.isMany()
            && !((Collection<?>) eObject.eGet(eReference)).isEmpty()) {
        @SuppressWarnings("unchecked")
        final EList<EObject> source = (EList<EObject>) eObject.eGet(eReference);
        @SuppressWarnings("unchecked")
        final EList<EObject> target = (EList<EObject>) copyEObject.eGet(getTarget(eReference));
        target.addAll(copyAll(source));
        final Namespace original = (Namespace) eObject;
        ECollections.sort(target, new Comparator<EObject>() {
            @Override
            public int compare(final EObject left, final EObject right) {
                return Integer.compare(indexOf(source, original.getOwnedMember(getName(left)), 0),
                        indexOf(source, original.getOwnedMember(getName(right)), 0));
            }
        });
    } else {
        super.copyContainment(eReference, eObject, copyEObject);
    }
}
 

import org.eclipse.uml2.uml.Namespace; //导入依赖的package包/类
private Collection<TreeItem> collectExistingItems(final Iterable<TreeItem> items) {
    final Collection<TreeItem> existingItems = new ArrayList<>();
    Namespace theCurrentOwner = null;
    Namespace theEquivalentOwnerInThePIM = null;
    for (final TreeItem item : items) {
        final Object o = item.getData();
        final Element visibleElement = (Element) o;
        final Namespace theOwner = getOwner(visibleElement);
        if (theOwner != theCurrentOwner) {
            theCurrentOwner = theOwner;
            theEquivalentOwnerInThePIM = findEquivalent(theOwner, thePIM);
        }
        if (theEquivalentOwnerInThePIM == null) {
            continue;
        }
        if (theEquivalentOwnerInThePIM.getMember(getName(visibleElement), false, getEClass(visibleElement)) != null) {
            existingItems.add(item);
        }
    }
    return existingItems;
}
 

import org.eclipse.uml2.uml.Namespace; //导入依赖的package包/类
private Collection<TreeItem> collectExistingItems(final Iterable<TreeItem> items) {
    final Collection<TreeItem> existingItems = new ArrayList<>();
    Namespace theCurrentOwner = null;
    Namespace theEquivalentOwnerInThePIM = null;
    for (final TreeItem item : items) {
        final Object o = item.getData();
        final Element visibleElement = (Element) o;
        final Namespace theOwner = getOwner(visibleElement);
        if (theOwner != theCurrentOwner) {
            theCurrentOwner = theOwner;
            theEquivalentOwnerInThePIM = findEquivalent(theOwner, thePIM);
        }
        if (theEquivalentOwnerInThePIM == null) {
            continue;
        }
        if (findMatching(visibleElement, theEquivalentOwnerInThePIM) != null) {
            existingItems.add(item);
        }
    }
    return existingItems;
}
 

import org.eclipse.uml2.uml.Namespace; //导入依赖的package包/类
public static Component searchComponentInModels(Namespace namespace, String componentName) {
	Component result = null;

	List<EObject> contents = namespace.eResource().getContents();
	List<Component> components = new ArrayList<Component>();
	for (EObject content : contents) {
		if (content instanceof Package) {
			Package rootPackage = (Package)content;
			List<PackageableElement> packagedElements = rootPackage.getPackagedElements();
			for (PackageableElement packageableElement : packagedElements) {
				if (packageableElement instanceof Component) {
					components.add((Component)packageableElement);
				}
			}
			components.addAll(searchAllImportedComponents(rootPackage));
		}
	}
	for (Component component : components) {
		if (componentName.equals(component.getName())) {
			result = component;
			break;
		}
	}
	return result;
}
 

import org.eclipse.uml2.uml.Namespace; //导入依赖的package包/类
public static Classifier searchClassifierInModels(Namespace namespace, String qualifiedName) {
	Classifier result = null;

	result = searchClassifierInModel(namespace, qualifiedName);
	if (result == null) {
		// search in imported packages
		Resource eResource = namespace.eResource();
		if (eResource != null) {
			List<EObject> contents = eResource.getContents();
			List<Component> components = new ArrayList<Component>();
			for (EObject content : contents) {
				if (content instanceof Package) {
					Package rootPackage = (Package)content;
					components.addAll(searchAllImportedComponents(rootPackage));
				}
			}
			result = searchClassifierInComponents(components, qualifiedName);
		} else {
			throw new IllegalStateException("Should not appended");
		}
	}
	return result;
}
 

import org.eclipse.uml2.uml.Namespace; //导入依赖的package包/类
/**
 * getCopiedUniqueName
 *  
 * @param element
 * @param parent
 * @param name
 * @return String
 */
public static String getCopiedUniqueName(NamedElement element, Namespace parent, String name) {

    int index = 1;
    String newName;
    while (true) {
        newName = UMLMessage.getMessage(UMLMessage.LABEL_COPYOF) + Integer.toString(index++)
            + UICoreConstant.PROJECT_CONSTANTS__UNDER_BAR + name;
        boolean isUnique = true;
        for (Element child : parent.getOwnedElements()) {
            if (child instanceof NamedElement) {
                if (((NamedElement) child).getName() != null) {
                    if (((NamedElement) child).getName().equals(newName)) {
                        isUnique = false;
                    }
                }
            }
        }
        if (isUnique) {
            return newName;
        }
        // if (null == parent.getOwnedMember(newName)) {
        // return newName;
        // }

        if (10000 <= index) {
            return name + Integer.toString(UMLManager.NAME_INDEX++);
        }
    }
}