Enum PRepr 

pub enum PRepr {
    Transparent,
    Rust(Option<PrimitiveRepr>),
    C(Option<PrimitiveRepr>),
    RustcWillCatch,
}

Parsed representation attribute

Variants

Transparent

#[repr(transparent)]

Rust(Option<PrimitiveRepr>)

#[repr(Rust)] with optional primitive type

C(Option<PrimitiveRepr>)

#[repr(C)] with optional primitive type

RustcWillCatch

A repr error that rustc will catch (e.g., conflicting hints). We use this sentinel to avoid emitting our own misleading errors.

Implementations

impl PRepr

pub fn parse(s: &ReprInner) -> Result<Option<Self>, ParseError>

Parse a &str (for example a value coming from #[repr(…)] attribute) into a PRepr variant.

Returns Err(ParseError::RustcWillCatch { .. }) for errors that rustc will catch on its own (conflicting repr hints). Returns Err(ParseError::FacetError { .. }) for facet-specific errors like unsupported repr types (e.g., packed).

Trait Implementations

impl Clone for PRepr

fn clone(&self) -> PRepr

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for PRepr

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

Formats the value using the given formatter.

impl Hash for PRepr

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 PRepr

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for PRepr

impl Eq for PRepr

impl StructuralPartialEq for PRepr