Java LexBIGService.getCodingSchemeConcepts方法代码示例

import org.LexGrid.LexBIG.LexBIGService.LexBIGService; //导入方法依赖的package包/类
/**
  * Get concept Entity by code
  * @param codingScheme
  * @param code
  * @return
  */
 public ResolvedConceptReference getConceptByCode(String codingScheme, String code) {
     CodedNodeSet cns = null;
     ResolvedConceptReferencesIterator iterator = null;

     try {
LexBIGService lbSvc = RemoteServerUtil.createLexBIGService();
         cns = lbSvc.getCodingSchemeConcepts(codingScheme, null);
         ConceptReferenceList crefs =
             createConceptReferenceList(new String[] { code }, codingScheme);
         cns.restrictToCodes(crefs);
         iterator = cns.resolve(null, null, null);
         if (iterator.numberRemaining() > 0) {
             ResolvedConceptReference ref = (ResolvedConceptReference) iterator.next();
             return ref;
         }
     } catch (LBException e) {
         _logger.info("Error: " + e.getMessage());
     }

     return null;
 }
 

import org.LexGrid.LexBIG.LexBIGService.LexBIGService; //导入方法依赖的package包/类
public static void main(String[] args) throws Exception {
    args = parse(args);
    LexBIGService lbs = RemoteServerUtil.createLexBIGService();
    
    CodedNodeSet cns =
        lbs.getCodingSchemeConcepts("NCI MetaThesaurus", null);
    cns =
        cns.restrictToMatchingDesignations("single dose",
            SearchDesignationOption.ALL, "LuceneQuery", null);

    CodedNodeGraph cng = lbs.getNodeGraph("NCI MetaThesaurus", null, null);
    cng = cng.restrictToTargetCodes(cns);
    ResolvedConceptReferenceList list =
        cng.resolveAsList(null, true, false, 0, 0, null, null, null, null,
            500);

    for (ResolvedConceptReference ref : list.getResolvedConceptReference()) {
        System.out.println("Code: " + ref.getCode());
        System.out.println(" Entity Description"
            + ref.getEntityDescription().getContent());
    }
}
 

import org.LexGrid.LexBIG.LexBIGService.LexBIGService; //导入方法依赖的package包/类
/**
  * Get concept Entity by code
  * @param codingScheme
  * @param code
  * @return
  */
 public ResolvedConceptReference getConceptByCode(String codingScheme, String version,
 		String code) {
     CodedNodeSet cns = null;
     ResolvedConceptReferencesIterator iterator = null;

     try {
LexBIGService lbSvc = RemoteServerUtil.createLexBIGService();
         CodingSchemeVersionOrTag csvt = new CodingSchemeVersionOrTag();
         if (version != null) csvt.setVersion(version);

         cns = lbSvc.getCodingSchemeConcepts(codingScheme, csvt);
         ConceptReferenceList crefs =
             createConceptReferenceList(new String[] { code }, codingScheme);
         cns.restrictToCodes(crefs);
         iterator = cns.resolve(null, null, null);
         if (iterator.numberRemaining() > 0) {
             ResolvedConceptReference ref = (ResolvedConceptReference) iterator.next();
             return ref;
         }
     } catch (LBException e) {
         _logger.info("Error: " + e.getMessage());
     }

     return null;
 }
 

import org.LexGrid.LexBIG.LexBIGService.LexBIGService; //导入方法依赖的package包/类
/**
 * Resolves matching concepts for any word in the given term.
 * @param css The code system to search.
 * @param matchWords The term to match.
 * @return The list of matching references.
 * @throws LBException
 */
protected ResolvedConceptReferencesIterator resolveConcepts(CodingSchemeSummary css, String query) throws LBException {
	// Define a code set over the target terminology and
	// restrict to concepts with matching text based on 
	// the provided term.
	LexBIGService lbs = LexBIGServiceImpl.defaultInstance();
	CodingSchemeVersionOrTag csvt = new CodingSchemeVersionOrTag();
	csvt.setVersion(css.getRepresentsVersion());
	CodedNodeSet cns = lbs.getCodingSchemeConcepts(css.getLocalName(), csvt);
	
	// Restrict the code set.
	cns.restrictToMatchingDesignations(
			query, SearchDesignationOption.ALL, MatchAlgorithms.LuceneQuery.name(), null);
	
	// Resolve the concepts and assigned text.
	ResolvedConceptReferencesIterator matches = cns.resolve(
			ConvenienceMethods.createSortOptionList(new String[] {SortableProperties.code.name()}),
			null, new PropertyType[] {PropertyType.PRESENTATION});
	return matches;
}
 

