Struct Record 

pub struct Record { /* private fields */ }

A freshly-built record. Owns its rec_record_t until passed to crate::Rset::append_record, at which point ownership is transferred to the containing record set.

Implementations

impl Record

pub fn new() -> Self

Examples found in repository

examples/write_rec.rs (line 14)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut db = Db::new();

    let mut rset = OwnedRset::new();

    let mut descriptor = Record::new();
    descriptor.append_field("%rec", "Book")?;
    descriptor.append_field("%type", "Year int")?;
    descriptor.append_field("%mandatory", "Title")?;
    rset.set_descriptor(descriptor);

    for (title, author, year) in [
        ("Refactoring", "Martin Fowler", "1999"),
        ("Domain-Driven Design", "Eric Evans", "2003"),
        ("Test-Driven Development", "Kent Beck", "2002"),
    ] {
        let mut record = Record::new();
        record.append_field("Title", title)?;
        record.append_field("Author", author)?;
        record.append_field("Year", year)?;
        rset.append_record(record)?;
    }

    db.append_rset(rset)?;
    println!("{}", db.to_rec_string()?);
    Ok(())
}

examples/append_record.rs (line 22)

fn main() {
    let mut args = std::env::args().skip(1);
    let path = args
        .next()
        .expect("usage: append_record <file.rec> <Type> Field=Value [Field=Value ...]");
    let rset_type = args.next().expect("missing record type");
    let pairs: Vec<(String, String)> = args
        .map(|a| {
            let (k, v) = a.split_once('=').expect("expected Field=Value");
            (k.to_string(), v.to_string())
        })
        .collect();
    assert!(!pairs.is_empty(), "need at least one Field=Value");

    let text = fs::read_to_string(&path).expect("read file");
    let mut db = Db::parse_str(&text).expect("parse");

    let mut record = Record::new();
    for (k, v) in &pairs {
        record.append_field(k, v).expect("append field");
    }

    {
        let mut rset = db
            .rset_by_type(&rset_type)
            .unwrap_or_else(|| panic!("no record set of type {rset_type:?}"));
        rset.append_record(record).expect("append record");
    }

    let serialized = db.to_rec_string().expect("serialize");
    fs::write(&path, serialized).expect("write file");
    println!("appended 1 record to rset {rset_type:?} in {path}");
}

pub fn append_field(&mut self, name: &str, value: &str) -> Result<(), Error>

Examples found in repository

examples/write_rec.rs (line 15)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut db = Db::new();

    let mut rset = OwnedRset::new();

    let mut descriptor = Record::new();
    descriptor.append_field("%rec", "Book")?;
    descriptor.append_field("%type", "Year int")?;
    descriptor.append_field("%mandatory", "Title")?;
    rset.set_descriptor(descriptor);

    for (title, author, year) in [
        ("Refactoring", "Martin Fowler", "1999"),
        ("Domain-Driven Design", "Eric Evans", "2003"),
        ("Test-Driven Development", "Kent Beck", "2002"),
    ] {
        let mut record = Record::new();
        record.append_field("Title", title)?;
        record.append_field("Author", author)?;
        record.append_field("Year", year)?;
        rset.append_record(record)?;
    }

    db.append_rset(rset)?;
    println!("{}", db.to_rec_string()?);
    Ok(())
}

examples/append_record.rs (line 24)

fn main() {
    let mut args = std::env::args().skip(1);
    let path = args
        .next()
        .expect("usage: append_record <file.rec> <Type> Field=Value [Field=Value ...]");
    let rset_type = args.next().expect("missing record type");
    let pairs: Vec<(String, String)> = args
        .map(|a| {
            let (k, v) = a.split_once('=').expect("expected Field=Value");
            (k.to_string(), v.to_string())
        })
        .collect();
    assert!(!pairs.is_empty(), "need at least one Field=Value");

    let text = fs::read_to_string(&path).expect("read file");
    let mut db = Db::parse_str(&text).expect("parse");

    let mut record = Record::new();
    for (k, v) in &pairs {
        record.append_field(k, v).expect("append field");
    }

    {
        let mut rset = db
            .rset_by_type(&rset_type)
            .unwrap_or_else(|| panic!("no record set of type {rset_type:?}"));
        rset.append_record(record).expect("append record");
    }

    let serialized = db.to_rec_string().expect("serialize");
    fs::write(&path, serialized).expect("write file");
    println!("appended 1 record to rset {rset_type:?} in {path}");
}

Trait Implementations

impl Default for Record

fn default() -> Self

Returns the “default value” for a type.

impl Drop for Record

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.