Struct Entry 

pub struct Entry<'a> {
    pub ty: EntryType<'a>,
    pub key: Cow<'a, str>,
    pub fields: Vec<Field<'a>>,
}

A BibTeX entry (article, book, etc.)

Fields

ty: EntryType<'a>

Entry type (article, book, inproceedings, etc.)

key: Cow<'a, str>

Citation key

fields: Vec<Field<'a>>

Fields (author, title, year, etc.)

Implementations

impl<'a> Entry<'a>

pub const fn new(ty: EntryType<'a>, key: &'a str) -> Self

Create a new entry

pub const fn entry_type(&self) -> &EntryType<'a>

Get the entry type

pub fn key(&self) -> &str

Get the citation key

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

Get a field by name (case-sensitive).

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

Get a field by name (case-insensitive).

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

Get a field value by name (case-sensitive) Note: This only returns string literals, not numbers

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

Get a field value by name (case-insensitive) Returns the first field whose name matches ignoring case Note: This only returns string literals, not numbers

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

Get a field value as a string, converting numbers if necessary (case-sensitive)

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

Get a field value as a string, converting numbers if necessary (case-insensitive)

pub fn get_any_ignore_case(&self, names: &[&str]) -> Option<&str>

Get the first string-literal field matching any of the names, case-insensitively.

pub fn get_any_as_string_ignore_case(&self, names: &[&str]) -> Option<String>

Get the first field matching any of the names as a string, case-insensitively.

pub fn has_field(&self, name: &str) -> bool

Return true when a field exists, ignoring ASCII case.

pub fn has_any_field(&self, names: &[&str]) -> bool

Return true when any field in names exists, ignoring ASCII case.

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

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

This accepts common input forms such as 10.1000/xyz, doi:10.1000/xyz, and https://doi.org/10.1000/xyz.

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.

date, issued, eventdate, origdate, and urldate are checked before falling back to year plus an optional month field.

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

Return classified resource and identifier fields in source order.

pub fn fields(&self) -> &[Field<'a>]

Get all fields

pub fn add_field(&mut self, field: Field<'a>)

Add a field

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

Set a field value, replacing the first matching field or appending it.

pub fn set_literal(&mut self, name: &'a str, value: &'a str)

Set a field to a string literal.

pub fn remove(&mut self, name: &str) -> Vec<Field<'a>>

Remove all fields whose name matches exactly.

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

Rename all fields whose name matches exactly.

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

Return the title field as a string.

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

Return the year field as a string.

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

Return the date field as a string.

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

Return the journal field, accepting BibLaTeX’s journaltitle alias.

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

Return the book title field as a string.

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

Return the URL field as a string.

pub fn keywords(&self) -> Vec<String>

Return keywords split on commas or semicolons.

pub fn validate( &self, level: ValidationLevel, ) -> Result<(), Vec<ValidationError>>

Validate the entry according to the specified level Returns Ok(()) if valid, or Err with a list of validation errors

pub fn is_valid(&self) -> bool

Check whether the entry has the minimal required fields for its type.

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

Get a field value with LaTeX sequences converted to Unicode (case-sensitive)

This method converts common LaTeX escape sequences like \'e to é and \"{o} to ö. Returns None if the field doesn’t exist or isn’t a string literal.

Examples

let bibtex = r#"@article{test, author = "Jos\'e Garc\'ia"}"#;
let library = Library::parser().parse(bibtex).unwrap();
let entry = &library.entries()[0];
assert_eq!(entry.get_unicode("author"), Some("José García".to_string()));

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

Get a field value with LaTeX sequences converted to Unicode (case-insensitive)

This method converts common LaTeX escape sequences like \'e to é and \"{o} to ö. Returns None if the field doesn’t exist or isn’t a string literal. Field name matching is case-insensitive.

Examples

let bibtex = r#"@article{test, TITLE = "M\\\"uller's work"}"#;
let library = Library::parser().parse(bibtex).unwrap();
let entry = &library.entries()[0];
assert_eq!(entry.get_unicode_ignore_case("title"), Some("Müller's work".to_string()));

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

Get a field value as string with LaTeX conversion (case-sensitive)

Similar to get_as_string() but converts LaTeX sequences to Unicode. This handles all field types (literals, numbers, variables, concatenations).

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

Get a field value as string with LaTeX conversion (case-insensitive)

Similar to get_as_string_ignore_case() but converts LaTeX sequences to Unicode. This handles all field types (literals, numbers, variables, concatenations).

pub fn fields_unicode(&self) -> Vec<(String, String)>

Get all fields with LaTeX converted to Unicode

Returns a vector of (field_name, unicode_value) pairs for all string literal fields. Non-string fields (numbers, variables) are excluded.

Examples

let bibtex = r#"@article{test,
    author = "Jos\'e Garc\'ia",
    title = "\\alpha and \\beta particles",
    year = 2024
}"#;
let library = Library::parser().parse(bibtex).unwrap();
let entry = &library.entries()[0];
let unicode_fields = entry.fields_unicode();

let author = unicode_fields.iter()
    .find(|(k, _)| k == "author")
    .map(|(_, v)| v.as_str())
    .unwrap();
assert_eq!(author, "José García");

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

Convert to owned version

Trait Implementations

impl<'a> Clone for Entry<'a>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for Entry<'a>

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

Formats the value using the given formatter.

impl<'a> PartialEq for Entry<'a>

fn eq(&self, other: &Entry<'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 Entry<'a>