NIH | National Cancer Institute | NCI Wiki  

Versions Compared

Old Version 147

changes.mady.by.user Unknown User (wileyal)

Saved on

compared with

New Version Current

changes.mady.by.user Unknown User (wileyal)

Saved on

Key

  • This line was added.
  • This line was removed.
  • Formatting was changed.
Comment: Migration of unmigrated content due to installation of a new plugin

...

Panel
titleDocument information

Author: Traci St.Martin/Craig Stancl/Kevin Peterson/Scott Bauer/Sridhar Dwarkanath/Mike Turk
Email: stmartin.traci@mayo.edu
Team: LexEVS/EVS
Contract: SAIC Subcontract#28XS112
Client: NCI CBIIT
National Institutes of Heath
US Department of Health and Human Services

Sign off

Date

Role

CBIIT or Stakeholder Organization

Reviewer's Comments (If disapproved indicate specific areas for improvement.)

—

—

—

—

—

The purpose of this document is to collect, analyze, and define high-level needs for and designed features of the National Cancer Institute Center for Biomedical Informatics and Information Technology (NCI CBIIT) caCORE LexEVS Release 5.1. The focus is on the functionalities proposed by the stakeholders and target users to make a better product. The use case documents show in detail how the features meet these needs.

...

Data Source layer--- is responsible for storage and access to all data required to represent the objects returned through API invocation.

High Level Design Diagram
high level diagram

...

The LexEVS Value Domain and Pick List Service meant to expose the API particularly for the Value Domain and Pick List elements of the LexGrid Logical Model. For more information on LexGrid model see http://informatics.mayo.edu\\Image Removed

Improved Loader Framework

...

For example, an index of People may be indexed in Lucene as:

No Format

Document: id 1
First Name: John
Last Name: Doe
Sex: Male
Age: 45

Document: id 2
First Name: Jane
Last Name: Doe
Sex: Female
Age: 40

... etc.

...

  • Lazy Retrieval
    We can leverage this to increase performance in LexEVS. Consider this simplified LexEVS Entity index:
No Format

Document: id 1
Code: C12345
Name: Heart

Document: id 2
Code: C67890
Name: Foot

Document: id 3
Code: C98765
Name: Heart Attack

...

Class:

org.LexGrid.LexBIG.Extensions.Extendable.Search

Method:

public org.apache.lucene.search.Query buildQuery(String searchText)

Description:

Given a String search string, build a Query object to match indexed Lucene Documents

...

WeightedDoubleMetaphoneQuery
This algorithm does not automatically assume that the user has spelled the terms incorrectly. Searches are also based on the actual text that the user has input, along with the Metaphone value.
Again, if the user input "Breast", the query will still match "Breast" and "Prostrate", but "Breast" will have a higher match score, because the actual user text is considered. This will add a greater precision to this fuzzy-type query.

Algorithm:

No Format

get: user text input
2: total score = 0
3: metaphone score = 0
4: actual score = 0
5: metaphone value = lucene.computeMetaphoneValue(user text input)
6: metaphone score = lucene.scoreMetaphoneValue(metaphone value)
7: actual score = lucene.score(user text input)
8: total score = metaphone score + actual score
9: halt

...

Also, a leading and trailing wildcard will be added, so
"th a heart atta"
Will also match:
"The patient with a heart attack was seen today".

Algorithm:

No Format

get: user text input
2: user text input = '*' + user text input + '*'
3: score = lucene.score(user text input)
4: halt

...

  • Sorting on Different Class types
    • A single Sort may be applicable for a variety of Class types. For instance, both an 'Association' and an 'Entity' may be sorted by 'Code', but the actual implementation of retrieving the Code and comparing it may be different between the two. It is the job of the Sort to implement a Comparator for each potential Class that it is eligible to sort.
  • Default Sorting
    • All result sets are sorted by default by Lucene Score, meaning that the best match according to Lucene will always be returned first by default. Note that if two or more result sets are being Unioned, Intersected, or Differenced, the user must explicitly call a 'matchToQuery' sort on the result set as a whole to order all of the results.
  • Sort Contexts
    • Sorts may be applicable in one or more 'Contexts' (see: org.LexGrid.LexBIG.DataModel.InterfaceElements.types.SortContext)
      This means that a Sort may apply only to a CodedNodeSet, or only to a CodedNodeGraph, or some combination. Sorts will only be employed by the API if they match the Context in which the results are being sorted.
  • Performance Issues
    • Sorting is generally computationally expensive, because in order to correctly sort, the field to be sorted has to be fully retrieved for the entire result set. For very specific or refined queries, this may not be a problem, but for large ontologies or very general queries, performance may be a concern. To alleviate this, 'Post sort' has been introduced.
  • Post Sorting

    • In order to minimize the performance impact of sorting, users are encouraged to use a 'Post sort' where possible. A Post sort is done after the result set has been restricted, thus limiting the amount of information that must be retrieved in order to perform the sort. For instance, a query may match a set of Entities:

      No Format
      
{"Heart", "Heart Failure", "Heart Attack", "Arm", "Finger", ...}

As described earlier, all results are by default sorted by Lucene score, so if we limit the result set to the top 3, the result is:

No Format

{"Heart", "Heart Failure", "Heart Attack"}


The restricted set can then be 'Post' sorted - and because the result set has be limited to a reasonable number of matches, sorting and retrieval time can be minimized.

Algorithm:

No Format

1: get: Sort requested by user
2: get: Context sort is being applied to
3: if: sort is not valid for Context
halt
4: else:
5: get: Class to be sorted on
6: if: sort is not valid for Class
halt
7: get: Comparator for Sort - given (Class to be sorted on)
8: sort results using Comparator for Sort
9: halt

...

Code

Qualifier

C01234

isAnOrgan

C98765

isADisease

No Format

SELECT * FROM Codes

Results in:

...

To get the Qualifiers, separate SELECTs must be used for each.

No Format

SELECT * FROM Qualifiers where Code = C01234
And
SELECT * FROM Qualifiers where Code = C98765

...

Code

Qualifier

C01234

isAnOrgan

C98765

isADisease

No Format

SELECT * FROM Codes JOIN Qualifiers ON Code

...

Class Name

Description

PickListsServices

Class to handle list of Pick List Definitions.

PickListServices

Class to handle individual Pick List Definition objects to and fro database.

PLEntryServices

Class to handle Pick List Entry objects to and fro database.

LexEVSPickListServices

Primary interface for LexEVS Pick List API.

LexEVSPickListServicesImpl

Implementation of LexEVSPickListServices which is primary interface for LexEVS Pick List API.

LoadPickList

Imports the Pick List Definitions in the source file, provided in LexGrid canonical format, to the LexBIG repository.

ResolvedPickListEntyList

Class to hold list of resolved pick list entries.

ResolvedPickListEntry

Bean for resolved pick list entries.

Image Modified

LexBIG Services Class Diagram

...

An interface to LexEVS Value Domain and Pick List Services could be obtained using an instance of LexBigService.

Information

getValueDomainService()

Description:

