Enum ReflectionError 

#[non_exhaustive]
pub enum ReflectionError {
    Decode(DecodeError),
    ElementBudget,
    Pool(PoolError),
    MalformedFraming {
        offset: usize,
    },
    UnnamedFile {
        index: usize,
    },
    CountMismatch {
        framed: usize,
        decoded: usize,
    },
    SharedPool,
}

Errors from building a Reflector.

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.

Decode(DecodeError)

The bytes did not decode as a FileDescriptorSet.

Exceeding the element-memory budget is reported separately as ElementBudget, because there the bytes are fine; this variant is every other wire-level failure.

ElementBudget

The descriptor set was well-formed but exceeded the decode’s element-memory budget.

Split apart from Decode because the remedy is different: the bytes are fine, and a reflection service is normally handed its own server’s descriptors, which are trusted. The remedy is a smaller set — strip source_code_info, or narrow it to the files this server reflects.

Pool(PoolError)

The decoded descriptors did not link into a valid pool (dangling type reference, duplicate symbol, malformed map entry, …).

MalformedFraming

The top-level wire structure of the set was malformed (e.g. a truncated length prefix), so per-file byte ranges could not be sliced out.

Fields

offset: usize

Byte offset of the unreadable tag or length.

UnnamedFile

A file in the set has no name field; the reflection protocol keys every file query by name.

Fields

index: usize

Position of the nameless file within the set.

CountMismatch

The framing walk and the message decoder disagreed on how many files the set contains — the bytes are not a coherent FileDescriptorSet.

Fields

framed: usize

Files found by the top-level framing walk.

decoded: usize

Files in the decoded FileDescriptorSet.

SharedPool

add_descriptor_set_bytes was called on a reflector whose pool is shared (adopted via from_descriptor_pool with other outstanding references). Merge sets before sharing, or build the reflector from bytes.

Trait Implementations

impl Debug for ReflectionError

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

Formats the value using the given formatter.

impl Display for ReflectionError

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

Formats the value using the given formatter.

impl Error for ReflectionError

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<DecodeError> for ReflectionError

Written out rather than derived with #[from], so that the budget/corrupt split cannot be bypassed. A derived conversion sends every buffa::DecodeError to Decode, so the next decode path added here — reached with ?, which compiles fine — would report an over-budget set as corruption again, silently undoing the reason ElementBudget exists.

fn from(e: DecodeError) -> Self

Converts to this type from the input type.

impl From<PoolError> for ReflectionError

fn from(source: PoolError) -> Self

Converts to this type from the input type.