Struct Posting 

pub struct Posting {
    pub account: InternedStr,
    pub units: Option<IncompleteAmount>,
    pub cost: Option<CostSpec>,
    pub price: Option<PriceAnnotation>,
    pub flag: Option<char>,
    pub meta: Metadata,
}

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: InternedStr

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

Implementations

impl Posting

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

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

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

Create a new posting with an incomplete amount.

pub fn auto(account: impl Into<InternedStr>) -> 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.

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

Add a price annotation.

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

Add a flag.

pub const fn has_units(&self) -> bool

Check if this posting has an amount.

Trait Implementations

impl Archive for Posting

where AsInternedStr: ArchiveWith<InternedStr>, Option<IncompleteAmount>: Archive, Option<CostSpec>: Archive, Option<PriceAnnotation>: Archive, Option<char>: Archive, Metadata: Archive,

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.

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.

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 AsInternedStr: ArchiveWith<InternedStr> + DeserializeWith<<AsInternedStr as ArchiveWith<InternedStr>>::Archived, InternedStr, __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>,

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 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<__S: Fallible + ?Sized> Serialize<__S> for Posting

where AsInternedStr: SerializeWith<InternedStr, __S>, Option<IncompleteAmount>: Serialize<__S>, Option<CostSpec>: Serialize<__S>, Option<PriceAnnotation>: Serialize<__S>, Option<char>: Serialize<__S>, Metadata: 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 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 Eq for Posting

impl StructuralPartialEq for Posting