Java UMLUtil类代码示例

import org.eclipse.uml2.uml.util.UMLUtil; //导入依赖的package包/类
/**
 *
 * @see org.eclipse.papyrus.infra.nattable.tester.ITableTester#isAllowed(java.lang.Object)
 *
 * @param context
 * @return
 */
@Override
public IStatus isAllowed(Object context) {	
	if (context instanceof Element) {
		Element el = (Element) context;
		ISpecializationType type = (ISpecializationType) ElementTypeRegistry.getInstance().getType("org.eclipse.papyrus.training.library.profile.extlibrary.Book");
		IElementMatcher matcher = type.getMatcher();
		if (context instanceof Package || matcher.matches(el)) {
			Profile profile = UMLUtil.getProfile(LibraryPackage.eINSTANCE, el);
			if (profile != null){
				final String packageQN = profile.getQualifiedName();
				if (el.getNearestPackage().getAppliedProfile(packageQN, true) != null) {
					return new Status(IStatus.OK, Activator.PLUGIN_ID, "The context allowed to create a Book Table"); //$NON-NLS-1$
				} else {
					return new Status(IStatus.ERROR, Activator.PLUGIN_ID, "The profile "+packageQN+" is not applied on the model"); //$NON-NLS-1$ //$NON-NLS-2$
				}					
			}

		}
	}
	return new Status(IStatus.ERROR, Activator.PLUGIN_ID, "The context is not an UML Element"); //$NON-NLS-1$
}
 

import org.eclipse.uml2.uml.util.UMLUtil; //导入依赖的package包/类
/**
 * @see org.eclipse.papyrus.infra.hyperlink.service.HyperlinkContributor#getHyperlinks(java.lang.Object)
 *
 * @param object
 * @return
 */
@Override
public List<HyperLinkObject> getHyperlinks(Object object) {
	List<HyperLinkObject> hyperlinks = new ArrayList<>();
	if (object instanceof Class) {
		Class clazz = (Class) object;
		if (UMLUtil.getStereotypeApplication(clazz, Book.class) != null) {
			// TODO: extract a method to get the borrower from a book in the
			// java implementation of the profile
			EList<DirectedRelationship> targetDirectedRelationships = clazz.getTargetDirectedRelationships();
			for (DirectedRelationship dependency : targetDirectedRelationships) {
				if (UMLUtil.getStereotypeApplication(dependency, Borrows.class) != null) {
					EList<Element> targets = dependency.getSources();
					for (Element element : targets) {
						Set<View> crossReferencingViews = CrossReferencerUtil.getCrossReferencingViews(element,null);
						// we take the first available view
						Object firstView = crossReferencingViews.toArray()[0];
						HyperLinkSpecificObject hyperlink = new HyperLinkSpecificObject((EObject) firstView);
						hyperlinks.add(hyperlink);
					}
				}
			}
		}
	}
	return hyperlinks;
}
 

import org.eclipse.uml2.uml.util.UMLUtil; //导入依赖的package包/类
@Override
public List<NavigableElement> getNavigableElements(Object fromElement) {
	List<NavigableElement> result = new LinkedList<>();
	Element element = org.eclipse.papyrus.uml.tools.utils.UMLUtil.resolveUMLElement(fromElement);
	if (element instanceof Class){
		final Book book = UMLUtil.getStereotypeApplication(element, Book.class);
		if (book != null) {
			final BookCategory category = book.getCategory();
			Resource eResource = book.eResource();
			EList<EObject> contents = eResource.getContents();
			result = 
					contents.stream()
					.filter(l -> !l.equals(book))		
					.filter(l -> l instanceof Book)
					.map(l -> (Book) l)
					.filter(l -> category.equals(l.getCategory()))
					.map(l -> l.getBase_Class())
					.map(clazz -> new SameCategoryNavigableElement(clazz))
					.collect(Collectors.toList());
		}
	}
	return result;
}
 

import org.eclipse.uml2.uml.util.UMLUtil; //导入依赖的package包/类
/**
 * updateParentInExplorer
 *  
 * @param target void
 */
public static void updateParentInExplorer(EObject target) {
    if (null == target) {
        return;
    }
    CommonViewer commonViewer = ViewerRegistry.getViewer();
    if (commonViewer.getControl().isDisposed()) {
        return;
    }
    if (target instanceof DynamicEObjectImpl) {
        target = UMLUtil.getBaseElement(target);
    }
    ITreeNode targetNode = null;
    EObject parent = UMLManager.getParent((Element) target);
    targetNode = UMLTreeNodeRegistry.getTreeNode(parent);
    String[] flags = null;
    flags = new String[] { IBasicPropertyConstants.P_IMAGE, IBasicPropertyConstants.P_TEXT,
        IBasicPropertyConstants.P_CHILDREN };
    commonViewer.update(targetNode, flags);
}
 

