Enum architect_api::protocol::orderflow::OrderAckProblem

#[repr(u64)]
pub enum OrderAckProblem {
    AckForUnknownOrder,
    DuplicateAck,
    AckForFilledOrder,
    AckForOutedOrder,
    CantParseAckResponse,
    UnknownAckProblem,
}

The list of problems that make an order ack aberrant

Variants

AckForUnknownOrder

We received an ack for an order we didn’t send

DuplicateAck

We received more than one ack for an order. Depending on the counterparty this may be ok, we will only generate an aberrant ack if we know it isn’t ok.

AckForFilledOrder

We received an ack for a filled order

AckForOutedOrder

We received an ack for an outed order

CantParseAckResponse

We received an ack, but we can’t fully parse it

UnknownAckProblem

We don’t even know what went wrong. This is mostly for protocol compatibility enhancement.

Trait Implementations

impl BitAnd<OrderAckProblem> for OrderAckProblem

type Output = BitFlags<OrderAckProblem, <OrderAckProblem as RawBitFlags>::Numeric>

The resulting type after applying the & operator.

fn bitand(self, other: Self) -> Self::Output

Performs the & operation.

impl BitFlag for OrderAckProblem

fn empty() -> BitFlags<Self, Self::Numeric>

Create a BitFlags with no flags set (in other words, with a value of 0).

fn all() -> BitFlags<Self, Self::Numeric>

Create a BitFlags with all flags set.

impl BitOr<OrderAckProblem> for OrderAckProblem

type Output = BitFlags<OrderAckProblem, <OrderAckProblem as RawBitFlags>::Numeric>

The resulting type after applying the | operator.

fn bitor(self, other: Self) -> Self::Output

Performs the | operation.

impl BitXor<OrderAckProblem> for OrderAckProblem

type Output = BitFlags<OrderAckProblem, <OrderAckProblem as RawBitFlags>::Numeric>

The resulting type after applying the ^ operator.

fn bitxor(self, other: Self) -> Self::Output

Performs the ^ operation.

impl Clone for OrderAckProblem

fn clone(&self) -> OrderAckProblem

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for OrderAckProblem

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

Formats the value using the given formatter.

impl Hash for OrderAckProblem

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 Not for OrderAckProblem

type Output = BitFlags<OrderAckProblem, <OrderAckProblem as RawBitFlags>::Numeric>

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl PartialEq<OrderAckProblem> for OrderAckProblem

fn eq(&self, other: &OrderAckProblem) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl RawBitFlags for OrderAckProblem

type Numeric = u64

The underlying integer type.

const EMPTY: Self::Numeric = {transmute(0x0000000000000000): <protocol::orderflow::OrderAckProblem as enumflags2::_internal::RawBitFlags>::Numeric}

A value with no bits set.

const DEFAULT: Self::Numeric = {transmute(0x0000000000000000): <protocol::orderflow::OrderAckProblem as enumflags2::_internal::RawBitFlags>::Numeric}

The value used by the Default implementation. Equivalent to EMPTY, unless customized.

const ALL_BITS: Self::Numeric = {transmute(0x000000000000003f): <protocol::orderflow::OrderAckProblem as enumflags2::_internal::RawBitFlags>::Numeric}

A value with all flag bits set.

const BITFLAGS_TYPE_NAME: &'static str = _

The name of the type for debug formatting purposes.

fn bits(self) -> Self::Numeric

Return the bits as a number type.

impl Copy for OrderAckProblem

impl Eq for OrderAckProblem

impl StructuralEq for OrderAckProblem

impl StructuralPartialEq for OrderAckProblem