Returns an interface to LexEVS Value Domain API.

Input:

none

Output:

org.lexgrid.valuedomain.LexEVSValueDomainServices

Exception:

LBException

Implementation Details:

Implementation:
Step 1: Call this method on the associated LexBIG Service instance.
Sample Call:
Using LexBIGService instance :
org.lexgrid.valuedomain.LexEVSValueDomainServices vds = lbs.getValueDomainService();

Information

getPickListService()

Description:

Returns an interface to LexEVS Pick List API.

Input:

none

Output:

org.lexgrid valuedomain.LexEVSPickListServices

Exception:

LBException

Implementation Details:

Implementation:
Step 1: Call this method on the associated LexBIG Service instance.
Sample Call:
Using LexBIGService instance :
_ _org.lexgrid.valuedomain.LexEVSPickListServices vds = lbs.getPickListService();

LexEVS Value Domain Service API - Loading Value Domain

...

Information

loadValueDomain(ValueDomainDefinition vddef, String systemReleaseURI)

Description:

Loads supplied valueDomainDefinition object

Input:

org.LexGrid.emf.valueDomains.ValueDomainDefinition,
String

Output:

none

Exception:

LBException

Implementation Details:

Implementation:
Step 1: Call this method on the associated LexEVS Value Domain Service instance to load a Value Domain Definition object and the System Release URI this definition belongs to.
Sample Call:
Step 1 : Using LexBIGService instance, get the LexEVSValueDomainServices interface :
org.lexgrid.valuedomain.LexEVSValueDomainServices vds = lbs.getValueDomainService();
Step 2 :Create and populate the ValueDomainDefinition object
ValueDomainDefinition can be created using :
org.LexGrid.emf.valueDomains.ValueDomainDefinition valueDomain = org.LexGrid.emf.valueDomains.ValuedomainsFactory.eINSTANCE.createValueDomainDefinition();
And data for valueDomain object can be populated by using set methods :
valueDomain.setValueDomainURI( uri );
valueDomain.setValueDomainName( name );
valueDomain.setDefaultCodingScheme( cs );
valueDomain.setEntityDescription( ed );
Similarly, DefinitionEntry, Property, Mapping objects can be created and assign to the valueDomain object.
valueDomain.getDefinitionEntry.add( vdEntry );
valueDomain.setProperties( propertisObject );
valueDomain.setMappings( mappingsObject );
Step 3 : call the load method by passing the Value Domain Definition object and the System Release URI :
vds.loadvalueDomain( valueDomain,"Release 2009" );

Information

loadValueDomain(InputStream inputStream,boolean failOnAllErrors))

Description:

Loads valueDomainDefinitions found in inputStream

Input:

java.io.InputStream
boolean

Output:

none

Exception:

Exception

Implementation Details:

Implementation:
Step 1: Call this method on the associated LexEVS Value Domain Service instance to load all Value Domain Definitions from the inputstream.
Sample Call:
Step 1 : Using LexBIGService instance, get the LexEVSValueDomainServices interface org.lexgrid.valuedomain.LexEVSValueDomainServices vds = lbs.getValueDomainService();
Step 2 :Call load method by passing the inputSteam and boolean flag whether to stop on load errors. :
vds.loadvalueDomain( inputStream, true );

Information

loadValueDomain(String xmlFileLocation, boolean failOnAllErrors)

Description:

Loads valueDomainDefinitions found in input xml file

Input:

java.lang.String
boolean

Output:

none

Exception:

Exception

Implementation Details:

Implementation:
Step 1: Call this method on the associated LexEVS Value Domain Service instance to load all Value Domain Definitions found in an XML file that is in LexGrid format.
 
Sample Call:
Step 1 : Using LexBIGService instance, get the LexEVSValueDomainServices interface org.lexgrid.valuedomain.LexEVSValueDomainServices vds = lbs.getValueDomainService();
Step 2 :Call load method by passing the inputfile location and boolean flag whether to stop on load errors. :
vds.loadvalueDomain( inputXMLFile, true );

 

Validate XML resources

Information

validate(URI uri, int valicationLevel) throws LBParameterException

Description:

Perform validation of the candidate resource without loading data.

Input:

java.net.URI
int

Output:

none

Exception:

Org.LexGrid.LexBIG.Exceptions.LBParameterException

Implementation Details:

Implementation:
Step 1: Call this method on the associated LexEVS Value Domain Service instance to validate the XML file that is in LexGrid format. This call will not load the data in XML file.
 
Sample Call:
Step 1 : Using LexBIGService instance, get the LexEVSValueDomainServices interface org.lexgrid.valuedomain.LexEVSValueDomainServices vds = lbs.getValueDomainService();
Step 2 :Call validate method for validation by supplying URI of the XML file and validation level:
Supported validationLevels includes :
0 = Verify document is well-formed
1 = Verify document is valid
  vds.validaten( uriOfXMLFile, true );

Query Value Domain

Information

isConceptInDomain(String entityCode, URI valueDomainURI)

Description:

Determine if the supplied entity code is a valid result for the supplied value domain and, if it is, return the particular codingSchemeVersion that was used.

Input:

java.lang.String,
java.net.URI

Output:

org.LexGrid.LexBIG.DataModel.Core. AbsoluteCodingSchemeVersionReference

Exception:

org.LexGrid.LexBIG.Exceptions.LBException

Implementation Details:

Implementation:
Step 1: Call this method on the associated LexEVS Value Domain Service instance to determine if the supplied entity code is a valid in the supplied Value Domain URI. If it is, return Coding Scheme URI and the Version that was used to resolve, other wise, returns null.
 
Sample Call:
Step 1 : Using LexBIGService instance, get the LexEVSValueDomainServices interface org.lexgrid.valuedomain.LexEVSValueDomainServices vds = lbs.getValueDomainService();
Step 2 :Call isConceptInComdin method:
AbsoluteCodingSchemeVersionReference acsvr =   vds.isConceptInDomain( "conceptA","valueDomainURI" );

Information

isConceptInDomain(String entityCode, URI entityCodeNamespace, CodingSchemeVersionOrTag csvt, URI valueDomainURI)

Description:

Similar to previous method, this method determine if the supplied entity code and entity namespace is a valid result for the supplied value domain when resolved against supplied Coding Scheme Version or Tag.

Input:

java.lang.String,
java.net.URI,
org.LexGrid.LexBIG.DataModel.Core. CodingSchemeVersionOrTag
java.net.URI

Output:

org.LexGrid.LexBIG.DataModel.Core. AbsoluteCodingSchemeVersionReference

Exception:

org.LexGrid.LexBIG.Exceptions.LBException

Implementation Details:

Implementation:
Step 1: Call this method on the associated LexEVS Value Domain Service instance to determine if the supplied entity code and its entity namespace is a valid in the supplied Value Domain URI when resolved against supplied Coding Scheme Version or Tag. If it is, return Coding Scheme URI and the Version that was used to resolve, other wise, returns null.
 
