Struct beancount_parser::Posting

#[non_exhaustive]
pub struct Posting<D> {
    pub flag: Option<char>,
    pub account: Account,
    pub amount: Option<Amount<D>>,
    pub cost: Option<Cost<D>>,
    pub price: Option<PostingPrice<D>>,
    pub metadata: Map<D>,
}

A transaction posting

Example

let input = r#"
2022-05-22 * "Grocery shopping"
  Assets:Cash           1 CHF {2 PLN} @ 3 EUR
  Expenses:Groceries
"#;

let beancount: BeancountFile<f64> = input.parse().unwrap();
let DirectiveContent::Transaction(trx) = &beancount.directives[0].content else {
  unreachable!("was not a transaction")
};
let posting = &trx.postings[0];
assert_eq!(posting.account.as_str(), "Assets:Cash");
assert_eq!(posting.amount.as_ref().unwrap().value, 1.0);
assert_eq!(posting.amount.as_ref().unwrap().currency.as_str(), "CHF");
assert_eq!(posting.cost.as_ref().unwrap().amount.as_ref().unwrap().value, 2.0);
assert_eq!(posting.cost.as_ref().unwrap().amount.as_ref().unwrap().currency.as_str(), "PLN");
let Some(PostingPrice::Unit(price)) = &posting.price else {
  unreachable!("no price");
};
assert_eq!(price.value, 3.0);
assert_eq!(price.currency.as_str(), "EUR");

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 absent)

account: Account

Account modified by the posting

amount: Option<Amount<D>>

Amount being added to the account

cost: Option<Cost<D>>

Cost (content within { and })

price: Option<PostingPrice<D>>

Price (@ or @@) syntax

metadata: Map<D>

The metadata attached to the posting

Trait Implementations

impl<D: Clone> Clone for Posting<D>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<D: Debug> Debug for Posting<D>

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

Formats the value using the given formatter.

impl<D: PartialEq> PartialEq for Posting<D>

fn eq(&self, other: &Posting<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 Posting<D>