/**
* Resolve the Iterator
*
* @param iterator
* @param maxToReturn
* @param code
* @return
*/
public Vector<Entity> resolveIterator(
ResolvedConceptReferencesIterator iterator, int maxToReturn, String code) {
Vector<Entity> v = new Vector<Entity>();
if (iterator == null) {
_logger.warn("No match.");
return v;
}
try {
int iteration = 0;
while (iterator.hasNext()) {
iteration++;
iterator = iterator.scroll(maxToReturn);
ResolvedConceptReferenceList rcrl = iterator.getNext();
ResolvedConceptReference[] rcra = rcrl.getResolvedConceptReference();
for (int i = 0; i < rcra.length; i++) {
ResolvedConceptReference rcr = rcra[i];
Entity ce = rcr.getReferencedEntry();
if (code == null) {
v.add(ce);
} else {
if (ce.getEntityCode().compareTo(code) != 0) v.add(ce);
}
}
}
} catch (Exception e) {
_logger.warn(e.getMessage());
}
return v;
}
@Override
public DirectoryResult<T> execute(String state, int start, int maxResults) {
ResolvedConceptReferencesIterator iterator;
try {
iterator =
searchExtension.search(
state, toCodingSchemeReference(this.codeSystemVersions), MatchAlgorithm.LUCENE);
} catch (LBParameterException e) {
throw new RuntimeException(e);
}
ResolvedConceptReferenceList list;
boolean atEnd;
try {
list = iterator.get(start, start + maxResults);
atEnd = iterator.numberRemaining() <= start + maxResults;
} catch (Exception e) {
throw new RuntimeException(e);
}
List<T> returnList = new ArrayList<T>();
for (ResolvedConceptReference ref : list.getResolvedConceptReference()) {
returnList.add(this.doTransform(ref));
}
return new DirectoryResult<T>(returnList, atEnd);
}
private static ResolvedConceptReferenceList searchConceptCode(
LexEVSApplicationService evsService, String dtsVocab, String CCode, int sMetaLimit) {
ResolvedConceptReferenceList concepts = new ResolvedConceptReferenceList();
int codesSize = 0;
try {
CodedNodeSet metaNodes = evsService.getNodeSet(dtsVocab, null, null);
ConceptReferenceList crefs =
ConvenienceMethods.createConceptReferenceList(new String[] {CCode}, dtsVocab);
metaNodes = metaNodes.restrictToCodes(crefs);
metaNodes.restrictToStatus(ActiveOption.ACTIVE_ONLY, null);
concepts =
metaNodes.resolveToList(
null, // Sorts used to sort results (null means sort by match score)
null, // PropertyNames to resolve (null resolves all)
null, // PropertyTypess to resolve (null resolves all)
sMetaLimit // cap the number of results returned (-1 resolves all)
);
codesSize = concepts.getResolvedConceptReferenceCount();
} catch (Exception ex) {
System.out.println("Error do_EVSSearch get concept: " + ex.toString());
}
return concepts;
}
/*
* (non-Javadoc)
*
* @see
* org.LexGrid.LexBIG.Utility.Iterators.ResolvedConceptReferencesIterator
* #next(int)
*/
public ResolvedConceptReferenceList next(int maxToReturn)
throws LBResourceUnavailableException, LBInvocationException {
ResolvedConceptReferenceList returnList = new ResolvedConceptReferenceList();
while (returnList.getResolvedConceptReferenceCount() < maxToReturn) {
ResolvedConceptReference ref = getNextFromList();
if (ref == null) {
return returnList;
} else {
returnList.addResolvedConceptReference(ref);
}
}
return returnList;
}
@Test
public void getTreeSharedRoot() {
ResolvedConceptReferenceList list1 = new ResolvedConceptReferenceList();
ResolvedConceptReferenceList list2 = new ResolvedConceptReferenceList();
AssociatedConcept as1 = this.createResolvedConceptReference("a");
AssociatedConcept at1 = this.createResolvedConceptReference("b");
this.addAssociatedConcept(as1, at1);
AssociatedConcept as2 = this.createResolvedConceptReference("a");
AssociatedConcept at2 = this.createResolvedConceptReference("c");
this.addAssociatedConcept(as2, at2);
list1.addResolvedConceptReference(as1);
list2.addResolvedConceptReference(as2);
KeyedGraph g1 = new KeyedGraph(list1);
KeyedGraph g2 = new KeyedGraph(list2);
KeyedGraph unionedGraph = g1.union(g2);
ResolvedConceptReferenceList returnList = unionedGraph.toResolvedConceptReferenceList();
assertEquals(1, returnList.getResolvedConceptReferenceCount());
assertEquals("a", returnList.getResolvedConceptReference(0).getCode());
assertEquals(
2,
returnList
.getResolvedConceptReference(0)
.getSourceOf()
.getAssociation(0)
.getAssociatedConcepts()
.getAssociatedConceptCount());
}
private boolean compareResolvedConceptReferenceList(
ResolvedConceptReferenceList list1, ResolvedConceptReferenceList list2) {
ResolvedConceptReference[] rcr1 = list1.getResolvedConceptReference();
ResolvedConceptReference[] rcr2 = list2.getResolvedConceptReference();
boolean found = false;
for (int i = 0; i < rcr1.length; i++) {
ResolvedConceptReference ref = rcr1[i];
String searchCode = ref.getConceptCode();
for (int j = 0; j < rcr2.length; j++) {
ResolvedConceptReference searchRef = rcr2[j];
String foundCode = searchRef.getConceptCode();
if (searchCode.equals(foundCode)) {
found = true;
}
}
}
return found;
}
@Test
public void getDuplicates() {
ResolvedConceptReferenceList list1 = new ResolvedConceptReferenceList();
ResolvedConceptReferenceList list2 = new ResolvedConceptReferenceList();
String[] codes1 = new String[] {"a", "b", "c", "d", "e", "f"};
String[] codes2 = new String[] {"d", "e", "f"};
for (String code : codes1) {
list1.addResolvedConceptReference(createResolvedConceptReference(code));
}
for (String code : codes2) {
list2.addResolvedConceptReference(createResolvedConceptReference(code));
}
KeyedGraph g1 = new KeyedGraph(list1);
KeyedGraph g2 = new KeyedGraph(list2);
KeyedGraph unionedGraph = g1.union(g2);
assertEquals(6, unionedGraph.getNodes().keySet().size());
}
private static ResolvedConceptReferenceList searchPrefTerm(
LexEVSApplicationService evsService,
String dtsVocab,
String prefName,
int sMetaLimit,
String algorithm) {
ResolvedConceptReferenceList concepts = new ResolvedConceptReferenceList();
int codesSize = 0;
try {
CodedNodeSet metaNodes = evsService.getNodeSet(dtsVocab, null, null);
metaNodes =
metaNodes.restrictToMatchingDesignations(
prefName, // the text to match
CodedNodeSet.SearchDesignationOption
.ALL, // whether to search all designation, only Preferred or only Non-Preferred
algorithm, // the match algorithm to use
null); // the language to match (null matches all)
metaNodes = metaNodes.restrictToStatus(ActiveOption.ACTIVE_ONLY, null);
concepts =
metaNodes.resolveToList(
null, // Sorts used to sort results (null means sort by match score)
null, // PropertyNames to resolve (null resolves all)
new CodedNodeSet.PropertyType[] {
PropertyType.DEFINITION, PropertyType.PRESENTATION
}, // PropertyTypess to resolve (null resolves all)
sMetaLimit // cap the number of results returned (-1 resolves all)
);
codesSize = concepts.getResolvedConceptReferenceCount();
} catch (Exception ex) {
// ex.printStackTrace();
System.out.println("Error do_EVSSearch DescLogic: " + ex.toString());
}
return concepts;
}
public static String getEVSCode(String prefName, String dtsVocab) {
LexEVSApplicationService evsService = null;
try {
evsService =
(LexEVSApplicationService)
ApplicationServiceProvider.getApplicationService("EvsServiceInfo");
} catch (Exception e) {
throw new RuntimeException(e);
}
if (dtsVocab == null) dtsVocab = "";
String CCode = "";
if (dtsVocab.equals("Thesaurus/Metathesaurus")
|| dtsVocab.equals("")
|| dtsVocab.equals("NCI Thesaurus")
|| dtsVocab.equals("NCI_Thesaurus")) dtsVocab = "NCI_Thesaurus";
ResolvedConceptReferenceList codes2 = null;
int codesSize = 0;
try {
CodedNodeSet metaNodes = evsService.getNodeSet("NCI MetaThesaurus", null, null);
metaNodes =
metaNodes.restrictToMatchingDesignations(
prefName, // the text to match
CodedNodeSet.SearchDesignationOption
.PREFERRED_ONLY, // whether to search all designation, only Preferred or only
// Non-Preferred
"exactMatch", // the match algorithm to use
null); // the language to match (null matches all)
metaNodes = metaNodes.restrictToStatus(ActiveOption.ACTIVE_ONLY, null);
codes2 =
metaNodes.resolveToList(
null, // Sorts used to sort results (null means sort by match score)
null, // PropertyNames to resolve (null resolves all)
new CodedNodeSet.PropertyType[] {
PropertyType.DEFINITION, PropertyType.PRESENTATION
}, // PropertyTypess to resolve (null resolves all) //PropertyTypess to resolve (null
// resolves all)
10 // cap the number of results returned (-1 resolves all)
);
codesSize = codes2.getResolvedConceptReferenceCount();
} catch (Exception ex) {
System.err.println("Error do_getEVSCode:resolveToList: " + ex.toString());
ex.printStackTrace();
}
if (codes2 != null) {
ResolvedConceptReference conceptReference = new ResolvedConceptReference();
// logger.debug("Got "+codesSize+" results for the do_getEVSCode search using prefName and
// exactMatch");
for (int i = 0; i < codesSize; i++) {
conceptReference = (ResolvedConceptReference) codes2.getResolvedConceptReference(i);
CCode = (String) conceptReference.getConceptCode();
}
}
evsService = null;
return CCode;
}
public static List searchEVS(
String term,
String dtsVocab,
String retired,
String sSearchInEVS,
String sUISearchType,
String sMetaSource,
int sMetaLimit)
throws Exception {
String algorithm;
String altNameType;
String CCode;
String prefName = "";
Boolean isRetired = new Boolean(false);
Boolean bTrue = new Boolean(true);
Boolean bFalse = new Boolean(false);
boolean isMetaCodeSearch = false;
Boolean codeFoundInThesaurus = new Boolean(false);
String source = "";
String definition = "";
List vCon = new ArrayList();
String sDefDefault = "No value exists.";
String sDef = "";
String sDefSrc = "";
// List vCon = null;
List vMetaDefs = new ArrayList();
// List vMetaDefs = null;
if (dtsVocab.equals("Thesaurus/Metathesaurus")
|| dtsVocab.equals("")
|| dtsVocab.equals("NCI Thesaurus")
|| dtsVocab.equals("NCI_Thesaurus")) {
dtsVocab = "NCI Thesaurus";
altNameType = "NCI_CONCEPT_CODE";
}
// for search Meta by (LOINC) code
else if (dtsVocab.equals("Metathesaurus") || sSearchInEVS.equals("Code")) {
dtsVocab = "NCI_Thesaurus";
altNameType = "NCI_CONCEPT_CODE";
isMetaCodeSearch = true;
sUISearchType = "term";
}
// for Meta searches only (no Thes search), like in getSuperConcepts Meta
else if (dtsVocab.equals("NCI Metathesaurus")) {
altNameType = "UMLS_CUI";
isMetaCodeSearch = false;
sUISearchType = "term";
} else altNameType = "";
LexEVSApplicationService evsService =
(LexEVSApplicationService)
ApplicationServiceProvider.getApplicationService("EvsServiceInfo");
/* if (!sSearchInEVS.equals("Concept Code") || term.equals("")) {*/
Pattern pattern = Pattern.compile("^C\\d{2,8}");
Matcher matcher = pattern.matcher(term);
algorithm = getAlgorithm(term);
term = cleanTerm(term);
int totalReturnCount = 0;
try {
if (retired.equals(
"Include")) // do this if all concepts, including retired, should be included
isRetired = new Boolean(false);
else {
try {
ResolvedConceptReferenceList rcrl =
searchPrefTerm(evsService, dtsVocab, term, sMetaLimit, algorithm);
if (rcrl != null && rcrl.getResolvedConceptReferenceCount() > 0)
isRetired = (Boolean) (!rcrl.getResolvedConceptReference(0).getEntity().isIsActive());
} catch (Exception ex) {
ex.printStackTrace();
}
}
if (isRetired.equals(bFalse)) {
ResolvedConceptReferenceList concepts = null;
// CCode = term;
int codesSize = 0;
try {
if (sSearchInEVS.equals("Concept Code") || matcher.matches())
concepts = searchConceptCode(evsService, dtsVocab, term, sMetaLimit);
else concepts = searchPrefTerm(evsService, dtsVocab, term, sMetaLimit, algorithm);
codesSize = concepts.getResolvedConceptReferenceCount();
} catch (Exception ex) {
System.out.println("Error do_EVSSearch get concept: " + ex.toString());
}
if (concepts != null && codesSize > 0) {
codeFoundInThesaurus = new Boolean(true);
prefName = concepts.getResolvedConceptReference(0).getEntityDescription().getContent();
concepts = new ResolvedConceptReferenceList();
try {
concepts = searchPrefTerm(evsService, dtsVocab, prefName, sMetaLimit, algorithm);
codesSize = concepts.getResolvedConceptReferenceCount();
} catch (Exception ex) {
// ex.printStackTrace();
System.out.println("Error do_EVSSearch DescLogic: " + ex.toString());
}
if (concepts != null) {
ResolvedConceptReference rcr = new ResolvedConceptReference();
for (int i = 0; i < codesSize; i++) {
rcr = concepts.getResolvedConceptReference(i);
prefName = rcr.getEntityDescription().getContent();
CCode = rcr.getConceptCode();
Definition[] defs = rcr.getEntity().getDefinition();
if (defs == null) defs = new Definition[0];
sDef = sDefDefault; // "No Value Exists.";
sDefSrc = "";
for (int k = 0; k < defs.length; k++) {
Definition def = defs[k];
if (def != null) {
if (def.getIsPreferred() != null) {
sDef = def.getValue().getContent();
if (def.getSourceCount() > 0)
sDefSrc = def.getSource(0).getContent(); // get def source
}
}
}
EVSBean conBean = new EVSBean();
conBean.setCode(CCode);
conBean.setDefinition(sDef);
conBean.setDictionary(dtsVocab);
conBean.setName(prefName);
conBean.setSource(sDefSrc);
conBean.setType(altNameType);
vCon.add(conBean);
totalReturnCount++;
if (totalReturnCount >= sMetaLimit) return vCon;
}
}
}
}
} catch (Exception ex) {
System.out.println("Error do_EVSSearch Concept code: " + ex.toString());
}
// Search Meta
int length = 0;
length = term.length();
ResolvedConceptReferenceList concepts = null;
if (sSearchInEVS.equals("Concept Code"))
concepts = searchConceptCode(evsService, "NCI Metathesaurus", term, sMetaLimit);
else if (!sSearchInEVS.equals("Concept Code"))
concepts = searchPrefTerm(evsService, "NCI Metathesaurus", term, sMetaLimit, algorithm);
if (concepts != null) {
ResolvedConceptReference rcr = new ResolvedConceptReference();
for (int i = 0; i < concepts.getResolvedConceptReferenceCount(); i++) {
if (totalReturnCount >= sMetaLimit) break;
rcr = concepts.getResolvedConceptReference(i);
prefName = rcr.getEntityDescription().getContent();
CCode = rcr.getConceptCode();
Definition[] defs = rcr.getEntity().getDefinition();
if (defs == null) defs = new Definition[0];
sDef = sDefDefault; // "No Value Exists.";
sDefSrc = "";
for (int k = 0; k < defs.length; k++) {
Definition def = defs[k];
if (def != null) {
sDef = def.getValue().getContent();
if (def.getSourceCount() > 0) sDefSrc = def.getSource(0).getContent(); // get def source
}
EVSBean conBean = new EVSBean();
conBean.setCode(CCode);
conBean.setDefinition(sDef);
conBean.setDictionary("NCI Metathesaurus");
conBean.setName(prefName);
conBean.setSource(sDefSrc);
conBean.setType("UMLS_CUI");
vCon.add(conBean);
totalReturnCount++;
if (totalReturnCount >= sMetaLimit) break;
}
}
}
evsService = null;
System.out.println(vCon.size());
return vCon;
}