From 33b07e2bce05939f2eb7bd0bec19796756b13054 Mon Sep 17 00:00:00 2001
From: slyrz <slyrz@users.noreply.github.com>
Date: Tue, 7 Mar 2017 19:14:46 +0100
Subject: [PATCH] Make example work with serde (#131)

* Make example work with serde

* Restore asserts
---
 README.md         | 23 +++++++++--------------
 examples/basic.rs | 26 +++++++++-----------------
 2 files changed, 18 insertions(+), 31 deletions(-)

diff --git a/README.md b/README.md
index 1d5034c..83f3ee7 100644
--- a/README.md
+++ b/README.md
@@ -26,38 +26,33 @@ library.
 
 ## Example
 ```rust
+#[macro_use]
+extern crate serde_derive;
 extern crate bincode;
-extern crate rustc_serialize;
 
-use bincode::SizeLimit;
-use bincode::rustc_serialize::{encode, decode};
+use bincode::{serialize, deserialize, SizeLimit};
 
-#[derive(RustcEncodable, RustcDecodable, PartialEq)]
+#[derive(Serialize, Deserialize, PartialEq)]
 struct Entity {
     x: f32,
     y: f32,
 }
 
-#[derive(RustcEncodable, RustcDecodable, PartialEq)]
-struct World {
-    entities: Vec<Entity>
-}
+#[derive(Serialize, Deserialize, PartialEq)]
+struct World(Vec<Entity>);
 
 fn main() {
-    let world = World {
-        entities: vec![Entity {x: 0.0, y: 4.0}, Entity {x: 10.0, y: 20.5}]
-    };
+    let world = World(vec![Entity { x: 0.0, y: 4.0 }, Entity { x: 10.0, y: 20.5 }]);
 
-    let encoded: Vec<u8> = encode(&world, SizeLimit::Infinite).unwrap();
+    let encoded: Vec<u8> = serialize(&world, SizeLimit::Infinite).unwrap();
 
     // 8 bytes for the length of the vector, 4 bytes per float.
     assert_eq!(encoded.len(), 8 + 4 * 4);
 
-    let decoded: World = decode(&encoded[..]).unwrap();
+    let decoded: World = deserialize(&encoded[..]).unwrap();
 
     assert!(world == decoded);
 }
-
 ```
 
 
diff --git a/examples/basic.rs b/examples/basic.rs
index c5d9d3e..abd8575 100644
--- a/examples/basic.rs
+++ b/examples/basic.rs
@@ -1,35 +1,27 @@
-/*
+#[macro_use]
+extern crate serde_derive;
 extern crate bincode;
-extern crate
 
-use bincode::SizeLimit;
-use bincode::rustc_serialize::{encode, decode};
+use bincode::{serialize, deserialize, SizeLimit};
 
-#[derive(RustcEncodable, RustcDecodable, PartialEq)]
+#[derive(Serialize, Deserialize, PartialEq)]
 struct Entity {
     x: f32,
     y: f32,
 }
 
-#[derive(RustcEncodable, RustcDecodable, PartialEq)]
-struct World {
-    entities: Vec<Entity>
-}
+#[derive(Serialize, Deserialize, PartialEq)]
+struct World(Vec<Entity>);
 
 fn main() {
-    let world = World {
-        entities: vec![Entity {x: 0.0, y: 4.0}, Entity {x: 10.0, y: 20.5}]
-    };
+    let world = World(vec![Entity { x: 0.0, y: 4.0 }, Entity { x: 10.0, y: 20.5 }]);
 
-    let encoded: Vec<u8> = encode(&world, SizeLimit::Infinite).unwrap();
+    let encoded: Vec<u8> = serialize(&world, SizeLimit::Infinite).unwrap();
 
     // 8 bytes for the length of the vector, 4 bytes per float.
     assert_eq!(encoded.len(), 8 + 4 * 4);
 
-    let decoded: World = decode(&encoded[..]).unwrap();
+    let decoded: World = deserialize(&encoded[..]).unwrap();
 
     assert!(world == decoded);
 }
- */
-
-fn main() {}