Java UMLClassMetadata类代码示例

import gov.nih.nci.cadsr.umlproject.domain.UMLClassMetadata; //导入依赖的package包/类
/**
 * This method initializes classComboBox
 * 
 * @return javax.swing.JComboBox
 */
private JComboBox getClassComboBox() {
    if (this.classComboBox == null) {
        this.classComboBox = new JComboBox();
        this.classComboBox.addItem(NO_SELECTION);
        this.classComboBox.addItemListener(new java.awt.event.ItemListener() {
            public void itemStateChanged(java.awt.event.ItemEvent e) {
                UMLClassMetadata clazz = getSelectedClass();
                if (e.getStateChange() == ItemEvent.SELECTED && clazz != null) {
                    for (int i = 0; i < CaDSRBrowserPanel.this.classSelectionListeners.size(); i++) {
                        ClassSelectedListener listener = (ClassSelectedListener) CaDSRBrowserPanel.this.classSelectionListeners
                            .get(i);
                        listener.handleClassSelection(clazz);
                    }
                }
            }
        });
    }
    return this.classComboBox;
}
 

import gov.nih.nci.cadsr.umlproject.domain.UMLClassMetadata; //导入依赖的package包/类
public static void main(String[] args) throws MalformedURIException, RemoteException {
    CaDSRUMLModelService umlService = new CaDSRUMLModelService(
        "http://cadsr-dataservice.nci.nih.gov:80/wsrf/services/cagrid/CaDSRDataService");
    Project[] projects = umlService.findAllProjects();
    for (Project p : projects) {
        System.out.println(p.getLongName());
        UMLPackageMetadata[] packages = umlService.findPackagesInProject(p);
        for (UMLPackageMetadata pack : packages) {
            System.out.println("\t-" + pack.getName());
            UMLClassMetadata[] classes = umlService.findClassesInPackage(p, pack.getName());
            for (UMLClassMetadata clazz : classes) {
                System.out.println("\t\t-" + clazz.getName());
            }
        }

    }
}
 

import gov.nih.nci.cadsr.umlproject.domain.UMLClassMetadata; //导入依赖的package包/类
private ModelClass[] createModelClasses(Project proj, UMLPackageMetadata pack) throws Exception {
    UMLModelService client = new CaDSRUMLModelService(getCaDsrBrowser().getCadsr().getText());
    UMLClassMetadata[] classMdArray = client.findClassesInPackage(proj, pack.getName());
    ModelClass[] classes = new ModelClass[]{};
    if (classMdArray != null) {
        classes = new ModelClass[classMdArray.length];
        for (int i = 0; i < classMdArray.length; i++) {
            ModelClass clazz = new ModelClass();
            clazz.setShortClassName(classMdArray[i].getName());
            clazz.setSelected(true);
            clazz.setTargetable(true);
            classes[i] = clazz;
        }
    }
    return classes;
}
 

import gov.nih.nci.cadsr.umlproject.domain.UMLClassMetadata; //导入依赖的package包/类
/**
 * This method initializes jButton
 * 
 * @return javax.swing.JButton
 */
private JButton getJButton() {
    if (addButton == null) {
        addButton = new JButton();
        addButton.setText("Add Package");
        addButton.addActionListener(new java.awt.event.ActionListener() {
            public void actionPerformed(java.awt.event.ActionEvent e) {
                UMLPackageMetadata pack = getBrowserPanel().getSelectedPackage();
                getProjectTree().addUmlPackage(pack.getName());
                String cadsrUrl = getBrowserPanel().getCadsr().getText();
                try {
                    UMLModelService cadsr = new CaDSRUMLModelService(cadsrUrl);
                    UMLClassMetadata[] classes = cadsr.findClassesInPackage(getBrowserPanel().getSelectedProject(),
                        pack.getName());
                    for (int i = 0; i < classes.length; i++) {
                        getProjectTree().addUmlClass(pack.getName(), classes[i].getName());
                    }
                } catch (Exception ex) {
                    ex.printStackTrace();
                    CompositeErrorDialog.showErrorDialog(ex);
                }
            }
        });
    }
    return addButton;
}
 

