pricelevel 0.7.0

A high-performance, lock-free price level implementation for limit order books in Rust. This library provides the building blocks for creating efficient trading systems with support for multiple order types and concurrent access patterns.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82

use crate::errors::PriceLevelError;
use serde::{Deserialize, Serialize};
use std::str::FromStr;

/// Represents the current status of an order in the system
#[repr(u8)]
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
pub enum OrderStatus {
    /// Order has been created but not yet processed
    New,

    /// Order is active in the order book
    Active,

    /// Order has been partially filled
    PartiallyFilled,

    /// Order has been completely filled
    Filled,

    /// Order has been canceled by the user
    Canceled,

    /// Order has been rejected by the system
    Rejected,

    /// Order has expired (for time-bounded orders)
    Expired,
}

impl OrderStatus {
    /// Returns true if the order is still active in the book
    #[allow(dead_code)]
    #[must_use]
    pub fn is_active(&self) -> bool {
        matches!(self, Self::Active | Self::PartiallyFilled)
    }

    /// Returns true if the order has been terminated
    /// (filled, canceled, rejected, or expired)
    #[allow(dead_code)]
    #[must_use]
    pub fn is_terminated(&self) -> bool {
        matches!(
            self,
            Self::Filled | Self::Canceled | Self::Rejected | Self::Expired
        )
    }
}

impl FromStr for OrderStatus {
    type Err = PriceLevelError;

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        match s.to_uppercase().as_str() {
            "NEW" => Ok(OrderStatus::New),
            "ACTIVE" => Ok(OrderStatus::Active),
            "PARTIALLYFILLED" => Ok(OrderStatus::PartiallyFilled),
            "FILLED" => Ok(OrderStatus::Filled),
            "CANCELED" => Ok(OrderStatus::Canceled),
            "REJECTED" => Ok(OrderStatus::Rejected),
            "EXPIRED" => Ok(OrderStatus::Expired),
            _ => Err(PriceLevelError::ParseError {
                message: format!("Invalid OrderStatus: {s}"),
            }),
        }
    }
}

impl std::fmt::Display for OrderStatus {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            OrderStatus::New => write!(f, "NEW"),
            OrderStatus::Active => write!(f, "ACTIVE"),
            OrderStatus::PartiallyFilled => write!(f, "PARTIALLYFILLED"),
            OrderStatus::Filled => write!(f, "FILLED"),
            OrderStatus::Canceled => write!(f, "CANCELED"),
            OrderStatus::Rejected => write!(f, "REJECTED"),
            OrderStatus::Expired => write!(f, "EXPIRED"),
        }
    }
}