Enum OrderStatus 

#[repr(C)]
pub enum OrderStatus {
    Initialized = 1,
    Denied = 2,
    Emulated = 3,
    Released = 4,
    Submitted = 5,
    Accepted = 6,
    Rejected = 7,
    Canceled = 8,
    Expired = 9,
    Triggered = 10,
    PendingUpdate = 11,
    PendingCancel = 12,
    PartiallyFilled = 13,
    Filled = 14,
}

The status for a specific order.

An order is considered open for the following status:

• ACCEPTED
• TRIGGERED
• PENDING_UPDATE
• PENDING_CANCEL
• PARTIALLY_FILLED

An order is considered in-flight for the following status:

• SUBMITTED
• PENDING_UPDATE
• PENDING_CANCEL

An order is considered closed for the following status:

• DENIED
• REJECTED
• CANCELED
• EXPIRED
• FILLED

Variants

Initialized = 1

The order is initialized (instantiated) within the Nautilus system.

Denied = 2

The order was denied by the Nautilus system, either for being invalid, unprocessable or exceeding a risk limit.

Emulated = 3

The order became emulated by the Nautilus system in the OrderEmulator component.

Released = 4

The order was released by the Nautilus system from the OrderEmulator component.

Submitted = 5

The order was submitted by the Nautilus system to the external service or trading venue (awaiting acknowledgement).

Accepted = 6

The order was acknowledged by the trading venue as being received and valid (may now be working).

Rejected = 7

The order was rejected by the trading venue.

Canceled = 8

The order was canceled (closed/done).

Expired = 9

The order reached a GTD expiration (closed/done).

Triggered = 10

The order STOP price was triggered on a trading venue.

PendingUpdate = 11

The order is currently pending a request to modify on a trading venue.

PendingCancel = 12

The order is currently pending a request to cancel on a trading venue.

PartiallyFilled = 13

The order has been partially filled on a trading venue.

Filled = 14

The order has been completely filled on a trading venue (closed/done).

Implementations

impl OrderStatus

pub const fn from_repr(discriminant: usize) -> Option<OrderStatus>

Try to create Self from the raw representation

impl OrderStatus

pub const fn is_open(self) -> bool

Returns whether the order status represents an open/working order.

pub const fn is_closed(self) -> bool

Returns whether the order status represents a terminal (closed) state.

pub const fn is_cancellable(self) -> bool

Returns whether the order can be cancelled from this status.

pub fn cancellable_statuses_set() -> &'static AHashSet<Self>

Returns a cached AHashSet of order statuses safe for cancellation queries.

These are statuses where an order is working on the venue but not already in the process of being cancelled or updated. Including PENDING_CANCEL in cancellation filters can cause duplicate cancel attempts or incorrect open order counts.

Returns:

• ACCEPTED: Order is working on the venue.
• TRIGGERED: Stop order has been triggered.
• PENDING_UPDATE: Order being updated.
• PARTIALLY_FILLED: Order is partially filled but still working.

Excludes:

• PENDING_CANCEL: Already being cancelled.

impl OrderStatus

pub fn transition(&mut self, event: &OrderEventAny) -> Result<Self, OrderError>

Transitions the order state machine based on the given event.

Errors

Returns an error if the state transition is invalid from the current status.

Trait Implementations

impl AsRef<str> for OrderStatus

fn as_ref(&self) -> &str

Converts this type into a shared reference of the (usually inferred) input type.

impl Clone for OrderStatus

fn clone(&self) -> OrderStatus

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for OrderStatus

impl Debug for OrderStatus

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for OrderStatus

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for OrderStatus

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

Formats the value using the given formatter.

impl Eq for OrderStatus

impl FromStr for OrderStatus

type Err = ParseError

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<OrderStatus, <Self as FromStr>::Err>

Parses a string s to return a value of this type.

impl Hash for OrderStatus

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 IntoEnumIterator for OrderStatus

type Iterator = OrderStatusIter

fn iter() -> OrderStatusIter

impl Ord for OrderStatus

fn cmp(&self, other: &OrderStatus) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for OrderStatus

fn eq(&self, other: &OrderStatus) -> 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 PartialOrd for OrderStatus

fn partial_cmp(&self, other: &OrderStatus) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Serialize for OrderStatus

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for OrderStatus

impl TryFrom<&str> for OrderStatus

type Error = ParseError

The type returned in the event of a conversion error.

fn try_from(s: &str) -> Result<OrderStatus, <Self as TryFrom<&str>>::Error>

Performs the conversion.