Add method router.

src/errors.rs

@@ -23,3 +23,5 @@ pub use search::SearchError;
 pub use crate::routers::path::errors::{
     PathConstraintError, PathDeleteError, PathInsertError, PathRouteError, PathSearchError,
 };
+
+pub use crate::routers::method::errors::{MethodDeleteError, MethodInsertError, MethodSearchError};

src/errors/delete.rs

@@ -1,11 +1,12 @@
 use super::PathDeleteError;
+use crate::routers::method::errors::MethodDeleteError;
 use core::{error::Error, fmt::Display};
 
 /// Errors relating to attempting to delete a route from a [`Router`](crate::Router).
 #[derive(Debug, PartialEq, Eq)]
 pub enum DeleteError {
-    /// A [`PathDeleteError`] occurred.
     PathDeleteError(PathDeleteError),
+    MethodDeleteError(MethodDeleteError),
 }
 
 impl Error for DeleteError {}
@@ -14,6 +15,7 @@ impl Display for DeleteError {
     fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         match self {
             Self::PathDeleteError(error) => error.fmt(f),
+            Self::MethodDeleteError(error) => error.fmt(f),
         }
     }
 }
@@ -23,3 +25,9 @@ impl From<PathDeleteError> for DeleteError {
         Self::PathDeleteError(error)
     }
 }
+
+impl From<MethodDeleteError> for DeleteError {
+    fn from(error: MethodDeleteError) -> Self {
+        Self::MethodDeleteError(error)
+    }
+}

src/errors/insert.rs

@@ -1,11 +1,11 @@
-use crate::routers::path::errors::PathInsertError;
+use crate::routers::{method::errors::MethodInsertError, path::errors::PathInsertError};
 use core::{error::Error, fmt::Display};
 
 /// Errors relating to attempting to insert a route into a [`Router`](crate::Router).
 #[derive(Debug, PartialEq, Eq)]
 pub enum InsertError {
-    /// A [`PathInsertError`] occurred.
     PathInsertError(PathInsertError),
+    MethodInsertError(MethodInsertError),
 }
 
 impl Error for InsertError {}
@@ -14,6 +14,7 @@ impl Display for InsertError {
     fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         match self {
             Self::PathInsertError(error) => error.fmt(f),
+            Self::MethodInsertError(error) => error.fmt(f),
         }
     }
 }
@@ -23,3 +24,9 @@ impl From<PathInsertError> for InsertError {
         Self::PathInsertError(error)
     }
 }
+
+impl From<MethodInsertError> for InsertError {
+    fn from(error: MethodInsertError) -> Self {
+        Self::MethodInsertError(error)
+    }
+}

src/errors/search.rs

@@ -1,11 +1,12 @@
 use super::PathSearchError;
+use crate::routers::method::errors::MethodSearchError;
 use core::{error::Error, fmt::Display};
 
 /// Errors relating to attempting to search for a match in a [`Router`](crate::Router).
 #[derive(Debug, PartialEq, Eq)]
 pub enum SearchError {
-    /// A [`PathSearchError`] occurred.
     PathSearchError(PathSearchError),
+    MethodSearchError(MethodSearchError),
 }
 
 impl Error for SearchError {}
@@ -14,6 +15,7 @@ impl Display for SearchError {
     fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         match self {
             Self::PathSearchError(error) => error.fmt(f),
+            Self::MethodSearchError(error) => error.fmt(f),
         }
     }
 }
@@ -23,3 +25,9 @@ impl From<PathSearchError> for SearchError {
         Self::PathSearchError(error)
     }
 }
+
+impl From<MethodSearchError> for SearchError {
+    fn from(error: MethodSearchError) -> Self {
+        Self::MethodSearchError(error)
+    }
+}

src/route.rs

@@ -2,24 +2,31 @@ use crate::{decode::percent_decode, errors::RouteError};
 use alloc::{
     borrow::ToOwned,
     string::{String, ToString},
+    vec::Vec,
 };
+use http::Method;
 
 /// A route that can be inserted into a [`Router`](`crate::Router`).
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct Route<'r> {
     pub(crate) route: &'r str,
+    pub(crate) methods: Option<Vec<Method>>,
 }
 
 /// Builder pattern for creating a [`Route`].
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct RouteBuilder<'r> {
     route: Option<&'r str>,
+    methods: Option<Vec<Method>>,
 }
 
 impl<'r> RouteBuilder<'r> {
     #[must_use]
     pub const fn new() -> Self {
-        Self { route: None }
+        Self {
+            route: None,
+            methods: None,
+        }
     }
 
     #[must_use]
@@ -28,6 +35,12 @@ impl<'r> RouteBuilder<'r> {
         self
     }
 
+    #[must_use]
+    pub fn methods(mut self, methods: Vec<Method>) -> Self {
+        self.methods = Some(methods);
+        self
+    }
+
     /// Builds a new [`Route`] instance from the builder.
     ///
     /// # Errors
@@ -44,7 +57,10 @@ impl<'r> RouteBuilder<'r> {
             })?;
         }
 
