Switch to string crate (#6)

src/hpack/decoder.rs

@@ -1,13 +1,14 @@
 use super::{huffman, Header};
 use frame;
-use util::byte_str::FromUtf8Error;
 
 use http::{method, header, status};
 use bytes::{Buf, Bytes, BytesMut};
+use string::String;
 
 use std::cmp;
 use std::io::Cursor;
 use std::collections::VecDeque;
+use std::str::Utf8Error;
 
 /// Decodes headers using HPACK
 #[derive(Debug)]
@@ -487,8 +488,8 @@ impl Table {
 
 // ===== impl DecoderError =====
 
-impl From<FromUtf8Error> for DecoderError {
-    fn from(_: FromUtf8Error) -> DecoderError {
+impl From<Utf8Error> for DecoderError {
+    fn from(_: Utf8Error) -> DecoderError {
         // TODO: Better error?
         DecoderError::InvalidUtf8
     }
@@ -532,16 +533,15 @@ impl From<DecoderError> for frame::Error {
 pub fn get_static(idx: usize) -> Header {
     use http::{status, method, header};
     use http::header::HeaderValue;
-    use util::byte_str::ByteStr;
 
     match idx {
-        1 => Header::Authority(ByteStr::from_static("")),
+        1 => Header::Authority(from_static("")),
         2 => Header::Method(method::GET),
         3 => Header::Method(method::POST),
-        4 => Header::Path(ByteStr::from_static("/")),
-        5 => Header::Path(ByteStr::from_static("/index.html")),
-        6 => Header::Scheme(ByteStr::from_static("http")),
-        7 => Header::Scheme(ByteStr::from_static("https")),
+        4 => Header::Path(from_static("/")),
+        5 => Header::Path(from_static("/index.html")),
+        6 => Header::Scheme(from_static("http")),
+        7 => Header::Scheme(from_static("https")),
         8 => Header::Status(status::OK),
         9 => Header::Status(status::NO_CONTENT),
         10 => Header::Status(status::PARTIAL_CONTENT),
@@ -740,3 +740,7 @@ pub fn get_static(idx: usize) -> Header {
         _ => unreachable!(),
     }
 }
+
+fn from_static(s: &'static str) -> String<Bytes> {
+    unsafe { String::from_utf8_unchecked(Bytes::from_static(s.as_bytes())) }
+}

src/hpack/header.rs

@@ -1,9 +1,9 @@
 use super::DecoderError;
-use util::byte_str::ByteStr;
 
 use http::{Method, StatusCode};
 use http::header::{HeaderName, HeaderValue};
 use bytes::Bytes;
+use string::{String, TryFrom};
 
 /// HTTP/2.0 Header
 #[derive(Debug, Clone, Eq, PartialEq)]
@@ -12,10 +12,11 @@ pub enum Header<T = HeaderName> {
         name: T,
         value: HeaderValue,
     },
-    Authority(ByteStr),
+    // TODO: Change these types to `http::uri` types.
+    Authority(String<Bytes>),
     Method(Method),
-    Scheme(ByteStr),
-    Path(ByteStr),
+    Scheme(String<Bytes>),
+    Path(String<Bytes>),
     Status(StatusCode),
 }
 
@@ -56,7 +57,7 @@ impl Header {
         if name[0] == b':' {
             match &name[1..] {
                 b"authority" => {
-                    let value = try!(ByteStr::from_utf8(value));
+                    let value = try!(String::try_from(value));
                     Ok(Header::Authority(value))
                 }
                 b"method" => {
@@ -64,11 +65,11 @@ impl Header {
                     Ok(Header::Method(method))
                 }
                 b"scheme" => {
-                    let value = try!(ByteStr::from_utf8(value));
+                    let value = try!(String::try_from(value));
                     Ok(Header::Scheme(value))
                 }
                 b"path" => {
-                    let value = try!(ByteStr::from_utf8(value));
+                    let value = try!(String::try_from(value));
                     Ok(Header::Path(value))
                 }
                 b"status" => {
@@ -231,16 +232,16 @@ impl<'a> Name<'a> {
                 })
             }
             Name::Authority => {
-                Ok(Header::Authority(try!(ByteStr::from_utf8(value))))
+                Ok(Header::Authority(try!(String::try_from(value))))
             }
             Name::Method => {
                 Ok(Header::Method(try!(Method::from_bytes(&*value))))
             }
             Name::Scheme => {
-                Ok(Header::Scheme(try!(ByteStr::from_utf8(value))))
+                Ok(Header::Scheme(try!(String::try_from(value))))
             }
             Name::Path => {
-                Ok(Header::Path(try!(ByteStr::from_utf8(value))))
+                Ok(Header::Path(try!(String::try_from(value))))
             }
             Name::Status => {
                 match StatusCode::from_bytes(&value) {

src/hpack/test/fuzz.rs

@@ -6,7 +6,7 @@ use hpack::{Header, Decoder, Encoder, Encode};
 
 use http::header::{HeaderName, HeaderValue};
 
-use self::bytes::BytesMut;
+use self::bytes::{BytesMut, Bytes};
 use self::quickcheck::{QuickCheck, Arbitrary, Gen, TestResult};
 use self::rand::{StdRng, Rng, SeedableRng};
 
@@ -183,7 +183,7 @@ fn gen_header(g: &mut StdRng) -> Header<Option<HeaderName>> {
         match g.next_u32() % 5 {
             0 => {
                 let value = gen_string(g, 4, 20);
-                Header::Authority(value.into())
+                Header::Authority(to_shared(value))
             }
             1 => {
                 let method = match g.next_u32() % 6 {
@@ -212,7 +212,7 @@ fn gen_header(g: &mut StdRng) -> Header<Option<HeaderName>> {
                     _ => unreachable!(),
                 };
 
-                Header::Scheme(value.into())
+                Header::Scheme(to_shared(value.to_string()))
             }
             3 => {
                 let value = match g.next_u32() % 100 {
@@ -221,7 +221,7 @@ fn gen_header(g: &mut StdRng) -> Header<Option<HeaderName>> {
                     _ => gen_string(g, 2, 20),
                 };
 
-                Header::Path(value.into())
+                Header::Path(to_shared(value))
             }
             4 => {
                 let status = (g.gen::<u16>() % 500) + 100;
@@ -346,3 +346,8 @@ fn gen_string(g: &mut StdRng, min: usize, max: usize) -> String {
 
     String::from_utf8(bytes).unwrap()
 }
+
+fn to_shared(src: String) -> ::string::String<Bytes> {
+    let b: Bytes = src.into();
+    unsafe { ::string::String::from_utf8_unchecked(b) }
+}