Trait ConvertSaveload

pub trait ConvertSaveload<M>: Sized {
    type Data: Serialize + DeserializeOwned;
    type Error;

    // Required methods
    fn convert_from<F>(data: Self::Data, ids: F) -> Result<Self, Self::Error>
       where F: FnMut(M) -> Option<Entity>;
    fn convert_into<F>(&self, ids: F) -> Result<Self::Data, Self::Error>
       where F: FnMut(Entity) -> Option<M>;
}

Converts a data type (usually a Component) into its serializable form and back to actual data from it’s deserialized form.

This is automatically implemented for any type that is Clone, Serialize and DeserializeOwned.

Implementing this yourself is usually only needed if you have a component that points to another Entity, or has a field which does, and you wish to Serialize it.

Note: if you’re using specs_derive you can use #[derive(Saveload)] to automatically derive this.

You must add the derive to any type that your component holds which does not auto-implement this traits, including the component itself (similar to how normal Serialize and Deserialize work).

Example

use serde::{Deserialize, Serialize};
use specs::{
    prelude::*,
    saveload::{ConvertSaveload, Marker},
};
use std::convert::Infallible;

struct Target(Entity);

impl Component for Target {
    type Storage = VecStorage<Self>;
}

// We need a matching "data" struct to hold our
// marker. In general, you just need a single struct
// per component you want to make `Serialize`/`Deserialize` with each
// instance of `Entity` replaced with a generic "M".
#[derive(Serialize, Deserialize)]
struct TargetData<M>(M);

impl<M: Marker + Serialize> ConvertSaveload<M> for Target
where
    for<'de> M: Deserialize<'de>,
{
    type Data = TargetData<M>;
    type Error = Infallible;

    fn convert_into<F>(&self, mut ids: F) -> Result<Self::Data, Self::Error>
    where
        F: FnMut(Entity) -> Option<M>,
    {
        let marker = ids(self.0).unwrap();
        Ok(TargetData(marker))
    }

    fn convert_from<F>(data: Self::Data, mut ids: F) -> Result<Self, Self::Error>
    where
        F: FnMut(M) -> Option<Entity>,
    {
        let entity = ids(data.0).unwrap();
        Ok(Target(entity))
    }
}

Required Associated Types

type Data: Serialize + DeserializeOwned

(De)Serializable data representation for data type

type Error

Error may occur during serialization or deserialization of component

Required Methods

fn convert_from<F>(data: Self::Data, ids: F) -> Result<Self, Self::Error>

where F: FnMut(M) -> Option<Entity>,

Convert this data from a deserializable form (Data) using entity to marker mapping function

fn convert_into<F>(&self, ids: F) -> Result<Self::Data, Self::Error>

where F: FnMut(Entity) -> Option<M>,

Convert this data type into serializable form (Data) using entity to marker mapping function

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors

impl<C, M> ConvertSaveload<M> for C

where C: Clone + Serialize + DeserializeOwned,

type Data = C

type Error = Infallible

impl<M> ConvertSaveload<M> for Entity

where M: Serialize + DeserializeOwned,

type Data = M

type Error = Infallible