Trait Element 

pub unsafe trait Element:
    Send
    + Sync
    + 'static {
    type Ref<'a>: Copy + Debug;
    type Spans: Spans;

    const INLINE_FIXED: bool;

    // Required methods
    fn validate(bytes: &[u8]) -> bool;
    unsafe fn read<'a>(ptr: *const u8, len: usize) -> Self::Ref<'a>
       where Self: 'a;

    // Provided method
    fn fmt_row<'a, I>(values: I, f: &mut Formatter<'_>) -> Result
       where I: Iterator<Item = Self::Ref<'a>>,
             Self: 'a { ... }
}

A type of the values a Buf holds: where they are in its storage, see Spans, and what octets are one of them.

This is implemented for every PackedElement, and for str, whose values are at the spans of a table.

Safety

Self::read must be sound for any octets Self::validate accepts.

Required Associated Constants

const INLINE_FIXED: bool

Whether a scalar of this type is held in place of a storage, which only a packed type small enough can be.

Required Associated Types

type Ref<'a>: Copy + Debug

How one value is given out: by value for a packed type, borrowed for a string.

type Spans: Spans

Where the values are in the storage.

Required Methods

fn validate(bytes: &[u8]) -> bool

Whether these octets are one valid value.

unsafe fn read<'a>(ptr: *const u8, len: usize) -> Self::Ref<'a>

where Self: 'a,

The value in these octets.

Safety

The octets must have been accepted by Self::validate, and be aligned for a packed type.

Provided Methods

fn fmt_row<'a, I>(values: I, f: &mut Formatter<'_>) -> Result

where I: Iterator<Item = Self::Ref<'a>>, Self: 'a,

Format the values of one row of a buffer for Debug, along its first dimension, within the brackets of that row: separated by commas unless a type has a better way.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementations on Foreign Types

impl Element for bool

const INLINE_FIXED: bool

type Ref<'a> = bool

type Spans = PackedSpans<bool>

fn validate(bytes: &[u8]) -> bool

unsafe fn read<'a>(ptr: *const u8, _len: usize) -> bool

where bool: 'a,

impl Element for f32

const INLINE_FIXED: bool

type Ref<'a> = f32

type Spans = PackedSpans<f32>

fn validate(bytes: &[u8]) -> bool

unsafe fn read<'a>(ptr: *const u8, _len: usize) -> f32

where f32: 'a,

impl Element for f64

const INLINE_FIXED: bool

type Ref<'a> = f64

type Spans = PackedSpans<f64>

fn validate(bytes: &[u8]) -> bool

unsafe fn read<'a>(ptr: *const u8, _len: usize) -> f64

where f64: 'a,

impl Element for i8

const INLINE_FIXED: bool

type Ref<'a> = i8

type Spans = PackedSpans<i8>

fn validate(bytes: &[u8]) -> bool

unsafe fn read<'a>(ptr: *const u8, _len: usize) -> i8

where i8: 'a,

impl Element for i16

const INLINE_FIXED: bool

type Ref<'a> = i16

type Spans = PackedSpans<i16>

fn validate(bytes: &[u8]) -> bool

unsafe fn read<'a>(ptr: *const u8, _len: usize) -> i16

where i16: 'a,

impl Element for i32

const INLINE_FIXED: bool

type Ref<'a> = i32

type Spans = PackedSpans<i32>

fn validate(bytes: &[u8]) -> bool

unsafe fn read<'a>(ptr: *const u8, _len: usize) -> i32

where i32: 'a,

impl Element for i64

const INLINE_FIXED: bool

type Ref<'a> = i64

type Spans = PackedSpans<i64>

fn validate(bytes: &[u8]) -> bool

unsafe fn read<'a>(ptr: *const u8, _len: usize) -> i64

where i64: 'a,

impl Element for str

const INLINE_FIXED: bool = false

type Ref<'a> = &'a str

type Spans = TableSpans

fn validate(bytes: &[u8]) -> bool

unsafe fn read<'a>(ptr: *const u8, len: usize) -> &'a str

where str: 'a,

impl Element for u8

const INLINE_FIXED: bool

type Ref<'a> = u8

type Spans = PackedSpans<u8>

fn validate(bytes: &[u8]) -> bool

unsafe fn read<'a>(ptr: *const u8, _len: usize) -> u8

where u8: 'a,

fn fmt_row<'a, I>(values: I, f: &mut Formatter<'_>) -> Result

where I: Iterator<Item = u8>, u8: 'a,

impl Element for u16

const INLINE_FIXED: bool

type Ref<'a> = u16

type Spans = PackedSpans<u16>

fn validate(bytes: &[u8]) -> bool

unsafe fn read<'a>(ptr: *const u8, _len: usize) -> u16

where u16: 'a,

impl Element for u32

const INLINE_FIXED: bool

type Ref<'a> = u32

type Spans = PackedSpans<u32>

fn validate(bytes: &[u8]) -> bool

unsafe fn read<'a>(ptr: *const u8, _len: usize) -> u32

where u32: 'a,

impl Element for u64

const INLINE_FIXED: bool

type Ref<'a> = u64

type Spans = PackedSpans<u64>

fn validate(bytes: &[u8]) -> bool

unsafe fn read<'a>(ptr: *const u8, _len: usize) -> u64

where u64: 'a,

Implementors

impl Element for DevEnum

const INLINE_FIXED: bool

type Ref<'a> = DevEnum

type Spans = PackedSpans<DevEnum>

impl Element for DevState

const INLINE_FIXED: bool

type Ref<'a> = DevState

type Spans = PackedSpans<DevState>