From 168b8937eb0fe88311fe474ab9569691a19d087f Mon Sep 17 00:00:00 2001
From: Tyler Murphy <tylerm@tylerm.dev>
Date: Wed, 5 Jul 2023 21:34:20 -0400
Subject: changes

---
 src/parse.rs | 110 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 110 insertions(+)
 create mode 100644 src/parse.rs

(limited to 'src/parse.rs')

diff --git a/src/parse.rs b/src/parse.rs
new file mode 100644
index 0000000..60bfc67
--- /dev/null
+++ b/src/parse.rs
@@ -0,0 +1,110 @@
+use crate::header::{Header, HeaderValue, HeaderName};
+use crate::error::HTTPError;
+use crate::method::Method;
+use crate::status::Status;
+use crate::uri::{QueryMap, QueryFragment, Authority, Path, Scheme, URI};
+use crate::version::Version;
+use crate::response::Response;
+use crate::request::Request;
+use std::convert::{From, TryFrom};
+use std::str::FromStr;
+use std::borrow::Cow;
+
+pub trait Parse
+where
+    Self: Sized
+{
+    fn parse(s: impl Into<String>) -> Self;
+}
+
+pub trait TryParse
+where
+    Self: Sized
+{
+    fn try_parse(s: impl Into<String>) -> Result<Self, HTTPError>;
+}
+
+macro_rules! try_into {
+    ($type:ty, $struct:ty) => {
+        impl TryFrom<$type> for $struct {
+            type Error = HTTPError;
+        
+            fn try_from(value: $type) -> Result<Self, Self::Error> {
+                Self::try_parse(value)
+            }
+        }
+    };
+}
+
+macro_rules! try_into_struct {
+    ($struct:ty) => {
+        impl From<$struct> for String {
+            fn from(value: $struct) -> Self {
+                value.to_string()
+            }
+        }
+        
+        try_into!(String, $struct);
+        try_into!(&String, $struct);
+        try_into!(&str, $struct);
+        try_into!(Cow<'_, str>, $struct);
+    };
+}
+
+try_into_struct!(Header);
+try_into_struct!(HeaderName);
+try_into_struct!(QueryMap);
+try_into_struct!(QueryFragment);
+try_into_struct!(Authority);
+try_into_struct!(Path);
+try_into_struct!(URI);
+try_into_struct!(Status);
+
+macro_rules! try_into_res {
+    ($type:ty, $struct:ty) => {
+        impl<T: FromStr + ToString> TryFrom<$type> for $struct {
+            type Error = HTTPError;
+        
+            fn try_from(value: $type) -> Result<Self, Self::Error> {
+                Self::try_parse(value)
+            }
+        }
+    };
+}
+
+macro_rules! try_into_struct_res {
+    ($struct:ty) => {
+        impl<T: FromStr + ToString> From<$struct> for String {
+            fn from(value: $struct) -> Self {
+                value.to_string()
+            }
+        }
+        
+        try_into_res!(String, $struct);
+        try_into_res!(&String, $struct);
+        try_into_res!(&str, $struct);
+        try_into_res!(Cow<'_, str>, $struct);
+    };
+}
+
+try_into_struct_res!(Request<T>);
+try_into_struct_res!(Response<T>);
+
+macro_rules! into_struct {
+    ($struct:ty) => {
+        impl<T> From<T> for $struct
+        where
+            T: Into<String>
+        {
+            fn from(value: T) -> Self {
+                Self::parse(value)
+            }
+        }
+
+    };
+}
+
+into_struct!(Scheme);
+into_struct!(HeaderValue);
+into_struct!(Method);
+into_struct!(Version);
-- 
cgit v1.2.3-freya