Enum LimitsError 

pub enum LimitsError {
    EmptyByteSize(String),
    UnknownByteUnit {
        unit: String,
    },
    BadByteMagnitude(String),
    NonIntegerByteMagnitude {
        value: String,
    },
    LeadingZeroByteMagnitude {
        value: String,
    },
    WhitespaceInByteSize {
        value: String,
        byte: u8,
    },
    NonAsciiWhitespaceInByteSize {
        value: String,
        ch: char,
        codepoint: u32,
    },
    EmptyDuration(String),
    UnknownDurationUnit {
        unit: String,
    },
    BadDurationMagnitude(String),
    NonIntegerDurationMagnitude {
        value: String,
    },
    LeadingZeroDurationMagnitude {
        value: String,
    },
    WhitespaceInDuration {
        value: String,
        byte: u8,
    },
    NonAsciiWhitespaceInDuration {
        value: String,
        ch: char,
        codepoint: u32,
    },
    BadMillicores(String),
    NonIntegerMillicoreMagnitude {
        value: String,
    },
    LeadingZeroMillicoreMagnitude {
        value: String,
    },
    WhitespaceInMillicores {
        value: String,
        byte: u8,
    },
    NonAsciiWhitespaceInMillicores {
        value: String,
        ch: char,
        codepoint: u32,
    },
    MemoryZero,
    MemoryBelowWasm32Page {
        bytes: u64,
    },
    MemoryExceedsWasm32Cap {
        bytes: u64,
    },
    MemoryNotPageMultiple {
        bytes: u64,
    },
    FuelZero,
    FuelExceedsCap {
        fuel: u64,
    },
    WallClockZero,
    WallClockNotCanonical {
        wall_clock: Duration,
    },
    WallClockExceedsCap {
        wall_clock: Duration,
    },
    CpuZero,
    CpuExceedsCap {
        millicores: u32,
    },
}

Variants

EmptyByteSize(String)

UnknownByteUnit

Fields

unit: String

BadByteMagnitude(String)

NonIntegerByteMagnitude

Fields

value: String

LeadingZeroByteMagnitude

Fields

value: String

WhitespaceInByteSize

Fields

value: String

byte: u8

NonAsciiWhitespaceInByteSize

Fields

value: String

ch: char

codepoint: u32

EmptyDuration(String)

UnknownDurationUnit

Fields

unit: String

BadDurationMagnitude(String)

NonIntegerDurationMagnitude

Fields

value: String

LeadingZeroDurationMagnitude

Fields

value: String

WhitespaceInDuration

Fields

value: String

byte: u8

NonAsciiWhitespaceInDuration

Fields

value: String

ch: char

codepoint: u32

BadMillicores(String)

NonIntegerMillicoreMagnitude

Fields

value: String

LeadingZeroMillicoreMagnitude

Fields

value: String

WhitespaceInMillicores

Fields

value: String

byte: u8

NonAsciiWhitespaceInMillicores

Fields

value: String

ch: char

codepoint: u32

MemoryZero

MemoryBelowWasm32Page

Fields

bytes: u64

MemoryExceedsWasm32Cap

Fields

bytes: u64

MemoryNotPageMultiple

Fields

bytes: u64

FuelZero

FuelExceedsCap

Fields

fuel: u64

WallClockZero

WallClockNotCanonical

Fields

wall_clock: Duration

WallClockExceedsCap

Fields

wall_clock: Duration

CpuZero

CpuExceedsCap

Fields

millicores: u32

Implementations

impl LimitsError

pub fn non_integer_byte_magnitude(value: &str) -> Self

Construct a LimitsError::NonIntegerByteMagnitude naming the offending magnitude value. Folds the uniform { value: value.to_string() } single-slot construction onto one substrate primitive so every wire-up on this variant reads through one dispatch rather than the pre-lift three-line struct-literal block.

pub fn leading_zero_byte_magnitude(value: &str) -> Self

Construct a LimitsError::LeadingZeroByteMagnitude naming the offending magnitude value. Folds the uniform { value: value.to_string() } single-slot construction onto one substrate primitive so every wire-up on this variant reads through one dispatch rather than the pre-lift three-line struct-literal block.

pub fn non_integer_duration_magnitude(value: &str) -> Self

Construct a LimitsError::NonIntegerDurationMagnitude naming the offending magnitude value. Folds the uniform { value: value.to_string() } single-slot construction onto one substrate primitive so every wire-up on this variant reads through one dispatch rather than the pre-lift three-line struct-literal block.

pub fn leading_zero_duration_magnitude(value: &str) -> Self

Construct a LimitsError::LeadingZeroDurationMagnitude naming the offending magnitude value. Folds the uniform { value: value.to_string() } single-slot construction onto one substrate primitive so every wire-up on this variant reads through one dispatch rather than the pre-lift three-line struct-literal block.

pub fn non_integer_millicore_magnitude(value: &str) -> Self

