Struct CostSpec 

pub struct CostSpec {
    pub number: Option<CostNumber>,
    pub currency: Option<Currency>,
    pub date: Option<NaiveDate>,
    pub label: Option<String>,
    pub merge: bool,
}

A cost specification on a posting ({...} or {{...}}).

Carries the parsed cost-spec axes: the numeric component (per-unit vs total, modeled as the mutually-exclusive CostNumber enum), currency, lot date, label, and merge flag. Any subset may be missing — {} corresponds to all-fields-None plus merge: false, which lets the booker do lot matching deferred to inventory.

Pre-#1164 this struct had two independent Option<Decimal> fields (number_per, number_total). The mutual-exclusion invariant was enforced only by parser discipline; the post-booking “derived per- unit from total” state was modeled accidentally by setting both fields at once. The new shape (number: Option<CostNumber>) makes the invalid state unrepresentable and the derived state explicit.

Fields

number: Option<CostNumber>

The numeric component: per-unit, total, or absent.

Replaces the pre-#1164 number_per / number_total pair, which allowed the invalid both-set state at the type level. See CostNumber for the per-unit vs total distinction.

currency: Option<Currency>

Currency of the cost (if specified)

date: Option<NaiveDate>

Acquisition date (if specified)

label: Option<String>

Lot label (if specified)

merge: bool

Whether to merge with existing lot (average cost)

Implementations

impl CostSpec

pub fn empty() -> Self

Create an empty cost spec.

pub const fn with_number(self, number: CostNumber) -> Self

Set the cost number directly.

The mutual exclusion between per-unit and total is enforced by the CostNumber enum — there is no way to set both. Callers construct the variant explicitly:

CostSpec::empty().with_number(CostNumber::PerUnit { value: dec!(150) });
CostSpec::empty().with_number(CostNumber::Total { value: dec!(1500) });

Pre-#1164 this slot was a pair of Option<Decimal> fields; pre-this-PR there were with_per_unit / with_total convenience shims that perpetuated the two-axis mental model in caller code and silently overwrote each other if both were called. Both are gone — there’s exactly one way to set a cost number now.

pub fn with_currency(self, currency: impl Into<Currency>) -> Self

Set the currency.

pub const fn with_date(self, date: NaiveDate) -> Self

Set the date.

pub fn with_label(self, label: impl Into<String>) -> Self

Set the label.

pub const fn with_merge(self) -> Self

Set the merge flag (for average cost booking).

pub const fn is_empty(&self) -> bool

Check if this is an empty cost spec (all fields None).

pub fn matches(&self, cost: &Cost) -> bool

Check if this cost spec matches a cost.

All specified fields must match the corresponding cost fields. Per-unit matching uses CostNumber::per_unit() — a Total-only spec doesn’t constrain the per-unit lot value (booking hasn’t resolved it yet), but a PerUnitFromTotal post-booking spec does.

pub fn resolve(&self, units: Decimal, date: NaiveDate) -> Option<Cost>

Resolve this cost spec to a concrete cost, given the number of units.

If the number is CostNumber::Total, the per-unit cost is calculated as total / |units|. Full precision is preserved to avoid cost basis errors when the position is later sold. PerUnitFromTotal already carries the derived per-unit value from a prior booking pass — using b.per_unit directly is equivalent to recomputing b.total / |units| because BookedCost::new enforces that invariant at construction.

Returns None if required fields (currency, number) are missing.

Trait Implementations

impl Archive for CostSpec

where Option<CostNumber>: Archive, Option<Currency>: Archive, Map<AsNaiveDate>: ArchiveWith<Option<NaiveDate>>, Option<String>: Archive, bool: Archive,

type Archived = ArchivedCostSpec

The archived representation of this type.

type Resolver = CostSpecResolver

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 CostSpec

fn clone(&self) -> CostSpec

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for CostSpec

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

Formats the value using the given formatter.

impl Default for CostSpec

fn default() -> CostSpec

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for CostSpec

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

where Option<CostNumber>: Archive, <Option<CostNumber> as Archive>::Archived: Deserialize<Option<CostNumber>, __D>, Option<Currency>: Archive, <Option<Currency> as Archive>::Archived: Deserialize<Option<Currency>, __D>, Map<AsNaiveDate>: ArchiveWith<Option<NaiveDate>> + DeserializeWith<<Map<AsNaiveDate> as ArchiveWith<Option<NaiveDate>>>::Archived, Option<NaiveDate>, __D>, Option<String>: Archive, <Option<String> as Archive>::Archived: Deserialize<Option<String>, __D>, bool: Archive, <bool as Archive>::Archived: Deserialize<bool, __D>,

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

Deserializes using the given deserializer

impl Display for CostSpec

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

Formats the value using the given formatter.

impl Eq for CostSpec

impl Hash for CostSpec

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for CostSpec

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

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 CostSpec

where Option<CostNumber>: Serialize<__S>, Option<Currency>: Serialize<__S>, Map<AsNaiveDate>: SerializeWith<Option<NaiveDate>, __S>, Option<String>: Serialize<__S>, bool: 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 CostSpec

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

Apply shift to every Span reachable in self.

impl StructuralPartialEq for CostSpec