Struct AnnotatedForm

pub struct AnnotatedForm {

    pub id: Option<Uuid>,
    pub source: String,
    pub normalized_source: Option<String>,
    pub simple_phonetics: Option<String>,
    pub phonemic: Option<String>,
    pub segments: Option<Vec<WordSegment>>,
    pub english_gloss: Vec<String>,
    pub commentary: Option<String>,
    pub line_break: Option<i32>,
    pub page_break: Option<i32>,
    pub position: PositionInDocument,
    pub date_recorded: Option<Date>,
    pub ingested_audio_track: Option<AudioSlice>,
}

A single word in an annotated document. One word contains several layers of interpretation, including the original source text, multiple layers of linguistic annotation, and annotator notes. TODO Split into two types, one for migration and one for SQL + GraphQL

Fields

id: Option<Uuid>

Unique identifier of this form

source: String

Original source text

normalized_source: Option<String>

A normalized version of the word

simple_phonetics: Option<String>

Romanized version of the word for simple phonetic pronunciation

phonemic: Option<String>

Underlying phonemic representation of this word

segments: Option<Vec<WordSegment>>

Morphemic segmentation of the form that includes a phonemic representation and gloss for each

english_gloss: Vec<String>

English gloss for the whole word

commentary: Option<String>

Further details about the annotation layers, including uncertainty

line_break: Option<i32>

The character index of a mid-word line break, if there is one

page_break: Option<i32>

The character index of a mid-word page break, if there is one

position: PositionInDocument

Position of the form within the context of its parent document

date_recorded: Option<Date>

The date and time this form was recorded

ingested_audio_track: Option<AudioSlice>

The audio for this word that was ingested from GoogleSheets, if there is any.

Implementations

impl AnnotatedForm

pub async fn source(&self, ctx: &Context<'_>) -> Result<&String>

pub async fn normalized_source( &self, ctx: &Context<'_>, ) -> Result<&Option<String>>

pub async fn phonemic(&self, ctx: &Context<'_>) -> Result<&Option<String>>

pub async fn english_gloss(&self, ctx: &Context<'_>) -> Result<&Vec<String>>

pub async fn commentary(&self, ctx: &Context<'_>) -> Result<&Option<String>>

pub async fn line_break(&self, ctx: &Context<'_>) -> Result<&Option<i32>>

pub async fn page_break(&self, ctx: &Context<'_>) -> Result<&Option<i32>>

pub async fn position(&self, ctx: &Context<'_>) -> Result<&PositionInDocument>

pub async fn date_recorded(&self, ctx: &Context<'_>) -> Result<&Option<Date>>

pub async fn ingested_audio_track( &self, ctx: &Context<'_>, ) -> Result<&Option<AudioSlice>>

impl AnnotatedForm

pub fn find_root(&self) -> Option<&WordSegment>

Look for a root morpheme in the word using crude case checks.

pub fn find_morpheme(&self, gloss: &str) -> Option<&WordSegment>

Find a morpheme within this word with the given exact gloss.

pub fn is_unresolved(&self) -> bool

Are there any unidentified segments within this word? Just checks if there are morphemes or glosses consisting of a question mark “?”

Trait Implementations

impl Clone for AnnotatedForm

fn clone(&self) -> AnnotatedForm

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl ContainerType for AnnotatedForm

fn resolve_field<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, ctx: &'life1 Context<'life2>, ) -> Pin<Box<dyn Future<Output = ServerResult<Option<Value>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Resolves a field value and outputs it as a json value async_graphql::Value.

fn collect_all_fields<'a>( &'a self, ctx: &ContextBase<'a, &'a Positioned<SelectionSet>>, fields: &mut Fields<'a>, ) -> Result<(), ServerError>

where Self: Send + Sync,

Collect all the fields of the container that are queried in the selection set.

fn find_entity<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, _: &'life1 ContextBase<'life2, &'life2 Positioned<Field>>, _params: &'life3 ConstValue, ) -> Pin<Box<dyn Future<Output = Result<Option<ConstValue>, ServerError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, Self: Sync + 'async_trait,

Find the GraphQL entity with the given name from the parameter.

impl Debug for AnnotatedForm

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for AnnotatedForm

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<AnnotatedForm> for AnnotatedSeg

fn from(obj: AnnotatedForm) -> Self

Converts to this type from the input type.

impl From<AnnotatedForm> for CommentParent

fn from(obj: AnnotatedForm) -> Self

Converts to this type from the input type.

impl OutputType for AnnotatedForm

fn type_name() -> Cow<'static, str>

Type the name.

fn create_type_info(registry: &mut Registry) -> String

Create type information in the registry and return qualified typename.

fn resolve<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, ctx: &'life1 ContextSelectionSet<'life2>, _field: &'life3 Positioned<Field>, ) -> Pin<Box<dyn Future<Output = ServerResult<Value>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Resolve an output value to async_graphql::Value.

fn qualified_type_name() -> String

Qualified typename.

fn introspection_type_name(&self) -> Cow<'static, str>

Introspection type name

impl Serialize for AnnotatedForm

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl ObjectType for AnnotatedForm