Struct UnknownLayout 

#[non_exhaustive]
pub struct UnknownLayout {
    pub tag: u8,
    pub raw_bytes: Vec<u8>,
}

Descriptor for an unrecognized layout, accepted only in permissive mode.

A conforming reader in permissive mode MAY accept tensor descriptors whose layout tag is not recognized, but MUST NOT dereference or interpret the tensor data buffer for such tensors. The Unknown variant preserves the raw tag and bytes for inspection without dereferencing.

Named-variant constructors on LayoutDescriptor reject tags 0x00, 0xFF, reserved ranges, and private-extension tags — callers that want to pass unknown layouts through must construct Unknown explicitly (or via a permissive decoder in a higher layer).

buffer_count is always None for Unknown because the number of required buffers is not known without understanding the layout.

The constructor rejects any tag this implementation does understand — see UnknownLayout::new. The type means “I could not parse this”, and that claim has to stay true, because a permissive relay downstream acts on it.

Examples

use hurray_core::layout::{LayoutDescriptor, UnknownLayout};

// Simulate a permissive reader accepting an unrecognised tag.
let layout = LayoutDescriptor::Unknown(UnknownLayout::new(0x0C, vec![0x00, 0x01]).unwrap());
assert_eq!(layout.tag(), 0x0C);
assert!(layout.buffer_count().is_none());

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

tag: u8

The raw tag byte from the wire, exactly as received.

raw_bytes: Vec<u8>

The raw layout-specific bytes following the tag, as received.

Implementations

impl UnknownLayout

pub fn new(tag: u8, raw_bytes: Vec<u8>) -> Result<Self>

Creates a new UnknownLayout from a raw tag byte and opaque payload bytes.

Errors

Tag	Error
0x00, 0xFF	Error::InvalidLayoutTag — permanently invalid in every mode
a tag with a named variant	Error::NamedLayoutTag
0xF0–0xFE	Error::PrivateLayoutTag — use PrivateExtensionLayout

Examples

use hurray_core::layout::UnknownLayout;

let u = UnknownLayout::new(0x0C, vec![1, 2, 3]).unwrap();
assert_eq!(u.tag, 0x0C);
assert_eq!(u.raw_bytes, [1, 2, 3]);

// Permanently-invalid sentinels are rejected even in permissive mode.
assert!(UnknownLayout::new(0x00, vec![]).is_err());
assert!(UnknownLayout::new(0xFF, vec![]).is_err());

// So is a tag this implementation understands.
assert!(UnknownLayout::new(0x07, vec![]).is_err()); // CSR
assert!(UnknownLayout::new(0xF0, vec![]).is_err()); // private extension

Trait Implementations

impl Clone for UnknownLayout

fn clone(&self) -> UnknownLayout

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for UnknownLayout

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

Formats the value using the given formatter.

impl Eq for UnknownLayout

impl Hash for UnknownLayout

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 UnknownLayout

fn eq(&self, other: &UnknownLayout) -> 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 StructuralPartialEq for UnknownLayout