Construct a LimitsError::NonIntegerMillicoreMagnitude naming the offending magnitude value. Folds the uniform { value: value.to_string() } single-slot construction onto one substrate primitive so every wire-up on this variant reads through one dispatch rather than the pre-lift three-line struct-literal block.

pub fn leading_zero_millicore_magnitude(value: &str) -> Self

Construct a LimitsError::LeadingZeroMillicoreMagnitude naming the offending magnitude value. Folds the uniform { value: value.to_string() } single-slot construction onto one substrate primitive so every wire-up on this variant reads through one dispatch rather than the pre-lift three-line struct-literal block.

impl LimitsError

pub fn unknown_byte_unit(unit: &str) -> Self

Construct a LimitsError::UnknownByteUnit naming the offending magnitude unit. Folds the uniform { unit: unit.to_string() } single-slot construction onto one substrate primitive so every wire-up on this variant reads through one dispatch rather than the pre-lift two-line struct-literal block.

pub fn unknown_duration_unit(unit: &str) -> Self

Construct a LimitsError::UnknownDurationUnit naming the offending magnitude unit. Folds the uniform { unit: unit.to_string() } single-slot construction onto one substrate primitive so every wire-up on this variant reads through one dispatch rather than the pre-lift two-line struct-literal block.

impl LimitsError

pub fn whitespace_in_byte_size(value: &str, byte: u8) -> Self

Construct a LimitsError::WhitespaceInByteSize naming the offending magnitude value and the raw ASCII-whitespace byte that fell inside it. Folds the uniform { value: value.to_string(), byte } two-slot construction onto one substrate primitive so every wire-up on this variant reads through one dispatch rather than the pre-lift four-line struct-literal block.

pub fn whitespace_in_duration(value: &str, byte: u8) -> Self

Construct a LimitsError::WhitespaceInDuration naming the offending magnitude value and the raw ASCII-whitespace byte that fell inside it. Folds the uniform { value: value.to_string(), byte } two-slot construction onto one substrate primitive so every wire-up on this variant reads through one dispatch rather than the pre-lift four-line struct-literal block.

pub fn whitespace_in_millicores(value: &str, byte: u8) -> Self

Construct a LimitsError::WhitespaceInMillicores naming the offending magnitude value and the raw ASCII-whitespace byte that fell inside it. Folds the uniform { value: value.to_string(), byte } two-slot construction onto one substrate primitive so every wire-up on this variant reads through one dispatch rather than the pre-lift four-line struct-literal block.

impl LimitsError

pub fn non_ascii_whitespace_in_byte_size(value: &str, ch: char) -> Self

Construct a LimitsError::NonAsciiWhitespaceInByteSize naming the offending magnitude value and the non-ASCII Unicode whitespace ch that fell inside it. Folds the uniform { value: value.to_string(), ch, codepoint: ch as u32 } three-slot construction onto one substrate primitive so every wire-up on this variant reads through one dispatch rather than the pre-lift five-line struct-literal block. The load-bearing codepoint = ch as u32 derivation is pulled inside the ctor body so every future consumer of the variant carries it through one canonical path.

pub fn non_ascii_whitespace_in_duration(value: &str, ch: char) -> Self

Construct a LimitsError::NonAsciiWhitespaceInDuration naming the offending magnitude value and the non-ASCII Unicode whitespace ch that fell inside it. Folds the uniform { value: value.to_string(), ch, codepoint: ch as u32 } three-slot construction onto one substrate primitive so every wire-up on this variant reads through one dispatch rather than the pre-lift five-line struct-literal block. The load-bearing codepoint = ch as u32 derivation is pulled inside the ctor body so every future consumer of the variant carries it through one canonical path.

pub fn non_ascii_whitespace_in_millicores(value: &str, ch: char) -> Self

Construct a LimitsError::NonAsciiWhitespaceInMillicores naming the offending magnitude value and the non-ASCII Unicode whitespace ch that fell inside it. Folds the uniform { value: value.to_string(), ch, codepoint: ch as u32 } three-slot construction onto one substrate primitive so every wire-up on this variant reads through one dispatch rather than the pre-lift five-line struct-literal block. The load-bearing codepoint = ch as u32 derivation is pulled inside the ctor body so every future consumer of the variant carries it through one canonical path.

impl LimitsError

pub const fn memory_below_wasm32_page(bytes: u64) -> Self

Construct a LimitsError::MemoryBelowWasm32Page naming the offending per-:limits bytes scalar. Folds the uniform Self::MemoryBelowWasm32Page { bytes } one-field Copy-pass-through struct-literal onto one substrate primitive so every per-axis wire-up on this variant reads through one dispatch — as a bare function pointer in the impl FnOnce(u64) -> LimitsError bracket-closure slot every crate::render::require_positive_bounded_* / crate::render::require_positive_canonical_bounded_* / crate::render::require_positive_quantum_multiple_bounded_* gate carries — rather than the pre-lift open-coded one-line closure over the same one-field struct-literal. const fn preserves the Copy-pass-through’s zero-runtime-work property verbatim.