import gov.nih.nci.cadsr.umlproject.domain.UMLClassMetadata; //导入依赖的package包/类
/**
 * @return Classes in a project
 * @throws ApplicationException
 */
private UMLClassMetadata[] getProjectClasses(Project proj, HQLCriteria classCriteria) throws ApplicationException {

    long start = System.currentTimeMillis();
    List rList = this.cadsr.query(classCriteria, UMLClassMetadata.class.getName());
    UMLClassMetadata classArr[] = new UMLClassMetadata[rList.size()];
    // caCORE's toArray(arr) is broken (cacore bug #1382), so need to do
    // this way
    System.arraycopy(rList.toArray(), 0, classArr, 0, rList.size());

    double duration = (System.currentTimeMillis() - start) / 1000.0;
    LOG.info(proj.getShortName() + "'s class fetch took " + duration + " seconds, and found " + classArr.length
        + " classes.");

    return classArr;
}
 

import gov.nih.nci.cadsr.umlproject.domain.UMLClassMetadata; //导入依赖的package包/类
private static void convertClass(ApplicationService appService, String projectShortName, String projectVersion,
	gov.nih.nci.cagrid.metadata.common.UMLClass result, UMLClassMetadata classMetadata) throws ApplicationException {
	if (classMetadata == null || result == null) {
		return;
	}

	result.setClassName(classMetadata.getName());
	result.setDescription(classMetadata.getDescription());
	if (result.getDescription() == null) {
		result.setDescription("");
	}
	result.setId(classMetadata.getId());
	result.setPackageName(CaDSRUtils.getPackageName(classMetadata));
	result.setProjectName(projectShortName);
	result.setProjectVersion(projectVersion);

	UMLAttribute[] attributes = createClassAttributes(appService, classMetadata);
	UMLClassUmlAttributeCollection attCol = new UMLClassUmlAttributeCollection();
	attCol.setUMLAttribute(attributes);
	result.setUmlAttributeCollection(attCol);

	gov.nih.nci.cagrid.metadata.common.SemanticMetadata[] smArray = semanticMetadataCollectionToArray(classMetadata
		.getSemanticMetadataCollection());
	result.setSemanticMetadata(smArray);

}
 

import gov.nih.nci.cadsr.umlproject.domain.UMLClassMetadata; //导入依赖的package包/类
/**
 * @param qname
 * @return The UML Class matching the QName
 * @throws CaDSRGeneralException
 */
protected UMLClass getUMLClassForQName(QName qname) throws CaDSRGeneralException {
    // look up the UMLClassMetadata we are looking for, based on the QName
    UMLClassMetadata classMetadata = getUMLClassMetadataForQName(qname);
    if (classMetadata == null) {
        return null;
    }

    UMLClass result = null;
    try {
        String shortName = classMetadata.getProject().getShortName();
        String version = classMetadata.getProject().getVersion();

        ApplicationService cadsr = defaultcaDSR;
        QualifiedProject proj = uri2ServiceMap.get(qname.getNamespaceURI());
        if (proj != null) {
            cadsr = proj.getSourceAppServ();
        }

        result = CaDSRUtils.convertClassToUMLClass(cadsr, shortName, version, classMetadata);
    } catch (ApplicationException e) {
        LOG.error("Problem converting class to metadata", e);
    }
    return result;
}
 

import gov.nih.nci.cadsr.umlproject.domain.UMLClassMetadata; //导入依赖的package包/类
private void addClassNodes(Collection<UMLClassMetadata> umlClasses,LazyActionTreeNode pkgNode){
	// build class nodes
	int bcIndex = pkgNode.getAction().indexOf("&treeBreadCrumbs=");
	String pkgBreadCrumb = pkgNode.getAction().subSequence(bcIndex,pkgNode.getAction().length() - 3).toString();

	for (Iterator clsIter = umlClasses.iterator(); clsIter.hasNext();) {
		UMLClassMetadata umlClass = (UMLClassMetadata) clsIter.next();
		LazyActionTreeNode clsNode = new LazyActionTreeNode("Class Node",umlClass.getName(),
				"javascript:classSearchAction('P_PARAM_TYPE=CLASS&P_IDSEQ="
				+ umlClass.getId() + pkgBreadCrumb + ">>"
				+ umlClass.getName() + " ')", umlClass.getId(),
				false);
		//pkgNode.addLeafSortedByDescription(clsNode);
		pkgNode.getChildren().add(clsNode);
	}
}
 