Sample Call:
Step 1 : Using LexBIGService instance, get the LexEVSValueDomainServices interface org.lexgrid.valuedomain.LexEVSValueDomainServices vds = lbs.getValueDomainService();
Step 2 :Call isConceptInDomain method:
AbsoluteCodingSchemeVersionReference acsvr =   vds.isConceptInDomain( "conceptA","conceptAEntityNamespace",
"codingSchemeVersion","valueDomainURI" );

Information

resolveValueDomain(URI valueDomainURI, AbsoluteCodingSchemeVersionReferenceList csVersionList)

Description:

Resolve a value domain using the supplied set of coding scheme versions.

Input:

java.net.URI,
org.LexGrid.LexBIG.DataModel.Core. AbsoluteCodingSchemeVersionReferenceList

Output:

org.lexgrid.valuedomain.dto.ResolvedValueDomainDefinition

Exception:

org.LexGrid.LexBIG.Exceptions.LBException

Implementation Details:

Implementation:
Step 1: Call this method on the associated LexEVS Value Domain Service instance to resolve supplied value domain against list of Coding Scheme versions if supplied. If Coding Scheme Versions list is not supplied, API will resolve against any version of the loaded Coding Scheme that is referenced by the Value Domain.   Returns, object ResolvedValueDomainDefinition which contains AbsoluteCodingSchemeVersionReferenceList which tells which all Coding Scheme and the versions were used for this resolve, plus the ResolvedConceptReferencesIterator, which is an iterator for all the valid concepts that belongs to the Value Domain and Value Domain Definition itself.
Sample Call:
Step 1 : Using LexBIGService instance, get the LexEVSValueDomainServices interface org.lexgrid.valuedomain.LexEVSValueDomainServices vds = lbs.getValueDomainService();
Step 2 :Create AbsoluteCodingSchemeVersionReferenceList:
AbsoluteCodingSchemeVersionReferenceList csvList = new AbsoluteCodingSchemeVersionReferenceList();
csvList.addAbsoluteCodingSchemeVersionReference(Constructors.
createAbsoluteCodingSchemeVersionReference("Automobiles", "2.0"));
csvList.addAbsoluteCodingSchemeVersionReference(Constructors.
createAbsoluteCodingSchemeVersionReference("AutomobilesParts", "2.0"));
Step 3 :Call resolveValueDomain method:
ResolvedValueDomainDefinition rvdDef =   vds.resolveValueDomain ( "valueDomainURI",csvList );

Information

isSubDomain(URI childValueDomainURI, URI parentValueDomainURI)

Description:

Check whether childValueDomainURI is a child of parentValueDomainURI.

Input:

java.net.URI,
java.net.URI

Output:

boolean

Exception:

org.LexGrid.LexBIG.Exceptions.LBException

Implementation Details:

Implementation:
Step 1: Call this method on the associated LexEVS Value Domain Service instance to determine if all the concepts that gets resolved from supplied Child Value Domain URI is children of concepts that gets resolved from Parent Value Domain URI. Return true, if it is otherwise return false.
Sample Call:
Step 1 : Using LexBIGService instance, get the LexEVSValueDomainServices interface org.lexgrid.valuedomain.LexEVSValueDomainServices vds = lbs.getValueDomainService();
Step 2 :Call isSubDomain method:
boolean isSubDomain =   vds.isSubDomain ( childValueDomainURI, parentValueDomainURI );

Information

getValueDomainDefinition(URI valueDomainURI)

Description:

Returns value domain definition for supplied value domain URI.

Input:

java.net.URI

Output:

org.LexGrid.emf.valueDomains.ValueDomainDefinition

Exception:

org.LexGrid.LexBIG.Exceptions.LBException

Implementation Details:

Implementation:
Step 1: Call this method on the associated LexEVS Value Domain Service instance to get the Value Domain Definition of supplied Value Domain URI.
Sample Call:
Step 1 : Using LexBIGService instance, get the LexEVSValueDomainServices interface org.lexgrid.valuedomain.LexEVSValueDomainServices vds = lbs.getValueDomainService();
Step 2 :Call getValueDomainDefinition   method:
ValueDomainDefinition vdDef   =   vds.getValueDomainDefinition ( valueDomainURI );

Information

listValueDomains(String valueDomainName)

Description:

Return the URI's for the value domain definition(s) for the supplied domain name. If the name is null, returns everything. If the name is not null, returns the value domain(s) that have the assigned name.
Note: plural because there is no guarantee of valueDomain uniqueness. If the name is the empty string "", returns all unnamed valueDomains.

Input:

java.lang.String
<ac:structured-macro ac:name="unmigrated-wiki-markup" ac:schema-version="1" ac:macro-id="2230e90a-f67a-4395-899f-171fcf46509a"><ac:plain-text-body><![CDATA[

Output:

java.net.URI[]

]]></ac:plain-text-body></ac:structured-macro>

Exception:

org.LexGrid.LexBIG.Exceptions.LBException

Implementation Details:

Implementation:
Step 1: Call this method on the associated LexEVS Value Domain Service instance to get the list of Value Domain URI that matches the supplied name.
 
Sample Call:
Step 1 : Using LexBIGService instance, get the LexEVSValueDomainServices interface org.lexgrid.valuedomain.LexEVSValueDomainServices vds = lbs.getValueDomainService();
Step 2 :Call listValueDomains   method:
<ac:structured-macro ac:name="unmigrated-wiki-markup" ac:schema-version="1" ac:macro-id="17a58390-0c35-4a25-bdaf-9e25e2010801"><ac:plain-text-body><![CDATA[ URI[] uris   =   vds.listValueDomains(" someValueDomainName" );

]]></ac:plain-text-body></ac:structured-macro>

Information

getAllValueDomainsWithNoNames()

Information

getAllValueDomainsWithNoNames()

Description:

Return the

Description:

Return the URI's of all unnamed value domain definition(s).

Input:

none
<ac:structured-macro ac:name="unmigrated-wiki-markup" ac:schema-version="1" ac:macro-id="204793b8-cada-432a-bfd7-6be57cadb11c"><ac:plain-text-body><![CDATA[

Output:

java.net.URI[]

]]></ac:plain-text-body></ac:structured-macro>

Exception:

org.LexGrid.LexBIG.Exceptions.LBException

Implementation Details:

Implementation:
Step 1: Call this method on the associated LexEVS Value Domain Service instance to get the list of Value Domain URI that have no names.
 
Sample Call:
Step 1 : Using LexBIGService instance, get the LexEVSValueDomainServices interface org.lexgrid.valuedomain.LexEVSValueDomainServices vds = lbs.getValueDomainService();
Step 2 :Call getAllValueDomainsWithNoNames   method:
<ac:structured-macro ac:name="unmigrated-wiki-markup" ac:schema-version="1" ac:macro-id="d594db52-54a3-4249-9ee5-eb5f9087e065"><ac:plain-text-body><![CDATA[ URI[] uris   =   vds.getAllValueDomainsWithNoNames();

]]></ac:plain-text-body></ac:structured-macro>

Information

getValueDomainEntitiesForTerm(String term, URI valueDomainURI, String matchAlgorithm)

Description:

