Struct CancelThenOpen 

#[non_exhaustive]
pub struct CancelThenOpen<ExchangeKey = ExchangeIndex, InstrumentKey = InstrumentIndex> {
    pub cancels: Vec<OrderRequestCancel<ExchangeKey, InstrumentKey>>,
    pub opens: Vec<OrderRequestOpen<ExchangeKey, InstrumentKey>>,
    pub on_cancel_failure: OnCancelFailure,
}

Cancels on one exchange, and the opens to send only once every one of them has been answered.

For a pair of requests that must not race: an exit that a resting stop would block or flip, or a stop moved to a new trigger without two ever resting at once. Requests sent separately reach the venue in no guaranteed order. A group’s opens are held back until each of its cancels has its answer, and are then sent, or dropped, as on_cancel_failure says.

What is and is not guaranteed

• Order. No open leaves before every cancel in its group has been answered. The cancels go out together, and so do the opens.
• Not atomic. Between the cancels’ answers and the opens’ arrival, nothing in the group rests: a stop being moved leaves its position unprotected for one round trip to the venue. A group of one cancel and one open that the client can send as one venue request (see ExecutionClient::cancel_replace) is sent that way, which takes that round trip out. The venue still cancels before it places, so even then the two never rest together and the open is not placed atomically with the cancel.
• Only within the group. Requests outside it, including other groups, are not ordered against it.
• A held open is in flight. It has not left yet, so a cancel sent for it while it is held reaches the venue first and finds no order, as for any open whose request is still in flight.
• One answer per leg. Each cancel is answered as a cancel sent alone would be. Each open is answered as an open sent alone would be, or, when it is dropped, with an inactive order whose error is NotPlacedReason::CancelFailed.

Valid groups

At least one cancel, at least one open, and every leg on one exchange: see exchange.

#[non_exhaustive], so a field can be added without breaking a caller. Outside this crate, build one with CancelThenOpen::new and with_on_cancel_failure.

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

cancels: Vec<OrderRequestCancel<ExchangeKey, InstrumentKey>>

The cancels to send first, together.

opens: Vec<OrderRequestOpen<ExchangeKey, InstrumentKey>>

The opens to send once every cancel has been answered.

on_cancel_failure: OnCancelFailure

What to do with the opens when a cancel fails.

#[serde(default)], so a group serialised without it loads with the safe default.

Implementations

impl<ExchangeKey, InstrumentKey> CancelThenOpen<ExchangeKey, InstrumentKey>

pub fn new( cancels: Vec<OrderRequestCancel<ExchangeKey, InstrumentKey>>, opens: Vec<OrderRequestOpen<ExchangeKey, InstrumentKey>>, ) -> Self

Send cancels, then opens once every cancel has been answered, dropping the opens if a cancel fails (OnCancelFailure::DropOpens).

pub fn with_on_cancel_failure(self, on_cancel_failure: OnCancelFailure) -> Self

Set what to do with the opens when a cancel fails.

pub fn exchange(&self) -> Result<&ExchangeKey, CancelThenOpenError>

where ExchangeKey: PartialEq,

The exchange every leg is on.

Errors

A CancelThenOpenError if the group has no cancel, has no open, or names more than one exchange.

Trait Implementations

impl<ExchangeKey: Clone, InstrumentKey: Clone> Clone for CancelThenOpen<ExchangeKey, InstrumentKey>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<ExchangeKey: Debug, InstrumentKey: Debug> Debug for CancelThenOpen<ExchangeKey, InstrumentKey>

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

Formats the value using the given formatter.

impl<'de, ExchangeKey, InstrumentKey> Deserialize<'de> for CancelThenOpen<ExchangeKey, InstrumentKey>

where ExchangeKey: 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<ExchangeKey: Eq, InstrumentKey: Eq> Eq for CancelThenOpen<ExchangeKey, InstrumentKey>

impl<ExchangeKey: Hash, InstrumentKey: Hash> Hash for CancelThenOpen<ExchangeKey, InstrumentKey>

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<ExchangeKey: Ord, InstrumentKey: Ord> Ord for CancelThenOpen<ExchangeKey, InstrumentKey>

fn cmp(&self, other: &Self) -> 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.

fn clamp_to<R>(self, range: R) -> Self

where Self: Sized, R: ClampBounds<Self>,

🔬This is a nightly-only experimental API. (clamp_to)

Restrict a value to a certain range.

impl<ExchangeKey: PartialEq, InstrumentKey: PartialEq> PartialEq for CancelThenOpen<ExchangeKey, InstrumentKey>

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

Equality operator ==.

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

Inequality operator !=.

impl<ExchangeKey: PartialOrd, InstrumentKey: PartialOrd> PartialOrd for CancelThenOpen<ExchangeKey, InstrumentKey>

fn partial_cmp(&self, other: &Self) -> 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<ExchangeKey, InstrumentKey> Serialize for CancelThenOpen<ExchangeKey, InstrumentKey>

where ExchangeKey: 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<ExchangeKey: PartialEq, InstrumentKey: PartialEq> StructuralPartialEq for CancelThenOpen<ExchangeKey, InstrumentKey>