Java LexBIGService.getGenericExtension方法代码示例

import org.LexGrid.LexBIG.LexBIGService.LexBIGService; //导入方法依赖的package包/类
public static Vector getMappingCodingSchemesEntityParticipatesIn(String code, String namespace) {
       Vector v = new Vector();
       try {
		LexBIGService distributed = RemoteServerUtil.createLexBIGService();

		MappingExtension mappingExtension =
			(MappingExtension)distributed.getGenericExtension("MappingExtension");

		AbsoluteCodingSchemeVersionReferenceList mappingSchemes =
			mappingExtension.getMappingCodingSchemesEntityParticipatesIn(code, namespace);

		//output is all of the mapping ontologies that this code participates in.
		for(AbsoluteCodingSchemeVersionReference ref : mappingSchemes.getAbsoluteCodingSchemeVersionReference()){
			//System.out.println("URI: " + ref.getCodingSchemeURN());
			//System.out.println("Version: " + ref.getCodingSchemeVersion());
			v.add(ref.getCodingSchemeURN() + "|" + ref.getCodingSchemeVersion());
		}

	} catch (Exception ex) {
           ex.printStackTrace();
       }
	return v;
}
 

import org.LexGrid.LexBIG.LexBIGService.LexBIGService; //导入方法依赖的package包/类
public static ResolvedConceptReferenceList getHierarchyRoots(
    String codingScheme, String version) {
    CodingSchemeVersionOrTag versionOrTag = new CodingSchemeVersionOrTag();
    if (version != null)
        versionOrTag.setVersion(version);
    try {
        LexBIGService lbSvc = RemoteServerUtil.createLexBIGService();
        LexBIGServiceConvenienceMethods lbscm =
            (LexBIGServiceConvenienceMethods) lbSvc
                .getGenericExtension("LexBIGServiceConvenienceMethods");
        lbscm.setLexBIGService(lbSvc);
        String hierarchyID = getHierarchyID(codingScheme, version);
        return lbscm.getHierarchyRoots(codingScheme, versionOrTag,
            hierarchyID);
    } catch (Exception e) {
        return null;
    }
}
 

import org.LexGrid.LexBIG.LexBIGService.LexBIGService; //导入方法依赖的package包/类
public static List<String> getDistinctNamespacesOfCode(
           String codingScheme,
           String version,
           String code) {

       try {
           LexBIGService lbSvc = RemoteServerUtil.createLexBIGService();
           LexBIGServiceConvenienceMethods lbscm =
               (LexBIGServiceConvenienceMethods) lbSvc
                   .getGenericExtension("LexBIGServiceConvenienceMethods");
           lbscm.setLexBIGService(lbSvc);

           CodingSchemeVersionOrTag csvt = new CodingSchemeVersionOrTag();
           csvt.setVersion(version);

           List<String> list = lbscm.getDistinctNamespacesOfCode(codingScheme, csvt, code);
           return list;
	} catch (Exception ex) {
		ex.printStackTrace();
	}
       return null;
}
 

import org.LexGrid.LexBIG.LexBIGService.LexBIGService; //导入方法依赖的package包/类
public MetaTreeUtils(LexBIGService lbSvc) {
this.lbSvc = lbSvc;

      try {
	this.lbscm =
		(LexBIGServiceConvenienceMethods) lbSvc
			.getGenericExtension("LexBIGServiceConvenienceMethods");
	lbscm.setLexBIGService(lbSvc);
} catch (Exception ex) {
	ex.printStackTrace();
}
this._termGroupRankHashMap = NCImBrowserProperties.getTermGroupRankHashMap();
  }
 

import org.LexGrid.LexBIG.LexBIGService.LexBIGService; //导入方法依赖的package包/类
public ConceptDetails(LexBIGService lbSvc) {
       this.lbSvc = lbSvc;
       try {
           lbscm =
               (LexBIGServiceConvenienceMethods) lbSvc
                   .getGenericExtension("LexBIGServiceConvenienceMethods");
           lbscm.setLexBIGService(lbSvc);
	} catch (Exception ex) {
		ex.printStackTrace();
	}
}
 

