Java Element.getOwnedElements方法代码示例

import org.eclipse.uml2.uml.Element; //导入方法依赖的package包/类
/**
 * 
 * 
 * @param uniqueIndex
 * @return int
 */
private static int getSequenceUniqueIndex(int uniqueIndex, Element parent, String parentName) {

    for (Element child : parent.getOwnedElements()) {

        if (child instanceof NamedElement) {
            NamedElement namedChild = (NamedElement) child;

            if (uniqueIndex == 0) {
                if (parentName.equals(namedChild.getName())) {
                    uniqueIndex++;
                    uniqueIndex = getSequenceUniqueIndex(uniqueIndex, parent, parentName);
                }
            } else {
                if ((parentName + uniqueIndex).equals(namedChild.getName())) {
                    uniqueIndex++;
                    uniqueIndex = getSequenceUniqueIndex(uniqueIndex, parent, parentName);
                }
            }
        }
    }
    return uniqueIndex;
}
 

import org.eclipse.uml2.uml.Element; //导入方法依赖的package包/类
/**
 * 
 * SelectedElement 하위에 컴포넌트가 있는지 검사.
 * 
 * @param parentElement
 * @return
 */
private boolean hasComponentChild(Element parentElement) {
    
    for( Element child : parentElement.getOwnedElements() ) {
        if( child instanceof org.eclipse.uml2.uml.Class ) {
            if( COMPONENT_STEREOTYPE.equals( ProjectUtil.getStereotypeLabel(child).trim() ) ) {
                return true;
            }
        }
        if (child instanceof PackageableElement) {
            if(hasComponentChild( child )){
                return true;
            }
        }
    }
    return false;
}
 

import org.eclipse.uml2.uml.Element; //导入方法依赖的package包/类
/**
 * Same as getElementsWithStereotype(Model model...) searches in an Element members, not in a Model members.
 * This function is private and used by getElementsWithStereotype(Model model...)
 * @param parent_elt
 * @param stereotype
 * @param target_list
 */
static private void getElementsWithStereotype(Element parent_elt, String stereotype, LinkedList<NamedElement> target_list) {
	for (Element ne : parent_elt.getOwnedElements()) {
		if (ne instanceof NamedElement) {
			if (ne instanceof org.eclipse.uml2.uml.Class) {
				if(hasStereotype((org.eclipse.uml2.uml.Class)ne, stereotype)){
					target_list.add((NamedElement)ne);
				}					
			}
			getElementsWithStereotype(ne,stereotype,target_list);
		}
	}
	return;
}
 

import org.eclipse.uml2.uml.Element; //导入方法依赖的package包/类
private static void getPackage(Element parent_elt, LinkedList<NamedElement> target_list) {
	for (Element ne : parent_elt.getOwnedElements()) {
		if (ne instanceof NamedElement) {
			if (ne instanceof org.eclipse.uml2.uml.Package) {
				target_list.add((NamedElement)ne);					
			}
			getPackage(ne,target_list);
		}
	}
	return;
	
}
 

import org.eclipse.uml2.uml.Element; //导入方法依赖的package包/类
static private void getClass(Element parent_elt, LinkedList<NamedElement> target_list) {
	for (Element ne : parent_elt.getOwnedElements()) {
		if (ne instanceof NamedElement) {
			if (ne instanceof org.eclipse.uml2.uml.Class) {
				target_list.add((NamedElement)ne);					
			}
			getClass(ne,target_list);
		}
	}
	return;
}
 

import org.eclipse.uml2.uml.Element; //导入方法依赖的package包/类
private static void getPackage(Element parent_elt, LinkedList<NamedElement> target_list) {
	
	for (Element ne : parent_elt.getOwnedElements()) {
		if (ne instanceof org.eclipse.uml2.uml.Package) {
			target_list.add((NamedElement)ne);
		}
		getPackage(ne,target_list);
	}
}
 

import org.eclipse.uml2.uml.Element; //导入方法依赖的package包/类
/**
 * 요소로부터 component id 찾는 메소드
 * 
 * @param element BizUnit
 * @param selectedElementList
 * @return String
 */
