Enum architect_api::protocol::limits::LimitScope

pub enum LimitScope {
    Global,
    Venue(Venue),
    Route(Route),
    Product(Product),
    ProductDefault,
    TradableProduct(TradableProduct),
    TradableProductDefault,
}

Each LimitSet contains a full set of LimitScopes

which are different ways of aggregating limits within that set. For example, Global applies to the entire set. Venue applies to trading in a specific venue within the set.

ProductDefault and TradableProductDefault sets the default limit for a product within the set. If a specific limit is set for a product then it overrides the default limit, but if no limit is set for a given product then it will use the default.

Positions and open interest also aggregate by scopes.

Variants

Global

All the trading in this aggregate

Venue(Venue)

All the trading on the specified venue

Route(Route)

All the trading to any venue via the specified route

Product(Product)

All the trading in the specified product

ProductDefault

The default product limit if none is specified

TradableProduct(TradableProduct)

All the trading in the specified tradable product

TradableProductDefault

The default tradable product limit if none is specified

Implementations

impl LimitScope

pub fn is_valid(&self) -> bool

true if there are no unknown/invalid symbols

Trait Implementations

impl Clone for LimitScope

fn clone(&self) -> LimitScope

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for LimitScope

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for LimitScope

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl FromValue for LimitScope

fn from_value(v: Value) -> Result<Self>

attempt to cast v to the type of self using any reasonable means

fn get(v: Value) -> Option<Self>where Self: Sized,

extract the type of self from v if the type of v is equivelent to the type of self, otherwise return None.

impl Hash for LimitScope

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 Into<Value> for LimitScope

fn into(self) -> Value

Converts this type into the (usually inferred) input type.

impl JsonSchema for LimitScope

fn schema_name() -> String

The name of the generated JSON Schema.

fn json_schema(gen: &mut SchemaGenerator) -> Schema

Generates a JSON Schema for this type.

fn is_referenceable() -> bool

Whether JSON Schemas generated for this type should be re-used where possible using the $ref keyword.

impl Pack for LimitScope

fn encoded_len(&self) -> usize

fn encode(&self, buf: &mut impl BufMut) -> Result<(), PackError>

fn decode(buf: &mut impl Buf) -> Result<Self, PackError>

fn const_encoded_len() -> Option<usize>

fn decode_into(&mut self, buf: &mut impl Buf) -> Result<(), PackError>where Self: Sized,

impl PartialEq<LimitScope> for LimitScope

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

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Copy for LimitScope

impl Eq for LimitScope

impl StructuralEq for LimitScope

impl StructuralPartialEq for LimitScope