Implemented a few things

src/http/mod.rs

@@ -1,5 +1,6 @@
 pub use request::Request;
 pub use method::Method;
+pub use request::ParseError;
 
 pub mod request;
 pub mod method;

src/http/request.rs

@@ -1,7 +1,9 @@
+use std::str;
 use super::method::Method;
 use std::convert::TryFrom;
 use std::io::Error;
-use std::fmt::{Display, Debug};
+use std::fmt::{Display, Debug, Formatter};
+use std::str::Utf8Error;
 
 pub struct Request {
     path: String,
@@ -14,17 +16,51 @@ impl Request {
 }
 
 impl TryFrom<&[u8]> for Request {
-    type Error = String;
+    type Error = ParseError;
 
+    //GET /search?name=abc&sort=1 HTTP/1.1
     fn try_from(buffer: &[u8]) -> Result<Self, Self::Error> {
-        todo!()
+        match str::from_utf8(buffer){
+            Ok(request) => {}
+            Err(_) => return Err(ParseError::InvalidEncoding),
+        }
+        match str::from_utf8(buffer).or(Err(ParseError::InvalidEncoding)) {
+            Ok(request) => {}
+            Err(e) => return Err(e)
+        }
+
+        let request = str::from_utf8(buffer).or(Err(ParseError::InvalidEncoding))?;
+    }
+}
+
+impl Display for ParseError {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", self.message())
+    }
+}
+
+impl Debug for ParseError {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", self.message())
     }
 }
 
 pub enum ParseError {
     InvalidRequest,
     InvalidEncoding,
-    InvalidProtocol
+    InvalidProtocol,
+    InvalidMethod
+}
+
+impl ParseError{
+    fn message(&self) -> &str{
+        match self {
+            ParseError::InvalidRequest => {"Invalid Request"}
+            ParseError::InvalidEncoding => {"Invalid Encoding"}
+            ParseError::InvalidProtocol => {"Invalid Protocol"}
+            ParseError::InvalidMethod => {"Invalid Method"}
+        }
+    }
 }
 
 impl Error for ParseError {