Resolves the value domain supplied and restricts to the term and matchAlgorith supplied. Return object ResolvedValueDomainCodedNodeSet contains the codingScheme URI and Version that was used to resolve and the CodedNodeSet.
Note : the CodedNodeSet is unresolved

Input:

java.lang.String,
java.net.URI,
java.lang.String

Output:

org.lexgrid.valuedomain.dto.ResolvedValueDomainCodedNodeSet

Exception:

org.LexGrid.LexBIG.Exceptions.LBException

Implementation Details:

Implementation:
Step 1: Call this method on the associated LexEVS Value Domain Service instance to get the resolved Value Domain Entries as CodedNodeSet that is restricted to supplied term and the match algorithm.   Returned CodedNodeSet is not resolved.
Sample Call:
Step 1 : Using LexBIGService instance, get the LexEVSValueDomainServices interface org.lexgrid.valuedomain.LexEVSValueDomainServices vds = lbs.getValueDomainService();
Step 2 :Call getValueDomainEntriesForTerm   method:
ResolvedValueDomainCodedNodeSet vdvns   =   vds.getValueDomainEntriesForTerm ("General Motors", new URI("AUTO:AllDomesticANDGM"), MatchAlgorithms.exactMatch.name() );

Information

getCodingSchemesInValueDomain(URI valueDomainURI)

Description:

Returns list of coding scheme summary that is referenced by the supplied value domain.

Input:

java.net.URI

Output:

org.LexGrid.LexBIG.DataModel.Collections. AbsoluteCodingSchemeVersionReferenceList

Exception:

org.LexGrid.LexBIG.Exceptions.LBException

Implementation Details:

Implementation:
Step 1: Call this method on the associated LexEVS Value Domain Service instance to get List of all Coding Scheme URI and Versions the supplied Value Domain URI references.
 
Sample Call:
Step 1 : Using LexBIGService instance, get the LexEVSValueDomainServices interface org.lexgrid.valuedomain.LexEVSValueDomainServices vds = lbs.getValueDomainService();
Step 2 :Call getCodingSchemesInValueDomain   method:
AbsoluteCodingSchemeVersionReferenceList csvList   =   vds.getCodingSchemesInValueDomain( new URI("AUTO:AllDomesticANDGM") );

Information

isDomain(String entityCode, String codingSchemeName, CodingSchemeVersionOrTag csvt)

Description:

Determine if the supplied entity code is of type valueDomain in supplied coding scheme and, if it is, return the true, otherwise return false.

Input:

java.lang.String,
java.lang.String
org.LexGrid.LexBIG.DataModel.Core. CodingSchemeVersionOrTag

Output:

boolean

Exception:

org.LexGrid.LexBIG.Exceptions.LBException

Implementation Details:

Implementation:
Step 1: Call this method on the associated LexEVS Value Domain Service instance to check if supplied entity code is of type valueDomain in supplied Coding Scheme.
 
Sample Call:
Step 1 : Using LexBIGService instance, get the LexEVSValueDomainServices interface org.lexgrid.valuedomain.LexEVSValueDomainServices vds = lbs.getValueDomainService();
Step 2 :Call isDomain   method:
boolean isDomain   =   vds.isDomain ("VD005", "Automobiles", Constructors.createCodingSchemeVersionOrTag(null, "2.0")) );

Remove Value Domain Definition

 

Information

removeValueDomain(URI valueDomainURI)

Description:

Removes supplied value domain definition from the system.

Input:

java.net.URI

Output:

none

Exception:

org.LexGrid.LexBIG.Exceptions.LBException,
org.LexGrid.managedobj.RemoveException

Implementation Details:

Implementation:
Step 1: Call this method on the associated LexEVS Value Domain Service instance to remove Value Domain Definition from the system that matches the supplied URI.
 
Sample Call:
Step 1 : Using LexBIGService instance, get the LexEVSValueDomainServices interface org.lexgrid.valuedomain.LexEVSValueDomainServices vds = lbs.getValueDomainService();
Step 2 :Call removeValueDomain   method:
vds.removeValueDomain ( new URI("AUTO:AllDomesticANDGM") );

Information

removeAllValueDomains()

Description:

Removes all value domain definitions from the system.

Input:

none

Output:

none

Exception:

org.LexGrid.LexBIG.Exceptions.LBException,
org.LexGrid.managedobj.RemoveException

Implementation Details:

Implementation:
Step 1: Call this method on the associated LexEVS Value Domain Service instance to remove all the Value Domain Definitions that are loaded in the system.
 
Sample Call:
Step 1 : Using LexBIGService instance, get the LexEVSValueDomainServices interface org.lexgrid.valuedomain.LexEVSValueDomainServices vds = lbs.getValueDomainService();
Step 2 :Call removeAllValueDomains   method:
vds.removeAllValueDomains();

Drop Value Domain tables

Information

dropValueDomainTables()

Description:

Drops value domain tables only if there are no value domain and pick list entries.

Input:

none

Output:

none

Exception:

org.LexGrid.LexBIG.Exceptions.LBException,
org.LexGrid.managedobj.RemoveException

Implementation Details:

Implementation:
Step 1: Call this method on the associated LexEVS Value Domain Service instance to drop both Value Domain and Pick List tables. The tables will be dropped only if there are no entries in both Value Domain and Pick List tables.
 
Sample Call:
Step 1 : Using LexBIGService instance, get the LexEVSValueDomainServices interface org.lexgrid.valuedomain.LexEVSValueDomainServices vds = lbs.getValueDomainService();
Step 2 :Call dropValueDomainTables   method:
vds.dropValueDomainTables();

LexEVS Pick List Service API

...

There are three methods that could be used to load Pick List Definitions :

Information

loadPickList(PickListDefinition pldef, String systemReleaseURI)

Description:

Loads supplied Pick List Definition object

Input:

org.LexGrid.emf.valueDomains.PickListDefinition,
String

Output:

none

Exception:

LBException

Implementation Details:

Implementation:
Step 1: Call this method on the associated LexEVS Pick List Service instance to load Pick List Definition object and the System Release URI this definition belongs to.
Sample Call:
Step 1 : Using LexBIGService instance, get the LexEVSPickListServices interface :
org.lexgrid.valuedomain.LexEVSPickListServices pls = lbs.getPickListService();
Step 2 :Create and populate the PickListDefinition object
PickListDefinition can be created using :
org.LexGrid.emf.valueDomains.PickListDefinition pickList = org.LexGrid.emf.valueDomains.ValuedomainsFactory.eINSTANCE.createPickListDefinition();
And data for pickList object can be populated by using set methods :
pickList.setPickListId( pickListId );
pickList.setRepresentsValueDomain( vdURI );
pickList.setCompleteDomain( true );
pickList.setDefaultEntityCodeNamespace( ecns );
pickList.setDefaultLanguage( "en" );
pickList.setDefaultSortOrder( "asc" );
pickList.setIsActive( true );
pickList.setEntityDescription( ed );
Similarly, PickListEntryNode, Property, Mapping objects can be created and assign to the pickList object.
pickList.getPickListEntryNode.add( pickListEntry );
pickList.setProperties( propertisObject );
pickList.setMappings( mappingsObject );
Step 3 : call the load method by passing the Pick List Definition object and the System Release URI :
pls.loadPickList( pickList,"Release 2009" );