import org.LexGrid.LexBIG.LexBIGService.LexBIGService; //导入方法依赖的package包/类
/**
   * Prints the tree for an individual code.
   */

  public HashMap getTreePathData(String scheme, String version, String hierarchyID, String code) throws LBException {
LexBIGService lbsvc = RemoteServerUtil.createLexBIGService();
LexBIGServiceConvenienceMethods lbscm = (LexBIGServiceConvenienceMethods) lbsvc
		.getGenericExtension("LexBIGServiceConvenienceMethods");
lbscm.setLexBIGService(lbsvc);
if (hierarchyID == null) hierarchyID = "is_a";
CodingSchemeVersionOrTag csvt = new CodingSchemeVersionOrTag();
if (version != null) csvt.setVersion(version);
SupportedHierarchy hierarchyDefn = getSupportedHierarchy(lbsvc, scheme, csvt, hierarchyID);
	return getTreePathData(lbsvc, lbscm, scheme, csvt, hierarchyDefn, code);
  }
 

import org.LexGrid.LexBIG.LexBIGService.LexBIGService; //导入方法依赖的package包/类
public LexBIGServiceConvenienceMethods createLexBIGServiceConvenienceMethods(
    LexBIGService lbSvc) {
    LexBIGServiceConvenienceMethods lbscm = null;
    try {
        lbscm =
            (LexBIGServiceConvenienceMethods) lbSvc
                .getGenericExtension("LexBIGServiceConvenienceMethods");
        lbscm.setLexBIGService(lbSvc);
    } catch (Exception ex) {
        ex.printStackTrace();
    }
    return lbscm;
}
 

import org.LexGrid.LexBIG.LexBIGService.LexBIGService; //导入方法依赖的package包/类
public static boolean isExtension(String codingScheme, String version) {
	CodingSchemeVersionOrTag tagOrVersion = new CodingSchemeVersionOrTag();
	if (version != null) tagOrVersion.setVersion(version);
	try {
		LexBIGService lbSvc = RemoteServerUtil.createLexBIGService();
		SupplementExtension supplementExtension =
			(SupplementExtension) lbSvc.getGenericExtension("SupplementExtension");

		return supplementExtension.isSupplement(codingScheme, tagOrVersion);
		//return ServiceUtility.isSupplement(codingScheme, tagOrVersion);
	} catch (Exception ex) {
		ex.printStackTrace();
	}
	return false;
}
 

import org.LexGrid.LexBIG.LexBIGService.LexBIGService; //导入方法依赖的package包/类
public EntityExporter(LexBIGService lbSvc) {
      this.lbSvc = lbSvc;
      try {
          lbscm =
              (LexBIGServiceConvenienceMethods) lbSvc
                  .getGenericExtension("LexBIGServiceConvenienceMethods");
          lbscm.setLexBIGService(lbSvc);
} catch (Exception ex) {
	ex.printStackTrace();
}
  }
 

import org.LexGrid.LexBIG.LexBIGService.LexBIGService; //导入方法依赖的package包/类
public VisUtils(LexBIGService lbSvc) {
       this.lbSvc = lbSvc;
       try {
           lbscm =
               (LexBIGServiceConvenienceMethods) lbSvc
                   .getGenericExtension("LexBIGServiceConvenienceMethods");
           lbscm.setLexBIGService(lbSvc);
	} catch (Exception ex) {
		ex.printStackTrace();
	}
}
 

import org.LexGrid.LexBIG.LexBIGService.LexBIGService; //导入方法依赖的package包/类
public PartonomyUtils(LexBIGService lbSvc) {
       this.lbSvc = lbSvc;
       this.relationshipUtils = new RelationshipUtils(lbSvc);
       try {
           this.lbscm =
               (LexBIGServiceConvenienceMethods) lbSvc
                   .getGenericExtension("LexBIGServiceConvenienceMethods");
           lbscm.setLexBIGService(lbSvc);
	} catch (Exception ex) {
		ex.printStackTrace();
	}
}
 

import org.LexGrid.LexBIG.LexBIGService.LexBIGService; //导入方法依赖的package包/类
public UIUtils(LexBIGService lbSvc) {
       this.lbSvc = lbSvc;
       try {
           lbscm =
               (LexBIGServiceConvenienceMethods) lbSvc
                   .getGenericExtension("LexBIGServiceConvenienceMethods");
           lbscm.setLexBIGService(lbSvc);
	} catch (Exception ex) {
		ex.printStackTrace();
	}
}
 

import org.LexGrid.LexBIG.LexBIGService.LexBIGService; //导入方法依赖的package包/类
public static HashMap getAssociatedConcepts(String scheme, String version,
    String code, String[] assocNames, boolean direction) {
    try {
        LexBIGService lbSvc = RemoteServerUtil.createLexBIGService();
        LexBIGServiceConvenienceMethods lbscm =
            (LexBIGServiceConvenienceMethods) lbSvc
                .getGenericExtension("LexBIGServiceConvenienceMethods");
        lbscm.setLexBIGService(lbSvc);
        return getAssociatedConcepts(lbSvc, lbscm, scheme, version, code,
            assocNames, direction);
    } catch (Exception ex) {
        return null;
    }
}
 

