Enum AnyChunk 

pub enum AnyChunk<const BODY_SIZE: usize = DEFAULT_BODY_SIZE> {
    Content(ContentChunk<BODY_SIZE>),
    SingleOwner(SingleOwnerChunk<BODY_SIZE>),
    Custom {
        type_id: ChunkTypeId,
        address: ChunkAddress,
        data: Bytes,
    },
}

Type-erased chunk for runtime polymorphism with configurable body size.

This enum provides dynamic dispatch for chunks without requiring object-safe traits. Use this when you need to store heterogeneous chunk types in collections or pass chunks through interfaces that can’t be generic.

Why an enum instead of Box<dyn Chunk>?

The Chunk trait has an associated type (type Header) which makes it not object-safe. This enum provides the same functionality while maintaining type safety.

Examples

use nectar_primitives::{AnyChunk, Chunk, ContentChunk, ChunkTypeId};

// Create a content chunk
let content = ContentChunk::new(&b"hello world"[..]).unwrap();
let any: AnyChunk = content.clone().into();

// Access common properties
assert_eq!(any.type_id(), ChunkTypeId::CONTENT);

// Get the concrete type back
if let Some(recovered) = any.as_content() {
    assert_eq!(recovered.address(), content.address());
}

Variants

Content(ContentChunk<BODY_SIZE>)

A content-addressed chunk (CAC).

SingleOwner(SingleOwnerChunk<BODY_SIZE>)

A single-owner chunk (SOC).

Custom

A custom chunk type (for extensibility).

This variant allows storing chunks of types not known at compile time. The raw bytes are preserved for potential later processing.

Fields

type_id: ChunkTypeId

The chunk type identifier.

address: ChunkAddress

The chunk’s address.

data: Bytes

The raw chunk data.

Implementations

impl<const BODY_SIZE: usize> AnyChunk<BODY_SIZE>

pub fn address(&self) -> &ChunkAddress

Get the address of this chunk.

pub fn data(&self) -> &Bytes

Get the raw data contained in this chunk.

pub const fn type_id(&self) -> ChunkTypeId

Get the type ID of this chunk.

pub fn size(&self) -> usize

Get the total size of this chunk in bytes.

pub fn span(&self) -> u64

Get the span (logical data length) of this chunk.

For content chunks and single-owner chunks, this returns the BMT span. For custom chunks, the span is not available (returns 0).

pub fn verify(&self, expected: &ChunkAddress) -> Result<()>

Verify that this chunk’s address matches an expected address.

pub fn into_bytes(self) -> Bytes

Convert this chunk into its serialized bytes representation.

pub fn is<T: ChunkType>(&self) -> bool

Check if this chunk is of a specific type.

pub const fn is_content(&self) -> bool

Check if this is a content chunk.

pub const fn is_single_owner(&self) -> bool

Check if this is a single-owner chunk.

pub const fn is_custom(&self) -> bool

Check if this is a custom chunk type.

pub const fn as_content(&self) -> Option<&ContentChunk<BODY_SIZE>>

Get a reference to the contained ContentChunk, if this is one.

pub const fn as_single_owner(&self) -> Option<&SingleOwnerChunk<BODY_SIZE>>

Get a reference to the contained SingleOwnerChunk, if this is one.

pub fn into_content(self) -> Option<ContentChunk<BODY_SIZE>>

Convert into the contained ContentChunk, if this is one.

pub fn into_single_owner(self) -> Option<SingleOwnerChunk<BODY_SIZE>>

Convert into the contained SingleOwnerChunk, if this is one.

Trait Implementations

impl<const BODY_SIZE: usize> Clone for AnyChunk<BODY_SIZE>

fn clone(&self) -> AnyChunk<BODY_SIZE>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<const BODY_SIZE: usize> Debug for AnyChunk<BODY_SIZE>

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

Formats the value using the given formatter.

impl<const BODY_SIZE: usize> Eq for AnyChunk<BODY_SIZE>

impl<const BODY_SIZE: usize> From<ContentChunk<BODY_SIZE>> for AnyChunk<BODY_SIZE>

fn from(chunk: ContentChunk<BODY_SIZE>) -> Self

Converts to this type from the input type.

impl<const BODY_SIZE: usize> From<SingleOwnerChunk<BODY_SIZE>> for AnyChunk<BODY_SIZE>

fn from(chunk: SingleOwnerChunk<BODY_SIZE>) -> Self

Converts to this type from the input type.

impl<const BODY_SIZE: usize> PartialEq for AnyChunk<BODY_SIZE>

fn eq(&self, other: &Self) -> 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.