Information

loadPickList(InputStream inputStream, boolean failOnAllErrors)

Description:

Loads Pick List Definitions found in inputStream

Input:

java.io.InputStream
boolean

Output:

none

Exception:

Exception

Implementation Details:

Implementation:
Step 1: Call this method on the associated LexEVS Pick List Service instance to load all Pick List Definitions from the inputstream.
Sample Call:
Step 1 : Using LexBIGService instance, get the LexEVS PickList Services interface org.lexgrid.valuedomain.LexEVSPickListServices pls = lbs.getPickListService();
Step 2 :Call load method by passing the inputSteam and boolean flag whether to stop on load errors. :
pls.loadPickList( inputStream, true );

Information

loadPickList (String xmlFileLocation, boolean failOnAllErrors)

Description:

Loads Pick List Definitions found in input xml file

Input:

java.lang.String
boolean

Output:

none

Exception:

Exception

Implementation Details:

Implementation:
Step 1: Call this method on the associated LexEVS Pick List Service instance to load all Pick List Definitions found in an XML file that is in LexGrid format.
 
Sample Call:
Step 1 : Using LexBIGService instance, get the LexEVSPickListServices interface org.lexgrid.valuedomain.LexEVSPickListServices pls = lbs.getPickListService();
Step 2 :Call load method by passing the inputfile location and boolean flag whether to stop on load errors. :
pls.loadPickList( inputXMLFile, true );

Validate XML resources

Information

validate(URI uri, int valicationLevel) throws LBParameterException

Description:

Perform validation of the candidate resource without loading data.

Input:

java.net.URI
int

Output:

none

Exception:

Org.LexGrid.LexBIG.Exceptions.LBParameterException

Implementation Details:

Implementation:
Step 1: Call this method on the associated LexEVS Pick List Service instance to validate the XML file that is in LexGrid format. This call will not load the data in XML file.
 
Sample Call:
Step 1 : Using LexBIGService instance, get the LexEVSPickListServices interface org.lexgrid.valuedomain.LexEVSPickListServices pls = lbs.getPickListService();
Step 2 :Call validate method for validation by supplying URI of the XML file and validation level:
Supported validationLevels includes :
0 = Verify document is well-formed
1 = Verify document is valid
  pls.validate( uriOfXMLFile, true );

Query Pick List

Information

getPickListDefinitionById(String pickListId)

Description:

Returns pickList definition for supplied pickListId.

Input:

java.lang.String

Output:

org.LexGrid.emf.valueDomains.PickListDefinition

Exception:

org.LexGrid.LexBIG.Exceptions.LBException

Implementation Details:

Implementation:
Step 1: Call this method on the associated LexEVS Pick List Service instance to get Pick List Definition for supplied pickListId.
 
Sample Call:
Step 1 : Using LexBIGService instance, get the LexEVSPickListServices interface org.lexgrid.valuedomain.LexEVSPickListServices pls = lbs.getPickListService();
Step 2 :Call getPickListDefinitionById   method:
PickListDefinition plDef   =   pls.getPickListDefinitionById( "AUTO:DomesticAutoMakers" );

Information

getPickListDefinitionsForDomain(URI valueDomainURI)

Description:

Returns all the pickList definitions that represents supplied valueDomain URI.

Input:

java.net.URI

:

java.net.URI<ac:structured-macro ac:name="unmigrated-wiki-markup" ac:schema-version="1" ac:macro-id="0e1cfad5-6b41-403a-b98e-c7fdd691adf6"><ac:plain-text-body><![CDATA[

Output:

org.LexGrid.emf.valueDomains.PickListDefinition[]

]]></ac:plain-text-body></ac:structured-macro>

Exception:

org.LexGrid.LexBIG.Exceptions.LBException

Implementation Details:

Implementation:
Step 1: Call this method on the associated LexEVS Pick List Service instance to get all the Pick List Definitions that are represented by supplied Value Domain URI.
 
Sample Call:
Step 1 : Using LexBIGService instance, get the LexEVSPickListServices interface org.lexgrid.valuedomain.LexEVSPickListServices pls = lbs.getPickListService();
Step 2 :Call getPickListDefinitionsForDomain method:
<ac:structured-macro ac:name="unmigrated-wiki-markup" ac:schema-version="1" ac:macro-id="c7cd94bc-a384-4c05-87b9-fcbc7edb107d"><ac:plain-text-body><![CDATA[ PickListDefinition[] plDefs   =   pls.getPickListDefinitionsForDomain( valueDomainURI );

]]></ac:plain-text-body></ac:structured-macro>

Information

getPickListValueDomain(String pickListId)

Description:

Returns an URI of the represented valueDomain of the pickList.

Input:

java.lang.String

Output:

java.net.URI

Exception:

org.LexGrid.LexBIG.Exceptions.LBException

Implementation Details:

Implementation:
Step 1: Call this method on the associated LexEVS Pick List Service instance to get an Value Domain URI represented by supplied pickListId.
Sample Call:
Step 1 : Using LexBIGService instance, get the LexEVSPickListServices interface org.lexgrid.valuedomain.LexEVSPickListServices pls = lbs.getPickListService();
Step 2 :Call getPickListValueDomain method:
URI vdURI   = pls.getPickListValueDomain ( "AUTO:DomesticAutoMakers" );

Information

listPickListIds()

Description:

Returns a list of pickListIds that are available in the system.

Input:

none

Output:

java.util.List<java.lang.String>

Exception:

org.LexGrid.LexBIG.Exceptions.LBException

Implementation Details:

Implementation:
Step 1: Call this method on the associated LexEVS Pick List Service instance to get all the PickListIds that are loaded in the system.
 
Sample Call:
Step 1 : Using LexBIGService instance, get the LexEVSPickListServices interface org.lexgrid.valuedomain.LexEVSPickListServices pls = lbs.getPickListService();
Step 2 :Call listPickListIds method:
List<String> plList   =   pls.listPickListIds();

Information

resolvePickList(String pickListId, boolean sortByText)

Description:

Resolves pickList definition for supplied pickListId.

Input:

java.langString,
boolean

Output:

org.lexgrid.valuedomain.dto.ResolvedPickListEntryList

Exception:

org.LexGrid.LexBIG.Exceptions.LBException

Implementation Details:

Implementation:
Step 1: Call this method on the associated LexEVS Pick List Service instance to get the   resolved Pick List Entries for the supplied pickListId. Optionally, if sortByTests is true, sort the pickText in the list.
 
