Struct AaOutput

pub struct AaOutput {
    pub id: String,
    pub abbreviation_type: AbbreviationType,
    pub short_form: String,
    pub long_form: String,
    pub short_token_count: i32,
    pub short_character_count: i32,
    pub long_token_count: i32,
    pub long_character_count: i32,
    pub positional_info: AaPosInfo,
}

Main “Secondary” struct of program Acronyms and Abbreviations detected by MetaMap

Fields

id: String

Unique identifier

abbreviation_type: AbbreviationType

Abbreviation type: either MetaMap defined or User-defined

short_form: String

Short form of the acronym/abbreviation

long_form: String

Long form or expansion

short_token_count: i32

number of tokens (including whitespace) in short form

short_character_count: i32

number of characters in short form

long_token_count: i32

number of tokens (including whitespace) in long form

long_character_count: i32

number of characters in long form

positional_info: AaPosInfo

starting position of short form followed by “:” followed by character length of short form

Implementations

impl AaOutput

pub fn assemble(parts: HashMap<&str, &str>) -> Result<Self, Box<dyn Error>>

Parses a hashmap into AaOutput field types. Utilizes all other functionality defined in this module to assemble/parse each field into its appropriate format and types.

While this function is useful for building AaOutput types, parse_record will probably be much more practical since it accepts a string reference and does the field tagging/mapping for you.

Trait Implementations

impl Debug for AaOutput

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for AaOutput

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for AaOutput

fn eq(&self, other: &AaOutput) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for AaOutput

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for AaOutput

impl StructuralPartialEq for AaOutput