Enum DataError 

#[non_exhaustive]
pub enum DataError {
    Index(IndexError),
    SubscriptionsEmpty,
    UnsupportedSubKind(SubKind),
    InitialSnapshotMissing(SubscriptionId),
    InitialSnapshotInvalid(String),
    Socket(String),
    Databento {
        kind: DatabentoErrorKind,
        context: String,
        message: String,
    },
    Lse {
        kind: LseErrorKind,
        message: String,
    },
    Unsupported {
        exchange: ExchangeId,
        sub_kind: SubKind,
    },
    SubscriberRequired {
        exchange: ExchangeId,
    },
    FeatureDisabled {
        exchange: ExchangeId,
        feature: String,
    },
    UnsupportedInterval {
        exchange: ExchangeId,
        interval: CandleInterval,
    },
    InvalidSequence {
        prev_last_update_id: u64,
        first_update_id: u64,
    },
    SubscriptionsUnacknowledged {
        reason: String,
        unacknowledged: Vec<SubscriptionId>,
    },
    ReinitFailed {
        attempt: u32,
        error: Box<DataError>,
    },
}

All errors generated in rustrade-data.

Non-exhaustive

Variants are added as integrations land, and two of the existing ones (Databento, Lse — not linked: each is behind its own feature, and this block is not) appear only under that feature, so the variant set a downstream match sees already depends on the feature selection it built with. A wildcard arm is required either way; #[non_exhaustive] makes that a compile-time contract rather than something a consumer discovers when a feature flag or a release moves. Matches within this crate stay exhaustively checked.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Index(IndexError)

SubscriptionsEmpty

UnsupportedSubKind(SubKind)

InitialSnapshotMissing(SubscriptionId)

InitialSnapshotInvalid(String)

Socket(String)

Databento

Databento-specific error with categorized kind for programmatic handling.

Fields

kind: DatabentoErrorKind

context: String

message: String

Lse

A London Strategic Edge integration error, flattened into this crate’s common error type.

LseError carries a reqwest::Error, which is neither Clone nor serialisable, so it cannot be nested here structurally. Callers wanting the full cause should handle LseError at the call site; this variant exists so an LSE-sourced stream can compose with the crate’s generic stream helpers. Same flattening as Socket applies to SocketError.

kind survives that flattening, so a consumer can still tell a resumable RateLimit from a terminal Decode without substring-matching message — which is the only thing a bare String left it. Same shape as the Databento variant (not linked: it is behind the databento feature, which this variant is not).

Fields

kind: LseErrorKind

message: String

Unsupported

Fields

exchange: ExchangeId

sub_kind: SubKind

SubscriberRequired

A dynamic subscription names a venue whose subscriber must be built by the caller — usually because it carries credentials — and none was supplied. See DynamicSubscribers.

Fields

exchange: ExchangeId

FeatureDisabled

The venue serves the subscription, but this build was compiled without the cargo feature that carries its integration.

Fields

exchange: ExchangeId

feature: String

UnsupportedInterval

Fields

exchange: ExchangeId

interval: CandleInterval

InvalidSequence

Fields

prev_last_update_id: u64

first_update_id: u64

SubscriptionsUnacknowledged

Subscription validation ended before every subscription in a batch was acknowledged.

unacknowledged holds the SubscriptionIds that received no acknowledgement, sorted. They are candidates, not proof of rejection: a venue that closes the connection on one bad subscription also leaves those sent after it unanswered. Venues whose acknowledgements cannot be matched to subscriptions (one acknowledgement per batch, or one that does not echo the subscription) report the whole batch.

A subscription’s identifier is ExchangeSub::new(&subscription).id() — see ExchangeSub.

Fields

reason: String

unacknowledged: Vec<SubscriptionId>

ReinitFailed

A started stream failed to re-initialise after it ended, and will retry after its backoff.

Yielded once per failed attempt. attempt counts consecutive failures since the stream last initialised, starting at 1, so a caller can tell a slow reconnect from one that keeps failing — for example a subscription the venue no longer accepts, reported as SubscriptionsUnacknowledged in error. The stream keeps retrying; giving up is the caller’s decision.

Fields

attempt: u32

error: Box<DataError>

Implementations

impl DataError

pub fn is_terminal(&self) -> bool

Determine if an error requires a MarketStream to re-initialise.

Trait Implementations

impl Clone for DataError

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for DataError

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for DataError

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for DataError

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

Formats the value using the given formatter.

impl Eq for DataError

impl Error for DataError

fn source(&self) -> Option<&(dyn Error + 'static)>

Returns the lower-level source of this error, if any.

fn description(&self) -> &str

👎Deprecated since 1.42.0:

use the Display impl or to_string()

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0:

replaced by Error::source, which can support downcasting

fn provide<'a>(&'a self, request: &mut Request<'a>)

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

Provides type-based access to context intended for error reports.

impl From<IndexError> for DataError

fn from(source: IndexError) -> Self

Converts to this type from the input type.

impl From<LseError> for DataError

Available on crate feature lse only.

fn from(value: LseError) -> Self

Converts to this type from the input type.

impl From<MassiveError> for DataError

fn from(err: MassiveError) -> Self

Converts to this type from the input type.

impl From<SocketError> for DataError

fn from(value: SocketError) -> Self

Converts to this type from the input type.

impl Hash for DataError

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 Ord for DataError

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 PartialEq for DataError

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

Equality operator ==.

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

Inequality operator !=.

impl PartialOrd for DataError

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 Serialize for DataError

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 DataError