Saveload overhaul

Cargo.toml

@@ -45,7 +45,7 @@ features = ["common", "serde"]
 [dev-dependencies]
 cgmath =  { version = "0.14", features = ["eders"] }
 criterion = "0.2"
-ron = "0.1.3"
+ron = "0.1.5"
 rand = "0.3"
 serde_json = "1.0"
 specs-derive = { path = "specs-derive", version = "0.2.0" }

examples/saveload.rs

@@ -3,9 +3,11 @@ extern crate ron;
 extern crate serde;
 extern crate specs;
 
+use std::fmt;
+
 use specs::error::NoError;
 use specs::prelude::*;
-use specs::saveload::{U64Marker, U64MarkerAllocator, WorldDeserialize, WorldSerialize};
+use specs::saveload::{DeserializeComponents, SerializeComponents, U64Marker, U64MarkerAllocator};
 
 const ENTITIES: &str = "
 [
@@ -49,6 +51,31 @@ impl Component for Mass {
     type Storage = VecStorage<Self>;
 }
 
+#[derive(Debug)]
+enum Combined {
+    Ron(ron::ser::Error),
+}
+
+impl fmt::Display for Combined {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match *self {
+            Combined::Ron(ref e) => write!(f, "{}", e),
+        }
+    }
+}
+
+impl From<ron::ser::Error> for Combined {
+    fn from(x: ron::ser::Error) -> Self {
+        Combined::Ron(x)
+    }
+}
+
+impl From<NoError> for Combined {
+    fn from(e: NoError) -> Self {
+        match e {}
+    }
+}
+
 fn main() {
     let mut world = World::new();
 
@@ -75,14 +102,25 @@ fn main() {
     struct Serialize;
 
     impl<'a> System<'a> for Serialize {
-        type SystemData = WorldSerialize<'a, U64Marker, NoError, (Pos, Mass)>;
-
-        fn run(&mut self, mut world: Self::SystemData) {
-            let s = ron::ser::to_string_pretty(&world, ron::ser::PrettyConfig::default()).unwrap();
-
-            println!("{}", s);
-
-            world.remove_serialized();
+        type SystemData = (
+            Entities<'a>,
+            ReadStorage<'a, Pos>,
+            ReadStorage<'a, Mass>,
+            ReadStorage<'a, U64Marker>,
+        );
+
+        fn run(&mut self, (ents, pos, mass, markers): Self::SystemData) {
+            let mut ser = ron::ser::Serializer::new(Some(Default::default()), true);
+            SerializeComponents::<NoError, U64Marker>::serialize(
+                &(&pos, &mass),
+                &ents,
+                &markers,
+                &mut ser,
+            ).unwrap_or_else(|e| eprintln!("Error: {}", e));
+            // TODO: Specs should return an error which combines serialization
+            // and component errors.
+
+            println!("{}", ser.into_output_string());
         }
     }
 
@@ -93,14 +131,25 @@ fn main() {
     struct Deserialize;
 
     impl<'a> System<'a> for Deserialize {
-        type SystemData = WorldDeserialize<'a, U64Marker, NoError, (Pos, Mass)>;
-
-        fn run(&mut self, world: Self::SystemData) {
+        type SystemData = (
+            Entities<'a>,
+            Write<'a, U64MarkerAllocator>,
+            WriteStorage<'a, Pos>,
+            WriteStorage<'a, Mass>,
+            WriteStorage<'a, U64Marker>,
+        );
+
+        fn run(&mut self, (ent, mut alloc, pos, mass, mut markers): Self::SystemData) {
             use ron::de::Deserializer;
-            use serde::de::DeserializeSeed;
 
             let mut de = Deserializer::from_str(ENTITIES);
-            world.deserialize(&mut de).unwrap();
+            DeserializeComponents::<Combined, _>::deserialize(
+                &mut (pos, mass),
+                &ent,
+                &mut markers,
+                &mut alloc,
+                &mut de,
+            ).unwrap_or_else(|e| eprintln!("Error: {}", e));
         }
     }
 

examples/serialize.rs

@@ -47,10 +47,8 @@ fn main() {
             // Get a list of all entities in the world
             let entity_list: Vec<_> = (&*data.entities).join().collect();
 
-            // Remove all components
-            for (entity, _) in (&*data.entities, &data.comp.mask().clone()).join() {
-                data.comp.remove(entity);
-            }
+            // Remove all components by consuming a draining iterator.
+            (&*data.entities, data.comp.drain()).join().count();
 
             // Deserialize with entity list
             let list: PackedData<CompSerialize> = json_from_str(&serialized).unwrap();

src/common.rs

@@ -167,8 +167,7 @@ impl Errors {
 #[derive(Derivative)]
 #[derivative(Default(bound = ""))]
 pub struct Merge<F> {
-    #[derivative(Default(value = "PhantomData"))]
-    future_type: PhantomData<F>,
+    #[derivative(Default(value = "PhantomData"))] future_type: PhantomData<F>,
     spawns: Vec<(Entity, Spawn<F>)>,
 }
 

src/error.rs

@@ -74,6 +74,12 @@ impl Display for Error {
     }
 }
 
+impl From<NoError> for Error {
+    fn from(e: NoError) -> Self {
+        match e {}
+    }
+}
+
 impl From<WrongGeneration> for Error {
     fn from(e: WrongGeneration) -> Self {
         Error::WrongGeneration(e)

src/lib.rs

@@ -1,4 +1,4 @@
-#![deny(missing_docs)]
+#![warn(missing_docs)]
 #![cfg_attr(feature = "nightly", feature(core_intrinsics))]
 
 //! # SPECS Parallel ECS
@@ -199,9 +199,6 @@ extern crate futures;
 #[cfg(feature = "serde")]
 #[macro_use]
 extern crate serde;
-#[cfg(feature = "serde")]
-#[macro_use]
-extern crate shred_derive;
 
 #[cfg(feature = "rudy")]
 extern crate rudy;