Struct RecordRef

Source

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

Implementations§

Source §

impl<'a> RecordRef<'a>

Source

pub fn fields(&self) -> Fields<'_> ⓘ

Examples found in repository ?

examples/query_records.rs (line 25)

5fn main() {
6    let mut args = std::env::args().skip(1);
7    let path = args
8        .next()
9        .expect("usage: query_records <file.rec> <Type> <selection-expression>");
10    let rset_type = args.next().expect("missing record type");
11    let expr = args.next().expect("missing selection expression");
12
13    let text = fs::read_to_string(&path).expect("read file");
14    let mut db = Db::parse_str(&text).expect("parse");
15
16    let rset = db
17        .rset_by_type(&rset_type)
18        .unwrap_or_else(|| panic!("no record set of type {rset_type:?}"));
19    let selection_expression =
20        SelectionExpression::compile(&expr, false).expect("compile selection expression");
21
22    let mut matches = 0usize;
23    for record in rset.records().filter(|r| selection_expression.matches(r)) {
24        matches += 1;
25        for field in record.fields() {
26            println!("{}: {}", field.name(), field.value());
27        }
28        println!();
29    }
30    eprintln!("{matches} match(es)");
31}

Source

pub fn as_ptr(&self) -> rec_record_t

Source

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

Set the value of the first field with the given name. Returns true if such a field was found and updated, false otherwise.

Examples found in repository ?

examples/modify_records.rs (line 41)

15fn main() -> ExitCode {
16    let mut args = std::env::args().skip(1);
17    let path = args.next().unwrap_or_else(|| usage());
18    let rset_type = args.next().unwrap_or_else(|| usage());
19    let expr = args.next().unwrap_or_else(|| usage());
20    let action = args.next().unwrap_or_else(|| usage());
21
22    let text = fs::read_to_string(&path).expect("read file");
23    let mut db = Db::parse_str(&text).expect("parse");
24    let selection_expression =
25        SelectionExpression::compile(&expr, false).expect("compile selection expression");
26
27    let summary = {
28        let mut rset = db
29            .rset_by_type(&rset_type)
30            .unwrap_or_else(|| panic!("no record set of type {rset_type:?}"));
31
32        match action.as_str() {
33            "set" => {
34                let pair = args.next().unwrap_or_else(|| usage());
35                let (field, value) = pair
36                    .split_once('=')
37                    .unwrap_or_else(|| panic!("expected Field=Value, got {pair:?}"));
38                let mut updated = 0usize;
39                let mut missing = 0usize;
40                for mut record in rset.records().filter(|r| selection_expression.matches(r)) {
41                    match record.set_field(field, value).expect("set field") {
42                        true => updated += 1,
43                        false => missing += 1,
44                    }
45                }
46                format!(
47                    "set {field}={value} on {updated} record(s); {missing} matching record(s) had no such field"
48                )
49            }
50            "delete" => {
51                let removed = rset.remove_matching(|r| selection_expression.matches(r));
52                format!("deleted {removed} record(s)")
53            }
54            other => {
55                eprintln!("unknown action {other:?}");
56                return ExitCode::from(2);
57            }
58        }
59    };
60
61    let serialized = db.to_rec_string().expect("serialize");
62    fs::write(&path, serialized).expect("write file");
63    println!("{summary}");
64    ExitCode::SUCCESS
65}