import org.LexGrid.LexBIG.LexBIGService.LexBIGService; //导入方法依赖的package包/类
public void run(String code) throws LBException {
    //CodingSchemeSummary css = Util.promptForCodeSystem();
    long ms = System.currentTimeMillis();
    try {
        //if (css != null) {
            //LexBIGService lbSvc = LexBIGServiceImpl.defaultInstance();
            LexBIGService lbsvc = RemoteServerUtil.createLexBIGService();
            LexBIGServiceConvenienceMethods lbscm = (LexBIGServiceConvenienceMethods) lbsvc
                    .getGenericExtension("LexBIGServiceConvenienceMethods");
            lbscm.setLexBIGService(lbsvc);
            // Fetch the description for the specified code.
            // Not required to find path to root, just nice to display.
            String scheme = "NCI Thesaurus";//css.getCodingSchemeURI();
            CodingSchemeVersionOrTag csvt = new CodingSchemeVersionOrTag();
            //csvt.setVersion(css.getRepresentsVersion());
            String desc = null;
            try {
                desc = lbscm.createCodeNodeSet(new String[] { code }, scheme, csvt).resolveToList(null, null, null,
                        1).getResolvedConceptReference(0).getEntityDescription().getContent();
            } catch (Exception e) {
                desc = "<not found>";
            }
            Util_displayMessage("============================================================");
            Util_displayMessage("Focus code: " + code + ":" + desc);
            Util_displayMessage("============================================================");

            // Iterate through all hierarchies ...
            String[] hierarchyIDs = lbscm.getHierarchyIDs(scheme, csvt);
            for (int i = 0; i < hierarchyIDs.length; i++) {
                String hierarchyID = hierarchyIDs[i];
                Util_displayMessage("------------------------------------------------------------");
                Util_displayMessage("Hierarchy ID: " + hierarchyID);
                Util_displayMessage("------------------------------------------------------------");
                AssociationList associations = lbscm.getHierarchyPathToRoot(scheme, csvt, hierarchyID, code, false,
                        LexBIGServiceConvenienceMethods.HierarchyPathResolveOption.ALL, null);
                for (int j = 0; j < associations.getAssociationCount(); j++) {
                    Association association = associations.getAssociation(j);
                    printChain(association, 0);
                }
                Util_displayMessage("");
            }
        //}
    } finally {
        System.out.println("Run time (ms): " + (System.currentTimeMillis() - ms));
    }
}
 

import org.LexGrid.LexBIG.LexBIGService.LexBIGService; //导入方法依赖的package包/类
/**
 * Build and returns tree items that represent the root and core concepts of
 * resolved paths for printing.
 *
 * @throws LBException
 */
protected TreeItem[] buildPathsToRoot(ResolvedConceptReference rcr,
    String scheme, CodingSchemeVersionOrTag csvt, String sab, int maxLevel)
        throws LBException {

    // Create a starting point for tree building.
    // TreeItem ti = new TreeItem(rcr.getCode(),
    // rcr.getEntityDescription().getContent(), getAtomText(rcr, sab));

    String root_name =
        getAtomName(rcr.getReferencedEntry(), NCI_SOURCE, "PT");

    // TreeItem ti = new TreeItem(rcr.getCode(),
    // rcr.getEntityDescription().getContent());
    TreeItem ti = new TreeItem(rcr.getCode(), root_name);

    LexBIGService lbs = RemoteServerUtil.createLexBIGService();
    MetaBrowserService mbs = null;
    try {
        mbs =
            (MetaBrowserService) lbs
                .getGenericExtension("metabrowser-extension");
    } catch (Exception ex) {

    }

    ti._expandable =
        hasSubconcepts(lbs, mbs, rcr.getCode(), sab, "CHD", true);
    // Maintain root tree items.
    Set<TreeItem> rootItems = new HashSet<TreeItem>();

    Set<String> visited_links = new HashSet<String>();

    // Natural flow of hierarchy relations moves forward
    // from tree root to leaves. Build the paths to root here
    // by processing upstream (child to parent) relationships.

    // buildPathsToUpperNodes(

    buildPathsToUpperNodesExt(lbs, mbs, ti, sab,
        new HashMap<String, TreeItem>(), rootItems, visited_links,
        maxLevel, 0);// , hierAssocToParentNodes_, false);
    // Return root items discovered during child to parent
    // processing.
    return rootItems.toArray(new TreeItem[rootItems.size()]);
}