Struct ParsedEntry 

pub struct ParsedEntry<'a> {
    pub ty: EntryType<'a>,
    pub key: Cow<'a, str>,
    pub fields: Vec<ParsedField<'a>>,
    pub status: ParsedEntryStatus,
    pub source: Option<SourceSpan>,
    pub entry_type_source: Option<SourceSpan>,
    pub key_source: Option<SourceSpan>,
    pub delimiter: Option<EntryDelimiter>,
    pub raw: Option<Cow<'a, str>>,
    pub diagnostics: Vec<Diagnostic>,
}

Parsed entry plus optional source-preserving metadata.

Fields

ty: EntryType<'a>

Entry type.

key: Cow<'a, str>

Citation key.

fields: Vec<ParsedField<'a>>

Parsed fields in source order.

status: ParsedEntryStatus

Whether the entry is complete or recovered.

source: Option<SourceSpan>

Source location for the whole entry, when available.

entry_type_source: Option<SourceSpan>

Source location for the entry type token, when available.

key_source: Option<SourceSpan>

Source location for the citation key token, when available.

delimiter: Option<EntryDelimiter>

Entry body delimiter, when retained.

raw: Option<Cow<'a, str>>

Exact raw entry text, when retained by the parser mode.

diagnostics: Vec<Diagnostic>

Diagnostics attached to this entry.

Implementations

impl<'a> ParsedEntry<'a>

pub fn from_entry(entry: Entry<'a>, source: Option<SourceSpan>) -> Self

Create parsed-entry metadata from a structured entry.

pub fn key(&self) -> &str

Return the citation key.

pub fn into_entry(self) -> Entry<'a>

Convert this parsed entry into the structured entry.

pub fn rename_key(&mut self, key: impl Into<Cow<'a, str>>)

Rename the citation key.

pub fn set_entry_type(&mut self, ty: EntryType<'a>)

Replace the entry type.

pub fn add_field(&mut self, name: impl Into<Cow<'a, str>>, value: Value<'a>)

Add a field and switch this entry to structured writing.

pub fn replace_field_value(&mut self, name: &str, value: Value<'a>) -> bool

Replace the first field value whose name matches exactly.

pub fn replace_field_value_at( &mut self, name: &str, occurrence: usize, value: Value<'a>, ) -> bool

Replace a specific duplicate field occurrence by zero-based occurrence index.

pub fn rename_field(&mut self, old: &str, new: impl Into<Cow<'a, str>>) -> usize

Rename all fields whose name matches exactly.

pub fn remove_field(&mut self, name: &str) -> usize

Remove all fields whose name matches exactly.

pub fn remove_field_at(&mut self, name: &str, occurrence: usize) -> bool

Remove a specific duplicate field occurrence by zero-based occurrence index.

pub fn remove_export_fields(&mut self, names: &[&str]) -> usize

Remove configured export-only fields from this entry.

pub fn field_ignore_case(&self, name: &str) -> Option<&ParsedField<'a>>

Return the first field matching name, ignoring ASCII case.

pub fn get_as_string_ignore_case(&self, name: &str) -> Option<String>

Return a field value as ordinary text, ignoring ASCII case.

pub fn doi(&self) -> Option<String>

Return the normalized DOI, if the entry has a recognizable DOI field.

pub fn authors(&self) -> Vec<PersonName>

Parse the author field into structured BibTeX names.

pub fn editors(&self) -> Vec<PersonName>

Parse the editor field into structured BibTeX names.

pub fn translators(&self) -> Vec<PersonName>

Parse the translator field into structured BibTeX names.

pub fn date_parts_for( &self, field: &str, ) -> Option<Result<DateParts, DateParseError>>

Parse a specific date-like field into date parts.

pub fn date_parts(&self) -> Option<Result<DateParts, DateParseError>>

Return issued date parts for this entry.

pub fn resource_fields(&self) -> Vec<ResourceField>

Return classified resource and identifier fields in source order.

pub fn into_owned(self) -> ParsedEntry<'static>

Convert this parsed entry into an owned value.

Trait Implementations

impl<'a> Clone for ParsedEntry<'a>

fn clone(&self) -> ParsedEntry<'a>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for ParsedEntry<'a>

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

Formats the value using the given formatter.

impl<'a> PartialEq for ParsedEntry<'a>

fn eq(&self, other: &ParsedEntry<'a>) -> 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<'a> StructuralPartialEq for ParsedEntry<'a>