Update to new serde de/ser interface

2 files changed, 38 insertions, 34 deletions

diff --git a/src/annotation.rs b/src/annotation.rs
index 682c170..a56c41b 100644
--- a/src/annotation.rs
+++ b/src/annotation.rs
@@ -55,10 +55,12 @@ impl Serialize for Annotation {
     fn serialize<S>(&self, serializer: S) -> RResult<S::Ok, S::Error>
         where S: Serializer
     {
+        use serde::ser::SerializeStruct;
+
         let mut state = try!(serializer.serialize_struct("Annotation", 2));
-        try!(serializer.serialize_struct_elt(&mut state, "entry", &self.entry));
-        try!(serializer.serialize_struct_elt(&mut state, "description", &self.description));
-        serializer.serialize_struct_end(state)
+        try!(state.serialize_field("entry", &self.entry));
+        try!(state.serialize_field("description", &self.description));
+        state.end()
     }
 
 }
@@ -91,6 +93,8 @@ impl Visitor for AnnotationDeserializeVisitor {
     fn visit_map<V>(self, mut visitor: V) -> RResult<Annotation, V::Error>
         where V: DeserializeMapVisitor
     {
+        use serde::de::Error;
+
         let mut entry       = None;
         let mut description = None;
 
@@ -120,16 +124,14 @@ impl Visitor for AnnotationDeserializeVisitor {
 
         let entry = match entry {
             Some(entry) => entry,
-            None => try!(visitor.missing_field("entry")),
+            None => return Err(V::Error::missing_field("entry")),
         };
 
         let description = match description {
             Some(description) => description,
-            None => try!(visitor.missing_field("description")),
+            None => return Err(V::Error::missing_field("description")),
         };
 
-        try!(visitor.end());
-
         Ok(Annotation::new(entry, description))
     }
 }
diff --git a/src/task.rs b/src/task.rs
index 477a257..c28d8ea 100644
--- a/src/task.rs
+++ b/src/task.rs
@@ -243,72 +243,74 @@ impl Serialize for Task {
     fn serialize<S>(&self, serializer: S) -> RResult<S::Ok, S::Error>
         where S: Serializer
     {
+        use serde::ser::SerializeStruct;
+
         let mut state = try!(serializer.serialize_struct("Task", 19));
-        try!(serializer.serialize_struct_elt(&mut state, "status", &self.status));
-        try!(serializer.serialize_struct_elt(&mut state, "uuid", &self.uuid));
-        try!(serializer.serialize_struct_elt(&mut state, "entry", &self.entry));
-        try!(serializer.serialize_struct_elt(&mut state, "description", &self.description));
-        try!(serializer.serialize_struct_elt(&mut state, "annotations", &self.annotations));
-        try!(serializer.serialize_struct_elt(&mut state, "tags", &self.tags));
+        try!(state.serialize_field("status", &self.status));
+        try!(state.serialize_field("uuid", &self.uuid));
+        try!(state.serialize_field("entry", &self.entry));
+        try!(state.serialize_field("description", &self.description));
+        try!(state.serialize_field("annotations", &self.annotations));
+        try!(state.serialize_field("tags", &self.tags));
 
         match self.recur {
-            Some(ref v) => try!(serializer.serialize_struct_elt(&mut state, "recur", v)),
+            Some(ref v) => try!(state.serialize_field("recur", v)),
             None => { },
         }
         match self.depends {
-            Some(ref v) => try!(serializer.serialize_struct_elt(&mut state, "depends", v)),
+            Some(ref v) => try!(state.serialize_field("depends", v)),
             None => { },
         }
         match self.due {
-            Some(ref v) => try!(serializer.serialize_struct_elt(&mut state, "due", v)),
+            Some(ref v) => try!(state.serialize_field("due", v)),
             None => { },
         }
         match self.end {
-            Some(ref v) => try!(serializer.serialize_struct_elt(&mut state, "end", v)),
+            Some(ref v) => try!(state.serialize_field("end", v)),
             None => { },
         }
         match self.imask {
-            Some(ref v) => try!(serializer.serialize_struct_elt(&mut state, "imask", v)),
+            Some(ref v) => try!(state.serialize_field("imask", v)),
             None => { },
         }
         match self.mask {
-            Some(ref v) => try!(serializer.serialize_struct_elt(&mut state, "mask", v)),
+            Some(ref v) => try!(state.serialize_field("mask", v)),
             None => { },
         }
         match self.modified {
-            Some(ref v) => try!(serializer.serialize_struct_elt(&mut state, "modified", v)),
+            Some(ref v) => try!(state.serialize_field("modified", v)),
             None => { },
         }
         match self.parent {
-            Some(ref v) => try!(serializer.serialize_struct_elt(&mut state, "parent", v)),
+            Some(ref v) => try!(state.serialize_field("parent", v)),
             None => { },
         }
         match self.priority {
-            Some(ref v) => try!(serializer.serialize_struct_elt(&mut state, "priority", v)),
+            Some(ref v) => try!(state.serialize_field("priority", v)),
             None => { },
         }
         match self.project {
-            Some(ref v) => try!(serializer.serialize_struct_elt(&mut state, "project", v)),
+            Some(ref v) => try!(state.serialize_field("project", v)),
             None => { },
         }
         match self.scheduled {
-            Some(ref v) => try!(serializer.serialize_struct_elt(&mut state, "scheduled", v)),
+            Some(ref v) => try!(state.serialize_field("scheduled", v)),
             None => { },
         }
         match self.start {
-            Some(ref v) => try!(serializer.serialize_struct_elt(&mut state, "start", v)),
+            Some(ref v) => try!(state.serialize_field("start", v)),
             None => { },
         }
         match self.until {
-            Some(ref v) => try!(serializer.serialize_struct_elt(&mut state, "until", v)),
+            Some(ref v) => try!(state.serialize_field("until", v)),
             None => { },
         }
         match self.wait {
-            Some(ref v) => try!(serializer.serialize_struct_elt(&mut state, "wait", v)),
+            Some(ref v) => try!(state.serialize_field("wait", v)),
             None => { },
         }
 
-        serializer.serialize_struct_end(state)
+        state.end()
     }
 
 }
@@ -359,6 +361,8 @@ impl Visitor for TaskDeserializeVisitor {
     fn visit_map<V>(self, mut visitor: V) -> RResult<Task, V::Error>
         where V: DeserializeMapVisitor
     {
+        use serde::de::Error;
+
         let mut status      = None;
         let mut uuid        = None;
         let mut entry       = None;
@@ -462,26 +466,24 @@ impl Visitor for TaskDeserializeVisitor {
 
         let status = match status {
             Some(status) => status,
-            None => try!(visitor.missing_field("status")),
+            None => return Err(V::Error::missing_field("status")),
         };
 
         let uuid = match uuid {
             Some(uuid) => uuid,
-            None => try!(visitor.missing_field("uuid")),
+            None => return Err(V::Error::missing_field("uuid")),
         };
 
         let entry = match entry {
             Some(entry) => entry,
-            None => try!(visitor.missing_field("entry")),
+            None => return Err(V::Error::missing_field("entry")),
         };
 
         let description = match description {
             Some(description) => description,
-            None => try!(visitor.missing_field("description")),
+            None => return Err(V::Error::missing_field("description")),
         };
 
-        try!(visitor.end());
-
         let task = Task::new(
             status,
             uuid,