TextBoundMention

Instance Constructors

new TextBoundMention(label: String, tokenInterval: Interval, sentence: Int, document: Document, keep: Boolean, foundBy: String)
new TextBoundMention(labels: Seq[String], tokenInterval: Interval, sentence: Int, document: Document, keep: Boolean, foundBy: String, attachments: Set[Attachment] = Set.empty)

Value Members

final def !=(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def ##(): Int

Definition Classes
AnyRef → Any
def <(that: Mention): Boolean

Definition Classes
Ordered
def <=(that: Mention): Boolean

Definition Classes
Ordered
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def >(that: Mention): Boolean

Definition Classes
Ordered
def >=(that: Mention): Boolean

Definition Classes
Ordered
val arguments: Map[String, Seq[Mention]]

A map from argument name to a sequence of mentions.
A map from argument name to a sequence of mentions.
The value of the map is a sequence because there are events that can have several arguments with the same name. For example, in the biodomain, Binding may have several themes.

Definition Classes
TextBoundMention → Mention
final def asInstanceOf[T0]: T0

Definition Classes
Any
val attachments: Set[Attachment]

Attachments that can modify a Mention.
Attachments that can modify a Mention.

Definition Classes
TextBoundMention → Mention
lazy val cachedHashCode: Int

Attributes
protected
Definition Classes
Mention
def calculateHashCode: Int

Attributes
protected
Definition Classes
Mention
def canEqual(a: Any): Boolean

Definition Classes
Mention → Equals
def chunks: Option[Seq[String]]

returns all chunks in mention
returns all chunks in mention

Definition Classes
Mention
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
def compare(that: Mention): Int

Definition Classes
Mention → Ordered
def compareTo(that: Mention): Int

Definition Classes
Ordered → Comparable
def copy(labels: Seq[String] = this.labels, tokenInterval: Interval = this.tokenInterval, sentence: Int = this.sentence, document: Document = this.document, keep: Boolean = this.keep, foundBy: String = this.foundBy, attachments: Set[Attachment] = this.attachments): TextBoundMention
val document: Document

The document where this mention occurs.
The document where this mention occurs.

Definition Classes
TextBoundMention → Mention
def end: Int

one after the last token in the mention
one after the last token in the mention

Definition Classes
Mention
def endOffset: Int

character offset of the mention end
character offset of the mention end

Definition Classes
Mention
def entities: Option[Seq[String]]

returns all entities in mention
returns all entities in mention

Definition Classes
Mention
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(that: Any): Boolean

Definition Classes
Mention → Equals → AnyRef → Any
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
val foundBy: String

name of matching rule
name of matching rule

Definition Classes
TextBoundMention → Mention
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def getPath(argRole: String, mention: Mention): SynPath

Definition Classes
Mention
def hashCode(): Int

Definition Classes
Mention → AnyRef → Any
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
def isValid: Boolean

returns true if this is a valid mention
returns true if this is a valid mention

Definition Classes
Mention
val keep: Boolean

Should we report this mention at the end?
Should we report this mention at the end?

Definition Classes
TextBoundMention → Mention
def label: String

default label
default label

Definition Classes
Mention
val labels: Seq[String]

A sequence of labels for this mention.
A sequence of labels for this mention. The first label in the sequence is considered the default.

Definition Classes
TextBoundMention → Mention
def lemmas: Option[Seq[String]]

returns all lemmas in mention
returns all lemmas in mention

Definition Classes
Mention
def matches(matcher: StringMatcher): Boolean

returns true if the StringMatcher matches any of the mention labels
returns true if the StringMatcher matches any of the mention labels

Definition Classes
Mention
def matches(regex: Regex): Boolean

returns true if the regex matches any of the mention labels
returns true if the regex matches any of the mention labels

Definition Classes
Mention
def matches(label: String): Boolean

returns true if the string matches any of the mention labels
returns true if the string matches any of the mention labels

Definition Classes
Mention
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def newWithAttachment(mod: Attachment): TextBoundMention
def newWithoutAttachment(mod: Attachment): TextBoundMention
def norms: Option[Seq[String]]

returns the norm value of this mention, if available
returns the norm value of this mention, if available

Definition Classes
Mention
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
val paths: Map[String, Map[Mention, SynPath]]

Definition Classes
TextBoundMention → Mention
def precedes(that: Mention): Boolean

Definition Classes
Mention
def raw: Seq[String]

returns all raw (original, no processing applied) tokens in mention
returns all raw (original, no processing applied) tokens in mention

Definition Classes
Mention
def semHead: Option[Int]

returns the syntactic head of mention
returns the syntactic head of mention

Definition Classes
Mention
def semHeadLemma: Option[String]

returns head lemma
returns head lemma

Definition Classes
Mention
def semHeadTag: Option[String]

returns head pos tag
returns head pos tag

Definition Classes
Mention
def semHeadWord: Option[String]

returns head token
returns head token

Definition Classes
Mention
def semHeads: Seq[Int]

returns all semantic heads
returns all semantic heads

Definition Classes
Mention
val sentence: Int

The index of the sentence where this mention occurs.
The index of the sentence where this mention occurs.

Definition Classes
TextBoundMention → Mention
def sentenceObj: Sentence

Definition Classes
Mention
def start: Int

index of the first token in the mention
index of the first token in the mention

Definition Classes
Mention
def startOffset: Int

character offset of the mention beginning
character offset of the mention beginning

Definition Classes
Mention
def synHead: Option[Int]

returns the syntactic head of mention
returns the syntactic head of mention

Definition Classes
Mention
def synHeadLemma: Option[String]

returns head lemma
returns head lemma

Definition Classes
Mention
def synHeadTag: Option[String]

returns head pos tag
returns head pos tag

Definition Classes
Mention
def synHeadWord: Option[String]

returns head token
returns head token

Definition Classes
Mention
def synHeads: Seq[Int]

returns all syntactic heads
returns all syntactic heads

Definition Classes
Mention
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def tags: Option[Seq[String]]

returns all tags in mention
returns all tags in mention

Definition Classes
Mention
def text: String

returns a string that contains the mention
returns a string that contains the mention

Definition Classes
Mention
def toString(): String

Definition Classes
AnyRef → Any
val tokenInterval: Interval

The interval of token indicess that form this mention.
The interval of token indicess that form this mention.

Definition Classes
TextBoundMention → Mention
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
def withAttachment(mod: Attachment): Mention

Definition Classes
Mention
def withoutAttachment(mod: Attachment): Mention

Definition Classes
Mention
def words: Seq[String]

returns all tokens in mention
returns all tokens in mention

Definition Classes
Mention

Related Doc: package odin

class TextBoundMention extends Mention

Instance Constructors

new TextBoundMention(label: String, tokenInterval: Interval, sentence: Int, document: Document, keep: Boolean, foundBy: String)

new TextBoundMention(labels: Seq[String], tokenInterval: Interval, sentence: Int, document: Document, keep: Boolean, foundBy: String, attachments: Set[Attachment] = Set.empty)

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

def <(that: Mention): Boolean

def <=(that: Mention): Boolean

final def ==(arg0: Any): Boolean

def >(that: Mention): Boolean

def >=(that: Mention): Boolean

val arguments: Map[String, Seq[Mention]]

final def asInstanceOf[T0]: T0

val attachments: Set[Attachment]

lazy val cachedHashCode: Int

def calculateHashCode: Int

def canEqual(a: Any): Boolean

def chunks: Option[Seq[String]]

def clone(): AnyRef

def compare(that: Mention): Int

def compareTo(that: Mention): Int

def copy(labels: Seq[String] = this.labels, tokenInterval: Interval = this.tokenInterval, sentence: Int = this.sentence, document: Document = this.document, keep: Boolean = this.keep, foundBy: String = this.foundBy, attachments: Set[Attachment] = this.attachments): TextBoundMention

val document: Document

def end: Int

def endOffset: Int

def entities: Option[Seq[String]]

final def eq(arg0: AnyRef): Boolean

def equals(that: Any): Boolean

def finalize(): Unit

val foundBy: String

final def getClass(): Class[_]

def getPath(argRole: String, mention: Mention): SynPath

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

def isValid: Boolean

val keep: Boolean

def label: String

val labels: Seq[String]

def lemmas: Option[Seq[String]]

def matches(matcher: StringMatcher): Boolean

def matches(regex: Regex): Boolean

def matches(label: String): Boolean

final def ne(arg0: AnyRef): Boolean

def newWithAttachment(mod: Attachment): TextBoundMention

def newWithoutAttachment(mod: Attachment): TextBoundMention

def norms: Option[Seq[String]]

final def notify(): Unit

final def notifyAll(): Unit

val paths: Map[String, Map[Mention, SynPath]]

def precedes(that: Mention): Boolean

def raw: Seq[String]

def semHead: Option[Int]

def semHeadLemma: Option[String]

def semHeadTag: Option[String]

def semHeadWord: Option[String]

def semHeads: Seq[Int]

val sentence: Int

def sentenceObj: Sentence

def start: Int

def startOffset: Int

def synHead: Option[Int]

def synHeadLemma: Option[String]

def synHeadTag: Option[String]

def synHeadWord: Option[String]

def synHeads: Seq[Int]

final def synchronized[T0](arg0: ⇒ T0): T0

def tags: Option[Seq[String]]

def text: String

def toString(): String

val tokenInterval: Interval

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

def withAttachment(mod: Attachment): Mention

def withoutAttachment(mod: Attachment): Mention

def words: Seq[String]

Inherited from Mention