import org.LexGrid.LexBIG.LexBIGService.LexBIGService; //导入方法依赖的package包/类
public static void search(String searchString, String searchAlgorithm, 
    int resolveCodedEntryDepth,
    int resolveAssociationDepth, int maxToReturn, boolean printList)
        throws Exception {
    LexBIGService lbs = RemoteServerUtil.createLexBIGService();
    String codingScheme = "NCI MetaThesaurus";

    System.out.println("----------------------------------------");
    System.out.println("* searchString: " + searchString
        + ", searchAlgorithm: " + searchAlgorithm);

    System.out.println("* resolveCodedEntryDepth: "
        + resolveCodedEntryDepth + ", resolveAssociationDepth: "
        + resolveAssociationDepth + ", maxToReturn: " + maxToReturn);

    CodedNodeSet cns = lbs.getCodingSchemeConcepts(codingScheme, null);
    cns =
        cns.restrictToMatchingDesignations(searchString,
            SearchDesignationOption.ALL, searchAlgorithm, null);

    CodedNodeGraph cng = lbs.getNodeGraph(codingScheme, null, null);
    cng = cng.restrictToTargetCodes(cns);

    ResolvedConceptReferenceList list =
        cng.resolveAsList(null, true, false, resolveCodedEntryDepth,
            resolveAssociationDepth, null, null, null, null, maxToReturn);

    int size = list.getResolvedConceptReferenceCount();
    int i = 0;
    if (printList) {
        for (ResolvedConceptReference ref : list
            .getResolvedConceptReference()) {
            System.out.println((i++) + ") " + ref.getCode() + ": "
                + ref.getEntityDescription().getContent());
        }
    }
    System.out.println("size: " + size);
    System.out.println("");
}
 

import org.LexGrid.LexBIG.LexBIGService.LexBIGService; //导入方法依赖的package包/类
public static CodedNodeSet getNodeSet(LexBIGService lbSvc, String scheme, CodingSchemeVersionOrTag versionOrTag)
       throws Exception {
	CodedNodeSet cns = null;
	try {
		cns = lbSvc.getCodingSchemeConcepts(scheme, versionOrTag);
		CodedNodeSet.AnonymousOption restrictToAnonymous = CodedNodeSet.AnonymousOption.NON_ANONYMOUS_ONLY;
		cns = cns.restrictToAnonymous(restrictToAnonymous);
    } catch (Exception ex) {
		ex.printStackTrace();
	}

	return cns;
}
 

