Struct Rset 

pub struct Rset<'a> { /* private fields */ }

Implementations

impl<'a> Rset<'a>

pub fn num_records(&self) -> usize

Examples found in repository

examples/count_records.rs (line 12)

fn main() {
    let path = std::env::args().nth(1).expect("usage: count_records <file.rec>");
    let text = fs::read_to_string(&path).expect("read file");

    let mut db = Db::parse_str(&text).expect("parse");
    let n_rsets = db.num_rsets();
    let total: usize = (0..n_rsets)
        .map(|i| db.rset_at(i).expect("rset by index").num_records())
        .sum();
    println!("{}: {} records across {} record set(s)", path, total, n_rsets);
}

pub fn descriptor(&self) -> Option<RecordRef<'_>>

The record-descriptor record (everything declared in the %rec: / %type: / %key: / %mandatory: block). None for record sets that have no descriptor.

pub fn records(&self) -> Records<'_>

Examples found in repository

examples/query_records.rs (line 23)

fn main() {
    let mut args = std::env::args().skip(1);
    let path = args
        .next()
        .expect("usage: query_records <file.rec> <Type> <selection-expression>");
    let rset_type = args.next().expect("missing record type");
    let expr = args.next().expect("missing selection expression");

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

    let rset = db
        .rset_by_type(&rset_type)
        .unwrap_or_else(|| panic!("no record set of type {rset_type:?}"));
    let selection_expression =
        SelectionExpression::compile(&expr, false).expect("compile selection expression");

    let mut matches = 0usize;
    for record in rset.records().filter(|r| selection_expression.matches(r)) {
        matches += 1;
        for field in record.fields() {
            println!("{}: {}", field.name(), field.value());
        }
        println!();
    }
    eprintln!("{matches} match(es)");
}

examples/modify_records.rs (line 40)

fn main() -> ExitCode {
    let mut args = std::env::args().skip(1);
    let path = args.next().unwrap_or_else(|| usage());
    let rset_type = args.next().unwrap_or_else(|| usage());
    let expr = args.next().unwrap_or_else(|| usage());
    let action = args.next().unwrap_or_else(|| usage());

    let text = fs::read_to_string(&path).expect("read file");
    let mut db = Db::parse_str(&text).expect("parse");
    let selection_expression =
        SelectionExpression::compile(&expr, false).expect("compile selection expression");

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

        match action.as_str() {
            "set" => {
                let pair = args.next().unwrap_or_else(|| usage());
                let (field, value) = pair
                    .split_once('=')
                    .unwrap_or_else(|| panic!("expected Field=Value, got {pair:?}"));
                let mut updated = 0usize;
                let mut missing = 0usize;
                for mut record in rset.records().filter(|r| selection_expression.matches(r)) {
                    match record.set_field(field, value).expect("set field") {
                        true => updated += 1,
                        false => missing += 1,
                    }
                }
                format!(
                    "set {field}={value} on {updated} record(s); {missing} matching record(s) had no such field"
                )
            }
            "delete" => {
                let removed = rset.remove_matching(|r| selection_expression.matches(r));
                format!("deleted {removed} record(s)")
            }
            other => {
                eprintln!("unknown action {other:?}");
                return ExitCode::from(2);
            }
        }
    };

    let serialized = db.to_rec_string().expect("serialize");
    fs::write(&path, serialized).expect("write file");
    println!("{summary}");
    ExitCode::SUCCESS
}

pub fn remove_matching<F>(&mut self, pred: F) -> usize

where F: FnMut(&RecordRef<'_>) -> bool,

Remove every record for which pred returns true. Returns the count of records removed.

Examples found in repository

examples/modify_records.rs (line 51)

fn main() -> ExitCode {
    let mut args = std::env::args().skip(1);
    let path = args.next().unwrap_or_else(|| usage());
    let rset_type = args.next().unwrap_or_else(|| usage());
    let expr = args.next().unwrap_or_else(|| usage());
    let action = args.next().unwrap_or_else(|| usage());

    let text = fs::read_to_string(&path).expect("read file");
    let mut db = Db::parse_str(&text).expect("parse");
    let selection_expression =
        SelectionExpression::compile(&expr, false).expect("compile selection expression");

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

        match action.as_str() {
            "set" => {
                let pair = args.next().unwrap_or_else(|| usage());
                let (field, value) = pair
                    .split_once('=')
                    .unwrap_or_else(|| panic!("expected Field=Value, got {pair:?}"));
                let mut updated = 0usize;
                let mut missing = 0usize;
                for mut record in rset.records().filter(|r| selection_expression.matches(r)) {
                    match record.set_field(field, value).expect("set field") {
                        true => updated += 1,
                        false => missing += 1,
                    }
                }
                format!(
                    "set {field}={value} on {updated} record(s); {missing} matching record(s) had no such field"
                )
            }
            "delete" => {
                let removed = rset.remove_matching(|r| selection_expression.matches(r));
                format!("deleted {removed} record(s)")
            }
            other => {
                eprintln!("unknown action {other:?}");
                return ExitCode::from(2);
            }
        }
    };

    let serialized = db.to_rec_string().expect("serialize");
    fs::write(&path, serialized).expect("write file");
    println!("{summary}");
    ExitCode::SUCCESS
}

pub fn append_record(&mut self, record: Record) -> Result<(), Error>

Examples found in repository

examples/append_record.rs (line 31)

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}");
}