-        Ok(Route { route })
+        Ok(Route {
+            route,
+            methods: self.methods,
+        })
     }
 }
 

src/routers.rs

@@ -1,27 +1,34 @@
 use crate::{
     errors::{DeleteError, InsertError, SearchError},
     id::RouteId,
-    map::RouteMap,
     Request, Route,
 };
-use path::{PathMatch, PathRouter};
+use hashbrown::HashMap;
+use method::MethodRouter;
+use path::{PathData, PathMatch, PathRouter};
 
+pub mod method;
 pub mod path;
 
 pub type Match<'r, 'p, T> = PathMatch<'r, 'p, T>;
 
 #[derive(Clone)]
 pub struct Router<'r, T> {
     pub path: PathRouter<'r>,
-    data: RouteMap<T>,
+    pub method: MethodRouter<T>,
+
+    /// Stored data.
+    data: HashMap<RouteId, T>,
 }
 
 impl<'r, T> Router<'r, T> {
     #[must_use]
     pub fn new() -> Self {
         Self {
             path: PathRouter::new(),
-            data: RouteMap::default(),
+            method: MethodRouter::new(),
+
+            data: HashMap::new(),
         }
     }
 
@@ -30,6 +37,8 @@ impl<'r, T> Router<'r, T> {
         let id = RouteId::new();
 
         self.path.insert(route, id)?;
+        self.method.insert(route, id)?;
+
         self.data.insert(id, value);
 
         Ok(())
@@ -38,6 +47,7 @@ impl<'r, T> Router<'r, T> {
     #[allow(clippy::missing_errors_doc)]
     pub fn delete(&mut self, route: &Route<'r>) -> Result<(), DeleteError> {
         let path_data = self.path.delete(route)?;
+        let method_delete = self.method.delete(route)?;
 
         let path_id = path_data.id;
         self.data.remove(&path_id);

src/routers/method.rs

@@ -0,0 +1,36 @@
+use crate::Route;
+use errors::{MethodDeleteError, MethodInsertError, MethodSearchError};
+use http::Method;
+
+pub mod errors;
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub enum MethodData<T> {}
+
+#[derive(Debug, Eq, PartialEq)]
+pub struct PathMatch<T> {}
+
+#[derive(Clone)]
+pub struct MethodRouter<T> {}
+
+impl<T> MethodRouter<T> {
+    pub fn new() -> Self {
+        Self {}
+    }
+
+    pub fn insert<'r>(
+        &mut self,
+        route: &Route<'r>,
+        value: Option<T>,
+    ) -> Result<(), MethodInsertError> {
+        Ok(())
+    }
+
+    pub fn delete<'r>(&mut self, route: &Route<'r>) -> Result<MethodData<T>, MethodDeleteError> {
+        Ok(())
+    }
+
+    pub fn search(&self, method: Method) -> Result<Option<MethodMatch<T>>, MethodSearchError> {
+        Ok(None)
+    }
+}

src/routers/method/errors.rs

@@ -0,0 +1,8 @@
+pub mod delete;
+pub use delete::MethodDeleteError;
+
+pub mod insert;
+pub use insert::MethodInsertError;
+
+pub mod search;
+pub use search::MethodSearchError;

src/routers/method/errors/delete.rs

@@ -0,0 +1,12 @@
+use core::{error::Error, fmt::Display};
+
+#[derive(Debug, PartialEq, Eq)]
+pub enum MethodDeleteError {}
+
+impl Error for MethodDeleteError {}
+
+impl Display for MethodDeleteError {
+    fn fmt(&self, _: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        Ok(())
+    }
+}

src/routers/method/errors/insert.rs

@@ -0,0 +1,12 @@
+use core::{error::Error, fmt::Display};
+
+#[derive(Debug, PartialEq, Eq)]
+pub enum MethodInsertError {}
+
+impl Error for MethodInsertError {}
+
+impl Display for MethodInsertError {
+    fn fmt(&self, _: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        Ok(())
+    }
+}

src/routers/method/errors/search.rs

@@ -0,0 +1,12 @@
+use core::{error::Error, fmt::Display};
+
+#[derive(Debug, PartialEq, Eq)]
+pub enum MethodSearchError {}
+
+impl Error for MethodSearchError {}
+
+impl Display for MethodSearchError {
+    fn fmt(&self, _: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        Ok(())
+    }
+}

src/routers/path/errors/route.rs

@@ -1,6 +1,5 @@
-use alloc::string::String;
-
 use crate::errors::EncodingError;
+use alloc::string::String;
 
 /// Errors relating to malformed routes.
 #[derive(Debug, PartialEq, Eq)]