Enum RenderError 

pub enum RenderError {
    NothingRendered,
    SeatUnplanned {
        role: &'static str,
    },
    BytesUnbounded {
        role: &'static str,
        bound: usize,
        observed: usize,
    },
    UnitsUnbounded {
        bound: usize,
        observed: usize,
    },
    TokensUnbounded {
        bound: usize,
        observed: usize,
    },
}

How rendering says no.

One refusal, at the first thing that goes wrong: a unit that cannot be materialized is not a unit, and the units after it were never written. Three rows name a declared magnitude and the two counts that passed it; the other two say a rendering and a plan’s seats do not line up at all.

Variants

NothingRendered

The renderer wrote no unit at all.

SeatUnplanned

A unit was written under a seat this plan declares no member for.

Refused where it is written rather than where a proof would notice it, because a unit answers to its member’s semantic key and a seat with no member offers none.

Fields

role: &'static str

The seat’s declared name.

BytesUnbounded

One unit’s canonical bytes pass the declared magnitude.

Fields

role: &'static str

The seat the unit was written under, by its declared name.

bound: usize

The declared bound.

observed: usize

The observed count.

UnitsUnbounded

The rendering carries more units than the declared magnitude admits.

Fields

bound: usize

The declared bound.

observed: usize

The observed count.

TokensUnbounded

A generated tree passed the declared per-level magnitude while a unit was being composed.

The one overflow a renderer meets: the composition helpers and the tree assembler are what it builds with, and they are the only roads it takes that bound anything.

Fields

bound: usize

The declared bound.

observed: usize

The observed count.

Implementations

impl RenderError

pub fn canonical_bytes(&self) -> Vec<u8>

This refusal’s canonical bytes on their own.

pub fn encode_into(&self, into: &mut Vec<u8>)

Appends this refusal’s canonical bytes: the row’s position in the declared roster, then the typed material that row carries, framed.

Exhaustive over the roster on purpose: a row added to RenderError stops compiling HERE until somebody says what of it a preimage commits to.

impl RenderError

pub const fn slot(&self) -> u8

This row’s position in the declared roster, written ahead of the refusal’s own material.

Appended and never renumbered: the byte is part of this refusal’s public canonical encoding.

Trait Implementations

impl Clone for RenderError

fn clone(&self) -> RenderError

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for RenderError

impl Debug for RenderError

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

Formats the value using the given formatter.

impl Display for RenderError

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

Formats the value using the given formatter.

impl Eq for RenderError

impl Error for RenderError

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<Overflow> for RenderError

fn from(overflow: Overflow) -> Self

The refusal a generated tree that outgrew its per-level magnitude makes.

The one overflow a renderer meets, so ? carries a composition helper’s answer straight out of a renderer body.

impl From<ProjectionError> for RenderError

fn from(refusal: ProjectionError) -> Self

Converts to this type from the input type.

impl Hash for RenderError

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

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

Equality operator ==.

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

Inequality operator !=.

impl Refused for RenderError

fn body(&self) -> LineBody

Rendering establishes one cause and enumerates nothing.

A unit that cannot be materialized is not a unit, and the units after it were never written, so there is no remainder for a line to count.

fn related(&self) -> Vec<Vec<u8>>

A single cause enumerates nothing: the primary cause is the summary’s own subject, never a member of its related set.

fn repairs(&self) -> Bounded<Repair, REPAIR_LIMIT>

This home declares no repair of its own.

Every row above is about the renderer the caller wrote or the plan the caller declared, so the repair is one of those two; a sentence composed here would be this compiler citing a fact nobody declared.

const PHASE: Phase = Phase::Rendering

The step of the road this refusal is raised at.

const FAMILY: Family = RENDERING_FAMILY

The family whose issue space this refusal’s related identities derive in.

fn class(&self) -> RefusalClass

Which class of refusal the summary line opens with.

fn first(&self) -> String

How the first established issue reads for a person.

fn observed(&self) -> Observed

How what was observed differs from the expected contract, read off that same first issue.

impl StructuralPartialEq for RenderError