Use Arc<Store> instead of Store for lazy loading

src/app.rs

@@ -86,7 +86,7 @@ impl<Data: Clone + Send + Sync + 'static> App<Data> {
             router: Router::new(),
             default_handler: EndpointData {
                 endpoint: BoxedEndpoint::new(async || http::status::StatusCode::NOT_FOUND),
-                store: Store::new(),
+                store: Arc::new(Store::new()),
             },
         };
 
@@ -240,7 +240,7 @@ impl<T: Clone + Send + 'static> Extract<T> for AppData<T> {
         data: &mut T,
         req: &mut Request,
         params: &Option<RouteMatch<'_>>,
-        store: &Store,
+        store: &Arc<Store>,
     ) -> Self::Fut {
         future::ok(AppData(data.clone()))
     }

src/body.rs

@@ -79,6 +79,7 @@ use http_service::Body;
 use multipart::server::Multipart;
 use std::io::Cursor;
 use std::ops::{Deref, DerefMut};
+use std::sync::Arc;
 
 use crate::{configuration::Store, Extract, IntoResponse, Request, Response, RouteMatch};
 
@@ -101,7 +102,7 @@ impl<S: 'static> Extract<S> for MultipartForm {
         data: &mut S,
         req: &mut Request,
         params: &Option<RouteMatch<'_>>,
