feat(lib): switch to non-blocking (asynchronous) IO

BREAKING CHANGE: This breaks a lot of the Client and Server APIs.
  Check the documentation for how Handlers can be used for asynchronous
  events.

src/header/internals/cell.rs

@@ -1,7 +1,6 @@
 use std::any::{Any, TypeId};
 use std::cell::UnsafeCell;
 use std::collections::HashMap;
-use std::fmt;
 use std::mem;
 use std::ops::Deref;
 
@@ -53,7 +52,7 @@ enum PtrMap<T> {
     Many(HashMap<TypeId, T>)
 }
 
-impl<V: ?Sized + fmt::Debug + Any + 'static> PtrMapCell<V> {
+impl<V: ?Sized + Any + 'static> PtrMapCell<V> {
     #[inline]
     pub fn new() -> PtrMapCell<V> {
         PtrMapCell(UnsafeCell::new(PtrMap::Empty))
@@ -114,12 +113,12 @@ impl<V: ?Sized + fmt::Debug + Any + 'static> PtrMapCell<V> {
         let map = &*self.0.get();
         match *map {
             PtrMap::One(_, ref one) => one,
-            _ => panic!("not PtrMap::One value, {:?}", *map)
+            _ => panic!("not PtrMap::One value")
         }
     }
 }
 
-impl<V: ?Sized + fmt::Debug + Any + 'static> Clone for PtrMapCell<V> where Box<V>: Clone {
+impl<V: ?Sized + Any + 'static> Clone for PtrMapCell<V> where Box<V>: Clone {
     #[inline]
     fn clone(&self) -> PtrMapCell<V> {
         let cell = PtrMapCell::new();

src/header/internals/item.rs

@@ -4,13 +4,13 @@ use std::fmt;
 use std::str::from_utf8;
 
 use super::cell::{OptCell, PtrMapCell};
-use header::{Header, HeaderFormat};
+use header::{Header};
 
 
 #[derive(Clone)]
 pub struct Item {
     raw: OptCell<Vec<Vec<u8>>>,
-    typed: PtrMapCell<HeaderFormat + Send + Sync>
+    typed: PtrMapCell<Header + Send + Sync>
 }
 
 impl Item {
@@ -23,7 +23,7 @@ impl Item {
     }
 
     #[inline]
-    pub fn new_typed(ty: Box<HeaderFormat + Send + Sync>) -> Item {
+    pub fn new_typed(ty: Box<Header + Send + Sync>) -> Item {
         let map = PtrMapCell::new();
         unsafe { map.insert((*ty).get_type(), ty); }
         Item {
@@ -52,7 +52,7 @@ impl Item {
         &raw[..]
     }
 
-    pub fn typed<H: Header + HeaderFormat + Any>(&self) -> Option<&H> {
+    pub fn typed<H: Header + Any>(&self) -> Option<&H> {
         let tid = TypeId::of::<H>();
         match self.typed.get(tid) {
             Some(val) => Some(val),
@@ -68,7 +68,7 @@ impl Item {
         }.map(|typed| unsafe { typed.downcast_ref_unchecked() })
     }
 
-    pub fn typed_mut<H: Header + HeaderFormat>(&mut self) -> Option<&mut H> {
+    pub fn typed_mut<H: Header>(&mut self) -> Option<&mut H> {
         let tid = TypeId::of::<H>();
         if self.typed.get_mut(tid).is_none() {
             match parse::<H>(self.raw.as_ref().expect("item.raw must exist")) {
@@ -83,11 +83,11 @@ impl Item {
 }
 
 #[inline]
-fn parse<H: Header + HeaderFormat>(raw: &Vec<Vec<u8>>) ->
-        ::Result<Box<HeaderFormat + Send + Sync>> {
+fn parse<H: Header>(raw: &Vec<Vec<u8>>) ->
+        ::Result<Box<Header + Send + Sync>> {
     Header::parse_header(&raw[..]).map(|h: H| {
         // FIXME: Use Type ascription
-        let h: Box<HeaderFormat + Send + Sync> = Box::new(h);
+        let h: Box<Header + Send + Sync> = Box::new(h);
         h
     })
 }