Struct PositionManager 

pub struct PositionManager<AssetKey = AssetIndex, InstrumentKey = InstrumentIndex> {
    pub mode: OmsMode,
    pub positions: IndexMap<PositionId, Position<AssetKey, InstrumentKey>>,
}

Manages open positions for a single instrument.

Supports two OMS modes (configurable at construction):

• Netting (default): at most one entry; same flip/close logic as before.
• Hedging: multiple concurrent entries, keyed by PositionId.

Fields

mode: OmsMode

positions: IndexMap<PositionId, Position<AssetKey, InstrumentKey>>

All currently open positions keyed by PositionId.

Implementations

impl<AssetKey, InstrumentKey> PositionManager<AssetKey, InstrumentKey>

pub fn new(mode: OmsMode) -> Self

Construct a new PositionManager with the given OMS mode and no open positions.

impl<AssetKey: Debug + Clone, InstrumentKey> PositionManager<AssetKey, InstrumentKey>

pub fn update_from_trade( &mut self, trade: &Trade<AssetKey, InstrumentKey>, contract_size: Decimal, ) -> Option<PositionExited<AssetKey, InstrumentKey>>

where InstrumentKey: Debug + Clone + PartialEq,

Updates the current position state based on a new trade.

This method handles:

• Opening a new position if none exists
• Updating an existing position (increase/decrease/close)
• Handling position flips (close existing & open new with any remaining trade quantity)

In Netting mode the PositionId is derived deterministically as "netting". In Hedging mode the PositionId is derived from trade.order_id.

Warning — Hedging mode callers

In OmsMode::Hedging, this method derives the PositionId directly from trade.order_id. The engine’s actual fill routing instead resolves the PositionId via a ClientOrderId → PositionId lookup table populated at order submission time (see InstrumentState::update_from_trade). Calling this method directly in Hedging mode bypasses that lookup and will open a spurious position slot under the exchange order ID rather than the caller’s chosen PositionId. Prefer routing fills through InstrumentState::update_from_trade, or call update_from_trade_with_id with the already-resolved PositionId.

Arguments

• trade - The trade to process
• contract_size - Contract multiplier for derivatives (1 for spot, 100 for standard options)

pub fn update_from_trade_with_id( &mut self, trade: &Trade<AssetKey, InstrumentKey>, position_id: &PositionId, contract_size: Decimal, ) -> Option<PositionExited<AssetKey, InstrumentKey>>

where InstrumentKey: Debug + Clone + PartialEq,

Updates position state routing to a specific PositionId.

Suitable for callers (e.g. expiry settlement) that have already resolved the correct PositionId and want to bypass the automatic derivation.

Arguments

• trade - The trade to process
• position_id - The resolved position ID to route the fill to
• contract_size - Contract multiplier for derivatives (1 for spot, 100 for standard options)

Fee model

This method does not apply a fee model — trade.fees.fees is used as-is. The caller is responsible for ensuring the fee value is correct before calling. For contract expiry settlement the caller must set fees to Decimal::ZERO (exchange settlement commission, if any, is not modelled and must be tracked separately).

Trait Implementations

impl<AssetKey: Clone, InstrumentKey: Clone> Clone for PositionManager<AssetKey, InstrumentKey>

fn clone(&self) -> PositionManager<AssetKey, InstrumentKey>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<AssetKey: Debug, InstrumentKey: Debug> Debug for PositionManager<AssetKey, InstrumentKey>

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

Formats the value using the given formatter.

impl<AssetKey, InstrumentKey> Default for PositionManager<AssetKey, InstrumentKey>

fn default() -> Self

Returns the “default value” for a type.

impl<'de, AssetKey, InstrumentKey> Deserialize<'de> for PositionManager<AssetKey, InstrumentKey>

where AssetKey: Deserialize<'de>, InstrumentKey: Deserialize<'de>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<AssetKey: PartialEq, InstrumentKey: PartialEq> PartialEq for PositionManager<AssetKey, InstrumentKey>

fn eq(&self, other: &PositionManager<AssetKey, InstrumentKey>) -> 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<AssetKey, InstrumentKey> Serialize for PositionManager<AssetKey, InstrumentKey>

where AssetKey: Serialize, InstrumentKey: Serialize,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<AssetKey: PartialEq, InstrumentKey: PartialEq> StructuralPartialEq for PositionManager<AssetKey, InstrumentKey>