Sample Call:
Step 1 : Using LexBIGService instance, get the LexEVSPickListServices interface org.lexgrid.valuedomain.LexEVSPickListServices pls = lbs.getPickListService();
Step 2 :Call resolvePickList   method:
ResolvedPickListEntryList pleList   =   pls.resolvePickList ( "AUTO:DomesticAutoMakers", true);
<ac:structured-macro ac:name="unmigrated-wiki-markup" ac:schema-version="1" ac:macro-id="add98a81-7781-4521-b8f7-5e38e13ca5d0"><ac:plain-text-body><![CDATA[, true );

Information

resolvePickListForTerm(String pickListId, String term, String matchAlgorithm, String language, String[] context, boolean sortByText)

]]></ac:plain-text-body></ac:structured-macro>

Description:

Resolves pickList definition by applying  supplied arguments.

Input:

java.lang.String,
java.lang.String,
java.lang.String,
java.lang.String,
<ac:structured-macro ac:name="unmigrated-wiki-markup" ac:schema-version="1" ac:macro-id="1c2c453e-123a-46ed-af25-20c993c87a76"><ac:plain-text-body><![CDATA[java.lang.String[],
]]></ac:plain-text-body></ac:structured-macro>
boolean

Output:

org.lexgrid.valuedomain.dto.ResolvedPickListEntryList

Exception:

org.LexGrid.LexBIG.Exceptions.LBException

Implementation Details:

Implementation:
Step 1: Call this method on the associated LexEVS Pick List Service instance to get list of Pick List Entries that  matches the term supplied and meets other supplied restrictions.
 
Sample Call:
Step 1 : Using LexBIGService instance, get the LexEVSPickListServices interface org.lexgrid.valuedomain.LexEVSPickListServices pls = lbs.getPickListService();
Step 2 :Call resolvePickListForTerm   method:
ResolvedPickListEntryList pleList   =   pls.resolvePickListForTerm (" AUTO:DomesticAutoMakers","Jaguar", MatchAlgorithms.exactMatch.name(), "en", null, true );

Remove Pick List Definition

Information

removePickList(String pickListId)

Description:

Removes supplied Pick List Definition from the system.

Input:

java.lang.String

Output:

none

Exception:

org.LexGrid.LexBIG.Exceptions.LBException,
org.LexGrid.managedobj.RemoveException

Implementation Details:

Implementation:
Step 1: Call this method on the associated LexEVS Pick List Service instance to remove Pick List Definition from the system that matches the supplied pickListId.
 
Sample Call:
Step 1 : Using LexBIGService instance, get the LexEVSPickListServices interface org.lexgrid.valuedomain.LexEVSPickListServices pls = lbs.getPickListService();
Step 2 :Call removePickList   method:
vds.removePickList ( "AUTO:AllDomesticANDGM" );

Resolved Value Domain Objects

...

Parameter

Function

-in

Input <uri> URI or path specifying location of the source file.

-v

Validate <int> Perform validation of the candidate resource without loading data.
Supported levels of validation includes :
0 = Verify document is well-formed
1 = Verify document is valid

Example:

No Format

sh LoadValueDomain.sh \-in "file:///path/to/file.xml"

...

Parameter

Function

-in

Input <uri> URI or path specifying location of the source file.

-v

Validate <int> Perform validation of the candidate resource without loading data.
Supported levels of validation includes :
0 = Verify document is well-formed
1 = Verify document is valid

Example:

No Format

sh LoadPickList.sh \-in "file:///path/to/file.xml"

...

Below is a sample XML file containing Value Domain Definitions in LexGrid format that can be loaded using LexEVS Value Domain Service.

Code Block
xml
xml

<?xml version="1.0" encoding="UTF-8"?>
<systemRelease xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://LexGrid.org/schema/2009/01/LexGrid/versions http://LexGrid.org/schema/2009/01/LexGrid/versions.xsd"
    xmlns="http://LexGrid.org/schema/2009/01/LexGrid/versions" xmlns:lgVer="http://LexGrid.org/schema/2009/01/LexGrid/versions"
    xmlns:lgCommon="http://LexGrid.org/schema/2009/01/LexGrid/commonTypes" xmlns:data="data"
    xmlns:lgVD="http://LexGrid.org/schema/2009/01/LexGrid/valueDomains" xmlns:lgNaming="http://LexGrid.org/schema/2009/01/LexGrid/naming"
    releaseURI="http://testRelease/04" releaseDate="2008-11-07T14:55:51.615-06:00">
    <lgCommon:entityDescription>Sample value domains</lgCommon:entityDescription>
    <lgVer:valueDomains>
        <lgVD:mappings>
            <lgNaming:supportedAssociation localId="hasSubtype" uri="urn:oid:1.3.6.1.4.1.2114.108.1.8.1">hasSubtype</lgNaming:supportedAssociation>
            <lgNaming:supportedCodingScheme localId="Automobiles" uri="urn:oid:11.11.0.1">Automobiles</lgNaming:supportedCodingScheme>
            <lgNaming:supportedDataType localId="testhtml">test/html</lgNaming:supportedDataType>
            <lgNaming:supportedDataType localId="textplain">text/plain</lgNaming:supportedDataType>
            <lgNaming:supportedHierarchy localId="is_a" associationNames="hasSubtype" isForwardNavigable="true" rootCode="@">hasSubtype</lgNaming:supportedHierarchy>
            <lgNaming:supportedLanguage localId="en" uri="www.en.org/orsomething">en</lgNaming:supportedLanguage>
            <lgNaming:supportedNamespace localId="Automobiles" uri="urn:oid:11.11.0.1" equivalentCodingScheme="Automobiles">Automobiles</lgNaming:supportedNamespace>
            <lgNaming:supportedProperty localId="textualPresentation">textualPresentation</lgNaming:supportedProperty>
            <lgNaming:supportedSource localId="lexgrid.org">lexgrid.org</lgNaming:supportedSource>
            <lgNaming:supportedSource localId="_111101">11.11.0.1</lgNaming:supportedSource>
        </lgVD:mappings>
       <lgVD:valueDomainDefinition valueDomainURI="SRITEST:AUTO:DomesticAutoMakers" valueDomainName="Domestic Auto Makers" defaultCodingScheme="Automobiles" effectiveDate="2009-01-01T11:00:00Z" isActive="true" status="ACTIVE">
            <lgVD:properties>
                <lgCommon:property propertyName="textualPresentation">
                    <lgCommon:value> Domestic Auto Makers</lgCommon:value>
                </lgCommon:property>
            </lgVD:properties>
            <lgVD:definitionEntry ruleOrder="1" operator="OR">
                <lgVD:entityReference entityCode="005" referenceAssociation="hasSubtype" transitiveClosure="true"  targetToSource="false" leafOnly="false"/>
            </lgVD:definitionEntry>
        </lgVD:valueDomainDefinition>
       <lgVD:valueDomainDefinition valueDomainURI="SRITEST:AUTO:AllDomesticButGM" valueDomainName="All Domestic Autos But GM" defaultCodingScheme="Automobiles" effectiveDate="2009-01-01T11:00:00Z" isActive="true" status="ACTIVE">
            <lgVD:properties>
                <lgCommon:property propertyName="textualPresentation">
                    <lgCommon:value> Domestic Auto Makers</lgCommon:value>
                </lgCommon:property>
            </lgVD:properties>
            <lgVD:definitionEntry ruleOrder="1" operator="OR">
                <lgVD:entityReference entityCode="005" referenceAssociation="hasSubtype" transitiveClosure="true"  targetToSource="false" leafOnly="false"/>
            </lgVD:definitionEntry>
            <lgVD:definitionEntry ruleOrder="2" operator="SUBTRACT">
                <lgVD:entityReference entityCode="GM" referenceAssociation="hasSubtype" transitiveClosure="true"  targetToSource="false" leafOnly="false"/>
            </lgVD:definitionEntry>
        </lgVD:valueDomainDefinition>
        <lgVD:valueDomainDefinition valueDomainURI="SRITEST:AUTO:AllDomesticANDGM" valueDomainName="All Domestic Autos AND GM" defaultCodingScheme="Automobiles" effectiveDate="2009-01-01T11:00:00Z" isActive="true" status="ACTIVE">
            <lgVD:properties>
                <lgCommon:property propertyName="textualPresentation">
                    <lgCommon:value> Domestic Auto Makers AND GM</lgCommon:value>
                </lgCommon:property>
            </lgVD:properties>
            <lgVD:definitionEntry ruleOrder="1" operator="OR">
                <lgVD:entityReference entityCode="005" referenceAssociation="hasSubtype" transitiveClosure="true"  targetToSource="false" leafOnly="false"/>
            </lgVD:definitionEntry>
            <lgVD:definitionEntry ruleOrder="2" operator="AND">
                <lgVD:entityReference entityCode="GM" referenceAssociation="hasSubtype" transitiveClosure="true"  targetToSource="false" leafOnly="false"/>
            </lgVD:definitionEntry>
        </lgVD:valueDomainDefinition>
         <lgVD:valueDomainDefinition valueDomainURI="SRITEST:AUTO:DomasticLeafOnly" valueDomainName="Domestic Leaf Only" defaultCodingScheme="Automobiles" effectiveDate="2009-01-01T11:00:00Z" isActive="true" status="ACTIVE">
            <lgVD:properties>
                <lgCommon:property propertyName="textualPresentation">
                    <lgCommon:value>Domestic Leaf Only</lgCommon:value>
                </lgCommon:property>
            </lgVD:properties>
            <lgVD:definitionEntry ruleOrder="1" operator="OR">
                <lgVD:entityReference entityCode="005" referenceAssociation="hasSubtype" transitiveClosure="true"  targetToSource="false" leafOnly="true"/>
            </lgVD:definitionEntry>
        </lgVD:valueDomainDefinition>
        </lgVer:valueDomains>