public static String findComponentId(Element element, List<Element> selectedElementList) {
    String methodLowerCaseName = null;
    List<Element> componentChildList = null;
    String componentChildLowerCaseName = null;

    List<Element> componentList = getComponentElementList(selectedElementList);
    if (componentList.size() == 1) {
        return getComponentId(componentList.get(0));
    }
    
    for (Element componentElement : componentList) {
        if (!componentElement.getOwnedElements().isEmpty()
                && componentElement.getOwnedElements().size() > 0) {
            componentChildList = componentElement.getOwnedElements();

            for (Element componentChild : componentChildList) {
                if (componentChild instanceof Operation) {
                    componentChildLowerCaseName = ((NamedElement) componentChild)
                            .getName().toLowerCase();
                    
                    List<Element> methodElementList = getMethodElementList(element);
                    if (null != methodElementList) {
                        for (Element methodElement : methodElementList) {
                            methodLowerCaseName = ((NamedElement) methodElement)
                                    .getName().toLowerCase();

                            if (methodLowerCaseName
                                    .startsWith(componentChildLowerCaseName)) {
                                return getComponentId(componentElement);
                            }
                        }
                    }
                }
            }
        }
    }

    return null;
}
 

import org.eclipse.uml2.uml.Element; //导入方法依赖的package包/类
/**
 * 선택된 BizUnit 요소 하위목록 중에서 method 스테레오타입이 적용된 요소의 목록을 반환
 * 
 * @param bizUnitElement
 * @return List<Element>
 */
public static List<Element> getMethodElementList(Element bizUnitElement) {
    List<Element> allElementChildList = null;
    List<Element> methodChildElementList = null;

    if (!bizUnitElement.getOwnedElements().isEmpty()
            && bizUnitElement.getOwnedElements().size() > 0) {
        allElementChildList = bizUnitElement.getOwnedElements();
    }
    
    if (null != allElementChildList) {
        for (Element childElement : allElementChildList) {
            for (Stereotype appliedStereotype : childElement
                    .getAppliedStereotypes()) {
                if (appliedStereotype
                        .getLabel()
                        .equals(
                                MDDCoreConstant.BIZUNIT_METADATA_METHOD_STEREOTYPE_NAME)) {
                    if (methodChildElementList == null) {
                        methodChildElementList = new ArrayList<Element>();
                    }

                    methodChildElementList.add(childElement);
                }
            }
        }
    }
    return methodChildElementList;
}
 

import org.eclipse.uml2.uml.Element; //导入方法依赖的package包/类
/**
 * 
 * 컴포넌트에 복사할 오퍼레이션을 가지고 있는 biz 패키지를 찾는다.
 * 
 * @param parent
 * @param packageList
 * @return
 */
private List<org.eclipse.uml2.uml.Package> getPackageList(Element parent, List<org.eclipse.uml2.uml.Package> packageList) {
    
    for( Element child : parent.getOwnedElements() ) {
        if( child instanceof org.eclipse.uml2.uml.Package ) {
            org.eclipse.uml2.uml.Package childPackage = (org.eclipse.uml2.uml.Package) child ;
            packageList.add(childPackage);
            
            packageList = getPackageList(childPackage, packageList);
        }
    }
    return packageList;
}
 

import org.eclipse.uml2.uml.Element; //导入方法依赖的package包/类
/**
 * 
 * SelectedElement 하위에 있는 전체 컴포넌트를 리스트로 보관.
 * 
 * @param parentElement
 */
private void setComponentList(Element parentElement) {
    for( Element child : parentElement.getOwnedElements() ) {
        if( child instanceof org.eclipse.uml2.uml.Class ) {
            if( COMPONENT_STEREOTYPE.equals( ProjectUtil.getStereotypeLabel(child).trim() ) ) {
                
                if( !componentList.contains(child) ) {
                    componentList.add((Class) child);
                }
            }
        } else if ( child instanceof PackageableElement ) {
            setComponentList(child);
        }
    }
}
 

import org.eclipse.uml2.uml.Element; //导入方法依赖的package包/类
private void runThroughModelRecursive(Queue<Element> queue, Multimap<Class<?>, Element> map) {
	if(!queue.isEmpty()){
		Element head = queue.poll();
		List<Element> children = head.getOwnedElements();
		if(children != null)
			queue.addAll(children);
		map.put(head.eClass().getInstanceClass(), head);
		runThroughModelRecursive(queue, map);
	}else{
		return;
	}
}