Struct Lse 

pub struct Lse<Server>(/* private fields */);

The London Strategic Edge live market data connector.

Use the per-dataset aliases — LseFx, LseCrypto, LseEquities, LseFutures, LseCfd, LseOptions — rather than naming the server type directly.

Trait Implementations

impl<Server: Clone> Clone for Lse<Server>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<Server> Connector for Lse<Server>

where Server: LseServer,

fn requests( exchange_subs: Vec<ExchangeSub<Self::Channel, Self::Market>>, ) -> Vec<WsMessage>

One payload per symbol — the provider accepts no batched subscribe.

⚠️ Nothing sends what this builds

LseSubscriber does not call this: a subscription may carry a replay window and this function cannot see one, so the subscriber builds its own payloads and the mapper’s output is discarded where it does so. This is required by the Connector contract and is implemented faithfully; it is not the route this integration subscribes over.

It shares subscribe_message with the live route, so the two cannot disagree about a payload’s shape. They do differ in what they are given: this receives one entry per subscription, while the subscriber sends one per distinct symbol, because a repeated symbol is one slot and one confirmation on this provider.

On LseOptions it sends one payload per distinct underlying, as the subscriber does. A contract with no OSI symbol has no underlying to name and is left out; the live route rejects the batch over it instead, which this infallible signature cannot.

fn expected_responses<InstrumentKey>(map: &Map<InstrumentKey>) -> usize

One confirmation per distinct symbol — or, on LseOptions, per distinct underlying.

The instrument map holds one entry per registered contract, but the provider confirms an underlying once however many of its contracts are registered, so counting entries would leave the validator waiting out its timeout for confirmations that never come.

const ID: ExchangeId = Server::ID

Unique identifier for the exchange server being connected with.

type Channel = LseChannel

Type that defines how to translate a Barter Subscription into an exchange specific channel to be subscribed to.

type Market = LseMarket

Type that defines how to translate a Barter Subscription into an exchange specific market that can be subscribed to.

type Subscriber = LseSubscriber

Subscriber type that establishes a connection with the exchange server, and actions Subscriptions over the socket.

type SubValidator = WebSocketSubValidator

SubscriptionValidator type that listens to responses from the exchange server and validates if the actioned Subscriptions were successful.

type SubResponse = LseSubResponse

Deserialisable type that the Self::SubValidator expects to receive from the exchange server in response to the Subscription Self::requests sent over the WebSocket. Implements Validator in order to determine if Self communicates a successful Subscription outcome.

fn url() -> Result<Url, ParseError>

Base Url of the exchange server being connected with.

fn ping_interval() -> Option<PingInterval>

Defines PingInterval of custom application-level WebSocket pings for the exchange server being connected with.

fn acknowledged_subscription( _response: &Self::SubResponse, ) -> Option<SubscriptionId>

The subscription a successful Self::SubResponse acknowledges, as the SubscriptionId the mapper keyed it under.

fn subscription_timeout() -> Duration

Expected Duration the SubscriptionValidator will wait to receive all success responses to actioned Subscription requests.

impl<Server: Copy> Copy for Lse<Server>

impl<Server: Debug> Debug for Lse<Server>

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

Formats the value using the given formatter.

impl<Server: Default> Default for Lse<Server>

fn default() -> Self

Returns the “default value” for a type.

impl<'de, Server> Deserialize<'de> for Lse<Server>

where Server: ExchangeServer,

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

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<Server: Eq> Eq for Lse<Server>

impl<Server: Hash> Hash for Lse<Server>

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<Server: Ord> Ord for Lse<Server>

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<Server: PartialEq> PartialEq for Lse<Server>

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

Equality operator ==.

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

Inequality operator !=.

impl<Server: PartialOrd> PartialOrd for Lse<Server>

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<Server> Serialize for Lse<Server>

where Server: ExchangeServer,

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

where S: Serializer,

Serialize this value into the given Serde serializer.

impl<Instrument, Server> StreamSelector<Instrument, OrderBooksL1> for Lse<Server>

where Instrument: InstrumentData, Server: LseQuoteServer + Debug + Send + Sync,

type SnapFetcher = NoInitialSnapshots

type Stream = SharedStream<LseAttachment, LseTransformer<Lse<Server>, <Instrument as InstrumentData>::Key, OrderBooksL1>>

impl<Instrument, Server> StreamSelector<Instrument, PublicTrades> for Lse<Server>

where Instrument: InstrumentData, Server: LseServer + Debug + Send + Sync,

type SnapFetcher = NoInitialSnapshots

type Stream = SharedStream<LseAttachment, LseTransformer<Lse<Server>, <Instrument as InstrumentData>::Key, PublicTrades>>

impl<Server: PartialEq> StructuralPartialEq for Lse<Server>