import gov.nih.nci.cadsr.umlproject.domain.UMLClassMetadata; //导入依赖的package包/类
public ActionForward attributeSearch(
      ActionMapping mapping,
      ActionForm form,
      HttpServletRequest request,
      HttpServletResponse response) throws Exception {

//      removeSessionObject(request, UMLBrowserFormConstants.CLASS_SEARCH_RESULTS);


      DynaActionForm dynaForm = (DynaActionForm) form;
      Collection<UMLAttributeMetadata> umlAttributes= new ArrayList();
      UMLBrowserQueryService queryService = getAppServiceLocator().findQuerySerivce();
      UMLAttributeMetadata umlAtt = new UMLAttributeMetadata();
      String attName = ((String) dynaForm.get("attributeName")).trim();
      if (attName !=null && attName.length()>0)
         umlAtt.setName(attName.replace('*','%') );
      UMLClassMetadata umlClass = this.populateClassFromForm(request,dynaForm);
      if (umlClass != null)
         umlAtt.setUMLClassMetadata(umlClass);
      SearchPreferences searchPreferences = (SearchPreferences)getSessionObject(request, UMLBrowserFormConstants.SEARCH_PREFERENCES);
      umlAttributes = queryService.findUmlAttributes(umlAtt, searchPreferences);

      setupSessionForAttributeResults(umlAttributes, request);
      return mapping.findForward("showAttributes");
    }
 

import gov.nih.nci.cadsr.umlproject.domain.UMLClassMetadata; //导入依赖的package包/类
private void getLazyAssociationsForClass(Collection classList)
{
   if(classList==null) return;

   int itemPerPage = UMLBrowserParams.getInstance().getItemPerPage();
   int count = 0;
    for (Iterator resultsIterator = classList.iterator();
            resultsIterator.hasNext();) {

        UMLClassMetadata returnedClass = (UMLClassMetadata) resultsIterator.next();
            for (Iterator mdIterator = returnedClass.getSemanticMetadataCollection().iterator();
                    mdIterator.hasNext();) {
                    SemanticMetadata metaData = (SemanticMetadata) mdIterator.next();                      
                    }
            }
        ++count;
        if(itemPerPage<=count) return;

    }
 

import gov.nih.nci.cadsr.umlproject.domain.UMLClassMetadata; //导入依赖的package包/类
public List<UMLClassMetadata> getClassesForContext(String contextId){
   List resultList =null;
   try {
     DetachedCriteria classCriteria = DetachedCriteria.forClass(UMLClassMetadata.class); 
     classCriteria.addOrder( Order.asc("name").ignoreCase());
     if (contextId != null && contextId.length() >0) {
        DetachedCriteria contextCri= classCriteria.createCriteria("project").createCriteria("classificationScheme").createCriteria("context");
        contextCri.add(Expression.eq("id", contextId));
     }
     resultList =  getCaCoreAPIService().query(classCriteria);
     	//getCaCoreAPIService().query(classCriteria, UMLClassMetadata.class.getName());

   } catch (Exception e) {
    e.printStackTrace();
}
return resultList;

}
 

import gov.nih.nci.cadsr.umlproject.domain.UMLClassMetadata; //导入依赖的package包/类
private static void convertClass(ApplicationService appService, String projectShortName, String projectVersion,
	gov.nih.nci.cagrid.metadata.common.UMLClass result, UMLClassMetadata classMetadata) throws ApplicationException {
	if (classMetadata == null || result == null) {
		return;
	}

	result.setClassName(classMetadata.getName());
	result.setDescription(classMetadata.getDescription());
	if (result.getDescription() == null) {
		result.setDescription("");
	}
	result.setId(classMetadata.getId());
	result.setPackageName(CaDSRUtils.getPackageName(classMetadata));
	result.setProjectName(projectShortName);
	result.setProjectVersion(projectVersion);

	UMLAttribute[] attributes = createClassAttributes(appService, classMetadata);
	UmlAttributeCollection attCol = new UmlAttributeCollection();
	attCol.getUMLAttribute().addAll(Arrays.asList(attributes));
	result.setUmlAttributeCollection(attCol);

	gov.nih.nci.cagrid.metadata.common.SemanticMetadata[] smArray = semanticMetadataCollectionToArray(classMetadata
		.getSemanticMetadataCollection());
	result.getSemanticMetadata().addAll(Arrays.asList(smArray));

}
 