</systemRelease>

...

Below is a sample XML file containing Pick List Definitions in LexGrid format that can be loaded using LexEVS Pick List Service.

Code Block
xml
xml

<?xml version="1.0" encoding="UTF-8"?>
<systemRelease xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://LexGrid.org/schema/2009/01/LexGrid/versions http://LexGrid.org/schema/2009/01/LexGrid/versions.xsd"
    xmlns="http://LexGrid.org/schema/2009/01/LexGrid/versions" xmlns:lgVer="http://LexGrid.org/schema/2009/01/LexGrid/versions"
    xmlns:lgCommon="http://LexGrid.org/schema/2009/01/LexGrid/commonTypes" xmlns:data="data"
    xmlns:lgVD="http://LexGrid.org/schema/2009/01/LexGrid/valueDomains" xmlns:lgNaming="http://LexGrid.org/schema/2009/01/LexGrid/naming"
    releaseURI="http://testRelease/04" releaseDate="2008-11-07T14:55:51.615-06:00">
    <lgCommon:entityDescription>Sample value domains</lgCommon:entityDescription>
    <pickLists>
        <lgVD:mappings>
            <lgNaming:supportedCodingScheme localId="Automobiles" uri="urn:oid:11.11.0.1">Automobiles</lgNaming:supportedCodingScheme>
            <lgNaming:supportedLanguage localId="en" uri="www.en.org/orsomething">en</lgNaming:supportedLanguage>
            <lgNaming:supportedNamespace localId="Automobiles" uri="urn:oid:11.11.0.1" equivalentCodingScheme="Automobiles">Automobiles</lgNaming:supportedNamespace>
            <lgNaming:supportedProperty localId="textualPresentation">textualPresentation</lgNaming:supportedProperty>
            <lgNaming:supportedSource localId="lexgrid.org">lexgrid.org</lgNaming:supportedSource>
            <lgNaming:supportedSource localId="_111101">11.11.0.1</lgNaming:supportedSource>
        </lgVD:mappings>
        <lgVD:pickListDefinition pickListId="SRITEST:AUTO:DomesticAutoMakers" representsValueDomain="SRITEST:AUTO:DomesticAutoMakers" isActive="true" defaultEntityCodeNamespace="Automobiles" defaultLanguage="en" completeDomain="false">
            <lgCommon:owner>Owner for Domestic Auto Makers</lgCommon:owner>
            <lgCommon:entityDescription>DomesticAutoMakers</lgCommon:entityDescription>
            <lgVD:mappings>
                <lgNaming:supportedCodingScheme localId="Automobiles" uri="urn:oid:11.11.0.1">Automobiles</lgNaming:supportedCodingScheme>
                <lgNaming:supportedDataType localId="texthtml">text/html</lgNaming:supportedDataType>
                <lgNaming:supportedDataType localId="textplain">text/plain</lgNaming:supportedDataType>
                <lgNaming:supportedLanguage localId="en" uri="www.en.org/orsomething">en</lgNaming:supportedLanguage>
                <lgNaming:supportedNamespace localId="Automobiles" uri="urn:oid:11.11.0.1" equivalentCodingScheme="Automobiles">Automobiles</lgNaming:supportedNamespace>
                <lgNaming:supportedProperty localId="textualPresentation">textualPresentation</lgNaming:supportedProperty>
                <lgNaming:supportedSource  assemblyRule="rule1" uri="http://informatics.mayo.edu" localId="lexgrid.org">lexgrid.org</lgNaming:supportedSource>
                <lgNaming:supportedSource localId="_111101">11.11.0.1</lgNaming:supportedSource>
            </lgVD:mappings>
           <lgVD:pickListEntryNode pickListEntryId="PLGMp1" isActive="true">
                <lgCommon:owner>Owner for PLGMp1</lgCommon:owner>
                <lgCommon:entryState containingRevision="R001" relativeOrder="1" changeType="NEW" prevRevision="R00A"/>
                <lgVD:inclusionEntry entityCode="GM" entityCodeNamespace="Automobiles" propertyId="p1">
                    <lgVD:pickText>General Motors</lgVD:pickText>
                </lgVD:inclusionEntry>
                <lgVD:properties>
                    <lgCommon:property propertyName="textualPresentation" isActive="true" language="en" propertyId="p1" propertyType="presentation" status="active" effectiveDate="2001-12-17T09:30:47Z" expirationDate="2011-12-17T09:30:47Z">
                        <lgCommon:owner role="role" subRef="subref">General Motors</lgCommon:owner>
                        <lgCommon:entryState containingRevision="R001" relativeOrder="1" changeType="NEW" prevRevision="R00A"/>
                        <lgCommon:source subRef="subref1" role="role1">General Motors</lgCommon:source>
                        <lgCommon:value dataType="textplain">Property for General Motors</lgCommon:value>
                    </lgCommon:property>
                </lgVD:properties>
            </lgVD:pickListEntryNode>
            <lgVD:pickListEntryNode pickListEntryId="PLGMp2" isActive="true">
                <lgCommon:owner>Owner for PLGMp2</lgCommon:owner>
                <lgCommon:entryState containingRevision="R001" relativeOrder="1" changeType="NEW" prevRevision="R00A"/>
                <lgVD:inclusionEntry entityCode="GM" entityCodeNamespace="Automobiles" propertyId="p2">
                    <lgVD:pickText>GM</lgVD:pickText>
                </lgVD:inclusionEntry>
            </lgVD:pickListEntryNode>
            <lgVD:pickListEntryNode pickListEntryId="PLJaguarp1" isActive="true">
                <lgCommon:owner>Owner for PLJaguarp1</lgCommon:owner>
                <lgCommon:entryState containingRevision="R001" relativeOrder="1" changeType="NEW" prevRevision="R00A"/>
                <lgVD:inclusionEntry entityCode="Jaguar" entityCodeNamespace="Automobiles" propertyId="p1">
                    <lgVD:pickText>Jaguar</lgVD:pickText>
                </lgVD:inclusionEntry>
            </lgVD:pickListEntryNode>
            <lgVD:pickListEntryNode pickListEntryId="PLChevroletp1" isActive="true">
                <lgCommon:owner>Owner for PLChevroletp1</lgCommon:owner>
                <lgCommon:entryState containingRevision="R001" relativeOrder="1" changeType="NEW" prevRevision="R00A"/>
                <lgVD:inclusionEntry entityCode="Chevy" entityCodeNamespace="Automobiles" propertyId="p1">
                    <lgVD:pickText>Chevrolet</lgVD:pickText>
                </lgVD:inclusionEntry>
            </lgVD:pickListEntryNode>
        </lgVD:pickListDefinition>
       <lgVD:pickListDefinition pickListId="SRITEST:AUTO:DomasticLeafOnly" representsValueDomain="SRITEST:AUTO:DomasticLeafOnly" completeDomain="true" defaultEntityCodeNamespace="Automobiles" defaultLanguage="en" isActive="true">
            <lgCommon:entityDescription>Leaf Only Nodes of Domastic AutoMakers</lgCommon:entityDescription>
        </lgVD:pickListDefinition>
    </pickLists>
