From e13a2a42b163fc8d2b6a663d58c962f76053f3e2 Mon Sep 17 00:00:00 2001
From: Ty Overby <ty@pre-alpha.com>
Date: Wed, 17 Sep 2014 01:36:53 -0700
Subject: [PATCH] implemented helper functions

---
 README.md     |  9 ++-------
 src/lib.rs    | 44 ++++++++++++++++++++++++++++++++++++++++++++
 src/reader.rs |  6 ++++--
 3 files changed, 50 insertions(+), 9 deletions(-)

diff --git a/README.md b/README.md
index 8042e74..b531859 100644
--- a/README.md
+++ b/README.md
@@ -1,9 +1,4 @@
 # Binary Encoder / Decoder
 
-I needed a more efficient way to store serialized rust ofjects than just
-serializing everything to JSON.
-
-This encoder + decoder pair encodes the data that it recieves in a binary
-format that is at least as space efficient as it is in memory.
-
-This encoding strategy is not backwards compatible.  If you change the
+A compact encoder / decoder pair that uses an binary encoding scheme similar
+to how the data is laid out in memory.
diff --git a/src/lib.rs b/src/lib.rs
index 0bc73bd..9fd29b5 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -2,11 +2,55 @@
 
 extern crate serialize;
 
+use std::io::MemWriter;
+use std::io::MemReader;
+use std::io::IoError;
+use serialize::Encodable;
+use serialize::Decodable;
+use serialize::Encoder;
+use serialize::Decoder;
+
 pub use writer::EncoderWriter;
 pub use reader::DecoderReader;
 
 mod writer;
 mod reader;
 
+pub fn encode<T: Encodable<EncoderWriter<MemWriter>, IoError>>(t: &T) -> Result<Vec<u8>, IoError> {
+    match encode_into(t, MemWriter::new()) {
+        Ok(w) => Ok(w.unwrap()),
+        Err((w, e)) => Err(e)
+    }
+}
+
+pub fn decode<T: Decodable<DecoderReader<MemReader>, IoError>>(b: Vec<u8>) ->
+Result<(T, Vec<u8>), (IoError, Vec<u8>)> {
+    match decode_from(MemReader::new(b)) {
+        Ok((t, r)) => Ok((t, r.unwrap())),
+        Err((e, r)) => Err((e, r.unwrap()))
+    }
+}
+
+pub fn encode_into<W: Writer, T: Encodable<EncoderWriter<W>, IoError>>
+(t: &T, w: W)
+-> Result<W, (W, IoError)> {
+    let mut writer = writer::EncoderWriter::new(w);
+    match t.encode(&mut writer) {
+        Ok(()) => Ok(writer.unwrap()),
+        Err(e) => Err((writer.unwrap(), e))
+    }
+}
+
+pub fn decode_from<R: Reader, T: Decodable<DecoderReader<R>, IoError>>(r: R) -> Result<(T, R), (IoError, R)> {
+    let mut reader = reader::DecoderReader::new(r);
+    let x: Result<T, IoError> = Decodable::decode(&mut reader);
+    let mem = reader.unwrap();
+
+    match x {
+        Ok(t) => Ok((t, mem)),
+        Err(e) => Err((e, mem))
+    }
+}
+
 #[cfg(test)]
 mod test;
diff --git a/src/reader.rs b/src/reader.rs
index 1141a03..6034542 100644
--- a/src/reader.rs
+++ b/src/reader.rs
@@ -2,6 +2,7 @@ use std::io::Reader;
 use std::io::BufferedReader;
 use std::io::IoError;
 use std::io::OtherIoError;
+use std::io::RefReader;
 use serialize::Decoder;
 
 type EwResult = Result<(), IoError>;
@@ -12,9 +13,10 @@ pub struct DecoderReader<R> {
 
 impl <R: Reader> DecoderReader<R> {
     pub fn new(r: R) -> DecoderReader<R> {
-        DecoderReader{ reader: BufferedReader::new(r) }
+        DecoderReader {
+            reader: BufferedReader::new(r)
+        }
     }
-
     pub fn unwrap(self) -> R {
         self.reader.unwrap()
     }