import org.eclipse.uml2.uml.util.UMLUtil; //导入依赖的package包/类
private void doFullCheckout() throws CoreException {
    CDOView view = getRepositoryFolder().cdoView();
    try {
        CDOTransferSystem target = new PathmapFilteringTransferSystem(WorkspaceTransferSystem.INSTANCE);
        RepositoryTransferSystem source = new RepositoryTransferSystem(view);

        cleanUpFolder(workspaceFolder);

        CDOTransfer transfer = new CDOTransferUMLFirst(source, target);
        transfer.setTargetPath(workspaceFolder.getFullPath());
        getRepositoryFolder().getNodes().forEach(n -> transfer.map(n.getPath(), new NullProgressMonitor()));

        // no default factory is registered in the CDO utilities
        transfer.getModelTransferContext().registerTargetExtension("*", new XMIResourceFactoryImpl());
        UMLUtil.init(transfer.getModelTransferContext().getTargetResourceSet());
        transfer.getModelTransferContext().getTargetResourceSet().getResource(UML_PRIMITIVE_TYPES_URI, true);

        transfer.perform();

        refreshFolder(workspaceFolder);
    } catch (RuntimeException e) {
        throw new CoreException(new Status(IStatus.ERROR, Activator.PLUGIN_ID, "Failed to transfer models", e));
    }
}
 

import org.eclipse.uml2.uml.util.UMLUtil; //导入依赖的package包/类
@Override
public Set<IHawkClass> getAllSuperTypes() {
	final Set<IHawkClass> ret = super.getAllSuperTypes();

	for (ProfileApplication app : umlPackage.getProfileApplications()) {
		final EAnnotation ann = app.getEAnnotation(UMLUtil.UML2_UML_PACKAGE_2_0_NS_URI);
		if (ann != null) {
			for (EObject ref : ann.getReferences()) {
				if (ref instanceof EPackage) {
					final EPackage appEPackage = (EPackage) ref;
					final UMLProfile umlProfile = new UMLProfile(appEPackage, wf, null);
					ret.add(umlProfile.getVirtualProfileClass());
				}
			}
		}
	}

	return ret;
}
 

import org.eclipse.uml2.uml.util.UMLUtil; //导入依赖的package包/类
private int countBooks(EList<Element> elementList) {
	int numberOfBooks = 0;
	for (Element element : elementList) {
		if (UMLUtil.getStereotypeApplication(element, Book.class) != null) {
			numberOfBooks++;
		}
	}
	return numberOfBooks;
}
 

import org.eclipse.uml2.uml.util.UMLUtil; //导入依赖的package包/类
static public boolean isInputPort(NamedElement e){
	boolean isInput=false;
	//flow port in
	if(!e.getAppliedStereotypes().isEmpty()){
		FlowPort f = UMLUtil.getStereotypeApplication(e, FlowPort.class);
		isInput=f.getDirection().equals(FlowDirection.IN);
	}
	return isInput;
}
 

import org.eclipse.uml2.uml.util.UMLUtil; //导入依赖的package包/类
static public boolean isOutputPort(NamedElement e){
	boolean isOutput=false;
	//flow port in
	if(!e.getAppliedStereotypes().isEmpty()){
		FlowPort f = UMLUtil.getStereotypeApplication(e, FlowPort.class);
		isOutput=f.getDirection().equals(FlowDirection.OUT);
	}
	return isOutput;
}
 

import org.eclipse.uml2.uml.util.UMLUtil; //导入依赖的package包/类
static public boolean isInOutPort(NamedElement e){
	boolean isInOut=false;
	//flow port in
	if(!e.getAppliedStereotypes().isEmpty()){
		FlowPort f = UMLUtil.getStereotypeApplication(e, FlowPort.class);
		isInOut=f.getDirection().equals(FlowDirection.INOUT);
	}
	return isInOut;
}
 

import org.eclipse.uml2.uml.util.UMLUtil; //导入依赖的package包/类
/**
 * component 요소로부터 id 가져오기
 * 
 * @param componentElement
 * @return String
 */
public static String getComponentId(Element componentElement) {
    // 참조할 스테레오타입 정보 가져오기
    Stereotype sourceStereotype = null;

    for (Stereotype appliedStereotype : componentElement
            .getAppliedStereotypes()) {
        if (appliedStereotype.getLabel().equals(
                MDDCoreConstant.COMPONENT_METADATA_STEREOTYPE_NAME)) {
            sourceStereotype = appliedStereotype;
            break;
        }
    }

    String taggedValue = MDDCoreConstant.EMPTY_STRING;

    // fqId 값 가져오기
    taggedValue = (String) UMLUtil.getTaggedValue(componentElement,
            sourceStereotype.getQualifiedName(),
            MDDCoreConstant.FQ_ID_KEY_IN_COMPONENT_STEREOTYPE);
    
    // 스테레오타입 속성에 값이 없을 때는 만들어서 리턴한다.
    if (taggedValue == null || taggedValue.length() == 0) {
        return createComponentFqId(componentElement);
    }

    return taggedValue;
}
 

