Struct Directive

#[non_exhaustive]
pub struct Directive<D> {
    pub date: Date,
    pub content: DirectiveContent<D>,
    pub metadata: Map<D>,
    pub line_number: u32,
}

A beancount “directive”

It has fields common to all directives, and a Directive::content field with a different content for each directive type.

let input = r#"
2022-01-01 open Assets:Cash
2022-01-01 * "Grocery shopping"
  Expenses:Groceries  10 CHF
  Assets:Cash
"#;
let beancount: BeancountFile<f64> = input.parse().unwrap();
assert_eq!(beancount.directives.len(), 2);
for directive in beancount.directives {
   println!("line: {}", directive.line_number);
   println!("metadata: {:#?}", directive.metadata);
   match directive.content {
      DirectiveContent::Open(open) => println!("open account directive: {open:?}"),
      DirectiveContent::Transaction(trx) => println!("transaction: {trx:?}"),
      other => println!("unknown directive: {other:?}"),
   }
}

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

date: Date

Date of the directive

content: DirectiveContent<D>

Content of the directive that is specific to each directive type

metadata: Map<D>

Metadata associated to the directive

See the metadata module for more

line_number: u32

Line number where the directive was found in the input file

Trait Implementations

impl<D: Clone> Clone for Directive<D>

fn clone(&self) -> Directive<D>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<D: Debug> Debug for Directive<D>

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

Formats the value using the given formatter.

impl<D: Decimal> FromStr for Directive<D>

type Err = Error

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl<D: PartialEq> PartialEq for Directive<D>

fn eq(&self, other: &Directive<D>) -> 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<D> StructuralPartialEq for Directive<D>