Struct beancount_parser::Transaction

#[non_exhaustive]
pub struct Transaction<D> {
    pub flag: Option<char>,
    pub payee: Option<String>,
    pub narration: Option<String>,
    pub tags: HashSet<Tag>,
    pub links: HashSet<Link>,
    pub postings: Vec<Posting<D>>,
}

A transaction

It notably contains a list of Posting

Example

let input = r#"
2022-05-22 * "Grocery store" "Grocery shopping" #food
  Assets:Cash           -10 CHF
  Expenses:Groceries
"#;

let beancount: BeancountFile<f64> = input.parse().unwrap();
let DirectiveContent::Transaction(trx) = &beancount.directives[0].content else {
  unreachable!("was not a transaction")
};
assert_eq!(trx.flag, Some('*'));
assert_eq!(trx.payee.as_deref(), Some("Grocery store"));
assert_eq!(trx.narration.as_deref(), Some("Grocery shopping"));
assert!(trx.tags.contains("food"));
assert_eq!(trx.postings.len(), 2);

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.

flag: Option<char>

Transaction flag (* or ! or None when using the txn keyword)

payee: Option<String>

Payee (if present)

narration: Option<String>

Narration (if present)

tags: HashSet<Tag>

Set of tags

links: HashSet<Link>

Set of links

postings: Vec<Posting<D>>

Postings

Trait Implementations

impl<D: Clone> Clone for Transaction<D>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<D: Debug> Debug for Transaction<D>

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

Formats the value using the given formatter.

impl<D: PartialEq> PartialEq for Transaction<D>

fn eq(&self, other: &Transaction<D>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<D> StructuralPartialEq for Transaction<D>