import org.eclipse.uml2.uml.util.UMLUtil; //导入依赖的package包/类
/**
 * refreshNodeInExplorer
 *  
 * @param target void
 */
public static void refreshNodeInExplorer(EObject target) {
    if (target instanceof EAnnotation) {
        return;
    }
    if (null == target) {
        return;
    }
    CommonViewer commonViewer = ViewerRegistry.getViewer();
    if (commonViewer.getControl().isDisposed()) {
        return;
    }

    ISelection selection = commonViewer.getSelection();
    TreePath[] expanedTreePaths = TreeItemUtil.getExpandTreePaths(commonViewer.getTree()).clone();

    /*
     * stereotype인 경우 전달 객체가 DynamicEobjectImpl이므로 할당된 클래스를 계산하여 처리해야 함.
     */
    if (target instanceof DynamicEObjectImpl) {
        target = UMLUtil.getBaseElement(target);
    }
    ITreeNode targetNode = null;
    targetNode = UMLTreeNodeRegistry.getTreeNode(target);

    if (null != targetNode) {
        commonViewer.refresh(targetNode);
        TreeItemUtil.expandTreePath(expanedTreePaths, selection);
    }
}
 

import org.eclipse.uml2.uml.util.UMLUtil; //导入依赖的package包/类
/**
 * updateExplorer
 *  
 * @param target
 * @param childIncluded void
 */
public static void updateExplorer(EObject target, boolean childIncluded) {
    if (null == target) {
        return;
    }
    if (target instanceof EAnnotation) {
        return;
    }
    CommonViewer commonViewer = ViewerRegistry.getViewer();
    if (commonViewer.getControl().isDisposed()) {
        return;
    }
    if (target instanceof DynamicEObjectImpl) {
        target = UMLUtil.getBaseElement(target);
    }
    ITreeNode targetNode = null;
    targetNode = UMLTreeNodeRegistry.getTreeNode(target);
    if (null == targetNode) {
        return;
    }
    String[] flags = null;
    if (childIncluded) {
        flags = new String[] { IBasicPropertyConstants.P_IMAGE, IBasicPropertyConstants.P_TEXT,
            IBasicPropertyConstants.P_CHILDREN };
    } else {
        flags = new String[] { IBasicPropertyConstants.P_IMAGE, IBasicPropertyConstants.P_TEXT };
    }
    try {
        commonViewer.update(targetNode, flags);
        commonViewer.refresh(targetNode);
    } catch (Exception ex) {
        Log.error(ex);
    }
}
 

import org.eclipse.uml2.uml.util.UMLUtil; //导入依赖的package包/类
/**
 * 스테레오타입의 언어정보 설정
 * 
 * @param appliedStereotype
 * @param element
 * @param koreanPropertyName
 * @param englishPropertyName
 * @param englishName
 * @param firstCharacterCaseType 첫글자의 대소문자 설정
 */
public static void setLanguageInformation(Stereotype appliedStereotype, Element element, String koreanPropertyName,
                                    String englishPropertyName, String englishName, String firstCharacterCaseType) {
    if (koreanPropertyName != null && koreanPropertyName.length() > 0) {
        UMLUtil.setTaggedValue(element, appliedStereotype, koreanPropertyName, ((NamedElement) element).getName());
    }

    if (englishPropertyName != null && englishPropertyName.length() > 0 && englishName != null
        && englishName.length() > 0) {
        UMLUtil.setTaggedValue(element, appliedStereotype, englishPropertyName, getProperName(englishName,
            firstCharacterCaseType));
    }
}
 

import org.eclipse.uml2.uml.util.UMLUtil; //导入依赖的package包/类
public UMLMetaModelResourceFactory() {
	resourceSet = new ResourceSetImpl();
	UMLUtil.init(resourceSet);

	resourceSet.getResourceFactoryRegistry().getExtensionToFactoryMap()
		.put("uml", new UMLResourceFactoryImpl());
	resourceSet.getResourceFactoryRegistry().getExtensionToFactoryMap()
		.put("ecore", new EcoreResourceFactoryImpl());
	resourceSet.getResourceFactoryRegistry().getExtensionToFactoryMap()
		.put("*", new XMIResourceFactoryImpl());
}