pub const fn memory_exceeds_wasm32_cap(bytes: u64) -> Self

Construct a LimitsError::MemoryExceedsWasm32Cap naming the offending per-:limits bytes scalar. Folds the uniform Self::MemoryExceedsWasm32Cap { bytes } one-field Copy-pass-through struct-literal onto one substrate primitive so every per-axis wire-up on this variant reads through one dispatch — as a bare function pointer in the impl FnOnce(u64) -> LimitsError bracket-closure slot every crate::render::require_positive_bounded_* / crate::render::require_positive_canonical_bounded_* / crate::render::require_positive_quantum_multiple_bounded_* gate carries — rather than the pre-lift open-coded one-line closure over the same one-field struct-literal. const fn preserves the Copy-pass-through’s zero-runtime-work property verbatim.

pub const fn memory_not_page_multiple(bytes: u64) -> Self

Construct a LimitsError::MemoryNotPageMultiple naming the offending per-:limits bytes scalar. Folds the uniform Self::MemoryNotPageMultiple { bytes } one-field Copy-pass-through struct-literal onto one substrate primitive so every per-axis wire-up on this variant reads through one dispatch — as a bare function pointer in the impl FnOnce(u64) -> LimitsError bracket-closure slot every crate::render::require_positive_bounded_* / crate::render::require_positive_canonical_bounded_* / crate::render::require_positive_quantum_multiple_bounded_* gate carries — rather than the pre-lift open-coded one-line closure over the same one-field struct-literal. const fn preserves the Copy-pass-through’s zero-runtime-work property verbatim.

pub const fn fuel_exceeds_cap(fuel: u64) -> Self

Construct a LimitsError::FuelExceedsCap naming the offending per-:limits fuel scalar. Folds the uniform Self::FuelExceedsCap { fuel } one-field Copy-pass-through struct-literal onto one substrate primitive so every per-axis wire-up on this variant reads through one dispatch — as a bare function pointer in the impl FnOnce(u64) -> LimitsError bracket-closure slot every crate::render::require_positive_bounded_* / crate::render::require_positive_canonical_bounded_* / crate::render::require_positive_quantum_multiple_bounded_* gate carries — rather than the pre-lift open-coded one-line closure over the same one-field struct-literal. const fn preserves the Copy-pass-through’s zero-runtime-work property verbatim.

pub const fn wall_clock_not_canonical(wall_clock: Duration) -> Self

Construct a LimitsError::WallClockNotCanonical naming the offending per-:limits wall_clock scalar. Folds the uniform Self::WallClockNotCanonical { wall_clock } one-field Copy-pass-through struct-literal onto one substrate primitive so every per-axis wire-up on this variant reads through one dispatch — as a bare function pointer in the impl FnOnce(Duration) -> LimitsError bracket-closure slot every crate::render::require_positive_bounded_* / crate::render::require_positive_canonical_bounded_* / crate::render::require_positive_quantum_multiple_bounded_* gate carries — rather than the pre-lift open-coded one-line closure over the same one-field struct-literal. const fn preserves the Copy-pass-through’s zero-runtime-work property verbatim.

pub const fn wall_clock_exceeds_cap(wall_clock: Duration) -> Self

Construct a LimitsError::WallClockExceedsCap naming the offending per-:limits wall_clock scalar. Folds the uniform Self::WallClockExceedsCap { wall_clock } one-field Copy-pass-through struct-literal onto one substrate primitive so every per-axis wire-up on this variant reads through one dispatch — as a bare function pointer in the impl FnOnce(Duration) -> LimitsError bracket-closure slot every crate::render::require_positive_bounded_* / crate::render::require_positive_canonical_bounded_* / crate::render::require_positive_quantum_multiple_bounded_* gate carries — rather than the pre-lift open-coded one-line closure over the same one-field struct-literal. const fn preserves the Copy-pass-through’s zero-runtime-work property verbatim.

pub const fn cpu_exceeds_cap(millicores: u32) -> Self

Construct a LimitsError::CpuExceedsCap naming the offending per-:limits millicores scalar. Folds the uniform Self::CpuExceedsCap { millicores } one-field Copy-pass-through struct-literal onto one substrate primitive so every per-axis wire-up on this variant reads through one dispatch — as a bare function pointer in the impl FnOnce(u32) -> LimitsError bracket-closure slot every crate::render::require_positive_bounded_* / crate::render::require_positive_canonical_bounded_* / crate::render::require_positive_quantum_multiple_bounded_* gate carries — rather than the pre-lift open-coded one-line closure over the same one-field struct-literal. const fn preserves the Copy-pass-through’s zero-runtime-work property verbatim.

Trait Implementations

impl Debug for LimitsError

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

Formats the value using the given formatter.

impl Display for LimitsError

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

Formats the value using the given formatter.

impl Eq for LimitsError

impl Error for LimitsError

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

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for LimitsError