Struct legion::Registry

pub struct Registry<T, S = Canon> where
    T: TypeKey,
    S: CustomEntitySerializer + 'static,  { /* fields omitted */ }

A world (de)serializer which describes how to (de)serialize the component types in a world.

The type parameter T represents the key used in the serialized output to identify each component type. The type keys used must uniquely identify each component type, and be stable between recompiles.

See the legion_typeuuid crate for an example of a type key which is stable between compiles.

Implementations

impl<T, S> Registry<T, S> where
    T: TypeKey,
    S: CustomEntitySerializer + 'static, 

pub fn new(entity_serializer: S) -> Self

Constructs a new registry.

pub fn on_unknown(&mut self, unknown: UnknownType)

Sets the behavior to use when a component type is unknown.

pub fn register<C: Component + Serialize + for<'de> Deserialize<'de>>(
    &mut self,
    mapped_type_id: T
)

Registers a component type and its key with the registry.

pub fn register_auto_mapped<C: Component + Serialize + for<'de> Deserialize<'de>>(
    &mut self
) where
    T: AutoTypeKey<C>, 

Registers a component type and its key with the registry.

pub fn as_deserialize_into_world<'a>(
    &'a self,
    world: &'a mut World
) -> DeserializeIntoWorld<'a, Self>

Constructs a serde::DeserializeSeed which will deserialize into an existing world.

pub fn as_deserialize(&self) -> DeserializeNewWorld<'_, Self>

Constructs a serde::DeserializeSeed which will deserialize into a new world.

Trait Implementations

impl<T, S> Default for Registry<T, S> where
    T: TypeKey,
    S: CustomEntitySerializer + Default + 'static, 

fn default() -> Self

Returns the "default value" for a type.

impl<T, S> WorldDeserializer for Registry<T, S> where
    T: TypeKey,
    S: CustomEntitySerializer + 'static, 

type TypeId = T

The stable type ID used to identify each component type in the serialized data.

fn unmap_id(
    &self,
    type_id: &Self::TypeId
) -> Result<ComponentTypeId, UnknownType>

Converts the serialized type ID into a runtime component type ID.

fn register_component(&self, type_id: Self::TypeId, layout: &mut EntityLayout)

Adds the specified component to the given entity layout.

fn deserialize_component_slice<'a, 'de, D: Deserializer<'de>>(
    &self,
    type_id: ComponentTypeId,
    storage: UnknownComponentWriter<'a>,
    deserializer: D
) -> Result<(), D::Error>

Deserializes a slice of components and inserts them into the given storage.

fn deserialize_component<'de, D: Deserializer<'de>>(
    &self,
    type_id: ComponentTypeId,
    deserializer: D
) -> Result<Box<[u8]>, D::Error>

Deserializes a single component and returns it as a boxed u8 slice.

fn with_entity_serializer(
    &self,
    callback: &mut dyn FnMut(&dyn EntitySerializer)
)

Calls callback with the Entity ID serializer

impl<T, S> WorldSerializer for Registry<T, S> where
    T: TypeKey,
    S: CustomEntitySerializer + 'static, 

type TypeId = T

The stable type ID used to identify each component type in the serialized data.

unsafe fn serialize_component<Ser: Serializer>(
    &self,
    ty: ComponentTypeId,
    ptr: *const u8,
    serializer: Ser
) -> Result<Ser::Ok, Ser::Error>

Serializes a single component.

fn map_id(&self, type_id: ComponentTypeId) -> Result<Self::TypeId, UnknownType>

Converts a runtime component type ID into the serialized type ID.

unsafe fn serialize_component_slice<Ser: Serializer>(
    &self,
    ty: ComponentTypeId,
    storage: &dyn UnknownComponentStorage,
    archetype: ArchetypeIndex,
    serializer: Ser
) -> Result<Ser::Ok, Ser::Error>

Serializes a slice of components.

fn with_entity_serializer(
    &self,
    callback: &mut dyn FnMut(&dyn EntitySerializer)
)

Calls callback with the Entity ID serializer