Mention

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

A map from argument name to a sequence of mentions.

abstract val attachments: Set[Attachment]

Attachments that can modify a Mention.

abstract def document: Document

The document where this mention occurs.

abstract def foundBy: String

name of matching rule

abstract def keep: Boolean

Should we report this mention at the end?

abstract def labels: Seq[String]

A sequence of labels for this mention.

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

abstract def sentence: Int

The index of the sentence where this mention occurs.

abstract def tokenInterval: Interval

The interval of token indicess that form this mention.

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

final def asInstanceOf[T0]: T0

lazy val cachedHashCode: Int

def calculateHashCode: Int

def canEqual(a: Any): Boolean

def chunks: Option[Seq[String]]

returns all chunks in mention

def clone(): AnyRef

def compare(that: Mention): Int

def compareTo(that: Mention): Int

def distToRootOpt: Option[Int]

returns the minimum distance to a root node for dependencies within the token interval

def end: Int

one after the last token in the mention

def endOffset: Int

character offset of the mention end

def entities: Option[Seq[String]]

returns all entities in mention

final def eq(arg0: AnyRef): Boolean

def equals(that: Any): Boolean

def finalize(): Unit

final def getClass(): Class[_]

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

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

def isValid: Boolean

returns true if this is a valid mention

def label: String

default label

def lemmas: Option[Seq[String]]

returns all lemmas in mention

def matches(matcher: StringMatcher): Boolean

returns true if the StringMatcher matches any of the mention labels

def matches(regex: Regex): Boolean

returns true if the regex matches any of the mention labels

def matches(label: String): Boolean

returns true if the string matches any of the mention labels

final def ne(arg0: AnyRef): Boolean

def norms: Option[Seq[String]]

returns the norm value of this mention, if available

final def notify(): Unit

final def notifyAll(): Unit

def precedes(that: Mention): Boolean

def raw: Seq[String]

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

def semHead: Option[Int]

returns the syntactic head of mention

def semHeadLemma: Option[String]

returns head lemma

def semHeadTag: Option[String]

returns head pos tag

def semHeadWord: Option[String]

returns head token

def semHeads: Seq[Int]

returns all semantic heads

def sentenceObj: Sentence

def start: Int

index of the first token in the mention

def startOffset: Int

character offset of the mention beginning

def synHead: Option[Int]

returns the syntactic head of mention

def synHeadLemma: Option[String]

returns head lemma

def synHeadTag: Option[String]

returns head pos tag

def synHeadWord: Option[String]

returns head token

def synHeads: Seq[Int]

returns all syntactic heads

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

def tags: Option[Seq[String]]

returns all tags in mention

def text: String

returns a string that contains the mention

def toString(): String

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def withAttachment(mod: Attachment): Mention

def withAttachments(mods: Seq[Attachment]): Mention

def withoutAttachment(mod: Attachment): Mention

def withoutAttachments(mods: Seq[Attachment]): Mention

def words: Seq[String]

returns all tokens in mention