-        store: &Store,
+        store: &Arc<Store>,
     ) -> Self::Fut {
         // https://stackoverflow.com/questions/43424982/how-to-parse-multipart-forms-using-abonander-multipart-with-rocket
 
@@ -152,7 +153,7 @@ impl<T: Send + serde::de::DeserializeOwned + 'static, S: 'static> Extract<S> for
         data: &mut S,
         req: &mut Request,
         params: &Option<RouteMatch<'_>>,
-        store: &Store,
+        store: &Arc<Store>,
     ) -> Self::Fut {
         let body = std::mem::replace(req.body_mut(), Body::empty());
         FutureObj::new(Box::new(
@@ -204,7 +205,7 @@ impl<T: Send + serde::de::DeserializeOwned + 'static, S: 'static> Extract<S> for
         data: &mut S,
         req: &mut Request,
         params: &Option<RouteMatch<'_>>,
-        store: &Store,
+        store: &Arc<Store>,
     ) -> Self::Fut {
         let body = std::mem::replace(req.body_mut(), Body::empty());
         FutureObj::new(Box::new(
@@ -252,7 +253,7 @@ impl<S: 'static> Extract<S> for Str {
         data: &mut S,
         req: &mut Request,
         params: &Option<RouteMatch<'_>>,
-        store: &Store,
+        store: &Arc<Store>,
     ) -> Self::Fut {
         let body = std::mem::replace(req.body_mut(), Body::empty());
 
@@ -288,7 +289,7 @@ impl<S: 'static> Extract<S> for StrLossy {
         data: &mut S,
         req: &mut Request,
         params: &Option<RouteMatch<'_>>,
-        store: &Store,
+        store: &Arc<Store>,
     ) -> Self::Fut {
         let body = std::mem::replace(req.body_mut(), Body::empty());
 
@@ -324,7 +325,7 @@ impl<S: 'static> Extract<S> for Bytes {
         data: &mut S,
         req: &mut Request,
         params: &Option<RouteMatch<'_>>,
-        store: &Store,
+        store: &Arc<Store>,
     ) -> Self::Fut {
         let body = std::mem::replace(req.body_mut(), Body::empty());
 

src/configuration/mod.rs

@@ -3,6 +3,7 @@
 use std::any::{Any, TypeId};
 use std::collections::HashMap;
 use std::fmt::{self, Debug};
+use std::sync::Arc;
 
 use futures::future::FutureObj;
 
@@ -106,7 +107,7 @@ where
         data: &mut S,
         req: &mut Request,
         params: &Option<RouteMatch<'_>>,
-        store: &Store,
+        store: &Arc<Store>,
     ) -> Self::Fut {
         // The return type here is Option<K>, but the return type of the result of the future is
         // Result<ExtractConfiguration<T>, Response>, so rustc can infer that K == T, so we do not

src/cookies.rs

@@ -1,5 +1,6 @@
 use cookie::{Cookie, CookieJar, ParseError};
 use futures::future;
+use std::sync::Arc;
 
 use crate::{configuration::Store, response::IntoResponse, Extract, Request, Response, RouteMatch};
 
@@ -28,7 +29,7 @@ impl<S: 'static> Extract<S> for Cookies {
         data: &mut S,
         req: &mut Request,
         params: &Option<RouteMatch<'_>>,
-        store: &Store,
+        store: &Arc<Store>,
     ) -> Self::Fut {
         let cookie_jar = match req.headers().get("Cookie") {
             Some(raw_cookies) => parse_from_header(raw_cookies.to_str().unwrap()),

src/endpoint.rs

@@ -1,4 +1,5 @@
 use futures::future::{Future, FutureObj};
+use std::sync::Arc;
 
 use crate::{
     configuration::Store, extract::Extract, head::Head, IntoResponse, Request, Response, RouteMatch,
@@ -72,12 +73,14 @@ pub trait Endpoint<Data, Kind>: Send + Sync + 'static {
         data: Data,
         req: Request,
         params: Option<RouteMatch<'_>>,
-        store: &Store,
+        store: &Arc<Store>,
     ) -> Self::Fut;
 }
 
 type BoxedEndpointFn<Data> =
-    dyn Fn(Data, Request, Option<RouteMatch>, &Store) -> FutureObj<'static, Response> + Send + Sync;
+    dyn Fn(Data, Request, Option<RouteMatch>, &Arc<Store>) -> FutureObj<'static, Response>
+        + Send
+        + Sync;
 
 pub(crate) struct BoxedEndpoint<Data> {
     endpoint: Box<BoxedEndpointFn<Data>>,
@@ -100,7 +103,7 @@ impl<Data> BoxedEndpoint<Data> {
         data: Data,
         req: Request,
         params: Option<RouteMatch<'_>>,
-        store: &Store,
+        store: &Arc<Store>,
     ) -> FutureObj<'static, Response> {
         (self.endpoint)(data, req, params, store)
     }
@@ -134,7 +137,7 @@ macro_rules! end_point_impl_raw {
             type Fut = FutureObj<'static, Response>;
 
             #[allow(unused_mut, non_snake_case)]
-            fn call(&self, mut data: Data, mut req: Request, params: Option<RouteMatch<'_>>, store: &Store) -> Self::Fut {
+            fn call(&self, mut data: Data, mut req: Request, params: Option<RouteMatch<'_>>, store: &Arc<Store>) -> Self::Fut {
                 let f = self.clone();
                 $(let $X = $X::extract(&mut data, &mut req, &params, store);)*
                 FutureObj::new(Box::new(async move {

src/extract.rs

@@ -1,4 +1,5 @@
 use futures::prelude::*;
+use std::sync::Arc;
 
 use crate::{configuration::Store, Request, Response, RouteMatch};
 
@@ -15,6 +16,6 @@ pub trait Extract<Data>: Send + Sized + 'static {
         data: &mut Data,
         req: &mut Request,
         params: &Option<RouteMatch<'_>>,
-        store: &Store,
+        store: &Arc<Store>,
     ) -> Self::Fut;
 }

src/head.rs

@@ -102,7 +102,7 @@ impl<T: Send + 'static + std::str::FromStr, S: 'static> Extract<S> for Path<T> {
         data: &mut S,
         req: &mut Request,
         params: &Option<RouteMatch<'_>>,
-        store: &Store,
+        store: &Arc<Store>,
     ) -> Self::Fut {
         let &PathIdx(i) = req.extensions().get::<PathIdx>().unwrap_or(&PathIdx(0));
         req.extensions_mut().insert(PathIdx(i + 1));
@@ -185,7 +185,7 @@ impl<T: NamedSegment, S: 'static> Extract<S> for Named<T> {
         data: &mut S,
         req: &mut Request,
         params: &Option<RouteMatch<'_>>,
-        store: &Store,
+        store: &Arc<Store>,
     ) -> Self::Fut {
         match params {
             Some(params) => params
@@ -215,7 +215,7 @@ where
         data: &mut S,
         req: &mut Request,
         params: &Option<RouteMatch<'_>>,
-        store: &Store,
+        store: &Arc<Store>,
     ) -> Self::Fut {
         req.uri().query().and_then(|q| q.parse().ok()).map_or(
             future::err(http::status::StatusCode::BAD_REQUEST.into_response()),

src/request.rs

@@ -1,6 +1,7 @@
 use futures::future;
 use http_service::Body;
 use std::ops::{Deref, DerefMut};
+use std::sync::Arc;
 
 use crate::{configuration::Store, Extract, Response, RouteMatch};
 
@@ -58,7 +59,7 @@ impl<Data: 'static, T: Compute> Extract<Data> for Computed<T> {
         data: &mut Data,
         req: &mut Request,
         params: &Option<RouteMatch<'_>>,
-        store: &Store,
+        store: &Arc<Store>,
     ) -> Self::Fut {
         future::ok(Computed(T::compute(req)))
     }

src/router.rs

@@ -16,7 +16,7 @@ use path_table::{PathTable, RouteMatch};
 pub struct Router<Data> {
     table: PathTable<ResourceData<Data>>,
     middleware_base: Vec<Arc<dyn Middleware<Data> + Send + Sync>>,
-    pub(crate) store_base: Store,
+    pub(crate) store_base: Arc<Store>,
 }
 
 pub(crate) struct RouteResult<'a, Data> {
@@ -115,7 +115,7 @@ impl<Data: Clone + Send + Sync + 'static> Router<Data> {
         Router {
             table: PathTable::new(),
             middleware_base: Vec::new(),
-            store_base: Store::new(),
+            store_base: Arc::new(Store::new()),
         }
     }
 
@@ -160,7 +160,7 @@ impl<Data: Clone + Send + Sync + 'static> Router<Data> {
     ///
     /// The default configuration will be applied when the router setup ends.
     pub fn config<T: Any + Debug + Clone + Send + Sync>(&mut self, item: T) -> &mut Self {
-        self.store_base.write(item);
+        Arc::get_mut(&mut self.store_base).unwrap().write(item);
         self
     }
 
@@ -182,7 +182,9 @@ impl<Data> Router<Data> {
     pub(crate) fn apply_default_config(&mut self) {
         for resource in self.table.iter_mut() {
             for endpoint in resource.endpoints.values_mut() {
-                endpoint.store.merge(&self.store_base);
+                Arc::get_mut(&mut endpoint.store)
+                    .unwrap()
+                    .merge(&self.store_base);
             }
         }
     }
@@ -197,13 +199,13 @@ impl<Data> Router<Data> {
 /// This can be used to add configuration items to the endpoint.
 pub struct EndpointData<Data> {
     pub(crate) endpoint: BoxedEndpoint<Data>,
-    pub(crate) store: Store,
+    pub(crate) store: Arc<Store>,
 }
 
 impl<Data> EndpointData<Data> {
     /// Add a configuration `item` for this endpoint.
     pub fn config<T: Any + Debug + Clone + Send + Sync>(&mut self, item: T) -> &mut Self {
-        self.store.write(item);
+        Arc::get_mut(&mut self.store).unwrap().write(item);
         self
     }
 }
@@ -238,7 +240,7 @@ impl<'a, Data> Resource<'a, Data> {
         let mut subrouter = Router {
             table: PathTable::new(),
             middleware_base: self.middleware_base.clone(),
-            store_base: Store::new(),
+            store_base: Arc::new(Store::new()),
         };
         builder(&mut subrouter);
         subrouter.apply_default_config();
@@ -268,7 +270,7 @@ impl<'a, Data> Resource<'a, Data> {
 
         let endpoint = EndpointData {
             endpoint: BoxedEndpoint::new(ep),
-            store: Store::new(),
+            store: Arc::new(Store::new()),
         };
 
         entry.or_insert(endpoint)
@@ -340,7 +342,7 @@ mod tests {
     ) -> Option<Response> {
         let default_handler = Arc::new(EndpointData {
             endpoint: BoxedEndpoint::new(async || http::status::StatusCode::NOT_FOUND),
-            store: Store::new(),
+            store: Arc::new(Store::new()),
         });
         let RouteResult {
             endpoint,
@@ -372,7 +374,7 @@ mod tests {
     ) -> Option<usize> {
         let default_handler = Arc::new(EndpointData {
             endpoint: BoxedEndpoint::new(async || http::status::StatusCode::NOT_FOUND),
-            store: Store::new(),
+            store: Arc::new(Store::new()),
         });
         let route_result = router.route(path, method, &default_handler);
         Some(route_result.middleware.len())