import gov.nih.nci.cadsr.umlproject.domain.UMLClassMetadata; //导入依赖的package包/类
public UMLClassMetadata getSelectedClass() {
    Object obj = getClassComboBox().getSelectedItem();
    if (obj != null && obj instanceof ClassDisplay) {
        return ((ClassDisplay) obj).getClazz();
    }
    return null;
}
 

import gov.nih.nci.cadsr.umlproject.domain.UMLClassMetadata; //导入依赖的package包/类
public void handlePackageSelection(final UMLPackageMetadata pkg) {
    // System.out.println("Handle package:" + pkg.getName());
    if (isShowClassSelection()) {
        makeCombosEnabled(false);

        final int progressEventID = getMultiEventProgressBar().startEvent(
            "Updating Classes for Package " + pkg.getName());
        resetClassComboBox();

        final Project project = ((ProjectDisplay) getProjectComboBox().getSelectedItem()).getProject();
        Thread t = new Thread() {
            @Override
            public void run() {
                try {
                    UMLModelService cadsrService = new CaDSRUMLModelService(getCadsr().getText());

                    UMLClassMetadata[] metadatas = cadsrService.findClassesInPackage(project, pkg.getName());
                    if (metadatas != null) {
                        ClassDisplay[] displayedClasses = new ClassDisplay[metadatas.length];
                        for (int i = 0; i < metadatas.length; i++) {
                            displayedClasses[i] = new ClassDisplay(metadatas[i]);
                        }
                        Arrays.sort(displayedClasses, CaDSRBrowserPanel.this.toStringComparator);
                        for (ClassDisplay element : displayedClasses) {
                            getClassComboBox().addItem(element);
                        }
                    }
                    makeCombosEnabled(true);
                } catch (Exception e1) {
                    e1.printStackTrace();
                    CompositeErrorDialog.showErrorDialog(
                        "Error communicating with caDSR; please check the caDSR URL!", e1.getMessage(), e1);
                } finally {
                    getMultiEventProgressBar().stopEvent(progressEventID, "Done.");
                }
            }
        };
        t.start();
    }
}
 

import gov.nih.nci.cadsr.umlproject.domain.UMLClassMetadata; //导入依赖的package包/类
private void applyMMSModelConfiguration() throws Exception {
    ModelInformation modelInfo = new ModelInformation();
    // default to model from mms
    modelInfo.setSource(ModelSourceType.mms);
    UMLProjectIdentifer id = new UMLProjectIdentifer();
    id.setIdentifier(selectedProject.getShortName());
    id.setVersion(selectedProject.getVersion());
    modelInfo.setUMLProjectIdentifer(id);
    
    // packages
    UMLModelService cadsrClient = new CaDSRUMLModelService(mmsUrl);
    ModelPackage[] packages = new ModelPackage[selectedPackages.size()];
    int index = 0;
    for (UMLPackageMetadata umlPackage : selectedPackages) {
        ModelPackage pack = new ModelPackage();
        pack.setPackageName(umlPackage.getName());
        UMLClassMetadata[] classMetadata = cadsrClient.findClassesInPackage(
            selectedProject, umlPackage.getName());
        ModelClass[] classes = new ModelClass[classMetadata.length];
        for (int j = 0; j < classMetadata.length; j++) {
            ModelClass clazz = new ModelClass();
            // NOT setting element name until schema mapping panel
            clazz.setShortClassName(classMetadata[j].getName());
            clazz.setSelected(true);
            clazz.setTargetable(true);
            classes[j] = clazz;
        }
        pack.setModelClass(classes);
        packages[index] = pack;
        index++;
    }
    modelInfo.setModelPackage(packages);
    storeModelInformation(modelInfo);
}