Struct Posting 

pub struct Posting {
    pub account: Account,
    pub units: Option<IncompleteAmount>,
    pub cost: Option<CostSpec>,
    pub price: Option<PriceAnnotation>,
    pub flag: Option<char>,
    pub meta: Metadata,
    pub comments: Vec<String>,
    pub trailing_comments: Vec<String>,
}

A posting within a transaction.

Postings represent the individual legs of a transaction. Each posting specifies an account and optionally an amount, cost, and price.

When the units are None, the entire amount will be inferred by the interpolation algorithm to balance the transaction. When units is Some(IncompleteAmount), it may still have missing components that need to be filled in.

Fields

account: Account

The account for this posting

units: Option<IncompleteAmount>

The units (may be incomplete or None for auto-calculated postings)

cost: Option<CostSpec>

Cost specification for the position

price: Option<PriceAnnotation>

Price annotation (@ or @@)

flag: Option<char>

Whether this posting has the “!” flag

meta: Metadata

Posting metadata

comments: Vec<String>

Comments that appear before this posting (one per line)

trailing_comments: Vec<String>

Trailing comment(s) on the same line as the posting

Implementations

impl Posting

pub fn new(account: impl Into<Account>, units: Amount) -> Self

Create a new posting with the given account and complete units.

pub fn with_incomplete( account: impl Into<Account>, units: IncompleteAmount, ) -> Self

Create a new posting with an incomplete amount.

pub fn auto(account: impl Into<Account>) -> Self

Create a posting without any amount (to be fully interpolated).

pub fn amount(&self) -> Option<&Amount>

Get the complete amount if available.

pub fn with_cost(self, cost: CostSpec) -> Self

Add a cost specification.

Consuming builder — takes self by value and returns Posting. To apply this to a Spanned<Posting> while preserving its source location, use crate::Spanned::map:

let spanned: Spanned<Posting> = Spanned::synthesized(
    Posting::new("Assets:Stock", Amount::new(dec!(10), "AAPL"))
);
let with_cost: Spanned<Posting> = spanned.map(|p| p.with_cost(cost));

pub fn with_price(self, price: PriceAnnotation) -> Self

Add a price annotation.

See Self::with_cost for the Spanned<Posting> pattern.

pub const fn with_flag(self, flag: char) -> Self

Add a flag.

See Self::with_cost for the Spanned<Posting> pattern.

pub const fn has_units(&self) -> bool

Check if this posting has an amount.

Trait Implementations

impl Archive for Posting

where Account: Archive, Option<IncompleteAmount>: Archive, Option<CostSpec>: Archive, Option<PriceAnnotation>: Archive, Option<char>: Archive, Metadata: Archive, Vec<String>: Archive,

const COPY_OPTIMIZATION: CopyOptimization<Self>

An optimization flag that allows the bytes of this type to be copied directly to a writer instead of calling serialize.

type Archived = ArchivedPosting

The archived representation of this type.

type Resolver = PostingResolver

The resolver for this type. It must contain all the additional information from serializing needed to make the archived type from the normal type.

fn resolve(&self, resolver: Self::Resolver, out: Place<Self::Archived>)

Creates the archived version of this value at the given position and writes it to the given output.

impl Clone for Posting

fn clone(&self) -> Posting

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Posting

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Posting

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<__D: Fallible + ?Sized> Deserialize<Posting, __D> for Archived<Posting>

where Account: Archive, <Account as Archive>::Archived: Deserialize<Account, __D>, Option<IncompleteAmount>: Archive, <Option<IncompleteAmount> as Archive>::Archived: Deserialize<Option<IncompleteAmount>, __D>, Option<CostSpec>: Archive, <Option<CostSpec> as Archive>::Archived: Deserialize<Option<CostSpec>, __D>, Option<PriceAnnotation>: Archive, <Option<PriceAnnotation> as Archive>::Archived: Deserialize<Option<PriceAnnotation>, __D>, Option<char>: Archive, <Option<char> as Archive>::Archived: Deserialize<Option<char>, __D>, Metadata: Archive, <Metadata as Archive>::Archived: Deserialize<Metadata, __D>, Vec<String>: Archive, <Vec<String> as Archive>::Archived: Deserialize<Vec<String>, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<Posting, <__D as Fallible>::Error>

Deserializes using the given deserializer

impl Display for Posting

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

Formats the value using the given formatter.

impl Eq for Posting

impl PartialEq for Posting

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

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<__S: Fallible + ?Sized> Serialize<__S> for Posting

where Account: Serialize<__S>, Option<IncompleteAmount>: Serialize<__S>, Option<CostSpec>: Serialize<__S>, Option<PriceAnnotation>: Serialize<__S>, Option<char>: Serialize<__S>, Metadata: Serialize<__S>, Vec<String>: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<Self as Archive>::Resolver, <__S as Fallible>::Error>

Writes the dependencies for the object and returns a resolver that can create the archived type.

impl ShiftSpans for Posting

fn shift_spans<F: Fn(&mut Span)>(&mut self, shift: &F)

Apply shift to every Span reachable in self.

impl StructuralPartialEq for Posting