Public

getBegin

getCoveredText

getEnd

getter for textReference - gets Reference to the text span that contains the
full form of the abbrev

getTextReference

getter for definedHere - gets The definedHere is true if the
abbreviation/acronym is defined for the

getDefinedHere

readObject

setBegin

setEnd

StringBuilder

Reading from database using SQL prepared statement

The base class for all formats. This is an abstract base class which specifies
the protocol for clas

java.text.Format

LinkedHashMap is an implementation of Map that guarantees iteration order. All
optional operations a

java.util.LinkedHashMap

javax.naming.Reference

Defines a general exception a servlet can throw when it encounters difficulty.

javax.servlet.ServletException

Central representation of an Ant project. This class defines an Ant project with
all of its targets,

org.apache.tools.ant.Project

org.hibernate.mapping.Join

notifyDataSetChanged

getApplicationContext

Return the contained value, if present, otherwise throw an exception to be
created by the provided s

orElseThrow

/**
	 * tests whether annotation should be ignored as this label is on a not
	 * introduced abbreviation
	 * 
	 * @param aJCas
	 * @param start
	 * @param end
	 * @param abbreviationIndex 
	 * @param coveredText
	 * @return
	 */

// check whether this abbreviation was introduced (if so, it has a

//			Annotation windowAnno = new Annotation(aJCas, start, end);

//			ArrayList<Abbreviation> abbreviations = (ArrayList<Abbreviation>) UIMAUtils.getAnnotations(aJCas,

//					windowAnno, (new Abbreviation(aJCas, 0, 0)).getClass());

"ignoreLabel() - found JACRO-recognized abbreviations under this string: "

" because it is a not introduced abbreviation!"

/**
	 * checks whether a chunk (= dictionary match) is an acronym. If yes, checks
	 * whether respective full form (obtained via abbr textReference) is
	 * ConceptMention and has same specificType as chunk If these conditions are not
	 * fulfilled, no entity annotation will be made.
	 * 
	 * @param abbreviationIndex
	 * @param conceptMentionIndex
	 */

// anno = new Annotation(aJCas, start, end);

"{} chunk \"{}\" is not an abbreviation\n"

// checks whether respective full form is ConceptMention

" chunk \"{}\" is an abbreviation but respective full \"{}\" form is no ConceptMention\n"

// checks whether full form annotation matches the type to be annotated

" chunk \"{}\" is an abbreviation and respective full form \"{}\" is ConceptMention with same type as OutputType\n"

" chunk \"{}\" is an abbreviation but respective full form \"{}\" is ConceptMention without the correct OutputType (is: {}; OutputType: {})\n"

"annotateAcronymsWithFullFormEntity() - checking abbreviation: "

// AnnotationRetrieval.getMatchingAnnotation(aJCas, fullFormAnnotation,

// The following code was once introduced for gene tagging. There,

// the acronym fullforms sometimes miss minor parts of an annotated

// gene, leading to non-annotated acronyms that would have been

// However, for general-purpose concept recognition this approach

// can be quite harmful. Example: "Anaphase-promoting complex (APC)"

// where only "anaphase" is recognized as concept. Now, "APC" would

// be annotated as an acronym for "anaphase". Here, a better

// recognition of the abbreviation span is required.

// List<ConceptMention> conceptsInFullform =

// JCoReAnnotationTools.getIncludedAnnotations(aJCas,

// emFullform = conceptsInFullform.get(0);

// LOGGER.debug("Found a single ConceptMention included in the full

// form: {}", emFullform.getCoveredText());

// } else if (conceptsInFullform.size() > 1) {

// // If there are multiple ConceptMentions found in the full form,

// take that largest right-most candidate.

// for (ConceptMention em : conceptsInFullform) {

// int emSize = em.getEnd() - em.getBegin();

// LOGGER.debug("Found multiple ConceptMentions included in the full

// LOGGER.trace("All found ConceptMentions:");

// for (ConceptMention cm : conceptsInFullform) {

// LOGGER.trace("Text: {}; offsets: {}-{}",

// new Object[] { cm.getCoveredText(), cm.getBegin(), cm.getEnd()

// LOGGER.debug("No ConceptMention in the span of acronym fullform

// AnnotationRetrieval.getMatchingAnnotation(aJCas, abbrev,

// This is really slow, really a pain with full texts.

// It was originally introduced to push recall for gene recognition.

// So now we will lose (a bit) of recognition performance there.

// JCoReAnnotationTools.getPartiallyOverlappingAnnotation(aJCas,

// if type of the entity is equal to the output type for this

"annotateAcronymsWithFullFormEntity() - fullform of abbreviation has no ConceptMention\n"

"annotateAcronymsWithFullFormEntity() - fullform of abbreviation ("

"process() - could not generate output type: "

"annotateAcronymsWithFullFormEntity() - emAcronym != null"

"annotateAcronymsWithFullFormEntity() - emAcroType="

/**
	 * Takes all info about meta data and generates the corresponding unit
	 * sequence represented by a Sentence object. Abbreviation is expanded when
	 * specified in descriptor. Only abbreviations which span over single tokens
	 * can be interpreted here. Other case (which is very rare and thus probably
	 * not relevant) is ignored!
	 * 
	 * @param tokenList
	 *            a list of Token objects of the current sentence
	 * @param JCas
	 *            the CAS we are working on
	 * @param metaList
	 *            a Arraylist of meta-info HashMaps which specify the meta
	 *            information of the respective token
	 * @param abbreviationIndex
	 * @param tokenIndex 
	 * @return an array of two sequences of units containing all available meta
	 *         data for the corresponding tokens. In the first sequence,
	 *         abbreviations are expanded to their fullform. In the second
	 *         sequence, the tokens are of their original form.
	 */

// for abbreviation expansion, if there is an abbreviation on the

// when abbreviation is defined here: ignore this token

// abbreviation only used here: replace token representation

// now make JNET Unit object for this token and add to Sentence

// abbrev was expanded, so we probably need to make more

//					ArrayList<Token> abbrevTokens = (ArrayList<Token>) UIMAUtils.getAnnotations(JCas,

//							abbreviation.getTextReference(), (new Token(JCas, 0, 0)).getClass());

// white space tokenization when no tokens found on

// typically is because full form didn't start/end on

// clean-up: remove tokens with consecutive brackets

// check whether full2acro mode is enabled

// The abbreviation has no exact entity match

// The longform HAS an exact entity match

// if we found an entity mention on the full form (exact

// The abbreviation HAS an exact entity match

How to use getTextReferencemethodin de.julielab.jcore.types.Abbreviation

Best Java code snippets using de.julielab.jcore.types.Abbreviation.getTextReference (Showing top 5 results out of 315)

How to use
getTextReference
method
in
de.julielab.jcore.types.Abbreviation