Enum ComponentData 

#[non_exhaustive]
pub enum ComponentData {
    Empty,
    Bool(bool),
    I32(i32),
    Float(f32),
    Tool(Tool),
    Equippable(Equippable),
    Enchantments(ItemEnchantments),
    TextComponent(Box<TextComponent>),
    Todo,
    Other(Vec<u8>),
}

ABI-stable component value storage.

Each vanilla component type gets its own variant for type-safe, zero-cost access. Plugin-defined components use the Other variant with serialized bytes that the plugin is responsible for interpreting.

Example (vanilla code)

let data = ComponentData::I32(10);
if let ComponentData::I32(d) = data {
    println!("Value: {}", d);
}

Example (plugin code)

// Plugin stores its own serialized data
let my_bytes = my_energy.serialize();
let data = ComponentData::Other(my_bytes);

// Plugin retrieves and deserializes
if let ComponentData::Other(bytes) = data {
    let energy = MyEnergy::deserialize(&bytes)?;
}

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Empty

Component with no data (e.g., Unbreakable, Glider, CreativeSlotLock)

Bool(bool)

Boolean component (e.g., EnchantmentGlintOverride)

I32(i32)

i32 component (e.g., MaxStackSize, MaxDamage, Damage, RepairCost) Stored as VarInt on network.

Float(f32)

Float component (e.g., PotionDurationScale)

Tool(Tool)

minecraft:tool

Equippable(Equippable)

minecraft:equippable

Enchantments(ItemEnchantments)

minecraft:enchantments / minecraft:stored_enchantments

TextComponent(Box<TextComponent>)

TextComponent component (e.g., CustomName, ItemName)

Todo

Placeholder for components that aren’t implemented yet.

Other(Vec<u8>)

Opaque bytes for plugin-defined components. The plugin is responsible for serialization/deserialization.

Implementations

impl ComponentData

pub const fn is_empty(&self) -> bool

Returns true if this is the empty/unit variant.

pub fn as_other(&self) -> Option<&[u8]>

Returns the raw bytes if this is an Other variant.

pub const fn discriminant(&self) -> ComponentDataDiscriminant

Returns the discriminant of this component data variant. Used for runtime type validation.

pub fn compute_hash(&self) -> i32

Computes a hash of this component value for validation.

Uses CRC32C hashing matching Minecraft’s HashOps implementation.

Trait Implementations

impl Clone for ComponentData

fn clone(&self) -> ComponentData

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ComponentData

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

Formats the value using the given formatter.

impl PartialEq for ComponentData

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