Skip to main content

nautilus_model/events/order/
any.rs

1// -------------------------------------------------------------------------------------------------
2//  Copyright (C) 2015-2026 Nautech Systems Pty Ltd. All rights reserved.
3//  https://nautechsystems.io
4//
5//  Licensed under the GNU Lesser General Public License Version 3.0 (the "License");
6//  You may not use this file except in compliance with the License.
7//  You may obtain a copy of the License at https://www.gnu.org/licenses/lgpl-3.0.en.html
8//
9//  Unless required by applicable law or agreed to in writing, software
10//  distributed under the License is distributed on an "AS IS" BASIS,
11//  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12//  See the License for the specific language governing permissions and
13//  limitations under the License.
14// -------------------------------------------------------------------------------------------------
15
16use std::fmt::Display;
17
18use nautilus_core::UnixNanos;
19use serde::{Deserialize, Serialize};
20use ustr::Ustr;
21
22use super::{OrderEvent, OrderEventType};
23use crate::{
24    events::{
25        OrderAccepted, OrderCancelDenied, OrderCancelRejected, OrderCanceled, OrderDenied,
26        OrderEmulated, OrderExpired, OrderFillVoided, OrderFilled, OrderInitialized,
27        OrderModifyDenied, OrderModifyRejected, OrderPendingCancel, OrderPendingUpdate,
28        OrderRejected, OrderReleased, OrderSubmitted, OrderTriggered, OrderUpdated,
29    },
30    identifiers::{AccountId, ClientOrderId, InstrumentId, StrategyId, TraderId, VenueOrderId},
31};
32
33/// Wraps an `OrderEvent` allowing polymorphism.
34#[allow(
35    clippy::large_enum_variant,
36    reason = "lint fires only with high-precision feature"
37)]
38#[derive(Clone, PartialEq, Eq, Debug, Serialize, Deserialize)]
39pub enum OrderEventAny {
40    Initialized(OrderInitialized),
41    Denied(OrderDenied),
42    Emulated(OrderEmulated),
43    Released(OrderReleased),
44    Submitted(OrderSubmitted),
45    Accepted(OrderAccepted),
46    Rejected(OrderRejected),
47    Canceled(OrderCanceled),
48    Expired(OrderExpired),
49    Triggered(OrderTriggered),
50    PendingUpdate(OrderPendingUpdate),
51    PendingCancel(OrderPendingCancel),
52    ModifyDenied(OrderModifyDenied),
53    ModifyRejected(OrderModifyRejected),
54    CancelDenied(OrderCancelDenied),
55    CancelRejected(OrderCancelRejected),
56    Updated(OrderUpdated),
57    Filled(OrderFilled),
58    FillVoided(OrderFillVoided),
59}
60
61impl OrderEventAny {
62    #[must_use]
63    pub fn into_boxed(self) -> Box<dyn OrderEvent> {
64        match self {
65            Self::Initialized(event) => Box::new(event),
66            Self::Denied(event) => Box::new(event),
67            Self::Emulated(event) => Box::new(event),
68            Self::Released(event) => Box::new(event),
69            Self::Submitted(event) => Box::new(event),
70            Self::Accepted(event) => Box::new(event),
71            Self::Rejected(event) => Box::new(event),
72            Self::Canceled(event) => Box::new(event),
73            Self::Expired(event) => Box::new(event),
74            Self::Triggered(event) => Box::new(event),
75            Self::PendingUpdate(event) => Box::new(event),
76            Self::PendingCancel(event) => Box::new(event),
77            Self::ModifyDenied(event) => Box::new(event),
78            Self::ModifyRejected(event) => Box::new(event),
79            Self::CancelDenied(event) => Box::new(event),
80            Self::CancelRejected(event) => Box::new(event),
81            Self::Updated(event) => Box::new(event),
82            Self::Filled(event) => Box::new(event),
83            Self::FillVoided(event) => Box::new(event),
84        }
85    }
86
87    #[must_use]
88    pub fn event_type(&self) -> OrderEventType {
89        match self {
90            Self::Initialized(_) => OrderEventType::Initialized,
91            Self::Denied(_) => OrderEventType::Denied,
92            Self::Emulated(_) => OrderEventType::Emulated,
93            Self::Released(_) => OrderEventType::Released,
94            Self::Submitted(_) => OrderEventType::Submitted,
95            Self::Accepted(_) => OrderEventType::Accepted,
96            Self::Rejected(_) => OrderEventType::Rejected,
97            Self::Canceled(_) => OrderEventType::Canceled,
98            Self::Expired(_) => OrderEventType::Expired,
99            Self::Triggered(_) => OrderEventType::Triggered,
100            Self::PendingUpdate(_) => OrderEventType::PendingUpdate,
101            Self::PendingCancel(_) => OrderEventType::PendingCancel,
102            Self::ModifyDenied(_) => OrderEventType::ModifyDenied,
103            Self::ModifyRejected(_) => OrderEventType::ModifyRejected,
104            Self::CancelDenied(_) => OrderEventType::CancelDenied,
105            Self::CancelRejected(_) => OrderEventType::CancelRejected,
106            Self::Updated(_) => OrderEventType::Updated,
107            Self::Filled(_) => OrderEventType::Filled,
108            Self::FillVoided(_) => OrderEventType::FillVoided,
109        }
110    }
111
112    #[must_use]
113    pub fn trader_id(&self) -> TraderId {
114        match self {
115            Self::Initialized(event) => event.trader_id,
116            Self::Denied(event) => event.trader_id,
117            Self::Emulated(event) => event.trader_id,
118            Self::Released(event) => event.trader_id,
119            Self::Submitted(event) => event.trader_id,
120            Self::Accepted(event) => event.trader_id,
121            Self::Rejected(event) => event.trader_id,
122            Self::Canceled(event) => event.trader_id,
123            Self::Expired(event) => event.trader_id,
124            Self::Triggered(event) => event.trader_id,
125            Self::PendingUpdate(event) => event.trader_id,
126            Self::PendingCancel(event) => event.trader_id,
127            Self::ModifyDenied(event) => event.trader_id,
128            Self::ModifyRejected(event) => event.trader_id,
129            Self::CancelDenied(event) => event.trader_id,
130            Self::CancelRejected(event) => event.trader_id,
131            Self::Updated(event) => event.trader_id,
132            Self::Filled(event) => event.trader_id,
133            Self::FillVoided(event) => event.trader_id,
134        }
135    }
136
137    #[must_use]
138    pub fn client_order_id(&self) -> ClientOrderId {
139        match self {
140            Self::Initialized(event) => event.client_order_id,
141            Self::Denied(event) => event.client_order_id,
142            Self::Emulated(event) => event.client_order_id,
143            Self::Released(event) => event.client_order_id,
144            Self::Submitted(event) => event.client_order_id,
145            Self::Accepted(event) => event.client_order_id,
146            Self::Rejected(event) => event.client_order_id,
147            Self::Canceled(event) => event.client_order_id,
148            Self::Expired(event) => event.client_order_id,
149            Self::Triggered(event) => event.client_order_id,
150            Self::PendingUpdate(event) => event.client_order_id,
151            Self::PendingCancel(event) => event.client_order_id,
152            Self::ModifyDenied(event) => event.client_order_id,
153            Self::ModifyRejected(event) => event.client_order_id,
154            Self::CancelDenied(event) => event.client_order_id,
155            Self::CancelRejected(event) => event.client_order_id,
156            Self::Updated(event) => event.client_order_id,
157            Self::Filled(event) => event.client_order_id,
158            Self::FillVoided(event) => event.client_order_id,
159        }
160    }
161
162    #[must_use]
163    pub fn with_client_order_id(mut self, client_order_id: ClientOrderId) -> Self {
164        match &mut self {
165            Self::Initialized(event) => event.client_order_id = client_order_id,
166            Self::Denied(event) => event.client_order_id = client_order_id,
167            Self::Emulated(event) => event.client_order_id = client_order_id,
168            Self::Released(event) => event.client_order_id = client_order_id,
169            Self::Submitted(event) => event.client_order_id = client_order_id,
170            Self::Accepted(event) => event.client_order_id = client_order_id,
171            Self::Rejected(event) => event.client_order_id = client_order_id,
172            Self::Canceled(event) => event.client_order_id = client_order_id,
173            Self::Expired(event) => event.client_order_id = client_order_id,
174            Self::Triggered(event) => event.client_order_id = client_order_id,
175            Self::PendingUpdate(event) => event.client_order_id = client_order_id,
176            Self::PendingCancel(event) => event.client_order_id = client_order_id,
177            Self::ModifyDenied(event) => event.client_order_id = client_order_id,
178            Self::ModifyRejected(event) => event.client_order_id = client_order_id,
179            Self::CancelDenied(event) => event.client_order_id = client_order_id,
180            Self::CancelRejected(event) => event.client_order_id = client_order_id,
181            Self::Updated(event) => event.client_order_id = client_order_id,
182            Self::Filled(event) => event.client_order_id = client_order_id,
183            Self::FillVoided(event) => event.client_order_id = client_order_id,
184        }
185
186        self
187    }
188
189    #[must_use]
190    pub fn venue_order_id(&self) -> Option<VenueOrderId> {
191        match self {
192            Self::Initialized(event) => event.venue_order_id(),
193            Self::Denied(event) => event.venue_order_id(),
194            Self::Emulated(event) => event.venue_order_id(),
195            Self::Released(event) => event.venue_order_id(),
196            Self::Submitted(event) => event.venue_order_id(),
197            Self::Accepted(event) => event.venue_order_id(),
198            Self::Rejected(event) => event.venue_order_id(),
199            Self::Canceled(event) => event.venue_order_id(),
200            Self::Expired(event) => event.venue_order_id(),
201            Self::Triggered(event) => event.venue_order_id(),
202            Self::PendingUpdate(event) => event.venue_order_id(),
203            Self::PendingCancel(event) => event.venue_order_id(),
204            Self::ModifyDenied(event) => event.venue_order_id(),
205            Self::ModifyRejected(event) => event.venue_order_id(),
206            Self::CancelDenied(event) => event.venue_order_id(),
207            Self::CancelRejected(event) => event.venue_order_id(),
208            Self::Updated(event) => event.venue_order_id(),
209            Self::Filled(event) => event.venue_order_id(),
210            Self::FillVoided(event) => event.venue_order_id(),
211        }
212    }
213
214    #[must_use]
215    pub fn account_id(&self) -> Option<AccountId> {
216        match self {
217            Self::Initialized(event) => event.account_id(),
218            Self::Denied(event) => event.account_id(),
219            Self::Emulated(event) => event.account_id(),
220            Self::Released(event) => event.account_id(),
221            Self::Submitted(event) => event.account_id(),
222            Self::Accepted(event) => event.account_id(),
223            Self::Rejected(event) => event.account_id(),
224            Self::Canceled(event) => event.account_id(),
225            Self::Expired(event) => event.account_id(),
226            Self::Triggered(event) => event.account_id(),
227            Self::PendingUpdate(event) => event.account_id(),
228            Self::PendingCancel(event) => event.account_id(),
229            Self::ModifyDenied(event) => event.account_id(),
230            Self::ModifyRejected(event) => event.account_id(),
231            Self::CancelDenied(event) => event.account_id(),
232            Self::CancelRejected(event) => event.account_id(),
233            Self::Updated(event) => event.account_id(),
234            Self::Filled(event) => event.account_id(),
235            Self::FillVoided(event) => event.account_id(),
236        }
237    }
238
239    #[must_use]
240    pub fn instrument_id(&self) -> InstrumentId {
241        match self {
242            Self::Initialized(event) => event.instrument_id(),
243            Self::Denied(event) => event.instrument_id(),
244            Self::Emulated(event) => event.instrument_id(),
245            Self::Released(event) => event.instrument_id(),
246            Self::Submitted(event) => event.instrument_id(),
247            Self::Accepted(event) => event.instrument_id(),
248            Self::Rejected(event) => event.instrument_id(),
249            Self::Canceled(event) => event.instrument_id(),
250            Self::Expired(event) => event.instrument_id(),
251            Self::Triggered(event) => event.instrument_id(),
252            Self::PendingUpdate(event) => event.instrument_id(),
253            Self::PendingCancel(event) => event.instrument_id(),
254            Self::ModifyDenied(event) => event.instrument_id(),
255            Self::ModifyRejected(event) => event.instrument_id(),
256            Self::CancelDenied(event) => event.instrument_id(),
257            Self::CancelRejected(event) => event.instrument_id(),
258            Self::Updated(event) => event.instrument_id(),
259            Self::Filled(event) => event.instrument_id(),
260            Self::FillVoided(event) => event.instrument_id(),
261        }
262    }
263
264    #[must_use]
265    pub fn strategy_id(&self) -> StrategyId {
266        match self {
267            Self::Initialized(event) => event.strategy_id,
268            Self::Denied(event) => event.strategy_id,
269            Self::Emulated(event) => event.strategy_id,
270            Self::Released(event) => event.strategy_id,
271            Self::Submitted(event) => event.strategy_id,
272            Self::Accepted(event) => event.strategy_id,
273            Self::Rejected(event) => event.strategy_id,
274            Self::Canceled(event) => event.strategy_id,
275            Self::Expired(event) => event.strategy_id,
276            Self::Triggered(event) => event.strategy_id,
277            Self::PendingUpdate(event) => event.strategy_id,
278            Self::PendingCancel(event) => event.strategy_id,
279            Self::ModifyDenied(event) => event.strategy_id,
280            Self::ModifyRejected(event) => event.strategy_id,
281            Self::CancelDenied(event) => event.strategy_id,
282            Self::CancelRejected(event) => event.strategy_id,
283            Self::Updated(event) => event.strategy_id,
284            Self::Filled(event) => event.strategy_id,
285            Self::FillVoided(event) => event.strategy_id,
286        }
287    }
288
289    #[must_use]
290    pub fn ts_event(&self) -> UnixNanos {
291        match self {
292            Self::Initialized(event) => event.ts_event,
293            Self::Denied(event) => event.ts_event,
294            Self::Emulated(event) => event.ts_event,
295            Self::Released(event) => event.ts_event,
296            Self::Submitted(event) => event.ts_event,
297            Self::Accepted(event) => event.ts_event,
298            Self::Rejected(event) => event.ts_event,
299            Self::Canceled(event) => event.ts_event,
300            Self::Expired(event) => event.ts_event,
301            Self::Triggered(event) => event.ts_event,
302            Self::PendingUpdate(event) => event.ts_event,
303            Self::PendingCancel(event) => event.ts_event,
304            Self::ModifyDenied(event) => event.ts_event,
305            Self::ModifyRejected(event) => event.ts_event,
306            Self::CancelDenied(event) => event.ts_event,
307            Self::CancelRejected(event) => event.ts_event,
308            Self::Updated(event) => event.ts_event,
309            Self::Filled(event) => event.ts_event,
310            Self::FillVoided(event) => event.ts_event,
311        }
312    }
313
314    #[must_use]
315    pub fn message(&self) -> Option<Ustr> {
316        match self {
317            Self::Initialized(_) => None,
318            Self::Denied(event) => Some(event.reason),
319            Self::Emulated(_) => None,
320            Self::Released(_) => None,
321            Self::Submitted(_) => None,
322            Self::Accepted(_) => None,
323            Self::Rejected(event) => Some(event.reason),
324            Self::Canceled(_) => None,
325            Self::Expired(_) => None,
326            Self::Triggered(_) => None,
327            Self::PendingUpdate(_) => None,
328            Self::PendingCancel(_) => None,
329            Self::ModifyDenied(event) => Some(event.reason),
330            Self::ModifyRejected(event) => Some(event.reason),
331            Self::CancelDenied(event) => Some(event.reason),
332            Self::CancelRejected(event) => Some(event.reason),
333            Self::Updated(_) => None,
334            Self::Filled(_) => None,
335            Self::FillVoided(event) => event.reason,
336        }
337    }
338}
339
340/// Converts an `OrderEventAny` into an `OrderFilled`.
341///
342/// # Panics
343///
344/// Panics if `event` is not a `Filled` variant.
345impl From<OrderEventAny> for OrderFilled {
346    #[inline]
347    fn from(event: OrderEventAny) -> Self {
348        match event {
349            OrderEventAny::Filled(event) => event,
350            _ => panic!("Invalid `OrderEventAny` not `OrderFilled`, was {event:?}"),
351        }
352    }
353}
354
355impl Display for OrderEventAny {
356    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
357        match self {
358            Self::Initialized(e) => write!(f, "{e}"),
359            Self::Denied(e) => write!(f, "{e}"),
360            Self::Emulated(e) => write!(f, "{e}"),
361            Self::Released(e) => write!(f, "{e}"),
362            Self::Submitted(e) => write!(f, "{e}"),
363            Self::Accepted(e) => write!(f, "{e}"),
364            Self::Rejected(e) => write!(f, "{e}"),
365            Self::Canceled(e) => write!(f, "{e}"),
366            Self::Expired(e) => write!(f, "{e}"),
367            Self::Triggered(e) => write!(f, "{e}"),
368            Self::PendingUpdate(e) => write!(f, "{e}"),
369            Self::PendingCancel(e) => write!(f, "{e}"),
370            Self::ModifyDenied(e) => write!(f, "{e}"),
371            Self::ModifyRejected(e) => write!(f, "{e}"),
372            Self::CancelDenied(e) => write!(f, "{e}"),
373            Self::CancelRejected(e) => write!(f, "{e}"),
374            Self::Updated(e) => write!(f, "{e}"),
375            Self::Filled(e) => write!(f, "{e}"),
376            Self::FillVoided(e) => write!(f, "{e}"),
377        }
378    }
379}
380
381#[cfg(test)]
382mod tests {
383    use rstest::rstest;
384
385    use super::OrderEventAny;
386    use crate::events::{OrderAccepted, OrderFilled, order::stubs::*};
387
388    #[rstest]
389    fn test_from_order_event_any_to_filled(order_filled: OrderFilled) {
390        let expected_trade_id = order_filled.trade_id;
391        let event = OrderEventAny::Filled(order_filled);
392        let filled: OrderFilled = event.into();
393        assert_eq!(filled.trade_id, expected_trade_id);
394    }
395
396    #[rstest]
397    #[should_panic(expected = "Invalid `OrderEventAny` not `OrderFilled`")]
398    fn test_from_order_event_any_to_filled_panics_on_wrong_variant(order_accepted: OrderAccepted) {
399        let event = OrderEventAny::Accepted(order_accepted);
400        let _filled: OrderFilled = event.into();
401    }
402
403    #[rstest]
404    fn test_display_delegates_to_inner(order_filled: OrderFilled) {
405        let inner_display = format!("{order_filled}");
406        let event = OrderEventAny::Filled(order_filled);
407        assert_eq!(format!("{event}"), inner_display);
408    }
409}