Enum IncompleteAmount 

pub enum IncompleteAmount {
    Complete(Amount),
    NumberOnly(Decimal),
    CurrencyOnly(InternedStr),
}

An incomplete amount specification used in postings before interpolation.

In Beancount, postings can have incomplete amount specifications that will be filled in by the interpolation algorithm:

• 100.00 USD - Complete amount
• USD - Currency only, number to be interpolated
• 100.00 - Number only, currency to be inferred
• (nothing) - Entire amount to be interpolated

This type represents all these cases before the interpolation phase.

Variants

Complete(Amount)

Complete amount with both number and currency

NumberOnly(Decimal)

Only number specified, currency to be inferred from context (cost, price, or other postings)

CurrencyOnly(InternedStr)

Only currency specified, number to be interpolated to balance the transaction

Implementations

impl IncompleteAmount

pub fn complete(number: Decimal, currency: impl Into<InternedStr>) -> Self

Create a complete amount.

pub const fn number_only(number: Decimal) -> Self

Create a number-only incomplete amount.

pub fn currency_only(currency: impl Into<InternedStr>) -> Self

Create a currency-only incomplete amount.

pub const fn number(&self) -> Option<Decimal>

Get the number if present.

pub fn currency(&self) -> Option<&str>

Get the currency if present.

pub const fn is_complete(&self) -> bool

Check if this is a complete amount.

pub const fn as_amount(&self) -> Option<&Amount>

Get as a complete Amount if possible.

pub fn into_amount(self) -> Option<Amount>

Convert to a complete Amount, consuming self.

Trait Implementations

impl Archive for IncompleteAmount

where Amount: Archive, AsDecimal: ArchiveWith<Decimal>, AsInternedStr: ArchiveWith<InternedStr>,

type Archived = ArchivedIncompleteAmount

The archived representation of this type.

type Resolver = IncompleteAmountResolver

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 as Archive>::Resolver, out: Place<<Self as Archive>::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 IncompleteAmount

fn clone(&self) -> IncompleteAmount

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for IncompleteAmount

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for IncompleteAmount

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<IncompleteAmount, __D> for Archived<IncompleteAmount>

where Amount: Archive, <Amount as Archive>::Archived: Deserialize<Amount, __D>, AsDecimal: ArchiveWith<Decimal> + DeserializeWith<<AsDecimal as ArchiveWith<Decimal>>::Archived, Decimal, __D>, AsInternedStr: ArchiveWith<InternedStr> + DeserializeWith<<AsInternedStr as ArchiveWith<InternedStr>>::Archived, InternedStr, __D>,

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

Deserializes using the given deserializer

impl Display for IncompleteAmount

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

Formats the value using the given formatter.

impl From<Amount> for IncompleteAmount

fn from(amount: Amount) -> Self

Converts to this type from the input type.

impl PartialEq for IncompleteAmount

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

where Amount: Serialize<__S>, AsDecimal: SerializeWith<Decimal, __S>, AsInternedStr: SerializeWith<InternedStr, __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 IncompleteAmount

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 IncompleteAmount

impl StructuralPartialEq for IncompleteAmount