</systemRelease>

Database structure

Value Domain Tables

Image Modified

Table Name

Description

valueDomain

Will contain Value Domain Definition information

vdEntry

Contains Value Domain Entries information and its rules

entryState

Contains entry state details of every entry

mappings

Contains supported mapping information for a Value Domain Definition

property

Contains Property informations for Value Domain Definition

...

  • This Loader Framework requires LexEVS release 5.0 or above.
  • Development system are required to install the Sun Java Development Kit (SDK) or Java Runtime Environment (JRE) version 1.5.0_11 or above.
  • Maven 2.1 or greater.
  • For software and hardware dependencies for the system hosting the LexEVS runtime, refer to the LexEVS 5.0 Documentation.
Issues
  • None
Third Party Tools

...

An example may help in understanding the Framework. Our discussion will refer to the following figure. Lets say we are writing a loader to load the ICD-9-CM codes and their description which are contained in a text file. We know we'll need a data structure to hold the data after we've read it so we have a class:

No Format

ICD9SourceObject {
String id;
String descr;
String getId() { return id; }
}

...

Use these tags, 'beans:bean', to define the beans to be managed by the Spring container by specifying the packaged qualified class name. You can also specify inititialization values and set bean properties within these tags.

Code Block
xml
xml

<beans:bean id="umlsCuiPropertyProcessor" parent="umlsDefaultPropertyProcessor" class="org.lexgrid.loader.processor.EntityPropertyProcessor">
  <beans:property name="propertyResolver" ref="umlsCuiPropertyResolver" />
</beans:bean>

...

The 'job' tag is the main unit of work. The job is comprised of one or more steps that define the work to be done. Other advanced and interesting things can be done within the Job such as using 'split' and 'flow' tags to indicate work that can be done in parellel steps to improve performance.

Code Block
xml
xml

<job id="umlsJob" restartable="true">
 <step id="populateStagingTable" next="loadHardcodedValues" parent="stagingTablePopulatorStepFactory"/>
...

...

Below is an image of the loader-framework-core project in Eclipse which shows the key directories of the Loader Framework. The following is a summary of the contents of those directories.

Image Modified

Directory

Summary

connection

Connect to LexBIG and do LexBIG tasks such as register and activate.

constants

Assorted constants.

dao

Access to the LexBIG database.

data

Directly related to data going into the LexBIG database tables.

database

Database specific tasks not related to data, such as finding out the database type (MySQL, Oracle)

fieldsetter

Spring related classes for helping to write to the database.

lexbigadmin

Common tasks you want LexBIG to do for you such as indexing.

listener

You can attach listeners to a load so that the code will execute and certain points in the load such as a cleanup listener that runs when the load is finished or a setup listener etc...

logging

Gives you access to the LexBIG logger.

processor

Important directory. Contains classes that you can pass your domain specific object to and will return a LexBIG object.

properties

Code used internally by the Loader Framework.

reader

Readers and reader-related tools for loader developers.

rowmapper

Classes for reading from a database. Currently experimental code.

setup

Classes such as JobRepositoryManager that help Spring do its work. As Spring hums along it keeps tables of its internal workings. Loader developers should not need to dive into this directory.

staging

If your loader needs to load data to the database temporarlily you can find helper classes in this directory.

wrappers

Helper classes and data strucutres such as a Code/CodingScheme class.

writer

Miscellaneous classes that write to the database. These are not the same ones you'd use in your loader, i.e the LexBIG model objects that use Hibernate. Those classes are contained in the PersistenceLayer project (next figure). It is by using those classes in the PersistenceLayer that you let the Loader Framework do some of the heavy lifting for you.

Image Modified

Algorithms

None

...

Automated tests are run via Maven. As mentioned earlier the projects containing the Loader Framework code are configured to work with Maven. The following figure shows the PersistenceLayer project and its standard Maven layout. Notice the structure of the test code mirrors the structure of the application code. To run the automated test in our Eclipse environment we select the project, right click, select 'Run As' and select 'Maven test'. Maven will do the rest.

Image Modified

Test Guidelines

...

The LexEVS 5.1 project plan is located on the Gforge archive in MS Project format and PDF format

The LexEVS 5.1 BDA Project plan is located at LexEVS 5.1 BDA Project Plan (login required).

...

Documentation for LexEVS 5.1 will be provided by the Vocabulary Knowledge Center: LexEVS DocumentationGuides and Training.

Download center changes

Downloads for LexEVS 5.1 will be located on the LexEVS wiki.

...