import org.LexGrid.LexBIG.LexBIGService.LexBIGService; //导入方法依赖的package包/类
public static Vector getNCImCodes(String scheme, String version, String code) {
      Vector w = new Vector();
      CodingSchemeVersionOrTag csvt = new CodingSchemeVersionOrTag();
      if (version != null) {
	csvt.setVersion(version);
}
try {
	LexBIGService lbSvc = RemoteServerUtil.createLexBIGService();
	if (lbSvc == null) {
		_logger
			.warn("WARNING: Unable to connect to instantiate LexBIGService ???");
		return null;
	}

	ConceptReferenceList crefs = ConvenienceMethods.createConceptReferenceList(new String[] { code }, scheme);
	CodedNodeSet cns = lbSvc.getCodingSchemeConcepts(scheme, csvt);

	if (cns == null) {
		return null;
	}
	cns = cns.restrictToStatus(ActiveOption.ALL, null);
	cns = cns.restrictToCodes(crefs);
	ResolvedConceptReferenceList matches = cns.resolveToList(null, null, null, 1);
	if (matches.getResolvedConceptReferenceCount() > 0) {
		ResolvedConceptReference ref = (ResolvedConceptReference) matches.enumerateResolvedConceptReference()
				.nextElement();
		Entity node = ref.getEntity();
		return getNCImCodes(node);
	}

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

import org.LexGrid.LexBIG.LexBIGService.LexBIGService; //导入方法依赖的package包/类
public CodedNodeSet getNodeSet(LexBIGService lbSvc, String scheme, CodingSchemeVersionOrTag versionOrTag)
       throws Exception {
	CodedNodeSet cns = null;
	try {
		cns = lbSvc.getCodingSchemeConcepts(scheme, versionOrTag);
		CodedNodeSet.AnonymousOption restrictToAnonymous = CodedNodeSet.AnonymousOption.NON_ANONYMOUS_ONLY;
		cns = cns.restrictToAnonymous(restrictToAnonymous);
    } catch (Exception ex) {
		ex.printStackTrace();
	}

	return cns;
}
 

import org.LexGrid.LexBIG.LexBIGService.LexBIGService; //导入方法依赖的package包/类
/**
 * Returns the entity description for the given code.
 */
protected String getCodeDescription(LexBIGService lbsvc, String scheme, CodingSchemeVersionOrTag csvt, String code)
        throws LBException {

    CodedNodeSet cns = lbsvc.getCodingSchemeConcepts(scheme, csvt);
    cns = cns.restrictToCodes(Constructors.createConceptReferenceList(code, scheme));
    ResolvedConceptReferenceList rcrl = cns.resolveToList(null, noopList_, null, 1);
    if (rcrl.getResolvedConceptReferenceCount() > 0) {
        EntityDescription desc = rcrl.getResolvedConceptReference(0).getEntityDescription();
        if (desc != null)
            return desc.getContent();
    }
    return "<Not assigned>";
}
 

import org.LexGrid.LexBIG.LexBIGService.LexBIGService; //导入方法依赖的package包/类
public static CodedNodeSet getNodeSet(LexBIGService lbSvc, String scheme, CodingSchemeVersionOrTag versionOrTag)
      throws Exception {
CodedNodeSet cns = null;
try {
	cns = lbSvc.getCodingSchemeConcepts(scheme, versionOrTag);
	CodedNodeSet.AnonymousOption restrictToAnonymous = CodedNodeSet.AnonymousOption.NON_ANONYMOUS_ONLY;
	cns = cns.restrictToAnonymous(restrictToAnonymous);
   } catch (Exception ex) {
	ex.printStackTrace();
}

    return cns;
  }
 

import org.LexGrid.LexBIG.LexBIGService.LexBIGService; //导入方法依赖的package包/类
public static Entity getConceptWithProperty(String scheme, String version,
    String code, String propertyName) {
    try {
        LexBIGService lbSvc = new RemoteServerUtil().createLexBIGService();

        if (lbSvc == null) {
            _logger.warn("lbSvc = null");
            return null;
        }

        CodingSchemeVersionOrTag versionOrTag =
            new CodingSchemeVersionOrTag();
        if (version != null) versionOrTag.setVersion(version);

        ConceptReferenceList crefs =
            createConceptReferenceList(new String[] { code }, scheme);
        CodedNodeSet cns = null;

        try {
            cns = lbSvc.getCodingSchemeConcepts(scheme, versionOrTag);
        } catch (Exception e1) {
            e1.printStackTrace();
            return null;
        }

        //cns = cns.restrictToCodes(crefs);

        try {
cns = cns.restrictToCodes(crefs);

            LocalNameList propertyNames = new LocalNameList();
            if (propertyName != null) propertyNames.addEntry(propertyName);
            CodedNodeSet.PropertyType[] propertyTypes = null;

            //long ms = System.currentTimeMillis(), delay = 0;
            SortOptionList sortOptions = null;
            LocalNameList filterOptions = null;
            boolean resolveObjects = true; // needs to be set to true
            int maxToReturn = 1000;

            ResolvedConceptReferenceList rcrl =
                cns.resolveToList(sortOptions, filterOptions,
                    propertyNames, propertyTypes, resolveObjects,
                    maxToReturn);

            //HashMap hmap = new HashMap();
            if (rcrl == null) {
                _logger.warn("Concep not found.");
                return null;
            }

            if (rcrl.getResolvedConceptReferenceCount() > 0) {
                // ResolvedConceptReference[] list =
                // rcrl.getResolvedConceptReference();
                for (int i = 0; i < rcrl.getResolvedConceptReferenceCount(); i++) {
                    ResolvedConceptReference rcr =
                        rcrl.getResolvedConceptReference(i);
                    Entity c = rcr.getReferencedEntry();
                    return c;
                }
            }

            return null;

        } catch (Exception e) {
            _logger.error("Method: SearchUtil.getConceptWithProperty");
            _logger.error("* ERROR: getConceptWithProperty throws exceptions.");
            _logger.error("* " + e.getClass().getSimpleName() + ": "
                + e.getMessage());
            //e.printStackTrace();
        }
    } catch (Exception ex) {
            _logger.error("Method: SearchUtil.getConceptWithProperty");
            _logger.error("* ERROR: getConceptWithProperty throws exceptions.");
            _logger.error("* " + ex.getClass().getSimpleName() + ": "
                + ex.getMessage());

    }
    return null;
}
 

import org.LexGrid.LexBIG.LexBIGService.LexBIGService; //导入方法依赖的package包/类
public static ResolvedConceptReferencesIterator restrictToMatchingProperty(
		                                        String codingSchemeName,
	                                            String version,

	                                            LocalNameList propertyList,
                                                CodedNodeSet.PropertyType[] propertyTypes,
                                                LocalNameList sourceList,
                                                NameAndValueList qualifierList,

 											    java.lang.String matchText,
											    java.lang.String matchAlgorithm,
											    java.lang.String language)
	{
	    CodedNodeSet cns = null;
         ResolvedConceptReferencesIterator iterator = null;
         try {
//            LexBIGService lbSvc = new RemoteServerUtil().createLexBIGService();
//			CodingSchemeVersionOrTag versionOrTag = new CodingSchemeVersionOrTag();
//			versionOrTag.setVersion(version);
             LexBIGService lbSvc = AppService.getInstance().getLBSvc();
             CodingSchemeVersionOrTag versionOrTag = AppService.getInstance().getCSVT();
             
			if (lbSvc == null)
			{
				_logger.warn("lbSvc = null");
				return null;
			}

			cns = lbSvc.getCodingSchemeConcepts(codingSchemeName, versionOrTag);
			if (cns == null)
			{
				_logger.warn("cns = null");
				return null;
			}

			LocalNameList contextList = null;
            cns = cns.restrictToMatchingProperties(propertyList,
                                           propertyTypes,
                                           sourceList,
                                           contextList,
                                           qualifierList,
                                           matchText,
                                           matchAlgorithm,
                                           language
                                           );

			LocalNameList restrictToProperties = new LocalNameList();
			// KLO, 030509
		    SortOptionList sortCriteria = null;
			    //Constructors.createSortOptionList(new String[]{"matchToQuery"});

            try {
				// resolve nothing
                Util.StopWatch stopWatch = new Util.StopWatch();
                boolean resolveConcepts = false;
                //iterator = cns.resolve(sortCriteria, null, restrictToProperties, null);
                iterator = cns.resolve(sortCriteria, null, restrictToProperties, null, resolveConcepts);

                //ResolvedConceptReferencesIterator     resolve(SortOptionList sortOptions, LocalNameList filterOptions, LocalNameList propertyNames, CodedNodeSet.PropertyType[] propertyTypes, boolean resolveConcepts)

                long duration = stopWatch.duration();
                _debugBuffer.append("DBG: " + stopWatch.getResult(duration) + " * cns.resolve\n");
                _excelBuffer.append(stopWatch.getSecondsString(duration) + "\t");
			} catch (Exception ex) {
				ex.printStackTrace();
				return null;
			}

	    } catch (Exception e) {
			e.printStackTrace();
			return null;
	    }
		return iterator;
	}
 

import org.LexGrid.LexBIG.LexBIGService.LexBIGService; //导入方法依赖的package包/类
public static Concept getConceptByCode(String codingSchemeName, String vers, String ltag, String code)
{
       try {
           //LexBIGService lbSvc = RemoteServerUtil.createLexBIGService();
           LexBIGService lbSvc = AppService.getInstance().getLBSvc();

		if (lbSvc == null)
		{
			_logger.warn("lbSvc == null???");
			return null;
		}

		CodingSchemeVersionOrTag versionOrTag = new CodingSchemeVersionOrTag();
		versionOrTag.setVersion(vers);

		ConceptReferenceList crefs =
			createConceptReferenceList(
				new String[] {code}, codingSchemeName);

		CodedNodeSet cns = null;

		try {
			cns = lbSvc.getCodingSchemeConcepts(codingSchemeName, versionOrTag);
	    } catch (Exception e1) {
			e1.printStackTrace();
		}

		cns = cns.restrictToCodes(crefs);
		ResolvedConceptReferenceList matches = cns.resolveToList(null, null, null, 1);

		if (matches == null)
		{
			_logger.warn("Concep not found.");
			return null;
		}

		// Analyze the result ...
		if (matches.getResolvedConceptReferenceCount() > 0) {
			ResolvedConceptReference ref =
				(ResolvedConceptReference) matches.enumerateResolvedConceptReference().nextElement();

			Concept entry = ref.getReferencedEntry();
			return entry;
		}
	 } catch (Exception e) {
		 e.printStackTrace();
		 return null;
	 }
	 return null;
}
 

import org.LexGrid.LexBIG.LexBIGService.LexBIGService; //导入方法依赖的package包/类
public static HashMap code2Name(String scheme, String version, List codes) {
	HashMap hmap = new HashMap();

       try {
           LexBIGService lbSvc = new RemoteServerUtil().createLexBIGService();
           if (lbSvc == null) {
               _logger.warn("lbSvc == null???");
               return null;
           }

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

           ConceptReferenceList crefs = new ConceptReferenceList();
           for (int i=0; i<codes.size(); i++) {
			String code = (String) codes.get(i);
			ConceptReference vConceptReference = ConvenienceMethods.createConceptReference(code, scheme);
			crefs.addConceptReference(vConceptReference);
		}

           CodedNodeSet cns = null;

           try {
               cns = lbSvc.getCodingSchemeConcepts(scheme, versionOrTag);
			cns = cns.restrictToCodes(crefs);
			ResolvedConceptReferenceList matches =
				cns.resolveToList(null, null, null, null, false, -1);

			if (matches == null) {
				_logger.warn("Concept not found.");
				return null;
			}

			// Analyze the result ...
			for (int k=0; k<matches.getResolvedConceptReferenceCount(); k++) {
				ResolvedConceptReference ref =
					(ResolvedConceptReference) matches
						.getResolvedConceptReference(k);
				hmap.put(ref.getConceptCode(), ref.getEntityDescription().getContent());
			}

           } catch (Exception e1) {
               e1.printStackTrace();
           }

       } catch (Exception e) {
           e.printStackTrace();
           return null;
       }
       return hmap;
}
 

import org.LexGrid.LexBIG.LexBIGService.LexBIGService; //导入方法依赖的package包/类
public static Entity getConceptByCode(String codingSchemeName,
    String vers, String ltag, String code) {
    try {
        LexBIGService lbSvc = new RemoteServerUtil().createLexBIGService();
        if (lbSvc == null) {
            _logger.warn("lbSvc == null???");
            return null;
        }

        CodingSchemeVersionOrTag versionOrTag =
            new CodingSchemeVersionOrTag();
        versionOrTag.setVersion(vers);

        ConceptReferenceList crefs =
            createConceptReferenceList(new String[] { code },
                codingSchemeName);

        CodedNodeSet cns = null;

        try {
            cns =
                lbSvc.getCodingSchemeConcepts(codingSchemeName,
                    versionOrTag);
            if (cns == null) return null;
        } catch (Exception e1) {
            e1.printStackTrace();
            return null;
        }

        cns = cns.restrictToCodes(crefs);
        ResolvedConceptReferenceList matches =
            cns.resolveToList(null, null, null, 1);

        if (matches == null) {
            _logger.warn("Concept not found.");
            return null;
        }

        // Analyze the result ...
        if (matches.getResolvedConceptReferenceCount() > 0) {
            ResolvedConceptReference ref =
                (ResolvedConceptReference) matches
                    .enumerateResolvedConceptReference().nextElement();

            Entity entry = ref.getReferencedEntry();
            return entry;
        }
    } catch (Exception e) {
        e.printStackTrace();
        return null;
    }
    return null;
}