Struct CostSpec 

pub struct CostSpec {
    pub number_per: Option<Decimal>,
    pub number_total: Option<Decimal>,
    pub currency: Option<InternedStr>,
    pub date: Option<NaiveDate>,
    pub label: Option<String>,
    pub merge: bool,
}

A cost specification for matching or creating costs.

Unlike Cost, all fields are optional to allow partial matching. This is used in postings where the user may specify only some cost components (e.g., just the date to match a specific lot).

Matching Rules

A CostSpec matches a Cost if all specified fields match:

• If number is Some, it must equal the cost’s number
• If currency is Some, it must equal the cost’s currency
• If date is Some, it must equal the cost’s date
• If label is Some, it must equal the cost’s label

Examples

use rustledger_core::{Cost, CostSpec};
use rust_decimal_macros::dec;
use chrono::NaiveDate;

let cost = Cost::new(dec!(150.00), "USD")
    .with_date(NaiveDate::from_ymd_opt(2024, 1, 15).unwrap());

// Match by date only
let spec = CostSpec::default().with_date(NaiveDate::from_ymd_opt(2024, 1, 15).unwrap());
assert!(spec.matches(&cost));

// Match by wrong date
let spec2 = CostSpec::default().with_date(NaiveDate::from_ymd_opt(2024, 1, 16).unwrap());
assert!(!spec2.matches(&cost));

Fields

number_per: Option<Decimal>

Cost per unit (if specified)

number_total: Option<Decimal>

Total cost (if specified) - alternative to number_per

currency: Option<InternedStr>

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_per(self, number: Decimal) -> Self

Set the per-unit cost.

pub const fn with_number_total(self, number: Decimal) -> Self

Set the total cost.

pub fn with_currency(self, currency: impl Into<InternedStr>) -> 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.

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

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

If number_total is specified, the per-unit cost is calculated as number_total / units. Full precision is preserved to avoid cost basis errors when the position is later sold.

Returns None if required fields (currency) are missing.

Trait Implementations

impl Archive for CostSpec

where Map<AsDecimal>: ArchiveWith<Option<Decimal>>, Map<AsInternedStr>: ArchiveWith<Option<InternedStr>>, 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 Map<AsDecimal>: ArchiveWith<Option<Decimal>> + DeserializeWith<<Map<AsDecimal> as ArchiveWith<Option<Decimal>>>::Archived, Option<Decimal>, __D>, Map<AsInternedStr>: ArchiveWith<Option<InternedStr>> + DeserializeWith<<Map<AsInternedStr> as ArchiveWith<Option<InternedStr>>>::Archived, Option<InternedStr>, __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 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<__S: Fallible + ?Sized> Serialize<__S> for CostSpec

where Map<AsDecimal>: SerializeWith<Option<Decimal>, __S>, Map<AsInternedStr>: SerializeWith<Option<InternedStr>, __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 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 Eq for CostSpec

impl StructuralPartialEq for CostSpec