Struct Inventory 

pub struct Inventory { /* private fields */ }

An inventory is a collection of positions.

It tracks all positions for an account and supports booking operations for adding and reducing positions.

Examples

use rustledger_core::{Inventory, Position, Amount, Cost, BookingMethod};
use rust_decimal_macros::dec;

let mut inv = Inventory::new();

// Add a simple position
inv.add(Position::simple(Amount::new(dec!(100), "USD")));
assert_eq!(inv.units("USD"), dec!(100));

// Add a position with cost
let cost = Cost::new(dec!(150.00), "USD");
inv.add(Position::with_cost(Amount::new(dec!(10), "AAPL"), cost));
assert_eq!(inv.units("AAPL"), dec!(10));

Implementations

impl Inventory

pub fn new() -> Self

Create an empty inventory.

pub fn positions(&self) -> &[Position]

Get all positions.

pub fn positions_mut(&mut self) -> &mut Vec<Position>

Get mutable access to all positions.

pub fn is_empty(&self) -> bool

Check if inventory is empty.

pub fn len(&self) -> usize

Get the number of positions (including empty ones).

pub fn units(&self, currency: &str) -> Decimal

Get total units of a currency (ignoring cost lots).

This sums all positions of the given currency regardless of cost basis.

pub fn currencies(&self) -> Vec<&str>

Get all currencies in this inventory.

pub fn book_value(&self, units_currency: &str) -> HashMap<InternedStr, Decimal>

Get the total book value (cost basis) for a currency.

Returns the sum of all cost bases for positions of the given currency.

pub fn add(&mut self, position: Position)

Add a position to the inventory.

For positions with cost, this creates a new lot. For positions without cost, this merges with existing positions of the same currency using O(1) HashMap lookup.

pub fn reduce( &mut self, units: &Amount, cost_spec: Option<&CostSpec>, method: BookingMethod, ) -> Result<BookingResult, BookingError>

Reduce positions from the inventory using the specified booking method.

Arguments

• units - The units to reduce (negative for selling)
• cost_spec - Optional cost specification for matching lots
• method - The booking method to use

Returns

Returns a BookingResult with the matched positions and cost basis, or a BookingError if the reduction cannot be performed.

pub fn compact(&mut self)

Remove all empty positions.

pub fn merge(&mut self, other: &Self)

Merge this inventory with another.

pub fn at_cost(&self) -> Self

Convert inventory to cost basis.

Returns a new inventory where all positions are converted to their cost basis. Positions without cost are returned as-is.

pub fn at_units(&self) -> Self

Convert inventory to units only.

Returns a new inventory where all positions have their cost removed, effectively aggregating by currency only.

Trait Implementations

impl Archive for Inventory

where Vec<Position>: Archive, Skip: ArchiveWith<HashMap<InternedStr, usize>>,

type Archived = ArchivedInventory

The archived representation of this type.

type Resolver = InventoryResolver

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 Inventory

fn clone(&self) -> Inventory

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Inventory

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

Formats the value using the given formatter.

impl Default for Inventory

fn default() -> Inventory

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Inventory

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

where Vec<Position>: Archive, <Vec<Position> as Archive>::Archived: Deserialize<Vec<Position>, __D>, Skip: ArchiveWith<HashMap<InternedStr, usize>> + DeserializeWith<<Skip as ArchiveWith<HashMap<InternedStr, usize>>>::Archived, HashMap<InternedStr, usize>, __D>,

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

Deserializes using the given deserializer

impl Display for Inventory

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

Formats the value using the given formatter.

impl FromIterator<Position> for Inventory

fn from_iter<I: IntoIterator<Item = Position>>(iter: I) -> Self

Creates a value from an iterator.

impl PartialEq for Inventory

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

where Vec<Position>: Serialize<__S>, Skip: SerializeWith<HashMap<InternedStr, usize>, __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 Inventory

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 Inventory