2019-03-03 08:57:48 +00:00
|
|
|
use std::cell::RefCell;
|
2018-04-13 23:02:01 +00:00
|
|
|
use std::marker::PhantomData;
|
2019-03-03 08:57:48 +00:00
|
|
|
use std::rc::Rc;
|
2017-10-07 04:48:14 +00:00
|
|
|
|
2019-04-07 21:43:07 +00:00
|
|
|
use actix_http::{Error, Extensions, Payload, Response};
|
2019-03-02 21:57:00 +00:00
|
|
|
use actix_service::{NewService, Service, Void};
|
2019-03-02 06:51:32 +00:00
|
|
|
use futures::future::{ok, FutureResult};
|
|
|
|
use futures::{try_ready, Async, Future, IntoFuture, Poll};
|
2018-05-02 00:30:06 +00:00
|
|
|
|
2019-03-03 21:53:31 +00:00
|
|
|
use crate::extract::FromRequest;
|
2019-03-02 06:51:32 +00:00
|
|
|
use crate::request::HttpRequest;
|
|
|
|
use crate::responder::Responder;
|
2019-04-07 21:43:07 +00:00
|
|
|
use crate::service::{ServiceRequest, ServiceResponse};
|
2017-11-03 20:35:34 +00:00
|
|
|
|
2019-03-02 06:51:32 +00:00
|
|
|
/// Handler converter factory
|
|
|
|
pub trait Factory<T, R>: Clone
|
|
|
|
where
|
|
|
|
R: Responder,
|
|
|
|
{
|
|
|
|
fn call(&self, param: T) -> R;
|
2018-03-10 17:39:43 +00:00
|
|
|
}
|
|
|
|
|
2019-03-02 06:51:32 +00:00
|
|
|
impl<F, R> Factory<(), R> for F
|
2018-04-13 23:02:01 +00:00
|
|
|
where
|
2019-04-04 20:17:55 +00:00
|
|
|
F: Fn() -> R + Clone,
|
|
|
|
R: Responder,
|
2018-03-10 17:39:43 +00:00
|
|
|
{
|
2019-03-02 06:51:32 +00:00
|
|
|
fn call(&self, _: ()) -> R {
|
|
|
|
(self)()
|
2018-03-10 17:39:43 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-03-02 06:51:32 +00:00
|
|
|
#[doc(hidden)]
|
2019-03-07 19:09:42 +00:00
|
|
|
pub struct Handler<F, T, R>
|
2018-04-13 23:02:01 +00:00
|
|
|
where
|
2019-03-02 06:51:32 +00:00
|
|
|
F: Factory<T, R>,
|
|
|
|
R: Responder,
|
2018-04-02 23:19:18 +00:00
|
|
|
{
|
2019-03-02 06:51:32 +00:00
|
|
|
hnd: F,
|
|
|
|
_t: PhantomData<(T, R)>,
|
2018-04-02 23:19:18 +00:00
|
|
|
}
|
|
|
|
|
2019-03-07 19:09:42 +00:00
|
|
|
impl<F, T, R> Handler<F, T, R>
|
2018-06-11 11:05:41 +00:00
|
|
|
where
|
2019-03-02 06:51:32 +00:00
|
|
|
F: Factory<T, R>,
|
|
|
|
R: Responder,
|
2018-06-11 11:05:41 +00:00
|
|
|
{
|
2019-03-02 06:51:32 +00:00
|
|
|
pub fn new(hnd: F) -> Self {
|
2019-03-07 19:09:42 +00:00
|
|
|
Handler {
|
2019-03-02 06:51:32 +00:00
|
|
|
hnd,
|
|
|
|
_t: PhantomData,
|
2018-06-11 11:05:41 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2019-04-08 06:06:21 +00:00
|
|
|
|
|
|
|
impl<F, T, R> Clone for Handler<F, T, R>
|
2019-03-02 06:51:32 +00:00
|
|
|
where
|
|
|
|
F: Factory<T, R>,
|
2019-04-04 20:17:55 +00:00
|
|
|
R: Responder,
|
2019-03-02 06:51:32 +00:00
|
|
|
{
|
2019-04-08 06:06:21 +00:00
|
|
|
fn clone(&self) -> Self {
|
|
|
|
Self {
|
2019-03-02 06:51:32 +00:00
|
|
|
hnd: self.hnd.clone(),
|
|
|
|
_t: PhantomData,
|
2019-04-08 06:06:21 +00:00
|
|
|
}
|
2019-03-02 06:51:32 +00:00
|
|
|
}
|
2017-12-21 04:30:54 +00:00
|
|
|
}
|
|
|
|
|
2019-04-08 06:06:21 +00:00
|
|
|
impl<F, T, R> Service for Handler<F, T, R>
|
2018-04-13 23:02:01 +00:00
|
|
|
where
|
2019-03-02 06:51:32 +00:00
|
|
|
F: Factory<T, R>,
|
2019-04-04 20:17:55 +00:00
|
|
|
R: Responder,
|
2017-10-15 21:17:41 +00:00
|
|
|
{
|
2019-03-09 17:49:11 +00:00
|
|
|
type Request = (T, HttpRequest);
|
2019-03-02 06:51:32 +00:00
|
|
|
type Response = ServiceResponse;
|
2019-03-02 21:57:00 +00:00
|
|
|
type Error = Void;
|
2019-03-07 19:09:42 +00:00
|
|
|
type Future = HandlerServiceResponse<<R::Future as IntoFuture>::Future>;
|
2017-10-15 21:17:41 +00:00
|
|
|
|
2019-03-02 06:51:32 +00:00
|
|
|
fn poll_ready(&mut self) -> Poll<(), Self::Error> {
|
|
|
|
Ok(Async::Ready(()))
|
2017-10-15 21:17:41 +00:00
|
|
|
}
|
|
|
|
|
2019-03-02 06:51:32 +00:00
|
|
|
fn call(&mut self, (param, req): (T, HttpRequest)) -> Self::Future {
|
2019-03-03 21:53:31 +00:00
|
|
|
let fut = self.hnd.call(param).respond_to(&req).into_future();
|
2019-03-07 19:09:42 +00:00
|
|
|
HandlerServiceResponse {
|
2019-03-02 06:51:32 +00:00
|
|
|
fut,
|
|
|
|
req: Some(req),
|
2018-05-02 00:30:06 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-03-07 19:09:42 +00:00
|
|
|
pub struct HandlerServiceResponse<T> {
|
2019-03-02 06:51:32 +00:00
|
|
|
fut: T,
|
|
|
|
req: Option<HttpRequest>,
|
2017-11-29 03:49:17 +00:00
|
|
|
}
|
|
|
|
|
2019-03-07 19:09:42 +00:00
|
|
|
impl<T> Future for HandlerServiceResponse<T>
|
2019-03-02 06:51:32 +00:00
|
|
|
where
|
|
|
|
T: Future<Item = Response>,
|
|
|
|
T::Error: Into<Error>,
|
|
|
|
{
|
|
|
|
type Item = ServiceResponse;
|
2019-03-02 21:57:00 +00:00
|
|
|
type Error = Void;
|
2019-03-02 06:51:32 +00:00
|
|
|
|
|
|
|
fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
|
|
|
|
match self.fut.poll() {
|
|
|
|
Ok(Async::Ready(res)) => Ok(Async::Ready(ServiceResponse::new(
|
|
|
|
self.req.take().unwrap(),
|
|
|
|
res,
|
|
|
|
))),
|
|
|
|
Ok(Async::NotReady) => Ok(Async::NotReady),
|
|
|
|
Err(e) => {
|
|
|
|
let res: Response = e.into().into();
|
|
|
|
Ok(Async::Ready(ServiceResponse::new(
|
|
|
|
self.req.take().unwrap(),
|
|
|
|
res,
|
|
|
|
)))
|
|
|
|
}
|
|
|
|
}
|
2017-11-29 03:49:17 +00:00
|
|
|
}
|
2019-03-02 06:51:32 +00:00
|
|
|
}
|
2017-11-29 03:49:17 +00:00
|
|
|
|
2019-03-02 06:51:32 +00:00
|
|
|
/// Async handler converter factory
|
|
|
|
pub trait AsyncFactory<T, R>: Clone + 'static
|
|
|
|
where
|
|
|
|
R: IntoFuture,
|
|
|
|
R::Item: Into<Response>,
|
|
|
|
R::Error: Into<Error>,
|
|
|
|
{
|
|
|
|
fn call(&self, param: T) -> R;
|
|
|
|
}
|
2018-05-02 00:19:15 +00:00
|
|
|
|
2019-03-02 06:51:32 +00:00
|
|
|
impl<F, R> AsyncFactory<(), R> for F
|
|
|
|
where
|
|
|
|
F: Fn() -> R + Clone + 'static,
|
|
|
|
R: IntoFuture,
|
|
|
|
R::Item: Into<Response>,
|
|
|
|
R::Error: Into<Error>,
|
|
|
|
{
|
|
|
|
fn call(&self, _: ()) -> R {
|
|
|
|
(self)()
|
2017-11-29 03:49:17 +00:00
|
|
|
}
|
2019-03-02 06:51:32 +00:00
|
|
|
}
|
2017-12-09 21:25:06 +00:00
|
|
|
|
2019-03-02 06:51:32 +00:00
|
|
|
#[doc(hidden)]
|
2019-03-07 19:09:42 +00:00
|
|
|
pub struct AsyncHandler<F, T, R>
|
2019-03-02 06:51:32 +00:00
|
|
|
where
|
|
|
|
F: AsyncFactory<T, R>,
|
|
|
|
R: IntoFuture,
|
|
|
|
R::Item: Into<Response>,
|
|
|
|
R::Error: Into<Error>,
|
|
|
|
{
|
|
|
|
hnd: F,
|
|
|
|
_t: PhantomData<(T, R)>,
|
|
|
|
}
|
2018-05-02 00:19:15 +00:00
|
|
|
|
2019-03-07 19:09:42 +00:00
|
|
|
impl<F, T, R> AsyncHandler<F, T, R>
|
2019-03-02 06:51:32 +00:00
|
|
|
where
|
|
|
|
F: AsyncFactory<T, R>,
|
|
|
|
R: IntoFuture,
|
|
|
|
R::Item: Into<Response>,
|
|
|
|
R::Error: Into<Error>,
|
|
|
|
{
|
|
|
|
pub fn new(hnd: F) -> Self {
|
2019-03-07 19:09:42 +00:00
|
|
|
AsyncHandler {
|
2019-03-02 06:51:32 +00:00
|
|
|
hnd,
|
|
|
|
_t: PhantomData,
|
2017-12-09 21:25:06 +00:00
|
|
|
}
|
|
|
|
}
|
2017-11-29 03:49:17 +00:00
|
|
|
}
|
2019-04-08 06:06:21 +00:00
|
|
|
|
|
|
|
impl<F, T, R> Clone for AsyncHandler<F, T, R>
|
2019-03-02 06:51:32 +00:00
|
|
|
where
|
|
|
|
F: AsyncFactory<T, R>,
|
|
|
|
R: IntoFuture,
|
|
|
|
R::Item: Into<Response>,
|
|
|
|
R::Error: Into<Error>,
|
|
|
|
{
|
2019-04-08 06:06:21 +00:00
|
|
|
fn clone(&self) -> Self {
|
|
|
|
AsyncHandler {
|
2019-03-02 06:51:32 +00:00
|
|
|
hnd: self.hnd.clone(),
|
|
|
|
_t: PhantomData,
|
2019-04-08 06:06:21 +00:00
|
|
|
}
|
2017-12-03 00:37:21 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-04-08 06:06:21 +00:00
|
|
|
impl<F, T, R> Service for AsyncHandler<F, T, R>
|
2019-03-02 06:51:32 +00:00
|
|
|
where
|
|
|
|
F: AsyncFactory<T, R>,
|
|
|
|
R: IntoFuture,
|
|
|
|
R::Item: Into<Response>,
|
|
|
|
R::Error: Into<Error>,
|
|
|
|
{
|
2019-03-09 17:49:11 +00:00
|
|
|
type Request = (T, HttpRequest);
|
2019-03-02 06:51:32 +00:00
|
|
|
type Response = ServiceResponse;
|
2019-04-08 06:06:21 +00:00
|
|
|
type Error = Void;
|
2019-03-07 19:09:42 +00:00
|
|
|
type Future = AsyncHandlerServiceResponse<R::Future>;
|
2017-12-02 05:29:22 +00:00
|
|
|
|
2019-03-02 06:51:32 +00:00
|
|
|
fn poll_ready(&mut self) -> Poll<(), Self::Error> {
|
|
|
|
Ok(Async::Ready(()))
|
2017-12-03 00:37:21 +00:00
|
|
|
}
|
|
|
|
|
2019-03-02 06:51:32 +00:00
|
|
|
fn call(&mut self, (param, req): (T, HttpRequest)) -> Self::Future {
|
2019-03-07 19:09:42 +00:00
|
|
|
AsyncHandlerServiceResponse {
|
2019-03-02 06:51:32 +00:00
|
|
|
fut: self.hnd.call(param).into_future(),
|
|
|
|
req: Some(req),
|
2017-12-03 00:37:21 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-03-02 06:51:32 +00:00
|
|
|
#[doc(hidden)]
|
2019-03-07 19:09:42 +00:00
|
|
|
pub struct AsyncHandlerServiceResponse<T> {
|
2019-03-02 06:51:32 +00:00
|
|
|
fut: T,
|
|
|
|
req: Option<HttpRequest>,
|
2018-05-02 00:19:15 +00:00
|
|
|
}
|
|
|
|
|
2019-03-07 19:09:42 +00:00
|
|
|
impl<T> Future for AsyncHandlerServiceResponse<T>
|
2018-08-23 16:48:01 +00:00
|
|
|
where
|
2019-03-02 06:51:32 +00:00
|
|
|
T: Future,
|
|
|
|
T::Item: Into<Response>,
|
|
|
|
T::Error: Into<Error>,
|
2018-05-02 00:19:15 +00:00
|
|
|
{
|
2019-03-02 06:51:32 +00:00
|
|
|
type Item = ServiceResponse;
|
2019-04-08 06:06:21 +00:00
|
|
|
type Error = Void;
|
2019-03-02 06:51:32 +00:00
|
|
|
|
|
|
|
fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
|
|
|
|
match self.fut.poll() {
|
|
|
|
Ok(Async::Ready(res)) => Ok(Async::Ready(ServiceResponse::new(
|
|
|
|
self.req.take().unwrap(),
|
|
|
|
res.into(),
|
|
|
|
))),
|
|
|
|
Ok(Async::NotReady) => Ok(Async::NotReady),
|
|
|
|
Err(e) => {
|
|
|
|
let res: Response = e.into().into();
|
|
|
|
Ok(Async::Ready(ServiceResponse::new(
|
|
|
|
self.req.take().unwrap(),
|
|
|
|
res,
|
|
|
|
)))
|
|
|
|
}
|
2018-01-03 07:43:17 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-03-02 06:51:32 +00:00
|
|
|
/// Extract arguments from request
|
2019-04-08 06:06:21 +00:00
|
|
|
pub struct Extract<P, T: FromRequest<P>, S> {
|
2019-03-03 08:57:48 +00:00
|
|
|
config: Rc<RefCell<Option<Rc<Extensions>>>>,
|
2019-04-08 06:06:21 +00:00
|
|
|
service: S,
|
2019-03-02 06:51:32 +00:00
|
|
|
_t: PhantomData<(P, T)>,
|
2018-01-03 07:43:17 +00:00
|
|
|
}
|
|
|
|
|
2019-04-08 06:06:21 +00:00
|
|
|
impl<P, T: FromRequest<P>, S> Extract<P, T, S> {
|
|
|
|
pub fn new(config: Rc<RefCell<Option<Rc<Extensions>>>>, service: S) -> Self {
|
2019-03-03 08:57:48 +00:00
|
|
|
Extract {
|
|
|
|
config,
|
2019-04-08 06:06:21 +00:00
|
|
|
service,
|
2019-03-03 08:57:48 +00:00
|
|
|
_t: PhantomData,
|
|
|
|
}
|
2018-06-21 08:17:27 +00:00
|
|
|
}
|
2019-03-02 06:51:32 +00:00
|
|
|
}
|
2018-06-21 08:17:27 +00:00
|
|
|
|
2019-04-08 06:06:21 +00:00
|
|
|
impl<P, T: FromRequest<P>, S> NewService for Extract<P, T, S>
|
|
|
|
where
|
|
|
|
S: Service<Request = (T, HttpRequest), Response = ServiceResponse, Error = Void>
|
|
|
|
+ Clone,
|
|
|
|
{
|
2019-03-09 17:49:11 +00:00
|
|
|
type Request = ServiceRequest<P>;
|
2019-04-08 06:06:21 +00:00
|
|
|
type Response = ServiceResponse;
|
2019-04-07 21:43:07 +00:00
|
|
|
type Error = (Error, ServiceRequest<P>);
|
2019-03-02 06:51:32 +00:00
|
|
|
type InitError = ();
|
2019-04-08 06:06:21 +00:00
|
|
|
type Service = ExtractService<P, T, S>;
|
2019-03-02 06:51:32 +00:00
|
|
|
type Future = FutureResult<Self::Service, ()>;
|
2018-07-15 09:12:21 +00:00
|
|
|
|
2019-03-02 06:51:32 +00:00
|
|
|
fn new_service(&self, _: &()) -> Self::Future {
|
2019-03-03 08:57:48 +00:00
|
|
|
ok(ExtractService {
|
|
|
|
_t: PhantomData,
|
|
|
|
config: self.config.borrow().clone(),
|
2019-04-08 06:06:21 +00:00
|
|
|
service: self.service.clone(),
|
2019-03-03 08:57:48 +00:00
|
|
|
})
|
2019-03-02 06:51:32 +00:00
|
|
|
}
|
2017-11-29 21:26:55 +00:00
|
|
|
}
|
|
|
|
|
2019-04-08 06:06:21 +00:00
|
|
|
pub struct ExtractService<P, T: FromRequest<P>, S> {
|
2019-03-03 08:57:48 +00:00
|
|
|
config: Option<Rc<Extensions>>,
|
2019-04-08 06:06:21 +00:00
|
|
|
service: S,
|
2019-03-02 06:51:32 +00:00
|
|
|
_t: PhantomData<(P, T)>,
|
2017-11-29 21:26:55 +00:00
|
|
|
}
|
|
|
|
|
2019-04-08 06:06:21 +00:00
|
|
|
impl<P, T: FromRequest<P>, S> Service for ExtractService<P, T, S>
|
|
|
|
where
|
|
|
|
S: Service<Request = (T, HttpRequest), Response = ServiceResponse, Error = Void>
|
|
|
|
+ Clone,
|
|
|
|
{
|
2019-03-09 17:49:11 +00:00
|
|
|
type Request = ServiceRequest<P>;
|
2019-04-08 06:06:21 +00:00
|
|
|
type Response = ServiceResponse;
|
2019-04-07 21:43:07 +00:00
|
|
|
type Error = (Error, ServiceRequest<P>);
|
2019-04-08 06:06:21 +00:00
|
|
|
type Future = ExtractResponse<P, T, S>;
|
2019-03-02 06:51:32 +00:00
|
|
|
|
|
|
|
fn poll_ready(&mut self) -> Poll<(), Self::Error> {
|
|
|
|
Ok(Async::Ready(()))
|
2017-11-29 21:26:55 +00:00
|
|
|
}
|
|
|
|
|
2019-03-03 03:19:56 +00:00
|
|
|
fn call(&mut self, req: ServiceRequest<P>) -> Self::Future {
|
2019-04-07 21:43:07 +00:00
|
|
|
let (mut req, mut payload) = req.into_parts();
|
|
|
|
req.set_route_data(self.config.clone());
|
|
|
|
let fut = T::from_request(&req, &mut payload).into_future();
|
|
|
|
|
2019-03-02 06:51:32 +00:00
|
|
|
ExtractResponse {
|
2019-04-07 21:43:07 +00:00
|
|
|
fut,
|
2019-04-08 06:06:21 +00:00
|
|
|
fut_s: None,
|
2019-04-07 21:43:07 +00:00
|
|
|
req: Some((req, payload)),
|
2019-04-08 06:06:21 +00:00
|
|
|
service: self.service.clone(),
|
2017-12-03 22:22:04 +00:00
|
|
|
}
|
2017-11-29 21:26:55 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-04-08 06:06:21 +00:00
|
|
|
pub struct ExtractResponse<P, T: FromRequest<P>, S: Service> {
|
2019-04-07 21:43:07 +00:00
|
|
|
req: Option<(HttpRequest, Payload<P>)>,
|
2019-04-08 06:06:21 +00:00
|
|
|
service: S,
|
2019-03-03 21:53:31 +00:00
|
|
|
fut: <T::Future as IntoFuture>::Future,
|
2019-04-08 06:06:21 +00:00
|
|
|
fut_s: Option<S::Future>,
|
2017-11-29 21:26:55 +00:00
|
|
|
}
|
|
|
|
|
2019-04-08 06:06:21 +00:00
|
|
|
impl<P, T: FromRequest<P>, S> Future for ExtractResponse<P, T, S>
|
|
|
|
where
|
|
|
|
S: Service<Request = (T, HttpRequest), Response = ServiceResponse, Error = Void>,
|
|
|
|
{
|
|
|
|
type Item = ServiceResponse;
|
2019-04-07 21:43:07 +00:00
|
|
|
type Error = (Error, ServiceRequest<P>);
|
2017-11-29 21:26:55 +00:00
|
|
|
|
2019-03-02 06:51:32 +00:00
|
|
|
fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
|
2019-04-08 06:06:21 +00:00
|
|
|
if let Some(ref mut fut) = self.fut_s {
|
|
|
|
return fut.poll().map_err(|_| panic!());
|
|
|
|
}
|
|
|
|
|
2019-04-07 21:43:07 +00:00
|
|
|
let item = try_ready!(self.fut.poll().map_err(|e| {
|
|
|
|
let (req, payload) = self.req.take().unwrap();
|
|
|
|
let req = ServiceRequest::from_parts(req, payload);
|
|
|
|
(e.into(), req)
|
|
|
|
}));
|
2019-03-02 06:51:32 +00:00
|
|
|
|
2019-04-08 06:06:21 +00:00
|
|
|
self.fut_s = Some(self.service.call((item, self.req.take().unwrap().0)));
|
|
|
|
self.poll()
|
2018-03-29 22:41:13 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-03-02 06:51:32 +00:00
|
|
|
/// FromRequest trait impl for tuples
|
|
|
|
macro_rules! factory_tuple ({ $(($n:tt, $T:ident)),+} => {
|
|
|
|
impl<Func, $($T,)+ Res> Factory<($($T,)+), Res> for Func
|
2019-04-04 20:17:55 +00:00
|
|
|
where Func: Fn($($T,)+) -> Res + Clone,
|
|
|
|
Res: Responder,
|
2019-03-02 06:51:32 +00:00
|
|
|
{
|
|
|
|
fn call(&self, param: ($($T,)+)) -> Res {
|
|
|
|
(self)($(param.$n,)+)
|
|
|
|
}
|
|
|
|
}
|
2018-03-29 22:41:13 +00:00
|
|
|
|
2019-03-02 06:51:32 +00:00
|
|
|
impl<Func, $($T,)+ Res> AsyncFactory<($($T,)+), Res> for Func
|
|
|
|
where Func: Fn($($T,)+) -> Res + Clone + 'static,
|
2019-04-04 20:17:55 +00:00
|
|
|
Res: IntoFuture,
|
2019-03-02 06:51:32 +00:00
|
|
|
Res::Item: Into<Response>,
|
|
|
|
Res::Error: Into<Error>,
|
|
|
|
{
|
|
|
|
fn call(&self, param: ($($T,)+)) -> Res {
|
|
|
|
(self)($(param.$n,)+)
|
|
|
|
}
|
2018-03-29 22:41:13 +00:00
|
|
|
}
|
2019-03-02 06:51:32 +00:00
|
|
|
});
|
|
|
|
|
|
|
|
#[rustfmt::skip]
|
|
|
|
mod m {
|
|
|
|
use super::*;
|
|
|
|
|
|
|
|
factory_tuple!((0, A));
|
|
|
|
factory_tuple!((0, A), (1, B));
|
|
|
|
factory_tuple!((0, A), (1, B), (2, C));
|
|
|
|
factory_tuple!((0, A), (1, B), (2, C), (3, D));
|
|
|
|
factory_tuple!((0, A), (1, B), (2, C), (3, D), (4, E));
|
|
|
|
factory_tuple!((0, A), (1, B), (2, C), (3, D), (4, E), (5, F));
|
|
|
|
factory_tuple!((0, A), (1, B), (2, C), (3, D), (4, E), (5, F), (6, G));
|
|
|
|
factory_tuple!((0, A), (1, B), (2, C), (3, D), (4, E), (5, F), (6, G), (7, H));
|
|
|
|
factory_tuple!((0, A), (1, B), (2, C), (3, D), (4, E), (5, F), (6, G), (7, H), (8, I));
|
|
|
|
factory_tuple!((0, A), (1, B), (2, C), (3, D), (4, E), (5, F), (6, G), (7, H), (8, I), (9, J));
|
2018-03-29 22:41:13 +00:00
|
|
|
}
|