(function() { var type_impls = Object.fromEntries([["cli",[["
§

impl<I, Output, Error, Alt2, Alt3, Alt4> Alt<I, Output, Error> for (Alt2, Alt3, Alt4)
where\n I: Stream,\n Error: ParserError<I>,\n Alt2: Parser<I, Output, Error>,\n Alt3: Parser<I, Output, Error>,\n Alt4: Parser<I, Output, Error>,

§

fn choice(&mut self, input: &mut I) -> Result<Output, Error>

Tests each parser in the tuple and returns the result of the first one that succeeds
","Alt","cli::data::export::TableReference"],["
§

impl<Input, Output, Error, A, B, C> Alt<Input, Output, Error> for (A, B, C)
where\n Input: Clone,\n Error: ParseError<Input>,\n A: Parser<Input, Output, Error>,\n B: Parser<Input, Output, Error>,\n C: Parser<Input, Output, Error>,

§

fn choice(&mut self, input: Input) -> Result<(Input, Output), Err<Error>>

Tests each parser in the tuple and returns the result of the first one that succeeds
","Alt","cli::data::export::TableReference"],["
§

impl<A, B, C> AsULE for (A, B, C)
where\n A: AsULE,\n B: AsULE,\n C: AsULE,

§

type ULE = Tuple3ULE<<A as AsULE>::ULE, <B as AsULE>::ULE, <C as AsULE>::ULE>

The ULE type corresponding to Self. Read more
§

fn to_unaligned(self) -> <(A, B, C) as AsULE>::ULE

Converts from Self to Self::ULE. Read more
§

fn from_unaligned(unaligned: <(A, B, C) as AsULE>::ULE) -> (A, B, C)

Converts from Self::ULE to Self. Read more
","AsULE","cli::data::export::TableReference"],["
§

impl<A, B, C> AssertFloatEq for (A, B, C)
where\n A: AssertFloatEq + Debug,\n B: AssertFloatEq + Debug,\n C: AssertFloatEq + Debug + ?Sized,\n <A as FloatEq>::Tol: Sized,\n <B as FloatEq>::Tol: Sized,\n <C as FloatEq>::Tol: Sized,\n <A as AssertFloatEq>::DebugTol: Sized,\n <B as AssertFloatEq>::DebugTol: Sized,\n <C as AssertFloatEq>::DebugTol: Sized,\n <<A as FloatEq>::Tol as FloatEqUlpsTol>::UlpsTol: Sized,\n <<B as FloatEq>::Tol as FloatEqUlpsTol>::UlpsTol: Sized,\n <<C as FloatEq>::Tol as FloatEqUlpsTol>::UlpsTol: Sized,\n <<A as AssertFloatEq>::DebugTol as FloatEqUlpsTol>::UlpsTol: Sized,\n <<B as AssertFloatEq>::DebugTol as FloatEqUlpsTol>::UlpsTol: Sized,\n <<C as AssertFloatEq>::DebugTol as FloatEqUlpsTol>::UlpsTol: Sized,

§

type DebugAbsDiff = (<A as AssertFloatEq>::DebugAbsDiff, <B as AssertFloatEq>::DebugAbsDiff, <C as AssertFloatEq>::DebugAbsDiff)

The absolute difference between two values, displayed to the user via\nfmt::Debug when an assert fails. Read more
§

type DebugTol = (<A as AssertFloatEq>::DebugTol, <B as AssertFloatEq>::DebugTol, <C as AssertFloatEq>::DebugTol)

The per-field tolerance value used for comparison between two values,\ndisplayed to the user via fmt::Debug when an assert fails. Read more
§

fn debug_abs_diff(\n &self,\n other: &(A, B, C),\n) -> <(A, B, C) as AssertFloatEq>::DebugAbsDiff

Always positive absolute difference between two values. Read more
§

fn debug_ulps_diff(\n &self,\n other: &(A, B, C),\n) -> <<(A, B, C) as AssertFloatEq>::DebugAbsDiff as FloatEqDebugUlpsDiff>::DebugUlpsDiff

Always positive absolute difference between two values in terms of ULPs. Read more
§

fn debug_abs_tol(\n &self,\n other: &(A, B, C),\n tol: &<(A, B, C) as FloatEq>::Tol,\n) -> <(A, B, C) as AssertFloatEq>::DebugTol

The tolerance used by an abs comparison, displayed when an assert fails.
§

fn debug_rmax_tol(\n &self,\n other: &(A, B, C),\n tol: &<(A, B, C) as FloatEq>::Tol,\n) -> <(A, B, C) as AssertFloatEq>::DebugTol

The tolerance used by an rmax comparison, displayed when an assert fails. Read more
§

fn debug_rmin_tol(\n &self,\n other: &(A, B, C),\n tol: &<(A, B, C) as FloatEq>::Tol,\n) -> <(A, B, C) as AssertFloatEq>::DebugTol

The tolerance used by an rmin comparison, displayed when an assert fails. Read more
§

fn debug_r1st_tol(\n &self,\n other: &(A, B, C),\n tol: &<(A, B, C) as FloatEq>::Tol,\n) -> <(A, B, C) as AssertFloatEq>::DebugTol

The tolerance used by an r1st comparison, displayed when an assert fails. Read more
§

fn debug_r2nd_tol(\n &self,\n other: &(A, B, C),\n tol: &<(A, B, C) as FloatEq>::Tol,\n) -> <(A, B, C) as AssertFloatEq>::DebugTol

The tolerance used by an r2nd comparison, displayed when an assert fails. Read more
§

fn debug_ulps_tol(\n &self,\n other: &(A, B, C),\n tol: &<<(A, B, C) as FloatEq>::Tol as FloatEqUlpsTol>::UlpsTol,\n) -> <<(A, B, C) as AssertFloatEq>::DebugTol as FloatEqUlpsTol>::UlpsTol

The tolerance used by an ulps comparison, displayed when an assert fails.
§

fn debug_rel_tol(&self, other: &Rhs, tol: &Self::Tol) -> Self::DebugTol

The tolerance used by a rel comparison, displayed when an assert fails. Read more
","AssertFloatEq","cli::data::export::TableReference"],["
Source§

impl<R, S, T> Bounded for (R, S, T)
where\n R: Bounded,\n S: Bounded,\n T: Bounded,

Source§

fn min_value() -> (R, S, T)

Returns the smallest finite number this type can represent
Source§

fn max_value() -> (R, S, T)

Returns the largest finite number this type can represent
","Bounded","cli::data::export::TableReference"],["
§

impl<T, F1, F2, F3> ContainsToken<T> for (F1, F2, F3)
where\n T: Clone,\n F1: ContainsToken<T>,\n F2: ContainsToken<T>,\n F3: ContainsToken<T>,

§

fn contains_token(&self, token: T) -> bool

Returns true if self contains the token
","ContainsToken","cli::data::export::TableReference"],["
§

impl<'r, T1, T2, T3> Decode<'r, Postgres> for (T1, T2, T3)
where\n T1: 'r + Type<Postgres> + for<'a> Decode<'a, Postgres>,\n T2: 'r + Type<Postgres> + for<'a> Decode<'a, Postgres>,\n T3: 'r + Type<Postgres> + for<'a> Decode<'a, Postgres>,

§

fn decode(\n value: PgValueRef<'r>,\n) -> Result<(T1, T2, T3), Box<dyn Error + Sync + Send>>

Decode a new value of this type using a raw value from the database.
","Decode<'r, Postgres>","cli::data::export::TableReference"],["
Source§

impl<'de, T0, T1, T2> Deserialize<'de> for (T0, T1, T2)
where\n T0: Deserialize<'de>,\n T1: Deserialize<'de>,\n T2: Deserialize<'de>,

Source§

fn deserialize<D>(\n deserializer: D,\n) -> Result<(T0, T1, T2), <D as Deserializer<'de>>::Error>
where\n D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer. Read more
","Deserialize<'de>","cli::data::export::TableReference"],["
Source§

impl<'de, T0, As0, T1, As1, T2, As2> DeserializeAs<'de, (T0, T1, T2)> for (As0, As1, As2)
where\n As0: DeserializeAs<'de, T0>,\n As1: DeserializeAs<'de, T1>,\n As2: DeserializeAs<'de, T2>,

Source§

fn deserialize_as<D>(\n deserializer: D,\n) -> Result<(T0, T1, T2), <D as Deserializer<'de>>::Error>
where\n D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.
","DeserializeAs<'de, (T0, T1, T2)>","cli::data::export::TableReference"],["
§

impl<A, B, C, AE, BE, CE, Format> EncodeAsVarULE<Tuple3VarULE<A, B, C, Format>> for (AE, BE, CE)
where\n A: VarULE + ?Sized,\n B: VarULE + ?Sized,\n C: VarULE + ?Sized,\n AE: EncodeAsVarULE<A>,\n BE: EncodeAsVarULE<B>,\n CE: EncodeAsVarULE<C>,\n Format: VarZeroVecFormat,

§

fn encode_var_ule_as_slices<R>(&self, _: impl FnOnce(&[&[u8]]) -> R) -> R

Calls cb with a piecewise list of byte slices that when concatenated\nproduce the memory pattern of the corresponding instance of T. Read more
§

fn encode_var_ule_len(&self) -> usize

Return the length, in bytes, of the corresponding [VarULE] type
§

fn encode_var_ule_write(&self, dst: &mut [u8])

Write the corresponding [VarULE] type to the dst buffer. dst should\nbe the size of [Self::encode_var_ule_len()]
","EncodeAsVarULE>","cli::data::export::TableReference"],["
§

impl<A, B, C> FloatEq for (A, B, C)
where\n A: FloatEq,\n B: FloatEq,\n C: FloatEq + ?Sized,\n <A as FloatEq>::Tol: Sized,\n <B as FloatEq>::Tol: Sized,\n <C as FloatEq>::Tol: Sized,\n <<A as FloatEq>::Tol as FloatEqUlpsTol>::UlpsTol: Sized,\n <<B as FloatEq>::Tol as FloatEqUlpsTol>::UlpsTol: Sized,\n <<C as FloatEq>::Tol as FloatEqUlpsTol>::UlpsTol: Sized,

§

type Tol = (<A as FloatEq>::Tol, <B as FloatEq>::Tol, <C as FloatEq>::Tol)

Type of the maximum allowed difference between two values for them to be\nconsidered equal.
§

fn eq_abs(&self, other: &(A, B, C), tol: &<(A, B, C) as FloatEq>::Tol) -> bool

Check whether self is equal to other, using an absolute tolerance\ncomparison. Read more
§

fn eq_rmax(&self, other: &(A, B, C), tol: &<(A, B, C) as FloatEq>::Tol) -> bool

Check whether self is equal to other, using a relative tolerance\ncomparison, scaled to the granularity of the input with the largest\nmagnitude. Read more
§

fn eq_rmin(&self, other: &(A, B, C), tol: &<(A, B, C) as FloatEq>::Tol) -> bool

Check whether self is equal to other, using a relative tolerance\ncomparison, scaled to the granularity of the input with the smallest\nmagnitude. Read more
§

fn eq_r1st(&self, other: &(A, B, C), tol: &<(A, B, C) as FloatEq>::Tol) -> bool

Check whether self is equal to other, using a relative tolerance\ncomparison, scaled to the granularity of the first input. Read more
§

fn eq_r2nd(&self, other: &(A, B, C), tol: &<(A, B, C) as FloatEq>::Tol) -> bool

Check whether self is equal to other, using a relative tolerance\ncomparison, scaled to the granularity of the second input. Read more
§

fn eq_ulps(\n &self,\n other: &(A, B, C),\n tol: &<<(A, B, C) as FloatEq>::Tol as FloatEqUlpsTol>::UlpsTol,\n) -> bool

Check whether self is equal to other, using an ULPs comparison. Read more
§

fn ne_abs(&self, other: &Rhs, tol: &Self::Tol) -> bool

Check whether self is not equal to other, using an absolute tolerance\ncomparison. Read more
§

fn eq_rel(&self, other: &Rhs, tol: &Self::Tol) -> bool

Check whether self is equal to other, using a relative tolerance\ncomparison. Read more
§

fn ne_rel(&self, other: &Rhs, tol: &Self::Tol) -> bool

Check whether self is not equal to other, using a relative tolerance\ncomparison. Read more
§

fn ne_rmax(&self, other: &Rhs, tol: &Self::Tol) -> bool

Check whether self is not equal to other, using a relative tolerance\ncomparison. Read more
§

fn ne_rmin(&self, other: &Rhs, tol: &Self::Tol) -> bool

Check whether self is not equal to other, using a relative tolerance\ncomparison. Read more
§

fn ne_r1st(&self, other: &Rhs, tol: &Self::Tol) -> bool

Check whether self is not equal to other, using a relative tolerance\ncomparison. Read more
§

fn ne_r2nd(&self, other: &Rhs, tol: &Self::Tol) -> bool

Check whether self is not equal to other, using a relative tolerance\ncomparison. Read more
§

fn ne_ulps(\n &self,\n other: &Rhs,\n tol: &<Self::Tol as FloatEqUlpsTol>::UlpsTol,\n) -> bool

Check whether self is not equal to other, using an ULPs comparison. Read more
","FloatEq","cli::data::export::TableReference"],["
§

impl<A, B, C> FloatEqDebugUlpsDiff for (A, B, C)
where\n A: FloatEqDebugUlpsDiff,\n B: FloatEqDebugUlpsDiff,\n C: FloatEqDebugUlpsDiff,

§

type DebugUlpsDiff = (<A as FloatEqDebugUlpsDiff>::DebugUlpsDiff, <B as FloatEqDebugUlpsDiff>::DebugUlpsDiff, <C as FloatEqDebugUlpsDiff>::DebugUlpsDiff)

A structurally identical type to Self, with fields recursively wrapped\nby DebugUlpsDiff.
","FloatEqDebugUlpsDiff","cli::data::export::TableReference"],["
§

impl<A, B, C> FloatEqUlpsTol for (A, B, C)
where\n A: FloatEqUlpsTol,\n B: FloatEqUlpsTol,\n C: FloatEqUlpsTol + ?Sized,\n <A as FloatEqUlpsTol>::UlpsTol: Sized,\n <B as FloatEqUlpsTol>::UlpsTol: Sized,\n <C as FloatEqUlpsTol>::UlpsTol: Sized,

§

type UlpsTol = (<A as FloatEqUlpsTol>::UlpsTol, <B as FloatEqUlpsTol>::UlpsTol, <C as FloatEqUlpsTol>::UlpsTol)

A structurally identical type to Self, with fields recursively wrapped\nby UlpsTol.
","FloatEqUlpsTol","cli::data::export::TableReference"],["
§

impl<R, S> From<Bgr<R>> for (S, S, S)
where\n R: Into<S>,

§

fn from(value: Bgr<R>) -> (S, S, S)

Converts to this type from the input type.
","From>","cli::data::export::TableReference"],["
§

impl<R, S> From<Grb<R>> for (S, S, S)
where\n R: Into<S>,

§

fn from(value: Grb<R>) -> (S, S, S)

Converts to this type from the input type.
","From>","cli::data::export::TableReference"],["
§

impl<R, S> From<Rgb<R>> for (S, S, S)
where\n R: Into<S>,

§

fn from(value: Rgb<R>) -> (S, S, S)

Converts to this type from the input type.
","From>","cli::data::export::TableReference"],["
§

impl<S, T1, T2, T3> FromRequest<S> for (T1, T2, T3)
where\n T1: FromRequestParts<S> + Send,\n T2: FromRequestParts<S> + Send,\n T3: FromRequest<S> + Send,\n S: Send + Sync,

§

type Rejection = Response<Body>

If the extractor fails it’ll use this “rejection” type. A rejection is\na kind of error that can be converted into a response.
§

fn from_request(\n req: Request<Body>,\n state: &S,\n) -> impl Future<Output = Result<(T1, T2, T3), <(T1, T2, T3) as FromRequest<S>>::Rejection>>

Perform the extraction.
","FromRequest","cli::data::export::TableReference"],["
§

impl<S, T1, T2, T3> FromRequestParts<S> for (T1, T2, T3)
where\n T1: FromRequestParts<S> + Send,\n T2: FromRequestParts<S> + Send,\n T3: FromRequestParts<S> + Send,\n S: Send + Sync,

§

type Rejection = Response<Body>

If the extractor fails it’ll use this “rejection” type. A rejection is\na kind of error that can be converted into a response.
§

async fn from_request_parts(\n parts: &mut Parts,\n state: &S,\n) -> Result<(T1, T2, T3), <(T1, T2, T3) as FromRequestParts<S>>::Rejection>

Perform the extraction.
","FromRequestParts","cli::data::export::TableReference"],["
§

impl<'r, R, T1, T2, T3> FromRow<'r, R> for (T1, T2, T3)
where\n R: Row,\n usize: ColumnIndex<R>,\n T1: Decode<'r, <R as Row>::Database> + Type<<R as Row>::Database>,\n T2: Decode<'r, <R as Row>::Database> + Type<<R as Row>::Database>,\n T3: Decode<'r, <R as Row>::Database> + Type<<R as Row>::Database>,

§

fn from_row(row: &'r R) -> Result<(T1, T2, T3), Error>

","FromRow<'r, R>","cli::data::export::TableReference"],["
§

impl<T1, T2, T3> FromRow for (T1, T2, T3)
where\n T1: FromValue,\n T2: FromValue,\n T3: FromValue,\n <T1 as FromValue>::Intermediate: Into<Value>,\n <T2 as FromValue>::Intermediate: Into<Value>,

§

fn from_row_opt(row: Row) -> Result<(T1, T2, T3), FromRowError>

§

fn from_row(row: Row) -> Self
where\n Self: Sized,

","FromRow","cli::data::export::TableReference"],["
§

impl<T2, T1, T0> Generic for (T2, T1, T0)

§

type Repr = HCons<T2, HCons<T1, HCons<T0, HNil>>>

The generic representation type.
§

fn into(self) -> <(T2, T1, T0) as Generic>::Repr

Convert a value to its representation type Repr.
§

fn from(r: <(T2, T1, T0) as Generic>::Repr) -> (T2, T1, T0)

Convert a value’s representation type Repr to the value’s type.
§

fn convert_from<Src>(src: Src) -> Self
where\n Self: Sized,\n Src: Generic<Repr = Self::Repr>,

Convert a value to another type provided that they have\nthe same representation type.
§

fn map_repr<Mapper>(self, mapper: Mapper) -> Self
where\n Self: Sized,\n Mapper: FnOnce(Self::Repr) -> Self::Repr,

Maps the given value of type Self by first transforming it to\nthe representation type Repr, then applying a mapper function\non Repr and finally transforming it back to a value of type Self.
§

fn map_inter<Inter, Mapper>(self, mapper: Mapper) -> Self
where\n Self: Sized,\n Inter: Generic<Repr = Self::Repr>,\n Mapper: FnOnce(Inter) -> Inter,

Maps the given value of type Self by first transforming it\na type Inter that has the same representation type as Self,\nthen applying a mapper function on Inter and finally transforming\nit back to a value of type Self.
","Generic","cli::data::export::TableReference"],["
§

impl<F, Fut, Res, S> Handler<((),), S> for F
where\n F: FnOnce() -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n Res: IntoResponse,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n _req: Request<Body>,\n _state: S,\n) -> <F as Handler<((),), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<((),), S>","cli::data::export::TableReference"],["
§

impl<F, Fut, S, Res, M, T1> Handler<(M, T1), S> for F
where\n F: FnOnce(T1) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1), S>","cli::data::export::TableReference"],["
§

impl<F, Fut, S, Res, M, T1, T2> Handler<(M, T1, T2), S> for F
where\n F: FnOnce(T1, T2) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequestParts<S> + Send,\n T2: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1, T2), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1, T2), S>","cli::data::export::TableReference"],["
§

impl<F, Fut, S, Res, M, T1, T2, T3> Handler<(M, T1, T2, T3), S> for F
where\n F: FnOnce(T1, T2, T3) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequestParts<S> + Send,\n T2: FromRequestParts<S> + Send,\n T3: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1, T2, T3), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1, T2, T3), S>","cli::data::export::TableReference"],["
§

impl<F, Fut, S, Res, M, T1, T2, T3, T4> Handler<(M, T1, T2, T3, T4), S> for F
where\n F: FnOnce(T1, T2, T3, T4) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequestParts<S> + Send,\n T2: FromRequestParts<S> + Send,\n T3: FromRequestParts<S> + Send,\n T4: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1, T2, T3, T4), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1, T2, T3, T4), S>","cli::data::export::TableReference"],["
§

impl<F, Fut, S, Res, M, T1, T2, T3, T4, T5> Handler<(M, T1, T2, T3, T4, T5), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequestParts<S> + Send,\n T2: FromRequestParts<S> + Send,\n T3: FromRequestParts<S> + Send,\n T4: FromRequestParts<S> + Send,\n T5: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1, T2, T3, T4, T5), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1, T2, T3, T4, T5), S>","cli::data::export::TableReference"],["
§

impl<F, Fut, S, Res, M, T1, T2, T3, T4, T5, T6> Handler<(M, T1, T2, T3, T4, T5, T6), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5, T6) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequestParts<S> + Send,\n T2: FromRequestParts<S> + Send,\n T3: FromRequestParts<S> + Send,\n T4: FromRequestParts<S> + Send,\n T5: FromRequestParts<S> + Send,\n T6: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1, T2, T3, T4, T5, T6), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1, T2, T3, T4, T5, T6), S>","cli::data::export::TableReference"],["
§

impl<F, Fut, S, Res, M, T1, T2, T3, T4, T5, T6, T7> Handler<(M, T1, T2, T3, T4, T5, T6, T7), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5, T6, T7) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequestParts<S> + Send,\n T2: FromRequestParts<S> + Send,\n T3: FromRequestParts<S> + Send,\n T4: FromRequestParts<S> + Send,\n T5: FromRequestParts<S> + Send,\n T6: FromRequestParts<S> + Send,\n T7: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1, T2, T3, T4, T5, T6, T7), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1, T2, T3, T4, T5, T6, T7), S>","cli::data::export::TableReference"],["
§

impl<F, Fut, S, Res, M, T1, T2, T3, T4, T5, T6, T7, T8> Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5, T6, T7, T8) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequestParts<S> + Send,\n T2: FromRequestParts<S> + Send,\n T3: FromRequestParts<S> + Send,\n T4: FromRequestParts<S> + Send,\n T5: FromRequestParts<S> + Send,\n T6: FromRequestParts<S> + Send,\n T7: FromRequestParts<S> + Send,\n T8: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8), S>","cli::data::export::TableReference"],["
§

impl<F, Fut, S, Res, M, T1, T2, T3, T4, T5, T6, T7, T8, T9> Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5, T6, T7, T8, T9) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequestParts<S> + Send,\n T2: FromRequestParts<S> + Send,\n T3: FromRequestParts<S> + Send,\n T4: FromRequestParts<S> + Send,\n T5: FromRequestParts<S> + Send,\n T6: FromRequestParts<S> + Send,\n T7: FromRequestParts<S> + Send,\n T8: FromRequestParts<S> + Send,\n T9: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9), S>","cli::data::export::TableReference"],["
§

impl<F, Fut, S, Res, M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequestParts<S> + Send,\n T2: FromRequestParts<S> + Send,\n T3: FromRequestParts<S> + Send,\n T4: FromRequestParts<S> + Send,\n T5: FromRequestParts<S> + Send,\n T6: FromRequestParts<S> + Send,\n T7: FromRequestParts<S> + Send,\n T8: FromRequestParts<S> + Send,\n T9: FromRequestParts<S> + Send,\n T10: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10), S>","cli::data::export::TableReference"],["
§

impl<F, Fut, S, Res, M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequestParts<S> + Send,\n T2: FromRequestParts<S> + Send,\n T3: FromRequestParts<S> + Send,\n T4: FromRequestParts<S> + Send,\n T5: FromRequestParts<S> + Send,\n T6: FromRequestParts<S> + Send,\n T7: FromRequestParts<S> + Send,\n T8: FromRequestParts<S> + Send,\n T9: FromRequestParts<S> + Send,\n T10: FromRequestParts<S> + Send,\n T11: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11), S>","cli::data::export::TableReference"],["
§

impl<F, Fut, S, Res, M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequestParts<S> + Send,\n T2: FromRequestParts<S> + Send,\n T3: FromRequestParts<S> + Send,\n T4: FromRequestParts<S> + Send,\n T5: FromRequestParts<S> + Send,\n T6: FromRequestParts<S> + Send,\n T7: FromRequestParts<S> + Send,\n T8: FromRequestParts<S> + Send,\n T9: FromRequestParts<S> + Send,\n T10: FromRequestParts<S> + Send,\n T11: FromRequestParts<S> + Send,\n T12: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12), S>","cli::data::export::TableReference"],["
§

impl<F, Fut, S, Res, M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequestParts<S> + Send,\n T2: FromRequestParts<S> + Send,\n T3: FromRequestParts<S> + Send,\n T4: FromRequestParts<S> + Send,\n T5: FromRequestParts<S> + Send,\n T6: FromRequestParts<S> + Send,\n T7: FromRequestParts<S> + Send,\n T8: FromRequestParts<S> + Send,\n T9: FromRequestParts<S> + Send,\n T10: FromRequestParts<S> + Send,\n T11: FromRequestParts<S> + Send,\n T12: FromRequestParts<S> + Send,\n T13: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13), S>","cli::data::export::TableReference"],["
§

impl<F, Fut, S, Res, M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequestParts<S> + Send,\n T2: FromRequestParts<S> + Send,\n T3: FromRequestParts<S> + Send,\n T4: FromRequestParts<S> + Send,\n T5: FromRequestParts<S> + Send,\n T6: FromRequestParts<S> + Send,\n T7: FromRequestParts<S> + Send,\n T8: FromRequestParts<S> + Send,\n T9: FromRequestParts<S> + Send,\n T10: FromRequestParts<S> + Send,\n T11: FromRequestParts<S> + Send,\n T12: FromRequestParts<S> + Send,\n T13: FromRequestParts<S> + Send,\n T14: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14), S>","cli::data::export::TableReference"],["
§

impl<F, Fut, S, Res, M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequestParts<S> + Send,\n T2: FromRequestParts<S> + Send,\n T3: FromRequestParts<S> + Send,\n T4: FromRequestParts<S> + Send,\n T5: FromRequestParts<S> + Send,\n T6: FromRequestParts<S> + Send,\n T7: FromRequestParts<S> + Send,\n T8: FromRequestParts<S> + Send,\n T9: FromRequestParts<S> + Send,\n T10: FromRequestParts<S> + Send,\n T11: FromRequestParts<S> + Send,\n T12: FromRequestParts<S> + Send,\n T13: FromRequestParts<S> + Send,\n T14: FromRequestParts<S> + Send,\n T15: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15), S>","cli::data::export::TableReference"],["
§

impl<F, Fut, S, Res, M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16> Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequestParts<S> + Send,\n T2: FromRequestParts<S> + Send,\n T3: FromRequestParts<S> + Send,\n T4: FromRequestParts<S> + Send,\n T5: FromRequestParts<S> + Send,\n T6: FromRequestParts<S> + Send,\n T7: FromRequestParts<S> + Send,\n T8: FromRequestParts<S> + Send,\n T9: FromRequestParts<S> + Send,\n T10: FromRequestParts<S> + Send,\n T11: FromRequestParts<S> + Send,\n T12: FromRequestParts<S> + Send,\n T13: FromRequestParts<S> + Send,\n T14: FromRequestParts<S> + Send,\n T15: FromRequestParts<S> + Send,\n T16: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16), S>","cli::data::export::TableReference"],["
§

impl<F, Fut, S, T1> HandlerCallWithExtractors<(T1,), S> for F
where\n F: FnOnce(T1) -> Fut,\n Fut: Future + Send + 'static,\n <Fut as Future>::Output: IntoResponse,

§

type Future = Map<Fut, fn(<Fut as Future>::Output) -> Response<Body>>

The type of future calling this handler returns.
§

fn call(\n self,\n _: (T1,),\n _state: S,\n) -> <F as HandlerCallWithExtractors<(T1,), S>>::Future

Call the handler with the extracted inputs.
§

fn into_handler(self) -> IntoHandler<Self, T, S>

Convert this HandlerCallWithExtractors into [Handler].
§

fn or<R, Rt>(self, rhs: R) -> Or<Self, R, T, Rt, S>
where\n R: HandlerCallWithExtractors<Rt, S>,

Chain two handlers together, running the second one if the first one rejects. Read more
","HandlerCallWithExtractors<(T1,), S>","cli::data::export::TableReference"],["
§

impl<F, Fut, S, T1, T2> HandlerCallWithExtractors<(T1, T2), S> for F
where\n F: FnOnce(T1, T2) -> Fut,\n Fut: Future + Send + 'static,\n <Fut as Future>::Output: IntoResponse,

§

type Future = Map<Fut, fn(<Fut as Future>::Output) -> Response<Body>>

The type of future calling this handler returns.
§

fn call(\n self,\n _: (T1, T2),\n _state: S,\n) -> <F as HandlerCallWithExtractors<(T1, T2), S>>::Future

Call the handler with the extracted inputs.
§

fn into_handler(self) -> IntoHandler<Self, T, S>

Convert this HandlerCallWithExtractors into [Handler].
§

fn or<R, Rt>(self, rhs: R) -> Or<Self, R, T, Rt, S>
where\n R: HandlerCallWithExtractors<Rt, S>,

Chain two handlers together, running the second one if the first one rejects. Read more
","HandlerCallWithExtractors<(T1, T2), S>","cli::data::export::TableReference"],["
§

impl<F, Fut, S, T1, T2, T3> HandlerCallWithExtractors<(T1, T2, T3), S> for F
where\n F: FnOnce(T1, T2, T3) -> Fut,\n Fut: Future + Send + 'static,\n <Fut as Future>::Output: IntoResponse,

§

type Future = Map<Fut, fn(<Fut as Future>::Output) -> Response<Body>>

The type of future calling this handler returns.
§

fn call(\n self,\n _: (T1, T2, T3),\n _state: S,\n) -> <F as HandlerCallWithExtractors<(T1, T2, T3), S>>::Future

Call the handler with the extracted inputs.
§

fn into_handler(self) -> IntoHandler<Self, T, S>

Convert this HandlerCallWithExtractors into [Handler].
§

fn or<R, Rt>(self, rhs: R) -> Or<Self, R, T, Rt, S>
where\n R: HandlerCallWithExtractors<Rt, S>,

Chain two handlers together, running the second one if the first one rejects. Read more
","HandlerCallWithExtractors<(T1, T2, T3), S>","cli::data::export::TableReference"],["
§

impl<F, Fut, S, T1, T2, T3, T4> HandlerCallWithExtractors<(T1, T2, T3, T4), S> for F
where\n F: FnOnce(T1, T2, T3, T4) -> Fut,\n Fut: Future + Send + 'static,\n <Fut as Future>::Output: IntoResponse,

§

type Future = Map<Fut, fn(<Fut as Future>::Output) -> Response<Body>>

The type of future calling this handler returns.
§

fn call(\n self,\n _: (T1, T2, T3, T4),\n _state: S,\n) -> <F as HandlerCallWithExtractors<(T1, T2, T3, T4), S>>::Future

Call the handler with the extracted inputs.
§

fn into_handler(self) -> IntoHandler<Self, T, S>

Convert this HandlerCallWithExtractors into [Handler].
§

fn or<R, Rt>(self, rhs: R) -> Or<Self, R, T, Rt, S>
where\n R: HandlerCallWithExtractors<Rt, S>,

Chain two handlers together, running the second one if the first one rejects. Read more
","HandlerCallWithExtractors<(T1, T2, T3, T4), S>","cli::data::export::TableReference"],["
§

impl<F, Fut, S, T1, T2, T3, T4, T5> HandlerCallWithExtractors<(T1, T2, T3, T4, T5), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5) -> Fut,\n Fut: Future + Send + 'static,\n <Fut as Future>::Output: IntoResponse,

§

type Future = Map<Fut, fn(<Fut as Future>::Output) -> Response<Body>>

The type of future calling this handler returns.
§

fn call(\n self,\n _: (T1, T2, T3, T4, T5),\n _state: S,\n) -> <F as HandlerCallWithExtractors<(T1, T2, T3, T4, T5), S>>::Future

Call the handler with the extracted inputs.
§

fn into_handler(self) -> IntoHandler<Self, T, S>

Convert this HandlerCallWithExtractors into [Handler].
§

fn or<R, Rt>(self, rhs: R) -> Or<Self, R, T, Rt, S>
where\n R: HandlerCallWithExtractors<Rt, S>,

Chain two handlers together, running the second one if the first one rejects. Read more
","HandlerCallWithExtractors<(T1, T2, T3, T4, T5), S>","cli::data::export::TableReference"],["
§

impl<F, Fut, S, T1, T2, T3, T4, T5, T6> HandlerCallWithExtractors<(T1, T2, T3, T4, T5, T6), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5, T6) -> Fut,\n Fut: Future + Send + 'static,\n <Fut as Future>::Output: IntoResponse,

§

type Future = Map<Fut, fn(<Fut as Future>::Output) -> Response<Body>>

The type of future calling this handler returns.
§

fn call(\n self,\n _: (T1, T2, T3, T4, T5, T6),\n _state: S,\n) -> <F as HandlerCallWithExtractors<(T1, T2, T3, T4, T5, T6), S>>::Future

Call the handler with the extracted inputs.
§

fn into_handler(self) -> IntoHandler<Self, T, S>

Convert this HandlerCallWithExtractors into [Handler].
§

fn or<R, Rt>(self, rhs: R) -> Or<Self, R, T, Rt, S>
where\n R: HandlerCallWithExtractors<Rt, S>,

Chain two handlers together, running the second one if the first one rejects. Read more
","HandlerCallWithExtractors<(T1, T2, T3, T4, T5, T6), S>","cli::data::export::TableReference"],["
§

impl<F, Fut, S, T1, T2, T3, T4, T5, T6, T7> HandlerCallWithExtractors<(T1, T2, T3, T4, T5, T6, T7), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5, T6, T7) -> Fut,\n Fut: Future + Send + 'static,\n <Fut as Future>::Output: IntoResponse,

§

type Future = Map<Fut, fn(<Fut as Future>::Output) -> Response<Body>>

The type of future calling this handler returns.
§

fn call(\n self,\n _: (T1, T2, T3, T4, T5, T6, T7),\n _state: S,\n) -> <F as HandlerCallWithExtractors<(T1, T2, T3, T4, T5, T6, T7), S>>::Future

Call the handler with the extracted inputs.
§

fn into_handler(self) -> IntoHandler<Self, T, S>

Convert this HandlerCallWithExtractors into [Handler].
§

fn or<R, Rt>(self, rhs: R) -> Or<Self, R, T, Rt, S>
where\n R: HandlerCallWithExtractors<Rt, S>,

Chain two handlers together, running the second one if the first one rejects. Read more
","HandlerCallWithExtractors<(T1, T2, T3, T4, T5, T6, T7), S>","cli::data::export::TableReference"],["
§

impl<F, Fut, S, T1, T2, T3, T4, T5, T6, T7, T8> HandlerCallWithExtractors<(T1, T2, T3, T4, T5, T6, T7, T8), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5, T6, T7, T8) -> Fut,\n Fut: Future + Send + 'static,\n <Fut as Future>::Output: IntoResponse,

§

type Future = Map<Fut, fn(<Fut as Future>::Output) -> Response<Body>>

The type of future calling this handler returns.
§

fn call(\n self,\n _: (T1, T2, T3, T4, T5, T6, T7, T8),\n _state: S,\n) -> <F as HandlerCallWithExtractors<(T1, T2, T3, T4, T5, T6, T7, T8), S>>::Future

Call the handler with the extracted inputs.
§

fn into_handler(self) -> IntoHandler<Self, T, S>

Convert this HandlerCallWithExtractors into [Handler].
§

fn or<R, Rt>(self, rhs: R) -> Or<Self, R, T, Rt, S>
where\n R: HandlerCallWithExtractors<Rt, S>,

Chain two handlers together, running the second one if the first one rejects. Read more
","HandlerCallWithExtractors<(T1, T2, T3, T4, T5, T6, T7, T8), S>","cli::data::export::TableReference"],["
§

impl<F, Fut, S, T1, T2, T3, T4, T5, T6, T7, T8, T9> HandlerCallWithExtractors<(T1, T2, T3, T4, T5, T6, T7, T8, T9), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5, T6, T7, T8, T9) -> Fut,\n Fut: Future + Send + 'static,\n <Fut as Future>::Output: IntoResponse,

§

type Future = Map<Fut, fn(<Fut as Future>::Output) -> Response<Body>>

The type of future calling this handler returns.
§

fn call(\n self,\n _: (T1, T2, T3, T4, T5, T6, T7, T8, T9),\n _state: S,\n) -> <F as HandlerCallWithExtractors<(T1, T2, T3, T4, T5, T6, T7, T8, T9), S>>::Future

Call the handler with the extracted inputs.
§

fn into_handler(self) -> IntoHandler<Self, T, S>

Convert this HandlerCallWithExtractors into [Handler].
§

fn or<R, Rt>(self, rhs: R) -> Or<Self, R, T, Rt, S>
where\n R: HandlerCallWithExtractors<Rt, S>,

Chain two handlers together, running the second one if the first one rejects. Read more
","HandlerCallWithExtractors<(T1, T2, T3, T4, T5, T6, T7, T8, T9), S>","cli::data::export::TableReference"],["
§

impl<F, Fut, S, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> HandlerCallWithExtractors<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) -> Fut,\n Fut: Future + Send + 'static,\n <Fut as Future>::Output: IntoResponse,

§

type Future = Map<Fut, fn(<Fut as Future>::Output) -> Response<Body>>

The type of future calling this handler returns.
§

fn call(\n self,\n _: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10),\n _state: S,\n) -> <F as HandlerCallWithExtractors<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10), S>>::Future

Call the handler with the extracted inputs.
§

fn into_handler(self) -> IntoHandler<Self, T, S>

Convert this HandlerCallWithExtractors into [Handler].
§

fn or<R, Rt>(self, rhs: R) -> Or<Self, R, T, Rt, S>
where\n R: HandlerCallWithExtractors<Rt, S>,

Chain two handlers together, running the second one if the first one rejects. Read more
","HandlerCallWithExtractors<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10), S>","cli::data::export::TableReference"],["
§

impl<F, Fut, S, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> HandlerCallWithExtractors<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) -> Fut,\n Fut: Future + Send + 'static,\n <Fut as Future>::Output: IntoResponse,

§

type Future = Map<Fut, fn(<Fut as Future>::Output) -> Response<Body>>

The type of future calling this handler returns.
§

fn call(\n self,\n _: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11),\n _state: S,\n) -> <F as HandlerCallWithExtractors<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11), S>>::Future

Call the handler with the extracted inputs.
§

fn into_handler(self) -> IntoHandler<Self, T, S>

Convert this HandlerCallWithExtractors into [Handler].
§

fn or<R, Rt>(self, rhs: R) -> Or<Self, R, T, Rt, S>
where\n R: HandlerCallWithExtractors<Rt, S>,

Chain two handlers together, running the second one if the first one rejects. Read more
","HandlerCallWithExtractors<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11), S>","cli::data::export::TableReference"],["
§

impl<F, Fut, S, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> HandlerCallWithExtractors<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) -> Fut,\n Fut: Future + Send + 'static,\n <Fut as Future>::Output: IntoResponse,

§

type Future = Map<Fut, fn(<Fut as Future>::Output) -> Response<Body>>

The type of future calling this handler returns.
§

fn call(\n self,\n _: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12),\n _state: S,\n) -> <F as HandlerCallWithExtractors<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12), S>>::Future

Call the handler with the extracted inputs.
§

fn into_handler(self) -> IntoHandler<Self, T, S>

Convert this HandlerCallWithExtractors into [Handler].
§

fn or<R, Rt>(self, rhs: R) -> Or<Self, R, T, Rt, S>
where\n R: HandlerCallWithExtractors<Rt, S>,

Chain two handlers together, running the second one if the first one rejects. Read more
","HandlerCallWithExtractors<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12), S>","cli::data::export::TableReference"],["
§

impl<F, Fut, S, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> HandlerCallWithExtractors<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) -> Fut,\n Fut: Future + Send + 'static,\n <Fut as Future>::Output: IntoResponse,

§

type Future = Map<Fut, fn(<Fut as Future>::Output) -> Response<Body>>

The type of future calling this handler returns.
§

fn call(\n self,\n _: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13),\n _state: S,\n) -> <F as HandlerCallWithExtractors<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13), S>>::Future

Call the handler with the extracted inputs.
§

fn into_handler(self) -> IntoHandler<Self, T, S>

Convert this HandlerCallWithExtractors into [Handler].
§

fn or<R, Rt>(self, rhs: R) -> Or<Self, R, T, Rt, S>
where\n R: HandlerCallWithExtractors<Rt, S>,

Chain two handlers together, running the second one if the first one rejects. Read more
","HandlerCallWithExtractors<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13), S>","cli::data::export::TableReference"],["
§

impl<F, Fut, S, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> HandlerCallWithExtractors<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) -> Fut,\n Fut: Future + Send + 'static,\n <Fut as Future>::Output: IntoResponse,

§

type Future = Map<Fut, fn(<Fut as Future>::Output) -> Response<Body>>

The type of future calling this handler returns.
§

fn call(\n self,\n _: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14),\n _state: S,\n) -> <F as HandlerCallWithExtractors<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14), S>>::Future

Call the handler with the extracted inputs.
§

fn into_handler(self) -> IntoHandler<Self, T, S>

Convert this HandlerCallWithExtractors into [Handler].
§

fn or<R, Rt>(self, rhs: R) -> Or<Self, R, T, Rt, S>
where\n R: HandlerCallWithExtractors<Rt, S>,

Chain two handlers together, running the second one if the first one rejects. Read more
","HandlerCallWithExtractors<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14), S>","cli::data::export::TableReference"],["
§

impl<F, Fut, S, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> HandlerCallWithExtractors<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) -> Fut,\n Fut: Future + Send + 'static,\n <Fut as Future>::Output: IntoResponse,

§

type Future = Map<Fut, fn(<Fut as Future>::Output) -> Response<Body>>

The type of future calling this handler returns.
§

fn call(\n self,\n _: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15),\n _state: S,\n) -> <F as HandlerCallWithExtractors<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15), S>>::Future

Call the handler with the extracted inputs.
§

fn into_handler(self) -> IntoHandler<Self, T, S>

Convert this HandlerCallWithExtractors into [Handler].
§

fn or<R, Rt>(self, rhs: R) -> Or<Self, R, T, Rt, S>
where\n R: HandlerCallWithExtractors<Rt, S>,

Chain two handlers together, running the second one if the first one rejects. Read more
","HandlerCallWithExtractors<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15), S>","cli::data::export::TableReference"],["
§

impl<F, Fut, S, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16> HandlerCallWithExtractors<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16) -> Fut,\n Fut: Future + Send + 'static,\n <Fut as Future>::Output: IntoResponse,

§

type Future = Map<Fut, fn(<Fut as Future>::Output) -> Response<Body>>

The type of future calling this handler returns.
§

fn call(\n self,\n _: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16),\n _state: S,\n) -> <F as HandlerCallWithExtractors<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16), S>>::Future

Call the handler with the extracted inputs.
§

fn into_handler(self) -> IntoHandler<Self, T, S>

Convert this HandlerCallWithExtractors into [Handler].
§

fn or<R, Rt>(self, rhs: R) -> Or<Self, R, T, Rt, S>
where\n R: HandlerCallWithExtractors<Rt, S>,

Chain two handlers together, running the second one if the first one rejects. Read more
","HandlerCallWithExtractors<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16), S>","cli::data::export::TableReference"],["
§

impl<A, B, C> IntoParallelIterator for (A, B, C)
where\n A: IntoParallelIterator,\n <A as IntoParallelIterator>::Iter: IndexedParallelIterator,\n B: IntoParallelIterator,\n <B as IntoParallelIterator>::Iter: IndexedParallelIterator,\n C: IntoParallelIterator,\n <C as IntoParallelIterator>::Iter: IndexedParallelIterator,

§

type Item = (<A as IntoParallelIterator>::Item, <B as IntoParallelIterator>::Item, <C as IntoParallelIterator>::Item)

The type of item that the parallel iterator will produce.
§

type Iter = MultiZip<(<A as IntoParallelIterator>::Iter, <B as IntoParallelIterator>::Iter, <C as IntoParallelIterator>::Iter)>

The parallel iterator type that will be created.
§

fn into_par_iter(self) -> <(A, B, C) as IntoParallelIterator>::Iter

Converts self into a parallel iterator. Read more
","IntoParallelIterator","cli::data::export::TableReference"],["
§

impl<R, T1, T2> IntoResponse for (T1, T2, R)
where\n T1: IntoResponseParts,\n T2: IntoResponseParts,\n R: IntoResponse,

§

fn into_response(self) -> Response<Body>

Create a response.
","IntoResponse","cli::data::export::TableReference"],["
§

impl<T1, T2, T3> IntoResponseParts for (T1, T2, T3)
where\n T1: IntoResponseParts,\n T2: IntoResponseParts,\n T3: IntoResponseParts,

§

type Error = Response<Body>

The type returned in the event of an error. Read more
§

fn into_response_parts(\n self,\n res: ResponseParts,\n) -> Result<ResponseParts, <(T1, T2, T3) as IntoResponseParts>::Error>

Set parts of the response
","IntoResponseParts","cli::data::export::TableReference"],["
Source§

impl<Ix, E> IntoWeightedEdge<E> for (Ix, Ix, E)

","IntoWeightedEdge","cli::data::export::TableReference"],["
Source§

impl<Ix, E> IntoWeightedEdge<E> for (Ix, Ix, E)

","IntoWeightedEdge","cli::data::export::TableReference"],["
§

impl<S, L1, L2, L3> Layer<S> for (L1, L2, L3)
where\n L1: Layer<<L2 as Layer<<L3 as Layer<S>>::Service>>::Service>,\n L2: Layer<<L3 as Layer<S>>::Service>,\n L3: Layer<S>,

§

type Service = <L1 as Layer<<L2 as Layer<<L3 as Layer<S>>::Service>>::Service>>::Service

The wrapped service
§

fn layer(&self, service: S) -> <(L1, L2, L3) as Layer<S>>::Service

Wrap the given service with the middleware, returning a new service\nthat has been decorated with the middleware.
","Layer","cli::data::export::TableReference"],["
§

impl<A, B, C> Monoid for (A, B, C)
where\n A: Monoid,\n B: Monoid,\n C: Monoid,

§

fn empty() -> (A, B, C)

For a given Monoid, returns its empty/zero value Read more
","Monoid","cli::data::export::TableReference"],["
Source§

impl<IT, A, FromA> MultiUnzip<(FromA,)> for IT
where\n IT: Iterator<Item = (A,)>,\n FromA: Default + Extend<A>,

Source§

fn multiunzip(self) -> (FromA,)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA,)>","cli::data::export::TableReference"],["
§

impl<IT, A, FromA> MultiUnzip<(FromA,)> for IT
where\n IT: Iterator<Item = (A,)>,\n FromA: Default + Extend<A>,

§

fn multiunzip(self) -> (FromA,)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA,)>","cli::data::export::TableReference"],["
§

impl<IT, A, FromA> MultiUnzip<(FromA,)> for IT
where\n IT: Iterator<Item = (A,)>,\n FromA: Default + Extend<A>,

§

fn multiunzip(self) -> (FromA,)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA,)>","cli::data::export::TableReference"],["
Source§

impl<IT, A, FromA, B, FromB> MultiUnzip<(FromA, FromB)> for IT
where\n IT: Iterator<Item = (A, B)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,

Source§

fn multiunzip(self) -> (FromA, FromB)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB)>","cli::data::export::TableReference"],["
§

impl<IT, A, FromA, B, FromB> MultiUnzip<(FromA, FromB)> for IT
where\n IT: Iterator<Item = (A, B)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,

§

fn multiunzip(self) -> (FromA, FromB)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB)>","cli::data::export::TableReference"],["
§

impl<IT, A, FromA, B, FromB> MultiUnzip<(FromA, FromB)> for IT
where\n IT: Iterator<Item = (A, B)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,

§

fn multiunzip(self) -> (FromA, FromB)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB)>","cli::data::export::TableReference"],["
Source§

impl<IT, A, FromA, B, FromB, C, FromC> MultiUnzip<(FromA, FromB, FromC)> for IT
where\n IT: Iterator<Item = (A, B, C)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,

Source§

fn multiunzip(self) -> (FromA, FromB, FromC)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC)>","cli::data::export::TableReference"],["
§

impl<IT, A, FromA, B, FromB, C, FromC> MultiUnzip<(FromA, FromB, FromC)> for IT
where\n IT: Iterator<Item = (A, B, C)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,

§

fn multiunzip(self) -> (FromA, FromB, FromC)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC)>","cli::data::export::TableReference"],["
§

impl<IT, A, FromA, B, FromB, C, FromC> MultiUnzip<(FromA, FromB, FromC)> for IT
where\n IT: Iterator<Item = (A, B, C)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,

§

fn multiunzip(self) -> (FromA, FromB, FromC)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC)>","cli::data::export::TableReference"],["
Source§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD> MultiUnzip<(FromA, FromB, FromC, FromD)> for IT
where\n IT: Iterator<Item = (A, B, C, D)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,

Source§

fn multiunzip(self) -> (FromA, FromB, FromC, FromD)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD)>","cli::data::export::TableReference"],["
§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD> MultiUnzip<(FromA, FromB, FromC, FromD)> for IT
where\n IT: Iterator<Item = (A, B, C, D)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,

§

fn multiunzip(self) -> (FromA, FromB, FromC, FromD)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD)>","cli::data::export::TableReference"],["
§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD> MultiUnzip<(FromA, FromB, FromC, FromD)> for IT
where\n IT: Iterator<Item = (A, B, C, D)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,

§

fn multiunzip(self) -> (FromA, FromB, FromC, FromD)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD)>","cli::data::export::TableReference"],["
Source§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE> MultiUnzip<(FromA, FromB, FromC, FromD, FromE)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,

Source§

fn multiunzip(self) -> (FromA, FromB, FromC, FromD, FromE)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE)>","cli::data::export::TableReference"],["
§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE> MultiUnzip<(FromA, FromB, FromC, FromD, FromE)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,

§

fn multiunzip(self) -> (FromA, FromB, FromC, FromD, FromE)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE)>","cli::data::export::TableReference"],["
§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE> MultiUnzip<(FromA, FromB, FromC, FromD, FromE)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,

§

fn multiunzip(self) -> (FromA, FromB, FromC, FromD, FromE)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE)>","cli::data::export::TableReference"],["
Source§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E, F)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,\n FromF: Default + Extend<F>,

Source§

fn multiunzip(self) -> (FromA, FromB, FromC, FromD, FromE, FromF)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF)>","cli::data::export::TableReference"],["
§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E, F)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,\n FromF: Default + Extend<F>,

§

fn multiunzip(self) -> (FromA, FromB, FromC, FromD, FromE, FromF)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF)>","cli::data::export::TableReference"],["
§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E, F)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,\n FromF: Default + Extend<F>,

§

fn multiunzip(self) -> (FromA, FromB, FromC, FromD, FromE, FromF)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF)>","cli::data::export::TableReference"],["
Source§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E, F, G)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,\n FromF: Default + Extend<F>,\n FromG: Default + Extend<G>,

Source§

fn multiunzip(self) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG)>","cli::data::export::TableReference"],["
§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E, F, G)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,\n FromF: Default + Extend<F>,\n FromG: Default + Extend<G>,

§

fn multiunzip(self) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG)>","cli::data::export::TableReference"],["
§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E, F, G)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,\n FromF: Default + Extend<F>,\n FromG: Default + Extend<G>,

§

fn multiunzip(self) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG)>","cli::data::export::TableReference"],["
Source§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E, F, G, H)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,\n FromF: Default + Extend<F>,\n FromG: Default + Extend<G>,\n FromH: Default + Extend<H>,

Source§

fn multiunzip(self) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH)>","cli::data::export::TableReference"],["
§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E, F, G, H)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,\n FromF: Default + Extend<F>,\n FromG: Default + Extend<G>,\n FromH: Default + Extend<H>,

§

fn multiunzip(self) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH)>","cli::data::export::TableReference"],["
§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E, F, G, H)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,\n FromF: Default + Extend<F>,\n FromG: Default + Extend<G>,\n FromH: Default + Extend<H>,

§

fn multiunzip(self) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH)>","cli::data::export::TableReference"],["
Source§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E, F, G, H, I)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,\n FromF: Default + Extend<F>,\n FromG: Default + Extend<G>,\n FromH: Default + Extend<H>,\n FromI: Default + Extend<I>,

Source§

fn multiunzip(\n self,\n) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI)>","cli::data::export::TableReference"],["
§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E, F, G, H, I)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,\n FromF: Default + Extend<F>,\n FromG: Default + Extend<G>,\n FromH: Default + Extend<H>,\n FromI: Default + Extend<I>,

§

fn multiunzip(\n self,\n) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI)>","cli::data::export::TableReference"],["
§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E, F, G, H, I)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,\n FromF: Default + Extend<F>,\n FromG: Default + Extend<G>,\n FromH: Default + Extend<H>,\n FromI: Default + Extend<I>,

§

fn multiunzip(\n self,\n) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI)>","cli::data::export::TableReference"],["
Source§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,\n FromF: Default + Extend<F>,\n FromG: Default + Extend<G>,\n FromH: Default + Extend<H>,\n FromI: Default + Extend<I>,\n FromJ: Default + Extend<J>,

Source§

fn multiunzip(\n self,\n) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ)>","cli::data::export::TableReference"],["
§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,\n FromF: Default + Extend<F>,\n FromG: Default + Extend<G>,\n FromH: Default + Extend<H>,\n FromI: Default + Extend<I>,\n FromJ: Default + Extend<J>,

§

fn multiunzip(\n self,\n) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ)>","cli::data::export::TableReference"],["
§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,\n FromF: Default + Extend<F>,\n FromG: Default + Extend<G>,\n FromH: Default + Extend<H>,\n FromI: Default + Extend<I>,\n FromJ: Default + Extend<J>,

§

fn multiunzip(\n self,\n) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ)>","cli::data::export::TableReference"],["
Source§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ, K, FromK> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J, K)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,\n FromF: Default + Extend<F>,\n FromG: Default + Extend<G>,\n FromH: Default + Extend<H>,\n FromI: Default + Extend<I>,\n FromJ: Default + Extend<J>,\n FromK: Default + Extend<K>,

Source§

fn multiunzip(\n self,\n) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK)>","cli::data::export::TableReference"],["
§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ, K, FromK> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J, K)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,\n FromF: Default + Extend<F>,\n FromG: Default + Extend<G>,\n FromH: Default + Extend<H>,\n FromI: Default + Extend<I>,\n FromJ: Default + Extend<J>,\n FromK: Default + Extend<K>,

§

fn multiunzip(\n self,\n) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK)>","cli::data::export::TableReference"],["
§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ, K, FromK> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J, K)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,\n FromF: Default + Extend<F>,\n FromG: Default + Extend<G>,\n FromH: Default + Extend<H>,\n FromI: Default + Extend<I>,\n FromJ: Default + Extend<J>,\n FromK: Default + Extend<K>,

§

fn multiunzip(\n self,\n) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK)>","cli::data::export::TableReference"],["
Source§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ, K, FromK, L, FromL> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK, FromL)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J, K, L)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,\n FromF: Default + Extend<F>,\n FromG: Default + Extend<G>,\n FromH: Default + Extend<H>,\n FromI: Default + Extend<I>,\n FromJ: Default + Extend<J>,\n FromK: Default + Extend<K>,\n FromL: Default + Extend<L>,

","MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK, FromL)>","cli::data::export::TableReference"],["
§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ, K, FromK, L, FromL> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK, FromL)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J, K, L)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,\n FromF: Default + Extend<F>,\n FromG: Default + Extend<G>,\n FromH: Default + Extend<H>,\n FromI: Default + Extend<I>,\n FromJ: Default + Extend<J>,\n FromK: Default + Extend<K>,\n FromL: Default + Extend<L>,

§

fn multiunzip(\n self,\n) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK, FromL)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK, FromL)>","cli::data::export::TableReference"],["
§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ, K, FromK, L, FromL> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK, FromL)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J, K, L)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,\n FromF: Default + Extend<F>,\n FromG: Default + Extend<G>,\n FromH: Default + Extend<H>,\n FromI: Default + Extend<I>,\n FromJ: Default + Extend<J>,\n FromK: Default + Extend<K>,\n FromL: Default + Extend<L>,

§

fn multiunzip(\n self,\n) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK, FromL)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK, FromL)>","cli::data::export::TableReference"],["
§

impl<I, O1, O2, O3, E, P1, P2, P3> Parser<I> for (P1, P2, P3)
where\n E: ParseError<I>,\n P1: Parser<I, Output = O1, Error = E>,\n P2: Parser<I, Output = O2, Error = E>,\n P3: Parser<I, Output = O3, Error = E>,

§

type Output = (O1, O2, O3)

Type of the produced value
§

type Error = E

Error type of this parser
§

fn process<OM>(\n &mut self,\n i: I,\n) -> Result<(I, <<OM as OutputMode>::Output as Mode>::Output<<(P1, P2, P3) as Parser<I>>::Output>), Err<<(P1, P2, P3) as Parser<I>>::Error, <<OM as OutputMode>::Error as Mode>::Output<<(P1, P2, P3) as Parser<I>>::Error>>>
where\n OM: OutputMode,

A parser takes in input type, and returns a Result containing\neither the remaining input and the output value, or an error
§

fn parse(\n &mut self,\n input: Input,\n) -> Result<(Input, Self::Output), Err<Self::Error>>

A parser takes in input type, and returns a Result containing\neither the remaining input and the output value, or an error
§

fn parse_complete(\n &mut self,\n input: Input,\n) -> Result<(Input, Self::Output), Err<Self::Error>>

A parser takes in input type, and returns a Result containing\neither the remaining input and the output value, or an error
§

fn map<G, O2>(self, g: G) -> Map<Self, G>
where\n G: FnMut(Self::Output) -> O2,\n Self: Sized,

Maps a function over the result of a parser
§

fn map_res<G, O2, E2>(self, g: G) -> MapRes<Self, G>
where\n G: FnMut(Self::Output) -> Result<O2, E2>,\n Self::Error: FromExternalError<Input, E2>,\n Self: Sized,

Applies a function returning a Result over the result of a parser.
§

fn map_opt<G, O2>(self, g: G) -> MapOpt<Self, G>
where\n G: FnMut(Self::Output) -> Option<O2>,\n Self: Sized,

Applies a function returning an Option over the result of a parser.
§

fn flat_map<G, H>(self, g: G) -> FlatMap<Self, G>
where\n G: FnMut(Self::Output) -> H,\n H: Parser<Input, Error = Self::Error>,\n Self: Sized,

Creates a second parser from the output of the first one, then apply over the rest of the input
§

fn and_then<G>(self, g: G) -> AndThen<Self, G>
where\n G: Parser<Self::Output, Error = Self::Error>,\n Self: Sized,

Applies a second parser over the output of the first one
§

fn and<G, O2>(self, g: G) -> And<Self, G>
where\n G: Parser<Input, Output = O2, Error = Self::Error>,\n Self: Sized,

Applies a second parser after the first one, return their results as a tuple
§

fn or<G>(self, g: G) -> Or<Self, G>
where\n G: Parser<Input, Output = Self::Output, Error = Self::Error>,\n Self: Sized,

Applies a second parser over the input if the first one failed
§

fn into<O2, E2>(self) -> Into<Self, O2, E2>
where\n O2: From<Self::Output>,\n E2: From<Self::Error>,\n Self: Sized,

automatically converts the parser’s output and error values to another type, as long as they\nimplement the From trait
","Parser","cli::data::export::TableReference"],["
§

impl<I, O0, O1, O2, E, P0, P1, P2> Parser<I, (O0, O1, O2), E> for (P0, P1, P2)
where\n I: Stream,\n E: ParserError<I>,\n P0: Parser<I, O0, E>,\n P1: Parser<I, O1, E>,\n P2: Parser<I, O2, E>,

§

fn parse_next(&mut self, i: &mut I) -> Result<(O0, O1, O2), E>

Take tokens from the [Stream], turning it into the output Read more
§

fn parse(\n &mut self,\n input: I,\n) -> Result<O, ParseError<I, <E as ParserError<I>>::Inner>>
where\n Self: Sized,\n I: Stream + StreamIsPartial,\n E: ParserError<I>,\n <E as ParserError<I>>::Inner: ParserError<I>,

Parse all of input, generating O from it
§

fn parse_peek(&mut self, input: I) -> Result<(I, O), E>

Take tokens from the [Stream], turning it into the output Read more
§

fn by_ref(&mut self) -> ByRef<'_, Self, I, O, E>
where\n Self: Sized,

Treat &mut Self as a parser Read more
§

fn value<O2>(self, val: O2) -> Value<Self, I, O, O2, E>
where\n Self: Sized,\n O2: Clone,

Produce the provided value Read more
§

fn default_value<O2>(self) -> DefaultValue<Self, I, O, O2, E>
where\n Self: Sized,\n O2: Default,

Produce a type’s default value Read more
§

fn void(self) -> Void<Self, I, O, E>
where\n Self: Sized,

Discards the output of the Parser Read more
§

fn output_into<O2>(self) -> OutputInto<Self, I, O, O2, E>
where\n Self: Sized,\n O: Into<O2>,

Convert the parser’s output to another type using std::convert::From Read more
§

fn take(self) -> Take<Self, I, O, E>
where\n Self: Sized,\n I: Stream,

Produce the consumed input as produced value. Read more
§

fn with_taken(self) -> WithTaken<Self, I, O, E>
where\n Self: Sized,\n I: Stream,

Produce the consumed input with the output Read more
§

fn span(self) -> Span<Self, I, O, E>
where\n Self: Sized,\n I: Stream + Location,

Produce the location of the consumed input as produced value. Read more
§

fn with_span(self) -> WithSpan<Self, I, O, E>
where\n Self: Sized,\n I: Stream + Location,

Produce the location of consumed input with the output Read more
§

fn map<G, O2>(self, map: G) -> Map<Self, G, I, O, O2, E>
where\n G: FnMut(O) -> O2,\n Self: Sized,

Maps a function over the output of a parser Read more
§

fn try_map<G, O2, E2>(self, map: G) -> TryMap<Self, G, I, O, O2, E, E2>
where\n Self: Sized,\n G: FnMut(O) -> Result<O2, E2>,\n I: Stream,\n E: FromExternalError<I, E2> + ParserError<I>,

Applies a function returning a Result over the output of a parser. Read more
§

fn verify_map<G, O2>(self, map: G) -> VerifyMap<Self, G, I, O, O2, E>
where\n Self: Sized,\n G: FnMut(O) -> Option<O2>,\n I: Stream,\n E: ParserError<I>,

Apply both [Parser::verify] and [Parser::map]. Read more
§

fn flat_map<G, H, O2>(self, map: G) -> FlatMap<Self, G, H, I, O, O2, E>
where\n Self: Sized,\n G: FnMut(O) -> H,\n H: Parser<I, O2, E>,

Creates a parser from the output of this one Read more
§

fn and_then<G, O2>(self, inner: G) -> AndThen<Self, G, I, O, O2, E>
where\n Self: Sized,\n G: Parser<O, O2, E>,\n O: StreamIsPartial,\n I: Stream,

Applies a second parser over the output of the first one Read more
§

fn parse_to<O2>(self) -> ParseTo<Self, I, O, O2, E>
where\n Self: Sized,\n I: Stream,\n O: ParseSlice<O2>,\n E: ParserError<I>,

Apply std::str::FromStr to the output of the parser Read more
§

fn verify<G, O2>(self, filter: G) -> Verify<Self, G, I, O, O2, E>
where\n Self: Sized,\n G: FnMut(&O2) -> bool,\n I: Stream,\n O: Borrow<O2>,\n E: ParserError<I>,\n O2: ?Sized,

Returns the output of the child parser if it satisfies a verification function. Read more
§

fn context<C>(self, context: C) -> Context<Self, I, O, E, C>
where\n Self: Sized,\n I: Stream,\n E: AddContext<I, C> + ParserError<I>,\n C: Clone + Debug,

If parsing fails, add context to the error Read more
§

fn context_with<F, C, FI>(\n self,\n context: F,\n) -> ContextWith<Self, I, O, E, F, C, FI>
where\n Self: Sized,\n I: Stream,\n E: AddContext<I, C> + ParserError<I>,\n F: Fn() -> FI + Clone,\n C: Debug,\n FI: Iterator<Item = C>,

If parsing fails, dynamically add context to the error Read more
§

fn map_err<G, E2>(self, map: G) -> MapErr<Self, G, I, O, E, E2>
where\n G: FnMut(E) -> E2,\n Self: Sized,

Maps a function over the error of a parser Read more
§

fn complete_err(self) -> CompleteErr<Self, I, O, E>
where\n Self: Sized,

Transforms [Incomplete][crate::error::ErrMode::Incomplete] into [Backtrack][crate::error::ErrMode::Backtrack] Read more
§

fn err_into<E2>(self) -> ErrInto<Self, I, O, E, E2>
where\n Self: Sized,\n E: Into<E2>,

Convert the parser’s error to another type using std::convert::From
","Parser","cli::data::export::TableReference"],["
§

impl<I, O1, O2, O3, Error, P1, P2, P3> Permutation<I, (O1, O2, O3), Error> for (P1, P2, P3)
where\n I: Stream,\n Error: ParserError<I>,\n P1: Parser<I, O1, Error>,\n P2: Parser<I, O2, Error>,\n P3: Parser<I, O3, Error>,

§

fn permutation(&mut self, input: &mut I) -> Result<(O1, O2, O3), Error>

Tries to apply all parsers in the tuple in various orders until all of them succeed
","Permutation","cli::data::export::TableReference"],["
§

impl<Input, A, B, C, Error, FnA, FnB, FnC> Permutation<Input, (A, B, C), Error> for (FnA, FnB, FnC)
where\n Input: Clone,\n Error: ParseError<Input>,\n FnA: Parser<Input, A, Error>,\n FnB: Parser<Input, B, Error>,\n FnC: Parser<Input, C, Error>,

§

fn permutation(\n &mut self,\n input: Input,\n) -> Result<(Input, (A, B, C)), Err<Error>>

Tries to apply all parsers in the tuple in various orders until all of them succeed
","Permutation","cli::data::export::TableReference"],["
§

impl<T1, T2, T3> PgHasArrayType for (T1, T2, T3)

§

fn array_type_info() -> PgTypeInfo

§

fn array_compatible(ty: &PgTypeInfo) -> bool

","PgHasArrayType","cli::data::export::TableReference"],["
§

impl<S> Point for (S, S, S)
where\n S: RTreeNum,

§

const DIMENSIONS: usize = 3usize

The number of dimensions of this point type.
§

type Scalar = S

The number type used by this point type.
§

fn generate(generator: impl FnMut(usize) -> S) -> (S, S, S)

Creates a new point value with given values for each dimension. Read more
§

fn nth(&self, index: usize) -> <(S, S, S) as Point>::Scalar

Returns a single coordinate of this point. Read more
§

fn nth_mut(&mut self, index: usize) -> &mut <(S, S, S) as Point>::Scalar

Mutable variant of nth.
","Point","cli::data::export::TableReference"],["
§

impl<A, B, C> Semigroup for (A, B, C)
where\n A: Semigroup,\n B: Semigroup,\n C: Semigroup,

§

fn combine(&self, other: &(A, B, C)) -> (A, B, C)

Associative operation taking which combines two values. Read more
","Semigroup","cli::data::export::TableReference"],["
Source§

impl<T0, T1, T2> Serialize for (T0, T1, T2)
where\n T0: Serialize,\n T1: Serialize,\n T2: Serialize,

Source§

fn serialize<S>(\n &self,\n serializer: S,\n) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>
where\n S: Serializer,

Serialize this value into the given Serde serializer. Read more
","Serialize","cli::data::export::TableReference"],["
Source§

impl<T0, As0, T1, As1, T2, As2> SerializeAs<(T0, T1, T2)> for (As0, As1, As2)
where\n As0: SerializeAs<T0>,\n As1: SerializeAs<T1>,\n As2: SerializeAs<T2>,

Source§

fn serialize_as<S>(\n tuple: &(T0, T1, T2),\n serializer: S,\n) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>
where\n S: Serializer,

Serialize this value into the given Serde serializer.
","SerializeAs<(T0, T1, T2)>","cli::data::export::TableReference"],["
§

impl<'a, T, C0, C1, C2> TreeNodeContainer<'a, T> for (C0, C1, C2)
where\n T: 'a,\n C0: TreeNodeContainer<'a, T>,\n C1: TreeNodeContainer<'a, T>,\n C2: TreeNodeContainer<'a, T>,

§

fn apply_elements<F>(\n &'a self,\n f: F,\n) -> Result<TreeNodeRecursion, DataFusionError>
where\n F: FnMut(&'a T) -> Result<TreeNodeRecursion, DataFusionError>,

Applies f to all elements of the container.\nThis method is usually called from [TreeNode::apply_children] implementations as\na node is actually a container of the node’s children.
§

fn map_elements<F>(\n self,\n f: F,\n) -> Result<Transformed<(C0, C1, C2)>, DataFusionError>
where\n F: FnMut(T) -> Result<Transformed<T>, DataFusionError>,

Maps all elements of the container with f.\nThis method is usually called from [TreeNode::map_children] implementations as\na node is actually a container of the node’s children.
","TreeNodeContainer<'a, T>","cli::data::export::TableReference"],["
§

impl<Input, A, B, C, Error, FnA, FnB, FnC> Tuple<Input, (A, B, C), Error> for (FnA, FnB, FnC)
where\n Input: Clone,\n Error: ParseError<Input>,\n FnA: Parser<Input, A, Error>,\n FnB: Parser<Input, B, Error>,\n FnC: Parser<Input, C, Error>,

§

fn parse(&mut self, input: Input) -> Result<(Input, (A, B, C)), Err<Error>>

Parses the input and returns a tuple of results of each parser.
","Tuple","cli::data::export::TableReference"],["
§

impl<Input, A, B, C, Error, FnA, FnB, FnC> Tuple<Input, (A, B, C), Error> for (FnA, FnB, FnC)
where\n Input: Clone,\n Error: ParseError<Input>,\n FnA: Parser<Input, Output = A, Error = Error>,\n FnB: Parser<Input, Output = B, Error = Error>,\n FnC: Parser<Input, Output = C, Error = Error>,

§

fn parse_tuple(\n &mut self,\n input: Input,\n) -> Result<(Input, (A, B, C)), Err<Error>>

👎Deprecated since 8.0.0: Parser is directly implemented for tuples
Parses the input and returns a tuple of results of each parser.
","Tuple","cli::data::export::TableReference"],["
§

impl<T1, T2, T3> Type<Postgres> for (T1, T2, T3)

§

fn type_info() -> PgTypeInfo

Returns the canonical SQL type for this Rust type. Read more
§

fn compatible(ty: &<DB as Database>::TypeInfo) -> bool

Determines if this Rust type is compatible with the given SQL type. Read more
","Type","cli::data::export::TableReference"],["
§

impl<A, B, C> UnsizedCopy for (A, B, C)
where\n A: Copy,\n B: Copy,\n C: UnsizedCopy + ?Sized,

§

type Alignment = (A, B, <C as UnsizedCopy>::Alignment)

A type with the same alignment as Self. Read more
§

fn ptr_with_addr(&self, addr: *const ()) -> *const (A, B, C)

Change the address of a pointer to Self. Read more
§

fn unsized_copy_into<T>(&self) -> T
where\n T: UnsizedCopyFrom<Source = Self>,

Copy self into a new container. Read more
§

fn copy(&self) -> Self
where\n Self: Sized,

Copy self and return it by value. Read more
","UnsizedCopy","cli::data::export::TableReference"],["
§

impl<T2, T1, T0> Values for (T2, T1, T0)
where\n T2: Values,\n T1: Values,\n T0: Values,

§

fn encoded_len(&self, mode: Mode) -> usize

Returns the length of the encoded values for the given mode.
§

fn write_encoded<W>(&self, mode: Mode, target: &mut W) -> Result<(), Error>
where\n W: Write,

Encodes the values in the given mode and writes them to target.
§

fn explicit(self, tag: Tag) -> Constructed<Self>
where\n Self: Sized,

Converts the encoder into one with an explicit tag.
§

fn to_captured(&self, mode: Mode) -> Captured

Captures the encoded values in the given mode.
","Values","cli::data::export::TableReference"],["
§

impl<'a, A, B, C, AE, BE, CE, Format> ZeroFrom<'a, Tuple3VarULE<A, B, C, Format>> for (AE, BE, CE)
where\n A: VarULE + ?Sized,\n B: VarULE + ?Sized,\n C: VarULE + ?Sized,\n AE: ZeroFrom<'a, A>,\n BE: ZeroFrom<'a, B>,\n CE: ZeroFrom<'a, C>,\n Format: VarZeroVecFormat,

§

fn zero_from(other: &'a Tuple3VarULE<A, B, C, Format>) -> (AE, BE, CE)

Clone the other C into a struct that may retain references into C.
","ZeroFrom<'a, Tuple3VarULE>","cli::data::export::TableReference"],["
§

impl<'zf, C1, T1, C2, T2, C3, T3> ZeroFrom<'zf, (C1, C2, C3)> for (T1, T2, T3)
where\n T1: ZeroFrom<'zf, C1>,\n T2: ZeroFrom<'zf, C2>,\n T3: ZeroFrom<'zf, C3>,

§

fn zero_from(other: &'zf (C1, C2, C3)) -> (T1, T2, T3)

Clone the other C into a struct that may retain references into C.
","ZeroFrom<'zf, (C1, C2, C3)>","cli::data::export::TableReference"],["
§

impl<'a, A, B, C> ZeroMapKV<'a> for (A, B, C)
where\n A: Ord + AsULE + 'static,\n B: Ord + AsULE + 'static,\n C: Ord + AsULE + 'static,

§

type Container = ZeroVec<'a, (A, B, C)>

The container that can be used with this type: [ZeroVec] or [VarZeroVec].
§

type Slice = ZeroSlice<(A, B, C)>

§

type GetType = Tuple3ULE<<A as AsULE>::ULE, <B as AsULE>::ULE, <C as AsULE>::ULE>

The type produced by Container::get() Read more
§

type OwnedType = (A, B, C)

The type produced by Container::replace() and Container::remove(),\nalso used during deserialization. If Self is human readable serialized,\ndeserializing to Self::OwnedType should produce the same value once\npassed through Self::owned_as_self() Read more
","ZeroMapKV<'a>","cli::data::export::TableReference"],["
§

impl<A, B, C> Zeroable for (A, B, C)
where\n A: Zeroable,\n B: Zeroable,\n C: Zeroable,

§

fn zeroed() -> Self

","Zeroable","cli::data::export::TableReference"],["
§

impl<A, B, C> Zeroize for (A, B, C)
where\n A: Zeroize,\n B: Zeroize,\n C: Zeroize,

§

fn zeroize(&mut self)

Zero out this object from memory using Rust intrinsics which ensure the\nzeroization operation is not “optimized away” by the compiler.
","Zeroize","cli::data::export::TableReference"],["
§

impl<A, B, C> ZeroizeOnDrop for (A, B, C)
where\n A: ZeroizeOnDrop,\n B: ZeroizeOnDrop,\n C: ZeroizeOnDrop,

","ZeroizeOnDrop","cli::data::export::TableReference"]]],["common_function",[["
§

impl<I, Output, Error, Alt2, Alt3> Alt<I, Output, Error> for (Alt2, Alt3)
where\n I: Stream,\n Error: ParserError<I>,\n Alt2: Parser<I, Output, Error>,\n Alt3: Parser<I, Output, Error>,

§

fn choice(&mut self, input: &mut I) -> Result<Output, Error>

Tests each parser in the tuple and returns the result of the first one that succeeds
","Alt","common_function::scalars::primary_key::NameValuePair"],["
§

impl<Input, Output, Error, A, B> Alt<Input, Output, Error> for (A, B)
where\n Input: Clone,\n Error: ParseError<Input>,\n A: Parser<Input, Output, Error>,\n B: Parser<Input, Output, Error>,

§

fn choice(&mut self, input: Input) -> Result<(Input, Output), Err<Error>>

Tests each parser in the tuple and returns the result of the first one that succeeds
","Alt","common_function::scalars::primary_key::NameValuePair"],["
§

impl<A, B> AsULE for (A, B)
where\n A: AsULE,\n B: AsULE,

§

type ULE = Tuple2ULE<<A as AsULE>::ULE, <B as AsULE>::ULE>

The ULE type corresponding to Self. Read more
§

fn to_unaligned(self) -> <(A, B) as AsULE>::ULE

Converts from Self to Self::ULE. Read more
§

fn from_unaligned(unaligned: <(A, B) as AsULE>::ULE) -> (A, B)

Converts from Self::ULE to Self. Read more
","AsULE","common_function::scalars::primary_key::NameValuePair"],["
§

impl<A, B> AssertFloatEq for (A, B)
where\n A: AssertFloatEq + Debug,\n B: AssertFloatEq + Debug + ?Sized,\n <A as FloatEq>::Tol: Sized,\n <B as FloatEq>::Tol: Sized,\n <A as AssertFloatEq>::DebugTol: Sized,\n <B as AssertFloatEq>::DebugTol: Sized,\n <<A as FloatEq>::Tol as FloatEqUlpsTol>::UlpsTol: Sized,\n <<B as FloatEq>::Tol as FloatEqUlpsTol>::UlpsTol: Sized,\n <<A as AssertFloatEq>::DebugTol as FloatEqUlpsTol>::UlpsTol: Sized,\n <<B as AssertFloatEq>::DebugTol as FloatEqUlpsTol>::UlpsTol: Sized,

§

type DebugAbsDiff = (<A as AssertFloatEq>::DebugAbsDiff, <B as AssertFloatEq>::DebugAbsDiff)

The absolute difference between two values, displayed to the user via\nfmt::Debug when an assert fails. Read more
§

type DebugTol = (<A as AssertFloatEq>::DebugTol, <B as AssertFloatEq>::DebugTol)

The per-field tolerance value used for comparison between two values,\ndisplayed to the user via fmt::Debug when an assert fails. Read more
§

fn debug_abs_diff(\n &self,\n other: &(A, B),\n) -> <(A, B) as AssertFloatEq>::DebugAbsDiff

Always positive absolute difference between two values. Read more
§

fn debug_ulps_diff(\n &self,\n other: &(A, B),\n) -> <<(A, B) as AssertFloatEq>::DebugAbsDiff as FloatEqDebugUlpsDiff>::DebugUlpsDiff

Always positive absolute difference between two values in terms of ULPs. Read more
§

fn debug_abs_tol(\n &self,\n other: &(A, B),\n tol: &<(A, B) as FloatEq>::Tol,\n) -> <(A, B) as AssertFloatEq>::DebugTol

The tolerance used by an abs comparison, displayed when an assert fails.
§

fn debug_rmax_tol(\n &self,\n other: &(A, B),\n tol: &<(A, B) as FloatEq>::Tol,\n) -> <(A, B) as AssertFloatEq>::DebugTol

The tolerance used by an rmax comparison, displayed when an assert fails. Read more
§

fn debug_rmin_tol(\n &self,\n other: &(A, B),\n tol: &<(A, B) as FloatEq>::Tol,\n) -> <(A, B) as AssertFloatEq>::DebugTol

The tolerance used by an rmin comparison, displayed when an assert fails. Read more
§

fn debug_r1st_tol(\n &self,\n other: &(A, B),\n tol: &<(A, B) as FloatEq>::Tol,\n) -> <(A, B) as AssertFloatEq>::DebugTol

The tolerance used by an r1st comparison, displayed when an assert fails. Read more
§

fn debug_r2nd_tol(\n &self,\n other: &(A, B),\n tol: &<(A, B) as FloatEq>::Tol,\n) -> <(A, B) as AssertFloatEq>::DebugTol

The tolerance used by an r2nd comparison, displayed when an assert fails. Read more
§

fn debug_ulps_tol(\n &self,\n other: &(A, B),\n tol: &<<(A, B) as FloatEq>::Tol as FloatEqUlpsTol>::UlpsTol,\n) -> <<(A, B) as AssertFloatEq>::DebugTol as FloatEqUlpsTol>::UlpsTol

The tolerance used by an ulps comparison, displayed when an assert fails.
§

fn debug_rel_tol(&self, other: &Rhs, tol: &Self::Tol) -> Self::DebugTol

The tolerance used by a rel comparison, displayed when an assert fails. Read more
","AssertFloatEq","common_function::scalars::primary_key::NameValuePair"],["
Source§

impl<S, T> Bounded for (S, T)
where\n S: Bounded,\n T: Bounded,

Source§

fn min_value() -> (S, T)

Returns the smallest finite number this type can represent
Source§

fn max_value() -> (S, T)

Returns the largest finite number this type can represent
","Bounded","common_function::scalars::primary_key::NameValuePair"],["
§

impl<T, F1, F2> ContainsToken<T> for (F1, F2)
where\n T: Clone,\n F1: ContainsToken<T>,\n F2: ContainsToken<T>,

§

fn contains_token(&self, token: T) -> bool

Returns true if self contains the token
","ContainsToken","common_function::scalars::primary_key::NameValuePair"],["
§

impl<'r, T1, T2> Decode<'r, Postgres> for (T1, T2)
where\n T1: 'r + Type<Postgres> + for<'a> Decode<'a, Postgres>,\n T2: 'r + Type<Postgres> + for<'a> Decode<'a, Postgres>,

§

fn decode(\n value: PgValueRef<'r>,\n) -> Result<(T1, T2), Box<dyn Error + Sync + Send>>

Decode a new value of this type using a raw value from the database.
","Decode<'r, Postgres>","common_function::scalars::primary_key::NameValuePair"],["
Source§

impl<'de, T0, T1> Deserialize<'de> for (T0, T1)
where\n T0: Deserialize<'de>,\n T1: Deserialize<'de>,

Source§

fn deserialize<D>(\n deserializer: D,\n) -> Result<(T0, T1), <D as Deserializer<'de>>::Error>
where\n D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer. Read more
","Deserialize<'de>","common_function::scalars::primary_key::NameValuePair"],["
Source§

impl<'de, T0, As0, T1, As1> DeserializeAs<'de, (T0, T1)> for (As0, As1)
where\n As0: DeserializeAs<'de, T0>,\n As1: DeserializeAs<'de, T1>,

Source§

fn deserialize_as<D>(\n deserializer: D,\n) -> Result<(T0, T1), <D as Deserializer<'de>>::Error>
where\n D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.
","DeserializeAs<'de, (T0, T1)>","common_function::scalars::primary_key::NameValuePair"],["
§

impl<A, B, AE, BE, Format> EncodeAsVarULE<Tuple2VarULE<A, B, Format>> for (AE, BE)
where\n A: VarULE + ?Sized,\n B: VarULE + ?Sized,\n AE: EncodeAsVarULE<A>,\n BE: EncodeAsVarULE<B>,\n Format: VarZeroVecFormat,

§

fn encode_var_ule_as_slices<R>(&self, _: impl FnOnce(&[&[u8]]) -> R) -> R

Calls cb with a piecewise list of byte slices that when concatenated\nproduce the memory pattern of the corresponding instance of T. Read more
§

fn encode_var_ule_len(&self) -> usize

Return the length, in bytes, of the corresponding [VarULE] type
§

fn encode_var_ule_write(&self, dst: &mut [u8])

Write the corresponding [VarULE] type to the dst buffer. dst should\nbe the size of [Self::encode_var_ule_len()]
","EncodeAsVarULE>","common_function::scalars::primary_key::NameValuePair"],["
§

impl<A, B> FloatEq for (A, B)
where\n A: FloatEq,\n B: FloatEq + ?Sized,\n <A as FloatEq>::Tol: Sized,\n <B as FloatEq>::Tol: Sized,\n <<A as FloatEq>::Tol as FloatEqUlpsTol>::UlpsTol: Sized,\n <<B as FloatEq>::Tol as FloatEqUlpsTol>::UlpsTol: Sized,

§

type Tol = (<A as FloatEq>::Tol, <B as FloatEq>::Tol)

Type of the maximum allowed difference between two values for them to be\nconsidered equal.
§

fn eq_abs(&self, other: &(A, B), tol: &<(A, B) as FloatEq>::Tol) -> bool

Check whether self is equal to other, using an absolute tolerance\ncomparison. Read more
§

fn eq_rmax(&self, other: &(A, B), tol: &<(A, B) as FloatEq>::Tol) -> bool

Check whether self is equal to other, using a relative tolerance\ncomparison, scaled to the granularity of the input with the largest\nmagnitude. Read more
§

fn eq_rmin(&self, other: &(A, B), tol: &<(A, B) as FloatEq>::Tol) -> bool

Check whether self is equal to other, using a relative tolerance\ncomparison, scaled to the granularity of the input with the smallest\nmagnitude. Read more
§

fn eq_r1st(&self, other: &(A, B), tol: &<(A, B) as FloatEq>::Tol) -> bool

Check whether self is equal to other, using a relative tolerance\ncomparison, scaled to the granularity of the first input. Read more
§

fn eq_r2nd(&self, other: &(A, B), tol: &<(A, B) as FloatEq>::Tol) -> bool

Check whether self is equal to other, using a relative tolerance\ncomparison, scaled to the granularity of the second input. Read more
§

fn eq_ulps(\n &self,\n other: &(A, B),\n tol: &<<(A, B) as FloatEq>::Tol as FloatEqUlpsTol>::UlpsTol,\n) -> bool

Check whether self is equal to other, using an ULPs comparison. Read more
§

fn ne_abs(&self, other: &Rhs, tol: &Self::Tol) -> bool

Check whether self is not equal to other, using an absolute tolerance\ncomparison. Read more
§

fn eq_rel(&self, other: &Rhs, tol: &Self::Tol) -> bool

Check whether self is equal to other, using a relative tolerance\ncomparison. Read more
§

fn ne_rel(&self, other: &Rhs, tol: &Self::Tol) -> bool

Check whether self is not equal to other, using a relative tolerance\ncomparison. Read more
§

fn ne_rmax(&self, other: &Rhs, tol: &Self::Tol) -> bool

Check whether self is not equal to other, using a relative tolerance\ncomparison. Read more
§

fn ne_rmin(&self, other: &Rhs, tol: &Self::Tol) -> bool

Check whether self is not equal to other, using a relative tolerance\ncomparison. Read more
§

fn ne_r1st(&self, other: &Rhs, tol: &Self::Tol) -> bool

Check whether self is not equal to other, using a relative tolerance\ncomparison. Read more
§

fn ne_r2nd(&self, other: &Rhs, tol: &Self::Tol) -> bool

Check whether self is not equal to other, using a relative tolerance\ncomparison. Read more
§

fn ne_ulps(\n &self,\n other: &Rhs,\n tol: &<Self::Tol as FloatEqUlpsTol>::UlpsTol,\n) -> bool

Check whether self is not equal to other, using an ULPs comparison. Read more
","FloatEq","common_function::scalars::primary_key::NameValuePair"],["
§

impl<A, B> FloatEqDebugUlpsDiff for (A, B)
where\n A: FloatEqDebugUlpsDiff,\n B: FloatEqDebugUlpsDiff,

§

type DebugUlpsDiff = (<A as FloatEqDebugUlpsDiff>::DebugUlpsDiff, <B as FloatEqDebugUlpsDiff>::DebugUlpsDiff)

A structurally identical type to Self, with fields recursively wrapped\nby DebugUlpsDiff.
","FloatEqDebugUlpsDiff","common_function::scalars::primary_key::NameValuePair"],["
§

impl<A, B> FloatEqUlpsTol for (A, B)
where\n A: FloatEqUlpsTol,\n B: FloatEqUlpsTol + ?Sized,\n <A as FloatEqUlpsTol>::UlpsTol: Sized,\n <B as FloatEqUlpsTol>::UlpsTol: Sized,

§

type UlpsTol = (<A as FloatEqUlpsTol>::UlpsTol, <B as FloatEqUlpsTol>::UlpsTol)

A structurally identical type to Self, with fields recursively wrapped\nby UlpsTol.
","FloatEqUlpsTol","common_function::scalars::primary_key::NameValuePair"],["
§

impl<T> From<Attr<T>> for (T, Option<T>)

Unpacks attribute key and value into tuple of this two elements.\nNone value element is returned only for [Attr::Empty] variant.

\n
§

fn from(attr: Attr<T>) -> (T, Option<T>)

Converts to this type from the input type.
","From>","common_function::scalars::primary_key::NameValuePair"],["
§

impl<T> From<Coord<T>> for (T, T)
where\n T: CoordNum,

§

fn from(coord: Coord<T>) -> (T, T)

Converts to this type from the input type.
","From>","common_function::scalars::primary_key::NameValuePair"],["
§

impl<T> From<Point<T>> for (T, T)
where\n T: CoordNum,

§

fn from(point: Point<T>) -> (T, T)

Converts to this type from the input type.
","From>","common_function::scalars::primary_key::NameValuePair"],["
§

impl<S> From<Point2<S>> for (S, S)
where\n S: SpadeNum,

§

fn from(point: Point2<S>) -> (S, S)

Converts to this type from the input type.
","From>","common_function::scalars::primary_key::NameValuePair"],["
Source§

impl<T> From<Ratio<T>> for (T, T)

Source§

fn from(val: Ratio<T>) -> (T, T)

Converts to this type from the input type.
","From>","common_function::scalars::primary_key::NameValuePair"],["
§

impl<A, B, FromA, FromB> FromParallelIterator<(A, B)> for (FromA, FromB)
where\n A: Send,\n B: Send,\n FromA: Send + FromParallelIterator<A>,\n FromB: Send + FromParallelIterator<B>,

§

fn from_par_iter<I>(pi: I) -> (FromA, FromB)
where\n I: IntoParallelIterator<Item = (A, B)>,

Creates an instance of the collection from the parallel iterator par_iter. Read more
","FromParallelIterator<(A, B)>","common_function::scalars::primary_key::NameValuePair"],["
§

impl<L, R, A, B> FromParallelIterator<Either<L, R>> for (A, B)
where\n L: Send,\n R: Send,\n A: Send + FromParallelIterator<L>,\n B: Send + FromParallelIterator<R>,

§

fn from_par_iter<I>(pi: I) -> (A, B)
where\n I: IntoParallelIterator<Item = Either<L, R>>,

Creates an instance of the collection from the parallel iterator par_iter. Read more
","FromParallelIterator>","common_function::scalars::primary_key::NameValuePair"],["
§

impl<S, T1, T2> FromRequest<S> for (T1, T2)
where\n T1: FromRequestParts<S> + Send,\n T2: FromRequest<S> + Send,\n S: Send + Sync,

§

type Rejection = Response<Body>

If the extractor fails it’ll use this “rejection” type. A rejection is\na kind of error that can be converted into a response.
§

fn from_request(\n req: Request<Body>,\n state: &S,\n) -> impl Future<Output = Result<(T1, T2), <(T1, T2) as FromRequest<S>>::Rejection>>

Perform the extraction.
","FromRequest","common_function::scalars::primary_key::NameValuePair"],["
§

impl<S, T1, T2> FromRequestParts<S> for (T1, T2)
where\n T1: FromRequestParts<S> + Send,\n T2: FromRequestParts<S> + Send,\n S: Send + Sync,

§

type Rejection = Response<Body>

If the extractor fails it’ll use this “rejection” type. A rejection is\na kind of error that can be converted into a response.
§

async fn from_request_parts(\n parts: &mut Parts,\n state: &S,\n) -> Result<(T1, T2), <(T1, T2) as FromRequestParts<S>>::Rejection>

Perform the extraction.
","FromRequestParts","common_function::scalars::primary_key::NameValuePair"],["
§

impl<'r, R, T1, T2> FromRow<'r, R> for (T1, T2)
where\n R: Row,\n usize: ColumnIndex<R>,\n T1: Decode<'r, <R as Row>::Database> + Type<<R as Row>::Database>,\n T2: Decode<'r, <R as Row>::Database> + Type<<R as Row>::Database>,

§

fn from_row(row: &'r R) -> Result<(T1, T2), Error>

","FromRow<'r, R>","common_function::scalars::primary_key::NameValuePair"],["
§

impl<F, Fut, Res, S> Handler<((),), S> for F
where\n F: FnOnce() -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n Res: IntoResponse,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n _req: Request<Body>,\n _state: S,\n) -> <F as Handler<((),), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<((),), S>","common_function::scalars::primary_key::NameValuePair"],["
§

impl<F, Fut, S, Res, M, T1> Handler<(M, T1), S> for F
where\n F: FnOnce(T1) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1), S>","common_function::scalars::primary_key::NameValuePair"],["
§

impl<F, Fut, S, Res, M, T1, T2> Handler<(M, T1, T2), S> for F
where\n F: FnOnce(T1, T2) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequestParts<S> + Send,\n T2: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1, T2), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1, T2), S>","common_function::scalars::primary_key::NameValuePair"],["
§

impl<F, Fut, S, Res, M, T1, T2, T3> Handler<(M, T1, T2, T3), S> for F
where\n F: FnOnce(T1, T2, T3) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequestParts<S> + Send,\n T2: FromRequestParts<S> + Send,\n T3: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1, T2, T3), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1, T2, T3), S>","common_function::scalars::primary_key::NameValuePair"],["
§

impl<F, Fut, S, Res, M, T1, T2, T3, T4> Handler<(M, T1, T2, T3, T4), S> for F
where\n F: FnOnce(T1, T2, T3, T4) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequestParts<S> + Send,\n T2: FromRequestParts<S> + Send,\n T3: FromRequestParts<S> + Send,\n T4: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1, T2, T3, T4), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1, T2, T3, T4), S>","common_function::scalars::primary_key::NameValuePair"],["
§

impl<F, Fut, S, Res, M, T1, T2, T3, T4, T5> Handler<(M, T1, T2, T3, T4, T5), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequestParts<S> + Send,\n T2: FromRequestParts<S> + Send,\n T3: FromRequestParts<S> + Send,\n T4: FromRequestParts<S> + Send,\n T5: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1, T2, T3, T4, T5), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1, T2, T3, T4, T5), S>","common_function::scalars::primary_key::NameValuePair"],["
§

impl<F, Fut, S, Res, M, T1, T2, T3, T4, T5, T6> Handler<(M, T1, T2, T3, T4, T5, T6), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5, T6) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequestParts<S> + Send,\n T2: FromRequestParts<S> + Send,\n T3: FromRequestParts<S> + Send,\n T4: FromRequestParts<S> + Send,\n T5: FromRequestParts<S> + Send,\n T6: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1, T2, T3, T4, T5, T6), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1, T2, T3, T4, T5, T6), S>","common_function::scalars::primary_key::NameValuePair"],["
§

impl<F, Fut, S, Res, M, T1, T2, T3, T4, T5, T6, T7> Handler<(M, T1, T2, T3, T4, T5, T6, T7), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5, T6, T7) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequestParts<S> + Send,\n T2: FromRequestParts<S> + Send,\n T3: FromRequestParts<S> + Send,\n T4: FromRequestParts<S> + Send,\n T5: FromRequestParts<S> + Send,\n T6: FromRequestParts<S> + Send,\n T7: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1, T2, T3, T4, T5, T6, T7), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1, T2, T3, T4, T5, T6, T7), S>","common_function::scalars::primary_key::NameValuePair"],["
§

impl<F, Fut, S, Res, M, T1, T2, T3, T4, T5, T6, T7, T8> Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5, T6, T7, T8) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequestParts<S> + Send,\n T2: FromRequestParts<S> + Send,\n T3: FromRequestParts<S> + Send,\n T4: FromRequestParts<S> + Send,\n T5: FromRequestParts<S> + Send,\n T6: FromRequestParts<S> + Send,\n T7: FromRequestParts<S> + Send,\n T8: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8), S>","common_function::scalars::primary_key::NameValuePair"],["
§

impl<F, Fut, S, Res, M, T1, T2, T3, T4, T5, T6, T7, T8, T9> Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5, T6, T7, T8, T9) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequestParts<S> + Send,\n T2: FromRequestParts<S> + Send,\n T3: FromRequestParts<S> + Send,\n T4: FromRequestParts<S> + Send,\n T5: FromRequestParts<S> + Send,\n T6: FromRequestParts<S> + Send,\n T7: FromRequestParts<S> + Send,\n T8: FromRequestParts<S> + Send,\n T9: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9), S>","common_function::scalars::primary_key::NameValuePair"],["
§

impl<F, Fut, S, Res, M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequestParts<S> + Send,\n T2: FromRequestParts<S> + Send,\n T3: FromRequestParts<S> + Send,\n T4: FromRequestParts<S> + Send,\n T5: FromRequestParts<S> + Send,\n T6: FromRequestParts<S> + Send,\n T7: FromRequestParts<S> + Send,\n T8: FromRequestParts<S> + Send,\n T9: FromRequestParts<S> + Send,\n T10: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10), S>","common_function::scalars::primary_key::NameValuePair"],["
§

impl<F, Fut, S, Res, M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequestParts<S> + Send,\n T2: FromRequestParts<S> + Send,\n T3: FromRequestParts<S> + Send,\n T4: FromRequestParts<S> + Send,\n T5: FromRequestParts<S> + Send,\n T6: FromRequestParts<S> + Send,\n T7: FromRequestParts<S> + Send,\n T8: FromRequestParts<S> + Send,\n T9: FromRequestParts<S> + Send,\n T10: FromRequestParts<S> + Send,\n T11: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11), S>","common_function::scalars::primary_key::NameValuePair"],["
§

impl<F, Fut, S, Res, M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequestParts<S> + Send,\n T2: FromRequestParts<S> + Send,\n T3: FromRequestParts<S> + Send,\n T4: FromRequestParts<S> + Send,\n T5: FromRequestParts<S> + Send,\n T6: FromRequestParts<S> + Send,\n T7: FromRequestParts<S> + Send,\n T8: FromRequestParts<S> + Send,\n T9: FromRequestParts<S> + Send,\n T10: FromRequestParts<S> + Send,\n T11: FromRequestParts<S> + Send,\n T12: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12), S>","common_function::scalars::primary_key::NameValuePair"],["
§

impl<F, Fut, S, Res, M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequestParts<S> + Send,\n T2: FromRequestParts<S> + Send,\n T3: FromRequestParts<S> + Send,\n T4: FromRequestParts<S> + Send,\n T5: FromRequestParts<S> + Send,\n T6: FromRequestParts<S> + Send,\n T7: FromRequestParts<S> + Send,\n T8: FromRequestParts<S> + Send,\n T9: FromRequestParts<S> + Send,\n T10: FromRequestParts<S> + Send,\n T11: FromRequestParts<S> + Send,\n T12: FromRequestParts<S> + Send,\n T13: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13), S>","common_function::scalars::primary_key::NameValuePair"],["
§

impl<F, Fut, S, Res, M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequestParts<S> + Send,\n T2: FromRequestParts<S> + Send,\n T3: FromRequestParts<S> + Send,\n T4: FromRequestParts<S> + Send,\n T5: FromRequestParts<S> + Send,\n T6: FromRequestParts<S> + Send,\n T7: FromRequestParts<S> + Send,\n T8: FromRequestParts<S> + Send,\n T9: FromRequestParts<S> + Send,\n T10: FromRequestParts<S> + Send,\n T11: FromRequestParts<S> + Send,\n T12: FromRequestParts<S> + Send,\n T13: FromRequestParts<S> + Send,\n T14: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14), S>","common_function::scalars::primary_key::NameValuePair"],["
§

impl<F, Fut, S, Res, M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequestParts<S> + Send,\n T2: FromRequestParts<S> + Send,\n T3: FromRequestParts<S> + Send,\n T4: FromRequestParts<S> + Send,\n T5: FromRequestParts<S> + Send,\n T6: FromRequestParts<S> + Send,\n T7: FromRequestParts<S> + Send,\n T8: FromRequestParts<S> + Send,\n T9: FromRequestParts<S> + Send,\n T10: FromRequestParts<S> + Send,\n T11: FromRequestParts<S> + Send,\n T12: FromRequestParts<S> + Send,\n T13: FromRequestParts<S> + Send,\n T14: FromRequestParts<S> + Send,\n T15: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15), S>","common_function::scalars::primary_key::NameValuePair"],["
§

impl<F, Fut, S, Res, M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16> Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequestParts<S> + Send,\n T2: FromRequestParts<S> + Send,\n T3: FromRequestParts<S> + Send,\n T4: FromRequestParts<S> + Send,\n T5: FromRequestParts<S> + Send,\n T6: FromRequestParts<S> + Send,\n T7: FromRequestParts<S> + Send,\n T8: FromRequestParts<S> + Send,\n T9: FromRequestParts<S> + Send,\n T10: FromRequestParts<S> + Send,\n T11: FromRequestParts<S> + Send,\n T12: FromRequestParts<S> + Send,\n T13: FromRequestParts<S> + Send,\n T14: FromRequestParts<S> + Send,\n T15: FromRequestParts<S> + Send,\n T16: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16), S>","common_function::scalars::primary_key::NameValuePair"],["
§

impl<A, B> IntoParallelIterator for (A, B)
where\n A: IntoParallelIterator,\n <A as IntoParallelIterator>::Iter: IndexedParallelIterator,\n B: IntoParallelIterator,\n <B as IntoParallelIterator>::Iter: IndexedParallelIterator,

§

type Item = (<A as IntoParallelIterator>::Item, <B as IntoParallelIterator>::Item)

The type of item that the parallel iterator will produce.
§

type Iter = MultiZip<(<A as IntoParallelIterator>::Iter, <B as IntoParallelIterator>::Iter)>

The parallel iterator type that will be created.
§

fn into_par_iter(self) -> <(A, B) as IntoParallelIterator>::Iter

Converts self into a parallel iterator. Read more
","IntoParallelIterator","common_function::scalars::primary_key::NameValuePair"],["
§

impl<R, T1> IntoResponse for (T1, R)
where\n T1: IntoResponseParts,\n R: IntoResponse,

§

fn into_response(self) -> Response<Body>

Create a response.
","IntoResponse","common_function::scalars::primary_key::NameValuePair"],["
§

impl<T1, T2> IntoResponseParts for (T1, T2)
where\n T1: IntoResponseParts,\n T2: IntoResponseParts,

§

type Error = Response<Body>

The type returned in the event of an error. Read more
§

fn into_response_parts(\n self,\n res: ResponseParts,\n) -> Result<ResponseParts, <(T1, T2) as IntoResponseParts>::Error>

Set parts of the response
","IntoResponseParts","common_function::scalars::primary_key::NameValuePair"],["
Source§

impl<Ix, E> IntoWeightedEdge<E> for (Ix, Ix)
where\n E: Default,

","IntoWeightedEdge","common_function::scalars::primary_key::NameValuePair"],["
Source§

impl<Ix, E> IntoWeightedEdge<E> for (Ix, Ix)
where\n E: Default,

","IntoWeightedEdge","common_function::scalars::primary_key::NameValuePair"],["
§

impl<S, L1, L2> Layer<S> for (L1, L2)
where\n L1: Layer<<L2 as Layer<S>>::Service>,\n L2: Layer<S>,

§

type Service = <L1 as Layer<<L2 as Layer<S>>::Service>>::Service

The wrapped service
§

fn layer(&self, service: S) -> <(L1, L2) as Layer<S>>::Service

Wrap the given service with the middleware, returning a new service\nthat has been decorated with the middleware.
","Layer","common_function::scalars::primary_key::NameValuePair"],["
Source§

impl<IT, A, FromA> MultiUnzip<(FromA,)> for IT
where\n IT: Iterator<Item = (A,)>,\n FromA: Default + Extend<A>,

Source§

fn multiunzip(self) -> (FromA,)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA,)>","common_function::scalars::primary_key::NameValuePair"],["
§

impl<IT, A, FromA> MultiUnzip<(FromA,)> for IT
where\n IT: Iterator<Item = (A,)>,\n FromA: Default + Extend<A>,

§

fn multiunzip(self) -> (FromA,)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA,)>","common_function::scalars::primary_key::NameValuePair"],["
Source§

impl<IT, A, FromA, B, FromB> MultiUnzip<(FromA, FromB)> for IT
where\n IT: Iterator<Item = (A, B)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,

Source§

fn multiunzip(self) -> (FromA, FromB)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB)>","common_function::scalars::primary_key::NameValuePair"],["
§

impl<IT, A, FromA, B, FromB> MultiUnzip<(FromA, FromB)> for IT
where\n IT: Iterator<Item = (A, B)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,

§

fn multiunzip(self) -> (FromA, FromB)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB)>","common_function::scalars::primary_key::NameValuePair"],["
Source§

impl<IT, A, FromA, B, FromB, C, FromC> MultiUnzip<(FromA, FromB, FromC)> for IT
where\n IT: Iterator<Item = (A, B, C)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,

Source§

fn multiunzip(self) -> (FromA, FromB, FromC)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC)>","common_function::scalars::primary_key::NameValuePair"],["
§

impl<IT, A, FromA, B, FromB, C, FromC> MultiUnzip<(FromA, FromB, FromC)> for IT
where\n IT: Iterator<Item = (A, B, C)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,

§

fn multiunzip(self) -> (FromA, FromB, FromC)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC)>","common_function::scalars::primary_key::NameValuePair"],["
Source§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD> MultiUnzip<(FromA, FromB, FromC, FromD)> for IT
where\n IT: Iterator<Item = (A, B, C, D)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,

Source§

fn multiunzip(self) -> (FromA, FromB, FromC, FromD)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD)>","common_function::scalars::primary_key::NameValuePair"],["
§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD> MultiUnzip<(FromA, FromB, FromC, FromD)> for IT
where\n IT: Iterator<Item = (A, B, C, D)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,

§

fn multiunzip(self) -> (FromA, FromB, FromC, FromD)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD)>","common_function::scalars::primary_key::NameValuePair"],["
Source§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE> MultiUnzip<(FromA, FromB, FromC, FromD, FromE)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,

Source§

fn multiunzip(self) -> (FromA, FromB, FromC, FromD, FromE)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE)>","common_function::scalars::primary_key::NameValuePair"],["
§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE> MultiUnzip<(FromA, FromB, FromC, FromD, FromE)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,

§

fn multiunzip(self) -> (FromA, FromB, FromC, FromD, FromE)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE)>","common_function::scalars::primary_key::NameValuePair"],["
Source§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E, F)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,\n FromF: Default + Extend<F>,

Source§

fn multiunzip(self) -> (FromA, FromB, FromC, FromD, FromE, FromF)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF)>","common_function::scalars::primary_key::NameValuePair"],["
§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E, F)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,\n FromF: Default + Extend<F>,

§

fn multiunzip(self) -> (FromA, FromB, FromC, FromD, FromE, FromF)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF)>","common_function::scalars::primary_key::NameValuePair"],["
Source§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E, F, G)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,\n FromF: Default + Extend<F>,\n FromG: Default + Extend<G>,

Source§

fn multiunzip(self) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG)>","common_function::scalars::primary_key::NameValuePair"],["
§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E, F, G)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,\n FromF: Default + Extend<F>,\n FromG: Default + Extend<G>,

§

fn multiunzip(self) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG)>","common_function::scalars::primary_key::NameValuePair"],["
Source§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E, F, G, H)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,\n FromF: Default + Extend<F>,\n FromG: Default + Extend<G>,\n FromH: Default + Extend<H>,

Source§

fn multiunzip(self) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH)>","common_function::scalars::primary_key::NameValuePair"],["
§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E, F, G, H)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,\n FromF: Default + Extend<F>,\n FromG: Default + Extend<G>,\n FromH: Default + Extend<H>,

§

fn multiunzip(self) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH)>","common_function::scalars::primary_key::NameValuePair"],["
Source§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E, F, G, H, I)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,\n FromF: Default + Extend<F>,\n FromG: Default + Extend<G>,\n FromH: Default + Extend<H>,\n FromI: Default + Extend<I>,

Source§

fn multiunzip(\n self,\n) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI)>","common_function::scalars::primary_key::NameValuePair"],["
§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E, F, G, H, I)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,\n FromF: Default + Extend<F>,\n FromG: Default + Extend<G>,\n FromH: Default + Extend<H>,\n FromI: Default + Extend<I>,

§

fn multiunzip(\n self,\n) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI)>","common_function::scalars::primary_key::NameValuePair"],["
Source§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,\n FromF: Default + Extend<F>,\n FromG: Default + Extend<G>,\n FromH: Default + Extend<H>,\n FromI: Default + Extend<I>,\n FromJ: Default + Extend<J>,

Source§

fn multiunzip(\n self,\n) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ)>","common_function::scalars::primary_key::NameValuePair"],["
§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,\n FromF: Default + Extend<F>,\n FromG: Default + Extend<G>,\n FromH: Default + Extend<H>,\n FromI: Default + Extend<I>,\n FromJ: Default + Extend<J>,

§

fn multiunzip(\n self,\n) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ)>","common_function::scalars::primary_key::NameValuePair"],["
Source§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ, K, FromK> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J, K)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,\n FromF: Default + Extend<F>,\n FromG: Default + Extend<G>,\n FromH: Default + Extend<H>,\n FromI: Default + Extend<I>,\n FromJ: Default + Extend<J>,\n FromK: Default + Extend<K>,

Source§

fn multiunzip(\n self,\n) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK)>","common_function::scalars::primary_key::NameValuePair"],["
§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ, K, FromK> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J, K)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,\n FromF: Default + Extend<F>,\n FromG: Default + Extend<G>,\n FromH: Default + Extend<H>,\n FromI: Default + Extend<I>,\n FromJ: Default + Extend<J>,\n FromK: Default + Extend<K>,

§

fn multiunzip(\n self,\n) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK)>","common_function::scalars::primary_key::NameValuePair"],["
Source§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ, K, FromK, L, FromL> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK, FromL)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J, K, L)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,\n FromF: Default + Extend<F>,\n FromG: Default + Extend<G>,\n FromH: Default + Extend<H>,\n FromI: Default + Extend<I>,\n FromJ: Default + Extend<J>,\n FromK: Default + Extend<K>,\n FromL: Default + Extend<L>,

","MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK, FromL)>","common_function::scalars::primary_key::NameValuePair"],["
§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ, K, FromK, L, FromL> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK, FromL)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J, K, L)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,\n FromF: Default + Extend<F>,\n FromG: Default + Extend<G>,\n FromH: Default + Extend<H>,\n FromI: Default + Extend<I>,\n FromJ: Default + Extend<J>,\n FromK: Default + Extend<K>,\n FromL: Default + Extend<L>,

§

fn multiunzip(\n self,\n) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK, FromL)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK, FromL)>","common_function::scalars::primary_key::NameValuePair"],["
§

impl<A, B, FromA, FromB> ParallelExtend<(A, B)> for (FromA, FromB)
where\n A: Send,\n B: Send,\n FromA: Send + ParallelExtend<A>,\n FromB: Send + ParallelExtend<B>,

§

fn par_extend<I>(&mut self, pi: I)
where\n I: IntoParallelIterator<Item = (A, B)>,

Extends an instance of the collection with the elements drawn\nfrom the parallel iterator par_iter. Read more
","ParallelExtend<(A, B)>","common_function::scalars::primary_key::NameValuePair"],["
§

impl<L, R, A, B> ParallelExtend<Either<L, R>> for (A, B)
where\n L: Send,\n R: Send,\n A: Send + ParallelExtend<L>,\n B: Send + ParallelExtend<R>,

§

fn par_extend<I>(&mut self, pi: I)
where\n I: IntoParallelIterator<Item = Either<L, R>>,

Extends an instance of the collection with the elements drawn\nfrom the parallel iterator par_iter. Read more
","ParallelExtend>","common_function::scalars::primary_key::NameValuePair"],["
§

impl<I, O1, O2, E, P1, P2> Parser<I> for (P1, P2)
where\n E: ParseError<I>,\n P1: Parser<I, Output = O1, Error = E>,\n P2: Parser<I, Output = O2, Error = E>,

§

type Output = (O1, O2)

Type of the produced value
§

type Error = E

Error type of this parser
§

fn process<OM>(\n &mut self,\n i: I,\n) -> Result<(I, <<OM as OutputMode>::Output as Mode>::Output<<(P1, P2) as Parser<I>>::Output>), Err<<(P1, P2) as Parser<I>>::Error, <<OM as OutputMode>::Error as Mode>::Output<<(P1, P2) as Parser<I>>::Error>>>
where\n OM: OutputMode,

A parser takes in input type, and returns a Result containing\neither the remaining input and the output value, or an error
§

fn parse(\n &mut self,\n input: Input,\n) -> Result<(Input, Self::Output), Err<Self::Error>>

A parser takes in input type, and returns a Result containing\neither the remaining input and the output value, or an error
§

fn parse_complete(\n &mut self,\n input: Input,\n) -> Result<(Input, Self::Output), Err<Self::Error>>

A parser takes in input type, and returns a Result containing\neither the remaining input and the output value, or an error
§

fn map<G, O2>(self, g: G) -> Map<Self, G>
where\n G: FnMut(Self::Output) -> O2,\n Self: Sized,

Maps a function over the result of a parser
§

fn map_res<G, O2, E2>(self, g: G) -> MapRes<Self, G>
where\n G: FnMut(Self::Output) -> Result<O2, E2>,\n Self::Error: FromExternalError<Input, E2>,\n Self: Sized,

Applies a function returning a Result over the result of a parser.
§

fn map_opt<G, O2>(self, g: G) -> MapOpt<Self, G>
where\n G: FnMut(Self::Output) -> Option<O2>,\n Self: Sized,

Applies a function returning an Option over the result of a parser.
§

fn flat_map<G, H>(self, g: G) -> FlatMap<Self, G>
where\n G: FnMut(Self::Output) -> H,\n H: Parser<Input, Error = Self::Error>,\n Self: Sized,

Creates a second parser from the output of the first one, then apply over the rest of the input
§

fn and_then<G>(self, g: G) -> AndThen<Self, G>
where\n G: Parser<Self::Output, Error = Self::Error>,\n Self: Sized,

Applies a second parser over the output of the first one
§

fn and<G, O2>(self, g: G) -> And<Self, G>
where\n G: Parser<Input, Output = O2, Error = Self::Error>,\n Self: Sized,

Applies a second parser after the first one, return their results as a tuple
§

fn or<G>(self, g: G) -> Or<Self, G>
where\n G: Parser<Input, Output = Self::Output, Error = Self::Error>,\n Self: Sized,

Applies a second parser over the input if the first one failed
§

fn into<O2, E2>(self) -> Into<Self, O2, E2>
where\n O2: From<Self::Output>,\n E2: From<Self::Error>,\n Self: Sized,

automatically converts the parser’s output and error values to another type, as long as they\nimplement the From trait
","Parser","common_function::scalars::primary_key::NameValuePair"],["
§

impl<I, O0, O1, E, P0, P1> Parser<I, (O0, O1), E> for (P0, P1)
where\n I: Stream,\n E: ParserError<I>,\n P0: Parser<I, O0, E>,\n P1: Parser<I, O1, E>,

§

fn parse_next(&mut self, i: &mut I) -> Result<(O0, O1), E>

Take tokens from the [Stream], turning it into the output Read more
§

fn parse(\n &mut self,\n input: I,\n) -> Result<O, ParseError<I, <E as ParserError<I>>::Inner>>
where\n Self: Sized,\n I: Stream + StreamIsPartial,\n E: ParserError<I>,\n <E as ParserError<I>>::Inner: ParserError<I>,

Parse all of input, generating O from it
§

fn parse_peek(&mut self, input: I) -> Result<(I, O), E>

Take tokens from the [Stream], turning it into the output Read more
§

fn by_ref(&mut self) -> ByRef<'_, Self, I, O, E>
where\n Self: Sized,

Treat &mut Self as a parser Read more
§

fn value<O2>(self, val: O2) -> Value<Self, I, O, O2, E>
where\n Self: Sized,\n O2: Clone,

Produce the provided value Read more
§

fn default_value<O2>(self) -> DefaultValue<Self, I, O, O2, E>
where\n Self: Sized,\n O2: Default,

Produce a type’s default value Read more
§

fn void(self) -> Void<Self, I, O, E>
where\n Self: Sized,

Discards the output of the Parser Read more
§

fn output_into<O2>(self) -> OutputInto<Self, I, O, O2, E>
where\n Self: Sized,\n O: Into<O2>,

Convert the parser’s output to another type using std::convert::From Read more
§

fn take(self) -> Take<Self, I, O, E>
where\n Self: Sized,\n I: Stream,

Produce the consumed input as produced value. Read more
§

fn with_taken(self) -> WithTaken<Self, I, O, E>
where\n Self: Sized,\n I: Stream,

Produce the consumed input with the output Read more
§

fn span(self) -> Span<Self, I, O, E>
where\n Self: Sized,\n I: Stream + Location,

Produce the location of the consumed input as produced value. Read more
§

fn with_span(self) -> WithSpan<Self, I, O, E>
where\n Self: Sized,\n I: Stream + Location,

Produce the location of consumed input with the output Read more
§

fn map<G, O2>(self, map: G) -> Map<Self, G, I, O, O2, E>
where\n G: FnMut(O) -> O2,\n Self: Sized,

Maps a function over the output of a parser Read more
§

fn try_map<G, O2, E2>(self, map: G) -> TryMap<Self, G, I, O, O2, E, E2>
where\n Self: Sized,\n G: FnMut(O) -> Result<O2, E2>,\n I: Stream,\n E: FromExternalError<I, E2> + ParserError<I>,

Applies a function returning a Result over the output of a parser. Read more
§

fn verify_map<G, O2>(self, map: G) -> VerifyMap<Self, G, I, O, O2, E>
where\n Self: Sized,\n G: FnMut(O) -> Option<O2>,\n I: Stream,\n E: ParserError<I>,

Apply both [Parser::verify] and [Parser::map]. Read more
§

fn flat_map<G, H, O2>(self, map: G) -> FlatMap<Self, G, H, I, O, O2, E>
where\n Self: Sized,\n G: FnMut(O) -> H,\n H: Parser<I, O2, E>,

Creates a parser from the output of this one Read more
§

fn and_then<G, O2>(self, inner: G) -> AndThen<Self, G, I, O, O2, E>
where\n Self: Sized,\n G: Parser<O, O2, E>,\n O: StreamIsPartial,\n I: Stream,

Applies a second parser over the output of the first one Read more
§

fn parse_to<O2>(self) -> ParseTo<Self, I, O, O2, E>
where\n Self: Sized,\n I: Stream,\n O: ParseSlice<O2>,\n E: ParserError<I>,

Apply std::str::FromStr to the output of the parser Read more
§

fn verify<G, O2>(self, filter: G) -> Verify<Self, G, I, O, O2, E>
where\n Self: Sized,\n G: FnMut(&O2) -> bool,\n I: Stream,\n O: Borrow<O2>,\n E: ParserError<I>,\n O2: ?Sized,

Returns the output of the child parser if it satisfies a verification function. Read more
§

fn context<C>(self, context: C) -> Context<Self, I, O, E, C>
where\n Self: Sized,\n I: Stream,\n E: AddContext<I, C> + ParserError<I>,\n C: Clone + Debug,

If parsing fails, add context to the error Read more
§

fn context_with<F, C, FI>(\n self,\n context: F,\n) -> ContextWith<Self, I, O, E, F, C, FI>
where\n Self: Sized,\n I: Stream,\n E: AddContext<I, C> + ParserError<I>,\n F: Fn() -> FI + Clone,\n C: Debug,\n FI: Iterator<Item = C>,

If parsing fails, dynamically add context to the error Read more
§

fn map_err<G, E2>(self, map: G) -> MapErr<Self, G, I, O, E, E2>
where\n G: FnMut(E) -> E2,\n Self: Sized,

Maps a function over the error of a parser Read more
§

fn complete_err(self) -> CompleteErr<Self, I, O, E>
where\n Self: Sized,

Transforms [Incomplete][crate::error::ErrMode::Incomplete] into [Backtrack][crate::error::ErrMode::Backtrack] Read more
§

fn err_into<E2>(self) -> ErrInto<Self, I, O, E, E2>
where\n Self: Sized,\n E: Into<E2>,

Convert the parser’s error to another type using std::convert::From
","Parser","common_function::scalars::primary_key::NameValuePair"],["
§

impl<I, O1, O2, Error, P1, P2> Permutation<I, (O1, O2), Error> for (P1, P2)
where\n I: Stream,\n Error: ParserError<I>,\n P1: Parser<I, O1, Error>,\n P2: Parser<I, O2, Error>,

§

fn permutation(&mut self, input: &mut I) -> Result<(O1, O2), Error>

Tries to apply all parsers in the tuple in various orders until all of them succeed
","Permutation","common_function::scalars::primary_key::NameValuePair"],["
§

impl<Input, A, B, Error, FnA, FnB> Permutation<Input, (A, B), Error> for (FnA, FnB)
where\n Input: Clone,\n Error: ParseError<Input>,\n FnA: Parser<Input, A, Error>,\n FnB: Parser<Input, B, Error>,

§

fn permutation(&mut self, input: Input) -> Result<(Input, (A, B)), Err<Error>>

Tries to apply all parsers in the tuple in various orders until all of them succeed
","Permutation","common_function::scalars::primary_key::NameValuePair"],["
§

impl<T1, T2> PgHasArrayType for (T1, T2)

§

fn array_type_info() -> PgTypeInfo

§

fn array_compatible(ty: &PgTypeInfo) -> bool

","PgHasArrayType","common_function::scalars::primary_key::NameValuePair"],["
§

impl<S> Point for (S, S)
where\n S: RTreeNum,

§

const DIMENSIONS: usize = 2usize

The number of dimensions of this point type.
§

type Scalar = S

The number type used by this point type.
§

fn generate(generator: impl FnMut(usize) -> S) -> (S, S)

Creates a new point value with given values for each dimension. Read more
§

fn nth(&self, index: usize) -> <(S, S) as Point>::Scalar

Returns a single coordinate of this point. Read more
§

fn nth_mut(&mut self, index: usize) -> &mut <(S, S) as Point>::Scalar

Mutable variant of nth.
","Point","common_function::scalars::primary_key::NameValuePair"],["
Source§

impl<T0, T1> Serialize for (T0, T1)
where\n T0: Serialize,\n T1: Serialize,

Source§

fn serialize<S>(\n &self,\n serializer: S,\n) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>
where\n S: Serializer,

Serialize this value into the given Serde serializer. Read more
","Serialize","common_function::scalars::primary_key::NameValuePair"],["
Source§

impl<T0, As0, T1, As1> SerializeAs<(T0, T1)> for (As0, As1)
where\n As0: SerializeAs<T0>,\n As1: SerializeAs<T1>,

Source§

fn serialize_as<S>(\n tuple: &(T0, T1),\n serializer: S,\n) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>
where\n S: Serializer,

Serialize this value into the given Serde serializer.
","SerializeAs<(T0, T1)>","common_function::scalars::primary_key::NameValuePair"],["
§

impl<'a, T, C0, C1> TreeNodeContainer<'a, T> for (C0, C1)
where\n T: 'a,\n C0: TreeNodeContainer<'a, T>,\n C1: TreeNodeContainer<'a, T>,

§

fn apply_elements<F>(\n &'a self,\n f: F,\n) -> Result<TreeNodeRecursion, DataFusionError>
where\n F: FnMut(&'a T) -> Result<TreeNodeRecursion, DataFusionError>,

Applies f to all elements of the container.\nThis method is usually called from [TreeNode::apply_children] implementations as\na node is actually a container of the node’s children.
§

fn map_elements<F>(self, f: F) -> Result<Transformed<(C0, C1)>, DataFusionError>
where\n F: FnMut(T) -> Result<Transformed<T>, DataFusionError>,

Maps all elements of the container with f.\nThis method is usually called from [TreeNode::map_children] implementations as\na node is actually a container of the node’s children.
","TreeNodeContainer<'a, T>","common_function::scalars::primary_key::NameValuePair"],["
§

impl<Input, A, B, Error, FnA, FnB> Tuple<Input, (A, B), Error> for (FnA, FnB)
where\n Input: Clone,\n Error: ParseError<Input>,\n FnA: Parser<Input, A, Error>,\n FnB: Parser<Input, B, Error>,

§

fn parse(&mut self, input: Input) -> Result<(Input, (A, B)), Err<Error>>

Parses the input and returns a tuple of results of each parser.
","Tuple","common_function::scalars::primary_key::NameValuePair"],["
§

impl<Input, A, B, Error, FnA, FnB> Tuple<Input, (A, B), Error> for (FnA, FnB)
where\n Input: Clone,\n Error: ParseError<Input>,\n FnA: Parser<Input, Output = A, Error = Error>,\n FnB: Parser<Input, Output = B, Error = Error>,

§

fn parse_tuple(&mut self, input: Input) -> Result<(Input, (A, B)), Err<Error>>

👎Deprecated since 8.0.0: Parser is directly implemented for tuples
Parses the input and returns a tuple of results of each parser.
","Tuple","common_function::scalars::primary_key::NameValuePair"],["
§

impl<T1, T2> Type<Postgres> for (T1, T2)

§

fn type_info() -> PgTypeInfo

Returns the canonical SQL type for this Rust type. Read more
§

fn compatible(ty: &<DB as Database>::TypeInfo) -> bool

Determines if this Rust type is compatible with the given SQL type. Read more
","Type","common_function::scalars::primary_key::NameValuePair"],["
§

impl<T1, T0> Values for (T1, T0)
where\n T1: Values,\n T0: Values,

§

fn encoded_len(&self, mode: Mode) -> usize

Returns the length of the encoded values for the given mode.
§

fn write_encoded<W>(&self, mode: Mode, target: &mut W) -> Result<(), Error>
where\n W: Write,

Encodes the values in the given mode and writes them to target.
§

fn explicit(self, tag: Tag) -> Constructed<Self>
where\n Self: Sized,

Converts the encoder into one with an explicit tag.
§

fn to_captured(&self, mode: Mode) -> Captured

Captures the encoded values in the given mode.
","Values","common_function::scalars::primary_key::NameValuePair"],["
§

impl<'a, T1, T2> Yokeable<'a> for (T1, T2)
where\n T1: 'static + for<'b> Yokeable<'b>,\n T2: 'static + for<'b> Yokeable<'b>,

§

type Output = (<T1 as Yokeable<'a>>::Output, <T2 as Yokeable<'a>>::Output)

This type MUST be Self with the 'static replaced with 'a, i.e. Self<'a>
§

fn transform(&'a self) -> &'a <(T1, T2) as Yokeable<'a>>::Output

This method must cast self between &'a Self<'static> and &'a Self<'a>. Read more
§

fn transform_owned(self) -> <(T1, T2) as Yokeable<'a>>::Output

This method must cast self between Self<'static> and Self<'a>. Read more
§

unsafe fn make(from: <(T1, T2) as Yokeable<'a>>::Output) -> (T1, T2)

This method can be used to cast away Self<'a>’s lifetime. Read more
§

fn transform_mut<F>(&'a mut self, f: F)
where\n F: 'static + for<'b> FnOnce(&'b mut <(T1, T2) as Yokeable<'a>>::Output),

This method must cast self between &'a mut Self<'static> and &'a mut Self<'a>,\nand pass it to f. Read more
","Yokeable<'a>","common_function::scalars::primary_key::NameValuePair"],["
§

impl<'a, A, B, AE, BE, Format> ZeroFrom<'a, Tuple2VarULE<A, B, Format>> for (AE, BE)
where\n A: VarULE + ?Sized,\n B: VarULE + ?Sized,\n AE: ZeroFrom<'a, A>,\n BE: ZeroFrom<'a, B>,\n Format: VarZeroVecFormat,

§

fn zero_from(other: &'a Tuple2VarULE<A, B, Format>) -> (AE, BE)

Clone the other C into a struct that may retain references into C.
","ZeroFrom<'a, Tuple2VarULE>","common_function::scalars::primary_key::NameValuePair"],["
§

impl<'zf, C1, T1, C2, T2> ZeroFrom<'zf, (C1, C2)> for (T1, T2)
where\n T1: ZeroFrom<'zf, C1>,\n T2: ZeroFrom<'zf, C2>,

§

fn zero_from(other: &'zf (C1, C2)) -> (T1, T2)

Clone the other C into a struct that may retain references into C.
","ZeroFrom<'zf, (C1, C2)>","common_function::scalars::primary_key::NameValuePair"],["
§

impl<'a, A, B> ZeroMapKV<'a> for (A, B)
where\n A: Ord + AsULE + 'static,\n B: Ord + AsULE + 'static,

§

type Container = ZeroVec<'a, (A, B)>

The container that can be used with this type: [ZeroVec] or [VarZeroVec].
§

type Slice = ZeroSlice<(A, B)>

§

type GetType = Tuple2ULE<<A as AsULE>::ULE, <B as AsULE>::ULE>

The type produced by Container::get() Read more
§

type OwnedType = (A, B)

The type produced by Container::replace() and Container::remove(),\nalso used during deserialization. If Self is human readable serialized,\ndeserializing to Self::OwnedType should produce the same value once\npassed through Self::owned_as_self() Read more
","ZeroMapKV<'a>","common_function::scalars::primary_key::NameValuePair"],["
§

impl<A, B> Zeroable for (A, B)
where\n A: Zeroable,\n B: Zeroable,

§

fn zeroed() -> Self

","Zeroable","common_function::scalars::primary_key::NameValuePair"],["
§

impl<A, B> Zeroize for (A, B)
where\n A: Zeroize,\n B: Zeroize,

§

fn zeroize(&mut self)

Zero out this object from memory using Rust intrinsics which ensure the\nzeroization operation is not “optimized away” by the compiler.
","Zeroize","common_function::scalars::primary_key::NameValuePair"],["
§

impl<A, B> ZeroizeOnDrop for (A, B)
where\n A: ZeroizeOnDrop,\n B: ZeroizeOnDrop,

","ZeroizeOnDrop","common_function::scalars::primary_key::NameValuePair"]]],["common_meta",[["
§

impl<I, Output, Error, Alt2, Alt3> Alt<I, Output, Error> for (Alt2, Alt3)
where\n I: Stream,\n Error: ParserError<I>,\n Alt2: Parser<I, Output, Error>,\n Alt3: Parser<I, Output, Error>,

§

fn choice(&mut self, input: &mut I) -> Result<Output, Error>

Tests each parser in the tuple and returns the result of the first one that succeeds
","Alt","common_meta::ddl::DetectingRegion","common_meta::heartbeat::mailbox::IncomingMessage","common_meta::heartbeat::mailbox::OutgoingMessage"],["
§

impl<Input, Output, Error, A, B> Alt<Input, Output, Error> for (A, B)
where\n Input: Clone,\n Error: ParseError<Input>,\n A: Parser<Input, Output, Error>,\n B: Parser<Input, Output, Error>,

§

fn choice(&mut self, input: Input) -> Result<(Input, Output), Err<Error>>

Tests each parser in the tuple and returns the result of the first one that succeeds
","Alt","common_meta::ddl::DetectingRegion","common_meta::heartbeat::mailbox::IncomingMessage","common_meta::heartbeat::mailbox::OutgoingMessage"],["
§

impl<A, B> AsULE for (A, B)
where\n A: AsULE,\n B: AsULE,

§

type ULE = Tuple2ULE<<A as AsULE>::ULE, <B as AsULE>::ULE>

The ULE type corresponding to Self. Read more
§

fn to_unaligned(self) -> <(A, B) as AsULE>::ULE

Converts from Self to Self::ULE. Read more
§

fn from_unaligned(unaligned: <(A, B) as AsULE>::ULE) -> (A, B)

Converts from Self::ULE to Self. Read more
","AsULE","common_meta::ddl::DetectingRegion","common_meta::heartbeat::mailbox::IncomingMessage","common_meta::heartbeat::mailbox::OutgoingMessage"],["
Source§

impl<S, T> Bounded for (S, T)
where\n S: Bounded,\n T: Bounded,

Source§

fn min_value() -> (S, T)

Returns the smallest finite number this type can represent
Source§

fn max_value() -> (S, T)

Returns the largest finite number this type can represent
","Bounded","common_meta::ddl::DetectingRegion","common_meta::heartbeat::mailbox::IncomingMessage","common_meta::heartbeat::mailbox::OutgoingMessage"],["
§

impl<T, F1, F2> ContainsToken<T> for (F1, F2)
where\n T: Clone,\n F1: ContainsToken<T>,\n F2: ContainsToken<T>,

§

fn contains_token(&self, token: T) -> bool

Returns true if self contains the token
","ContainsToken","common_meta::ddl::DetectingRegion","common_meta::heartbeat::mailbox::IncomingMessage","common_meta::heartbeat::mailbox::OutgoingMessage"],["
§

impl<'r, T1, T2> Decode<'r, Postgres> for (T1, T2)
where\n T1: 'r + Type<Postgres> + for<'a> Decode<'a, Postgres>,\n T2: 'r + Type<Postgres> + for<'a> Decode<'a, Postgres>,

§

fn decode(\n value: PgValueRef<'r>,\n) -> Result<(T1, T2), Box<dyn Error + Sync + Send>>

Decode a new value of this type using a raw value from the database.
","Decode<'r, Postgres>","common_meta::ddl::DetectingRegion","common_meta::heartbeat::mailbox::IncomingMessage","common_meta::heartbeat::mailbox::OutgoingMessage"],["
Source§

impl<'de, T0, T1> Deserialize<'de> for (T0, T1)
where\n T0: Deserialize<'de>,\n T1: Deserialize<'de>,

Source§

fn deserialize<D>(\n deserializer: D,\n) -> Result<(T0, T1), <D as Deserializer<'de>>::Error>
where\n D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer. Read more
","Deserialize<'de>","common_meta::ddl::DetectingRegion","common_meta::heartbeat::mailbox::IncomingMessage","common_meta::heartbeat::mailbox::OutgoingMessage"],["
Source§

impl<'de, T0, As0, T1, As1> DeserializeAs<'de, (T0, T1)> for (As0, As1)
where\n As0: DeserializeAs<'de, T0>,\n As1: DeserializeAs<'de, T1>,

Source§

fn deserialize_as<D>(\n deserializer: D,\n) -> Result<(T0, T1), <D as Deserializer<'de>>::Error>
where\n D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.
","DeserializeAs<'de, (T0, T1)>","common_meta::ddl::DetectingRegion","common_meta::heartbeat::mailbox::IncomingMessage","common_meta::heartbeat::mailbox::OutgoingMessage"],["
§

impl<A, B, AE, BE, Format> EncodeAsVarULE<Tuple2VarULE<A, B, Format>> for (AE, BE)
where\n A: VarULE + ?Sized,\n B: VarULE + ?Sized,\n AE: EncodeAsVarULE<A>,\n BE: EncodeAsVarULE<B>,\n Format: VarZeroVecFormat,

§

fn encode_var_ule_as_slices<R>(&self, _: impl FnOnce(&[&[u8]]) -> R) -> R

Calls cb with a piecewise list of byte slices that when concatenated\nproduce the memory pattern of the corresponding instance of T. Read more
§

fn encode_var_ule_len(&self) -> usize

Return the length, in bytes, of the corresponding [VarULE] type
§

fn encode_var_ule_write(&self, dst: &mut [u8])

Write the corresponding [VarULE] type to the dst buffer. dst should\nbe the size of [Self::encode_var_ule_len()]
","EncodeAsVarULE>","common_meta::ddl::DetectingRegion","common_meta::heartbeat::mailbox::IncomingMessage","common_meta::heartbeat::mailbox::OutgoingMessage"],["
Source§

impl<T> From<Ratio<T>> for (T, T)

Source§

fn from(val: Ratio<T>) -> (T, T)

Converts to this type from the input type.
","From>","common_meta::ddl::DetectingRegion","common_meta::heartbeat::mailbox::IncomingMessage","common_meta::heartbeat::mailbox::OutgoingMessage"],["
§

impl<S, T1, T2> FromRequest<S> for (T1, T2)
where\n T1: FromRequestParts<S> + Send,\n T2: FromRequest<S> + Send,\n S: Send + Sync,

§

type Rejection = Response<Body>

If the extractor fails it’ll use this “rejection” type. A rejection is\na kind of error that can be converted into a response.
§

fn from_request(\n req: Request<Body>,\n state: &S,\n) -> impl Future<Output = Result<(T1, T2), <(T1, T2) as FromRequest<S>>::Rejection>>

Perform the extraction.
","FromRequest","common_meta::ddl::DetectingRegion","common_meta::heartbeat::mailbox::IncomingMessage","common_meta::heartbeat::mailbox::OutgoingMessage"],["
§

impl<S, T1, T2> FromRequestParts<S> for (T1, T2)
where\n T1: FromRequestParts<S> + Send,\n T2: FromRequestParts<S> + Send,\n S: Send + Sync,

§

type Rejection = Response<Body>

If the extractor fails it’ll use this “rejection” type. A rejection is\na kind of error that can be converted into a response.
§

async fn from_request_parts(\n parts: &mut Parts,\n state: &S,\n) -> Result<(T1, T2), <(T1, T2) as FromRequestParts<S>>::Rejection>

Perform the extraction.
","FromRequestParts","common_meta::ddl::DetectingRegion","common_meta::heartbeat::mailbox::IncomingMessage","common_meta::heartbeat::mailbox::OutgoingMessage"],["
§

impl<'r, R, T1, T2> FromRow<'r, R> for (T1, T2)
where\n R: Row,\n usize: ColumnIndex<R>,\n T1: Decode<'r, <R as Row>::Database> + Type<<R as Row>::Database>,\n T2: Decode<'r, <R as Row>::Database> + Type<<R as Row>::Database>,

§

fn from_row(row: &'r R) -> Result<(T1, T2), Error>

","FromRow<'r, R>","common_meta::ddl::DetectingRegion","common_meta::heartbeat::mailbox::IncomingMessage","common_meta::heartbeat::mailbox::OutgoingMessage"],["
§

impl<F, Fut, Res, S> Handler<((),), S> for F
where\n F: FnOnce() -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n Res: IntoResponse,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n _req: Request<Body>,\n _state: S,\n) -> <F as Handler<((),), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<((),), S>","common_meta::ddl::DetectingRegion","common_meta::heartbeat::mailbox::IncomingMessage","common_meta::heartbeat::mailbox::OutgoingMessage"],["
§

impl<F, Fut, S, Res, M, T1> Handler<(M, T1), S> for F
where\n F: FnOnce(T1) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1), S>","common_meta::ddl::DetectingRegion","common_meta::heartbeat::mailbox::IncomingMessage","common_meta::heartbeat::mailbox::OutgoingMessage"],["
§

impl<F, Fut, S, Res, M, T1, T2> Handler<(M, T1, T2), S> for F
where\n F: FnOnce(T1, T2) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequestParts<S> + Send,\n T2: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1, T2), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1, T2), S>","common_meta::ddl::DetectingRegion","common_meta::heartbeat::mailbox::IncomingMessage","common_meta::heartbeat::mailbox::OutgoingMessage"],["
§

impl<F, Fut, S, Res, M, T1, T2, T3> Handler<(M, T1, T2, T3), S> for F
where\n F: FnOnce(T1, T2, T3) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequestParts<S> + Send,\n T2: FromRequestParts<S> + Send,\n T3: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1, T2, T3), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1, T2, T3), S>","common_meta::ddl::DetectingRegion","common_meta::heartbeat::mailbox::IncomingMessage","common_meta::heartbeat::mailbox::OutgoingMessage"],["
§

impl<F, Fut, S, Res, M, T1, T2, T3, T4> Handler<(M, T1, T2, T3, T4), S> for F
where\n F: FnOnce(T1, T2, T3, T4) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequestParts<S> + Send,\n T2: FromRequestParts<S> + Send,\n T3: FromRequestParts<S> + Send,\n T4: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1, T2, T3, T4), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1, T2, T3, T4), S>","common_meta::ddl::DetectingRegion","common_meta::heartbeat::mailbox::IncomingMessage","common_meta::heartbeat::mailbox::OutgoingMessage"],["
§

impl<F, Fut, S, Res, M, T1, T2, T3, T4, T5> Handler<(M, T1, T2, T3, T4, T5), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequestParts<S> + Send,\n T2: FromRequestParts<S> + Send,\n T3: FromRequestParts<S> + Send,\n T4: FromRequestParts<S> + Send,\n T5: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1, T2, T3, T4, T5), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1, T2, T3, T4, T5), S>","common_meta::ddl::DetectingRegion","common_meta::heartbeat::mailbox::IncomingMessage","common_meta::heartbeat::mailbox::OutgoingMessage"],["
§

impl<F, Fut, S, Res, M, T1, T2, T3, T4, T5, T6> Handler<(M, T1, T2, T3, T4, T5, T6), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5, T6) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequestParts<S> + Send,\n T2: FromRequestParts<S> + Send,\n T3: FromRequestParts<S> + Send,\n T4: FromRequestParts<S> + Send,\n T5: FromRequestParts<S> + Send,\n T6: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1, T2, T3, T4, T5, T6), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1, T2, T3, T4, T5, T6), S>","common_meta::ddl::DetectingRegion","common_meta::heartbeat::mailbox::IncomingMessage","common_meta::heartbeat::mailbox::OutgoingMessage"],["
§

impl<F, Fut, S, Res, M, T1, T2, T3, T4, T5, T6, T7> Handler<(M, T1, T2, T3, T4, T5, T6, T7), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5, T6, T7) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequestParts<S> + Send,\n T2: FromRequestParts<S> + Send,\n T3: FromRequestParts<S> + Send,\n T4: FromRequestParts<S> + Send,\n T5: FromRequestParts<S> + Send,\n T6: FromRequestParts<S> + Send,\n T7: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1, T2, T3, T4, T5, T6, T7), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1, T2, T3, T4, T5, T6, T7), S>","common_meta::ddl::DetectingRegion","common_meta::heartbeat::mailbox::IncomingMessage","common_meta::heartbeat::mailbox::OutgoingMessage"],["
§

impl<F, Fut, S, Res, M, T1, T2, T3, T4, T5, T6, T7, T8> Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5, T6, T7, T8) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequestParts<S> + Send,\n T2: FromRequestParts<S> + Send,\n T3: FromRequestParts<S> + Send,\n T4: FromRequestParts<S> + Send,\n T5: FromRequestParts<S> + Send,\n T6: FromRequestParts<S> + Send,\n T7: FromRequestParts<S> + Send,\n T8: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8), S>","common_meta::ddl::DetectingRegion","common_meta::heartbeat::mailbox::IncomingMessage","common_meta::heartbeat::mailbox::OutgoingMessage"],["
§

impl<F, Fut, S, Res, M, T1, T2, T3, T4, T5, T6, T7, T8, T9> Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5, T6, T7, T8, T9) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequestParts<S> + Send,\n T2: FromRequestParts<S> + Send,\n T3: FromRequestParts<S> + Send,\n T4: FromRequestParts<S> + Send,\n T5: FromRequestParts<S> + Send,\n T6: FromRequestParts<S> + Send,\n T7: FromRequestParts<S> + Send,\n T8: FromRequestParts<S> + Send,\n T9: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9), S>","common_meta::ddl::DetectingRegion","common_meta::heartbeat::mailbox::IncomingMessage","common_meta::heartbeat::mailbox::OutgoingMessage"],["
§

impl<F, Fut, S, Res, M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequestParts<S> + Send,\n T2: FromRequestParts<S> + Send,\n T3: FromRequestParts<S> + Send,\n T4: FromRequestParts<S> + Send,\n T5: FromRequestParts<S> + Send,\n T6: FromRequestParts<S> + Send,\n T7: FromRequestParts<S> + Send,\n T8: FromRequestParts<S> + Send,\n T9: FromRequestParts<S> + Send,\n T10: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10), S>","common_meta::ddl::DetectingRegion","common_meta::heartbeat::mailbox::IncomingMessage","common_meta::heartbeat::mailbox::OutgoingMessage"],["
§

impl<F, Fut, S, Res, M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequestParts<S> + Send,\n T2: FromRequestParts<S> + Send,\n T3: FromRequestParts<S> + Send,\n T4: FromRequestParts<S> + Send,\n T5: FromRequestParts<S> + Send,\n T6: FromRequestParts<S> + Send,\n T7: FromRequestParts<S> + Send,\n T8: FromRequestParts<S> + Send,\n T9: FromRequestParts<S> + Send,\n T10: FromRequestParts<S> + Send,\n T11: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11), S>","common_meta::ddl::DetectingRegion","common_meta::heartbeat::mailbox::IncomingMessage","common_meta::heartbeat::mailbox::OutgoingMessage"],["
§

impl<F, Fut, S, Res, M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequestParts<S> + Send,\n T2: FromRequestParts<S> + Send,\n T3: FromRequestParts<S> + Send,\n T4: FromRequestParts<S> + Send,\n T5: FromRequestParts<S> + Send,\n T6: FromRequestParts<S> + Send,\n T7: FromRequestParts<S> + Send,\n T8: FromRequestParts<S> + Send,\n T9: FromRequestParts<S> + Send,\n T10: FromRequestParts<S> + Send,\n T11: FromRequestParts<S> + Send,\n T12: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12), S>","common_meta::ddl::DetectingRegion","common_meta::heartbeat::mailbox::IncomingMessage","common_meta::heartbeat::mailbox::OutgoingMessage"],["
§

impl<F, Fut, S, Res, M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequestParts<S> + Send,\n T2: FromRequestParts<S> + Send,\n T3: FromRequestParts<S> + Send,\n T4: FromRequestParts<S> + Send,\n T5: FromRequestParts<S> + Send,\n T6: FromRequestParts<S> + Send,\n T7: FromRequestParts<S> + Send,\n T8: FromRequestParts<S> + Send,\n T9: FromRequestParts<S> + Send,\n T10: FromRequestParts<S> + Send,\n T11: FromRequestParts<S> + Send,\n T12: FromRequestParts<S> + Send,\n T13: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13), S>","common_meta::ddl::DetectingRegion","common_meta::heartbeat::mailbox::IncomingMessage","common_meta::heartbeat::mailbox::OutgoingMessage"],["
§

impl<F, Fut, S, Res, M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequestParts<S> + Send,\n T2: FromRequestParts<S> + Send,\n T3: FromRequestParts<S> + Send,\n T4: FromRequestParts<S> + Send,\n T5: FromRequestParts<S> + Send,\n T6: FromRequestParts<S> + Send,\n T7: FromRequestParts<S> + Send,\n T8: FromRequestParts<S> + Send,\n T9: FromRequestParts<S> + Send,\n T10: FromRequestParts<S> + Send,\n T11: FromRequestParts<S> + Send,\n T12: FromRequestParts<S> + Send,\n T13: FromRequestParts<S> + Send,\n T14: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14), S>","common_meta::ddl::DetectingRegion","common_meta::heartbeat::mailbox::IncomingMessage","common_meta::heartbeat::mailbox::OutgoingMessage"],["
§

impl<F, Fut, S, Res, M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequestParts<S> + Send,\n T2: FromRequestParts<S> + Send,\n T3: FromRequestParts<S> + Send,\n T4: FromRequestParts<S> + Send,\n T5: FromRequestParts<S> + Send,\n T6: FromRequestParts<S> + Send,\n T7: FromRequestParts<S> + Send,\n T8: FromRequestParts<S> + Send,\n T9: FromRequestParts<S> + Send,\n T10: FromRequestParts<S> + Send,\n T11: FromRequestParts<S> + Send,\n T12: FromRequestParts<S> + Send,\n T13: FromRequestParts<S> + Send,\n T14: FromRequestParts<S> + Send,\n T15: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15), S>","common_meta::ddl::DetectingRegion","common_meta::heartbeat::mailbox::IncomingMessage","common_meta::heartbeat::mailbox::OutgoingMessage"],["
§

impl<F, Fut, S, Res, M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16> Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequestParts<S> + Send,\n T2: FromRequestParts<S> + Send,\n T3: FromRequestParts<S> + Send,\n T4: FromRequestParts<S> + Send,\n T5: FromRequestParts<S> + Send,\n T6: FromRequestParts<S> + Send,\n T7: FromRequestParts<S> + Send,\n T8: FromRequestParts<S> + Send,\n T9: FromRequestParts<S> + Send,\n T10: FromRequestParts<S> + Send,\n T11: FromRequestParts<S> + Send,\n T12: FromRequestParts<S> + Send,\n T13: FromRequestParts<S> + Send,\n T14: FromRequestParts<S> + Send,\n T15: FromRequestParts<S> + Send,\n T16: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16), S>","common_meta::ddl::DetectingRegion","common_meta::heartbeat::mailbox::IncomingMessage","common_meta::heartbeat::mailbox::OutgoingMessage"],["
§

impl<R, T1> IntoResponse for (T1, R)
where\n T1: IntoResponseParts,\n R: IntoResponse,

§

fn into_response(self) -> Response<Body>

Create a response.
","IntoResponse","common_meta::ddl::DetectingRegion","common_meta::heartbeat::mailbox::IncomingMessage","common_meta::heartbeat::mailbox::OutgoingMessage"],["
§

impl<T1, T2> IntoResponseParts for (T1, T2)
where\n T1: IntoResponseParts,\n T2: IntoResponseParts,

§

type Error = Response<Body>

The type returned in the event of an error. Read more
§

fn into_response_parts(\n self,\n res: ResponseParts,\n) -> Result<ResponseParts, <(T1, T2) as IntoResponseParts>::Error>

Set parts of the response
","IntoResponseParts","common_meta::ddl::DetectingRegion","common_meta::heartbeat::mailbox::IncomingMessage","common_meta::heartbeat::mailbox::OutgoingMessage"],["
Source§

impl<Ix, E> IntoWeightedEdge<E> for (Ix, Ix)
where\n E: Default,

","IntoWeightedEdge","common_meta::ddl::DetectingRegion","common_meta::heartbeat::mailbox::IncomingMessage","common_meta::heartbeat::mailbox::OutgoingMessage"],["
Source§

impl<Ix, E> IntoWeightedEdge<E> for (Ix, Ix)
where\n E: Default,

","IntoWeightedEdge","common_meta::ddl::DetectingRegion","common_meta::heartbeat::mailbox::IncomingMessage","common_meta::heartbeat::mailbox::OutgoingMessage"],["
§

impl<S, L1, L2> Layer<S> for (L1, L2)
where\n L1: Layer<<L2 as Layer<S>>::Service>,\n L2: Layer<S>,

§

type Service = <L1 as Layer<<L2 as Layer<S>>::Service>>::Service

The wrapped service
§

fn layer(&self, service: S) -> <(L1, L2) as Layer<S>>::Service

Wrap the given service with the middleware, returning a new service\nthat has been decorated with the middleware.
","Layer","common_meta::ddl::DetectingRegion","common_meta::heartbeat::mailbox::IncomingMessage","common_meta::heartbeat::mailbox::OutgoingMessage"],["
§

impl<IT, A, FromA> MultiUnzip<(FromA,)> for IT
where\n IT: Iterator<Item = (A,)>,\n FromA: Default + Extend<A>,

§

fn multiunzip(self) -> (FromA,)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA,)>","common_meta::ddl::DetectingRegion","common_meta::heartbeat::mailbox::IncomingMessage","common_meta::heartbeat::mailbox::OutgoingMessage"],["
§

impl<IT, A, FromA, B, FromB> MultiUnzip<(FromA, FromB)> for IT
where\n IT: Iterator<Item = (A, B)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,

§

fn multiunzip(self) -> (FromA, FromB)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB)>","common_meta::ddl::DetectingRegion","common_meta::heartbeat::mailbox::IncomingMessage","common_meta::heartbeat::mailbox::OutgoingMessage"],["
§

impl<IT, A, FromA, B, FromB, C, FromC> MultiUnzip<(FromA, FromB, FromC)> for IT
where\n IT: Iterator<Item = (A, B, C)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,

§

fn multiunzip(self) -> (FromA, FromB, FromC)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC)>","common_meta::ddl::DetectingRegion","common_meta::heartbeat::mailbox::IncomingMessage","common_meta::heartbeat::mailbox::OutgoingMessage"],["
§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD> MultiUnzip<(FromA, FromB, FromC, FromD)> for IT
where\n IT: Iterator<Item = (A, B, C, D)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,

§

fn multiunzip(self) -> (FromA, FromB, FromC, FromD)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD)>","common_meta::ddl::DetectingRegion","common_meta::heartbeat::mailbox::IncomingMessage","common_meta::heartbeat::mailbox::OutgoingMessage"],["
§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE> MultiUnzip<(FromA, FromB, FromC, FromD, FromE)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,

§

fn multiunzip(self) -> (FromA, FromB, FromC, FromD, FromE)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE)>","common_meta::ddl::DetectingRegion","common_meta::heartbeat::mailbox::IncomingMessage","common_meta::heartbeat::mailbox::OutgoingMessage"],["
§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E, F)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,\n FromF: Default + Extend<F>,

§

fn multiunzip(self) -> (FromA, FromB, FromC, FromD, FromE, FromF)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF)>","common_meta::ddl::DetectingRegion","common_meta::heartbeat::mailbox::IncomingMessage","common_meta::heartbeat::mailbox::OutgoingMessage"],["
§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E, F, G)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,\n FromF: Default + Extend<F>,\n FromG: Default + Extend<G>,

§

fn multiunzip(self) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG)>","common_meta::ddl::DetectingRegion","common_meta::heartbeat::mailbox::IncomingMessage","common_meta::heartbeat::mailbox::OutgoingMessage"],["
§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E, F, G, H)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,\n FromF: Default + Extend<F>,\n FromG: Default + Extend<G>,\n FromH: Default + Extend<H>,

§

fn multiunzip(self) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH)>","common_meta::ddl::DetectingRegion","common_meta::heartbeat::mailbox::IncomingMessage","common_meta::heartbeat::mailbox::OutgoingMessage"],["
§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E, F, G, H, I)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,\n FromF: Default + Extend<F>,\n FromG: Default + Extend<G>,\n FromH: Default + Extend<H>,\n FromI: Default + Extend<I>,

§

fn multiunzip(\n self,\n) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI)>","common_meta::ddl::DetectingRegion","common_meta::heartbeat::mailbox::IncomingMessage","common_meta::heartbeat::mailbox::OutgoingMessage"],["
§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,\n FromF: Default + Extend<F>,\n FromG: Default + Extend<G>,\n FromH: Default + Extend<H>,\n FromI: Default + Extend<I>,\n FromJ: Default + Extend<J>,

§

fn multiunzip(\n self,\n) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ)>","common_meta::ddl::DetectingRegion","common_meta::heartbeat::mailbox::IncomingMessage","common_meta::heartbeat::mailbox::OutgoingMessage"],["
§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ, K, FromK> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J, K)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,\n FromF: Default + Extend<F>,\n FromG: Default + Extend<G>,\n FromH: Default + Extend<H>,\n FromI: Default + Extend<I>,\n FromJ: Default + Extend<J>,\n FromK: Default + Extend<K>,

§

fn multiunzip(\n self,\n) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK)>","common_meta::ddl::DetectingRegion","common_meta::heartbeat::mailbox::IncomingMessage","common_meta::heartbeat::mailbox::OutgoingMessage"],["
§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ, K, FromK, L, FromL> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK, FromL)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J, K, L)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,\n FromF: Default + Extend<F>,\n FromG: Default + Extend<G>,\n FromH: Default + Extend<H>,\n FromI: Default + Extend<I>,\n FromJ: Default + Extend<J>,\n FromK: Default + Extend<K>,\n FromL: Default + Extend<L>,

§

fn multiunzip(\n self,\n) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK, FromL)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK, FromL)>","common_meta::ddl::DetectingRegion","common_meta::heartbeat::mailbox::IncomingMessage","common_meta::heartbeat::mailbox::OutgoingMessage"],["
§

impl<I, O1, O2, E, P1, P2> Parser<I> for (P1, P2)
where\n E: ParseError<I>,\n P1: Parser<I, Output = O1, Error = E>,\n P2: Parser<I, Output = O2, Error = E>,

§

type Output = (O1, O2)

Type of the produced value
§

type Error = E

Error type of this parser
§

fn process<OM>(\n &mut self,\n i: I,\n) -> Result<(I, <<OM as OutputMode>::Output as Mode>::Output<<(P1, P2) as Parser<I>>::Output>), Err<<(P1, P2) as Parser<I>>::Error, <<OM as OutputMode>::Error as Mode>::Output<<(P1, P2) as Parser<I>>::Error>>>
where\n OM: OutputMode,

A parser takes in input type, and returns a Result containing\neither the remaining input and the output value, or an error
§

fn parse(\n &mut self,\n input: Input,\n) -> Result<(Input, Self::Output), Err<Self::Error>>

A parser takes in input type, and returns a Result containing\neither the remaining input and the output value, or an error
§

fn parse_complete(\n &mut self,\n input: Input,\n) -> Result<(Input, Self::Output), Err<Self::Error>>

A parser takes in input type, and returns a Result containing\neither the remaining input and the output value, or an error
§

fn map<G, O2>(self, g: G) -> Map<Self, G>
where\n G: FnMut(Self::Output) -> O2,\n Self: Sized,

Maps a function over the result of a parser
§

fn map_res<G, O2, E2>(self, g: G) -> MapRes<Self, G>
where\n G: FnMut(Self::Output) -> Result<O2, E2>,\n Self::Error: FromExternalError<Input, E2>,\n Self: Sized,

Applies a function returning a Result over the result of a parser.
§

fn map_opt<G, O2>(self, g: G) -> MapOpt<Self, G>
where\n G: FnMut(Self::Output) -> Option<O2>,\n Self: Sized,

Applies a function returning an Option over the result of a parser.
§

fn flat_map<G, H>(self, g: G) -> FlatMap<Self, G>
where\n G: FnMut(Self::Output) -> H,\n H: Parser<Input, Error = Self::Error>,\n Self: Sized,

Creates a second parser from the output of the first one, then apply over the rest of the input
§

fn and_then<G>(self, g: G) -> AndThen<Self, G>
where\n G: Parser<Self::Output, Error = Self::Error>,\n Self: Sized,

Applies a second parser over the output of the first one
§

fn and<G, O2>(self, g: G) -> And<Self, G>
where\n G: Parser<Input, Output = O2, Error = Self::Error>,\n Self: Sized,

Applies a second parser after the first one, return their results as a tuple
§

fn or<G>(self, g: G) -> Or<Self, G>
where\n G: Parser<Input, Output = Self::Output, Error = Self::Error>,\n Self: Sized,

Applies a second parser over the input if the first one failed
§

fn into<O2, E2>(self) -> Into<Self, O2, E2>
where\n O2: From<Self::Output>,\n E2: From<Self::Error>,\n Self: Sized,

automatically converts the parser’s output and error values to another type, as long as they\nimplement the From trait
","Parser","common_meta::ddl::DetectingRegion","common_meta::heartbeat::mailbox::IncomingMessage","common_meta::heartbeat::mailbox::OutgoingMessage"],["
§

impl<I, O0, O1, E, P0, P1> Parser<I, (O0, O1), E> for (P0, P1)
where\n I: Stream,\n E: ParserError<I>,\n P0: Parser<I, O0, E>,\n P1: Parser<I, O1, E>,

§

fn parse_next(&mut self, i: &mut I) -> Result<(O0, O1), E>

Take tokens from the [Stream], turning it into the output Read more
§

fn parse(\n &mut self,\n input: I,\n) -> Result<O, ParseError<I, <E as ParserError<I>>::Inner>>
where\n Self: Sized,\n I: Stream + StreamIsPartial,\n E: ParserError<I>,\n <E as ParserError<I>>::Inner: ParserError<I>,

Parse all of input, generating O from it
§

fn parse_peek(&mut self, input: I) -> Result<(I, O), E>

Take tokens from the [Stream], turning it into the output Read more
§

fn by_ref(&mut self) -> ByRef<'_, Self, I, O, E>
where\n Self: Sized,

Treat &mut Self as a parser Read more
§

fn value<O2>(self, val: O2) -> Value<Self, I, O, O2, E>
where\n Self: Sized,\n O2: Clone,

Produce the provided value Read more
§

fn default_value<O2>(self) -> DefaultValue<Self, I, O, O2, E>
where\n Self: Sized,\n O2: Default,

Produce a type’s default value Read more
§

fn void(self) -> Void<Self, I, O, E>
where\n Self: Sized,

Discards the output of the Parser Read more
§

fn output_into<O2>(self) -> OutputInto<Self, I, O, O2, E>
where\n Self: Sized,\n O: Into<O2>,

Convert the parser’s output to another type using std::convert::From Read more
§

fn take(self) -> Take<Self, I, O, E>
where\n Self: Sized,\n I: Stream,

Produce the consumed input as produced value. Read more
§

fn with_taken(self) -> WithTaken<Self, I, O, E>
where\n Self: Sized,\n I: Stream,

Produce the consumed input with the output Read more
§

fn span(self) -> Span<Self, I, O, E>
where\n Self: Sized,\n I: Stream + Location,

Produce the location of the consumed input as produced value. Read more
§

fn with_span(self) -> WithSpan<Self, I, O, E>
where\n Self: Sized,\n I: Stream + Location,

Produce the location of consumed input with the output Read more
§

fn map<G, O2>(self, map: G) -> Map<Self, G, I, O, O2, E>
where\n G: FnMut(O) -> O2,\n Self: Sized,

Maps a function over the output of a parser Read more
§

fn try_map<G, O2, E2>(self, map: G) -> TryMap<Self, G, I, O, O2, E, E2>
where\n Self: Sized,\n G: FnMut(O) -> Result<O2, E2>,\n I: Stream,\n E: FromExternalError<I, E2> + ParserError<I>,

Applies a function returning a Result over the output of a parser. Read more
§

fn verify_map<G, O2>(self, map: G) -> VerifyMap<Self, G, I, O, O2, E>
where\n Self: Sized,\n G: FnMut(O) -> Option<O2>,\n I: Stream,\n E: ParserError<I>,

Apply both [Parser::verify] and [Parser::map]. Read more
§

fn flat_map<G, H, O2>(self, map: G) -> FlatMap<Self, G, H, I, O, O2, E>
where\n Self: Sized,\n G: FnMut(O) -> H,\n H: Parser<I, O2, E>,

Creates a parser from the output of this one Read more
§

fn and_then<G, O2>(self, inner: G) -> AndThen<Self, G, I, O, O2, E>
where\n Self: Sized,\n G: Parser<O, O2, E>,\n O: StreamIsPartial,\n I: Stream,

Applies a second parser over the output of the first one Read more
§

fn parse_to<O2>(self) -> ParseTo<Self, I, O, O2, E>
where\n Self: Sized,\n I: Stream,\n O: ParseSlice<O2>,\n E: ParserError<I>,

Apply std::str::FromStr to the output of the parser Read more
§

fn verify<G, O2>(self, filter: G) -> Verify<Self, G, I, O, O2, E>
where\n Self: Sized,\n G: FnMut(&O2) -> bool,\n I: Stream,\n O: Borrow<O2>,\n E: ParserError<I>,\n O2: ?Sized,

Returns the output of the child parser if it satisfies a verification function. Read more
§

fn context<C>(self, context: C) -> Context<Self, I, O, E, C>
where\n Self: Sized,\n I: Stream,\n E: AddContext<I, C> + ParserError<I>,\n C: Clone + Debug,

If parsing fails, add context to the error Read more
§

fn context_with<F, C, FI>(\n self,\n context: F,\n) -> ContextWith<Self, I, O, E, F, C, FI>
where\n Self: Sized,\n I: Stream,\n E: AddContext<I, C> + ParserError<I>,\n F: Fn() -> FI + Clone,\n C: Debug,\n FI: Iterator<Item = C>,

If parsing fails, dynamically add context to the error Read more
§

fn map_err<G, E2>(self, map: G) -> MapErr<Self, G, I, O, E, E2>
where\n G: FnMut(E) -> E2,\n Self: Sized,

Maps a function over the error of a parser Read more
§

fn complete_err(self) -> CompleteErr<Self, I, O, E>
where\n Self: Sized,

Transforms [Incomplete][crate::error::ErrMode::Incomplete] into [Backtrack][crate::error::ErrMode::Backtrack] Read more
§

fn err_into<E2>(self) -> ErrInto<Self, I, O, E, E2>
where\n Self: Sized,\n E: Into<E2>,

Convert the parser’s error to another type using std::convert::From
","Parser","common_meta::ddl::DetectingRegion","common_meta::heartbeat::mailbox::IncomingMessage","common_meta::heartbeat::mailbox::OutgoingMessage"],["
§

impl<I, O1, O2, Error, P1, P2> Permutation<I, (O1, O2), Error> for (P1, P2)
where\n I: Stream,\n Error: ParserError<I>,\n P1: Parser<I, O1, Error>,\n P2: Parser<I, O2, Error>,

§

fn permutation(&mut self, input: &mut I) -> Result<(O1, O2), Error>

Tries to apply all parsers in the tuple in various orders until all of them succeed
","Permutation","common_meta::ddl::DetectingRegion","common_meta::heartbeat::mailbox::IncomingMessage","common_meta::heartbeat::mailbox::OutgoingMessage"],["
§

impl<Input, A, B, Error, FnA, FnB> Permutation<Input, (A, B), Error> for (FnA, FnB)
where\n Input: Clone,\n Error: ParseError<Input>,\n FnA: Parser<Input, A, Error>,\n FnB: Parser<Input, B, Error>,

§

fn permutation(&mut self, input: Input) -> Result<(Input, (A, B)), Err<Error>>

Tries to apply all parsers in the tuple in various orders until all of them succeed
","Permutation","common_meta::ddl::DetectingRegion","common_meta::heartbeat::mailbox::IncomingMessage","common_meta::heartbeat::mailbox::OutgoingMessage"],["
§

impl<T1, T2> PgHasArrayType for (T1, T2)

§

fn array_type_info() -> PgTypeInfo

§

fn array_compatible(ty: &PgTypeInfo) -> bool

","PgHasArrayType","common_meta::ddl::DetectingRegion","common_meta::heartbeat::mailbox::IncomingMessage","common_meta::heartbeat::mailbox::OutgoingMessage"],["
Source§

impl<T0, T1> Serialize for (T0, T1)
where\n T0: Serialize,\n T1: Serialize,

Source§

fn serialize<S>(\n &self,\n serializer: S,\n) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>
where\n S: Serializer,

Serialize this value into the given Serde serializer. Read more
","Serialize","common_meta::ddl::DetectingRegion","common_meta::heartbeat::mailbox::IncomingMessage","common_meta::heartbeat::mailbox::OutgoingMessage"],["
Source§

impl<T0, As0, T1, As1> SerializeAs<(T0, T1)> for (As0, As1)
where\n As0: SerializeAs<T0>,\n As1: SerializeAs<T1>,

Source§

fn serialize_as<S>(\n tuple: &(T0, T1),\n serializer: S,\n) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>
where\n S: Serializer,

Serialize this value into the given Serde serializer.
","SerializeAs<(T0, T1)>","common_meta::ddl::DetectingRegion","common_meta::heartbeat::mailbox::IncomingMessage","common_meta::heartbeat::mailbox::OutgoingMessage"],["
§

impl<'a, T, C0, C1> TreeNodeContainer<'a, T> for (C0, C1)
where\n T: 'a,\n C0: TreeNodeContainer<'a, T>,\n C1: TreeNodeContainer<'a, T>,

§

fn apply_elements<F>(\n &'a self,\n f: F,\n) -> Result<TreeNodeRecursion, DataFusionError>
where\n F: FnMut(&'a T) -> Result<TreeNodeRecursion, DataFusionError>,

Applies f to all elements of the container.\nThis method is usually called from [TreeNode::apply_children] implementations as\na node is actually a container of the node’s children.
§

fn map_elements<F>(self, f: F) -> Result<Transformed<(C0, C1)>, DataFusionError>
where\n F: FnMut(T) -> Result<Transformed<T>, DataFusionError>,

Maps all elements of the container with f.\nThis method is usually called from [TreeNode::map_children] implementations as\na node is actually a container of the node’s children.
","TreeNodeContainer<'a, T>","common_meta::ddl::DetectingRegion","common_meta::heartbeat::mailbox::IncomingMessage","common_meta::heartbeat::mailbox::OutgoingMessage"],["
§

impl<Input, A, B, Error, FnA, FnB> Tuple<Input, (A, B), Error> for (FnA, FnB)
where\n Input: Clone,\n Error: ParseError<Input>,\n FnA: Parser<Input, A, Error>,\n FnB: Parser<Input, B, Error>,

§

fn parse(&mut self, input: Input) -> Result<(Input, (A, B)), Err<Error>>

Parses the input and returns a tuple of results of each parser.
","Tuple","common_meta::ddl::DetectingRegion","common_meta::heartbeat::mailbox::IncomingMessage","common_meta::heartbeat::mailbox::OutgoingMessage"],["
§

impl<Input, A, B, Error, FnA, FnB> Tuple<Input, (A, B), Error> for (FnA, FnB)
where\n Input: Clone,\n Error: ParseError<Input>,\n FnA: Parser<Input, Output = A, Error = Error>,\n FnB: Parser<Input, Output = B, Error = Error>,

§

fn parse_tuple(&mut self, input: Input) -> Result<(Input, (A, B)), Err<Error>>

👎Deprecated since 8.0.0: Parser is directly implemented for tuples
Parses the input and returns a tuple of results of each parser.
","Tuple","common_meta::ddl::DetectingRegion","common_meta::heartbeat::mailbox::IncomingMessage","common_meta::heartbeat::mailbox::OutgoingMessage"],["
§

impl<T1, T2> Type<Postgres> for (T1, T2)

§

fn type_info() -> PgTypeInfo

Returns the canonical SQL type for this Rust type. Read more
§

fn compatible(ty: &<DB as Database>::TypeInfo) -> bool

Determines if this Rust type is compatible with the given SQL type. Read more
","Type","common_meta::ddl::DetectingRegion","common_meta::heartbeat::mailbox::IncomingMessage","common_meta::heartbeat::mailbox::OutgoingMessage"],["
§

impl<T1, T0> Values for (T1, T0)
where\n T1: Values,\n T0: Values,

§

fn encoded_len(&self, mode: Mode) -> usize

Returns the length of the encoded values for the given mode.
§

fn write_encoded<W>(&self, mode: Mode, target: &mut W) -> Result<(), Error>
where\n W: Write,

Encodes the values in the given mode and writes them to target.
§

fn explicit(self, tag: Tag) -> Constructed<Self>
where\n Self: Sized,

Converts the encoder into one with an explicit tag.
§

fn to_captured(&self, mode: Mode) -> Captured

Captures the encoded values in the given mode.
","Values","common_meta::ddl::DetectingRegion","common_meta::heartbeat::mailbox::IncomingMessage","common_meta::heartbeat::mailbox::OutgoingMessage"],["
§

impl<'a, T1, T2> Yokeable<'a> for (T1, T2)
where\n T1: 'static + for<'b> Yokeable<'b>,\n T2: 'static + for<'b> Yokeable<'b>,

§

type Output = (<T1 as Yokeable<'a>>::Output, <T2 as Yokeable<'a>>::Output)

This type MUST be Self with the 'static replaced with 'a, i.e. Self<'a>
§

fn transform(&'a self) -> &'a <(T1, T2) as Yokeable<'a>>::Output

This method must cast self between &'a Self<'static> and &'a Self<'a>. Read more
§

fn transform_owned(self) -> <(T1, T2) as Yokeable<'a>>::Output

This method must cast self between Self<'static> and Self<'a>. Read more
§

unsafe fn make(from: <(T1, T2) as Yokeable<'a>>::Output) -> (T1, T2)

This method can be used to cast away Self<'a>’s lifetime. Read more
§

fn transform_mut<F>(&'a mut self, f: F)
where\n F: 'static + for<'b> FnOnce(&'b mut <(T1, T2) as Yokeable<'a>>::Output),

This method must cast self between &'a mut Self<'static> and &'a mut Self<'a>,\nand pass it to f. Read more
","Yokeable<'a>","common_meta::ddl::DetectingRegion","common_meta::heartbeat::mailbox::IncomingMessage","common_meta::heartbeat::mailbox::OutgoingMessage"],["
§

impl<'a, A, B, AE, BE, Format> ZeroFrom<'a, Tuple2VarULE<A, B, Format>> for (AE, BE)
where\n A: VarULE + ?Sized,\n B: VarULE + ?Sized,\n AE: ZeroFrom<'a, A>,\n BE: ZeroFrom<'a, B>,\n Format: VarZeroVecFormat,

§

fn zero_from(other: &'a Tuple2VarULE<A, B, Format>) -> (AE, BE)

Clone the other C into a struct that may retain references into C.
","ZeroFrom<'a, Tuple2VarULE>","common_meta::ddl::DetectingRegion","common_meta::heartbeat::mailbox::IncomingMessage","common_meta::heartbeat::mailbox::OutgoingMessage"],["
§

impl<'zf, C1, T1, C2, T2> ZeroFrom<'zf, (C1, C2)> for (T1, T2)
where\n T1: ZeroFrom<'zf, C1>,\n T2: ZeroFrom<'zf, C2>,

§

fn zero_from(other: &'zf (C1, C2)) -> (T1, T2)

Clone the other C into a struct that may retain references into C.
","ZeroFrom<'zf, (C1, C2)>","common_meta::ddl::DetectingRegion","common_meta::heartbeat::mailbox::IncomingMessage","common_meta::heartbeat::mailbox::OutgoingMessage"],["
§

impl<'a, A, B> ZeroMapKV<'a> for (A, B)
where\n A: Ord + AsULE + 'static,\n B: Ord + AsULE + 'static,

§

type Container = ZeroVec<'a, (A, B)>

The container that can be used with this type: [ZeroVec] or [VarZeroVec].
§

type Slice = ZeroSlice<(A, B)>

§

type GetType = Tuple2ULE<<A as AsULE>::ULE, <B as AsULE>::ULE>

The type produced by Container::get() Read more
§

type OwnedType = (A, B)

The type produced by Container::replace() and Container::remove(),\nalso used during deserialization. If Self is human readable serialized,\ndeserializing to Self::OwnedType should produce the same value once\npassed through Self::owned_as_self() Read more
","ZeroMapKV<'a>","common_meta::ddl::DetectingRegion","common_meta::heartbeat::mailbox::IncomingMessage","common_meta::heartbeat::mailbox::OutgoingMessage"],["
§

impl<A, B> Zeroable for (A, B)
where\n A: Zeroable,\n B: Zeroable,

§

fn zeroed() -> Self

","Zeroable","common_meta::ddl::DetectingRegion","common_meta::heartbeat::mailbox::IncomingMessage","common_meta::heartbeat::mailbox::OutgoingMessage"],["
§

impl<A, B> Zeroize for (A, B)
where\n A: Zeroize,\n B: Zeroize,

§

fn zeroize(&mut self)

Zero out this object from memory using Rust intrinsics which ensure the\nzeroization operation is not “optimized away” by the compiler.
","Zeroize","common_meta::ddl::DetectingRegion","common_meta::heartbeat::mailbox::IncomingMessage","common_meta::heartbeat::mailbox::OutgoingMessage"],["
§

impl<A, B> ZeroizeOnDrop for (A, B)
where\n A: ZeroizeOnDrop,\n B: ZeroizeOnDrop,

","ZeroizeOnDrop","common_meta::ddl::DetectingRegion","common_meta::heartbeat::mailbox::IncomingMessage","common_meta::heartbeat::mailbox::OutgoingMessage"]]],["common_procedure",[["
§

impl<I, Output, Error, Alt2, Alt3> Alt<I, Output, Error> for (Alt2, Alt3)
where\n I: Stream,\n Error: ParserError<I>,\n Alt2: Parser<I, Output, Error>,\n Alt3: Parser<I, Output, Error>,

§

fn choice(&mut self, input: &mut I) -> Result<Output, Error>

Tests each parser in the tuple and returns the result of the first one that succeeds
","Alt","common_procedure::store::state_store::KeyValue"],["
§

impl<Input, Output, Error, A, B> Alt<Input, Output, Error> for (A, B)
where\n Input: Clone,\n Error: ParseError<Input>,\n A: Parser<Input, Output, Error>,\n B: Parser<Input, Output, Error>,

§

fn choice(&mut self, input: Input) -> Result<(Input, Output), Err<Error>>

Tests each parser in the tuple and returns the result of the first one that succeeds
","Alt","common_procedure::store::state_store::KeyValue"],["
§

impl<A, B> AsULE for (A, B)
where\n A: AsULE,\n B: AsULE,

§

type ULE = Tuple2ULE<<A as AsULE>::ULE, <B as AsULE>::ULE>

The ULE type corresponding to Self. Read more
§

fn to_unaligned(self) -> <(A, B) as AsULE>::ULE

Converts from Self to Self::ULE. Read more
§

fn from_unaligned(unaligned: <(A, B) as AsULE>::ULE) -> (A, B)

Converts from Self::ULE to Self. Read more
","AsULE","common_procedure::store::state_store::KeyValue"],["
Source§

impl<S, T> Bounded for (S, T)
where\n S: Bounded,\n T: Bounded,

Source§

fn min_value() -> (S, T)

Returns the smallest finite number this type can represent
Source§

fn max_value() -> (S, T)

Returns the largest finite number this type can represent
","Bounded","common_procedure::store::state_store::KeyValue"],["
§

impl<T, F1, F2> ContainsToken<T> for (F1, F2)
where\n T: Clone,\n F1: ContainsToken<T>,\n F2: ContainsToken<T>,

§

fn contains_token(&self, token: T) -> bool

Returns true if self contains the token
","ContainsToken","common_procedure::store::state_store::KeyValue"],["
Source§

impl<'de, T0, T1> Deserialize<'de> for (T0, T1)
where\n T0: Deserialize<'de>,\n T1: Deserialize<'de>,

Source§

fn deserialize<D>(\n deserializer: D,\n) -> Result<(T0, T1), <D as Deserializer<'de>>::Error>
where\n D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer. Read more
","Deserialize<'de>","common_procedure::store::state_store::KeyValue"],["
Source§

impl<'de, T0, As0, T1, As1> DeserializeAs<'de, (T0, T1)> for (As0, As1)
where\n As0: DeserializeAs<'de, T0>,\n As1: DeserializeAs<'de, T1>,

Source§

fn deserialize_as<D>(\n deserializer: D,\n) -> Result<(T0, T1), <D as Deserializer<'de>>::Error>
where\n D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.
","DeserializeAs<'de, (T0, T1)>","common_procedure::store::state_store::KeyValue"],["
§

impl<A, B, AE, BE, Format> EncodeAsVarULE<Tuple2VarULE<A, B, Format>> for (AE, BE)
where\n A: VarULE + ?Sized,\n B: VarULE + ?Sized,\n AE: EncodeAsVarULE<A>,\n BE: EncodeAsVarULE<B>,\n Format: VarZeroVecFormat,

§

fn encode_var_ule_as_slices<R>(&self, _: impl FnOnce(&[&[u8]]) -> R) -> R

Calls cb with a piecewise list of byte slices that when concatenated\nproduce the memory pattern of the corresponding instance of T. Read more
§

fn encode_var_ule_len(&self) -> usize

Return the length, in bytes, of the corresponding [VarULE] type
§

fn encode_var_ule_write(&self, dst: &mut [u8])

Write the corresponding [VarULE] type to the dst buffer. dst should\nbe the size of [Self::encode_var_ule_len()]
","EncodeAsVarULE>","common_procedure::store::state_store::KeyValue"],["
Source§

impl<T> From<Ratio<T>> for (T, T)

Source§

fn from(val: Ratio<T>) -> (T, T)

Converts to this type from the input type.
","From>","common_procedure::store::state_store::KeyValue"],["
§

impl<S, T1, T2> FromRequest<S> for (T1, T2)
where\n T1: FromRequestParts<S> + Send,\n T2: FromRequest<S> + Send,\n S: Send + Sync,

§

type Rejection = Response<Body>

If the extractor fails it’ll use this “rejection” type. A rejection is\na kind of error that can be converted into a response.
§

fn from_request(\n req: Request<Body>,\n state: &S,\n) -> impl Future<Output = Result<(T1, T2), <(T1, T2) as FromRequest<S>>::Rejection>>

Perform the extraction.
","FromRequest","common_procedure::store::state_store::KeyValue"],["
§

impl<S, T1, T2> FromRequestParts<S> for (T1, T2)
where\n T1: FromRequestParts<S> + Send,\n T2: FromRequestParts<S> + Send,\n S: Send + Sync,

§

type Rejection = Response<Body>

If the extractor fails it’ll use this “rejection” type. A rejection is\na kind of error that can be converted into a response.
§

async fn from_request_parts(\n parts: &mut Parts,\n state: &S,\n) -> Result<(T1, T2), <(T1, T2) as FromRequestParts<S>>::Rejection>

Perform the extraction.
","FromRequestParts","common_procedure::store::state_store::KeyValue"],["
§

impl<F, Fut, Res, S> Handler<((),), S> for F
where\n F: FnOnce() -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n Res: IntoResponse,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n _req: Request<Body>,\n _state: S,\n) -> <F as Handler<((),), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<((),), S>","common_procedure::store::state_store::KeyValue"],["
§

impl<F, Fut, S, Res, M, T1> Handler<(M, T1), S> for F
where\n F: FnOnce(T1) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1), S>","common_procedure::store::state_store::KeyValue"],["
§

impl<F, Fut, S, Res, M, T1, T2> Handler<(M, T1, T2), S> for F
where\n F: FnOnce(T1, T2) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequestParts<S> + Send,\n T2: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1, T2), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1, T2), S>","common_procedure::store::state_store::KeyValue"],["
§

impl<F, Fut, S, Res, M, T1, T2, T3> Handler<(M, T1, T2, T3), S> for F
where\n F: FnOnce(T1, T2, T3) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequestParts<S> + Send,\n T2: FromRequestParts<S> + Send,\n T3: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1, T2, T3), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1, T2, T3), S>","common_procedure::store::state_store::KeyValue"],["
§

impl<F, Fut, S, Res, M, T1, T2, T3, T4> Handler<(M, T1, T2, T3, T4), S> for F
where\n F: FnOnce(T1, T2, T3, T4) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequestParts<S> + Send,\n T2: FromRequestParts<S> + Send,\n T3: FromRequestParts<S> + Send,\n T4: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1, T2, T3, T4), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1, T2, T3, T4), S>","common_procedure::store::state_store::KeyValue"],["
§

impl<F, Fut, S, Res, M, T1, T2, T3, T4, T5> Handler<(M, T1, T2, T3, T4, T5), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequestParts<S> + Send,\n T2: FromRequestParts<S> + Send,\n T3: FromRequestParts<S> + Send,\n T4: FromRequestParts<S> + Send,\n T5: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1, T2, T3, T4, T5), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1, T2, T3, T4, T5), S>","common_procedure::store::state_store::KeyValue"],["
§

impl<F, Fut, S, Res, M, T1, T2, T3, T4, T5, T6> Handler<(M, T1, T2, T3, T4, T5, T6), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5, T6) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequestParts<S> + Send,\n T2: FromRequestParts<S> + Send,\n T3: FromRequestParts<S> + Send,\n T4: FromRequestParts<S> + Send,\n T5: FromRequestParts<S> + Send,\n T6: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1, T2, T3, T4, T5, T6), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1, T2, T3, T4, T5, T6), S>","common_procedure::store::state_store::KeyValue"],["
§

impl<F, Fut, S, Res, M, T1, T2, T3, T4, T5, T6, T7> Handler<(M, T1, T2, T3, T4, T5, T6, T7), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5, T6, T7) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequestParts<S> + Send,\n T2: FromRequestParts<S> + Send,\n T3: FromRequestParts<S> + Send,\n T4: FromRequestParts<S> + Send,\n T5: FromRequestParts<S> + Send,\n T6: FromRequestParts<S> + Send,\n T7: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1, T2, T3, T4, T5, T6, T7), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1, T2, T3, T4, T5, T6, T7), S>","common_procedure::store::state_store::KeyValue"],["
§

impl<F, Fut, S, Res, M, T1, T2, T3, T4, T5, T6, T7, T8> Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5, T6, T7, T8) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequestParts<S> + Send,\n T2: FromRequestParts<S> + Send,\n T3: FromRequestParts<S> + Send,\n T4: FromRequestParts<S> + Send,\n T5: FromRequestParts<S> + Send,\n T6: FromRequestParts<S> + Send,\n T7: FromRequestParts<S> + Send,\n T8: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8), S>","common_procedure::store::state_store::KeyValue"],["
§

impl<F, Fut, S, Res, M, T1, T2, T3, T4, T5, T6, T7, T8, T9> Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5, T6, T7, T8, T9) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequestParts<S> + Send,\n T2: FromRequestParts<S> + Send,\n T3: FromRequestParts<S> + Send,\n T4: FromRequestParts<S> + Send,\n T5: FromRequestParts<S> + Send,\n T6: FromRequestParts<S> + Send,\n T7: FromRequestParts<S> + Send,\n T8: FromRequestParts<S> + Send,\n T9: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9), S>","common_procedure::store::state_store::KeyValue"],["
§

impl<F, Fut, S, Res, M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequestParts<S> + Send,\n T2: FromRequestParts<S> + Send,\n T3: FromRequestParts<S> + Send,\n T4: FromRequestParts<S> + Send,\n T5: FromRequestParts<S> + Send,\n T6: FromRequestParts<S> + Send,\n T7: FromRequestParts<S> + Send,\n T8: FromRequestParts<S> + Send,\n T9: FromRequestParts<S> + Send,\n T10: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10), S>","common_procedure::store::state_store::KeyValue"],["
§

impl<F, Fut, S, Res, M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequestParts<S> + Send,\n T2: FromRequestParts<S> + Send,\n T3: FromRequestParts<S> + Send,\n T4: FromRequestParts<S> + Send,\n T5: FromRequestParts<S> + Send,\n T6: FromRequestParts<S> + Send,\n T7: FromRequestParts<S> + Send,\n T8: FromRequestParts<S> + Send,\n T9: FromRequestParts<S> + Send,\n T10: FromRequestParts<S> + Send,\n T11: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11), S>","common_procedure::store::state_store::KeyValue"],["
§

impl<F, Fut, S, Res, M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequestParts<S> + Send,\n T2: FromRequestParts<S> + Send,\n T3: FromRequestParts<S> + Send,\n T4: FromRequestParts<S> + Send,\n T5: FromRequestParts<S> + Send,\n T6: FromRequestParts<S> + Send,\n T7: FromRequestParts<S> + Send,\n T8: FromRequestParts<S> + Send,\n T9: FromRequestParts<S> + Send,\n T10: FromRequestParts<S> + Send,\n T11: FromRequestParts<S> + Send,\n T12: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12), S>","common_procedure::store::state_store::KeyValue"],["
§

impl<F, Fut, S, Res, M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequestParts<S> + Send,\n T2: FromRequestParts<S> + Send,\n T3: FromRequestParts<S> + Send,\n T4: FromRequestParts<S> + Send,\n T5: FromRequestParts<S> + Send,\n T6: FromRequestParts<S> + Send,\n T7: FromRequestParts<S> + Send,\n T8: FromRequestParts<S> + Send,\n T9: FromRequestParts<S> + Send,\n T10: FromRequestParts<S> + Send,\n T11: FromRequestParts<S> + Send,\n T12: FromRequestParts<S> + Send,\n T13: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13), S>","common_procedure::store::state_store::KeyValue"],["
§

impl<F, Fut, S, Res, M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequestParts<S> + Send,\n T2: FromRequestParts<S> + Send,\n T3: FromRequestParts<S> + Send,\n T4: FromRequestParts<S> + Send,\n T5: FromRequestParts<S> + Send,\n T6: FromRequestParts<S> + Send,\n T7: FromRequestParts<S> + Send,\n T8: FromRequestParts<S> + Send,\n T9: FromRequestParts<S> + Send,\n T10: FromRequestParts<S> + Send,\n T11: FromRequestParts<S> + Send,\n T12: FromRequestParts<S> + Send,\n T13: FromRequestParts<S> + Send,\n T14: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14), S>","common_procedure::store::state_store::KeyValue"],["
§

impl<F, Fut, S, Res, M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequestParts<S> + Send,\n T2: FromRequestParts<S> + Send,\n T3: FromRequestParts<S> + Send,\n T4: FromRequestParts<S> + Send,\n T5: FromRequestParts<S> + Send,\n T6: FromRequestParts<S> + Send,\n T7: FromRequestParts<S> + Send,\n T8: FromRequestParts<S> + Send,\n T9: FromRequestParts<S> + Send,\n T10: FromRequestParts<S> + Send,\n T11: FromRequestParts<S> + Send,\n T12: FromRequestParts<S> + Send,\n T13: FromRequestParts<S> + Send,\n T14: FromRequestParts<S> + Send,\n T15: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15), S>","common_procedure::store::state_store::KeyValue"],["
§

impl<F, Fut, S, Res, M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16> Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequestParts<S> + Send,\n T2: FromRequestParts<S> + Send,\n T3: FromRequestParts<S> + Send,\n T4: FromRequestParts<S> + Send,\n T5: FromRequestParts<S> + Send,\n T6: FromRequestParts<S> + Send,\n T7: FromRequestParts<S> + Send,\n T8: FromRequestParts<S> + Send,\n T9: FromRequestParts<S> + Send,\n T10: FromRequestParts<S> + Send,\n T11: FromRequestParts<S> + Send,\n T12: FromRequestParts<S> + Send,\n T13: FromRequestParts<S> + Send,\n T14: FromRequestParts<S> + Send,\n T15: FromRequestParts<S> + Send,\n T16: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16), S>","common_procedure::store::state_store::KeyValue"],["
§

impl<R, T1> IntoResponse for (T1, R)
where\n T1: IntoResponseParts,\n R: IntoResponse,

§

fn into_response(self) -> Response<Body>

Create a response.
","IntoResponse","common_procedure::store::state_store::KeyValue"],["
§

impl<T1, T2> IntoResponseParts for (T1, T2)
where\n T1: IntoResponseParts,\n T2: IntoResponseParts,

§

type Error = Response<Body>

The type returned in the event of an error. Read more
§

fn into_response_parts(\n self,\n res: ResponseParts,\n) -> Result<ResponseParts, <(T1, T2) as IntoResponseParts>::Error>

Set parts of the response
","IntoResponseParts","common_procedure::store::state_store::KeyValue"],["
Source§

impl<Ix, E> IntoWeightedEdge<E> for (Ix, Ix)
where\n E: Default,

","IntoWeightedEdge","common_procedure::store::state_store::KeyValue"],["
Source§

impl<Ix, E> IntoWeightedEdge<E> for (Ix, Ix)
where\n E: Default,

","IntoWeightedEdge","common_procedure::store::state_store::KeyValue"],["
§

impl<S, L1, L2> Layer<S> for (L1, L2)
where\n L1: Layer<<L2 as Layer<S>>::Service>,\n L2: Layer<S>,

§

type Service = <L1 as Layer<<L2 as Layer<S>>::Service>>::Service

The wrapped service
§

fn layer(&self, service: S) -> <(L1, L2) as Layer<S>>::Service

Wrap the given service with the middleware, returning a new service\nthat has been decorated with the middleware.
","Layer","common_procedure::store::state_store::KeyValue"],["
§

impl<IT, A, FromA> MultiUnzip<(FromA,)> for IT
where\n IT: Iterator<Item = (A,)>,\n FromA: Default + Extend<A>,

§

fn multiunzip(self) -> (FromA,)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA,)>","common_procedure::store::state_store::KeyValue"],["
§

impl<IT, A, FromA, B, FromB> MultiUnzip<(FromA, FromB)> for IT
where\n IT: Iterator<Item = (A, B)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,

§

fn multiunzip(self) -> (FromA, FromB)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB)>","common_procedure::store::state_store::KeyValue"],["
§

impl<IT, A, FromA, B, FromB, C, FromC> MultiUnzip<(FromA, FromB, FromC)> for IT
where\n IT: Iterator<Item = (A, B, C)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,

§

fn multiunzip(self) -> (FromA, FromB, FromC)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC)>","common_procedure::store::state_store::KeyValue"],["
§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD> MultiUnzip<(FromA, FromB, FromC, FromD)> for IT
where\n IT: Iterator<Item = (A, B, C, D)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,

§

fn multiunzip(self) -> (FromA, FromB, FromC, FromD)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD)>","common_procedure::store::state_store::KeyValue"],["
§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE> MultiUnzip<(FromA, FromB, FromC, FromD, FromE)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,

§

fn multiunzip(self) -> (FromA, FromB, FromC, FromD, FromE)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE)>","common_procedure::store::state_store::KeyValue"],["
§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E, F)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,\n FromF: Default + Extend<F>,

§

fn multiunzip(self) -> (FromA, FromB, FromC, FromD, FromE, FromF)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF)>","common_procedure::store::state_store::KeyValue"],["
§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E, F, G)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,\n FromF: Default + Extend<F>,\n FromG: Default + Extend<G>,

§

fn multiunzip(self) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG)>","common_procedure::store::state_store::KeyValue"],["
§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E, F, G, H)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,\n FromF: Default + Extend<F>,\n FromG: Default + Extend<G>,\n FromH: Default + Extend<H>,

§

fn multiunzip(self) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH)>","common_procedure::store::state_store::KeyValue"],["
§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E, F, G, H, I)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,\n FromF: Default + Extend<F>,\n FromG: Default + Extend<G>,\n FromH: Default + Extend<H>,\n FromI: Default + Extend<I>,

§

fn multiunzip(\n self,\n) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI)>","common_procedure::store::state_store::KeyValue"],["
§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,\n FromF: Default + Extend<F>,\n FromG: Default + Extend<G>,\n FromH: Default + Extend<H>,\n FromI: Default + Extend<I>,\n FromJ: Default + Extend<J>,

§

fn multiunzip(\n self,\n) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ)>","common_procedure::store::state_store::KeyValue"],["
§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ, K, FromK> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J, K)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,\n FromF: Default + Extend<F>,\n FromG: Default + Extend<G>,\n FromH: Default + Extend<H>,\n FromI: Default + Extend<I>,\n FromJ: Default + Extend<J>,\n FromK: Default + Extend<K>,

§

fn multiunzip(\n self,\n) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK)>","common_procedure::store::state_store::KeyValue"],["
§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ, K, FromK, L, FromL> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK, FromL)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J, K, L)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,\n FromF: Default + Extend<F>,\n FromG: Default + Extend<G>,\n FromH: Default + Extend<H>,\n FromI: Default + Extend<I>,\n FromJ: Default + Extend<J>,\n FromK: Default + Extend<K>,\n FromL: Default + Extend<L>,

§

fn multiunzip(\n self,\n) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK, FromL)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK, FromL)>","common_procedure::store::state_store::KeyValue"],["
§

impl<I, O0, O1, E, P0, P1> Parser<I, (O0, O1), E> for (P0, P1)
where\n I: Stream,\n E: ParserError<I>,\n P0: Parser<I, O0, E>,\n P1: Parser<I, O1, E>,

§

fn parse_next(&mut self, i: &mut I) -> Result<(O0, O1), E>

Take tokens from the [Stream], turning it into the output Read more
§

fn parse(\n &mut self,\n input: I,\n) -> Result<O, ParseError<I, <E as ParserError<I>>::Inner>>
where\n Self: Sized,\n I: Stream + StreamIsPartial,\n E: ParserError<I>,\n <E as ParserError<I>>::Inner: ParserError<I>,

Parse all of input, generating O from it
§

fn parse_peek(&mut self, input: I) -> Result<(I, O), E>

Take tokens from the [Stream], turning it into the output Read more
§

fn by_ref(&mut self) -> ByRef<'_, Self, I, O, E>
where\n Self: Sized,

Treat &mut Self as a parser Read more
§

fn value<O2>(self, val: O2) -> Value<Self, I, O, O2, E>
where\n Self: Sized,\n O2: Clone,

Produce the provided value Read more
§

fn default_value<O2>(self) -> DefaultValue<Self, I, O, O2, E>
where\n Self: Sized,\n O2: Default,

Produce a type’s default value Read more
§

fn void(self) -> Void<Self, I, O, E>
where\n Self: Sized,

Discards the output of the Parser Read more
§

fn output_into<O2>(self) -> OutputInto<Self, I, O, O2, E>
where\n Self: Sized,\n O: Into<O2>,

Convert the parser’s output to another type using std::convert::From Read more
§

fn take(self) -> Take<Self, I, O, E>
where\n Self: Sized,\n I: Stream,

Produce the consumed input as produced value. Read more
§

fn with_taken(self) -> WithTaken<Self, I, O, E>
where\n Self: Sized,\n I: Stream,

Produce the consumed input with the output Read more
§

fn span(self) -> Span<Self, I, O, E>
where\n Self: Sized,\n I: Stream + Location,

Produce the location of the consumed input as produced value. Read more
§

fn with_span(self) -> WithSpan<Self, I, O, E>
where\n Self: Sized,\n I: Stream + Location,

Produce the location of consumed input with the output Read more
§

fn map<G, O2>(self, map: G) -> Map<Self, G, I, O, O2, E>
where\n G: FnMut(O) -> O2,\n Self: Sized,

Maps a function over the output of a parser Read more
§

fn try_map<G, O2, E2>(self, map: G) -> TryMap<Self, G, I, O, O2, E, E2>
where\n Self: Sized,\n G: FnMut(O) -> Result<O2, E2>,\n I: Stream,\n E: FromExternalError<I, E2> + ParserError<I>,

Applies a function returning a Result over the output of a parser. Read more
§

fn verify_map<G, O2>(self, map: G) -> VerifyMap<Self, G, I, O, O2, E>
where\n Self: Sized,\n G: FnMut(O) -> Option<O2>,\n I: Stream,\n E: ParserError<I>,

Apply both [Parser::verify] and [Parser::map]. Read more
§

fn flat_map<G, H, O2>(self, map: G) -> FlatMap<Self, G, H, I, O, O2, E>
where\n Self: Sized,\n G: FnMut(O) -> H,\n H: Parser<I, O2, E>,

Creates a parser from the output of this one Read more
§

fn and_then<G, O2>(self, inner: G) -> AndThen<Self, G, I, O, O2, E>
where\n Self: Sized,\n G: Parser<O, O2, E>,\n O: StreamIsPartial,\n I: Stream,

Applies a second parser over the output of the first one Read more
§

fn parse_to<O2>(self) -> ParseTo<Self, I, O, O2, E>
where\n Self: Sized,\n I: Stream,\n O: ParseSlice<O2>,\n E: ParserError<I>,

Apply std::str::FromStr to the output of the parser Read more
§

fn verify<G, O2>(self, filter: G) -> Verify<Self, G, I, O, O2, E>
where\n Self: Sized,\n G: FnMut(&O2) -> bool,\n I: Stream,\n O: Borrow<O2>,\n E: ParserError<I>,\n O2: ?Sized,

Returns the output of the child parser if it satisfies a verification function. Read more
§

fn context<C>(self, context: C) -> Context<Self, I, O, E, C>
where\n Self: Sized,\n I: Stream,\n E: AddContext<I, C> + ParserError<I>,\n C: Clone + Debug,

If parsing fails, add context to the error Read more
§

fn context_with<F, C, FI>(\n self,\n context: F,\n) -> ContextWith<Self, I, O, E, F, C, FI>
where\n Self: Sized,\n I: Stream,\n E: AddContext<I, C> + ParserError<I>,\n F: Fn() -> FI + Clone,\n C: Debug,\n FI: Iterator<Item = C>,

If parsing fails, dynamically add context to the error Read more
§

fn map_err<G, E2>(self, map: G) -> MapErr<Self, G, I, O, E, E2>
where\n G: FnMut(E) -> E2,\n Self: Sized,

Maps a function over the error of a parser Read more
§

fn complete_err(self) -> CompleteErr<Self, I, O, E>
where\n Self: Sized,

Transforms [Incomplete][crate::error::ErrMode::Incomplete] into [Backtrack][crate::error::ErrMode::Backtrack] Read more
§

fn err_into<E2>(self) -> ErrInto<Self, I, O, E, E2>
where\n Self: Sized,\n E: Into<E2>,

Convert the parser’s error to another type using std::convert::From
","Parser","common_procedure::store::state_store::KeyValue"],["
§

impl<I, O1, O2, Error, P1, P2> Permutation<I, (O1, O2), Error> for (P1, P2)
where\n I: Stream,\n Error: ParserError<I>,\n P1: Parser<I, O1, Error>,\n P2: Parser<I, O2, Error>,

§

fn permutation(&mut self, input: &mut I) -> Result<(O1, O2), Error>

Tries to apply all parsers in the tuple in various orders until all of them succeed
","Permutation","common_procedure::store::state_store::KeyValue"],["
§

impl<Input, A, B, Error, FnA, FnB> Permutation<Input, (A, B), Error> for (FnA, FnB)
where\n Input: Clone,\n Error: ParseError<Input>,\n FnA: Parser<Input, A, Error>,\n FnB: Parser<Input, B, Error>,

§

fn permutation(&mut self, input: Input) -> Result<(Input, (A, B)), Err<Error>>

Tries to apply all parsers in the tuple in various orders until all of them succeed
","Permutation","common_procedure::store::state_store::KeyValue"],["
Source§

impl<T0, T1> Serialize for (T0, T1)
where\n T0: Serialize,\n T1: Serialize,

Source§

fn serialize<S>(\n &self,\n serializer: S,\n) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>
where\n S: Serializer,

Serialize this value into the given Serde serializer. Read more
","Serialize","common_procedure::store::state_store::KeyValue"],["
Source§

impl<T0, As0, T1, As1> SerializeAs<(T0, T1)> for (As0, As1)
where\n As0: SerializeAs<T0>,\n As1: SerializeAs<T1>,

Source§

fn serialize_as<S>(\n tuple: &(T0, T1),\n serializer: S,\n) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>
where\n S: Serializer,

Serialize this value into the given Serde serializer.
","SerializeAs<(T0, T1)>","common_procedure::store::state_store::KeyValue"],["
§

impl<'a, T, C0, C1> TreeNodeContainer<'a, T> for (C0, C1)
where\n T: 'a,\n C0: TreeNodeContainer<'a, T>,\n C1: TreeNodeContainer<'a, T>,

§

fn apply_elements<F>(\n &'a self,\n f: F,\n) -> Result<TreeNodeRecursion, DataFusionError>
where\n F: FnMut(&'a T) -> Result<TreeNodeRecursion, DataFusionError>,

Applies f to all elements of the container.\nThis method is usually called from [TreeNode::apply_children] implementations as\na node is actually a container of the node’s children.
§

fn map_elements<F>(self, f: F) -> Result<Transformed<(C0, C1)>, DataFusionError>
where\n F: FnMut(T) -> Result<Transformed<T>, DataFusionError>,

Maps all elements of the container with f.\nThis method is usually called from [TreeNode::map_children] implementations as\na node is actually a container of the node’s children.
","TreeNodeContainer<'a, T>","common_procedure::store::state_store::KeyValue"],["
§

impl<Input, A, B, Error, FnA, FnB> Tuple<Input, (A, B), Error> for (FnA, FnB)
where\n Input: Clone,\n Error: ParseError<Input>,\n FnA: Parser<Input, A, Error>,\n FnB: Parser<Input, B, Error>,

§

fn parse(&mut self, input: Input) -> Result<(Input, (A, B)), Err<Error>>

Parses the input and returns a tuple of results of each parser.
","Tuple","common_procedure::store::state_store::KeyValue"],["
§

impl<'a, T1, T2> Yokeable<'a> for (T1, T2)
where\n T1: 'static + for<'b> Yokeable<'b>,\n T2: 'static + for<'b> Yokeable<'b>,

§

type Output = (<T1 as Yokeable<'a>>::Output, <T2 as Yokeable<'a>>::Output)

This type MUST be Self with the 'static replaced with 'a, i.e. Self<'a>
§

fn transform(&'a self) -> &'a <(T1, T2) as Yokeable<'a>>::Output

This method must cast self between &'a Self<'static> and &'a Self<'a>. Read more
§

fn transform_owned(self) -> <(T1, T2) as Yokeable<'a>>::Output

This method must cast self between Self<'static> and Self<'a>. Read more
§

unsafe fn make(from: <(T1, T2) as Yokeable<'a>>::Output) -> (T1, T2)

This method can be used to cast away Self<'a>’s lifetime. Read more
§

fn transform_mut<F>(&'a mut self, f: F)
where\n F: 'static + for<'b> FnOnce(&'b mut <(T1, T2) as Yokeable<'a>>::Output),

This method must cast self between &'a mut Self<'static> and &'a mut Self<'a>,\nand pass it to f. Read more
","Yokeable<'a>","common_procedure::store::state_store::KeyValue"],["
§

impl<'a, A, B, AE, BE, Format> ZeroFrom<'a, Tuple2VarULE<A, B, Format>> for (AE, BE)
where\n A: VarULE + ?Sized,\n B: VarULE + ?Sized,\n AE: ZeroFrom<'a, A>,\n BE: ZeroFrom<'a, B>,\n Format: VarZeroVecFormat,

§

fn zero_from(other: &'a Tuple2VarULE<A, B, Format>) -> (AE, BE)

Clone the other C into a struct that may retain references into C.
","ZeroFrom<'a, Tuple2VarULE>","common_procedure::store::state_store::KeyValue"],["
§

impl<'zf, C1, T1, C2, T2> ZeroFrom<'zf, (C1, C2)> for (T1, T2)
where\n T1: ZeroFrom<'zf, C1>,\n T2: ZeroFrom<'zf, C2>,

§

fn zero_from(other: &'zf (C1, C2)) -> (T1, T2)

Clone the other C into a struct that may retain references into C.
","ZeroFrom<'zf, (C1, C2)>","common_procedure::store::state_store::KeyValue"],["
§

impl<'a, A, B> ZeroMapKV<'a> for (A, B)
where\n A: Ord + AsULE + 'static,\n B: Ord + AsULE + 'static,

§

type Container = ZeroVec<'a, (A, B)>

The container that can be used with this type: [ZeroVec] or [VarZeroVec].
§

type Slice = ZeroSlice<(A, B)>

§

type GetType = Tuple2ULE<<A as AsULE>::ULE, <B as AsULE>::ULE>

The type produced by Container::get() Read more
§

type OwnedType = (A, B)

The type produced by Container::replace() and Container::remove(),\nalso used during deserialization. If Self is human readable serialized,\ndeserializing to Self::OwnedType should produce the same value once\npassed through Self::owned_as_self() Read more
","ZeroMapKV<'a>","common_procedure::store::state_store::KeyValue"],["
§

impl<A, B> Zeroize for (A, B)
where\n A: Zeroize,\n B: Zeroize,

§

fn zeroize(&mut self)

Zero out this object from memory using Rust intrinsics which ensure the\nzeroization operation is not “optimized away” by the compiler.
","Zeroize","common_procedure::store::state_store::KeyValue"],["
§

impl<A, B> ZeroizeOnDrop for (A, B)
where\n A: ZeroizeOnDrop,\n B: ZeroizeOnDrop,

","ZeroizeOnDrop","common_procedure::store::state_store::KeyValue"]]],["datatypes",[["
§

impl<F, Fut, Res, S> Handler<((),), S> for F
where\n F: FnOnce() -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n Res: IntoResponse,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n _req: Request<Body>,\n _state: S,\n) -> <F as Handler<((),), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<((),), S>","datatypes::compute::kernels::cast_utils::MonthDayNano"],["
§

impl<F, Fut, S, Res, M, T1> Handler<(M, T1), S> for F
where\n F: FnOnce(T1) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1), S>","datatypes::compute::kernels::cast_utils::MonthDayNano"],["
§

impl<F, Fut, S, Res, M, T1, T2> Handler<(M, T1, T2), S> for F
where\n F: FnOnce(T1, T2) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequestParts<S> + Send,\n T2: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1, T2), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1, T2), S>","datatypes::compute::kernels::cast_utils::MonthDayNano"],["
§

impl<F, Fut, S, Res, M, T1, T2, T3> Handler<(M, T1, T2, T3), S> for F
where\n F: FnOnce(T1, T2, T3) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequestParts<S> + Send,\n T2: FromRequestParts<S> + Send,\n T3: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1, T2, T3), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1, T2, T3), S>","datatypes::compute::kernels::cast_utils::MonthDayNano"],["
§

impl<F, Fut, S, Res, M, T1, T2, T3, T4> Handler<(M, T1, T2, T3, T4), S> for F
where\n F: FnOnce(T1, T2, T3, T4) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequestParts<S> + Send,\n T2: FromRequestParts<S> + Send,\n T3: FromRequestParts<S> + Send,\n T4: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1, T2, T3, T4), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1, T2, T3, T4), S>","datatypes::compute::kernels::cast_utils::MonthDayNano"],["
§

impl<F, Fut, S, Res, M, T1, T2, T3, T4, T5> Handler<(M, T1, T2, T3, T4, T5), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequestParts<S> + Send,\n T2: FromRequestParts<S> + Send,\n T3: FromRequestParts<S> + Send,\n T4: FromRequestParts<S> + Send,\n T5: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1, T2, T3, T4, T5), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1, T2, T3, T4, T5), S>","datatypes::compute::kernels::cast_utils::MonthDayNano"],["
§

impl<F, Fut, S, Res, M, T1, T2, T3, T4, T5, T6> Handler<(M, T1, T2, T3, T4, T5, T6), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5, T6) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequestParts<S> + Send,\n T2: FromRequestParts<S> + Send,\n T3: FromRequestParts<S> + Send,\n T4: FromRequestParts<S> + Send,\n T5: FromRequestParts<S> + Send,\n T6: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1, T2, T3, T4, T5, T6), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1, T2, T3, T4, T5, T6), S>","datatypes::compute::kernels::cast_utils::MonthDayNano"],["
§

impl<F, Fut, S, Res, M, T1, T2, T3, T4, T5, T6, T7> Handler<(M, T1, T2, T3, T4, T5, T6, T7), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5, T6, T7) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequestParts<S> + Send,\n T2: FromRequestParts<S> + Send,\n T3: FromRequestParts<S> + Send,\n T4: FromRequestParts<S> + Send,\n T5: FromRequestParts<S> + Send,\n T6: FromRequestParts<S> + Send,\n T7: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1, T2, T3, T4, T5, T6, T7), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1, T2, T3, T4, T5, T6, T7), S>","datatypes::compute::kernels::cast_utils::MonthDayNano"],["
§

impl<F, Fut, S, Res, M, T1, T2, T3, T4, T5, T6, T7, T8> Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5, T6, T7, T8) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequestParts<S> + Send,\n T2: FromRequestParts<S> + Send,\n T3: FromRequestParts<S> + Send,\n T4: FromRequestParts<S> + Send,\n T5: FromRequestParts<S> + Send,\n T6: FromRequestParts<S> + Send,\n T7: FromRequestParts<S> + Send,\n T8: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8), S>","datatypes::compute::kernels::cast_utils::MonthDayNano"],["
§

impl<F, Fut, S, Res, M, T1, T2, T3, T4, T5, T6, T7, T8, T9> Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5, T6, T7, T8, T9) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequestParts<S> + Send,\n T2: FromRequestParts<S> + Send,\n T3: FromRequestParts<S> + Send,\n T4: FromRequestParts<S> + Send,\n T5: FromRequestParts<S> + Send,\n T6: FromRequestParts<S> + Send,\n T7: FromRequestParts<S> + Send,\n T8: FromRequestParts<S> + Send,\n T9: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9), S>","datatypes::compute::kernels::cast_utils::MonthDayNano"],["
§

impl<F, Fut, S, Res, M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequestParts<S> + Send,\n T2: FromRequestParts<S> + Send,\n T3: FromRequestParts<S> + Send,\n T4: FromRequestParts<S> + Send,\n T5: FromRequestParts<S> + Send,\n T6: FromRequestParts<S> + Send,\n T7: FromRequestParts<S> + Send,\n T8: FromRequestParts<S> + Send,\n T9: FromRequestParts<S> + Send,\n T10: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10), S>","datatypes::compute::kernels::cast_utils::MonthDayNano"],["
§

impl<F, Fut, S, Res, M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequestParts<S> + Send,\n T2: FromRequestParts<S> + Send,\n T3: FromRequestParts<S> + Send,\n T4: FromRequestParts<S> + Send,\n T5: FromRequestParts<S> + Send,\n T6: FromRequestParts<S> + Send,\n T7: FromRequestParts<S> + Send,\n T8: FromRequestParts<S> + Send,\n T9: FromRequestParts<S> + Send,\n T10: FromRequestParts<S> + Send,\n T11: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11), S>","datatypes::compute::kernels::cast_utils::MonthDayNano"],["
§

impl<F, Fut, S, Res, M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequestParts<S> + Send,\n T2: FromRequestParts<S> + Send,\n T3: FromRequestParts<S> + Send,\n T4: FromRequestParts<S> + Send,\n T5: FromRequestParts<S> + Send,\n T6: FromRequestParts<S> + Send,\n T7: FromRequestParts<S> + Send,\n T8: FromRequestParts<S> + Send,\n T9: FromRequestParts<S> + Send,\n T10: FromRequestParts<S> + Send,\n T11: FromRequestParts<S> + Send,\n T12: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12), S>","datatypes::compute::kernels::cast_utils::MonthDayNano"],["
§

impl<F, Fut, S, Res, M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequestParts<S> + Send,\n T2: FromRequestParts<S> + Send,\n T3: FromRequestParts<S> + Send,\n T4: FromRequestParts<S> + Send,\n T5: FromRequestParts<S> + Send,\n T6: FromRequestParts<S> + Send,\n T7: FromRequestParts<S> + Send,\n T8: FromRequestParts<S> + Send,\n T9: FromRequestParts<S> + Send,\n T10: FromRequestParts<S> + Send,\n T11: FromRequestParts<S> + Send,\n T12: FromRequestParts<S> + Send,\n T13: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13), S>","datatypes::compute::kernels::cast_utils::MonthDayNano"],["
§

impl<F, Fut, S, Res, M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequestParts<S> + Send,\n T2: FromRequestParts<S> + Send,\n T3: FromRequestParts<S> + Send,\n T4: FromRequestParts<S> + Send,\n T5: FromRequestParts<S> + Send,\n T6: FromRequestParts<S> + Send,\n T7: FromRequestParts<S> + Send,\n T8: FromRequestParts<S> + Send,\n T9: FromRequestParts<S> + Send,\n T10: FromRequestParts<S> + Send,\n T11: FromRequestParts<S> + Send,\n T12: FromRequestParts<S> + Send,\n T13: FromRequestParts<S> + Send,\n T14: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14), S>","datatypes::compute::kernels::cast_utils::MonthDayNano"],["
§

impl<F, Fut, S, Res, M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequestParts<S> + Send,\n T2: FromRequestParts<S> + Send,\n T3: FromRequestParts<S> + Send,\n T4: FromRequestParts<S> + Send,\n T5: FromRequestParts<S> + Send,\n T6: FromRequestParts<S> + Send,\n T7: FromRequestParts<S> + Send,\n T8: FromRequestParts<S> + Send,\n T9: FromRequestParts<S> + Send,\n T10: FromRequestParts<S> + Send,\n T11: FromRequestParts<S> + Send,\n T12: FromRequestParts<S> + Send,\n T13: FromRequestParts<S> + Send,\n T14: FromRequestParts<S> + Send,\n T15: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15), S>","datatypes::compute::kernels::cast_utils::MonthDayNano"],["
§

impl<F, Fut, S, Res, M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16> Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequestParts<S> + Send,\n T2: FromRequestParts<S> + Send,\n T3: FromRequestParts<S> + Send,\n T4: FromRequestParts<S> + Send,\n T5: FromRequestParts<S> + Send,\n T6: FromRequestParts<S> + Send,\n T7: FromRequestParts<S> + Send,\n T8: FromRequestParts<S> + Send,\n T9: FromRequestParts<S> + Send,\n T10: FromRequestParts<S> + Send,\n T11: FromRequestParts<S> + Send,\n T12: FromRequestParts<S> + Send,\n T13: FromRequestParts<S> + Send,\n T14: FromRequestParts<S> + Send,\n T15: FromRequestParts<S> + Send,\n T16: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16), S>","datatypes::compute::kernels::cast_utils::MonthDayNano"],["
§

impl<IT, A, FromA> MultiUnzip<(FromA,)> for IT
where\n IT: Iterator<Item = (A,)>,\n FromA: Default + Extend<A>,

§

fn multiunzip(self) -> (FromA,)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA,)>","datatypes::compute::kernels::cast_utils::MonthDayNano"],["
§

impl<IT, A, FromA, B, FromB, C, FromC> MultiUnzip<(FromA, FromB, FromC)> for IT
where\n IT: Iterator<Item = (A, B, C)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,

§

fn multiunzip(self) -> (FromA, FromB, FromC)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC)>","datatypes::compute::kernels::cast_utils::MonthDayNano"],["
§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD> MultiUnzip<(FromA, FromB, FromC, FromD)> for IT
where\n IT: Iterator<Item = (A, B, C, D)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,

§

fn multiunzip(self) -> (FromA, FromB, FromC, FromD)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD)>","datatypes::compute::kernels::cast_utils::MonthDayNano"],["
§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE> MultiUnzip<(FromA, FromB, FromC, FromD, FromE)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,

§

fn multiunzip(self) -> (FromA, FromB, FromC, FromD, FromE)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE)>","datatypes::compute::kernels::cast_utils::MonthDayNano"],["
§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E, F)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,\n FromF: Default + Extend<F>,

§

fn multiunzip(self) -> (FromA, FromB, FromC, FromD, FromE, FromF)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF)>","datatypes::compute::kernels::cast_utils::MonthDayNano"],["
§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E, F, G)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,\n FromF: Default + Extend<F>,\n FromG: Default + Extend<G>,

§

fn multiunzip(self) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG)>","datatypes::compute::kernels::cast_utils::MonthDayNano"],["
§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E, F, G, H)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,\n FromF: Default + Extend<F>,\n FromG: Default + Extend<G>,\n FromH: Default + Extend<H>,

§

fn multiunzip(self) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH)>","datatypes::compute::kernels::cast_utils::MonthDayNano"],["
§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E, F, G, H, I)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,\n FromF: Default + Extend<F>,\n FromG: Default + Extend<G>,\n FromH: Default + Extend<H>,\n FromI: Default + Extend<I>,

§

fn multiunzip(\n self,\n) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI)>","datatypes::compute::kernels::cast_utils::MonthDayNano"],["
§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,\n FromF: Default + Extend<F>,\n FromG: Default + Extend<G>,\n FromH: Default + Extend<H>,\n FromI: Default + Extend<I>,\n FromJ: Default + Extend<J>,

§

fn multiunzip(\n self,\n) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ)>","datatypes::compute::kernels::cast_utils::MonthDayNano"],["
§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ, K, FromK> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J, K)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,\n FromF: Default + Extend<F>,\n FromG: Default + Extend<G>,\n FromH: Default + Extend<H>,\n FromI: Default + Extend<I>,\n FromJ: Default + Extend<J>,\n FromK: Default + Extend<K>,

§

fn multiunzip(\n self,\n) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK)>","datatypes::compute::kernels::cast_utils::MonthDayNano"],["
§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ, K, FromK, L, FromL> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK, FromL)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J, K, L)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,\n FromF: Default + Extend<F>,\n FromG: Default + Extend<G>,\n FromH: Default + Extend<H>,\n FromI: Default + Extend<I>,\n FromJ: Default + Extend<J>,\n FromK: Default + Extend<K>,\n FromL: Default + Extend<L>,

§

fn multiunzip(\n self,\n) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK, FromL)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK, FromL)>","datatypes::compute::kernels::cast_utils::MonthDayNano"]]],["flow",[["
§

impl<I, Output, Error, Alt2, Alt3, Alt4> Alt<I, Output, Error> for (Alt2, Alt3, Alt4)
where\n I: Stream,\n Error: ParserError<I>,\n Alt2: Parser<I, Output, Error>,\n Alt3: Parser<I, Output, Error>,\n Alt4: Parser<I, Output, Error>,

§

fn choice(&mut self, input: &mut I) -> Result<Output, Error>

Tests each parser in the tuple and returns the result of the first one that succeeds
","Alt","flow::repr::DiffRow","flow::repr::KeyValDiffRow"],["
§

impl<Input, Output, Error, A, B, C> Alt<Input, Output, Error> for (A, B, C)
where\n Input: Clone,\n Error: ParseError<Input>,\n A: Parser<Input, Output, Error>,\n B: Parser<Input, Output, Error>,\n C: Parser<Input, Output, Error>,

§

fn choice(&mut self, input: Input) -> Result<(Input, Output), Err<Error>>

Tests each parser in the tuple and returns the result of the first one that succeeds
","Alt","flow::repr::DiffRow","flow::repr::KeyValDiffRow"],["
§

impl<A, B, C> AsULE for (A, B, C)
where\n A: AsULE,\n B: AsULE,\n C: AsULE,

§

type ULE = Tuple3ULE<<A as AsULE>::ULE, <B as AsULE>::ULE, <C as AsULE>::ULE>

The ULE type corresponding to Self. Read more
§

fn to_unaligned(self) -> <(A, B, C) as AsULE>::ULE

Converts from Self to Self::ULE. Read more
§

fn from_unaligned(unaligned: <(A, B, C) as AsULE>::ULE) -> (A, B, C)

Converts from Self::ULE to Self. Read more
","AsULE","flow::repr::DiffRow","flow::repr::KeyValDiffRow"],["
§

impl<A, B, C> AssertFloatEq for (A, B, C)
where\n A: AssertFloatEq + Debug,\n B: AssertFloatEq + Debug,\n C: AssertFloatEq + Debug + ?Sized,\n <A as FloatEq>::Tol: Sized,\n <B as FloatEq>::Tol: Sized,\n <C as FloatEq>::Tol: Sized,\n <A as AssertFloatEq>::DebugTol: Sized,\n <B as AssertFloatEq>::DebugTol: Sized,\n <C as AssertFloatEq>::DebugTol: Sized,\n <<A as FloatEq>::Tol as FloatEqUlpsTol>::UlpsTol: Sized,\n <<B as FloatEq>::Tol as FloatEqUlpsTol>::UlpsTol: Sized,\n <<C as FloatEq>::Tol as FloatEqUlpsTol>::UlpsTol: Sized,\n <<A as AssertFloatEq>::DebugTol as FloatEqUlpsTol>::UlpsTol: Sized,\n <<B as AssertFloatEq>::DebugTol as FloatEqUlpsTol>::UlpsTol: Sized,\n <<C as AssertFloatEq>::DebugTol as FloatEqUlpsTol>::UlpsTol: Sized,

§

type DebugAbsDiff = (<A as AssertFloatEq>::DebugAbsDiff, <B as AssertFloatEq>::DebugAbsDiff, <C as AssertFloatEq>::DebugAbsDiff)

The absolute difference between two values, displayed to the user via\nfmt::Debug when an assert fails. Read more
§

type DebugTol = (<A as AssertFloatEq>::DebugTol, <B as AssertFloatEq>::DebugTol, <C as AssertFloatEq>::DebugTol)

The per-field tolerance value used for comparison between two values,\ndisplayed to the user via fmt::Debug when an assert fails. Read more
§

fn debug_abs_diff(\n &self,\n other: &(A, B, C),\n) -> <(A, B, C) as AssertFloatEq>::DebugAbsDiff

Always positive absolute difference between two values. Read more
§

fn debug_ulps_diff(\n &self,\n other: &(A, B, C),\n) -> <<(A, B, C) as AssertFloatEq>::DebugAbsDiff as FloatEqDebugUlpsDiff>::DebugUlpsDiff

Always positive absolute difference between two values in terms of ULPs. Read more
§

fn debug_abs_tol(\n &self,\n other: &(A, B, C),\n tol: &<(A, B, C) as FloatEq>::Tol,\n) -> <(A, B, C) as AssertFloatEq>::DebugTol

The tolerance used by an abs comparison, displayed when an assert fails.
§

fn debug_rmax_tol(\n &self,\n other: &(A, B, C),\n tol: &<(A, B, C) as FloatEq>::Tol,\n) -> <(A, B, C) as AssertFloatEq>::DebugTol

The tolerance used by an rmax comparison, displayed when an assert fails. Read more
§

fn debug_rmin_tol(\n &self,\n other: &(A, B, C),\n tol: &<(A, B, C) as FloatEq>::Tol,\n) -> <(A, B, C) as AssertFloatEq>::DebugTol

The tolerance used by an rmin comparison, displayed when an assert fails. Read more
§

fn debug_r1st_tol(\n &self,\n other: &(A, B, C),\n tol: &<(A, B, C) as FloatEq>::Tol,\n) -> <(A, B, C) as AssertFloatEq>::DebugTol

The tolerance used by an r1st comparison, displayed when an assert fails. Read more
§

fn debug_r2nd_tol(\n &self,\n other: &(A, B, C),\n tol: &<(A, B, C) as FloatEq>::Tol,\n) -> <(A, B, C) as AssertFloatEq>::DebugTol

The tolerance used by an r2nd comparison, displayed when an assert fails. Read more
§

fn debug_ulps_tol(\n &self,\n other: &(A, B, C),\n tol: &<<(A, B, C) as FloatEq>::Tol as FloatEqUlpsTol>::UlpsTol,\n) -> <<(A, B, C) as AssertFloatEq>::DebugTol as FloatEqUlpsTol>::UlpsTol

The tolerance used by an ulps comparison, displayed when an assert fails.
§

fn debug_rel_tol(&self, other: &Rhs, tol: &Self::Tol) -> Self::DebugTol

The tolerance used by a rel comparison, displayed when an assert fails. Read more
","AssertFloatEq","flow::repr::DiffRow","flow::repr::KeyValDiffRow"],["
Source§

impl<R, S, T> Bounded for (R, S, T)
where\n R: Bounded,\n S: Bounded,\n T: Bounded,

Source§

fn min_value() -> (R, S, T)

Returns the smallest finite number this type can represent
Source§

fn max_value() -> (R, S, T)

Returns the largest finite number this type can represent
","Bounded","flow::repr::DiffRow","flow::repr::KeyValDiffRow"],["
§

impl<T, F1, F2, F3> ContainsToken<T> for (F1, F2, F3)
where\n T: Clone,\n F1: ContainsToken<T>,\n F2: ContainsToken<T>,\n F3: ContainsToken<T>,

§

fn contains_token(&self, token: T) -> bool

Returns true if self contains the token
","ContainsToken","flow::repr::DiffRow","flow::repr::KeyValDiffRow"],["
§

impl<'r, T1, T2, T3> Decode<'r, Postgres> for (T1, T2, T3)
where\n T1: 'r + Type<Postgres> + for<'a> Decode<'a, Postgres>,\n T2: 'r + Type<Postgres> + for<'a> Decode<'a, Postgres>,\n T3: 'r + Type<Postgres> + for<'a> Decode<'a, Postgres>,

§

fn decode(\n value: PgValueRef<'r>,\n) -> Result<(T1, T2, T3), Box<dyn Error + Sync + Send>>

Decode a new value of this type using a raw value from the database.
","Decode<'r, Postgres>","flow::repr::DiffRow","flow::repr::KeyValDiffRow"],["
Source§

impl<'de, T0, T1, T2> Deserialize<'de> for (T0, T1, T2)
where\n T0: Deserialize<'de>,\n T1: Deserialize<'de>,\n T2: Deserialize<'de>,

Source§

fn deserialize<D>(\n deserializer: D,\n) -> Result<(T0, T1, T2), <D as Deserializer<'de>>::Error>
where\n D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer. Read more
","Deserialize<'de>","flow::repr::DiffRow","flow::repr::KeyValDiffRow"],["
Source§

impl<'de, T0, As0, T1, As1, T2, As2> DeserializeAs<'de, (T0, T1, T2)> for (As0, As1, As2)
where\n As0: DeserializeAs<'de, T0>,\n As1: DeserializeAs<'de, T1>,\n As2: DeserializeAs<'de, T2>,

Source§

fn deserialize_as<D>(\n deserializer: D,\n) -> Result<(T0, T1, T2), <D as Deserializer<'de>>::Error>
where\n D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.
","DeserializeAs<'de, (T0, T1, T2)>","flow::repr::DiffRow","flow::repr::KeyValDiffRow"],["
§

impl<A, B, C, AE, BE, CE, Format> EncodeAsVarULE<Tuple3VarULE<A, B, C, Format>> for (AE, BE, CE)
where\n A: VarULE + ?Sized,\n B: VarULE + ?Sized,\n C: VarULE + ?Sized,\n AE: EncodeAsVarULE<A>,\n BE: EncodeAsVarULE<B>,\n CE: EncodeAsVarULE<C>,\n Format: VarZeroVecFormat,

§

fn encode_var_ule_as_slices<R>(&self, _: impl FnOnce(&[&[u8]]) -> R) -> R

Calls cb with a piecewise list of byte slices that when concatenated\nproduce the memory pattern of the corresponding instance of T. Read more
§

fn encode_var_ule_len(&self) -> usize

Return the length, in bytes, of the corresponding [VarULE] type
§

fn encode_var_ule_write(&self, dst: &mut [u8])

Write the corresponding [VarULE] type to the dst buffer. dst should\nbe the size of [Self::encode_var_ule_len()]
","EncodeAsVarULE>","flow::repr::DiffRow","flow::repr::KeyValDiffRow"],["
§

impl<A, B, C> FloatEq for (A, B, C)
where\n A: FloatEq,\n B: FloatEq,\n C: FloatEq + ?Sized,\n <A as FloatEq>::Tol: Sized,\n <B as FloatEq>::Tol: Sized,\n <C as FloatEq>::Tol: Sized,\n <<A as FloatEq>::Tol as FloatEqUlpsTol>::UlpsTol: Sized,\n <<B as FloatEq>::Tol as FloatEqUlpsTol>::UlpsTol: Sized,\n <<C as FloatEq>::Tol as FloatEqUlpsTol>::UlpsTol: Sized,

§

type Tol = (<A as FloatEq>::Tol, <B as FloatEq>::Tol, <C as FloatEq>::Tol)

Type of the maximum allowed difference between two values for them to be\nconsidered equal.
§

fn eq_abs(&self, other: &(A, B, C), tol: &<(A, B, C) as FloatEq>::Tol) -> bool

Check whether self is equal to other, using an absolute tolerance\ncomparison. Read more
§

fn eq_rmax(&self, other: &(A, B, C), tol: &<(A, B, C) as FloatEq>::Tol) -> bool

Check whether self is equal to other, using a relative tolerance\ncomparison, scaled to the granularity of the input with the largest\nmagnitude. Read more
§

fn eq_rmin(&self, other: &(A, B, C), tol: &<(A, B, C) as FloatEq>::Tol) -> bool

Check whether self is equal to other, using a relative tolerance\ncomparison, scaled to the granularity of the input with the smallest\nmagnitude. Read more
§

fn eq_r1st(&self, other: &(A, B, C), tol: &<(A, B, C) as FloatEq>::Tol) -> bool

Check whether self is equal to other, using a relative tolerance\ncomparison, scaled to the granularity of the first input. Read more
§

fn eq_r2nd(&self, other: &(A, B, C), tol: &<(A, B, C) as FloatEq>::Tol) -> bool

Check whether self is equal to other, using a relative tolerance\ncomparison, scaled to the granularity of the second input. Read more
§

fn eq_ulps(\n &self,\n other: &(A, B, C),\n tol: &<<(A, B, C) as FloatEq>::Tol as FloatEqUlpsTol>::UlpsTol,\n) -> bool

Check whether self is equal to other, using an ULPs comparison. Read more
§

fn ne_abs(&self, other: &Rhs, tol: &Self::Tol) -> bool

Check whether self is not equal to other, using an absolute tolerance\ncomparison. Read more
§

fn eq_rel(&self, other: &Rhs, tol: &Self::Tol) -> bool

Check whether self is equal to other, using a relative tolerance\ncomparison. Read more
§

fn ne_rel(&self, other: &Rhs, tol: &Self::Tol) -> bool

Check whether self is not equal to other, using a relative tolerance\ncomparison. Read more
§

fn ne_rmax(&self, other: &Rhs, tol: &Self::Tol) -> bool

Check whether self is not equal to other, using a relative tolerance\ncomparison. Read more
§

fn ne_rmin(&self, other: &Rhs, tol: &Self::Tol) -> bool

Check whether self is not equal to other, using a relative tolerance\ncomparison. Read more
§

fn ne_r1st(&self, other: &Rhs, tol: &Self::Tol) -> bool

Check whether self is not equal to other, using a relative tolerance\ncomparison. Read more
§

fn ne_r2nd(&self, other: &Rhs, tol: &Self::Tol) -> bool

Check whether self is not equal to other, using a relative tolerance\ncomparison. Read more
§

fn ne_ulps(\n &self,\n other: &Rhs,\n tol: &<Self::Tol as FloatEqUlpsTol>::UlpsTol,\n) -> bool

Check whether self is not equal to other, using an ULPs comparison. Read more
","FloatEq","flow::repr::DiffRow","flow::repr::KeyValDiffRow"],["
§

impl<A, B, C> FloatEqDebugUlpsDiff for (A, B, C)
where\n A: FloatEqDebugUlpsDiff,\n B: FloatEqDebugUlpsDiff,\n C: FloatEqDebugUlpsDiff,

§

type DebugUlpsDiff = (<A as FloatEqDebugUlpsDiff>::DebugUlpsDiff, <B as FloatEqDebugUlpsDiff>::DebugUlpsDiff, <C as FloatEqDebugUlpsDiff>::DebugUlpsDiff)

A structurally identical type to Self, with fields recursively wrapped\nby DebugUlpsDiff.
","FloatEqDebugUlpsDiff","flow::repr::DiffRow","flow::repr::KeyValDiffRow"],["
§

impl<A, B, C> FloatEqUlpsTol for (A, B, C)
where\n A: FloatEqUlpsTol,\n B: FloatEqUlpsTol,\n C: FloatEqUlpsTol + ?Sized,\n <A as FloatEqUlpsTol>::UlpsTol: Sized,\n <B as FloatEqUlpsTol>::UlpsTol: Sized,\n <C as FloatEqUlpsTol>::UlpsTol: Sized,

§

type UlpsTol = (<A as FloatEqUlpsTol>::UlpsTol, <B as FloatEqUlpsTol>::UlpsTol, <C as FloatEqUlpsTol>::UlpsTol)

A structurally identical type to Self, with fields recursively wrapped\nby UlpsTol.
","FloatEqUlpsTol","flow::repr::DiffRow","flow::repr::KeyValDiffRow"],["
§

impl<R, S> From<Bgr<R>> for (S, S, S)
where\n R: Into<S>,

§

fn from(value: Bgr<R>) -> (S, S, S)

Converts to this type from the input type.
","From>","flow::repr::DiffRow","flow::repr::KeyValDiffRow"],["
§

impl<R, S> From<Grb<R>> for (S, S, S)
where\n R: Into<S>,

§

fn from(value: Grb<R>) -> (S, S, S)

Converts to this type from the input type.
","From>","flow::repr::DiffRow","flow::repr::KeyValDiffRow"],["
§

impl<R, S> From<Rgb<R>> for (S, S, S)
where\n R: Into<S>,

§

fn from(value: Rgb<R>) -> (S, S, S)

Converts to this type from the input type.
","From>","flow::repr::DiffRow","flow::repr::KeyValDiffRow"],["
§

impl<S, T1, T2, T3> FromRequest<S> for (T1, T2, T3)
where\n T1: FromRequestParts<S> + Send,\n T2: FromRequestParts<S> + Send,\n T3: FromRequest<S> + Send,\n S: Send + Sync,

§

type Rejection = Response<Body>

If the extractor fails it’ll use this “rejection” type. A rejection is\na kind of error that can be converted into a response.
§

fn from_request(\n req: Request<Body>,\n state: &S,\n) -> impl Future<Output = Result<(T1, T2, T3), <(T1, T2, T3) as FromRequest<S>>::Rejection>>

Perform the extraction.
","FromRequest","flow::repr::DiffRow","flow::repr::KeyValDiffRow"],["
§

impl<S, T1, T2, T3> FromRequestParts<S> for (T1, T2, T3)
where\n T1: FromRequestParts<S> + Send,\n T2: FromRequestParts<S> + Send,\n T3: FromRequestParts<S> + Send,\n S: Send + Sync,

§

type Rejection = Response<Body>

If the extractor fails it’ll use this “rejection” type. A rejection is\na kind of error that can be converted into a response.
§

async fn from_request_parts(\n parts: &mut Parts,\n state: &S,\n) -> Result<(T1, T2, T3), <(T1, T2, T3) as FromRequestParts<S>>::Rejection>

Perform the extraction.
","FromRequestParts","flow::repr::DiffRow","flow::repr::KeyValDiffRow"],["
§

impl<'r, R, T1, T2, T3> FromRow<'r, R> for (T1, T2, T3)
where\n R: Row,\n usize: ColumnIndex<R>,\n T1: Decode<'r, <R as Row>::Database> + Type<<R as Row>::Database>,\n T2: Decode<'r, <R as Row>::Database> + Type<<R as Row>::Database>,\n T3: Decode<'r, <R as Row>::Database> + Type<<R as Row>::Database>,

§

fn from_row(row: &'r R) -> Result<(T1, T2, T3), Error>

","FromRow<'r, R>","flow::repr::DiffRow","flow::repr::KeyValDiffRow"],["
§

impl<T1, T2, T3> FromRow for (T1, T2, T3)
where\n T1: FromValue,\n T2: FromValue,\n T3: FromValue,\n <T1 as FromValue>::Intermediate: Into<Value>,\n <T2 as FromValue>::Intermediate: Into<Value>,

§

fn from_row_opt(row: Row) -> Result<(T1, T2, T3), FromRowError>

§

fn from_row(row: Row) -> Self
where\n Self: Sized,

","FromRow","flow::repr::DiffRow","flow::repr::KeyValDiffRow"],["
§

impl<T2, T1, T0> Generic for (T2, T1, T0)

§

type Repr = HCons<T2, HCons<T1, HCons<T0, HNil>>>

The generic representation type.
§

fn into(self) -> <(T2, T1, T0) as Generic>::Repr

Convert a value to its representation type Repr.
§

fn from(r: <(T2, T1, T0) as Generic>::Repr) -> (T2, T1, T0)

Convert a value’s representation type Repr to the value’s type.
§

fn convert_from<Src>(src: Src) -> Self
where\n Self: Sized,\n Src: Generic<Repr = Self::Repr>,

Convert a value to another type provided that they have\nthe same representation type.
§

fn map_repr<Mapper>(self, mapper: Mapper) -> Self
where\n Self: Sized,\n Mapper: FnOnce(Self::Repr) -> Self::Repr,

Maps the given value of type Self by first transforming it to\nthe representation type Repr, then applying a mapper function\non Repr and finally transforming it back to a value of type Self.
§

fn map_inter<Inter, Mapper>(self, mapper: Mapper) -> Self
where\n Self: Sized,\n Inter: Generic<Repr = Self::Repr>,\n Mapper: FnOnce(Inter) -> Inter,

Maps the given value of type Self by first transforming it\na type Inter that has the same representation type as Self,\nthen applying a mapper function on Inter and finally transforming\nit back to a value of type Self.
","Generic","flow::repr::DiffRow","flow::repr::KeyValDiffRow"],["
§

impl<V1, V2, V3> GetSize for (V1, V2, V3)
where\n V1: GetSize,\n V2: GetSize,\n V3: GetSize,

§

fn get_heap_size(&self) -> usize

Determines how many bytes this object occupies inside the heap. Read more
§

fn get_stack_size() -> usize

Determines how may bytes this object occupies inside the stack. Read more
§

fn get_heap_size_with_tracker<T>(&self, tracker: T) -> (usize, T)
where\n T: GetSizeTracker,

Determines how many bytes this object occupies inside the heap while using a tracker. Read more
§

fn get_size(&self) -> usize

Determines the total size of the object. Read more
§

fn get_size_with_tracker<T>(&self, tracker: T) -> (usize, T)
where\n T: GetSizeTracker,

Determines the total size of the object while using a tracker. Read more
","GetSize","flow::repr::DiffRow","flow::repr::KeyValDiffRow"],["
§

impl<F, Fut, Res, S> Handler<((),), S> for F
where\n F: FnOnce() -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n Res: IntoResponse,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n _req: Request<Body>,\n _state: S,\n) -> <F as Handler<((),), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<((),), S>","flow::repr::DiffRow","flow::repr::KeyValDiffRow"],["
§

impl<F, Fut, S, Res, M, T1> Handler<(M, T1), S> for F
where\n F: FnOnce(T1) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1), S>","flow::repr::DiffRow","flow::repr::KeyValDiffRow"],["
§

impl<F, Fut, S, Res, M, T1, T2> Handler<(M, T1, T2), S> for F
where\n F: FnOnce(T1, T2) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequestParts<S> + Send,\n T2: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1, T2), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1, T2), S>","flow::repr::DiffRow","flow::repr::KeyValDiffRow"],["
§

impl<F, Fut, S, Res, M, T1, T2, T3> Handler<(M, T1, T2, T3), S> for F
where\n F: FnOnce(T1, T2, T3) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequestParts<S> + Send,\n T2: FromRequestParts<S> + Send,\n T3: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1, T2, T3), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1, T2, T3), S>","flow::repr::DiffRow","flow::repr::KeyValDiffRow"],["
§

impl<F, Fut, S, Res, M, T1, T2, T3, T4> Handler<(M, T1, T2, T3, T4), S> for F
where\n F: FnOnce(T1, T2, T3, T4) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequestParts<S> + Send,\n T2: FromRequestParts<S> + Send,\n T3: FromRequestParts<S> + Send,\n T4: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1, T2, T3, T4), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1, T2, T3, T4), S>","flow::repr::DiffRow","flow::repr::KeyValDiffRow"],["
§

impl<F, Fut, S, Res, M, T1, T2, T3, T4, T5> Handler<(M, T1, T2, T3, T4, T5), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequestParts<S> + Send,\n T2: FromRequestParts<S> + Send,\n T3: FromRequestParts<S> + Send,\n T4: FromRequestParts<S> + Send,\n T5: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1, T2, T3, T4, T5), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1, T2, T3, T4, T5), S>","flow::repr::DiffRow","flow::repr::KeyValDiffRow"],["
§

impl<F, Fut, S, Res, M, T1, T2, T3, T4, T5, T6> Handler<(M, T1, T2, T3, T4, T5, T6), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5, T6) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequestParts<S> + Send,\n T2: FromRequestParts<S> + Send,\n T3: FromRequestParts<S> + Send,\n T4: FromRequestParts<S> + Send,\n T5: FromRequestParts<S> + Send,\n T6: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1, T2, T3, T4, T5, T6), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1, T2, T3, T4, T5, T6), S>","flow::repr::DiffRow","flow::repr::KeyValDiffRow"],["
§

impl<F, Fut, S, Res, M, T1, T2, T3, T4, T5, T6, T7> Handler<(M, T1, T2, T3, T4, T5, T6, T7), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5, T6, T7) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequestParts<S> + Send,\n T2: FromRequestParts<S> + Send,\n T3: FromRequestParts<S> + Send,\n T4: FromRequestParts<S> + Send,\n T5: FromRequestParts<S> + Send,\n T6: FromRequestParts<S> + Send,\n T7: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1, T2, T3, T4, T5, T6, T7), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1, T2, T3, T4, T5, T6, T7), S>","flow::repr::DiffRow","flow::repr::KeyValDiffRow"],["
§

impl<F, Fut, S, Res, M, T1, T2, T3, T4, T5, T6, T7, T8> Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5, T6, T7, T8) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequestParts<S> + Send,\n T2: FromRequestParts<S> + Send,\n T3: FromRequestParts<S> + Send,\n T4: FromRequestParts<S> + Send,\n T5: FromRequestParts<S> + Send,\n T6: FromRequestParts<S> + Send,\n T7: FromRequestParts<S> + Send,\n T8: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8), S>","flow::repr::DiffRow","flow::repr::KeyValDiffRow"],["
§

impl<F, Fut, S, Res, M, T1, T2, T3, T4, T5, T6, T7, T8, T9> Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5, T6, T7, T8, T9) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequestParts<S> + Send,\n T2: FromRequestParts<S> + Send,\n T3: FromRequestParts<S> + Send,\n T4: FromRequestParts<S> + Send,\n T5: FromRequestParts<S> + Send,\n T6: FromRequestParts<S> + Send,\n T7: FromRequestParts<S> + Send,\n T8: FromRequestParts<S> + Send,\n T9: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9), S>","flow::repr::DiffRow","flow::repr::KeyValDiffRow"],["
§

impl<F, Fut, S, Res, M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequestParts<S> + Send,\n T2: FromRequestParts<S> + Send,\n T3: FromRequestParts<S> + Send,\n T4: FromRequestParts<S> + Send,\n T5: FromRequestParts<S> + Send,\n T6: FromRequestParts<S> + Send,\n T7: FromRequestParts<S> + Send,\n T8: FromRequestParts<S> + Send,\n T9: FromRequestParts<S> + Send,\n T10: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10), S>","flow::repr::DiffRow","flow::repr::KeyValDiffRow"],["
§

impl<F, Fut, S, Res, M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequestParts<S> + Send,\n T2: FromRequestParts<S> + Send,\n T3: FromRequestParts<S> + Send,\n T4: FromRequestParts<S> + Send,\n T5: FromRequestParts<S> + Send,\n T6: FromRequestParts<S> + Send,\n T7: FromRequestParts<S> + Send,\n T8: FromRequestParts<S> + Send,\n T9: FromRequestParts<S> + Send,\n T10: FromRequestParts<S> + Send,\n T11: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11), S>","flow::repr::DiffRow","flow::repr::KeyValDiffRow"],["
§

impl<F, Fut, S, Res, M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequestParts<S> + Send,\n T2: FromRequestParts<S> + Send,\n T3: FromRequestParts<S> + Send,\n T4: FromRequestParts<S> + Send,\n T5: FromRequestParts<S> + Send,\n T6: FromRequestParts<S> + Send,\n T7: FromRequestParts<S> + Send,\n T8: FromRequestParts<S> + Send,\n T9: FromRequestParts<S> + Send,\n T10: FromRequestParts<S> + Send,\n T11: FromRequestParts<S> + Send,\n T12: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12), S>","flow::repr::DiffRow","flow::repr::KeyValDiffRow"],["
§

impl<F, Fut, S, Res, M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequestParts<S> + Send,\n T2: FromRequestParts<S> + Send,\n T3: FromRequestParts<S> + Send,\n T4: FromRequestParts<S> + Send,\n T5: FromRequestParts<S> + Send,\n T6: FromRequestParts<S> + Send,\n T7: FromRequestParts<S> + Send,\n T8: FromRequestParts<S> + Send,\n T9: FromRequestParts<S> + Send,\n T10: FromRequestParts<S> + Send,\n T11: FromRequestParts<S> + Send,\n T12: FromRequestParts<S> + Send,\n T13: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13), S>","flow::repr::DiffRow","flow::repr::KeyValDiffRow"],["
§

impl<F, Fut, S, Res, M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequestParts<S> + Send,\n T2: FromRequestParts<S> + Send,\n T3: FromRequestParts<S> + Send,\n T4: FromRequestParts<S> + Send,\n T5: FromRequestParts<S> + Send,\n T6: FromRequestParts<S> + Send,\n T7: FromRequestParts<S> + Send,\n T8: FromRequestParts<S> + Send,\n T9: FromRequestParts<S> + Send,\n T10: FromRequestParts<S> + Send,\n T11: FromRequestParts<S> + Send,\n T12: FromRequestParts<S> + Send,\n T13: FromRequestParts<S> + Send,\n T14: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14), S>","flow::repr::DiffRow","flow::repr::KeyValDiffRow"],["
§

impl<F, Fut, S, Res, M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequestParts<S> + Send,\n T2: FromRequestParts<S> + Send,\n T3: FromRequestParts<S> + Send,\n T4: FromRequestParts<S> + Send,\n T5: FromRequestParts<S> + Send,\n T6: FromRequestParts<S> + Send,\n T7: FromRequestParts<S> + Send,\n T8: FromRequestParts<S> + Send,\n T9: FromRequestParts<S> + Send,\n T10: FromRequestParts<S> + Send,\n T11: FromRequestParts<S> + Send,\n T12: FromRequestParts<S> + Send,\n T13: FromRequestParts<S> + Send,\n T14: FromRequestParts<S> + Send,\n T15: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15), S>","flow::repr::DiffRow","flow::repr::KeyValDiffRow"],["
§

impl<F, Fut, S, Res, M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16> Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequestParts<S> + Send,\n T2: FromRequestParts<S> + Send,\n T3: FromRequestParts<S> + Send,\n T4: FromRequestParts<S> + Send,\n T5: FromRequestParts<S> + Send,\n T6: FromRequestParts<S> + Send,\n T7: FromRequestParts<S> + Send,\n T8: FromRequestParts<S> + Send,\n T9: FromRequestParts<S> + Send,\n T10: FromRequestParts<S> + Send,\n T11: FromRequestParts<S> + Send,\n T12: FromRequestParts<S> + Send,\n T13: FromRequestParts<S> + Send,\n T14: FromRequestParts<S> + Send,\n T15: FromRequestParts<S> + Send,\n T16: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16), S>","flow::repr::DiffRow","flow::repr::KeyValDiffRow"],["
§

impl<F, Fut, S, T1> HandlerCallWithExtractors<(T1,), S> for F
where\n F: FnOnce(T1) -> Fut,\n Fut: Future + Send + 'static,\n <Fut as Future>::Output: IntoResponse,

§

type Future = Map<Fut, fn(<Fut as Future>::Output) -> Response<Body>>

The type of future calling this handler returns.
§

fn call(\n self,\n _: (T1,),\n _state: S,\n) -> <F as HandlerCallWithExtractors<(T1,), S>>::Future

Call the handler with the extracted inputs.
§

fn into_handler(self) -> IntoHandler<Self, T, S>

Convert this HandlerCallWithExtractors into [Handler].
§

fn or<R, Rt>(self, rhs: R) -> Or<Self, R, T, Rt, S>
where\n R: HandlerCallWithExtractors<Rt, S>,

Chain two handlers together, running the second one if the first one rejects. Read more
","HandlerCallWithExtractors<(T1,), S>","flow::repr::DiffRow","flow::repr::KeyValDiffRow"],["
§

impl<F, Fut, S, T1, T2> HandlerCallWithExtractors<(T1, T2), S> for F
where\n F: FnOnce(T1, T2) -> Fut,\n Fut: Future + Send + 'static,\n <Fut as Future>::Output: IntoResponse,

§

type Future = Map<Fut, fn(<Fut as Future>::Output) -> Response<Body>>

The type of future calling this handler returns.
§

fn call(\n self,\n _: (T1, T2),\n _state: S,\n) -> <F as HandlerCallWithExtractors<(T1, T2), S>>::Future

Call the handler with the extracted inputs.
§

fn into_handler(self) -> IntoHandler<Self, T, S>

Convert this HandlerCallWithExtractors into [Handler].
§

fn or<R, Rt>(self, rhs: R) -> Or<Self, R, T, Rt, S>
where\n R: HandlerCallWithExtractors<Rt, S>,

Chain two handlers together, running the second one if the first one rejects. Read more
","HandlerCallWithExtractors<(T1, T2), S>","flow::repr::DiffRow","flow::repr::KeyValDiffRow"],["
§

impl<F, Fut, S, T1, T2, T3> HandlerCallWithExtractors<(T1, T2, T3), S> for F
where\n F: FnOnce(T1, T2, T3) -> Fut,\n Fut: Future + Send + 'static,\n <Fut as Future>::Output: IntoResponse,

§

type Future = Map<Fut, fn(<Fut as Future>::Output) -> Response<Body>>

The type of future calling this handler returns.
§

fn call(\n self,\n _: (T1, T2, T3),\n _state: S,\n) -> <F as HandlerCallWithExtractors<(T1, T2, T3), S>>::Future

Call the handler with the extracted inputs.
§

fn into_handler(self) -> IntoHandler<Self, T, S>

Convert this HandlerCallWithExtractors into [Handler].
§

fn or<R, Rt>(self, rhs: R) -> Or<Self, R, T, Rt, S>
where\n R: HandlerCallWithExtractors<Rt, S>,

Chain two handlers together, running the second one if the first one rejects. Read more
","HandlerCallWithExtractors<(T1, T2, T3), S>","flow::repr::DiffRow","flow::repr::KeyValDiffRow"],["
§

impl<F, Fut, S, T1, T2, T3, T4> HandlerCallWithExtractors<(T1, T2, T3, T4), S> for F
where\n F: FnOnce(T1, T2, T3, T4) -> Fut,\n Fut: Future + Send + 'static,\n <Fut as Future>::Output: IntoResponse,

§

type Future = Map<Fut, fn(<Fut as Future>::Output) -> Response<Body>>

The type of future calling this handler returns.
§

fn call(\n self,\n _: (T1, T2, T3, T4),\n _state: S,\n) -> <F as HandlerCallWithExtractors<(T1, T2, T3, T4), S>>::Future

Call the handler with the extracted inputs.
§

fn into_handler(self) -> IntoHandler<Self, T, S>

Convert this HandlerCallWithExtractors into [Handler].
§

fn or<R, Rt>(self, rhs: R) -> Or<Self, R, T, Rt, S>
where\n R: HandlerCallWithExtractors<Rt, S>,

Chain two handlers together, running the second one if the first one rejects. Read more
","HandlerCallWithExtractors<(T1, T2, T3, T4), S>","flow::repr::DiffRow","flow::repr::KeyValDiffRow"],["
§

impl<F, Fut, S, T1, T2, T3, T4, T5> HandlerCallWithExtractors<(T1, T2, T3, T4, T5), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5) -> Fut,\n Fut: Future + Send + 'static,\n <Fut as Future>::Output: IntoResponse,

§

type Future = Map<Fut, fn(<Fut as Future>::Output) -> Response<Body>>

The type of future calling this handler returns.
§

fn call(\n self,\n _: (T1, T2, T3, T4, T5),\n _state: S,\n) -> <F as HandlerCallWithExtractors<(T1, T2, T3, T4, T5), S>>::Future

Call the handler with the extracted inputs.
§

fn into_handler(self) -> IntoHandler<Self, T, S>

Convert this HandlerCallWithExtractors into [Handler].
§

fn or<R, Rt>(self, rhs: R) -> Or<Self, R, T, Rt, S>
where\n R: HandlerCallWithExtractors<Rt, S>,

Chain two handlers together, running the second one if the first one rejects. Read more
","HandlerCallWithExtractors<(T1, T2, T3, T4, T5), S>","flow::repr::DiffRow","flow::repr::KeyValDiffRow"],["
§

impl<F, Fut, S, T1, T2, T3, T4, T5, T6> HandlerCallWithExtractors<(T1, T2, T3, T4, T5, T6), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5, T6) -> Fut,\n Fut: Future + Send + 'static,\n <Fut as Future>::Output: IntoResponse,

§

type Future = Map<Fut, fn(<Fut as Future>::Output) -> Response<Body>>

The type of future calling this handler returns.
§

fn call(\n self,\n _: (T1, T2, T3, T4, T5, T6),\n _state: S,\n) -> <F as HandlerCallWithExtractors<(T1, T2, T3, T4, T5, T6), S>>::Future

Call the handler with the extracted inputs.
§

fn into_handler(self) -> IntoHandler<Self, T, S>

Convert this HandlerCallWithExtractors into [Handler].
§

fn or<R, Rt>(self, rhs: R) -> Or<Self, R, T, Rt, S>
where\n R: HandlerCallWithExtractors<Rt, S>,

Chain two handlers together, running the second one if the first one rejects. Read more
","HandlerCallWithExtractors<(T1, T2, T3, T4, T5, T6), S>","flow::repr::DiffRow","flow::repr::KeyValDiffRow"],["
§

impl<F, Fut, S, T1, T2, T3, T4, T5, T6, T7> HandlerCallWithExtractors<(T1, T2, T3, T4, T5, T6, T7), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5, T6, T7) -> Fut,\n Fut: Future + Send + 'static,\n <Fut as Future>::Output: IntoResponse,

§

type Future = Map<Fut, fn(<Fut as Future>::Output) -> Response<Body>>

The type of future calling this handler returns.
§

fn call(\n self,\n _: (T1, T2, T3, T4, T5, T6, T7),\n _state: S,\n) -> <F as HandlerCallWithExtractors<(T1, T2, T3, T4, T5, T6, T7), S>>::Future

Call the handler with the extracted inputs.
§

fn into_handler(self) -> IntoHandler<Self, T, S>

Convert this HandlerCallWithExtractors into [Handler].
§

fn or<R, Rt>(self, rhs: R) -> Or<Self, R, T, Rt, S>
where\n R: HandlerCallWithExtractors<Rt, S>,

Chain two handlers together, running the second one if the first one rejects. Read more
","HandlerCallWithExtractors<(T1, T2, T3, T4, T5, T6, T7), S>","flow::repr::DiffRow","flow::repr::KeyValDiffRow"],["
§

impl<F, Fut, S, T1, T2, T3, T4, T5, T6, T7, T8> HandlerCallWithExtractors<(T1, T2, T3, T4, T5, T6, T7, T8), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5, T6, T7, T8) -> Fut,\n Fut: Future + Send + 'static,\n <Fut as Future>::Output: IntoResponse,

§

type Future = Map<Fut, fn(<Fut as Future>::Output) -> Response<Body>>

The type of future calling this handler returns.
§

fn call(\n self,\n _: (T1, T2, T3, T4, T5, T6, T7, T8),\n _state: S,\n) -> <F as HandlerCallWithExtractors<(T1, T2, T3, T4, T5, T6, T7, T8), S>>::Future

Call the handler with the extracted inputs.
§

fn into_handler(self) -> IntoHandler<Self, T, S>

Convert this HandlerCallWithExtractors into [Handler].
§

fn or<R, Rt>(self, rhs: R) -> Or<Self, R, T, Rt, S>
where\n R: HandlerCallWithExtractors<Rt, S>,

Chain two handlers together, running the second one if the first one rejects. Read more
","HandlerCallWithExtractors<(T1, T2, T3, T4, T5, T6, T7, T8), S>","flow::repr::DiffRow","flow::repr::KeyValDiffRow"],["
§

impl<F, Fut, S, T1, T2, T3, T4, T5, T6, T7, T8, T9> HandlerCallWithExtractors<(T1, T2, T3, T4, T5, T6, T7, T8, T9), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5, T6, T7, T8, T9) -> Fut,\n Fut: Future + Send + 'static,\n <Fut as Future>::Output: IntoResponse,

§

type Future = Map<Fut, fn(<Fut as Future>::Output) -> Response<Body>>

The type of future calling this handler returns.
§

fn call(\n self,\n _: (T1, T2, T3, T4, T5, T6, T7, T8, T9),\n _state: S,\n) -> <F as HandlerCallWithExtractors<(T1, T2, T3, T4, T5, T6, T7, T8, T9), S>>::Future

Call the handler with the extracted inputs.
§

fn into_handler(self) -> IntoHandler<Self, T, S>

Convert this HandlerCallWithExtractors into [Handler].
§

fn or<R, Rt>(self, rhs: R) -> Or<Self, R, T, Rt, S>
where\n R: HandlerCallWithExtractors<Rt, S>,

Chain two handlers together, running the second one if the first one rejects. Read more
","HandlerCallWithExtractors<(T1, T2, T3, T4, T5, T6, T7, T8, T9), S>","flow::repr::DiffRow","flow::repr::KeyValDiffRow"],["
§

impl<F, Fut, S, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> HandlerCallWithExtractors<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) -> Fut,\n Fut: Future + Send + 'static,\n <Fut as Future>::Output: IntoResponse,

§

type Future = Map<Fut, fn(<Fut as Future>::Output) -> Response<Body>>

The type of future calling this handler returns.
§

fn call(\n self,\n _: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10),\n _state: S,\n) -> <F as HandlerCallWithExtractors<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10), S>>::Future

Call the handler with the extracted inputs.
§

fn into_handler(self) -> IntoHandler<Self, T, S>

Convert this HandlerCallWithExtractors into [Handler].
§

fn or<R, Rt>(self, rhs: R) -> Or<Self, R, T, Rt, S>
where\n R: HandlerCallWithExtractors<Rt, S>,

Chain two handlers together, running the second one if the first one rejects. Read more
","HandlerCallWithExtractors<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10), S>","flow::repr::DiffRow","flow::repr::KeyValDiffRow"],["
§

impl<F, Fut, S, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> HandlerCallWithExtractors<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) -> Fut,\n Fut: Future + Send + 'static,\n <Fut as Future>::Output: IntoResponse,

§

type Future = Map<Fut, fn(<Fut as Future>::Output) -> Response<Body>>

The type of future calling this handler returns.
§

fn call(\n self,\n _: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11),\n _state: S,\n) -> <F as HandlerCallWithExtractors<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11), S>>::Future

Call the handler with the extracted inputs.
§

fn into_handler(self) -> IntoHandler<Self, T, S>

Convert this HandlerCallWithExtractors into [Handler].
§

fn or<R, Rt>(self, rhs: R) -> Or<Self, R, T, Rt, S>
where\n R: HandlerCallWithExtractors<Rt, S>,

Chain two handlers together, running the second one if the first one rejects. Read more
","HandlerCallWithExtractors<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11), S>","flow::repr::DiffRow","flow::repr::KeyValDiffRow"],["
§

impl<F, Fut, S, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> HandlerCallWithExtractors<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) -> Fut,\n Fut: Future + Send + 'static,\n <Fut as Future>::Output: IntoResponse,

§

type Future = Map<Fut, fn(<Fut as Future>::Output) -> Response<Body>>

The type of future calling this handler returns.
§

fn call(\n self,\n _: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12),\n _state: S,\n) -> <F as HandlerCallWithExtractors<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12), S>>::Future

Call the handler with the extracted inputs.
§

fn into_handler(self) -> IntoHandler<Self, T, S>

Convert this HandlerCallWithExtractors into [Handler].
§

fn or<R, Rt>(self, rhs: R) -> Or<Self, R, T, Rt, S>
where\n R: HandlerCallWithExtractors<Rt, S>,

Chain two handlers together, running the second one if the first one rejects. Read more
","HandlerCallWithExtractors<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12), S>","flow::repr::DiffRow","flow::repr::KeyValDiffRow"],["
§

impl<F, Fut, S, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> HandlerCallWithExtractors<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) -> Fut,\n Fut: Future + Send + 'static,\n <Fut as Future>::Output: IntoResponse,

§

type Future = Map<Fut, fn(<Fut as Future>::Output) -> Response<Body>>

The type of future calling this handler returns.
§

fn call(\n self,\n _: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13),\n _state: S,\n) -> <F as HandlerCallWithExtractors<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13), S>>::Future

Call the handler with the extracted inputs.
§

fn into_handler(self) -> IntoHandler<Self, T, S>

Convert this HandlerCallWithExtractors into [Handler].
§

fn or<R, Rt>(self, rhs: R) -> Or<Self, R, T, Rt, S>
where\n R: HandlerCallWithExtractors<Rt, S>,

Chain two handlers together, running the second one if the first one rejects. Read more
","HandlerCallWithExtractors<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13), S>","flow::repr::DiffRow","flow::repr::KeyValDiffRow"],["
§

impl<F, Fut, S, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> HandlerCallWithExtractors<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) -> Fut,\n Fut: Future + Send + 'static,\n <Fut as Future>::Output: IntoResponse,

§

type Future = Map<Fut, fn(<Fut as Future>::Output) -> Response<Body>>

The type of future calling this handler returns.
§

fn call(\n self,\n _: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14),\n _state: S,\n) -> <F as HandlerCallWithExtractors<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14), S>>::Future

Call the handler with the extracted inputs.
§

fn into_handler(self) -> IntoHandler<Self, T, S>

Convert this HandlerCallWithExtractors into [Handler].
§

fn or<R, Rt>(self, rhs: R) -> Or<Self, R, T, Rt, S>
where\n R: HandlerCallWithExtractors<Rt, S>,

Chain two handlers together, running the second one if the first one rejects. Read more
","HandlerCallWithExtractors<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14), S>","flow::repr::DiffRow","flow::repr::KeyValDiffRow"],["
§

impl<F, Fut, S, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> HandlerCallWithExtractors<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) -> Fut,\n Fut: Future + Send + 'static,\n <Fut as Future>::Output: IntoResponse,

§

type Future = Map<Fut, fn(<Fut as Future>::Output) -> Response<Body>>

The type of future calling this handler returns.
§

fn call(\n self,\n _: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15),\n _state: S,\n) -> <F as HandlerCallWithExtractors<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15), S>>::Future

Call the handler with the extracted inputs.
§

fn into_handler(self) -> IntoHandler<Self, T, S>

Convert this HandlerCallWithExtractors into [Handler].
§

fn or<R, Rt>(self, rhs: R) -> Or<Self, R, T, Rt, S>
where\n R: HandlerCallWithExtractors<Rt, S>,

Chain two handlers together, running the second one if the first one rejects. Read more
","HandlerCallWithExtractors<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15), S>","flow::repr::DiffRow","flow::repr::KeyValDiffRow"],["
§

impl<F, Fut, S, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16> HandlerCallWithExtractors<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16) -> Fut,\n Fut: Future + Send + 'static,\n <Fut as Future>::Output: IntoResponse,

§

type Future = Map<Fut, fn(<Fut as Future>::Output) -> Response<Body>>

The type of future calling this handler returns.
§

fn call(\n self,\n _: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16),\n _state: S,\n) -> <F as HandlerCallWithExtractors<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16), S>>::Future

Call the handler with the extracted inputs.
§

fn into_handler(self) -> IntoHandler<Self, T, S>

Convert this HandlerCallWithExtractors into [Handler].
§

fn or<R, Rt>(self, rhs: R) -> Or<Self, R, T, Rt, S>
where\n R: HandlerCallWithExtractors<Rt, S>,

Chain two handlers together, running the second one if the first one rejects. Read more
","HandlerCallWithExtractors<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16), S>","flow::repr::DiffRow","flow::repr::KeyValDiffRow"],["
§

impl<A, B, C> IntoParallelIterator for (A, B, C)
where\n A: IntoParallelIterator,\n <A as IntoParallelIterator>::Iter: IndexedParallelIterator,\n B: IntoParallelIterator,\n <B as IntoParallelIterator>::Iter: IndexedParallelIterator,\n C: IntoParallelIterator,\n <C as IntoParallelIterator>::Iter: IndexedParallelIterator,

§

type Item = (<A as IntoParallelIterator>::Item, <B as IntoParallelIterator>::Item, <C as IntoParallelIterator>::Item)

The type of item that the parallel iterator will produce.
§

type Iter = MultiZip<(<A as IntoParallelIterator>::Iter, <B as IntoParallelIterator>::Iter, <C as IntoParallelIterator>::Iter)>

The parallel iterator type that will be created.
§

fn into_par_iter(self) -> <(A, B, C) as IntoParallelIterator>::Iter

Converts self into a parallel iterator. Read more
","IntoParallelIterator","flow::repr::DiffRow","flow::repr::KeyValDiffRow"],["
§

impl<R, T1, T2> IntoResponse for (T1, T2, R)
where\n T1: IntoResponseParts,\n T2: IntoResponseParts,\n R: IntoResponse,

§

fn into_response(self) -> Response<Body>

Create a response.
","IntoResponse","flow::repr::DiffRow","flow::repr::KeyValDiffRow"],["
§

impl<T1, T2, T3> IntoResponseParts for (T1, T2, T3)
where\n T1: IntoResponseParts,\n T2: IntoResponseParts,\n T3: IntoResponseParts,

§

type Error = Response<Body>

The type returned in the event of an error. Read more
§

fn into_response_parts(\n self,\n res: ResponseParts,\n) -> Result<ResponseParts, <(T1, T2, T3) as IntoResponseParts>::Error>

Set parts of the response
","IntoResponseParts","flow::repr::DiffRow","flow::repr::KeyValDiffRow"],["
Source§

impl<Ix, E> IntoWeightedEdge<E> for (Ix, Ix, E)

","IntoWeightedEdge","flow::repr::DiffRow","flow::repr::KeyValDiffRow"],["
Source§

impl<Ix, E> IntoWeightedEdge<E> for (Ix, Ix, E)

","IntoWeightedEdge","flow::repr::DiffRow","flow::repr::KeyValDiffRow"],["
§

impl<S, L1, L2, L3> Layer<S> for (L1, L2, L3)
where\n L1: Layer<<L2 as Layer<<L3 as Layer<S>>::Service>>::Service>,\n L2: Layer<<L3 as Layer<S>>::Service>,\n L3: Layer<S>,

§

type Service = <L1 as Layer<<L2 as Layer<<L3 as Layer<S>>::Service>>::Service>>::Service

The wrapped service
§

fn layer(&self, service: S) -> <(L1, L2, L3) as Layer<S>>::Service

Wrap the given service with the middleware, returning a new service\nthat has been decorated with the middleware.
","Layer","flow::repr::DiffRow","flow::repr::KeyValDiffRow"],["
§

impl<A, B, C> Monoid for (A, B, C)
where\n A: Monoid,\n B: Monoid,\n C: Monoid,

§

fn empty() -> (A, B, C)

For a given Monoid, returns its empty/zero value Read more
","Monoid","flow::repr::DiffRow","flow::repr::KeyValDiffRow"],["
Source§

impl<IT, A, FromA> MultiUnzip<(FromA,)> for IT
where\n IT: Iterator<Item = (A,)>,\n FromA: Default + Extend<A>,

Source§

fn multiunzip(self) -> (FromA,)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA,)>","flow::repr::DiffRow","flow::repr::KeyValDiffRow"],["
§

impl<IT, A, FromA> MultiUnzip<(FromA,)> for IT
where\n IT: Iterator<Item = (A,)>,\n FromA: Default + Extend<A>,

§

fn multiunzip(self) -> (FromA,)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA,)>","flow::repr::DiffRow","flow::repr::KeyValDiffRow"],["
§

impl<IT, A, FromA> MultiUnzip<(FromA,)> for IT
where\n IT: Iterator<Item = (A,)>,\n FromA: Default + Extend<A>,

§

fn multiunzip(self) -> (FromA,)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA,)>","flow::repr::DiffRow","flow::repr::KeyValDiffRow"],["
Source§

impl<IT, A, FromA, B, FromB, C, FromC> MultiUnzip<(FromA, FromB, FromC)> for IT
where\n IT: Iterator<Item = (A, B, C)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,

Source§

fn multiunzip(self) -> (FromA, FromB, FromC)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC)>","flow::repr::DiffRow","flow::repr::KeyValDiffRow"],["
§

impl<IT, A, FromA, B, FromB, C, FromC> MultiUnzip<(FromA, FromB, FromC)> for IT
where\n IT: Iterator<Item = (A, B, C)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,

§

fn multiunzip(self) -> (FromA, FromB, FromC)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC)>","flow::repr::DiffRow","flow::repr::KeyValDiffRow"],["
§

impl<IT, A, FromA, B, FromB, C, FromC> MultiUnzip<(FromA, FromB, FromC)> for IT
where\n IT: Iterator<Item = (A, B, C)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,

§

fn multiunzip(self) -> (FromA, FromB, FromC)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC)>","flow::repr::DiffRow","flow::repr::KeyValDiffRow"],["
Source§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD> MultiUnzip<(FromA, FromB, FromC, FromD)> for IT
where\n IT: Iterator<Item = (A, B, C, D)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,

Source§

fn multiunzip(self) -> (FromA, FromB, FromC, FromD)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD)>","flow::repr::DiffRow","flow::repr::KeyValDiffRow"],["
§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD> MultiUnzip<(FromA, FromB, FromC, FromD)> for IT
where\n IT: Iterator<Item = (A, B, C, D)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,

§

fn multiunzip(self) -> (FromA, FromB, FromC, FromD)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD)>","flow::repr::DiffRow","flow::repr::KeyValDiffRow"],["
§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD> MultiUnzip<(FromA, FromB, FromC, FromD)> for IT
where\n IT: Iterator<Item = (A, B, C, D)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,

§

fn multiunzip(self) -> (FromA, FromB, FromC, FromD)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD)>","flow::repr::DiffRow","flow::repr::KeyValDiffRow"],["
Source§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE> MultiUnzip<(FromA, FromB, FromC, FromD, FromE)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,

Source§

fn multiunzip(self) -> (FromA, FromB, FromC, FromD, FromE)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE)>","flow::repr::DiffRow","flow::repr::KeyValDiffRow"],["
§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE> MultiUnzip<(FromA, FromB, FromC, FromD, FromE)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,

§

fn multiunzip(self) -> (FromA, FromB, FromC, FromD, FromE)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE)>","flow::repr::DiffRow","flow::repr::KeyValDiffRow"],["
§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE> MultiUnzip<(FromA, FromB, FromC, FromD, FromE)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,

§

fn multiunzip(self) -> (FromA, FromB, FromC, FromD, FromE)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE)>","flow::repr::DiffRow","flow::repr::KeyValDiffRow"],["
Source§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E, F)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,\n FromF: Default + Extend<F>,

Source§

fn multiunzip(self) -> (FromA, FromB, FromC, FromD, FromE, FromF)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF)>","flow::repr::DiffRow","flow::repr::KeyValDiffRow"],["
§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E, F)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,\n FromF: Default + Extend<F>,

§

fn multiunzip(self) -> (FromA, FromB, FromC, FromD, FromE, FromF)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF)>","flow::repr::DiffRow","flow::repr::KeyValDiffRow"],["
§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E, F)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,\n FromF: Default + Extend<F>,

§

fn multiunzip(self) -> (FromA, FromB, FromC, FromD, FromE, FromF)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF)>","flow::repr::DiffRow","flow::repr::KeyValDiffRow"],["
Source§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E, F, G)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,\n FromF: Default + Extend<F>,\n FromG: Default + Extend<G>,

Source§

fn multiunzip(self) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG)>","flow::repr::DiffRow","flow::repr::KeyValDiffRow"],["
§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E, F, G)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,\n FromF: Default + Extend<F>,\n FromG: Default + Extend<G>,

§

fn multiunzip(self) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG)>","flow::repr::DiffRow","flow::repr::KeyValDiffRow"],["
§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E, F, G)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,\n FromF: Default + Extend<F>,\n FromG: Default + Extend<G>,

§

fn multiunzip(self) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG)>","flow::repr::DiffRow","flow::repr::KeyValDiffRow"],["
Source§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E, F, G, H)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,\n FromF: Default + Extend<F>,\n FromG: Default + Extend<G>,\n FromH: Default + Extend<H>,

Source§

fn multiunzip(self) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH)>","flow::repr::DiffRow","flow::repr::KeyValDiffRow"],["
§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E, F, G, H)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,\n FromF: Default + Extend<F>,\n FromG: Default + Extend<G>,\n FromH: Default + Extend<H>,

§

fn multiunzip(self) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH)>","flow::repr::DiffRow","flow::repr::KeyValDiffRow"],["
§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E, F, G, H)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,\n FromF: Default + Extend<F>,\n FromG: Default + Extend<G>,\n FromH: Default + Extend<H>,

§

fn multiunzip(self) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH)>","flow::repr::DiffRow","flow::repr::KeyValDiffRow"],["
Source§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E, F, G, H, I)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,\n FromF: Default + Extend<F>,\n FromG: Default + Extend<G>,\n FromH: Default + Extend<H>,\n FromI: Default + Extend<I>,

Source§

fn multiunzip(\n self,\n) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI)>","flow::repr::DiffRow","flow::repr::KeyValDiffRow"],["
§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E, F, G, H, I)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,\n FromF: Default + Extend<F>,\n FromG: Default + Extend<G>,\n FromH: Default + Extend<H>,\n FromI: Default + Extend<I>,

§

fn multiunzip(\n self,\n) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI)>","flow::repr::DiffRow","flow::repr::KeyValDiffRow"],["
§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E, F, G, H, I)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,\n FromF: Default + Extend<F>,\n FromG: Default + Extend<G>,\n FromH: Default + Extend<H>,\n FromI: Default + Extend<I>,

§

fn multiunzip(\n self,\n) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI)>","flow::repr::DiffRow","flow::repr::KeyValDiffRow"],["
Source§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,\n FromF: Default + Extend<F>,\n FromG: Default + Extend<G>,\n FromH: Default + Extend<H>,\n FromI: Default + Extend<I>,\n FromJ: Default + Extend<J>,

Source§

fn multiunzip(\n self,\n) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ)>","flow::repr::DiffRow","flow::repr::KeyValDiffRow"],["
§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,\n FromF: Default + Extend<F>,\n FromG: Default + Extend<G>,\n FromH: Default + Extend<H>,\n FromI: Default + Extend<I>,\n FromJ: Default + Extend<J>,

§

fn multiunzip(\n self,\n) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ)>","flow::repr::DiffRow","flow::repr::KeyValDiffRow"],["
§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,\n FromF: Default + Extend<F>,\n FromG: Default + Extend<G>,\n FromH: Default + Extend<H>,\n FromI: Default + Extend<I>,\n FromJ: Default + Extend<J>,

§

fn multiunzip(\n self,\n) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ)>","flow::repr::DiffRow","flow::repr::KeyValDiffRow"],["
Source§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ, K, FromK> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J, K)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,\n FromF: Default + Extend<F>,\n FromG: Default + Extend<G>,\n FromH: Default + Extend<H>,\n FromI: Default + Extend<I>,\n FromJ: Default + Extend<J>,\n FromK: Default + Extend<K>,

Source§

fn multiunzip(\n self,\n) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK)>","flow::repr::DiffRow","flow::repr::KeyValDiffRow"],["
§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ, K, FromK> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J, K)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,\n FromF: Default + Extend<F>,\n FromG: Default + Extend<G>,\n FromH: Default + Extend<H>,\n FromI: Default + Extend<I>,\n FromJ: Default + Extend<J>,\n FromK: Default + Extend<K>,

§

fn multiunzip(\n self,\n) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK)>","flow::repr::DiffRow","flow::repr::KeyValDiffRow"],["
§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ, K, FromK> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J, K)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,\n FromF: Default + Extend<F>,\n FromG: Default + Extend<G>,\n FromH: Default + Extend<H>,\n FromI: Default + Extend<I>,\n FromJ: Default + Extend<J>,\n FromK: Default + Extend<K>,

§

fn multiunzip(\n self,\n) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK)>","flow::repr::DiffRow","flow::repr::KeyValDiffRow"],["
Source§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ, K, FromK, L, FromL> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK, FromL)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J, K, L)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,\n FromF: Default + Extend<F>,\n FromG: Default + Extend<G>,\n FromH: Default + Extend<H>,\n FromI: Default + Extend<I>,\n FromJ: Default + Extend<J>,\n FromK: Default + Extend<K>,\n FromL: Default + Extend<L>,

","MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK, FromL)>","flow::repr::DiffRow","flow::repr::KeyValDiffRow"],["
§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ, K, FromK, L, FromL> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK, FromL)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J, K, L)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,\n FromF: Default + Extend<F>,\n FromG: Default + Extend<G>,\n FromH: Default + Extend<H>,\n FromI: Default + Extend<I>,\n FromJ: Default + Extend<J>,\n FromK: Default + Extend<K>,\n FromL: Default + Extend<L>,

§

fn multiunzip(\n self,\n) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK, FromL)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK, FromL)>","flow::repr::DiffRow","flow::repr::KeyValDiffRow"],["
§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ, K, FromK, L, FromL> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK, FromL)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J, K, L)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,\n FromF: Default + Extend<F>,\n FromG: Default + Extend<G>,\n FromH: Default + Extend<H>,\n FromI: Default + Extend<I>,\n FromJ: Default + Extend<J>,\n FromK: Default + Extend<K>,\n FromL: Default + Extend<L>,

§

fn multiunzip(\n self,\n) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK, FromL)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK, FromL)>","flow::repr::DiffRow","flow::repr::KeyValDiffRow"],["
§

impl<I, O1, O2, O3, E, P1, P2, P3> Parser<I> for (P1, P2, P3)
where\n E: ParseError<I>,\n P1: Parser<I, Output = O1, Error = E>,\n P2: Parser<I, Output = O2, Error = E>,\n P3: Parser<I, Output = O3, Error = E>,

§

type Output = (O1, O2, O3)

Type of the produced value
§

type Error = E

Error type of this parser
§

fn process<OM>(\n &mut self,\n i: I,\n) -> Result<(I, <<OM as OutputMode>::Output as Mode>::Output<<(P1, P2, P3) as Parser<I>>::Output>), Err<<(P1, P2, P3) as Parser<I>>::Error, <<OM as OutputMode>::Error as Mode>::Output<<(P1, P2, P3) as Parser<I>>::Error>>>
where\n OM: OutputMode,

A parser takes in input type, and returns a Result containing\neither the remaining input and the output value, or an error
§

fn parse(\n &mut self,\n input: Input,\n) -> Result<(Input, Self::Output), Err<Self::Error>>

A parser takes in input type, and returns a Result containing\neither the remaining input and the output value, or an error
§

fn parse_complete(\n &mut self,\n input: Input,\n) -> Result<(Input, Self::Output), Err<Self::Error>>

A parser takes in input type, and returns a Result containing\neither the remaining input and the output value, or an error
§

fn map<G, O2>(self, g: G) -> Map<Self, G>
where\n G: FnMut(Self::Output) -> O2,\n Self: Sized,

Maps a function over the result of a parser
§

fn map_res<G, O2, E2>(self, g: G) -> MapRes<Self, G>
where\n G: FnMut(Self::Output) -> Result<O2, E2>,\n Self::Error: FromExternalError<Input, E2>,\n Self: Sized,

Applies a function returning a Result over the result of a parser.
§

fn map_opt<G, O2>(self, g: G) -> MapOpt<Self, G>
where\n G: FnMut(Self::Output) -> Option<O2>,\n Self: Sized,

Applies a function returning an Option over the result of a parser.
§

fn flat_map<G, H>(self, g: G) -> FlatMap<Self, G>
where\n G: FnMut(Self::Output) -> H,\n H: Parser<Input, Error = Self::Error>,\n Self: Sized,

Creates a second parser from the output of the first one, then apply over the rest of the input
§

fn and_then<G>(self, g: G) -> AndThen<Self, G>
where\n G: Parser<Self::Output, Error = Self::Error>,\n Self: Sized,

Applies a second parser over the output of the first one
§

fn and<G, O2>(self, g: G) -> And<Self, G>
where\n G: Parser<Input, Output = O2, Error = Self::Error>,\n Self: Sized,

Applies a second parser after the first one, return their results as a tuple
§

fn or<G>(self, g: G) -> Or<Self, G>
where\n G: Parser<Input, Output = Self::Output, Error = Self::Error>,\n Self: Sized,

Applies a second parser over the input if the first one failed
§

fn into<O2, E2>(self) -> Into<Self, O2, E2>
where\n O2: From<Self::Output>,\n E2: From<Self::Error>,\n Self: Sized,

automatically converts the parser’s output and error values to another type, as long as they\nimplement the From trait
","Parser","flow::repr::DiffRow","flow::repr::KeyValDiffRow"],["
§

impl<I, O0, O1, O2, E, P0, P1, P2> Parser<I, (O0, O1, O2), E> for (P0, P1, P2)
where\n I: Stream,\n E: ParserError<I>,\n P0: Parser<I, O0, E>,\n P1: Parser<I, O1, E>,\n P2: Parser<I, O2, E>,

§

fn parse_next(&mut self, i: &mut I) -> Result<(O0, O1, O2), E>

Take tokens from the [Stream], turning it into the output Read more
§

fn parse(\n &mut self,\n input: I,\n) -> Result<O, ParseError<I, <E as ParserError<I>>::Inner>>
where\n Self: Sized,\n I: Stream + StreamIsPartial,\n E: ParserError<I>,\n <E as ParserError<I>>::Inner: ParserError<I>,

Parse all of input, generating O from it
§

fn parse_peek(&mut self, input: I) -> Result<(I, O), E>

Take tokens from the [Stream], turning it into the output Read more
§

fn by_ref(&mut self) -> ByRef<'_, Self, I, O, E>
where\n Self: Sized,

Treat &mut Self as a parser Read more
§

fn value<O2>(self, val: O2) -> Value<Self, I, O, O2, E>
where\n Self: Sized,\n O2: Clone,

Produce the provided value Read more
§

fn default_value<O2>(self) -> DefaultValue<Self, I, O, O2, E>
where\n Self: Sized,\n O2: Default,

Produce a type’s default value Read more
§

fn void(self) -> Void<Self, I, O, E>
where\n Self: Sized,

Discards the output of the Parser Read more
§

fn output_into<O2>(self) -> OutputInto<Self, I, O, O2, E>
where\n Self: Sized,\n O: Into<O2>,

Convert the parser’s output to another type using std::convert::From Read more
§

fn take(self) -> Take<Self, I, O, E>
where\n Self: Sized,\n I: Stream,

Produce the consumed input as produced value. Read more
§

fn with_taken(self) -> WithTaken<Self, I, O, E>
where\n Self: Sized,\n I: Stream,

Produce the consumed input with the output Read more
§

fn span(self) -> Span<Self, I, O, E>
where\n Self: Sized,\n I: Stream + Location,

Produce the location of the consumed input as produced value. Read more
§

fn with_span(self) -> WithSpan<Self, I, O, E>
where\n Self: Sized,\n I: Stream + Location,

Produce the location of consumed input with the output Read more
§

fn map<G, O2>(self, map: G) -> Map<Self, G, I, O, O2, E>
where\n G: FnMut(O) -> O2,\n Self: Sized,

Maps a function over the output of a parser Read more
§

fn try_map<G, O2, E2>(self, map: G) -> TryMap<Self, G, I, O, O2, E, E2>
where\n Self: Sized,\n G: FnMut(O) -> Result<O2, E2>,\n I: Stream,\n E: FromExternalError<I, E2> + ParserError<I>,

Applies a function returning a Result over the output of a parser. Read more
§

fn verify_map<G, O2>(self, map: G) -> VerifyMap<Self, G, I, O, O2, E>
where\n Self: Sized,\n G: FnMut(O) -> Option<O2>,\n I: Stream,\n E: ParserError<I>,

Apply both [Parser::verify] and [Parser::map]. Read more
§

fn flat_map<G, H, O2>(self, map: G) -> FlatMap<Self, G, H, I, O, O2, E>
where\n Self: Sized,\n G: FnMut(O) -> H,\n H: Parser<I, O2, E>,

Creates a parser from the output of this one Read more
§

fn and_then<G, O2>(self, inner: G) -> AndThen<Self, G, I, O, O2, E>
where\n Self: Sized,\n G: Parser<O, O2, E>,\n O: StreamIsPartial,\n I: Stream,

Applies a second parser over the output of the first one Read more
§

fn parse_to<O2>(self) -> ParseTo<Self, I, O, O2, E>
where\n Self: Sized,\n I: Stream,\n O: ParseSlice<O2>,\n E: ParserError<I>,

Apply std::str::FromStr to the output of the parser Read more
§

fn verify<G, O2>(self, filter: G) -> Verify<Self, G, I, O, O2, E>
where\n Self: Sized,\n G: FnMut(&O2) -> bool,\n I: Stream,\n O: Borrow<O2>,\n E: ParserError<I>,\n O2: ?Sized,

Returns the output of the child parser if it satisfies a verification function. Read more
§

fn context<C>(self, context: C) -> Context<Self, I, O, E, C>
where\n Self: Sized,\n I: Stream,\n E: AddContext<I, C> + ParserError<I>,\n C: Clone + Debug,

If parsing fails, add context to the error Read more
§

fn context_with<F, C, FI>(\n self,\n context: F,\n) -> ContextWith<Self, I, O, E, F, C, FI>
where\n Self: Sized,\n I: Stream,\n E: AddContext<I, C> + ParserError<I>,\n F: Fn() -> FI + Clone,\n C: Debug,\n FI: Iterator<Item = C>,

If parsing fails, dynamically add context to the error Read more
§

fn map_err<G, E2>(self, map: G) -> MapErr<Self, G, I, O, E, E2>
where\n G: FnMut(E) -> E2,\n Self: Sized,

Maps a function over the error of a parser Read more
§

fn complete_err(self) -> CompleteErr<Self, I, O, E>
where\n Self: Sized,

Transforms [Incomplete][crate::error::ErrMode::Incomplete] into [Backtrack][crate::error::ErrMode::Backtrack] Read more
§

fn err_into<E2>(self) -> ErrInto<Self, I, O, E, E2>
where\n Self: Sized,\n E: Into<E2>,

Convert the parser’s error to another type using std::convert::From
","Parser","flow::repr::DiffRow","flow::repr::KeyValDiffRow"],["
§

impl<I, O1, O2, O3, Error, P1, P2, P3> Permutation<I, (O1, O2, O3), Error> for (P1, P2, P3)
where\n I: Stream,\n Error: ParserError<I>,\n P1: Parser<I, O1, Error>,\n P2: Parser<I, O2, Error>,\n P3: Parser<I, O3, Error>,

§

fn permutation(&mut self, input: &mut I) -> Result<(O1, O2, O3), Error>

Tries to apply all parsers in the tuple in various orders until all of them succeed
","Permutation","flow::repr::DiffRow","flow::repr::KeyValDiffRow"],["
§

impl<Input, A, B, C, Error, FnA, FnB, FnC> Permutation<Input, (A, B, C), Error> for (FnA, FnB, FnC)
where\n Input: Clone,\n Error: ParseError<Input>,\n FnA: Parser<Input, A, Error>,\n FnB: Parser<Input, B, Error>,\n FnC: Parser<Input, C, Error>,

§

fn permutation(\n &mut self,\n input: Input,\n) -> Result<(Input, (A, B, C)), Err<Error>>

Tries to apply all parsers in the tuple in various orders until all of them succeed
","Permutation","flow::repr::DiffRow","flow::repr::KeyValDiffRow"],["
§

impl<T1, T2, T3> PgHasArrayType for (T1, T2, T3)

§

fn array_type_info() -> PgTypeInfo

§

fn array_compatible(ty: &PgTypeInfo) -> bool

","PgHasArrayType","flow::repr::DiffRow","flow::repr::KeyValDiffRow"],["
§

impl<S> Point for (S, S, S)
where\n S: RTreeNum,

§

const DIMENSIONS: usize = 3usize

The number of dimensions of this point type.
§

type Scalar = S

The number type used by this point type.
§

fn generate(generator: impl FnMut(usize) -> S) -> (S, S, S)

Creates a new point value with given values for each dimension. Read more
§

fn nth(&self, index: usize) -> <(S, S, S) as Point>::Scalar

Returns a single coordinate of this point. Read more
§

fn nth_mut(&mut self, index: usize) -> &mut <(S, S, S) as Point>::Scalar

Mutable variant of nth.
","Point","flow::repr::DiffRow","flow::repr::KeyValDiffRow"],["
§

impl<A, B, C> Semigroup for (A, B, C)
where\n A: Semigroup,\n B: Semigroup,\n C: Semigroup,

§

fn combine(&self, other: &(A, B, C)) -> (A, B, C)

Associative operation taking which combines two values. Read more
","Semigroup","flow::repr::DiffRow","flow::repr::KeyValDiffRow"],["
Source§

impl<T0, T1, T2> Serialize for (T0, T1, T2)
where\n T0: Serialize,\n T1: Serialize,\n T2: Serialize,

Source§

fn serialize<S>(\n &self,\n serializer: S,\n) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>
where\n S: Serializer,

Serialize this value into the given Serde serializer. Read more
","Serialize","flow::repr::DiffRow","flow::repr::KeyValDiffRow"],["
Source§

impl<T0, As0, T1, As1, T2, As2> SerializeAs<(T0, T1, T2)> for (As0, As1, As2)
where\n As0: SerializeAs<T0>,\n As1: SerializeAs<T1>,\n As2: SerializeAs<T2>,

Source§

fn serialize_as<S>(\n tuple: &(T0, T1, T2),\n serializer: S,\n) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>
where\n S: Serializer,

Serialize this value into the given Serde serializer.
","SerializeAs<(T0, T1, T2)>","flow::repr::DiffRow","flow::repr::KeyValDiffRow"],["
§

impl<'a, T, C0, C1, C2> TreeNodeContainer<'a, T> for (C0, C1, C2)
where\n T: 'a,\n C0: TreeNodeContainer<'a, T>,\n C1: TreeNodeContainer<'a, T>,\n C2: TreeNodeContainer<'a, T>,

§

fn apply_elements<F>(\n &'a self,\n f: F,\n) -> Result<TreeNodeRecursion, DataFusionError>
where\n F: FnMut(&'a T) -> Result<TreeNodeRecursion, DataFusionError>,

Applies f to all elements of the container.\nThis method is usually called from [TreeNode::apply_children] implementations as\na node is actually a container of the node’s children.
§

fn map_elements<F>(\n self,\n f: F,\n) -> Result<Transformed<(C0, C1, C2)>, DataFusionError>
where\n F: FnMut(T) -> Result<Transformed<T>, DataFusionError>,

Maps all elements of the container with f.\nThis method is usually called from [TreeNode::map_children] implementations as\na node is actually a container of the node’s children.
","TreeNodeContainer<'a, T>","flow::repr::DiffRow","flow::repr::KeyValDiffRow"],["
§

impl<Input, A, B, C, Error, FnA, FnB, FnC> Tuple<Input, (A, B, C), Error> for (FnA, FnB, FnC)
where\n Input: Clone,\n Error: ParseError<Input>,\n FnA: Parser<Input, A, Error>,\n FnB: Parser<Input, B, Error>,\n FnC: Parser<Input, C, Error>,

§

fn parse(&mut self, input: Input) -> Result<(Input, (A, B, C)), Err<Error>>

Parses the input and returns a tuple of results of each parser.
","Tuple","flow::repr::DiffRow","flow::repr::KeyValDiffRow"],["
§

impl<Input, A, B, C, Error, FnA, FnB, FnC> Tuple<Input, (A, B, C), Error> for (FnA, FnB, FnC)
where\n Input: Clone,\n Error: ParseError<Input>,\n FnA: Parser<Input, Output = A, Error = Error>,\n FnB: Parser<Input, Output = B, Error = Error>,\n FnC: Parser<Input, Output = C, Error = Error>,

§

fn parse_tuple(\n &mut self,\n input: Input,\n) -> Result<(Input, (A, B, C)), Err<Error>>

👎Deprecated since 8.0.0: Parser is directly implemented for tuples
Parses the input and returns a tuple of results of each parser.
","Tuple","flow::repr::DiffRow","flow::repr::KeyValDiffRow"],["
§

impl<T1, T2, T3> Type<Postgres> for (T1, T2, T3)

§

fn type_info() -> PgTypeInfo

Returns the canonical SQL type for this Rust type. Read more
§

fn compatible(ty: &<DB as Database>::TypeInfo) -> bool

Determines if this Rust type is compatible with the given SQL type. Read more
","Type","flow::repr::DiffRow","flow::repr::KeyValDiffRow"],["
§

impl<A, B, C> UnsizedCopy for (A, B, C)
where\n A: Copy,\n B: Copy,\n C: UnsizedCopy + ?Sized,

§

type Alignment = (A, B, <C as UnsizedCopy>::Alignment)

A type with the same alignment as Self. Read more
§

fn ptr_with_addr(&self, addr: *const ()) -> *const (A, B, C)

Change the address of a pointer to Self. Read more
§

fn unsized_copy_into<T>(&self) -> T
where\n T: UnsizedCopyFrom<Source = Self>,

Copy self into a new container. Read more
§

fn copy(&self) -> Self
where\n Self: Sized,

Copy self and return it by value. Read more
","UnsizedCopy","flow::repr::DiffRow","flow::repr::KeyValDiffRow"],["
§

impl<T2, T1, T0> Values for (T2, T1, T0)
where\n T2: Values,\n T1: Values,\n T0: Values,

§

fn encoded_len(&self, mode: Mode) -> usize

Returns the length of the encoded values for the given mode.
§

fn write_encoded<W>(&self, mode: Mode, target: &mut W) -> Result<(), Error>
where\n W: Write,

Encodes the values in the given mode and writes them to target.
§

fn explicit(self, tag: Tag) -> Constructed<Self>
where\n Self: Sized,

Converts the encoder into one with an explicit tag.
§

fn to_captured(&self, mode: Mode) -> Captured

Captures the encoded values in the given mode.
","Values","flow::repr::DiffRow","flow::repr::KeyValDiffRow"],["
§

impl<'a, A, B, C, AE, BE, CE, Format> ZeroFrom<'a, Tuple3VarULE<A, B, C, Format>> for (AE, BE, CE)
where\n A: VarULE + ?Sized,\n B: VarULE + ?Sized,\n C: VarULE + ?Sized,\n AE: ZeroFrom<'a, A>,\n BE: ZeroFrom<'a, B>,\n CE: ZeroFrom<'a, C>,\n Format: VarZeroVecFormat,

§

fn zero_from(other: &'a Tuple3VarULE<A, B, C, Format>) -> (AE, BE, CE)

Clone the other C into a struct that may retain references into C.
","ZeroFrom<'a, Tuple3VarULE>","flow::repr::DiffRow","flow::repr::KeyValDiffRow"],["
§

impl<'zf, C1, T1, C2, T2, C3, T3> ZeroFrom<'zf, (C1, C2, C3)> for (T1, T2, T3)
where\n T1: ZeroFrom<'zf, C1>,\n T2: ZeroFrom<'zf, C2>,\n T3: ZeroFrom<'zf, C3>,

§

fn zero_from(other: &'zf (C1, C2, C3)) -> (T1, T2, T3)

Clone the other C into a struct that may retain references into C.
","ZeroFrom<'zf, (C1, C2, C3)>","flow::repr::DiffRow","flow::repr::KeyValDiffRow"],["
§

impl<'a, A, B, C> ZeroMapKV<'a> for (A, B, C)
where\n A: Ord + AsULE + 'static,\n B: Ord + AsULE + 'static,\n C: Ord + AsULE + 'static,

§

type Container = ZeroVec<'a, (A, B, C)>

The container that can be used with this type: [ZeroVec] or [VarZeroVec].
§

type Slice = ZeroSlice<(A, B, C)>

§

type GetType = Tuple3ULE<<A as AsULE>::ULE, <B as AsULE>::ULE, <C as AsULE>::ULE>

The type produced by Container::get() Read more
§

type OwnedType = (A, B, C)

The type produced by Container::replace() and Container::remove(),\nalso used during deserialization. If Self is human readable serialized,\ndeserializing to Self::OwnedType should produce the same value once\npassed through Self::owned_as_self() Read more
","ZeroMapKV<'a>","flow::repr::DiffRow","flow::repr::KeyValDiffRow"],["
§

impl<A, B, C> Zeroable for (A, B, C)
where\n A: Zeroable,\n B: Zeroable,\n C: Zeroable,

§

fn zeroed() -> Self

","Zeroable","flow::repr::DiffRow","flow::repr::KeyValDiffRow"],["
§

impl<A, B, C> Zeroize for (A, B, C)
where\n A: Zeroize,\n B: Zeroize,\n C: Zeroize,

§

fn zeroize(&mut self)

Zero out this object from memory using Rust intrinsics which ensure the\nzeroization operation is not “optimized away” by the compiler.
","Zeroize","flow::repr::DiffRow","flow::repr::KeyValDiffRow"],["
§

impl<A, B, C> ZeroizeOnDrop for (A, B, C)
where\n A: ZeroizeOnDrop,\n B: ZeroizeOnDrop,\n C: ZeroizeOnDrop,

","ZeroizeOnDrop","flow::repr::DiffRow","flow::repr::KeyValDiffRow"]]],["mito2",[["
§

impl<I, Output, Error, Alt2, Alt3> Alt<I, Output, Error> for (Alt2, Alt3)
where\n I: Stream,\n Error: ParserError<I>,\n Alt2: Parser<I, Output, Error>,\n Alt3: Parser<I, Output, Error>,

§

fn choice(&mut self, input: &mut I) -> Result<Output, Error>

Tests each parser in the tuple and returns the result of the first one that succeeds
","Alt","mito2::sst::file::FileTimeRange"],["
§

impl<I, Output, Error, Alt2, Alt3, Alt4, Alt5> Alt<I, Output, Error> for (Alt2, Alt3, Alt4, Alt5)
where\n I: Stream,\n Error: ParserError<I>,\n Alt2: Parser<I, Output, Error>,\n Alt3: Parser<I, Output, Error>,\n Alt4: Parser<I, Output, Error>,\n Alt5: Parser<I, Output, Error>,

§

fn choice(&mut self, input: &mut I) -> Result<Output, Error>

Tests each parser in the tuple and returns the result of the first one that succeeds
","Alt","mito2::cache::index::bloom_filter_index::BloomFilterIndexKey"],["
§

impl<Input, Output, Error, A, B> Alt<Input, Output, Error> for (A, B)
where\n Input: Clone,\n Error: ParseError<Input>,\n A: Parser<Input, Output, Error>,\n B: Parser<Input, Output, Error>,

§

fn choice(&mut self, input: Input) -> Result<(Input, Output), Err<Error>>

Tests each parser in the tuple and returns the result of the first one that succeeds
","Alt","mito2::sst::file::FileTimeRange"],["
§

impl<Input, Output, Error, A, B, C, D> Alt<Input, Output, Error> for (A, B, C, D)
where\n Input: Clone,\n Error: ParseError<Input>,\n A: Parser<Input, Output, Error>,\n B: Parser<Input, Output, Error>,\n C: Parser<Input, Output, Error>,\n D: Parser<Input, Output, Error>,

§

fn choice(&mut self, input: Input) -> Result<(Input, Output), Err<Error>>

Tests each parser in the tuple and returns the result of the first one that succeeds
","Alt","mito2::cache::index::bloom_filter_index::BloomFilterIndexKey"],["
§

impl<A, B> AsULE for (A, B)
where\n A: AsULE,\n B: AsULE,

§

type ULE = Tuple2ULE<<A as AsULE>::ULE, <B as AsULE>::ULE>

The ULE type corresponding to Self. Read more
§

fn to_unaligned(self) -> <(A, B) as AsULE>::ULE

Converts from Self to Self::ULE. Read more
§

fn from_unaligned(unaligned: <(A, B) as AsULE>::ULE) -> (A, B)

Converts from Self::ULE to Self. Read more
","AsULE","mito2::sst::file::FileTimeRange"],["
§

impl<A, B, C, D> AsULE for (A, B, C, D)
where\n A: AsULE,\n B: AsULE,\n C: AsULE,\n D: AsULE,

§

type ULE = Tuple4ULE<<A as AsULE>::ULE, <B as AsULE>::ULE, <C as AsULE>::ULE, <D as AsULE>::ULE>

The ULE type corresponding to Self. Read more
§

fn to_unaligned(self) -> <(A, B, C, D) as AsULE>::ULE

Converts from Self to Self::ULE. Read more
§

fn from_unaligned(unaligned: <(A, B, C, D) as AsULE>::ULE) -> (A, B, C, D)

Converts from Self::ULE to Self. Read more
","AsULE","mito2::cache::index::bloom_filter_index::BloomFilterIndexKey"],["
§

impl<A, B> AssertFloatEq for (A, B)
where\n A: AssertFloatEq + Debug,\n B: AssertFloatEq + Debug + ?Sized,\n <A as FloatEq>::Tol: Sized,\n <B as FloatEq>::Tol: Sized,\n <A as AssertFloatEq>::DebugTol: Sized,\n <B as AssertFloatEq>::DebugTol: Sized,\n <<A as FloatEq>::Tol as FloatEqUlpsTol>::UlpsTol: Sized,\n <<B as FloatEq>::Tol as FloatEqUlpsTol>::UlpsTol: Sized,\n <<A as AssertFloatEq>::DebugTol as FloatEqUlpsTol>::UlpsTol: Sized,\n <<B as AssertFloatEq>::DebugTol as FloatEqUlpsTol>::UlpsTol: Sized,

§

type DebugAbsDiff = (<A as AssertFloatEq>::DebugAbsDiff, <B as AssertFloatEq>::DebugAbsDiff)

The absolute difference between two values, displayed to the user via\nfmt::Debug when an assert fails. Read more
§

type DebugTol = (<A as AssertFloatEq>::DebugTol, <B as AssertFloatEq>::DebugTol)

The per-field tolerance value used for comparison between two values,\ndisplayed to the user via fmt::Debug when an assert fails. Read more
§

fn debug_abs_diff(\n &self,\n other: &(A, B),\n) -> <(A, B) as AssertFloatEq>::DebugAbsDiff

Always positive absolute difference between two values. Read more
§

fn debug_ulps_diff(\n &self,\n other: &(A, B),\n) -> <<(A, B) as AssertFloatEq>::DebugAbsDiff as FloatEqDebugUlpsDiff>::DebugUlpsDiff

Always positive absolute difference between two values in terms of ULPs. Read more
§

fn debug_abs_tol(\n &self,\n other: &(A, B),\n tol: &<(A, B) as FloatEq>::Tol,\n) -> <(A, B) as AssertFloatEq>::DebugTol

The tolerance used by an abs comparison, displayed when an assert fails.
§

fn debug_rmax_tol(\n &self,\n other: &(A, B),\n tol: &<(A, B) as FloatEq>::Tol,\n) -> <(A, B) as AssertFloatEq>::DebugTol

The tolerance used by an rmax comparison, displayed when an assert fails. Read more
§

fn debug_rmin_tol(\n &self,\n other: &(A, B),\n tol: &<(A, B) as FloatEq>::Tol,\n) -> <(A, B) as AssertFloatEq>::DebugTol

The tolerance used by an rmin comparison, displayed when an assert fails. Read more
§

fn debug_r1st_tol(\n &self,\n other: &(A, B),\n tol: &<(A, B) as FloatEq>::Tol,\n) -> <(A, B) as AssertFloatEq>::DebugTol

The tolerance used by an r1st comparison, displayed when an assert fails. Read more
§

fn debug_r2nd_tol(\n &self,\n other: &(A, B),\n tol: &<(A, B) as FloatEq>::Tol,\n) -> <(A, B) as AssertFloatEq>::DebugTol

The tolerance used by an r2nd comparison, displayed when an assert fails. Read more
§

fn debug_ulps_tol(\n &self,\n other: &(A, B),\n tol: &<<(A, B) as FloatEq>::Tol as FloatEqUlpsTol>::UlpsTol,\n) -> <<(A, B) as AssertFloatEq>::DebugTol as FloatEqUlpsTol>::UlpsTol

The tolerance used by an ulps comparison, displayed when an assert fails.
§

fn debug_rel_tol(&self, other: &Rhs, tol: &Self::Tol) -> Self::DebugTol

The tolerance used by a rel comparison, displayed when an assert fails. Read more
","AssertFloatEq","mito2::sst::file::FileTimeRange"],["
§

impl<A, B, C, D> AssertFloatEq for (A, B, C, D)
where\n A: AssertFloatEq + Debug,\n B: AssertFloatEq + Debug,\n C: AssertFloatEq + Debug,\n D: AssertFloatEq + Debug + ?Sized,\n <A as FloatEq>::Tol: Sized,\n <B as FloatEq>::Tol: Sized,\n <C as FloatEq>::Tol: Sized,\n <D as FloatEq>::Tol: Sized,\n <A as AssertFloatEq>::DebugTol: Sized,\n <B as AssertFloatEq>::DebugTol: Sized,\n <C as AssertFloatEq>::DebugTol: Sized,\n <D as AssertFloatEq>::DebugTol: Sized,\n <<A as FloatEq>::Tol as FloatEqUlpsTol>::UlpsTol: Sized,\n <<B as FloatEq>::Tol as FloatEqUlpsTol>::UlpsTol: Sized,\n <<C as FloatEq>::Tol as FloatEqUlpsTol>::UlpsTol: Sized,\n <<D as FloatEq>::Tol as FloatEqUlpsTol>::UlpsTol: Sized,\n <<A as AssertFloatEq>::DebugTol as FloatEqUlpsTol>::UlpsTol: Sized,\n <<B as AssertFloatEq>::DebugTol as FloatEqUlpsTol>::UlpsTol: Sized,\n <<C as AssertFloatEq>::DebugTol as FloatEqUlpsTol>::UlpsTol: Sized,\n <<D as AssertFloatEq>::DebugTol as FloatEqUlpsTol>::UlpsTol: Sized,

§

type DebugAbsDiff = (<A as AssertFloatEq>::DebugAbsDiff, <B as AssertFloatEq>::DebugAbsDiff, <C as AssertFloatEq>::DebugAbsDiff, <D as AssertFloatEq>::DebugAbsDiff)

The absolute difference between two values, displayed to the user via\nfmt::Debug when an assert fails. Read more
§

type DebugTol = (<A as AssertFloatEq>::DebugTol, <B as AssertFloatEq>::DebugTol, <C as AssertFloatEq>::DebugTol, <D as AssertFloatEq>::DebugTol)

The per-field tolerance value used for comparison between two values,\ndisplayed to the user via fmt::Debug when an assert fails. Read more
§

fn debug_abs_diff(\n &self,\n other: &(A, B, C, D),\n) -> <(A, B, C, D) as AssertFloatEq>::DebugAbsDiff

Always positive absolute difference between two values. Read more
§

fn debug_ulps_diff(\n &self,\n other: &(A, B, C, D),\n) -> <<(A, B, C, D) as AssertFloatEq>::DebugAbsDiff as FloatEqDebugUlpsDiff>::DebugUlpsDiff

Always positive absolute difference between two values in terms of ULPs. Read more
§

fn debug_abs_tol(\n &self,\n other: &(A, B, C, D),\n tol: &<(A, B, C, D) as FloatEq>::Tol,\n) -> <(A, B, C, D) as AssertFloatEq>::DebugTol

The tolerance used by an abs comparison, displayed when an assert fails.
§

fn debug_rmax_tol(\n &self,\n other: &(A, B, C, D),\n tol: &<(A, B, C, D) as FloatEq>::Tol,\n) -> <(A, B, C, D) as AssertFloatEq>::DebugTol

The tolerance used by an rmax comparison, displayed when an assert fails. Read more
§

fn debug_rmin_tol(\n &self,\n other: &(A, B, C, D),\n tol: &<(A, B, C, D) as FloatEq>::Tol,\n) -> <(A, B, C, D) as AssertFloatEq>::DebugTol

The tolerance used by an rmin comparison, displayed when an assert fails. Read more
§

fn debug_r1st_tol(\n &self,\n other: &(A, B, C, D),\n tol: &<(A, B, C, D) as FloatEq>::Tol,\n) -> <(A, B, C, D) as AssertFloatEq>::DebugTol

The tolerance used by an r1st comparison, displayed when an assert fails. Read more
§

fn debug_r2nd_tol(\n &self,\n other: &(A, B, C, D),\n tol: &<(A, B, C, D) as FloatEq>::Tol,\n) -> <(A, B, C, D) as AssertFloatEq>::DebugTol

The tolerance used by an r2nd comparison, displayed when an assert fails. Read more
§

fn debug_ulps_tol(\n &self,\n other: &(A, B, C, D),\n tol: &<<(A, B, C, D) as FloatEq>::Tol as FloatEqUlpsTol>::UlpsTol,\n) -> <<(A, B, C, D) as AssertFloatEq>::DebugTol as FloatEqUlpsTol>::UlpsTol

The tolerance used by an ulps comparison, displayed when an assert fails.
§

fn debug_rel_tol(&self, other: &Rhs, tol: &Self::Tol) -> Self::DebugTol

The tolerance used by a rel comparison, displayed when an assert fails. Read more
","AssertFloatEq","mito2::cache::index::bloom_filter_index::BloomFilterIndexKey"],["
§

impl<Left, Right> BinarySerializable for (Left, Right)
where\n Left: BinarySerializable,\n Right: BinarySerializable,

§

fn serialize<W>(&self, write: &mut W) -> Result<(), Error>
where\n W: Write + ?Sized,

Serialize
§

fn deserialize<R>(reader: &mut R) -> Result<(Left, Right), Error>
where\n R: Read,

Deserialize
§

fn num_bytes(&self) -> u64

","BinarySerializable","mito2::sst::file::FileTimeRange"],["
Source§

impl<Q, R, S, T> Bounded for (Q, R, S, T)
where\n Q: Bounded,\n R: Bounded,\n S: Bounded,\n T: Bounded,

Source§

fn min_value() -> (Q, R, S, T)

Returns the smallest finite number this type can represent
Source§

fn max_value() -> (Q, R, S, T)

Returns the largest finite number this type can represent
","Bounded","mito2::cache::index::bloom_filter_index::BloomFilterIndexKey"],["
Source§

impl<S, T> Bounded for (S, T)
where\n S: Bounded,\n T: Bounded,

Source§

fn min_value() -> (S, T)

Returns the smallest finite number this type can represent
Source§

fn max_value() -> (S, T)

Returns the largest finite number this type can represent
","Bounded","mito2::sst::file::FileTimeRange"],["
§

impl<Left, Right> Collector for (Left, Right)
where\n Left: Collector,\n Right: Collector,

§

type Fruit = (<Left as Collector>::Fruit, <Right as Collector>::Fruit)

Fruit is the type for the result of our collection.\ne.g. usize for the Count collector.
§

type Child = (<Left as Collector>::Child, <Right as Collector>::Child)

Type of the SegmentCollector associated with this collector.
§

fn for_segment(\n &self,\n segment_local_id: u32,\n segment: &SegmentReader,\n) -> Result<<(Left, Right) as Collector>::Child, TantivyError>

set_segment is called before beginning to enumerate\non this segment.
§

fn requires_scoring(&self) -> bool

Returns true iff the collector requires to compute scores for documents.
§

fn merge_fruits(\n &self,\n segment_fruits: Vec<<<(Left, Right) as Collector>::Child as SegmentCollector>::Fruit>,\n) -> Result<(<Left as Collector>::Fruit, <Right as Collector>::Fruit), TantivyError>

Combines the fruit associated with the collection of each segments\ninto one fruit.
§

fn collect_segment(\n &self,\n weight: &(dyn Weight + 'static),\n segment_ord: u32,\n reader: &SegmentReader,\n) -> Result<<Self::Child as SegmentCollector>::Fruit, TantivyError>

Created a segment collector and
","Collector","mito2::sst::file::FileTimeRange"],["
§

impl<One, Two, Three, Four> Collector for (One, Two, Three, Four)
where\n One: Collector,\n Two: Collector,\n Three: Collector,\n Four: Collector,

§

type Fruit = (<One as Collector>::Fruit, <Two as Collector>::Fruit, <Three as Collector>::Fruit, <Four as Collector>::Fruit)

Fruit is the type for the result of our collection.\ne.g. usize for the Count collector.
§

type Child = (<One as Collector>::Child, <Two as Collector>::Child, <Three as Collector>::Child, <Four as Collector>::Child)

Type of the SegmentCollector associated with this collector.
§

fn for_segment(\n &self,\n segment_local_id: u32,\n segment: &SegmentReader,\n) -> Result<<(One, Two, Three, Four) as Collector>::Child, TantivyError>

set_segment is called before beginning to enumerate\non this segment.
§

fn requires_scoring(&self) -> bool

Returns true iff the collector requires to compute scores for documents.
§

fn merge_fruits(\n &self,\n children: Vec<<<(One, Two, Three, Four) as Collector>::Child as SegmentCollector>::Fruit>,\n) -> Result<<(One, Two, Three, Four) as Collector>::Fruit, TantivyError>

Combines the fruit associated with the collection of each segments\ninto one fruit.
§

fn collect_segment(\n &self,\n weight: &(dyn Weight + 'static),\n segment_ord: u32,\n reader: &SegmentReader,\n) -> Result<<Self::Child as SegmentCollector>::Fruit, TantivyError>

Created a segment collector and
","Collector","mito2::cache::index::bloom_filter_index::BloomFilterIndexKey"],["
§

impl<T, F1, F2> ContainsToken<T> for (F1, F2)
where\n T: Clone,\n F1: ContainsToken<T>,\n F2: ContainsToken<T>,

§

fn contains_token(&self, token: T) -> bool

Returns true if self contains the token
","ContainsToken","mito2::sst::file::FileTimeRange"],["
§

impl<T, F1, F2, F3, F4> ContainsToken<T> for (F1, F2, F3, F4)
where\n T: Clone,\n F1: ContainsToken<T>,\n F2: ContainsToken<T>,\n F3: ContainsToken<T>,\n F4: ContainsToken<T>,

§

fn contains_token(&self, token: T) -> bool

Returns true if self contains the token
","ContainsToken","mito2::cache::index::bloom_filter_index::BloomFilterIndexKey"],["
§

impl<'r, T1, T2> Decode<'r, Postgres> for (T1, T2)
where\n T1: 'r + Type<Postgres> + for<'a> Decode<'a, Postgres>,\n T2: 'r + Type<Postgres> + for<'a> Decode<'a, Postgres>,

§

fn decode(\n value: PgValueRef<'r>,\n) -> Result<(T1, T2), Box<dyn Error + Sync + Send>>

Decode a new value of this type using a raw value from the database.
","Decode<'r, Postgres>","mito2::sst::file::FileTimeRange"],["
§

impl<'r, T1, T2, T3, T4> Decode<'r, Postgres> for (T1, T2, T3, T4)
where\n T1: 'r + Type<Postgres> + for<'a> Decode<'a, Postgres>,\n T2: 'r + Type<Postgres> + for<'a> Decode<'a, Postgres>,\n T3: 'r + Type<Postgres> + for<'a> Decode<'a, Postgres>,\n T4: 'r + Type<Postgres> + for<'a> Decode<'a, Postgres>,

§

fn decode(\n value: PgValueRef<'r>,\n) -> Result<(T1, T2, T3, T4), Box<dyn Error + Sync + Send>>

Decode a new value of this type using a raw value from the database.
","Decode<'r, Postgres>","mito2::cache::index::bloom_filter_index::BloomFilterIndexKey"],["
Source§

impl<'de, T0, T1> Deserialize<'de> for (T0, T1)
where\n T0: Deserialize<'de>,\n T1: Deserialize<'de>,

Source§

fn deserialize<D>(\n deserializer: D,\n) -> Result<(T0, T1), <D as Deserializer<'de>>::Error>
where\n D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer. Read more
","Deserialize<'de>","mito2::sst::file::FileTimeRange"],["
Source§

impl<'de, T0, T1, T2, T3> Deserialize<'de> for (T0, T1, T2, T3)
where\n T0: Deserialize<'de>,\n T1: Deserialize<'de>,\n T2: Deserialize<'de>,\n T3: Deserialize<'de>,

Source§

fn deserialize<D>(\n deserializer: D,\n) -> Result<(T0, T1, T2, T3), <D as Deserializer<'de>>::Error>
where\n D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer. Read more
","Deserialize<'de>","mito2::cache::index::bloom_filter_index::BloomFilterIndexKey"],["
Source§

impl<'de, T0, As0, T1, As1> DeserializeAs<'de, (T0, T1)> for (As0, As1)
where\n As0: DeserializeAs<'de, T0>,\n As1: DeserializeAs<'de, T1>,

Source§

fn deserialize_as<D>(\n deserializer: D,\n) -> Result<(T0, T1), <D as Deserializer<'de>>::Error>
where\n D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.
","DeserializeAs<'de, (T0, T1)>","mito2::sst::file::FileTimeRange"],["
Source§

impl<'de, T0, As0, T1, As1, T2, As2, T3, As3> DeserializeAs<'de, (T0, T1, T2, T3)> for (As0, As1, As2, As3)
where\n As0: DeserializeAs<'de, T0>,\n As1: DeserializeAs<'de, T1>,\n As2: DeserializeAs<'de, T2>,\n As3: DeserializeAs<'de, T3>,

Source§

fn deserialize_as<D>(\n deserializer: D,\n) -> Result<(T0, T1, T2, T3), <D as Deserializer<'de>>::Error>
where\n D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.
","DeserializeAs<'de, (T0, T1, T2, T3)>","mito2::cache::index::bloom_filter_index::BloomFilterIndexKey"],["
§

impl<A, B, AE, BE, Format> EncodeAsVarULE<Tuple2VarULE<A, B, Format>> for (AE, BE)
where\n A: VarULE + ?Sized,\n B: VarULE + ?Sized,\n AE: EncodeAsVarULE<A>,\n BE: EncodeAsVarULE<B>,\n Format: VarZeroVecFormat,

§

fn encode_var_ule_as_slices<R>(&self, _: impl FnOnce(&[&[u8]]) -> R) -> R

Calls cb with a piecewise list of byte slices that when concatenated\nproduce the memory pattern of the corresponding instance of T. Read more
§

fn encode_var_ule_len(&self) -> usize

Return the length, in bytes, of the corresponding [VarULE] type
§

fn encode_var_ule_write(&self, dst: &mut [u8])

Write the corresponding [VarULE] type to the dst buffer. dst should\nbe the size of [Self::encode_var_ule_len()]
","EncodeAsVarULE>","mito2::sst::file::FileTimeRange"],["
§

impl<A, B, C, D, AE, BE, CE, DE, Format> EncodeAsVarULE<Tuple4VarULE<A, B, C, D, Format>> for (AE, BE, CE, DE)
where\n A: VarULE + ?Sized,\n B: VarULE + ?Sized,\n C: VarULE + ?Sized,\n D: VarULE + ?Sized,\n AE: EncodeAsVarULE<A>,\n BE: EncodeAsVarULE<B>,\n CE: EncodeAsVarULE<C>,\n DE: EncodeAsVarULE<D>,\n Format: VarZeroVecFormat,

§

fn encode_var_ule_as_slices<R>(&self, _: impl FnOnce(&[&[u8]]) -> R) -> R

Calls cb with a piecewise list of byte slices that when concatenated\nproduce the memory pattern of the corresponding instance of T. Read more
§

fn encode_var_ule_len(&self) -> usize

Return the length, in bytes, of the corresponding [VarULE] type
§

fn encode_var_ule_write(&self, dst: &mut [u8])

Write the corresponding [VarULE] type to the dst buffer. dst should\nbe the size of [Self::encode_var_ule_len()]
","EncodeAsVarULE>","mito2::cache::index::bloom_filter_index::BloomFilterIndexKey"],["
§

impl<Left, Right> FixedSize for (Left, Right)
where\n Left: BinarySerializable + FixedSize,\n Right: BinarySerializable + FixedSize,

","FixedSize","mito2::sst::file::FileTimeRange"],["
§

impl<A, B> FloatEq for (A, B)
where\n A: FloatEq,\n B: FloatEq + ?Sized,\n <A as FloatEq>::Tol: Sized,\n <B as FloatEq>::Tol: Sized,\n <<A as FloatEq>::Tol as FloatEqUlpsTol>::UlpsTol: Sized,\n <<B as FloatEq>::Tol as FloatEqUlpsTol>::UlpsTol: Sized,

§

type Tol = (<A as FloatEq>::Tol, <B as FloatEq>::Tol)

Type of the maximum allowed difference between two values for them to be\nconsidered equal.
§

fn eq_abs(&self, other: &(A, B), tol: &<(A, B) as FloatEq>::Tol) -> bool

Check whether self is equal to other, using an absolute tolerance\ncomparison. Read more
§

fn eq_rmax(&self, other: &(A, B), tol: &<(A, B) as FloatEq>::Tol) -> bool

Check whether self is equal to other, using a relative tolerance\ncomparison, scaled to the granularity of the input with the largest\nmagnitude. Read more
§

fn eq_rmin(&self, other: &(A, B), tol: &<(A, B) as FloatEq>::Tol) -> bool

Check whether self is equal to other, using a relative tolerance\ncomparison, scaled to the granularity of the input with the smallest\nmagnitude. Read more
§

fn eq_r1st(&self, other: &(A, B), tol: &<(A, B) as FloatEq>::Tol) -> bool

Check whether self is equal to other, using a relative tolerance\ncomparison, scaled to the granularity of the first input. Read more
§

fn eq_r2nd(&self, other: &(A, B), tol: &<(A, B) as FloatEq>::Tol) -> bool

Check whether self is equal to other, using a relative tolerance\ncomparison, scaled to the granularity of the second input. Read more
§

fn eq_ulps(\n &self,\n other: &(A, B),\n tol: &<<(A, B) as FloatEq>::Tol as FloatEqUlpsTol>::UlpsTol,\n) -> bool

Check whether self is equal to other, using an ULPs comparison. Read more
§

fn ne_abs(&self, other: &Rhs, tol: &Self::Tol) -> bool

Check whether self is not equal to other, using an absolute tolerance\ncomparison. Read more
§

fn eq_rel(&self, other: &Rhs, tol: &Self::Tol) -> bool

Check whether self is equal to other, using a relative tolerance\ncomparison. Read more
§

fn ne_rel(&self, other: &Rhs, tol: &Self::Tol) -> bool

Check whether self is not equal to other, using a relative tolerance\ncomparison. Read more
§

fn ne_rmax(&self, other: &Rhs, tol: &Self::Tol) -> bool

Check whether self is not equal to other, using a relative tolerance\ncomparison. Read more
§

fn ne_rmin(&self, other: &Rhs, tol: &Self::Tol) -> bool

Check whether self is not equal to other, using a relative tolerance\ncomparison. Read more
§

fn ne_r1st(&self, other: &Rhs, tol: &Self::Tol) -> bool

Check whether self is not equal to other, using a relative tolerance\ncomparison. Read more
§

fn ne_r2nd(&self, other: &Rhs, tol: &Self::Tol) -> bool

Check whether self is not equal to other, using a relative tolerance\ncomparison. Read more
§

fn ne_ulps(\n &self,\n other: &Rhs,\n tol: &<Self::Tol as FloatEqUlpsTol>::UlpsTol,\n) -> bool

Check whether self is not equal to other, using an ULPs comparison. Read more
","FloatEq","mito2::sst::file::FileTimeRange"],["
§

impl<A, B, C, D> FloatEq for (A, B, C, D)
where\n A: FloatEq,\n B: FloatEq,\n C: FloatEq,\n D: FloatEq + ?Sized,\n <A as FloatEq>::Tol: Sized,\n <B as FloatEq>::Tol: Sized,\n <C as FloatEq>::Tol: Sized,\n <D as FloatEq>::Tol: Sized,\n <<A as FloatEq>::Tol as FloatEqUlpsTol>::UlpsTol: Sized,\n <<B as FloatEq>::Tol as FloatEqUlpsTol>::UlpsTol: Sized,\n <<C as FloatEq>::Tol as FloatEqUlpsTol>::UlpsTol: Sized,\n <<D as FloatEq>::Tol as FloatEqUlpsTol>::UlpsTol: Sized,

§

type Tol = (<A as FloatEq>::Tol, <B as FloatEq>::Tol, <C as FloatEq>::Tol, <D as FloatEq>::Tol)

Type of the maximum allowed difference between two values for them to be\nconsidered equal.
§

fn eq_abs(\n &self,\n other: &(A, B, C, D),\n tol: &<(A, B, C, D) as FloatEq>::Tol,\n) -> bool

Check whether self is equal to other, using an absolute tolerance\ncomparison. Read more
§

fn eq_rmax(\n &self,\n other: &(A, B, C, D),\n tol: &<(A, B, C, D) as FloatEq>::Tol,\n) -> bool

Check whether self is equal to other, using a relative tolerance\ncomparison, scaled to the granularity of the input with the largest\nmagnitude. Read more
§

fn eq_rmin(\n &self,\n other: &(A, B, C, D),\n tol: &<(A, B, C, D) as FloatEq>::Tol,\n) -> bool

Check whether self is equal to other, using a relative tolerance\ncomparison, scaled to the granularity of the input with the smallest\nmagnitude. Read more
§

fn eq_r1st(\n &self,\n other: &(A, B, C, D),\n tol: &<(A, B, C, D) as FloatEq>::Tol,\n) -> bool

Check whether self is equal to other, using a relative tolerance\ncomparison, scaled to the granularity of the first input. Read more
§

fn eq_r2nd(\n &self,\n other: &(A, B, C, D),\n tol: &<(A, B, C, D) as FloatEq>::Tol,\n) -> bool

Check whether self is equal to other, using a relative tolerance\ncomparison, scaled to the granularity of the second input. Read more
§

fn eq_ulps(\n &self,\n other: &(A, B, C, D),\n tol: &<<(A, B, C, D) as FloatEq>::Tol as FloatEqUlpsTol>::UlpsTol,\n) -> bool

Check whether self is equal to other, using an ULPs comparison. Read more
§

fn ne_abs(&self, other: &Rhs, tol: &Self::Tol) -> bool

Check whether self is not equal to other, using an absolute tolerance\ncomparison. Read more
§

fn eq_rel(&self, other: &Rhs, tol: &Self::Tol) -> bool

Check whether self is equal to other, using a relative tolerance\ncomparison. Read more
§

fn ne_rel(&self, other: &Rhs, tol: &Self::Tol) -> bool

Check whether self is not equal to other, using a relative tolerance\ncomparison. Read more
§

fn ne_rmax(&self, other: &Rhs, tol: &Self::Tol) -> bool

Check whether self is not equal to other, using a relative tolerance\ncomparison. Read more
§

fn ne_rmin(&self, other: &Rhs, tol: &Self::Tol) -> bool

Check whether self is not equal to other, using a relative tolerance\ncomparison. Read more
§

fn ne_r1st(&self, other: &Rhs, tol: &Self::Tol) -> bool

Check whether self is not equal to other, using a relative tolerance\ncomparison. Read more
§

fn ne_r2nd(&self, other: &Rhs, tol: &Self::Tol) -> bool

Check whether self is not equal to other, using a relative tolerance\ncomparison. Read more
§

fn ne_ulps(\n &self,\n other: &Rhs,\n tol: &<Self::Tol as FloatEqUlpsTol>::UlpsTol,\n) -> bool

Check whether self is not equal to other, using an ULPs comparison. Read more
","FloatEq","mito2::cache::index::bloom_filter_index::BloomFilterIndexKey"],["
§

impl<A, B> FloatEqDebugUlpsDiff for (A, B)
where\n A: FloatEqDebugUlpsDiff,\n B: FloatEqDebugUlpsDiff,

§

type DebugUlpsDiff = (<A as FloatEqDebugUlpsDiff>::DebugUlpsDiff, <B as FloatEqDebugUlpsDiff>::DebugUlpsDiff)

A structurally identical type to Self, with fields recursively wrapped\nby DebugUlpsDiff.
","FloatEqDebugUlpsDiff","mito2::sst::file::FileTimeRange"],["
§

impl<A, B, C, D> FloatEqDebugUlpsDiff for (A, B, C, D)
where\n A: FloatEqDebugUlpsDiff,\n B: FloatEqDebugUlpsDiff,\n C: FloatEqDebugUlpsDiff,\n D: FloatEqDebugUlpsDiff,

§

type DebugUlpsDiff = (<A as FloatEqDebugUlpsDiff>::DebugUlpsDiff, <B as FloatEqDebugUlpsDiff>::DebugUlpsDiff, <C as FloatEqDebugUlpsDiff>::DebugUlpsDiff, <D as FloatEqDebugUlpsDiff>::DebugUlpsDiff)

A structurally identical type to Self, with fields recursively wrapped\nby DebugUlpsDiff.
","FloatEqDebugUlpsDiff","mito2::cache::index::bloom_filter_index::BloomFilterIndexKey"],["
§

impl<A, B> FloatEqUlpsTol for (A, B)
where\n A: FloatEqUlpsTol,\n B: FloatEqUlpsTol + ?Sized,\n <A as FloatEqUlpsTol>::UlpsTol: Sized,\n <B as FloatEqUlpsTol>::UlpsTol: Sized,

§

type UlpsTol = (<A as FloatEqUlpsTol>::UlpsTol, <B as FloatEqUlpsTol>::UlpsTol)

A structurally identical type to Self, with fields recursively wrapped\nby UlpsTol.
","FloatEqUlpsTol","mito2::sst::file::FileTimeRange"],["
§

impl<A, B, C, D> FloatEqUlpsTol for (A, B, C, D)
where\n A: FloatEqUlpsTol,\n B: FloatEqUlpsTol,\n C: FloatEqUlpsTol,\n D: FloatEqUlpsTol + ?Sized,\n <A as FloatEqUlpsTol>::UlpsTol: Sized,\n <B as FloatEqUlpsTol>::UlpsTol: Sized,\n <C as FloatEqUlpsTol>::UlpsTol: Sized,\n <D as FloatEqUlpsTol>::UlpsTol: Sized,

§

type UlpsTol = (<A as FloatEqUlpsTol>::UlpsTol, <B as FloatEqUlpsTol>::UlpsTol, <C as FloatEqUlpsTol>::UlpsTol, <D as FloatEqUlpsTol>::UlpsTol)

A structurally identical type to Self, with fields recursively wrapped\nby UlpsTol.
","FloatEqUlpsTol","mito2::cache::index::bloom_filter_index::BloomFilterIndexKey"],["
§

impl<T> From<Coord<T>> for (T, T)
where\n T: CoordNum,

§

fn from(coord: Coord<T>) -> (T, T)

Converts to this type from the input type.
","From>","mito2::sst::file::FileTimeRange"],["
§

impl<T> From<Point<T>> for (T, T)
where\n T: CoordNum,

§

fn from(point: Point<T>) -> (T, T)

Converts to this type from the input type.
","From>","mito2::sst::file::FileTimeRange"],["
§

impl<S> From<Point2<S>> for (S, S)
where\n S: SpadeNum,

§

fn from(point: Point2<S>) -> (S, S)

Converts to this type from the input type.
","From>","mito2::sst::file::FileTimeRange"],["
Source§

impl<T> From<Ratio<T>> for (T, T)

Source§

fn from(val: Ratio<T>) -> (T, T)

Converts to this type from the input type.
","From>","mito2::sst::file::FileTimeRange"],["
§

impl<A, B, FromA, FromB> FromParallelIterator<(A, B)> for (FromA, FromB)
where\n A: Send,\n B: Send,\n FromA: Send + FromParallelIterator<A>,\n FromB: Send + FromParallelIterator<B>,

§

fn from_par_iter<I>(pi: I) -> (FromA, FromB)
where\n I: IntoParallelIterator<Item = (A, B)>,

Creates an instance of the collection from the parallel iterator par_iter. Read more
","FromParallelIterator<(A, B)>","mito2::sst::file::FileTimeRange"],["
§

impl<L, R, A, B> FromParallelIterator<Either<L, R>> for (A, B)
where\n L: Send,\n R: Send,\n A: Send + FromParallelIterator<L>,\n B: Send + FromParallelIterator<R>,

§

fn from_par_iter<I>(pi: I) -> (A, B)
where\n I: IntoParallelIterator<Item = Either<L, R>>,

Creates an instance of the collection from the parallel iterator par_iter. Read more
","FromParallelIterator>","mito2::sst::file::FileTimeRange"],["
§

impl<S, T1, T2> FromRequest<S> for (T1, T2)
where\n T1: FromRequestParts<S> + Send,\n T2: FromRequest<S> + Send,\n S: Send + Sync,

§

type Rejection = Response<Body>

If the extractor fails it’ll use this “rejection” type. A rejection is\na kind of error that can be converted into a response.
§

fn from_request(\n req: Request<Body>,\n state: &S,\n) -> impl Future<Output = Result<(T1, T2), <(T1, T2) as FromRequest<S>>::Rejection>>

Perform the extraction.
","FromRequest","mito2::sst::file::FileTimeRange"],["
§

impl<S, T1, T2, T3, T4> FromRequest<S> for (T1, T2, T3, T4)
where\n T1: FromRequestParts<S> + Send,\n T2: FromRequestParts<S> + Send,\n T3: FromRequestParts<S> + Send,\n T4: FromRequest<S> + Send,\n S: Send + Sync,

§

type Rejection = Response<Body>

If the extractor fails it’ll use this “rejection” type. A rejection is\na kind of error that can be converted into a response.
§

fn from_request(\n req: Request<Body>,\n state: &S,\n) -> impl Future<Output = Result<(T1, T2, T3, T4), <(T1, T2, T3, T4) as FromRequest<S>>::Rejection>>

Perform the extraction.
","FromRequest","mito2::cache::index::bloom_filter_index::BloomFilterIndexKey"],["
§

impl<S, T1, T2> FromRequestParts<S> for (T1, T2)
where\n T1: FromRequestParts<S> + Send,\n T2: FromRequestParts<S> + Send,\n S: Send + Sync,

§

type Rejection = Response<Body>

If the extractor fails it’ll use this “rejection” type. A rejection is\na kind of error that can be converted into a response.
§

async fn from_request_parts(\n parts: &mut Parts,\n state: &S,\n) -> Result<(T1, T2), <(T1, T2) as FromRequestParts<S>>::Rejection>

Perform the extraction.
","FromRequestParts","mito2::sst::file::FileTimeRange"],["
§

impl<S, T1, T2, T3, T4> FromRequestParts<S> for (T1, T2, T3, T4)
where\n T1: FromRequestParts<S> + Send,\n T2: FromRequestParts<S> + Send,\n T3: FromRequestParts<S> + Send,\n T4: FromRequestParts<S> + Send,\n S: Send + Sync,

§

type Rejection = Response<Body>

If the extractor fails it’ll use this “rejection” type. A rejection is\na kind of error that can be converted into a response.
§

async fn from_request_parts(\n parts: &mut Parts,\n state: &S,\n) -> Result<(T1, T2, T3, T4), <(T1, T2, T3, T4) as FromRequestParts<S>>::Rejection>

Perform the extraction.
","FromRequestParts","mito2::cache::index::bloom_filter_index::BloomFilterIndexKey"],["
§

impl<'r, R, T1, T2> FromRow<'r, R> for (T1, T2)
where\n R: Row,\n usize: ColumnIndex<R>,\n T1: Decode<'r, <R as Row>::Database> + Type<<R as Row>::Database>,\n T2: Decode<'r, <R as Row>::Database> + Type<<R as Row>::Database>,

§

fn from_row(row: &'r R) -> Result<(T1, T2), Error>

","FromRow<'r, R>","mito2::sst::file::FileTimeRange"],["
§

impl<'r, R, T1, T2, T3, T4> FromRow<'r, R> for (T1, T2, T3, T4)
where\n R: Row,\n usize: ColumnIndex<R>,\n T1: Decode<'r, <R as Row>::Database> + Type<<R as Row>::Database>,\n T2: Decode<'r, <R as Row>::Database> + Type<<R as Row>::Database>,\n T3: Decode<'r, <R as Row>::Database> + Type<<R as Row>::Database>,\n T4: Decode<'r, <R as Row>::Database> + Type<<R as Row>::Database>,

","FromRow<'r, R>","mito2::cache::index::bloom_filter_index::BloomFilterIndexKey"],["
§

impl<F, Fut, Res, S> Handler<((),), S> for F
where\n F: FnOnce() -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n Res: IntoResponse,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n _req: Request<Body>,\n _state: S,\n) -> <F as Handler<((),), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<((),), S>","mito2::cache::index::bloom_filter_index::BloomFilterIndexKey","mito2::sst::file::FileTimeRange"],["
§

impl<F, Fut, S, Res, M, T1> Handler<(M, T1), S> for F
where\n F: FnOnce(T1) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1), S>","mito2::cache::index::bloom_filter_index::BloomFilterIndexKey","mito2::sst::file::FileTimeRange"],["
§

impl<F, Fut, S, Res, M, T1, T2> Handler<(M, T1, T2), S> for F
where\n F: FnOnce(T1, T2) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequestParts<S> + Send,\n T2: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1, T2), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1, T2), S>","mito2::cache::index::bloom_filter_index::BloomFilterIndexKey","mito2::sst::file::FileTimeRange"],["
§

impl<F, Fut, S, Res, M, T1, T2, T3> Handler<(M, T1, T2, T3), S> for F
where\n F: FnOnce(T1, T2, T3) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequestParts<S> + Send,\n T2: FromRequestParts<S> + Send,\n T3: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1, T2, T3), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1, T2, T3), S>","mito2::cache::index::bloom_filter_index::BloomFilterIndexKey","mito2::sst::file::FileTimeRange"],["
§

impl<F, Fut, S, Res, M, T1, T2, T3, T4> Handler<(M, T1, T2, T3, T4), S> for F
where\n F: FnOnce(T1, T2, T3, T4) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequestParts<S> + Send,\n T2: FromRequestParts<S> + Send,\n T3: FromRequestParts<S> + Send,\n T4: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1, T2, T3, T4), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1, T2, T3, T4), S>","mito2::cache::index::bloom_filter_index::BloomFilterIndexKey","mito2::sst::file::FileTimeRange"],["
§

impl<F, Fut, S, Res, M, T1, T2, T3, T4, T5> Handler<(M, T1, T2, T3, T4, T5), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequestParts<S> + Send,\n T2: FromRequestParts<S> + Send,\n T3: FromRequestParts<S> + Send,\n T4: FromRequestParts<S> + Send,\n T5: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1, T2, T3, T4, T5), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1, T2, T3, T4, T5), S>","mito2::cache::index::bloom_filter_index::BloomFilterIndexKey","mito2::sst::file::FileTimeRange"],["
§

impl<F, Fut, S, Res, M, T1, T2, T3, T4, T5, T6> Handler<(M, T1, T2, T3, T4, T5, T6), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5, T6) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequestParts<S> + Send,\n T2: FromRequestParts<S> + Send,\n T3: FromRequestParts<S> + Send,\n T4: FromRequestParts<S> + Send,\n T5: FromRequestParts<S> + Send,\n T6: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1, T2, T3, T4, T5, T6), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1, T2, T3, T4, T5, T6), S>","mito2::cache::index::bloom_filter_index::BloomFilterIndexKey","mito2::sst::file::FileTimeRange"],["
§

impl<F, Fut, S, Res, M, T1, T2, T3, T4, T5, T6, T7> Handler<(M, T1, T2, T3, T4, T5, T6, T7), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5, T6, T7) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequestParts<S> + Send,\n T2: FromRequestParts<S> + Send,\n T3: FromRequestParts<S> + Send,\n T4: FromRequestParts<S> + Send,\n T5: FromRequestParts<S> + Send,\n T6: FromRequestParts<S> + Send,\n T7: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1, T2, T3, T4, T5, T6, T7), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1, T2, T3, T4, T5, T6, T7), S>","mito2::cache::index::bloom_filter_index::BloomFilterIndexKey","mito2::sst::file::FileTimeRange"],["
§

impl<F, Fut, S, Res, M, T1, T2, T3, T4, T5, T6, T7, T8> Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5, T6, T7, T8) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequestParts<S> + Send,\n T2: FromRequestParts<S> + Send,\n T3: FromRequestParts<S> + Send,\n T4: FromRequestParts<S> + Send,\n T5: FromRequestParts<S> + Send,\n T6: FromRequestParts<S> + Send,\n T7: FromRequestParts<S> + Send,\n T8: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8), S>","mito2::cache::index::bloom_filter_index::BloomFilterIndexKey","mito2::sst::file::FileTimeRange"],["
§

impl<F, Fut, S, Res, M, T1, T2, T3, T4, T5, T6, T7, T8, T9> Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5, T6, T7, T8, T9) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequestParts<S> + Send,\n T2: FromRequestParts<S> + Send,\n T3: FromRequestParts<S> + Send,\n T4: FromRequestParts<S> + Send,\n T5: FromRequestParts<S> + Send,\n T6: FromRequestParts<S> + Send,\n T7: FromRequestParts<S> + Send,\n T8: FromRequestParts<S> + Send,\n T9: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9), S>","mito2::cache::index::bloom_filter_index::BloomFilterIndexKey","mito2::sst::file::FileTimeRange"],["
§

impl<F, Fut, S, Res, M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequestParts<S> + Send,\n T2: FromRequestParts<S> + Send,\n T3: FromRequestParts<S> + Send,\n T4: FromRequestParts<S> + Send,\n T5: FromRequestParts<S> + Send,\n T6: FromRequestParts<S> + Send,\n T7: FromRequestParts<S> + Send,\n T8: FromRequestParts<S> + Send,\n T9: FromRequestParts<S> + Send,\n T10: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10), S>","mito2::cache::index::bloom_filter_index::BloomFilterIndexKey","mito2::sst::file::FileTimeRange"],["
§

impl<F, Fut, S, Res, M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequestParts<S> + Send,\n T2: FromRequestParts<S> + Send,\n T3: FromRequestParts<S> + Send,\n T4: FromRequestParts<S> + Send,\n T5: FromRequestParts<S> + Send,\n T6: FromRequestParts<S> + Send,\n T7: FromRequestParts<S> + Send,\n T8: FromRequestParts<S> + Send,\n T9: FromRequestParts<S> + Send,\n T10: FromRequestParts<S> + Send,\n T11: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11), S>","mito2::cache::index::bloom_filter_index::BloomFilterIndexKey","mito2::sst::file::FileTimeRange"],["
§

impl<F, Fut, S, Res, M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequestParts<S> + Send,\n T2: FromRequestParts<S> + Send,\n T3: FromRequestParts<S> + Send,\n T4: FromRequestParts<S> + Send,\n T5: FromRequestParts<S> + Send,\n T6: FromRequestParts<S> + Send,\n T7: FromRequestParts<S> + Send,\n T8: FromRequestParts<S> + Send,\n T9: FromRequestParts<S> + Send,\n T10: FromRequestParts<S> + Send,\n T11: FromRequestParts<S> + Send,\n T12: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12), S>","mito2::cache::index::bloom_filter_index::BloomFilterIndexKey","mito2::sst::file::FileTimeRange"],["
§

impl<F, Fut, S, Res, M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequestParts<S> + Send,\n T2: FromRequestParts<S> + Send,\n T3: FromRequestParts<S> + Send,\n T4: FromRequestParts<S> + Send,\n T5: FromRequestParts<S> + Send,\n T6: FromRequestParts<S> + Send,\n T7: FromRequestParts<S> + Send,\n T8: FromRequestParts<S> + Send,\n T9: FromRequestParts<S> + Send,\n T10: FromRequestParts<S> + Send,\n T11: FromRequestParts<S> + Send,\n T12: FromRequestParts<S> + Send,\n T13: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13), S>","mito2::cache::index::bloom_filter_index::BloomFilterIndexKey","mito2::sst::file::FileTimeRange"],["
§

impl<F, Fut, S, Res, M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequestParts<S> + Send,\n T2: FromRequestParts<S> + Send,\n T3: FromRequestParts<S> + Send,\n T4: FromRequestParts<S> + Send,\n T5: FromRequestParts<S> + Send,\n T6: FromRequestParts<S> + Send,\n T7: FromRequestParts<S> + Send,\n T8: FromRequestParts<S> + Send,\n T9: FromRequestParts<S> + Send,\n T10: FromRequestParts<S> + Send,\n T11: FromRequestParts<S> + Send,\n T12: FromRequestParts<S> + Send,\n T13: FromRequestParts<S> + Send,\n T14: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14), S>","mito2::cache::index::bloom_filter_index::BloomFilterIndexKey","mito2::sst::file::FileTimeRange"],["
§

impl<F, Fut, S, Res, M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequestParts<S> + Send,\n T2: FromRequestParts<S> + Send,\n T3: FromRequestParts<S> + Send,\n T4: FromRequestParts<S> + Send,\n T5: FromRequestParts<S> + Send,\n T6: FromRequestParts<S> + Send,\n T7: FromRequestParts<S> + Send,\n T8: FromRequestParts<S> + Send,\n T9: FromRequestParts<S> + Send,\n T10: FromRequestParts<S> + Send,\n T11: FromRequestParts<S> + Send,\n T12: FromRequestParts<S> + Send,\n T13: FromRequestParts<S> + Send,\n T14: FromRequestParts<S> + Send,\n T15: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15), S>","mito2::cache::index::bloom_filter_index::BloomFilterIndexKey","mito2::sst::file::FileTimeRange"],["
§

impl<F, Fut, S, Res, M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16> Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequestParts<S> + Send,\n T2: FromRequestParts<S> + Send,\n T3: FromRequestParts<S> + Send,\n T4: FromRequestParts<S> + Send,\n T5: FromRequestParts<S> + Send,\n T6: FromRequestParts<S> + Send,\n T7: FromRequestParts<S> + Send,\n T8: FromRequestParts<S> + Send,\n T9: FromRequestParts<S> + Send,\n T10: FromRequestParts<S> + Send,\n T11: FromRequestParts<S> + Send,\n T12: FromRequestParts<S> + Send,\n T13: FromRequestParts<S> + Send,\n T14: FromRequestParts<S> + Send,\n T15: FromRequestParts<S> + Send,\n T16: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16), S>","mito2::cache::index::bloom_filter_index::BloomFilterIndexKey","mito2::sst::file::FileTimeRange"],["
§

impl<A, B> IntoParallelIterator for (A, B)
where\n A: IntoParallelIterator,\n <A as IntoParallelIterator>::Iter: IndexedParallelIterator,\n B: IntoParallelIterator,\n <B as IntoParallelIterator>::Iter: IndexedParallelIterator,

§

type Item = (<A as IntoParallelIterator>::Item, <B as IntoParallelIterator>::Item)

The type of item that the parallel iterator will produce.
§

type Iter = MultiZip<(<A as IntoParallelIterator>::Iter, <B as IntoParallelIterator>::Iter)>

The parallel iterator type that will be created.
§

fn into_par_iter(self) -> <(A, B) as IntoParallelIterator>::Iter

Converts self into a parallel iterator. Read more
","IntoParallelIterator","mito2::sst::file::FileTimeRange"],["
§

impl<A, B, C, D> IntoParallelIterator for (A, B, C, D)
where\n A: IntoParallelIterator,\n <A as IntoParallelIterator>::Iter: IndexedParallelIterator,\n B: IntoParallelIterator,\n <B as IntoParallelIterator>::Iter: IndexedParallelIterator,\n C: IntoParallelIterator,\n <C as IntoParallelIterator>::Iter: IndexedParallelIterator,\n D: IntoParallelIterator,\n <D as IntoParallelIterator>::Iter: IndexedParallelIterator,

§

type Item = (<A as IntoParallelIterator>::Item, <B as IntoParallelIterator>::Item, <C as IntoParallelIterator>::Item, <D as IntoParallelIterator>::Item)

The type of item that the parallel iterator will produce.
§

type Iter = MultiZip<(<A as IntoParallelIterator>::Iter, <B as IntoParallelIterator>::Iter, <C as IntoParallelIterator>::Iter, <D as IntoParallelIterator>::Iter)>

The parallel iterator type that will be created.
§

fn into_par_iter(self) -> <(A, B, C, D) as IntoParallelIterator>::Iter

Converts self into a parallel iterator. Read more
","IntoParallelIterator","mito2::cache::index::bloom_filter_index::BloomFilterIndexKey"],["
§

impl<R, T1> IntoResponse for (T1, R)
where\n T1: IntoResponseParts,\n R: IntoResponse,

§

fn into_response(self) -> Response<Body>

Create a response.
","IntoResponse","mito2::sst::file::FileTimeRange"],["
§

impl<R, T1, T2, T3> IntoResponse for (T1, T2, T3, R)
where\n T1: IntoResponseParts,\n T2: IntoResponseParts,\n T3: IntoResponseParts,\n R: IntoResponse,

§

fn into_response(self) -> Response<Body>

Create a response.
","IntoResponse","mito2::cache::index::bloom_filter_index::BloomFilterIndexKey"],["
§

impl<T1, T2> IntoResponseParts for (T1, T2)
where\n T1: IntoResponseParts,\n T2: IntoResponseParts,

§

type Error = Response<Body>

The type returned in the event of an error. Read more
§

fn into_response_parts(\n self,\n res: ResponseParts,\n) -> Result<ResponseParts, <(T1, T2) as IntoResponseParts>::Error>

Set parts of the response
","IntoResponseParts","mito2::sst::file::FileTimeRange"],["
§

impl<T1, T2, T3, T4> IntoResponseParts for (T1, T2, T3, T4)
where\n T1: IntoResponseParts,\n T2: IntoResponseParts,\n T3: IntoResponseParts,\n T4: IntoResponseParts,

§

type Error = Response<Body>

The type returned in the event of an error. Read more
§

fn into_response_parts(\n self,\n res: ResponseParts,\n) -> Result<ResponseParts, <(T1, T2, T3, T4) as IntoResponseParts>::Error>

Set parts of the response
","IntoResponseParts","mito2::cache::index::bloom_filter_index::BloomFilterIndexKey"],["
Source§

impl<Ix, E> IntoWeightedEdge<E> for (Ix, Ix)
where\n E: Default,

","IntoWeightedEdge","mito2::sst::file::FileTimeRange"],["
Source§

impl<Ix, E> IntoWeightedEdge<E> for (Ix, Ix)
where\n E: Default,

","IntoWeightedEdge","mito2::sst::file::FileTimeRange"],["
§

impl<S, L1, L2> Layer<S> for (L1, L2)
where\n L1: Layer<<L2 as Layer<S>>::Service>,\n L2: Layer<S>,

§

type Service = <L1 as Layer<<L2 as Layer<S>>::Service>>::Service

The wrapped service
§

fn layer(&self, service: S) -> <(L1, L2) as Layer<S>>::Service

Wrap the given service with the middleware, returning a new service\nthat has been decorated with the middleware.
","Layer","mito2::sst::file::FileTimeRange"],["
§

impl<S, L1, L2, L3, L4> Layer<S> for (L1, L2, L3, L4)
where\n L1: Layer<<L2 as Layer<<L3 as Layer<<L4 as Layer<S>>::Service>>::Service>>::Service>,\n L2: Layer<<L3 as Layer<<L4 as Layer<S>>::Service>>::Service>,\n L3: Layer<<L4 as Layer<S>>::Service>,\n L4: Layer<S>,

§

type Service = <L1 as Layer<<L2 as Layer<<L3 as Layer<<L4 as Layer<S>>::Service>>::Service>>::Service>>::Service

The wrapped service
§

fn layer(&self, service: S) -> <(L1, L2, L3, L4) as Layer<S>>::Service

Wrap the given service with the middleware, returning a new service\nthat has been decorated with the middleware.
","Layer","mito2::cache::index::bloom_filter_index::BloomFilterIndexKey"],["
Source§

impl<IT, A, FromA> MultiUnzip<(FromA,)> for IT
where\n IT: Iterator<Item = (A,)>,\n FromA: Default + Extend<A>,

Source§

fn multiunzip(self) -> (FromA,)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA,)>","mito2::cache::index::bloom_filter_index::BloomFilterIndexKey","mito2::sst::file::FileTimeRange"],["
§

impl<IT, A, FromA> MultiUnzip<(FromA,)> for IT
where\n IT: Iterator<Item = (A,)>,\n FromA: Default + Extend<A>,

§

fn multiunzip(self) -> (FromA,)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA,)>","mito2::cache::index::bloom_filter_index::BloomFilterIndexKey","mito2::sst::file::FileTimeRange"],["
Source§

impl<IT, A, FromA, B, FromB> MultiUnzip<(FromA, FromB)> for IT
where\n IT: Iterator<Item = (A, B)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,

Source§

fn multiunzip(self) -> (FromA, FromB)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB)>","mito2::cache::index::bloom_filter_index::BloomFilterIndexKey","mito2::sst::file::FileTimeRange"],["
§

impl<IT, A, FromA, B, FromB> MultiUnzip<(FromA, FromB)> for IT
where\n IT: Iterator<Item = (A, B)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,

§

fn multiunzip(self) -> (FromA, FromB)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB)>","mito2::cache::index::bloom_filter_index::BloomFilterIndexKey","mito2::sst::file::FileTimeRange"],["
Source§

impl<IT, A, FromA, B, FromB, C, FromC> MultiUnzip<(FromA, FromB, FromC)> for IT
where\n IT: Iterator<Item = (A, B, C)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,

Source§

fn multiunzip(self) -> (FromA, FromB, FromC)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC)>","mito2::cache::index::bloom_filter_index::BloomFilterIndexKey","mito2::sst::file::FileTimeRange"],["
§

impl<IT, A, FromA, B, FromB, C, FromC> MultiUnzip<(FromA, FromB, FromC)> for IT
where\n IT: Iterator<Item = (A, B, C)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,

§

fn multiunzip(self) -> (FromA, FromB, FromC)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC)>","mito2::cache::index::bloom_filter_index::BloomFilterIndexKey","mito2::sst::file::FileTimeRange"],["
Source§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD> MultiUnzip<(FromA, FromB, FromC, FromD)> for IT
where\n IT: Iterator<Item = (A, B, C, D)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,

Source§

fn multiunzip(self) -> (FromA, FromB, FromC, FromD)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD)>","mito2::cache::index::bloom_filter_index::BloomFilterIndexKey","mito2::sst::file::FileTimeRange"],["
§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD> MultiUnzip<(FromA, FromB, FromC, FromD)> for IT
where\n IT: Iterator<Item = (A, B, C, D)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,

§

fn multiunzip(self) -> (FromA, FromB, FromC, FromD)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD)>","mito2::cache::index::bloom_filter_index::BloomFilterIndexKey","mito2::sst::file::FileTimeRange"],["
Source§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE> MultiUnzip<(FromA, FromB, FromC, FromD, FromE)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,

Source§

fn multiunzip(self) -> (FromA, FromB, FromC, FromD, FromE)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE)>","mito2::cache::index::bloom_filter_index::BloomFilterIndexKey","mito2::sst::file::FileTimeRange"],["
§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE> MultiUnzip<(FromA, FromB, FromC, FromD, FromE)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,

§

fn multiunzip(self) -> (FromA, FromB, FromC, FromD, FromE)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE)>","mito2::cache::index::bloom_filter_index::BloomFilterIndexKey","mito2::sst::file::FileTimeRange"],["
Source§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E, F)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,\n FromF: Default + Extend<F>,

Source§

fn multiunzip(self) -> (FromA, FromB, FromC, FromD, FromE, FromF)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF)>","mito2::cache::index::bloom_filter_index::BloomFilterIndexKey","mito2::sst::file::FileTimeRange"],["
§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E, F)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,\n FromF: Default + Extend<F>,

§

fn multiunzip(self) -> (FromA, FromB, FromC, FromD, FromE, FromF)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF)>","mito2::cache::index::bloom_filter_index::BloomFilterIndexKey","mito2::sst::file::FileTimeRange"],["
Source§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E, F, G)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,\n FromF: Default + Extend<F>,\n FromG: Default + Extend<G>,

Source§

fn multiunzip(self) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG)>","mito2::cache::index::bloom_filter_index::BloomFilterIndexKey","mito2::sst::file::FileTimeRange"],["
§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E, F, G)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,\n FromF: Default + Extend<F>,\n FromG: Default + Extend<G>,

§

fn multiunzip(self) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG)>","mito2::cache::index::bloom_filter_index::BloomFilterIndexKey","mito2::sst::file::FileTimeRange"],["
Source§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E, F, G, H)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,\n FromF: Default + Extend<F>,\n FromG: Default + Extend<G>,\n FromH: Default + Extend<H>,

Source§

fn multiunzip(self) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH)>","mito2::cache::index::bloom_filter_index::BloomFilterIndexKey","mito2::sst::file::FileTimeRange"],["
§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E, F, G, H)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,\n FromF: Default + Extend<F>,\n FromG: Default + Extend<G>,\n FromH: Default + Extend<H>,

§

fn multiunzip(self) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH)>","mito2::cache::index::bloom_filter_index::BloomFilterIndexKey","mito2::sst::file::FileTimeRange"],["
Source§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E, F, G, H, I)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,\n FromF: Default + Extend<F>,\n FromG: Default + Extend<G>,\n FromH: Default + Extend<H>,\n FromI: Default + Extend<I>,

Source§

fn multiunzip(\n self,\n) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI)>","mito2::cache::index::bloom_filter_index::BloomFilterIndexKey","mito2::sst::file::FileTimeRange"],["
§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E, F, G, H, I)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,\n FromF: Default + Extend<F>,\n FromG: Default + Extend<G>,\n FromH: Default + Extend<H>,\n FromI: Default + Extend<I>,

§

fn multiunzip(\n self,\n) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI)>","mito2::cache::index::bloom_filter_index::BloomFilterIndexKey","mito2::sst::file::FileTimeRange"],["
Source§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,\n FromF: Default + Extend<F>,\n FromG: Default + Extend<G>,\n FromH: Default + Extend<H>,\n FromI: Default + Extend<I>,\n FromJ: Default + Extend<J>,

Source§

fn multiunzip(\n self,\n) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ)>","mito2::cache::index::bloom_filter_index::BloomFilterIndexKey","mito2::sst::file::FileTimeRange"],["
§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,\n FromF: Default + Extend<F>,\n FromG: Default + Extend<G>,\n FromH: Default + Extend<H>,\n FromI: Default + Extend<I>,\n FromJ: Default + Extend<J>,

§

fn multiunzip(\n self,\n) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ)>","mito2::cache::index::bloom_filter_index::BloomFilterIndexKey","mito2::sst::file::FileTimeRange"],["
Source§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ, K, FromK> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J, K)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,\n FromF: Default + Extend<F>,\n FromG: Default + Extend<G>,\n FromH: Default + Extend<H>,\n FromI: Default + Extend<I>,\n FromJ: Default + Extend<J>,\n FromK: Default + Extend<K>,

Source§

fn multiunzip(\n self,\n) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK)>","mito2::cache::index::bloom_filter_index::BloomFilterIndexKey","mito2::sst::file::FileTimeRange"],["
§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ, K, FromK> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J, K)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,\n FromF: Default + Extend<F>,\n FromG: Default + Extend<G>,\n FromH: Default + Extend<H>,\n FromI: Default + Extend<I>,\n FromJ: Default + Extend<J>,\n FromK: Default + Extend<K>,

§

fn multiunzip(\n self,\n) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK)>","mito2::cache::index::bloom_filter_index::BloomFilterIndexKey","mito2::sst::file::FileTimeRange"],["
Source§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ, K, FromK, L, FromL> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK, FromL)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J, K, L)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,\n FromF: Default + Extend<F>,\n FromG: Default + Extend<G>,\n FromH: Default + Extend<H>,\n FromI: Default + Extend<I>,\n FromJ: Default + Extend<J>,\n FromK: Default + Extend<K>,\n FromL: Default + Extend<L>,

","MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK, FromL)>","mito2::cache::index::bloom_filter_index::BloomFilterIndexKey","mito2::sst::file::FileTimeRange"],["
§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ, K, FromK, L, FromL> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK, FromL)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J, K, L)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,\n FromF: Default + Extend<F>,\n FromG: Default + Extend<G>,\n FromH: Default + Extend<H>,\n FromI: Default + Extend<I>,\n FromJ: Default + Extend<J>,\n FromK: Default + Extend<K>,\n FromL: Default + Extend<L>,

§

fn multiunzip(\n self,\n) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK, FromL)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK, FromL)>","mito2::cache::index::bloom_filter_index::BloomFilterIndexKey","mito2::sst::file::FileTimeRange"],["
§

impl<A, B, FromA, FromB> ParallelExtend<(A, B)> for (FromA, FromB)
where\n A: Send,\n B: Send,\n FromA: Send + ParallelExtend<A>,\n FromB: Send + ParallelExtend<B>,

§

fn par_extend<I>(&mut self, pi: I)
where\n I: IntoParallelIterator<Item = (A, B)>,

Extends an instance of the collection with the elements drawn\nfrom the parallel iterator par_iter. Read more
","ParallelExtend<(A, B)>","mito2::sst::file::FileTimeRange"],["
§

impl<L, R, A, B> ParallelExtend<Either<L, R>> for (A, B)
where\n L: Send,\n R: Send,\n A: Send + ParallelExtend<L>,\n B: Send + ParallelExtend<R>,

§

fn par_extend<I>(&mut self, pi: I)
where\n I: IntoParallelIterator<Item = Either<L, R>>,

Extends an instance of the collection with the elements drawn\nfrom the parallel iterator par_iter. Read more
","ParallelExtend>","mito2::sst::file::FileTimeRange"],["
§

impl<I, O1, O2, E, P1, P2> Parser<I> for (P1, P2)
where\n E: ParseError<I>,\n P1: Parser<I, Output = O1, Error = E>,\n P2: Parser<I, Output = O2, Error = E>,

§

type Output = (O1, O2)

Type of the produced value
§

type Error = E

Error type of this parser
§

fn process<OM>(\n &mut self,\n i: I,\n) -> Result<(I, <<OM as OutputMode>::Output as Mode>::Output<<(P1, P2) as Parser<I>>::Output>), Err<<(P1, P2) as Parser<I>>::Error, <<OM as OutputMode>::Error as Mode>::Output<<(P1, P2) as Parser<I>>::Error>>>
where\n OM: OutputMode,

A parser takes in input type, and returns a Result containing\neither the remaining input and the output value, or an error
§

fn parse(\n &mut self,\n input: Input,\n) -> Result<(Input, Self::Output), Err<Self::Error>>

A parser takes in input type, and returns a Result containing\neither the remaining input and the output value, or an error
§

fn parse_complete(\n &mut self,\n input: Input,\n) -> Result<(Input, Self::Output), Err<Self::Error>>

A parser takes in input type, and returns a Result containing\neither the remaining input and the output value, or an error
§

fn map<G, O2>(self, g: G) -> Map<Self, G>
where\n G: FnMut(Self::Output) -> O2,\n Self: Sized,

Maps a function over the result of a parser
§

fn map_res<G, O2, E2>(self, g: G) -> MapRes<Self, G>
where\n G: FnMut(Self::Output) -> Result<O2, E2>,\n Self::Error: FromExternalError<Input, E2>,\n Self: Sized,

Applies a function returning a Result over the result of a parser.
§

fn map_opt<G, O2>(self, g: G) -> MapOpt<Self, G>
where\n G: FnMut(Self::Output) -> Option<O2>,\n Self: Sized,

Applies a function returning an Option over the result of a parser.
§

fn flat_map<G, H>(self, g: G) -> FlatMap<Self, G>
where\n G: FnMut(Self::Output) -> H,\n H: Parser<Input, Error = Self::Error>,\n Self: Sized,

Creates a second parser from the output of the first one, then apply over the rest of the input
§

fn and_then<G>(self, g: G) -> AndThen<Self, G>
where\n G: Parser<Self::Output, Error = Self::Error>,\n Self: Sized,

Applies a second parser over the output of the first one
§

fn and<G, O2>(self, g: G) -> And<Self, G>
where\n G: Parser<Input, Output = O2, Error = Self::Error>,\n Self: Sized,

Applies a second parser after the first one, return their results as a tuple
§

fn or<G>(self, g: G) -> Or<Self, G>
where\n G: Parser<Input, Output = Self::Output, Error = Self::Error>,\n Self: Sized,

Applies a second parser over the input if the first one failed
§

fn into<O2, E2>(self) -> Into<Self, O2, E2>
where\n O2: From<Self::Output>,\n E2: From<Self::Error>,\n Self: Sized,

automatically converts the parser’s output and error values to another type, as long as they\nimplement the From trait
","Parser","mito2::sst::file::FileTimeRange"],["
§

impl<I, O1, O2, O3, O4, E, P1, P2, P3, P4> Parser<I> for (P1, P2, P3, P4)
where\n E: ParseError<I>,\n P1: Parser<I, Output = O1, Error = E>,\n P2: Parser<I, Output = O2, Error = E>,\n P3: Parser<I, Output = O3, Error = E>,\n P4: Parser<I, Output = O4, Error = E>,

§

type Output = (O1, O2, O3, O4)

Type of the produced value
§

type Error = E

Error type of this parser
§

fn process<OM>(\n &mut self,\n i: I,\n) -> Result<(I, <<OM as OutputMode>::Output as Mode>::Output<<(P1, P2, P3, P4) as Parser<I>>::Output>), Err<<(P1, P2, P3, P4) as Parser<I>>::Error, <<OM as OutputMode>::Error as Mode>::Output<<(P1, P2, P3, P4) as Parser<I>>::Error>>>
where\n OM: OutputMode,

A parser takes in input type, and returns a Result containing\neither the remaining input and the output value, or an error
§

fn parse(\n &mut self,\n input: Input,\n) -> Result<(Input, Self::Output), Err<Self::Error>>

A parser takes in input type, and returns a Result containing\neither the remaining input and the output value, or an error
§

fn parse_complete(\n &mut self,\n input: Input,\n) -> Result<(Input, Self::Output), Err<Self::Error>>

A parser takes in input type, and returns a Result containing\neither the remaining input and the output value, or an error
§

fn map<G, O2>(self, g: G) -> Map<Self, G>
where\n G: FnMut(Self::Output) -> O2,\n Self: Sized,

Maps a function over the result of a parser
§

fn map_res<G, O2, E2>(self, g: G) -> MapRes<Self, G>
where\n G: FnMut(Self::Output) -> Result<O2, E2>,\n Self::Error: FromExternalError<Input, E2>,\n Self: Sized,

Applies a function returning a Result over the result of a parser.
§

fn map_opt<G, O2>(self, g: G) -> MapOpt<Self, G>
where\n G: FnMut(Self::Output) -> Option<O2>,\n Self: Sized,

Applies a function returning an Option over the result of a parser.
§

fn flat_map<G, H>(self, g: G) -> FlatMap<Self, G>
where\n G: FnMut(Self::Output) -> H,\n H: Parser<Input, Error = Self::Error>,\n Self: Sized,

Creates a second parser from the output of the first one, then apply over the rest of the input
§

fn and_then<G>(self, g: G) -> AndThen<Self, G>
where\n G: Parser<Self::Output, Error = Self::Error>,\n Self: Sized,

Applies a second parser over the output of the first one
§

fn and<G, O2>(self, g: G) -> And<Self, G>
where\n G: Parser<Input, Output = O2, Error = Self::Error>,\n Self: Sized,

Applies a second parser after the first one, return their results as a tuple
§

fn or<G>(self, g: G) -> Or<Self, G>
where\n G: Parser<Input, Output = Self::Output, Error = Self::Error>,\n Self: Sized,

Applies a second parser over the input if the first one failed
§

fn into<O2, E2>(self) -> Into<Self, O2, E2>
where\n O2: From<Self::Output>,\n E2: From<Self::Error>,\n Self: Sized,

automatically converts the parser’s output and error values to another type, as long as they\nimplement the From trait
","Parser","mito2::cache::index::bloom_filter_index::BloomFilterIndexKey"],["
§

impl<I, O0, O1, E, P0, P1> Parser<I, (O0, O1), E> for (P0, P1)
where\n I: Stream,\n E: ParserError<I>,\n P0: Parser<I, O0, E>,\n P1: Parser<I, O1, E>,

§

fn parse_next(&mut self, i: &mut I) -> Result<(O0, O1), E>

Take tokens from the [Stream], turning it into the output Read more
§

fn parse(\n &mut self,\n input: I,\n) -> Result<O, ParseError<I, <E as ParserError<I>>::Inner>>
where\n Self: Sized,\n I: Stream + StreamIsPartial,\n E: ParserError<I>,\n <E as ParserError<I>>::Inner: ParserError<I>,

Parse all of input, generating O from it
§

fn parse_peek(&mut self, input: I) -> Result<(I, O), E>

Take tokens from the [Stream], turning it into the output Read more
§

fn by_ref(&mut self) -> ByRef<'_, Self, I, O, E>
where\n Self: Sized,

Treat &mut Self as a parser Read more
§

fn value<O2>(self, val: O2) -> Value<Self, I, O, O2, E>
where\n Self: Sized,\n O2: Clone,

Produce the provided value Read more
§

fn default_value<O2>(self) -> DefaultValue<Self, I, O, O2, E>
where\n Self: Sized,\n O2: Default,

Produce a type’s default value Read more
§

fn void(self) -> Void<Self, I, O, E>
where\n Self: Sized,

Discards the output of the Parser Read more
§

fn output_into<O2>(self) -> OutputInto<Self, I, O, O2, E>
where\n Self: Sized,\n O: Into<O2>,

Convert the parser’s output to another type using std::convert::From Read more
§

fn take(self) -> Take<Self, I, O, E>
where\n Self: Sized,\n I: Stream,

Produce the consumed input as produced value. Read more
§

fn with_taken(self) -> WithTaken<Self, I, O, E>
where\n Self: Sized,\n I: Stream,

Produce the consumed input with the output Read more
§

fn span(self) -> Span<Self, I, O, E>
where\n Self: Sized,\n I: Stream + Location,

Produce the location of the consumed input as produced value. Read more
§

fn with_span(self) -> WithSpan<Self, I, O, E>
where\n Self: Sized,\n I: Stream + Location,

Produce the location of consumed input with the output Read more
§

fn map<G, O2>(self, map: G) -> Map<Self, G, I, O, O2, E>
where\n G: FnMut(O) -> O2,\n Self: Sized,

Maps a function over the output of a parser Read more
§

fn try_map<G, O2, E2>(self, map: G) -> TryMap<Self, G, I, O, O2, E, E2>
where\n Self: Sized,\n G: FnMut(O) -> Result<O2, E2>,\n I: Stream,\n E: FromExternalError<I, E2> + ParserError<I>,

Applies a function returning a Result over the output of a parser. Read more
§

fn verify_map<G, O2>(self, map: G) -> VerifyMap<Self, G, I, O, O2, E>
where\n Self: Sized,\n G: FnMut(O) -> Option<O2>,\n I: Stream,\n E: ParserError<I>,

Apply both [Parser::verify] and [Parser::map]. Read more
§

fn flat_map<G, H, O2>(self, map: G) -> FlatMap<Self, G, H, I, O, O2, E>
where\n Self: Sized,\n G: FnMut(O) -> H,\n H: Parser<I, O2, E>,

Creates a parser from the output of this one Read more
§

fn and_then<G, O2>(self, inner: G) -> AndThen<Self, G, I, O, O2, E>
where\n Self: Sized,\n G: Parser<O, O2, E>,\n O: StreamIsPartial,\n I: Stream,

Applies a second parser over the output of the first one Read more
§

fn parse_to<O2>(self) -> ParseTo<Self, I, O, O2, E>
where\n Self: Sized,\n I: Stream,\n O: ParseSlice<O2>,\n E: ParserError<I>,

Apply std::str::FromStr to the output of the parser Read more
§

fn verify<G, O2>(self, filter: G) -> Verify<Self, G, I, O, O2, E>
where\n Self: Sized,\n G: FnMut(&O2) -> bool,\n I: Stream,\n O: Borrow<O2>,\n E: ParserError<I>,\n O2: ?Sized,

Returns the output of the child parser if it satisfies a verification function. Read more
§

fn context<C>(self, context: C) -> Context<Self, I, O, E, C>
where\n Self: Sized,\n I: Stream,\n E: AddContext<I, C> + ParserError<I>,\n C: Clone + Debug,

If parsing fails, add context to the error Read more
§

fn context_with<F, C, FI>(\n self,\n context: F,\n) -> ContextWith<Self, I, O, E, F, C, FI>
where\n Self: Sized,\n I: Stream,\n E: AddContext<I, C> + ParserError<I>,\n F: Fn() -> FI + Clone,\n C: Debug,\n FI: Iterator<Item = C>,

If parsing fails, dynamically add context to the error Read more
§

fn map_err<G, E2>(self, map: G) -> MapErr<Self, G, I, O, E, E2>
where\n G: FnMut(E) -> E2,\n Self: Sized,

Maps a function over the error of a parser Read more
§

fn complete_err(self) -> CompleteErr<Self, I, O, E>
where\n Self: Sized,

Transforms [Incomplete][crate::error::ErrMode::Incomplete] into [Backtrack][crate::error::ErrMode::Backtrack] Read more
§

fn err_into<E2>(self) -> ErrInto<Self, I, O, E, E2>
where\n Self: Sized,\n E: Into<E2>,

Convert the parser’s error to another type using std::convert::From
","Parser","mito2::sst::file::FileTimeRange"],["
§

impl<I, O0, O1, O2, O3, E, P0, P1, P2, P3> Parser<I, (O0, O1, O2, O3), E> for (P0, P1, P2, P3)
where\n I: Stream,\n E: ParserError<I>,\n P0: Parser<I, O0, E>,\n P1: Parser<I, O1, E>,\n P2: Parser<I, O2, E>,\n P3: Parser<I, O3, E>,

§

fn parse_next(&mut self, i: &mut I) -> Result<(O0, O1, O2, O3), E>

Take tokens from the [Stream], turning it into the output Read more
§

fn parse(\n &mut self,\n input: I,\n) -> Result<O, ParseError<I, <E as ParserError<I>>::Inner>>
where\n Self: Sized,\n I: Stream + StreamIsPartial,\n E: ParserError<I>,\n <E as ParserError<I>>::Inner: ParserError<I>,

Parse all of input, generating O from it
§

fn parse_peek(&mut self, input: I) -> Result<(I, O), E>

Take tokens from the [Stream], turning it into the output Read more
§

fn by_ref(&mut self) -> ByRef<'_, Self, I, O, E>
where\n Self: Sized,

Treat &mut Self as a parser Read more
§

fn value<O2>(self, val: O2) -> Value<Self, I, O, O2, E>
where\n Self: Sized,\n O2: Clone,

Produce the provided value Read more
§

fn default_value<O2>(self) -> DefaultValue<Self, I, O, O2, E>
where\n Self: Sized,\n O2: Default,

Produce a type’s default value Read more
§

fn void(self) -> Void<Self, I, O, E>
where\n Self: Sized,

Discards the output of the Parser Read more
§

fn output_into<O2>(self) -> OutputInto<Self, I, O, O2, E>
where\n Self: Sized,\n O: Into<O2>,

Convert the parser’s output to another type using std::convert::From Read more
§

fn take(self) -> Take<Self, I, O, E>
where\n Self: Sized,\n I: Stream,

Produce the consumed input as produced value. Read more
§

fn with_taken(self) -> WithTaken<Self, I, O, E>
where\n Self: Sized,\n I: Stream,

Produce the consumed input with the output Read more
§

fn span(self) -> Span<Self, I, O, E>
where\n Self: Sized,\n I: Stream + Location,

Produce the location of the consumed input as produced value. Read more
§

fn with_span(self) -> WithSpan<Self, I, O, E>
where\n Self: Sized,\n I: Stream + Location,

Produce the location of consumed input with the output Read more
§

fn map<G, O2>(self, map: G) -> Map<Self, G, I, O, O2, E>
where\n G: FnMut(O) -> O2,\n Self: Sized,

Maps a function over the output of a parser Read more
§

fn try_map<G, O2, E2>(self, map: G) -> TryMap<Self, G, I, O, O2, E, E2>
where\n Self: Sized,\n G: FnMut(O) -> Result<O2, E2>,\n I: Stream,\n E: FromExternalError<I, E2> + ParserError<I>,

Applies a function returning a Result over the output of a parser. Read more
§

fn verify_map<G, O2>(self, map: G) -> VerifyMap<Self, G, I, O, O2, E>
where\n Self: Sized,\n G: FnMut(O) -> Option<O2>,\n I: Stream,\n E: ParserError<I>,

Apply both [Parser::verify] and [Parser::map]. Read more
§

fn flat_map<G, H, O2>(self, map: G) -> FlatMap<Self, G, H, I, O, O2, E>
where\n Self: Sized,\n G: FnMut(O) -> H,\n H: Parser<I, O2, E>,

Creates a parser from the output of this one Read more
§

fn and_then<G, O2>(self, inner: G) -> AndThen<Self, G, I, O, O2, E>
where\n Self: Sized,\n G: Parser<O, O2, E>,\n O: StreamIsPartial,\n I: Stream,

Applies a second parser over the output of the first one Read more
§

fn parse_to<O2>(self) -> ParseTo<Self, I, O, O2, E>
where\n Self: Sized,\n I: Stream,\n O: ParseSlice<O2>,\n E: ParserError<I>,

Apply std::str::FromStr to the output of the parser Read more
§

fn verify<G, O2>(self, filter: G) -> Verify<Self, G, I, O, O2, E>
where\n Self: Sized,\n G: FnMut(&O2) -> bool,\n I: Stream,\n O: Borrow<O2>,\n E: ParserError<I>,\n O2: ?Sized,

Returns the output of the child parser if it satisfies a verification function. Read more
§

fn context<C>(self, context: C) -> Context<Self, I, O, E, C>
where\n Self: Sized,\n I: Stream,\n E: AddContext<I, C> + ParserError<I>,\n C: Clone + Debug,

If parsing fails, add context to the error Read more
§

fn context_with<F, C, FI>(\n self,\n context: F,\n) -> ContextWith<Self, I, O, E, F, C, FI>
where\n Self: Sized,\n I: Stream,\n E: AddContext<I, C> + ParserError<I>,\n F: Fn() -> FI + Clone,\n C: Debug,\n FI: Iterator<Item = C>,

If parsing fails, dynamically add context to the error Read more
§

fn map_err<G, E2>(self, map: G) -> MapErr<Self, G, I, O, E, E2>
where\n G: FnMut(E) -> E2,\n Self: Sized,

Maps a function over the error of a parser Read more
§

fn complete_err(self) -> CompleteErr<Self, I, O, E>
where\n Self: Sized,

Transforms [Incomplete][crate::error::ErrMode::Incomplete] into [Backtrack][crate::error::ErrMode::Backtrack] Read more
§

fn err_into<E2>(self) -> ErrInto<Self, I, O, E, E2>
where\n Self: Sized,\n E: Into<E2>,

Convert the parser’s error to another type using std::convert::From
","Parser","mito2::cache::index::bloom_filter_index::BloomFilterIndexKey"],["
§

impl<I, O1, O2, Error, P1, P2> Permutation<I, (O1, O2), Error> for (P1, P2)
where\n I: Stream,\n Error: ParserError<I>,\n P1: Parser<I, O1, Error>,\n P2: Parser<I, O2, Error>,

§

fn permutation(&mut self, input: &mut I) -> Result<(O1, O2), Error>

Tries to apply all parsers in the tuple in various orders until all of them succeed
","Permutation","mito2::sst::file::FileTimeRange"],["
§

impl<I, O1, O2, O3, O4, Error, P1, P2, P3, P4> Permutation<I, (O1, O2, O3, O4), Error> for (P1, P2, P3, P4)
where\n I: Stream,\n Error: ParserError<I>,\n P1: Parser<I, O1, Error>,\n P2: Parser<I, O2, Error>,\n P3: Parser<I, O3, Error>,\n P4: Parser<I, O4, Error>,

§

fn permutation(&mut self, input: &mut I) -> Result<(O1, O2, O3, O4), Error>

Tries to apply all parsers in the tuple in various orders until all of them succeed
","Permutation","mito2::cache::index::bloom_filter_index::BloomFilterIndexKey"],["
§

impl<Input, A, B, Error, FnA, FnB> Permutation<Input, (A, B), Error> for (FnA, FnB)
where\n Input: Clone,\n Error: ParseError<Input>,\n FnA: Parser<Input, A, Error>,\n FnB: Parser<Input, B, Error>,

§

fn permutation(&mut self, input: Input) -> Result<(Input, (A, B)), Err<Error>>

Tries to apply all parsers in the tuple in various orders until all of them succeed
","Permutation","mito2::sst::file::FileTimeRange"],["
§

impl<Input, A, B, C, D, Error, FnA, FnB, FnC, FnD> Permutation<Input, (A, B, C, D), Error> for (FnA, FnB, FnC, FnD)
where\n Input: Clone,\n Error: ParseError<Input>,\n FnA: Parser<Input, A, Error>,\n FnB: Parser<Input, B, Error>,\n FnC: Parser<Input, C, Error>,\n FnD: Parser<Input, D, Error>,

§

fn permutation(\n &mut self,\n input: Input,\n) -> Result<(Input, (A, B, C, D)), Err<Error>>

Tries to apply all parsers in the tuple in various orders until all of them succeed
","Permutation","mito2::cache::index::bloom_filter_index::BloomFilterIndexKey"],["
§

impl<T1, T2> PgHasArrayType for (T1, T2)

§

fn array_type_info() -> PgTypeInfo

§

fn array_compatible(ty: &PgTypeInfo) -> bool

","PgHasArrayType","mito2::sst::file::FileTimeRange"],["
§

impl<T1, T2, T3, T4> PgHasArrayType for (T1, T2, T3, T4)

§

fn array_type_info() -> PgTypeInfo

§

fn array_compatible(ty: &PgTypeInfo) -> bool

","PgHasArrayType","mito2::cache::index::bloom_filter_index::BloomFilterIndexKey"],["
§

impl<S> Point for (S, S)
where\n S: RTreeNum,

§

const DIMENSIONS: usize = 2usize

The number of dimensions of this point type.
§

type Scalar = S

The number type used by this point type.
§

fn generate(generator: impl FnMut(usize) -> S) -> (S, S)

Creates a new point value with given values for each dimension. Read more
§

fn nth(&self, index: usize) -> <(S, S) as Point>::Scalar

Returns a single coordinate of this point. Read more
§

fn nth_mut(&mut self, index: usize) -> &mut <(S, S) as Point>::Scalar

Mutable variant of nth.
","Point","mito2::sst::file::FileTimeRange"],["
§

impl<S> Point for (S, S, S, S)
where\n S: RTreeNum,

§

const DIMENSIONS: usize = 4usize

The number of dimensions of this point type.
§

type Scalar = S

The number type used by this point type.
§

fn generate(generator: impl FnMut(usize) -> S) -> (S, S, S, S)

Creates a new point value with given values for each dimension. Read more
§

fn nth(&self, index: usize) -> <(S, S, S, S) as Point>::Scalar

Returns a single coordinate of this point. Read more
§

fn nth_mut(&mut self, index: usize) -> &mut <(S, S, S, S) as Point>::Scalar

Mutable variant of nth.
","Point","mito2::cache::index::bloom_filter_index::BloomFilterIndexKey"],["
§

impl<Left, Right> SegmentCollector for (Left, Right)
where\n Left: SegmentCollector,\n Right: SegmentCollector,

§

type Fruit = (<Left as SegmentCollector>::Fruit, <Right as SegmentCollector>::Fruit)

Fruit is the type for the result of our collection.\ne.g. usize for the Count collector.
§

fn collect(&mut self, doc: u32, score: f32)

The query pushes the scored document to the collector via this method.
§

fn harvest(self) -> <(Left, Right) as SegmentCollector>::Fruit

Extract the fruit of the collection from the SegmentCollector.
§

fn collect_block(&mut self, docs: &[u32])

The query pushes the scored document to the collector via this method.\nThis method is used when the collector does not require scoring. Read more
","SegmentCollector","mito2::sst::file::FileTimeRange"],["
§

impl<One, Two, Three, Four> SegmentCollector for (One, Two, Three, Four)
where\n One: SegmentCollector,\n Two: SegmentCollector,\n Three: SegmentCollector,\n Four: SegmentCollector,

§

type Fruit = (<One as SegmentCollector>::Fruit, <Two as SegmentCollector>::Fruit, <Three as SegmentCollector>::Fruit, <Four as SegmentCollector>::Fruit)

Fruit is the type for the result of our collection.\ne.g. usize for the Count collector.
§

fn collect(&mut self, doc: u32, score: f32)

The query pushes the scored document to the collector via this method.
§

fn harvest(self) -> <(One, Two, Three, Four) as SegmentCollector>::Fruit

Extract the fruit of the collection from the SegmentCollector.
§

fn collect_block(&mut self, docs: &[u32])

The query pushes the scored document to the collector via this method.\nThis method is used when the collector does not require scoring. Read more
","SegmentCollector","mito2::cache::index::bloom_filter_index::BloomFilterIndexKey"],["
Source§

impl<T0, T1> Serialize for (T0, T1)
where\n T0: Serialize,\n T1: Serialize,

Source§

fn serialize<S>(\n &self,\n serializer: S,\n) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>
where\n S: Serializer,

Serialize this value into the given Serde serializer. Read more
","Serialize","mito2::sst::file::FileTimeRange"],["
Source§

impl<T0, T1, T2, T3> Serialize for (T0, T1, T2, T3)
where\n T0: Serialize,\n T1: Serialize,\n T2: Serialize,\n T3: Serialize,

Source§

fn serialize<S>(\n &self,\n serializer: S,\n) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>
where\n S: Serializer,

Serialize this value into the given Serde serializer. Read more
","Serialize","mito2::cache::index::bloom_filter_index::BloomFilterIndexKey"],["
Source§

impl<T0, As0, T1, As1> SerializeAs<(T0, T1)> for (As0, As1)
where\n As0: SerializeAs<T0>,\n As1: SerializeAs<T1>,

Source§

fn serialize_as<S>(\n tuple: &(T0, T1),\n serializer: S,\n) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>
where\n S: Serializer,

Serialize this value into the given Serde serializer.
","SerializeAs<(T0, T1)>","mito2::sst::file::FileTimeRange"],["
Source§

impl<T0, As0, T1, As1, T2, As2, T3, As3> SerializeAs<(T0, T1, T2, T3)> for (As0, As1, As2, As3)
where\n As0: SerializeAs<T0>,\n As1: SerializeAs<T1>,\n As2: SerializeAs<T2>,\n As3: SerializeAs<T3>,

Source§

fn serialize_as<S>(\n tuple: &(T0, T1, T2, T3),\n serializer: S,\n) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>
where\n S: Serializer,

Serialize this value into the given Serde serializer.
","SerializeAs<(T0, T1, T2, T3)>","mito2::cache::index::bloom_filter_index::BloomFilterIndexKey"],["
§

impl<'a, T, C0, C1> TreeNodeContainer<'a, T> for (C0, C1)
where\n T: 'a,\n C0: TreeNodeContainer<'a, T>,\n C1: TreeNodeContainer<'a, T>,

§

fn apply_elements<F>(\n &'a self,\n f: F,\n) -> Result<TreeNodeRecursion, DataFusionError>
where\n F: FnMut(&'a T) -> Result<TreeNodeRecursion, DataFusionError>,

Applies f to all elements of the container.\nThis method is usually called from [TreeNode::apply_children] implementations as\na node is actually a container of the node’s children.
§

fn map_elements<F>(self, f: F) -> Result<Transformed<(C0, C1)>, DataFusionError>
where\n F: FnMut(T) -> Result<Transformed<T>, DataFusionError>,

Maps all elements of the container with f.\nThis method is usually called from [TreeNode::map_children] implementations as\na node is actually a container of the node’s children.
","TreeNodeContainer<'a, T>","mito2::sst::file::FileTimeRange"],["
§

impl<'a, T, C0, C1, C2, C3> TreeNodeContainer<'a, T> for (C0, C1, C2, C3)
where\n T: 'a,\n C0: TreeNodeContainer<'a, T>,\n C1: TreeNodeContainer<'a, T>,\n C2: TreeNodeContainer<'a, T>,\n C3: TreeNodeContainer<'a, T>,

§

fn apply_elements<F>(\n &'a self,\n f: F,\n) -> Result<TreeNodeRecursion, DataFusionError>
where\n F: FnMut(&'a T) -> Result<TreeNodeRecursion, DataFusionError>,

Applies f to all elements of the container.\nThis method is usually called from [TreeNode::apply_children] implementations as\na node is actually a container of the node’s children.
§

fn map_elements<F>(\n self,\n f: F,\n) -> Result<Transformed<(C0, C1, C2, C3)>, DataFusionError>
where\n F: FnMut(T) -> Result<Transformed<T>, DataFusionError>,

Maps all elements of the container with f.\nThis method is usually called from [TreeNode::map_children] implementations as\na node is actually a container of the node’s children.
","TreeNodeContainer<'a, T>","mito2::cache::index::bloom_filter_index::BloomFilterIndexKey"],["
§

impl<Input, A, B, Error, FnA, FnB> Tuple<Input, (A, B), Error> for (FnA, FnB)
where\n Input: Clone,\n Error: ParseError<Input>,\n FnA: Parser<Input, A, Error>,\n FnB: Parser<Input, B, Error>,

§

fn parse(&mut self, input: Input) -> Result<(Input, (A, B)), Err<Error>>

Parses the input and returns a tuple of results of each parser.
","Tuple","mito2::sst::file::FileTimeRange"],["
§

impl<Input, A, B, Error, FnA, FnB> Tuple<Input, (A, B), Error> for (FnA, FnB)
where\n Input: Clone,\n Error: ParseError<Input>,\n FnA: Parser<Input, Output = A, Error = Error>,\n FnB: Parser<Input, Output = B, Error = Error>,

§

fn parse_tuple(&mut self, input: Input) -> Result<(Input, (A, B)), Err<Error>>

👎Deprecated since 8.0.0: Parser is directly implemented for tuples
Parses the input and returns a tuple of results of each parser.
","Tuple","mito2::sst::file::FileTimeRange"],["
§

impl<Input, A, B, C, D, Error, FnA, FnB, FnC, FnD> Tuple<Input, (A, B, C, D), Error> for (FnA, FnB, FnC, FnD)
where\n Input: Clone,\n Error: ParseError<Input>,\n FnA: Parser<Input, A, Error>,\n FnB: Parser<Input, B, Error>,\n FnC: Parser<Input, C, Error>,\n FnD: Parser<Input, D, Error>,

§

fn parse(&mut self, input: Input) -> Result<(Input, (A, B, C, D)), Err<Error>>

Parses the input and returns a tuple of results of each parser.
","Tuple","mito2::cache::index::bloom_filter_index::BloomFilterIndexKey"],["
§

impl<Input, A, B, C, D, Error, FnA, FnB, FnC, FnD> Tuple<Input, (A, B, C, D), Error> for (FnA, FnB, FnC, FnD)
where\n Input: Clone,\n Error: ParseError<Input>,\n FnA: Parser<Input, Output = A, Error = Error>,\n FnB: Parser<Input, Output = B, Error = Error>,\n FnC: Parser<Input, Output = C, Error = Error>,\n FnD: Parser<Input, Output = D, Error = Error>,

§

fn parse_tuple(\n &mut self,\n input: Input,\n) -> Result<(Input, (A, B, C, D)), Err<Error>>

👎Deprecated since 8.0.0: Parser is directly implemented for tuples
Parses the input and returns a tuple of results of each parser.
","Tuple","mito2::cache::index::bloom_filter_index::BloomFilterIndexKey"],["
§

impl<T1, T2> Type<Postgres> for (T1, T2)

§

fn type_info() -> PgTypeInfo

Returns the canonical SQL type for this Rust type. Read more
§

fn compatible(ty: &<DB as Database>::TypeInfo) -> bool

Determines if this Rust type is compatible with the given SQL type. Read more
","Type","mito2::sst::file::FileTimeRange"],["
§

impl<T1, T2, T3, T4> Type<Postgres> for (T1, T2, T3, T4)

§

fn type_info() -> PgTypeInfo

Returns the canonical SQL type for this Rust type. Read more
§

fn compatible(ty: &<DB as Database>::TypeInfo) -> bool

Determines if this Rust type is compatible with the given SQL type. Read more
","Type","mito2::cache::index::bloom_filter_index::BloomFilterIndexKey"],["
§

impl<T1, T0> Values for (T1, T0)
where\n T1: Values,\n T0: Values,

§

fn encoded_len(&self, mode: Mode) -> usize

Returns the length of the encoded values for the given mode.
§

fn write_encoded<W>(&self, mode: Mode, target: &mut W) -> Result<(), Error>
where\n W: Write,

Encodes the values in the given mode and writes them to target.
§

fn explicit(self, tag: Tag) -> Constructed<Self>
where\n Self: Sized,

Converts the encoder into one with an explicit tag.
§

fn to_captured(&self, mode: Mode) -> Captured

Captures the encoded values in the given mode.
","Values","mito2::sst::file::FileTimeRange"],["
§

impl<T3, T2, T1, T0> Values for (T3, T2, T1, T0)
where\n T3: Values,\n T2: Values,\n T1: Values,\n T0: Values,

§

fn encoded_len(&self, mode: Mode) -> usize

Returns the length of the encoded values for the given mode.
§

fn write_encoded<W>(&self, mode: Mode, target: &mut W) -> Result<(), Error>
where\n W: Write,

Encodes the values in the given mode and writes them to target.
§

fn explicit(self, tag: Tag) -> Constructed<Self>
where\n Self: Sized,

Converts the encoder into one with an explicit tag.
§

fn to_captured(&self, mode: Mode) -> Captured

Captures the encoded values in the given mode.
","Values","mito2::cache::index::bloom_filter_index::BloomFilterIndexKey"],["
§

impl<'a, T1, T2> Yokeable<'a> for (T1, T2)
where\n T1: 'static + for<'b> Yokeable<'b>,\n T2: 'static + for<'b> Yokeable<'b>,

§

type Output = (<T1 as Yokeable<'a>>::Output, <T2 as Yokeable<'a>>::Output)

This type MUST be Self with the 'static replaced with 'a, i.e. Self<'a>
§

fn transform(&'a self) -> &'a <(T1, T2) as Yokeable<'a>>::Output

This method must cast self between &'a Self<'static> and &'a Self<'a>. Read more
§

fn transform_owned(self) -> <(T1, T2) as Yokeable<'a>>::Output

This method must cast self between Self<'static> and Self<'a>. Read more
§

unsafe fn make(from: <(T1, T2) as Yokeable<'a>>::Output) -> (T1, T2)

This method can be used to cast away Self<'a>’s lifetime. Read more
§

fn transform_mut<F>(&'a mut self, f: F)
where\n F: 'static + for<'b> FnOnce(&'b mut <(T1, T2) as Yokeable<'a>>::Output),

This method must cast self between &'a mut Self<'static> and &'a mut Self<'a>,\nand pass it to f. Read more
","Yokeable<'a>","mito2::sst::file::FileTimeRange"],["
§

impl<'a, A, B, AE, BE, Format> ZeroFrom<'a, Tuple2VarULE<A, B, Format>> for (AE, BE)
where\n A: VarULE + ?Sized,\n B: VarULE + ?Sized,\n AE: ZeroFrom<'a, A>,\n BE: ZeroFrom<'a, B>,\n Format: VarZeroVecFormat,

§

fn zero_from(other: &'a Tuple2VarULE<A, B, Format>) -> (AE, BE)

Clone the other C into a struct that may retain references into C.
","ZeroFrom<'a, Tuple2VarULE>","mito2::sst::file::FileTimeRange"],["
§

impl<'a, A, B, C, D, AE, BE, CE, DE, Format> ZeroFrom<'a, Tuple4VarULE<A, B, C, D, Format>> for (AE, BE, CE, DE)
where\n A: VarULE + ?Sized,\n B: VarULE + ?Sized,\n C: VarULE + ?Sized,\n D: VarULE + ?Sized,\n AE: ZeroFrom<'a, A>,\n BE: ZeroFrom<'a, B>,\n CE: ZeroFrom<'a, C>,\n DE: ZeroFrom<'a, D>,\n Format: VarZeroVecFormat,

§

fn zero_from(other: &'a Tuple4VarULE<A, B, C, D, Format>) -> (AE, BE, CE, DE)

Clone the other C into a struct that may retain references into C.
","ZeroFrom<'a, Tuple4VarULE>","mito2::cache::index::bloom_filter_index::BloomFilterIndexKey"],["
§

impl<'zf, C1, T1, C2, T2> ZeroFrom<'zf, (C1, C2)> for (T1, T2)
where\n T1: ZeroFrom<'zf, C1>,\n T2: ZeroFrom<'zf, C2>,

§

fn zero_from(other: &'zf (C1, C2)) -> (T1, T2)

Clone the other C into a struct that may retain references into C.
","ZeroFrom<'zf, (C1, C2)>","mito2::sst::file::FileTimeRange"],["
§

impl<'zf, C1, T1, C2, T2, C3, T3, C4, T4> ZeroFrom<'zf, (C1, C2, C3, C4)> for (T1, T2, T3, T4)
where\n T1: ZeroFrom<'zf, C1>,\n T2: ZeroFrom<'zf, C2>,\n T3: ZeroFrom<'zf, C3>,\n T4: ZeroFrom<'zf, C4>,

§

fn zero_from(other: &'zf (C1, C2, C3, C4)) -> (T1, T2, T3, T4)

Clone the other C into a struct that may retain references into C.
","ZeroFrom<'zf, (C1, C2, C3, C4)>","mito2::cache::index::bloom_filter_index::BloomFilterIndexKey"],["
§

impl<'a, A, B> ZeroMapKV<'a> for (A, B)
where\n A: Ord + AsULE + 'static,\n B: Ord + AsULE + 'static,

§

type Container = ZeroVec<'a, (A, B)>

The container that can be used with this type: [ZeroVec] or [VarZeroVec].
§

type Slice = ZeroSlice<(A, B)>

§

type GetType = Tuple2ULE<<A as AsULE>::ULE, <B as AsULE>::ULE>

The type produced by Container::get() Read more
§

type OwnedType = (A, B)

The type produced by Container::replace() and Container::remove(),\nalso used during deserialization. If Self is human readable serialized,\ndeserializing to Self::OwnedType should produce the same value once\npassed through Self::owned_as_self() Read more
","ZeroMapKV<'a>","mito2::sst::file::FileTimeRange"],["
§

impl<'a, A, B, C, D> ZeroMapKV<'a> for (A, B, C, D)
where\n A: Ord + AsULE + 'static,\n B: Ord + AsULE + 'static,\n C: Ord + AsULE + 'static,\n D: Ord + AsULE + 'static,

§

type Container = ZeroVec<'a, (A, B, C, D)>

The container that can be used with this type: [ZeroVec] or [VarZeroVec].
§

type Slice = ZeroSlice<(A, B, C, D)>

§

type GetType = Tuple4ULE<<A as AsULE>::ULE, <B as AsULE>::ULE, <C as AsULE>::ULE, <D as AsULE>::ULE>

The type produced by Container::get() Read more
§

type OwnedType = (A, B, C, D)

The type produced by Container::replace() and Container::remove(),\nalso used during deserialization. If Self is human readable serialized,\ndeserializing to Self::OwnedType should produce the same value once\npassed through Self::owned_as_self() Read more
","ZeroMapKV<'a>","mito2::cache::index::bloom_filter_index::BloomFilterIndexKey"],["
§

impl<A, B> Zeroable for (A, B)
where\n A: Zeroable,\n B: Zeroable,

§

fn zeroed() -> Self

","Zeroable","mito2::sst::file::FileTimeRange"],["
§

impl<A, B, C, D> Zeroable for (A, B, C, D)
where\n A: Zeroable,\n B: Zeroable,\n C: Zeroable,\n D: Zeroable,

§

fn zeroed() -> Self

","Zeroable","mito2::cache::index::bloom_filter_index::BloomFilterIndexKey"],["
§

impl<A, B> Zeroize for (A, B)
where\n A: Zeroize,\n B: Zeroize,

§

fn zeroize(&mut self)

Zero out this object from memory using Rust intrinsics which ensure the\nzeroization operation is not “optimized away” by the compiler.
","Zeroize","mito2::sst::file::FileTimeRange"],["
§

impl<A, B, C, D> Zeroize for (A, B, C, D)
where\n A: Zeroize,\n B: Zeroize,\n C: Zeroize,\n D: Zeroize,

§

fn zeroize(&mut self)

Zero out this object from memory using Rust intrinsics which ensure the\nzeroization operation is not “optimized away” by the compiler.
","Zeroize","mito2::cache::index::bloom_filter_index::BloomFilterIndexKey"],["
§

impl<A, B> ZeroizeOnDrop for (A, B)
where\n A: ZeroizeOnDrop,\n B: ZeroizeOnDrop,

","ZeroizeOnDrop","mito2::sst::file::FileTimeRange"],["
§

impl<A, B, C, D> ZeroizeOnDrop for (A, B, C, D)
where\n A: ZeroizeOnDrop,\n B: ZeroizeOnDrop,\n C: ZeroizeOnDrop,\n D: ZeroizeOnDrop,

","ZeroizeOnDrop","mito2::cache::index::bloom_filter_index::BloomFilterIndexKey"]]],["pipeline",[["
§

impl<I, Output, Error, Alt2, Alt3> Alt<I, Output, Error> for (Alt2, Alt3)
where\n I: Stream,\n Error: ParserError<I>,\n Alt2: Parser<I, Output, Error>,\n Alt3: Parser<I, Output, Error>,

§

fn choice(&mut self, input: &mut I) -> Result<Output, Error>

Tests each parser in the tuple and returns the result of the first one that succeeds
","Alt","pipeline::etl::transform::transformer::greptime::RowWithTableSuffix","pipeline::manager::PipelineInfo"],["
§

impl<Input, Output, Error, A, B> Alt<Input, Output, Error> for (A, B)
where\n Input: Clone,\n Error: ParseError<Input>,\n A: Parser<Input, Output, Error>,\n B: Parser<Input, Output, Error>,

§

fn choice(&mut self, input: Input) -> Result<(Input, Output), Err<Error>>

Tests each parser in the tuple and returns the result of the first one that succeeds
","Alt","pipeline::etl::transform::transformer::greptime::RowWithTableSuffix","pipeline::manager::PipelineInfo"],["
§

impl<A, B> AsULE for (A, B)
where\n A: AsULE,\n B: AsULE,

§

type ULE = Tuple2ULE<<A as AsULE>::ULE, <B as AsULE>::ULE>

The ULE type corresponding to Self. Read more
§

fn to_unaligned(self) -> <(A, B) as AsULE>::ULE

Converts from Self to Self::ULE. Read more
§

fn from_unaligned(unaligned: <(A, B) as AsULE>::ULE) -> (A, B)

Converts from Self::ULE to Self. Read more
","AsULE","pipeline::etl::transform::transformer::greptime::RowWithTableSuffix","pipeline::manager::PipelineInfo"],["
§

impl<A, B> AssertFloatEq for (A, B)
where\n A: AssertFloatEq + Debug,\n B: AssertFloatEq + Debug + ?Sized,\n <A as FloatEq>::Tol: Sized,\n <B as FloatEq>::Tol: Sized,\n <A as AssertFloatEq>::DebugTol: Sized,\n <B as AssertFloatEq>::DebugTol: Sized,\n <<A as FloatEq>::Tol as FloatEqUlpsTol>::UlpsTol: Sized,\n <<B as FloatEq>::Tol as FloatEqUlpsTol>::UlpsTol: Sized,\n <<A as AssertFloatEq>::DebugTol as FloatEqUlpsTol>::UlpsTol: Sized,\n <<B as AssertFloatEq>::DebugTol as FloatEqUlpsTol>::UlpsTol: Sized,

§

type DebugAbsDiff = (<A as AssertFloatEq>::DebugAbsDiff, <B as AssertFloatEq>::DebugAbsDiff)

The absolute difference between two values, displayed to the user via\nfmt::Debug when an assert fails. Read more
§

type DebugTol = (<A as AssertFloatEq>::DebugTol, <B as AssertFloatEq>::DebugTol)

The per-field tolerance value used for comparison between two values,\ndisplayed to the user via fmt::Debug when an assert fails. Read more
§

fn debug_abs_diff(\n &self,\n other: &(A, B),\n) -> <(A, B) as AssertFloatEq>::DebugAbsDiff

Always positive absolute difference between two values. Read more
§

fn debug_ulps_diff(\n &self,\n other: &(A, B),\n) -> <<(A, B) as AssertFloatEq>::DebugAbsDiff as FloatEqDebugUlpsDiff>::DebugUlpsDiff

Always positive absolute difference between two values in terms of ULPs. Read more
§

fn debug_abs_tol(\n &self,\n other: &(A, B),\n tol: &<(A, B) as FloatEq>::Tol,\n) -> <(A, B) as AssertFloatEq>::DebugTol

The tolerance used by an abs comparison, displayed when an assert fails.
§

fn debug_rmax_tol(\n &self,\n other: &(A, B),\n tol: &<(A, B) as FloatEq>::Tol,\n) -> <(A, B) as AssertFloatEq>::DebugTol

The tolerance used by an rmax comparison, displayed when an assert fails. Read more
§

fn debug_rmin_tol(\n &self,\n other: &(A, B),\n tol: &<(A, B) as FloatEq>::Tol,\n) -> <(A, B) as AssertFloatEq>::DebugTol

The tolerance used by an rmin comparison, displayed when an assert fails. Read more
§

fn debug_r1st_tol(\n &self,\n other: &(A, B),\n tol: &<(A, B) as FloatEq>::Tol,\n) -> <(A, B) as AssertFloatEq>::DebugTol

The tolerance used by an r1st comparison, displayed when an assert fails. Read more
§

fn debug_r2nd_tol(\n &self,\n other: &(A, B),\n tol: &<(A, B) as FloatEq>::Tol,\n) -> <(A, B) as AssertFloatEq>::DebugTol

The tolerance used by an r2nd comparison, displayed when an assert fails. Read more
§

fn debug_ulps_tol(\n &self,\n other: &(A, B),\n tol: &<<(A, B) as FloatEq>::Tol as FloatEqUlpsTol>::UlpsTol,\n) -> <<(A, B) as AssertFloatEq>::DebugTol as FloatEqUlpsTol>::UlpsTol

The tolerance used by an ulps comparison, displayed when an assert fails.
§

fn debug_rel_tol(&self, other: &Rhs, tol: &Self::Tol) -> Self::DebugTol

The tolerance used by a rel comparison, displayed when an assert fails. Read more
","AssertFloatEq","pipeline::etl::transform::transformer::greptime::RowWithTableSuffix","pipeline::manager::PipelineInfo"],["
Source§

impl<S, T> Bounded for (S, T)
where\n S: Bounded,\n T: Bounded,

Source§

fn min_value() -> (S, T)

Returns the smallest finite number this type can represent
Source§

fn max_value() -> (S, T)

Returns the largest finite number this type can represent
","Bounded","pipeline::etl::transform::transformer::greptime::RowWithTableSuffix","pipeline::manager::PipelineInfo"],["
§

impl<T, F1, F2> ContainsToken<T> for (F1, F2)
where\n T: Clone,\n F1: ContainsToken<T>,\n F2: ContainsToken<T>,

§

fn contains_token(&self, token: T) -> bool

Returns true if self contains the token
","ContainsToken","pipeline::etl::transform::transformer::greptime::RowWithTableSuffix","pipeline::manager::PipelineInfo"],["
§

impl<'r, T1, T2> Decode<'r, Postgres> for (T1, T2)
where\n T1: 'r + Type<Postgres> + for<'a> Decode<'a, Postgres>,\n T2: 'r + Type<Postgres> + for<'a> Decode<'a, Postgres>,

§

fn decode(\n value: PgValueRef<'r>,\n) -> Result<(T1, T2), Box<dyn Error + Sync + Send>>

Decode a new value of this type using a raw value from the database.
","Decode<'r, Postgres>","pipeline::etl::transform::transformer::greptime::RowWithTableSuffix","pipeline::manager::PipelineInfo"],["
Source§

impl<'de, T0, T1> Deserialize<'de> for (T0, T1)
where\n T0: Deserialize<'de>,\n T1: Deserialize<'de>,

Source§

fn deserialize<D>(\n deserializer: D,\n) -> Result<(T0, T1), <D as Deserializer<'de>>::Error>
where\n D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer. Read more
","Deserialize<'de>","pipeline::etl::transform::transformer::greptime::RowWithTableSuffix","pipeline::manager::PipelineInfo"],["
Source§

impl<'de, T0, As0, T1, As1> DeserializeAs<'de, (T0, T1)> for (As0, As1)
where\n As0: DeserializeAs<'de, T0>,\n As1: DeserializeAs<'de, T1>,

Source§

fn deserialize_as<D>(\n deserializer: D,\n) -> Result<(T0, T1), <D as Deserializer<'de>>::Error>
where\n D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.
","DeserializeAs<'de, (T0, T1)>","pipeline::etl::transform::transformer::greptime::RowWithTableSuffix","pipeline::manager::PipelineInfo"],["
§

impl<A, B, AE, BE, Format> EncodeAsVarULE<Tuple2VarULE<A, B, Format>> for (AE, BE)
where\n A: VarULE + ?Sized,\n B: VarULE + ?Sized,\n AE: EncodeAsVarULE<A>,\n BE: EncodeAsVarULE<B>,\n Format: VarZeroVecFormat,

§

fn encode_var_ule_as_slices<R>(&self, _: impl FnOnce(&[&[u8]]) -> R) -> R

Calls cb with a piecewise list of byte slices that when concatenated\nproduce the memory pattern of the corresponding instance of T. Read more
§

fn encode_var_ule_len(&self) -> usize

Return the length, in bytes, of the corresponding [VarULE] type
§

fn encode_var_ule_write(&self, dst: &mut [u8])

Write the corresponding [VarULE] type to the dst buffer. dst should\nbe the size of [Self::encode_var_ule_len()]
","EncodeAsVarULE>","pipeline::etl::transform::transformer::greptime::RowWithTableSuffix","pipeline::manager::PipelineInfo"],["
§

impl<A, B> FloatEq for (A, B)
where\n A: FloatEq,\n B: FloatEq + ?Sized,\n <A as FloatEq>::Tol: Sized,\n <B as FloatEq>::Tol: Sized,\n <<A as FloatEq>::Tol as FloatEqUlpsTol>::UlpsTol: Sized,\n <<B as FloatEq>::Tol as FloatEqUlpsTol>::UlpsTol: Sized,

§

type Tol = (<A as FloatEq>::Tol, <B as FloatEq>::Tol)

Type of the maximum allowed difference between two values for them to be\nconsidered equal.
§

fn eq_abs(&self, other: &(A, B), tol: &<(A, B) as FloatEq>::Tol) -> bool

Check whether self is equal to other, using an absolute tolerance\ncomparison. Read more
§

fn eq_rmax(&self, other: &(A, B), tol: &<(A, B) as FloatEq>::Tol) -> bool

Check whether self is equal to other, using a relative tolerance\ncomparison, scaled to the granularity of the input with the largest\nmagnitude. Read more
§

fn eq_rmin(&self, other: &(A, B), tol: &<(A, B) as FloatEq>::Tol) -> bool

Check whether self is equal to other, using a relative tolerance\ncomparison, scaled to the granularity of the input with the smallest\nmagnitude. Read more
§

fn eq_r1st(&self, other: &(A, B), tol: &<(A, B) as FloatEq>::Tol) -> bool

Check whether self is equal to other, using a relative tolerance\ncomparison, scaled to the granularity of the first input. Read more
§

fn eq_r2nd(&self, other: &(A, B), tol: &<(A, B) as FloatEq>::Tol) -> bool

Check whether self is equal to other, using a relative tolerance\ncomparison, scaled to the granularity of the second input. Read more
§

fn eq_ulps(\n &self,\n other: &(A, B),\n tol: &<<(A, B) as FloatEq>::Tol as FloatEqUlpsTol>::UlpsTol,\n) -> bool

Check whether self is equal to other, using an ULPs comparison. Read more
§

fn ne_abs(&self, other: &Rhs, tol: &Self::Tol) -> bool

Check whether self is not equal to other, using an absolute tolerance\ncomparison. Read more
§

fn eq_rel(&self, other: &Rhs, tol: &Self::Tol) -> bool

Check whether self is equal to other, using a relative tolerance\ncomparison. Read more
§

fn ne_rel(&self, other: &Rhs, tol: &Self::Tol) -> bool

Check whether self is not equal to other, using a relative tolerance\ncomparison. Read more
§

fn ne_rmax(&self, other: &Rhs, tol: &Self::Tol) -> bool

Check whether self is not equal to other, using a relative tolerance\ncomparison. Read more
§

fn ne_rmin(&self, other: &Rhs, tol: &Self::Tol) -> bool

Check whether self is not equal to other, using a relative tolerance\ncomparison. Read more
§

fn ne_r1st(&self, other: &Rhs, tol: &Self::Tol) -> bool

Check whether self is not equal to other, using a relative tolerance\ncomparison. Read more
§

fn ne_r2nd(&self, other: &Rhs, tol: &Self::Tol) -> bool

Check whether self is not equal to other, using a relative tolerance\ncomparison. Read more
§

fn ne_ulps(\n &self,\n other: &Rhs,\n tol: &<Self::Tol as FloatEqUlpsTol>::UlpsTol,\n) -> bool

Check whether self is not equal to other, using an ULPs comparison. Read more
","FloatEq","pipeline::etl::transform::transformer::greptime::RowWithTableSuffix","pipeline::manager::PipelineInfo"],["
§

impl<A, B> FloatEqDebugUlpsDiff for (A, B)
where\n A: FloatEqDebugUlpsDiff,\n B: FloatEqDebugUlpsDiff,

§

type DebugUlpsDiff = (<A as FloatEqDebugUlpsDiff>::DebugUlpsDiff, <B as FloatEqDebugUlpsDiff>::DebugUlpsDiff)

A structurally identical type to Self, with fields recursively wrapped\nby DebugUlpsDiff.
","FloatEqDebugUlpsDiff","pipeline::etl::transform::transformer::greptime::RowWithTableSuffix","pipeline::manager::PipelineInfo"],["
§

impl<A, B> FloatEqUlpsTol for (A, B)
where\n A: FloatEqUlpsTol,\n B: FloatEqUlpsTol + ?Sized,\n <A as FloatEqUlpsTol>::UlpsTol: Sized,\n <B as FloatEqUlpsTol>::UlpsTol: Sized,

§

type UlpsTol = (<A as FloatEqUlpsTol>::UlpsTol, <B as FloatEqUlpsTol>::UlpsTol)

A structurally identical type to Self, with fields recursively wrapped\nby UlpsTol.
","FloatEqUlpsTol","pipeline::etl::transform::transformer::greptime::RowWithTableSuffix","pipeline::manager::PipelineInfo"],["
§

impl<T> From<Attr<T>> for (T, Option<T>)

Unpacks attribute key and value into tuple of this two elements.\nNone value element is returned only for [Attr::Empty] variant.

\n
§

fn from(attr: Attr<T>) -> (T, Option<T>)

Converts to this type from the input type.
","From>","pipeline::etl::transform::transformer::greptime::RowWithTableSuffix"],["
§

impl<T> From<Coord<T>> for (T, T)
where\n T: CoordNum,

§

fn from(coord: Coord<T>) -> (T, T)

Converts to this type from the input type.
","From>","pipeline::etl::transform::transformer::greptime::RowWithTableSuffix","pipeline::manager::PipelineInfo"],["
§

impl<T> From<Point<T>> for (T, T)
where\n T: CoordNum,

§

fn from(point: Point<T>) -> (T, T)

Converts to this type from the input type.
","From>","pipeline::etl::transform::transformer::greptime::RowWithTableSuffix","pipeline::manager::PipelineInfo"],["
§

impl<S> From<Point2<S>> for (S, S)
where\n S: SpadeNum,

§

fn from(point: Point2<S>) -> (S, S)

Converts to this type from the input type.
","From>","pipeline::etl::transform::transformer::greptime::RowWithTableSuffix","pipeline::manager::PipelineInfo"],["
Source§

impl<T> From<Ratio<T>> for (T, T)

Source§

fn from(val: Ratio<T>) -> (T, T)

Converts to this type from the input type.
","From>","pipeline::etl::transform::transformer::greptime::RowWithTableSuffix","pipeline::manager::PipelineInfo"],["
§

impl<A, B, FromA, FromB> FromParallelIterator<(A, B)> for (FromA, FromB)
where\n A: Send,\n B: Send,\n FromA: Send + FromParallelIterator<A>,\n FromB: Send + FromParallelIterator<B>,

§

fn from_par_iter<I>(pi: I) -> (FromA, FromB)
where\n I: IntoParallelIterator<Item = (A, B)>,

Creates an instance of the collection from the parallel iterator par_iter. Read more
","FromParallelIterator<(A, B)>","pipeline::etl::transform::transformer::greptime::RowWithTableSuffix","pipeline::manager::PipelineInfo"],["
§

impl<L, R, A, B> FromParallelIterator<Either<L, R>> for (A, B)
where\n L: Send,\n R: Send,\n A: Send + FromParallelIterator<L>,\n B: Send + FromParallelIterator<R>,

§

fn from_par_iter<I>(pi: I) -> (A, B)
where\n I: IntoParallelIterator<Item = Either<L, R>>,

Creates an instance of the collection from the parallel iterator par_iter. Read more
","FromParallelIterator>","pipeline::etl::transform::transformer::greptime::RowWithTableSuffix","pipeline::manager::PipelineInfo"],["
§

impl<S, T1, T2> FromRequest<S> for (T1, T2)
where\n T1: FromRequestParts<S> + Send,\n T2: FromRequest<S> + Send,\n S: Send + Sync,

§

type Rejection = Response<Body>

If the extractor fails it’ll use this “rejection” type. A rejection is\na kind of error that can be converted into a response.
§

fn from_request(\n req: Request<Body>,\n state: &S,\n) -> impl Future<Output = Result<(T1, T2), <(T1, T2) as FromRequest<S>>::Rejection>>

Perform the extraction.
","FromRequest","pipeline::etl::transform::transformer::greptime::RowWithTableSuffix","pipeline::manager::PipelineInfo"],["
§

impl<S, T1, T2> FromRequestParts<S> for (T1, T2)
where\n T1: FromRequestParts<S> + Send,\n T2: FromRequestParts<S> + Send,\n S: Send + Sync,

§

type Rejection = Response<Body>

If the extractor fails it’ll use this “rejection” type. A rejection is\na kind of error that can be converted into a response.
§

async fn from_request_parts(\n parts: &mut Parts,\n state: &S,\n) -> Result<(T1, T2), <(T1, T2) as FromRequestParts<S>>::Rejection>

Perform the extraction.
","FromRequestParts","pipeline::etl::transform::transformer::greptime::RowWithTableSuffix","pipeline::manager::PipelineInfo"],["
§

impl<'r, R, T1, T2> FromRow<'r, R> for (T1, T2)
where\n R: Row,\n usize: ColumnIndex<R>,\n T1: Decode<'r, <R as Row>::Database> + Type<<R as Row>::Database>,\n T2: Decode<'r, <R as Row>::Database> + Type<<R as Row>::Database>,

§

fn from_row(row: &'r R) -> Result<(T1, T2), Error>

","FromRow<'r, R>","pipeline::etl::transform::transformer::greptime::RowWithTableSuffix","pipeline::manager::PipelineInfo"],["
§

impl<F, Fut, Res, S> Handler<((),), S> for F
where\n F: FnOnce() -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n Res: IntoResponse,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n _req: Request<Body>,\n _state: S,\n) -> <F as Handler<((),), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<((),), S>","pipeline::etl::transform::transformer::greptime::RowWithTableSuffix","pipeline::manager::PipelineInfo"],["
§

impl<F, Fut, S, Res, M, T1> Handler<(M, T1), S> for F
where\n F: FnOnce(T1) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1), S>","pipeline::etl::transform::transformer::greptime::RowWithTableSuffix","pipeline::manager::PipelineInfo"],["
§

impl<F, Fut, S, Res, M, T1, T2> Handler<(M, T1, T2), S> for F
where\n F: FnOnce(T1, T2) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequestParts<S> + Send,\n T2: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1, T2), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1, T2), S>","pipeline::etl::transform::transformer::greptime::RowWithTableSuffix","pipeline::manager::PipelineInfo"],["
§

impl<F, Fut, S, Res, M, T1, T2, T3> Handler<(M, T1, T2, T3), S> for F
where\n F: FnOnce(T1, T2, T3) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequestParts<S> + Send,\n T2: FromRequestParts<S> + Send,\n T3: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1, T2, T3), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1, T2, T3), S>","pipeline::etl::transform::transformer::greptime::RowWithTableSuffix","pipeline::manager::PipelineInfo"],["
§

impl<F, Fut, S, Res, M, T1, T2, T3, T4> Handler<(M, T1, T2, T3, T4), S> for F
where\n F: FnOnce(T1, T2, T3, T4) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequestParts<S> + Send,\n T2: FromRequestParts<S> + Send,\n T3: FromRequestParts<S> + Send,\n T4: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1, T2, T3, T4), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1, T2, T3, T4), S>","pipeline::etl::transform::transformer::greptime::RowWithTableSuffix","pipeline::manager::PipelineInfo"],["
§

impl<F, Fut, S, Res, M, T1, T2, T3, T4, T5> Handler<(M, T1, T2, T3, T4, T5), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequestParts<S> + Send,\n T2: FromRequestParts<S> + Send,\n T3: FromRequestParts<S> + Send,\n T4: FromRequestParts<S> + Send,\n T5: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1, T2, T3, T4, T5), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1, T2, T3, T4, T5), S>","pipeline::etl::transform::transformer::greptime::RowWithTableSuffix","pipeline::manager::PipelineInfo"],["
§

impl<F, Fut, S, Res, M, T1, T2, T3, T4, T5, T6> Handler<(M, T1, T2, T3, T4, T5, T6), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5, T6) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequestParts<S> + Send,\n T2: FromRequestParts<S> + Send,\n T3: FromRequestParts<S> + Send,\n T4: FromRequestParts<S> + Send,\n T5: FromRequestParts<S> + Send,\n T6: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1, T2, T3, T4, T5, T6), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1, T2, T3, T4, T5, T6), S>","pipeline::etl::transform::transformer::greptime::RowWithTableSuffix","pipeline::manager::PipelineInfo"],["
§

impl<F, Fut, S, Res, M, T1, T2, T3, T4, T5, T6, T7> Handler<(M, T1, T2, T3, T4, T5, T6, T7), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5, T6, T7) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequestParts<S> + Send,\n T2: FromRequestParts<S> + Send,\n T3: FromRequestParts<S> + Send,\n T4: FromRequestParts<S> + Send,\n T5: FromRequestParts<S> + Send,\n T6: FromRequestParts<S> + Send,\n T7: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1, T2, T3, T4, T5, T6, T7), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1, T2, T3, T4, T5, T6, T7), S>","pipeline::etl::transform::transformer::greptime::RowWithTableSuffix","pipeline::manager::PipelineInfo"],["
§

impl<F, Fut, S, Res, M, T1, T2, T3, T4, T5, T6, T7, T8> Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5, T6, T7, T8) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequestParts<S> + Send,\n T2: FromRequestParts<S> + Send,\n T3: FromRequestParts<S> + Send,\n T4: FromRequestParts<S> + Send,\n T5: FromRequestParts<S> + Send,\n T6: FromRequestParts<S> + Send,\n T7: FromRequestParts<S> + Send,\n T8: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8), S>","pipeline::etl::transform::transformer::greptime::RowWithTableSuffix","pipeline::manager::PipelineInfo"],["
§

impl<F, Fut, S, Res, M, T1, T2, T3, T4, T5, T6, T7, T8, T9> Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5, T6, T7, T8, T9) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequestParts<S> + Send,\n T2: FromRequestParts<S> + Send,\n T3: FromRequestParts<S> + Send,\n T4: FromRequestParts<S> + Send,\n T5: FromRequestParts<S> + Send,\n T6: FromRequestParts<S> + Send,\n T7: FromRequestParts<S> + Send,\n T8: FromRequestParts<S> + Send,\n T9: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9), S>","pipeline::etl::transform::transformer::greptime::RowWithTableSuffix","pipeline::manager::PipelineInfo"],["
§

impl<F, Fut, S, Res, M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequestParts<S> + Send,\n T2: FromRequestParts<S> + Send,\n T3: FromRequestParts<S> + Send,\n T4: FromRequestParts<S> + Send,\n T5: FromRequestParts<S> + Send,\n T6: FromRequestParts<S> + Send,\n T7: FromRequestParts<S> + Send,\n T8: FromRequestParts<S> + Send,\n T9: FromRequestParts<S> + Send,\n T10: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10), S>","pipeline::etl::transform::transformer::greptime::RowWithTableSuffix","pipeline::manager::PipelineInfo"],["
§

impl<F, Fut, S, Res, M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequestParts<S> + Send,\n T2: FromRequestParts<S> + Send,\n T3: FromRequestParts<S> + Send,\n T4: FromRequestParts<S> + Send,\n T5: FromRequestParts<S> + Send,\n T6: FromRequestParts<S> + Send,\n T7: FromRequestParts<S> + Send,\n T8: FromRequestParts<S> + Send,\n T9: FromRequestParts<S> + Send,\n T10: FromRequestParts<S> + Send,\n T11: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11), S>","pipeline::etl::transform::transformer::greptime::RowWithTableSuffix","pipeline::manager::PipelineInfo"],["
§

impl<F, Fut, S, Res, M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequestParts<S> + Send,\n T2: FromRequestParts<S> + Send,\n T3: FromRequestParts<S> + Send,\n T4: FromRequestParts<S> + Send,\n T5: FromRequestParts<S> + Send,\n T6: FromRequestParts<S> + Send,\n T7: FromRequestParts<S> + Send,\n T8: FromRequestParts<S> + Send,\n T9: FromRequestParts<S> + Send,\n T10: FromRequestParts<S> + Send,\n T11: FromRequestParts<S> + Send,\n T12: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12), S>","pipeline::etl::transform::transformer::greptime::RowWithTableSuffix","pipeline::manager::PipelineInfo"],["
§

impl<F, Fut, S, Res, M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequestParts<S> + Send,\n T2: FromRequestParts<S> + Send,\n T3: FromRequestParts<S> + Send,\n T4: FromRequestParts<S> + Send,\n T5: FromRequestParts<S> + Send,\n T6: FromRequestParts<S> + Send,\n T7: FromRequestParts<S> + Send,\n T8: FromRequestParts<S> + Send,\n T9: FromRequestParts<S> + Send,\n T10: FromRequestParts<S> + Send,\n T11: FromRequestParts<S> + Send,\n T12: FromRequestParts<S> + Send,\n T13: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13), S>","pipeline::etl::transform::transformer::greptime::RowWithTableSuffix","pipeline::manager::PipelineInfo"],["
§

impl<F, Fut, S, Res, M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequestParts<S> + Send,\n T2: FromRequestParts<S> + Send,\n T3: FromRequestParts<S> + Send,\n T4: FromRequestParts<S> + Send,\n T5: FromRequestParts<S> + Send,\n T6: FromRequestParts<S> + Send,\n T7: FromRequestParts<S> + Send,\n T8: FromRequestParts<S> + Send,\n T9: FromRequestParts<S> + Send,\n T10: FromRequestParts<S> + Send,\n T11: FromRequestParts<S> + Send,\n T12: FromRequestParts<S> + Send,\n T13: FromRequestParts<S> + Send,\n T14: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14), S>","pipeline::etl::transform::transformer::greptime::RowWithTableSuffix","pipeline::manager::PipelineInfo"],["
§

impl<F, Fut, S, Res, M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequestParts<S> + Send,\n T2: FromRequestParts<S> + Send,\n T3: FromRequestParts<S> + Send,\n T4: FromRequestParts<S> + Send,\n T5: FromRequestParts<S> + Send,\n T6: FromRequestParts<S> + Send,\n T7: FromRequestParts<S> + Send,\n T8: FromRequestParts<S> + Send,\n T9: FromRequestParts<S> + Send,\n T10: FromRequestParts<S> + Send,\n T11: FromRequestParts<S> + Send,\n T12: FromRequestParts<S> + Send,\n T13: FromRequestParts<S> + Send,\n T14: FromRequestParts<S> + Send,\n T15: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15), S>","pipeline::etl::transform::transformer::greptime::RowWithTableSuffix","pipeline::manager::PipelineInfo"],["
§

impl<F, Fut, S, Res, M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16> Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequestParts<S> + Send,\n T2: FromRequestParts<S> + Send,\n T3: FromRequestParts<S> + Send,\n T4: FromRequestParts<S> + Send,\n T5: FromRequestParts<S> + Send,\n T6: FromRequestParts<S> + Send,\n T7: FromRequestParts<S> + Send,\n T8: FromRequestParts<S> + Send,\n T9: FromRequestParts<S> + Send,\n T10: FromRequestParts<S> + Send,\n T11: FromRequestParts<S> + Send,\n T12: FromRequestParts<S> + Send,\n T13: FromRequestParts<S> + Send,\n T14: FromRequestParts<S> + Send,\n T15: FromRequestParts<S> + Send,\n T16: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16), S>","pipeline::etl::transform::transformer::greptime::RowWithTableSuffix","pipeline::manager::PipelineInfo"],["
§

impl<A, B> IntoParallelIterator for (A, B)
where\n A: IntoParallelIterator,\n <A as IntoParallelIterator>::Iter: IndexedParallelIterator,\n B: IntoParallelIterator,\n <B as IntoParallelIterator>::Iter: IndexedParallelIterator,

§

type Item = (<A as IntoParallelIterator>::Item, <B as IntoParallelIterator>::Item)

The type of item that the parallel iterator will produce.
§

type Iter = MultiZip<(<A as IntoParallelIterator>::Iter, <B as IntoParallelIterator>::Iter)>

The parallel iterator type that will be created.
§

fn into_par_iter(self) -> <(A, B) as IntoParallelIterator>::Iter

Converts self into a parallel iterator. Read more
","IntoParallelIterator","pipeline::etl::transform::transformer::greptime::RowWithTableSuffix","pipeline::manager::PipelineInfo"],["
§

impl<R, T1> IntoResponse for (T1, R)
where\n T1: IntoResponseParts,\n R: IntoResponse,

§

fn into_response(self) -> Response<Body>

Create a response.
","IntoResponse","pipeline::etl::transform::transformer::greptime::RowWithTableSuffix","pipeline::manager::PipelineInfo"],["
§

impl<T1, T2> IntoResponseParts for (T1, T2)
where\n T1: IntoResponseParts,\n T2: IntoResponseParts,

§

type Error = Response<Body>

The type returned in the event of an error. Read more
§

fn into_response_parts(\n self,\n res: ResponseParts,\n) -> Result<ResponseParts, <(T1, T2) as IntoResponseParts>::Error>

Set parts of the response
","IntoResponseParts","pipeline::etl::transform::transformer::greptime::RowWithTableSuffix","pipeline::manager::PipelineInfo"],["
Source§

impl<Ix, E> IntoWeightedEdge<E> for (Ix, Ix)
where\n E: Default,

","IntoWeightedEdge","pipeline::etl::transform::transformer::greptime::RowWithTableSuffix","pipeline::manager::PipelineInfo"],["
Source§

impl<Ix, E> IntoWeightedEdge<E> for (Ix, Ix)
where\n E: Default,

","IntoWeightedEdge","pipeline::etl::transform::transformer::greptime::RowWithTableSuffix","pipeline::manager::PipelineInfo"],["
§

impl<S, L1, L2> Layer<S> for (L1, L2)
where\n L1: Layer<<L2 as Layer<S>>::Service>,\n L2: Layer<S>,

§

type Service = <L1 as Layer<<L2 as Layer<S>>::Service>>::Service

The wrapped service
§

fn layer(&self, service: S) -> <(L1, L2) as Layer<S>>::Service

Wrap the given service with the middleware, returning a new service\nthat has been decorated with the middleware.
","Layer","pipeline::etl::transform::transformer::greptime::RowWithTableSuffix","pipeline::manager::PipelineInfo"],["
Source§

impl<IT, A, FromA> MultiUnzip<(FromA,)> for IT
where\n IT: Iterator<Item = (A,)>,\n FromA: Default + Extend<A>,

Source§

fn multiunzip(self) -> (FromA,)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA,)>","pipeline::etl::transform::transformer::greptime::RowWithTableSuffix","pipeline::manager::PipelineInfo"],["
§

impl<IT, A, FromA> MultiUnzip<(FromA,)> for IT
where\n IT: Iterator<Item = (A,)>,\n FromA: Default + Extend<A>,

§

fn multiunzip(self) -> (FromA,)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA,)>","pipeline::etl::transform::transformer::greptime::RowWithTableSuffix","pipeline::manager::PipelineInfo"],["
§

impl<IT, A, FromA> MultiUnzip<(FromA,)> for IT
where\n IT: Iterator<Item = (A,)>,\n FromA: Default + Extend<A>,

§

fn multiunzip(self) -> (FromA,)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA,)>","pipeline::etl::transform::transformer::greptime::RowWithTableSuffix","pipeline::manager::PipelineInfo"],["
Source§

impl<IT, A, FromA, B, FromB, C, FromC> MultiUnzip<(FromA, FromB, FromC)> for IT
where\n IT: Iterator<Item = (A, B, C)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,

Source§

fn multiunzip(self) -> (FromA, FromB, FromC)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC)>","pipeline::etl::transform::transformer::greptime::RowWithTableSuffix","pipeline::manager::PipelineInfo"],["
§

impl<IT, A, FromA, B, FromB, C, FromC> MultiUnzip<(FromA, FromB, FromC)> for IT
where\n IT: Iterator<Item = (A, B, C)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,

§

fn multiunzip(self) -> (FromA, FromB, FromC)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC)>","pipeline::etl::transform::transformer::greptime::RowWithTableSuffix","pipeline::manager::PipelineInfo"],["
§

impl<IT, A, FromA, B, FromB, C, FromC> MultiUnzip<(FromA, FromB, FromC)> for IT
where\n IT: Iterator<Item = (A, B, C)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,

§

fn multiunzip(self) -> (FromA, FromB, FromC)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC)>","pipeline::etl::transform::transformer::greptime::RowWithTableSuffix","pipeline::manager::PipelineInfo"],["
Source§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD> MultiUnzip<(FromA, FromB, FromC, FromD)> for IT
where\n IT: Iterator<Item = (A, B, C, D)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,

Source§

fn multiunzip(self) -> (FromA, FromB, FromC, FromD)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD)>","pipeline::etl::transform::transformer::greptime::RowWithTableSuffix","pipeline::manager::PipelineInfo"],["
§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD> MultiUnzip<(FromA, FromB, FromC, FromD)> for IT
where\n IT: Iterator<Item = (A, B, C, D)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,

§

fn multiunzip(self) -> (FromA, FromB, FromC, FromD)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD)>","pipeline::etl::transform::transformer::greptime::RowWithTableSuffix","pipeline::manager::PipelineInfo"],["
§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD> MultiUnzip<(FromA, FromB, FromC, FromD)> for IT
where\n IT: Iterator<Item = (A, B, C, D)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,

§

fn multiunzip(self) -> (FromA, FromB, FromC, FromD)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD)>","pipeline::etl::transform::transformer::greptime::RowWithTableSuffix","pipeline::manager::PipelineInfo"],["
Source§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE> MultiUnzip<(FromA, FromB, FromC, FromD, FromE)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,

Source§

fn multiunzip(self) -> (FromA, FromB, FromC, FromD, FromE)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE)>","pipeline::etl::transform::transformer::greptime::RowWithTableSuffix","pipeline::manager::PipelineInfo"],["
§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE> MultiUnzip<(FromA, FromB, FromC, FromD, FromE)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,

§

fn multiunzip(self) -> (FromA, FromB, FromC, FromD, FromE)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE)>","pipeline::etl::transform::transformer::greptime::RowWithTableSuffix","pipeline::manager::PipelineInfo"],["
§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE> MultiUnzip<(FromA, FromB, FromC, FromD, FromE)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,

§

fn multiunzip(self) -> (FromA, FromB, FromC, FromD, FromE)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE)>","pipeline::etl::transform::transformer::greptime::RowWithTableSuffix","pipeline::manager::PipelineInfo"],["
Source§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E, F)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,\n FromF: Default + Extend<F>,

Source§

fn multiunzip(self) -> (FromA, FromB, FromC, FromD, FromE, FromF)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF)>","pipeline::etl::transform::transformer::greptime::RowWithTableSuffix","pipeline::manager::PipelineInfo"],["
§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E, F)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,\n FromF: Default + Extend<F>,

§

fn multiunzip(self) -> (FromA, FromB, FromC, FromD, FromE, FromF)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF)>","pipeline::etl::transform::transformer::greptime::RowWithTableSuffix","pipeline::manager::PipelineInfo"],["
§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E, F)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,\n FromF: Default + Extend<F>,

§

fn multiunzip(self) -> (FromA, FromB, FromC, FromD, FromE, FromF)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF)>","pipeline::etl::transform::transformer::greptime::RowWithTableSuffix","pipeline::manager::PipelineInfo"],["
Source§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E, F, G)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,\n FromF: Default + Extend<F>,\n FromG: Default + Extend<G>,

Source§

fn multiunzip(self) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG)>","pipeline::etl::transform::transformer::greptime::RowWithTableSuffix","pipeline::manager::PipelineInfo"],["
§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E, F, G)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,\n FromF: Default + Extend<F>,\n FromG: Default + Extend<G>,

§

fn multiunzip(self) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG)>","pipeline::etl::transform::transformer::greptime::RowWithTableSuffix","pipeline::manager::PipelineInfo"],["
§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E, F, G)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,\n FromF: Default + Extend<F>,\n FromG: Default + Extend<G>,

§

fn multiunzip(self) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG)>","pipeline::etl::transform::transformer::greptime::RowWithTableSuffix","pipeline::manager::PipelineInfo"],["
Source§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E, F, G, H)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,\n FromF: Default + Extend<F>,\n FromG: Default + Extend<G>,\n FromH: Default + Extend<H>,

Source§

fn multiunzip(self) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH)>","pipeline::etl::transform::transformer::greptime::RowWithTableSuffix","pipeline::manager::PipelineInfo"],["
§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E, F, G, H)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,\n FromF: Default + Extend<F>,\n FromG: Default + Extend<G>,\n FromH: Default + Extend<H>,

§

fn multiunzip(self) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH)>","pipeline::etl::transform::transformer::greptime::RowWithTableSuffix","pipeline::manager::PipelineInfo"],["
§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E, F, G, H)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,\n FromF: Default + Extend<F>,\n FromG: Default + Extend<G>,\n FromH: Default + Extend<H>,

§

fn multiunzip(self) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH)>","pipeline::etl::transform::transformer::greptime::RowWithTableSuffix","pipeline::manager::PipelineInfo"],["
Source§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E, F, G, H, I)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,\n FromF: Default + Extend<F>,\n FromG: Default + Extend<G>,\n FromH: Default + Extend<H>,\n FromI: Default + Extend<I>,

Source§

fn multiunzip(\n self,\n) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI)>","pipeline::etl::transform::transformer::greptime::RowWithTableSuffix","pipeline::manager::PipelineInfo"],["
§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E, F, G, H, I)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,\n FromF: Default + Extend<F>,\n FromG: Default + Extend<G>,\n FromH: Default + Extend<H>,\n FromI: Default + Extend<I>,

§

fn multiunzip(\n self,\n) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI)>","pipeline::etl::transform::transformer::greptime::RowWithTableSuffix","pipeline::manager::PipelineInfo"],["
§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E, F, G, H, I)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,\n FromF: Default + Extend<F>,\n FromG: Default + Extend<G>,\n FromH: Default + Extend<H>,\n FromI: Default + Extend<I>,

§

fn multiunzip(\n self,\n) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI)>","pipeline::etl::transform::transformer::greptime::RowWithTableSuffix","pipeline::manager::PipelineInfo"],["
Source§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,\n FromF: Default + Extend<F>,\n FromG: Default + Extend<G>,\n FromH: Default + Extend<H>,\n FromI: Default + Extend<I>,\n FromJ: Default + Extend<J>,

Source§

fn multiunzip(\n self,\n) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ)>","pipeline::etl::transform::transformer::greptime::RowWithTableSuffix","pipeline::manager::PipelineInfo"],["
§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,\n FromF: Default + Extend<F>,\n FromG: Default + Extend<G>,\n FromH: Default + Extend<H>,\n FromI: Default + Extend<I>,\n FromJ: Default + Extend<J>,

§

fn multiunzip(\n self,\n) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ)>","pipeline::etl::transform::transformer::greptime::RowWithTableSuffix","pipeline::manager::PipelineInfo"],["
§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,\n FromF: Default + Extend<F>,\n FromG: Default + Extend<G>,\n FromH: Default + Extend<H>,\n FromI: Default + Extend<I>,\n FromJ: Default + Extend<J>,

§

fn multiunzip(\n self,\n) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ)>","pipeline::etl::transform::transformer::greptime::RowWithTableSuffix","pipeline::manager::PipelineInfo"],["
Source§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ, K, FromK> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J, K)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,\n FromF: Default + Extend<F>,\n FromG: Default + Extend<G>,\n FromH: Default + Extend<H>,\n FromI: Default + Extend<I>,\n FromJ: Default + Extend<J>,\n FromK: Default + Extend<K>,

Source§

fn multiunzip(\n self,\n) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK)>","pipeline::etl::transform::transformer::greptime::RowWithTableSuffix","pipeline::manager::PipelineInfo"],["
§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ, K, FromK> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J, K)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,\n FromF: Default + Extend<F>,\n FromG: Default + Extend<G>,\n FromH: Default + Extend<H>,\n FromI: Default + Extend<I>,\n FromJ: Default + Extend<J>,\n FromK: Default + Extend<K>,

§

fn multiunzip(\n self,\n) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK)>","pipeline::etl::transform::transformer::greptime::RowWithTableSuffix","pipeline::manager::PipelineInfo"],["
§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ, K, FromK> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J, K)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,\n FromF: Default + Extend<F>,\n FromG: Default + Extend<G>,\n FromH: Default + Extend<H>,\n FromI: Default + Extend<I>,\n FromJ: Default + Extend<J>,\n FromK: Default + Extend<K>,

§

fn multiunzip(\n self,\n) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK)>","pipeline::etl::transform::transformer::greptime::RowWithTableSuffix","pipeline::manager::PipelineInfo"],["
Source§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ, K, FromK, L, FromL> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK, FromL)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J, K, L)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,\n FromF: Default + Extend<F>,\n FromG: Default + Extend<G>,\n FromH: Default + Extend<H>,\n FromI: Default + Extend<I>,\n FromJ: Default + Extend<J>,\n FromK: Default + Extend<K>,\n FromL: Default + Extend<L>,

","MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK, FromL)>","pipeline::etl::transform::transformer::greptime::RowWithTableSuffix","pipeline::manager::PipelineInfo"],["
§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ, K, FromK, L, FromL> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK, FromL)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J, K, L)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,\n FromF: Default + Extend<F>,\n FromG: Default + Extend<G>,\n FromH: Default + Extend<H>,\n FromI: Default + Extend<I>,\n FromJ: Default + Extend<J>,\n FromK: Default + Extend<K>,\n FromL: Default + Extend<L>,

§

fn multiunzip(\n self,\n) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK, FromL)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK, FromL)>","pipeline::etl::transform::transformer::greptime::RowWithTableSuffix","pipeline::manager::PipelineInfo"],["
§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ, K, FromK, L, FromL> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK, FromL)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J, K, L)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,\n FromF: Default + Extend<F>,\n FromG: Default + Extend<G>,\n FromH: Default + Extend<H>,\n FromI: Default + Extend<I>,\n FromJ: Default + Extend<J>,\n FromK: Default + Extend<K>,\n FromL: Default + Extend<L>,

§

fn multiunzip(\n self,\n) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK, FromL)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK, FromL)>","pipeline::etl::transform::transformer::greptime::RowWithTableSuffix","pipeline::manager::PipelineInfo"],["
§

impl<A, B, FromA, FromB> ParallelExtend<(A, B)> for (FromA, FromB)
where\n A: Send,\n B: Send,\n FromA: Send + ParallelExtend<A>,\n FromB: Send + ParallelExtend<B>,

§

fn par_extend<I>(&mut self, pi: I)
where\n I: IntoParallelIterator<Item = (A, B)>,

Extends an instance of the collection with the elements drawn\nfrom the parallel iterator par_iter. Read more
","ParallelExtend<(A, B)>","pipeline::etl::transform::transformer::greptime::RowWithTableSuffix","pipeline::manager::PipelineInfo"],["
§

impl<L, R, A, B> ParallelExtend<Either<L, R>> for (A, B)
where\n L: Send,\n R: Send,\n A: Send + ParallelExtend<L>,\n B: Send + ParallelExtend<R>,

§

fn par_extend<I>(&mut self, pi: I)
where\n I: IntoParallelIterator<Item = Either<L, R>>,

Extends an instance of the collection with the elements drawn\nfrom the parallel iterator par_iter. Read more
","ParallelExtend>","pipeline::etl::transform::transformer::greptime::RowWithTableSuffix","pipeline::manager::PipelineInfo"],["
§

impl<I, O1, O2, E, P1, P2> Parser<I> for (P1, P2)
where\n E: ParseError<I>,\n P1: Parser<I, Output = O1, Error = E>,\n P2: Parser<I, Output = O2, Error = E>,

§

type Output = (O1, O2)

Type of the produced value
§

type Error = E

Error type of this parser
§

fn process<OM>(\n &mut self,\n i: I,\n) -> Result<(I, <<OM as OutputMode>::Output as Mode>::Output<<(P1, P2) as Parser<I>>::Output>), Err<<(P1, P2) as Parser<I>>::Error, <<OM as OutputMode>::Error as Mode>::Output<<(P1, P2) as Parser<I>>::Error>>>
where\n OM: OutputMode,

A parser takes in input type, and returns a Result containing\neither the remaining input and the output value, or an error
§

fn parse(\n &mut self,\n input: Input,\n) -> Result<(Input, Self::Output), Err<Self::Error>>

A parser takes in input type, and returns a Result containing\neither the remaining input and the output value, or an error
§

fn parse_complete(\n &mut self,\n input: Input,\n) -> Result<(Input, Self::Output), Err<Self::Error>>

A parser takes in input type, and returns a Result containing\neither the remaining input and the output value, or an error
§

fn map<G, O2>(self, g: G) -> Map<Self, G>
where\n G: FnMut(Self::Output) -> O2,\n Self: Sized,

Maps a function over the result of a parser
§

fn map_res<G, O2, E2>(self, g: G) -> MapRes<Self, G>
where\n G: FnMut(Self::Output) -> Result<O2, E2>,\n Self::Error: FromExternalError<Input, E2>,\n Self: Sized,

Applies a function returning a Result over the result of a parser.
§

fn map_opt<G, O2>(self, g: G) -> MapOpt<Self, G>
where\n G: FnMut(Self::Output) -> Option<O2>,\n Self: Sized,

Applies a function returning an Option over the result of a parser.
§

fn flat_map<G, H>(self, g: G) -> FlatMap<Self, G>
where\n G: FnMut(Self::Output) -> H,\n H: Parser<Input, Error = Self::Error>,\n Self: Sized,

Creates a second parser from the output of the first one, then apply over the rest of the input
§

fn and_then<G>(self, g: G) -> AndThen<Self, G>
where\n G: Parser<Self::Output, Error = Self::Error>,\n Self: Sized,

Applies a second parser over the output of the first one
§

fn and<G, O2>(self, g: G) -> And<Self, G>
where\n G: Parser<Input, Output = O2, Error = Self::Error>,\n Self: Sized,

Applies a second parser after the first one, return their results as a tuple
§

fn or<G>(self, g: G) -> Or<Self, G>
where\n G: Parser<Input, Output = Self::Output, Error = Self::Error>,\n Self: Sized,

Applies a second parser over the input if the first one failed
§

fn into<O2, E2>(self) -> Into<Self, O2, E2>
where\n O2: From<Self::Output>,\n E2: From<Self::Error>,\n Self: Sized,

automatically converts the parser’s output and error values to another type, as long as they\nimplement the From trait
","Parser","pipeline::etl::transform::transformer::greptime::RowWithTableSuffix","pipeline::manager::PipelineInfo"],["
§

impl<I, O0, O1, E, P0, P1> Parser<I, (O0, O1), E> for (P0, P1)
where\n I: Stream,\n E: ParserError<I>,\n P0: Parser<I, O0, E>,\n P1: Parser<I, O1, E>,

§

fn parse_next(&mut self, i: &mut I) -> Result<(O0, O1), E>

Take tokens from the [Stream], turning it into the output Read more
§

fn parse(\n &mut self,\n input: I,\n) -> Result<O, ParseError<I, <E as ParserError<I>>::Inner>>
where\n Self: Sized,\n I: Stream + StreamIsPartial,\n E: ParserError<I>,\n <E as ParserError<I>>::Inner: ParserError<I>,

Parse all of input, generating O from it
§

fn parse_peek(&mut self, input: I) -> Result<(I, O), E>

Take tokens from the [Stream], turning it into the output Read more
§

fn by_ref(&mut self) -> ByRef<'_, Self, I, O, E>
where\n Self: Sized,

Treat &mut Self as a parser Read more
§

fn value<O2>(self, val: O2) -> Value<Self, I, O, O2, E>
where\n Self: Sized,\n O2: Clone,

Produce the provided value Read more
§

fn default_value<O2>(self) -> DefaultValue<Self, I, O, O2, E>
where\n Self: Sized,\n O2: Default,

Produce a type’s default value Read more
§

fn void(self) -> Void<Self, I, O, E>
where\n Self: Sized,

Discards the output of the Parser Read more
§

fn output_into<O2>(self) -> OutputInto<Self, I, O, O2, E>
where\n Self: Sized,\n O: Into<O2>,

Convert the parser’s output to another type using std::convert::From Read more
§

fn take(self) -> Take<Self, I, O, E>
where\n Self: Sized,\n I: Stream,

Produce the consumed input as produced value. Read more
§

fn with_taken(self) -> WithTaken<Self, I, O, E>
where\n Self: Sized,\n I: Stream,

Produce the consumed input with the output Read more
§

fn span(self) -> Span<Self, I, O, E>
where\n Self: Sized,\n I: Stream + Location,

Produce the location of the consumed input as produced value. Read more
§

fn with_span(self) -> WithSpan<Self, I, O, E>
where\n Self: Sized,\n I: Stream + Location,

Produce the location of consumed input with the output Read more
§

fn map<G, O2>(self, map: G) -> Map<Self, G, I, O, O2, E>
where\n G: FnMut(O) -> O2,\n Self: Sized,

Maps a function over the output of a parser Read more
§

fn try_map<G, O2, E2>(self, map: G) -> TryMap<Self, G, I, O, O2, E, E2>
where\n Self: Sized,\n G: FnMut(O) -> Result<O2, E2>,\n I: Stream,\n E: FromExternalError<I, E2> + ParserError<I>,

Applies a function returning a Result over the output of a parser. Read more
§

fn verify_map<G, O2>(self, map: G) -> VerifyMap<Self, G, I, O, O2, E>
where\n Self: Sized,\n G: FnMut(O) -> Option<O2>,\n I: Stream,\n E: ParserError<I>,

Apply both [Parser::verify] and [Parser::map]. Read more
§

fn flat_map<G, H, O2>(self, map: G) -> FlatMap<Self, G, H, I, O, O2, E>
where\n Self: Sized,\n G: FnMut(O) -> H,\n H: Parser<I, O2, E>,

Creates a parser from the output of this one Read more
§

fn and_then<G, O2>(self, inner: G) -> AndThen<Self, G, I, O, O2, E>
where\n Self: Sized,\n G: Parser<O, O2, E>,\n O: StreamIsPartial,\n I: Stream,

Applies a second parser over the output of the first one Read more
§

fn parse_to<O2>(self) -> ParseTo<Self, I, O, O2, E>
where\n Self: Sized,\n I: Stream,\n O: ParseSlice<O2>,\n E: ParserError<I>,

Apply std::str::FromStr to the output of the parser Read more
§

fn verify<G, O2>(self, filter: G) -> Verify<Self, G, I, O, O2, E>
where\n Self: Sized,\n G: FnMut(&O2) -> bool,\n I: Stream,\n O: Borrow<O2>,\n E: ParserError<I>,\n O2: ?Sized,

Returns the output of the child parser if it satisfies a verification function. Read more
§

fn context<C>(self, context: C) -> Context<Self, I, O, E, C>
where\n Self: Sized,\n I: Stream,\n E: AddContext<I, C> + ParserError<I>,\n C: Clone + Debug,

If parsing fails, add context to the error Read more
§

fn context_with<F, C, FI>(\n self,\n context: F,\n) -> ContextWith<Self, I, O, E, F, C, FI>
where\n Self: Sized,\n I: Stream,\n E: AddContext<I, C> + ParserError<I>,\n F: Fn() -> FI + Clone,\n C: Debug,\n FI: Iterator<Item = C>,

If parsing fails, dynamically add context to the error Read more
§

fn map_err<G, E2>(self, map: G) -> MapErr<Self, G, I, O, E, E2>
where\n G: FnMut(E) -> E2,\n Self: Sized,

Maps a function over the error of a parser Read more
§

fn complete_err(self) -> CompleteErr<Self, I, O, E>
where\n Self: Sized,

Transforms [Incomplete][crate::error::ErrMode::Incomplete] into [Backtrack][crate::error::ErrMode::Backtrack] Read more
§

fn err_into<E2>(self) -> ErrInto<Self, I, O, E, E2>
where\n Self: Sized,\n E: Into<E2>,

Convert the parser’s error to another type using std::convert::From
","Parser","pipeline::etl::transform::transformer::greptime::RowWithTableSuffix","pipeline::manager::PipelineInfo"],["
§

impl<I, O1, O2, Error, P1, P2> Permutation<I, (O1, O2), Error> for (P1, P2)
where\n I: Stream,\n Error: ParserError<I>,\n P1: Parser<I, O1, Error>,\n P2: Parser<I, O2, Error>,

§

fn permutation(&mut self, input: &mut I) -> Result<(O1, O2), Error>

Tries to apply all parsers in the tuple in various orders until all of them succeed
","Permutation","pipeline::etl::transform::transformer::greptime::RowWithTableSuffix","pipeline::manager::PipelineInfo"],["
§

impl<Input, A, B, Error, FnA, FnB> Permutation<Input, (A, B), Error> for (FnA, FnB)
where\n Input: Clone,\n Error: ParseError<Input>,\n FnA: Parser<Input, A, Error>,\n FnB: Parser<Input, B, Error>,

§

fn permutation(&mut self, input: Input) -> Result<(Input, (A, B)), Err<Error>>

Tries to apply all parsers in the tuple in various orders until all of them succeed
","Permutation","pipeline::etl::transform::transformer::greptime::RowWithTableSuffix","pipeline::manager::PipelineInfo"],["
§

impl<T1, T2> PgHasArrayType for (T1, T2)

§

fn array_type_info() -> PgTypeInfo

§

fn array_compatible(ty: &PgTypeInfo) -> bool

","PgHasArrayType","pipeline::etl::transform::transformer::greptime::RowWithTableSuffix","pipeline::manager::PipelineInfo"],["
§

impl<S> Point for (S, S)
where\n S: RTreeNum,

§

const DIMENSIONS: usize = 2usize

The number of dimensions of this point type.
§

type Scalar = S

The number type used by this point type.
§

fn generate(generator: impl FnMut(usize) -> S) -> (S, S)

Creates a new point value with given values for each dimension. Read more
§

fn nth(&self, index: usize) -> <(S, S) as Point>::Scalar

Returns a single coordinate of this point. Read more
§

fn nth_mut(&mut self, index: usize) -> &mut <(S, S) as Point>::Scalar

Mutable variant of nth.
","Point","pipeline::etl::transform::transformer::greptime::RowWithTableSuffix","pipeline::manager::PipelineInfo"],["
Source§

impl<T0, T1> Serialize for (T0, T1)
where\n T0: Serialize,\n T1: Serialize,

Source§

fn serialize<S>(\n &self,\n serializer: S,\n) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>
where\n S: Serializer,

Serialize this value into the given Serde serializer. Read more
","Serialize","pipeline::etl::transform::transformer::greptime::RowWithTableSuffix","pipeline::manager::PipelineInfo"],["
Source§

impl<T0, As0, T1, As1> SerializeAs<(T0, T1)> for (As0, As1)
where\n As0: SerializeAs<T0>,\n As1: SerializeAs<T1>,

Source§

fn serialize_as<S>(\n tuple: &(T0, T1),\n serializer: S,\n) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>
where\n S: Serializer,

Serialize this value into the given Serde serializer.
","SerializeAs<(T0, T1)>","pipeline::etl::transform::transformer::greptime::RowWithTableSuffix","pipeline::manager::PipelineInfo"],["
§

impl<'a, T, C0, C1> TreeNodeContainer<'a, T> for (C0, C1)
where\n T: 'a,\n C0: TreeNodeContainer<'a, T>,\n C1: TreeNodeContainer<'a, T>,

§

fn apply_elements<F>(\n &'a self,\n f: F,\n) -> Result<TreeNodeRecursion, DataFusionError>
where\n F: FnMut(&'a T) -> Result<TreeNodeRecursion, DataFusionError>,

Applies f to all elements of the container.\nThis method is usually called from [TreeNode::apply_children] implementations as\na node is actually a container of the node’s children.
§

fn map_elements<F>(self, f: F) -> Result<Transformed<(C0, C1)>, DataFusionError>
where\n F: FnMut(T) -> Result<Transformed<T>, DataFusionError>,

Maps all elements of the container with f.\nThis method is usually called from [TreeNode::map_children] implementations as\na node is actually a container of the node’s children.
","TreeNodeContainer<'a, T>","pipeline::etl::transform::transformer::greptime::RowWithTableSuffix","pipeline::manager::PipelineInfo"],["
§

impl<Input, A, B, Error, FnA, FnB> Tuple<Input, (A, B), Error> for (FnA, FnB)
where\n Input: Clone,\n Error: ParseError<Input>,\n FnA: Parser<Input, A, Error>,\n FnB: Parser<Input, B, Error>,

§

fn parse(&mut self, input: Input) -> Result<(Input, (A, B)), Err<Error>>

Parses the input and returns a tuple of results of each parser.
","Tuple","pipeline::etl::transform::transformer::greptime::RowWithTableSuffix","pipeline::manager::PipelineInfo"],["
§

impl<Input, A, B, Error, FnA, FnB> Tuple<Input, (A, B), Error> for (FnA, FnB)
where\n Input: Clone,\n Error: ParseError<Input>,\n FnA: Parser<Input, Output = A, Error = Error>,\n FnB: Parser<Input, Output = B, Error = Error>,

§

fn parse_tuple(&mut self, input: Input) -> Result<(Input, (A, B)), Err<Error>>

👎Deprecated since 8.0.0: Parser is directly implemented for tuples
Parses the input and returns a tuple of results of each parser.
","Tuple","pipeline::etl::transform::transformer::greptime::RowWithTableSuffix","pipeline::manager::PipelineInfo"],["
§

impl<T1, T2> Type<Postgres> for (T1, T2)

§

fn type_info() -> PgTypeInfo

Returns the canonical SQL type for this Rust type. Read more
§

fn compatible(ty: &<DB as Database>::TypeInfo) -> bool

Determines if this Rust type is compatible with the given SQL type. Read more
","Type","pipeline::etl::transform::transformer::greptime::RowWithTableSuffix","pipeline::manager::PipelineInfo"],["
§

impl<A, B> UnsizedCopy for (A, B)
where\n A: Copy,\n B: UnsizedCopy + ?Sized,

§

type Alignment = (A, <B as UnsizedCopy>::Alignment)

A type with the same alignment as Self. Read more
§

fn ptr_with_addr(&self, addr: *const ()) -> *const (A, B)

Change the address of a pointer to Self. Read more
§

fn unsized_copy_into<T>(&self) -> T
where\n T: UnsizedCopyFrom<Source = Self>,

Copy self into a new container. Read more
§

fn copy(&self) -> Self
where\n Self: Sized,

Copy self and return it by value. Read more
","UnsizedCopy","pipeline::etl::transform::transformer::greptime::RowWithTableSuffix","pipeline::manager::PipelineInfo"],["
§

impl<T1, T0> Values for (T1, T0)
where\n T1: Values,\n T0: Values,

§

fn encoded_len(&self, mode: Mode) -> usize

Returns the length of the encoded values for the given mode.
§

fn write_encoded<W>(&self, mode: Mode, target: &mut W) -> Result<(), Error>
where\n W: Write,

Encodes the values in the given mode and writes them to target.
§

fn explicit(self, tag: Tag) -> Constructed<Self>
where\n Self: Sized,

Converts the encoder into one with an explicit tag.
§

fn to_captured(&self, mode: Mode) -> Captured

Captures the encoded values in the given mode.
","Values","pipeline::etl::transform::transformer::greptime::RowWithTableSuffix","pipeline::manager::PipelineInfo"],["
§

impl<'a, T1, T2> Yokeable<'a> for (T1, T2)
where\n T1: 'static + for<'b> Yokeable<'b>,\n T2: 'static + for<'b> Yokeable<'b>,

§

type Output = (<T1 as Yokeable<'a>>::Output, <T2 as Yokeable<'a>>::Output)

This type MUST be Self with the 'static replaced with 'a, i.e. Self<'a>
§

fn transform(&'a self) -> &'a <(T1, T2) as Yokeable<'a>>::Output

This method must cast self between &'a Self<'static> and &'a Self<'a>. Read more
§

fn transform_owned(self) -> <(T1, T2) as Yokeable<'a>>::Output

This method must cast self between Self<'static> and Self<'a>. Read more
§

unsafe fn make(from: <(T1, T2) as Yokeable<'a>>::Output) -> (T1, T2)

This method can be used to cast away Self<'a>’s lifetime. Read more
§

fn transform_mut<F>(&'a mut self, f: F)
where\n F: 'static + for<'b> FnOnce(&'b mut <(T1, T2) as Yokeable<'a>>::Output),

This method must cast self between &'a mut Self<'static> and &'a mut Self<'a>,\nand pass it to f. Read more
","Yokeable<'a>","pipeline::etl::transform::transformer::greptime::RowWithTableSuffix","pipeline::manager::PipelineInfo"],["
§

impl<'a, A, B, AE, BE, Format> ZeroFrom<'a, Tuple2VarULE<A, B, Format>> for (AE, BE)
where\n A: VarULE + ?Sized,\n B: VarULE + ?Sized,\n AE: ZeroFrom<'a, A>,\n BE: ZeroFrom<'a, B>,\n Format: VarZeroVecFormat,

§

fn zero_from(other: &'a Tuple2VarULE<A, B, Format>) -> (AE, BE)

Clone the other C into a struct that may retain references into C.
","ZeroFrom<'a, Tuple2VarULE>","pipeline::etl::transform::transformer::greptime::RowWithTableSuffix","pipeline::manager::PipelineInfo"],["
§

impl<'zf, C1, T1, C2, T2> ZeroFrom<'zf, (C1, C2)> for (T1, T2)
where\n T1: ZeroFrom<'zf, C1>,\n T2: ZeroFrom<'zf, C2>,

§

fn zero_from(other: &'zf (C1, C2)) -> (T1, T2)

Clone the other C into a struct that may retain references into C.
","ZeroFrom<'zf, (C1, C2)>","pipeline::etl::transform::transformer::greptime::RowWithTableSuffix","pipeline::manager::PipelineInfo"],["
§

impl<'a, A, B> ZeroMapKV<'a> for (A, B)
where\n A: Ord + AsULE + 'static,\n B: Ord + AsULE + 'static,

§

type Container = ZeroVec<'a, (A, B)>

The container that can be used with this type: [ZeroVec] or [VarZeroVec].
§

type Slice = ZeroSlice<(A, B)>

§

type GetType = Tuple2ULE<<A as AsULE>::ULE, <B as AsULE>::ULE>

The type produced by Container::get() Read more
§

type OwnedType = (A, B)

The type produced by Container::replace() and Container::remove(),\nalso used during deserialization. If Self is human readable serialized,\ndeserializing to Self::OwnedType should produce the same value once\npassed through Self::owned_as_self() Read more
","ZeroMapKV<'a>","pipeline::etl::transform::transformer::greptime::RowWithTableSuffix","pipeline::manager::PipelineInfo"],["
§

impl<A, B> Zeroable for (A, B)
where\n A: Zeroable,\n B: Zeroable,

§

fn zeroed() -> Self

","Zeroable","pipeline::etl::transform::transformer::greptime::RowWithTableSuffix","pipeline::manager::PipelineInfo"],["
§

impl<A, B> Zeroize for (A, B)
where\n A: Zeroize,\n B: Zeroize,

§

fn zeroize(&mut self)

Zero out this object from memory using Rust intrinsics which ensure the\nzeroization operation is not “optimized away” by the compiler.
","Zeroize","pipeline::etl::transform::transformer::greptime::RowWithTableSuffix","pipeline::manager::PipelineInfo"],["
§

impl<A, B> ZeroizeOnDrop for (A, B)
where\n A: ZeroizeOnDrop,\n B: ZeroizeOnDrop,

","ZeroizeOnDrop","pipeline::etl::transform::transformer::greptime::RowWithTableSuffix","pipeline::manager::PipelineInfo"]]],["promql",[["
§

impl<F, Fut, Res, S> Handler<((),), S> for F
where\n F: FnOnce() -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n Res: IntoResponse,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n _req: Request<Body>,\n _state: S,\n) -> <F as Handler<((),), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<((),), S>","promql::range_array::RangeTuple"],["
§

impl<F, Fut, S, Res, M, T1> Handler<(M, T1), S> for F
where\n F: FnOnce(T1) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1), S>","promql::range_array::RangeTuple"],["
§

impl<F, Fut, S, Res, M, T1, T2> Handler<(M, T1, T2), S> for F
where\n F: FnOnce(T1, T2) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequestParts<S> + Send,\n T2: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1, T2), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1, T2), S>","promql::range_array::RangeTuple"],["
§

impl<F, Fut, S, Res, M, T1, T2, T3> Handler<(M, T1, T2, T3), S> for F
where\n F: FnOnce(T1, T2, T3) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequestParts<S> + Send,\n T2: FromRequestParts<S> + Send,\n T3: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1, T2, T3), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1, T2, T3), S>","promql::range_array::RangeTuple"],["
§

impl<F, Fut, S, Res, M, T1, T2, T3, T4> Handler<(M, T1, T2, T3, T4), S> for F
where\n F: FnOnce(T1, T2, T3, T4) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequestParts<S> + Send,\n T2: FromRequestParts<S> + Send,\n T3: FromRequestParts<S> + Send,\n T4: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1, T2, T3, T4), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1, T2, T3, T4), S>","promql::range_array::RangeTuple"],["
§

impl<F, Fut, S, Res, M, T1, T2, T3, T4, T5> Handler<(M, T1, T2, T3, T4, T5), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequestParts<S> + Send,\n T2: FromRequestParts<S> + Send,\n T3: FromRequestParts<S> + Send,\n T4: FromRequestParts<S> + Send,\n T5: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1, T2, T3, T4, T5), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1, T2, T3, T4, T5), S>","promql::range_array::RangeTuple"],["
§

impl<F, Fut, S, Res, M, T1, T2, T3, T4, T5, T6> Handler<(M, T1, T2, T3, T4, T5, T6), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5, T6) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequestParts<S> + Send,\n T2: FromRequestParts<S> + Send,\n T3: FromRequestParts<S> + Send,\n T4: FromRequestParts<S> + Send,\n T5: FromRequestParts<S> + Send,\n T6: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1, T2, T3, T4, T5, T6), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1, T2, T3, T4, T5, T6), S>","promql::range_array::RangeTuple"],["
§

impl<F, Fut, S, Res, M, T1, T2, T3, T4, T5, T6, T7> Handler<(M, T1, T2, T3, T4, T5, T6, T7), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5, T6, T7) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequestParts<S> + Send,\n T2: FromRequestParts<S> + Send,\n T3: FromRequestParts<S> + Send,\n T4: FromRequestParts<S> + Send,\n T5: FromRequestParts<S> + Send,\n T6: FromRequestParts<S> + Send,\n T7: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1, T2, T3, T4, T5, T6, T7), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1, T2, T3, T4, T5, T6, T7), S>","promql::range_array::RangeTuple"],["
§

impl<F, Fut, S, Res, M, T1, T2, T3, T4, T5, T6, T7, T8> Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5, T6, T7, T8) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequestParts<S> + Send,\n T2: FromRequestParts<S> + Send,\n T3: FromRequestParts<S> + Send,\n T4: FromRequestParts<S> + Send,\n T5: FromRequestParts<S> + Send,\n T6: FromRequestParts<S> + Send,\n T7: FromRequestParts<S> + Send,\n T8: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8), S>","promql::range_array::RangeTuple"],["
§

impl<F, Fut, S, Res, M, T1, T2, T3, T4, T5, T6, T7, T8, T9> Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5, T6, T7, T8, T9) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequestParts<S> + Send,\n T2: FromRequestParts<S> + Send,\n T3: FromRequestParts<S> + Send,\n T4: FromRequestParts<S> + Send,\n T5: FromRequestParts<S> + Send,\n T6: FromRequestParts<S> + Send,\n T7: FromRequestParts<S> + Send,\n T8: FromRequestParts<S> + Send,\n T9: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9), S>","promql::range_array::RangeTuple"],["
§

impl<F, Fut, S, Res, M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequestParts<S> + Send,\n T2: FromRequestParts<S> + Send,\n T3: FromRequestParts<S> + Send,\n T4: FromRequestParts<S> + Send,\n T5: FromRequestParts<S> + Send,\n T6: FromRequestParts<S> + Send,\n T7: FromRequestParts<S> + Send,\n T8: FromRequestParts<S> + Send,\n T9: FromRequestParts<S> + Send,\n T10: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10), S>","promql::range_array::RangeTuple"],["
§

impl<F, Fut, S, Res, M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequestParts<S> + Send,\n T2: FromRequestParts<S> + Send,\n T3: FromRequestParts<S> + Send,\n T4: FromRequestParts<S> + Send,\n T5: FromRequestParts<S> + Send,\n T6: FromRequestParts<S> + Send,\n T7: FromRequestParts<S> + Send,\n T8: FromRequestParts<S> + Send,\n T9: FromRequestParts<S> + Send,\n T10: FromRequestParts<S> + Send,\n T11: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11), S>","promql::range_array::RangeTuple"],["
§

impl<F, Fut, S, Res, M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequestParts<S> + Send,\n T2: FromRequestParts<S> + Send,\n T3: FromRequestParts<S> + Send,\n T4: FromRequestParts<S> + Send,\n T5: FromRequestParts<S> + Send,\n T6: FromRequestParts<S> + Send,\n T7: FromRequestParts<S> + Send,\n T8: FromRequestParts<S> + Send,\n T9: FromRequestParts<S> + Send,\n T10: FromRequestParts<S> + Send,\n T11: FromRequestParts<S> + Send,\n T12: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12), S>","promql::range_array::RangeTuple"],["
§

impl<F, Fut, S, Res, M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequestParts<S> + Send,\n T2: FromRequestParts<S> + Send,\n T3: FromRequestParts<S> + Send,\n T4: FromRequestParts<S> + Send,\n T5: FromRequestParts<S> + Send,\n T6: FromRequestParts<S> + Send,\n T7: FromRequestParts<S> + Send,\n T8: FromRequestParts<S> + Send,\n T9: FromRequestParts<S> + Send,\n T10: FromRequestParts<S> + Send,\n T11: FromRequestParts<S> + Send,\n T12: FromRequestParts<S> + Send,\n T13: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13), S>","promql::range_array::RangeTuple"],["
§

impl<F, Fut, S, Res, M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequestParts<S> + Send,\n T2: FromRequestParts<S> + Send,\n T3: FromRequestParts<S> + Send,\n T4: FromRequestParts<S> + Send,\n T5: FromRequestParts<S> + Send,\n T6: FromRequestParts<S> + Send,\n T7: FromRequestParts<S> + Send,\n T8: FromRequestParts<S> + Send,\n T9: FromRequestParts<S> + Send,\n T10: FromRequestParts<S> + Send,\n T11: FromRequestParts<S> + Send,\n T12: FromRequestParts<S> + Send,\n T13: FromRequestParts<S> + Send,\n T14: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14), S>","promql::range_array::RangeTuple"],["
§

impl<F, Fut, S, Res, M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequestParts<S> + Send,\n T2: FromRequestParts<S> + Send,\n T3: FromRequestParts<S> + Send,\n T4: FromRequestParts<S> + Send,\n T5: FromRequestParts<S> + Send,\n T6: FromRequestParts<S> + Send,\n T7: FromRequestParts<S> + Send,\n T8: FromRequestParts<S> + Send,\n T9: FromRequestParts<S> + Send,\n T10: FromRequestParts<S> + Send,\n T11: FromRequestParts<S> + Send,\n T12: FromRequestParts<S> + Send,\n T13: FromRequestParts<S> + Send,\n T14: FromRequestParts<S> + Send,\n T15: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15), S>","promql::range_array::RangeTuple"],["
§

impl<F, Fut, S, Res, M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16> Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequestParts<S> + Send,\n T2: FromRequestParts<S> + Send,\n T3: FromRequestParts<S> + Send,\n T4: FromRequestParts<S> + Send,\n T5: FromRequestParts<S> + Send,\n T6: FromRequestParts<S> + Send,\n T7: FromRequestParts<S> + Send,\n T8: FromRequestParts<S> + Send,\n T9: FromRequestParts<S> + Send,\n T10: FromRequestParts<S> + Send,\n T11: FromRequestParts<S> + Send,\n T12: FromRequestParts<S> + Send,\n T13: FromRequestParts<S> + Send,\n T14: FromRequestParts<S> + Send,\n T15: FromRequestParts<S> + Send,\n T16: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16), S>","promql::range_array::RangeTuple"],["
§

impl<IT, A, FromA> MultiUnzip<(FromA,)> for IT
where\n IT: Iterator<Item = (A,)>,\n FromA: Default + Extend<A>,

§

fn multiunzip(self) -> (FromA,)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA,)>","promql::range_array::RangeTuple"],["
§

impl<IT, A, FromA, B, FromB> MultiUnzip<(FromA, FromB)> for IT
where\n IT: Iterator<Item = (A, B)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,

§

fn multiunzip(self) -> (FromA, FromB)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB)>","promql::range_array::RangeTuple"],["
§

impl<IT, A, FromA, B, FromB, C, FromC> MultiUnzip<(FromA, FromB, FromC)> for IT
where\n IT: Iterator<Item = (A, B, C)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,

§

fn multiunzip(self) -> (FromA, FromB, FromC)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC)>","promql::range_array::RangeTuple"],["
§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD> MultiUnzip<(FromA, FromB, FromC, FromD)> for IT
where\n IT: Iterator<Item = (A, B, C, D)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,

§

fn multiunzip(self) -> (FromA, FromB, FromC, FromD)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD)>","promql::range_array::RangeTuple"],["
§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE> MultiUnzip<(FromA, FromB, FromC, FromD, FromE)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,

§

fn multiunzip(self) -> (FromA, FromB, FromC, FromD, FromE)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE)>","promql::range_array::RangeTuple"],["
§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E, F)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,\n FromF: Default + Extend<F>,

§

fn multiunzip(self) -> (FromA, FromB, FromC, FromD, FromE, FromF)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF)>","promql::range_array::RangeTuple"],["
§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E, F, G)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,\n FromF: Default + Extend<F>,\n FromG: Default + Extend<G>,

§

fn multiunzip(self) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG)>","promql::range_array::RangeTuple"],["
§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E, F, G, H)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,\n FromF: Default + Extend<F>,\n FromG: Default + Extend<G>,\n FromH: Default + Extend<H>,

§

fn multiunzip(self) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH)>","promql::range_array::RangeTuple"],["
§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E, F, G, H, I)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,\n FromF: Default + Extend<F>,\n FromG: Default + Extend<G>,\n FromH: Default + Extend<H>,\n FromI: Default + Extend<I>,

§

fn multiunzip(\n self,\n) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI)>","promql::range_array::RangeTuple"],["
§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,\n FromF: Default + Extend<F>,\n FromG: Default + Extend<G>,\n FromH: Default + Extend<H>,\n FromI: Default + Extend<I>,\n FromJ: Default + Extend<J>,

§

fn multiunzip(\n self,\n) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ)>","promql::range_array::RangeTuple"],["
§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ, K, FromK> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J, K)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,\n FromF: Default + Extend<F>,\n FromG: Default + Extend<G>,\n FromH: Default + Extend<H>,\n FromI: Default + Extend<I>,\n FromJ: Default + Extend<J>,\n FromK: Default + Extend<K>,

§

fn multiunzip(\n self,\n) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK)>","promql::range_array::RangeTuple"],["
§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ, K, FromK, L, FromL> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK, FromL)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J, K, L)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,\n FromF: Default + Extend<F>,\n FromG: Default + Extend<G>,\n FromH: Default + Extend<H>,\n FromI: Default + Extend<I>,\n FromJ: Default + Extend<J>,\n FromK: Default + Extend<K>,\n FromL: Default + Extend<L>,

§

fn multiunzip(\n self,\n) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK, FromL)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK, FromL)>","promql::range_array::RangeTuple"]]],["servers",[["
§

impl<I, Output, Error, Alt2, Alt3> Alt<I, Output, Error> for (Alt2, Alt3)
where\n I: Stream,\n Error: ParserError<I>,\n Alt2: Parser<I, Output, Error>,\n Alt3: Parser<I, Output, Error>,

§

fn choice(&mut self, input: &mut I) -> Result<Output, Error>

Tests each parser in the tuple and returns the result of the first one that succeeds
","Alt","servers::server::ServerHandler"],["
§

impl<Input, Output, Error, A, B> Alt<Input, Output, Error> for (A, B)
where\n Input: Clone,\n Error: ParseError<Input>,\n A: Parser<Input, Output, Error>,\n B: Parser<Input, Output, Error>,

§

fn choice(&mut self, input: Input) -> Result<(Input, Output), Err<Error>>

Tests each parser in the tuple and returns the result of the first one that succeeds
","Alt","servers::server::ServerHandler"],["
§

impl<A, B> AsULE for (A, B)
where\n A: AsULE,\n B: AsULE,

§

type ULE = Tuple2ULE<<A as AsULE>::ULE, <B as AsULE>::ULE>

The ULE type corresponding to Self. Read more
§

fn to_unaligned(self) -> <(A, B) as AsULE>::ULE

Converts from Self to Self::ULE. Read more
§

fn from_unaligned(unaligned: <(A, B) as AsULE>::ULE) -> (A, B)

Converts from Self::ULE to Self. Read more
","AsULE","servers::server::ServerHandler"],["
§

impl<A, B> AssertFloatEq for (A, B)
where\n A: AssertFloatEq + Debug,\n B: AssertFloatEq + Debug + ?Sized,\n <A as FloatEq>::Tol: Sized,\n <B as FloatEq>::Tol: Sized,\n <A as AssertFloatEq>::DebugTol: Sized,\n <B as AssertFloatEq>::DebugTol: Sized,\n <<A as FloatEq>::Tol as FloatEqUlpsTol>::UlpsTol: Sized,\n <<B as FloatEq>::Tol as FloatEqUlpsTol>::UlpsTol: Sized,\n <<A as AssertFloatEq>::DebugTol as FloatEqUlpsTol>::UlpsTol: Sized,\n <<B as AssertFloatEq>::DebugTol as FloatEqUlpsTol>::UlpsTol: Sized,

§

type DebugAbsDiff = (<A as AssertFloatEq>::DebugAbsDiff, <B as AssertFloatEq>::DebugAbsDiff)

The absolute difference between two values, displayed to the user via\nfmt::Debug when an assert fails. Read more
§

type DebugTol = (<A as AssertFloatEq>::DebugTol, <B as AssertFloatEq>::DebugTol)

The per-field tolerance value used for comparison between two values,\ndisplayed to the user via fmt::Debug when an assert fails. Read more
§

fn debug_abs_diff(\n &self,\n other: &(A, B),\n) -> <(A, B) as AssertFloatEq>::DebugAbsDiff

Always positive absolute difference between two values. Read more
§

fn debug_ulps_diff(\n &self,\n other: &(A, B),\n) -> <<(A, B) as AssertFloatEq>::DebugAbsDiff as FloatEqDebugUlpsDiff>::DebugUlpsDiff

Always positive absolute difference between two values in terms of ULPs. Read more
§

fn debug_abs_tol(\n &self,\n other: &(A, B),\n tol: &<(A, B) as FloatEq>::Tol,\n) -> <(A, B) as AssertFloatEq>::DebugTol

The tolerance used by an abs comparison, displayed when an assert fails.
§

fn debug_rmax_tol(\n &self,\n other: &(A, B),\n tol: &<(A, B) as FloatEq>::Tol,\n) -> <(A, B) as AssertFloatEq>::DebugTol

The tolerance used by an rmax comparison, displayed when an assert fails. Read more
§

fn debug_rmin_tol(\n &self,\n other: &(A, B),\n tol: &<(A, B) as FloatEq>::Tol,\n) -> <(A, B) as AssertFloatEq>::DebugTol

The tolerance used by an rmin comparison, displayed when an assert fails. Read more
§

fn debug_r1st_tol(\n &self,\n other: &(A, B),\n tol: &<(A, B) as FloatEq>::Tol,\n) -> <(A, B) as AssertFloatEq>::DebugTol

The tolerance used by an r1st comparison, displayed when an assert fails. Read more
§

fn debug_r2nd_tol(\n &self,\n other: &(A, B),\n tol: &<(A, B) as FloatEq>::Tol,\n) -> <(A, B) as AssertFloatEq>::DebugTol

The tolerance used by an r2nd comparison, displayed when an assert fails. Read more
§

fn debug_ulps_tol(\n &self,\n other: &(A, B),\n tol: &<<(A, B) as FloatEq>::Tol as FloatEqUlpsTol>::UlpsTol,\n) -> <<(A, B) as AssertFloatEq>::DebugTol as FloatEqUlpsTol>::UlpsTol

The tolerance used by an ulps comparison, displayed when an assert fails.
§

fn debug_rel_tol(&self, other: &Rhs, tol: &Self::Tol) -> Self::DebugTol

The tolerance used by a rel comparison, displayed when an assert fails. Read more
","AssertFloatEq","servers::server::ServerHandler"],["
Source§

impl<S, T> Bounded for (S, T)
where\n S: Bounded,\n T: Bounded,

Source§

fn min_value() -> (S, T)

Returns the smallest finite number this type can represent
Source§

fn max_value() -> (S, T)

Returns the largest finite number this type can represent
","Bounded","servers::server::ServerHandler"],["
§

impl<T, F1, F2> ContainsToken<T> for (F1, F2)
where\n T: Clone,\n F1: ContainsToken<T>,\n F2: ContainsToken<T>,

§

fn contains_token(&self, token: T) -> bool

Returns true if self contains the token
","ContainsToken","servers::server::ServerHandler"],["
§

impl<'r, T1, T2> Decode<'r, Postgres> for (T1, T2)
where\n T1: 'r + Type<Postgres> + for<'a> Decode<'a, Postgres>,\n T2: 'r + Type<Postgres> + for<'a> Decode<'a, Postgres>,

§

fn decode(\n value: PgValueRef<'r>,\n) -> Result<(T1, T2), Box<dyn Error + Sync + Send>>

Decode a new value of this type using a raw value from the database.
","Decode<'r, Postgres>","servers::server::ServerHandler"],["
Source§

impl<'de, T0, T1> Deserialize<'de> for (T0, T1)
where\n T0: Deserialize<'de>,\n T1: Deserialize<'de>,

Source§

fn deserialize<D>(\n deserializer: D,\n) -> Result<(T0, T1), <D as Deserializer<'de>>::Error>
where\n D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer. Read more
","Deserialize<'de>","servers::server::ServerHandler"],["
Source§

impl<'de, T0, As0, T1, As1> DeserializeAs<'de, (T0, T1)> for (As0, As1)
where\n As0: DeserializeAs<'de, T0>,\n As1: DeserializeAs<'de, T1>,

Source§

fn deserialize_as<D>(\n deserializer: D,\n) -> Result<(T0, T1), <D as Deserializer<'de>>::Error>
where\n D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.
","DeserializeAs<'de, (T0, T1)>","servers::server::ServerHandler"],["
§

impl<A, B, AE, BE, Format> EncodeAsVarULE<Tuple2VarULE<A, B, Format>> for (AE, BE)
where\n A: VarULE + ?Sized,\n B: VarULE + ?Sized,\n AE: EncodeAsVarULE<A>,\n BE: EncodeAsVarULE<B>,\n Format: VarZeroVecFormat,

§

fn encode_var_ule_as_slices<R>(&self, _: impl FnOnce(&[&[u8]]) -> R) -> R

Calls cb with a piecewise list of byte slices that when concatenated\nproduce the memory pattern of the corresponding instance of T. Read more
§

fn encode_var_ule_len(&self) -> usize

Return the length, in bytes, of the corresponding [VarULE] type
§

fn encode_var_ule_write(&self, dst: &mut [u8])

Write the corresponding [VarULE] type to the dst buffer. dst should\nbe the size of [Self::encode_var_ule_len()]
","EncodeAsVarULE>","servers::server::ServerHandler"],["
§

impl<A, B> FloatEq for (A, B)
where\n A: FloatEq,\n B: FloatEq + ?Sized,\n <A as FloatEq>::Tol: Sized,\n <B as FloatEq>::Tol: Sized,\n <<A as FloatEq>::Tol as FloatEqUlpsTol>::UlpsTol: Sized,\n <<B as FloatEq>::Tol as FloatEqUlpsTol>::UlpsTol: Sized,

§

type Tol = (<A as FloatEq>::Tol, <B as FloatEq>::Tol)

Type of the maximum allowed difference between two values for them to be\nconsidered equal.
§

fn eq_abs(&self, other: &(A, B), tol: &<(A, B) as FloatEq>::Tol) -> bool

Check whether self is equal to other, using an absolute tolerance\ncomparison. Read more
§

fn eq_rmax(&self, other: &(A, B), tol: &<(A, B) as FloatEq>::Tol) -> bool

Check whether self is equal to other, using a relative tolerance\ncomparison, scaled to the granularity of the input with the largest\nmagnitude. Read more
§

fn eq_rmin(&self, other: &(A, B), tol: &<(A, B) as FloatEq>::Tol) -> bool

Check whether self is equal to other, using a relative tolerance\ncomparison, scaled to the granularity of the input with the smallest\nmagnitude. Read more
§

fn eq_r1st(&self, other: &(A, B), tol: &<(A, B) as FloatEq>::Tol) -> bool

Check whether self is equal to other, using a relative tolerance\ncomparison, scaled to the granularity of the first input. Read more
§

fn eq_r2nd(&self, other: &(A, B), tol: &<(A, B) as FloatEq>::Tol) -> bool

Check whether self is equal to other, using a relative tolerance\ncomparison, scaled to the granularity of the second input. Read more
§

fn eq_ulps(\n &self,\n other: &(A, B),\n tol: &<<(A, B) as FloatEq>::Tol as FloatEqUlpsTol>::UlpsTol,\n) -> bool

Check whether self is equal to other, using an ULPs comparison. Read more
§

fn ne_abs(&self, other: &Rhs, tol: &Self::Tol) -> bool

Check whether self is not equal to other, using an absolute tolerance\ncomparison. Read more
§

fn eq_rel(&self, other: &Rhs, tol: &Self::Tol) -> bool

Check whether self is equal to other, using a relative tolerance\ncomparison. Read more
§

fn ne_rel(&self, other: &Rhs, tol: &Self::Tol) -> bool

Check whether self is not equal to other, using a relative tolerance\ncomparison. Read more
§

fn ne_rmax(&self, other: &Rhs, tol: &Self::Tol) -> bool

Check whether self is not equal to other, using a relative tolerance\ncomparison. Read more
§

fn ne_rmin(&self, other: &Rhs, tol: &Self::Tol) -> bool

Check whether self is not equal to other, using a relative tolerance\ncomparison. Read more
§

fn ne_r1st(&self, other: &Rhs, tol: &Self::Tol) -> bool

Check whether self is not equal to other, using a relative tolerance\ncomparison. Read more
§

fn ne_r2nd(&self, other: &Rhs, tol: &Self::Tol) -> bool

Check whether self is not equal to other, using a relative tolerance\ncomparison. Read more
§

fn ne_ulps(\n &self,\n other: &Rhs,\n tol: &<Self::Tol as FloatEqUlpsTol>::UlpsTol,\n) -> bool

Check whether self is not equal to other, using an ULPs comparison. Read more
","FloatEq","servers::server::ServerHandler"],["
§

impl<A, B> FloatEqDebugUlpsDiff for (A, B)
where\n A: FloatEqDebugUlpsDiff,\n B: FloatEqDebugUlpsDiff,

§

type DebugUlpsDiff = (<A as FloatEqDebugUlpsDiff>::DebugUlpsDiff, <B as FloatEqDebugUlpsDiff>::DebugUlpsDiff)

A structurally identical type to Self, with fields recursively wrapped\nby DebugUlpsDiff.
","FloatEqDebugUlpsDiff","servers::server::ServerHandler"],["
§

impl<A, B> FloatEqUlpsTol for (A, B)
where\n A: FloatEqUlpsTol,\n B: FloatEqUlpsTol + ?Sized,\n <A as FloatEqUlpsTol>::UlpsTol: Sized,\n <B as FloatEqUlpsTol>::UlpsTol: Sized,

§

type UlpsTol = (<A as FloatEqUlpsTol>::UlpsTol, <B as FloatEqUlpsTol>::UlpsTol)

A structurally identical type to Self, with fields recursively wrapped\nby UlpsTol.
","FloatEqUlpsTol","servers::server::ServerHandler"],["
§

impl<T> From<Coord<T>> for (T, T)
where\n T: CoordNum,

§

fn from(coord: Coord<T>) -> (T, T)

Converts to this type from the input type.
","From>","servers::server::ServerHandler"],["
§

impl<R, S> From<GrayAlpha_v08<R>> for (S, S)
where\n R: Into<S>,

§

fn from(value: GrayAlpha_v08<R>) -> (S, S)

Converts to this type from the input type.
","From>","servers::server::ServerHandler"],["
§

impl<T> From<Point<T>> for (T, T)
where\n T: CoordNum,

§

fn from(point: Point<T>) -> (T, T)

Converts to this type from the input type.
","From>","servers::server::ServerHandler"],["
§

impl<S> From<Point2<S>> for (S, S)
where\n S: SpadeNum,

§

fn from(point: Point2<S>) -> (S, S)

Converts to this type from the input type.
","From>","servers::server::ServerHandler"],["
Source§

impl<T> From<Ratio<T>> for (T, T)

Source§

fn from(val: Ratio<T>) -> (T, T)

Converts to this type from the input type.
","From>","servers::server::ServerHandler"],["
§

impl<A, B, FromA, FromB> FromParallelIterator<(A, B)> for (FromA, FromB)
where\n A: Send,\n B: Send,\n FromA: Send + FromParallelIterator<A>,\n FromB: Send + FromParallelIterator<B>,

§

fn from_par_iter<I>(pi: I) -> (FromA, FromB)
where\n I: IntoParallelIterator<Item = (A, B)>,

Creates an instance of the collection from the parallel iterator par_iter. Read more
","FromParallelIterator<(A, B)>","servers::server::ServerHandler"],["
§

impl<L, R, A, B> FromParallelIterator<Either<L, R>> for (A, B)
where\n L: Send,\n R: Send,\n A: Send + FromParallelIterator<L>,\n B: Send + FromParallelIterator<R>,

§

fn from_par_iter<I>(pi: I) -> (A, B)
where\n I: IntoParallelIterator<Item = Either<L, R>>,

Creates an instance of the collection from the parallel iterator par_iter. Read more
","FromParallelIterator>","servers::server::ServerHandler"],["
§

impl<S, T1, T2> FromRequest<S> for (T1, T2)
where\n T1: FromRequestParts<S> + Send,\n T2: FromRequest<S> + Send,\n S: Send + Sync,

§

type Rejection = Response<Body>

If the extractor fails it’ll use this “rejection” type. A rejection is\na kind of error that can be converted into a response.
§

fn from_request(\n req: Request<Body>,\n state: &S,\n) -> impl Future<Output = Result<(T1, T2), <(T1, T2) as FromRequest<S>>::Rejection>>

Perform the extraction.
","FromRequest","servers::server::ServerHandler"],["
§

impl<S, T1, T2> FromRequestParts<S> for (T1, T2)
where\n T1: FromRequestParts<S> + Send,\n T2: FromRequestParts<S> + Send,\n S: Send + Sync,

§

type Rejection = Response<Body>

If the extractor fails it’ll use this “rejection” type. A rejection is\na kind of error that can be converted into a response.
§

async fn from_request_parts(\n parts: &mut Parts,\n state: &S,\n) -> Result<(T1, T2), <(T1, T2) as FromRequestParts<S>>::Rejection>

Perform the extraction.
","FromRequestParts","servers::server::ServerHandler"],["
§

impl<'r, R, T1, T2> FromRow<'r, R> for (T1, T2)
where\n R: Row,\n usize: ColumnIndex<R>,\n T1: Decode<'r, <R as Row>::Database> + Type<<R as Row>::Database>,\n T2: Decode<'r, <R as Row>::Database> + Type<<R as Row>::Database>,

§

fn from_row(row: &'r R) -> Result<(T1, T2), Error>

","FromRow<'r, R>","servers::server::ServerHandler"],["
§

impl<T1, T2> FromRow for (T1, T2)
where\n T1: FromValue,\n T2: FromValue,\n <T1 as FromValue>::Intermediate: Into<Value>,

§

fn from_row_opt(row: Row) -> Result<(T1, T2), FromRowError>

§

fn from_row(row: Row) -> Self
where\n Self: Sized,

","FromRow","servers::server::ServerHandler"],["
§

impl<T1, T0> Generic for (T1, T0)

§

type Repr = HCons<T1, HCons<T0, HNil>>

The generic representation type.
§

fn into(self) -> <(T1, T0) as Generic>::Repr

Convert a value to its representation type Repr.
§

fn from(r: <(T1, T0) as Generic>::Repr) -> (T1, T0)

Convert a value’s representation type Repr to the value’s type.
§

fn convert_from<Src>(src: Src) -> Self
where\n Self: Sized,\n Src: Generic<Repr = Self::Repr>,

Convert a value to another type provided that they have\nthe same representation type.
§

fn map_repr<Mapper>(self, mapper: Mapper) -> Self
where\n Self: Sized,\n Mapper: FnOnce(Self::Repr) -> Self::Repr,

Maps the given value of type Self by first transforming it to\nthe representation type Repr, then applying a mapper function\non Repr and finally transforming it back to a value of type Self.
§

fn map_inter<Inter, Mapper>(self, mapper: Mapper) -> Self
where\n Self: Sized,\n Inter: Generic<Repr = Self::Repr>,\n Mapper: FnOnce(Inter) -> Inter,

Maps the given value of type Self by first transforming it\na type Inter that has the same representation type as Self,\nthen applying a mapper function on Inter and finally transforming\nit back to a value of type Self.
","Generic","servers::server::ServerHandler"],["
§

impl<F, Fut, Res, S> Handler<((),), S> for F
where\n F: FnOnce() -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n Res: IntoResponse,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n _req: Request<Body>,\n _state: S,\n) -> <F as Handler<((),), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<((),), S>","servers::server::ServerHandler"],["
§

impl<F, Fut, S, Res, M, T1> Handler<(M, T1), S> for F
where\n F: FnOnce(T1) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1), S>","servers::server::ServerHandler"],["
§

impl<F, Fut, S, Res, M, T1, T2> Handler<(M, T1, T2), S> for F
where\n F: FnOnce(T1, T2) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequestParts<S> + Send,\n T2: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1, T2), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1, T2), S>","servers::server::ServerHandler"],["
§

impl<F, Fut, S, Res, M, T1, T2, T3> Handler<(M, T1, T2, T3), S> for F
where\n F: FnOnce(T1, T2, T3) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequestParts<S> + Send,\n T2: FromRequestParts<S> + Send,\n T3: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1, T2, T3), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1, T2, T3), S>","servers::server::ServerHandler"],["
§

impl<F, Fut, S, Res, M, T1, T2, T3, T4> Handler<(M, T1, T2, T3, T4), S> for F
where\n F: FnOnce(T1, T2, T3, T4) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequestParts<S> + Send,\n T2: FromRequestParts<S> + Send,\n T3: FromRequestParts<S> + Send,\n T4: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1, T2, T3, T4), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1, T2, T3, T4), S>","servers::server::ServerHandler"],["
§

impl<F, Fut, S, Res, M, T1, T2, T3, T4, T5> Handler<(M, T1, T2, T3, T4, T5), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequestParts<S> + Send,\n T2: FromRequestParts<S> + Send,\n T3: FromRequestParts<S> + Send,\n T4: FromRequestParts<S> + Send,\n T5: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1, T2, T3, T4, T5), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1, T2, T3, T4, T5), S>","servers::server::ServerHandler"],["
§

impl<F, Fut, S, Res, M, T1, T2, T3, T4, T5, T6> Handler<(M, T1, T2, T3, T4, T5, T6), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5, T6) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequestParts<S> + Send,\n T2: FromRequestParts<S> + Send,\n T3: FromRequestParts<S> + Send,\n T4: FromRequestParts<S> + Send,\n T5: FromRequestParts<S> + Send,\n T6: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1, T2, T3, T4, T5, T6), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1, T2, T3, T4, T5, T6), S>","servers::server::ServerHandler"],["
§

impl<F, Fut, S, Res, M, T1, T2, T3, T4, T5, T6, T7> Handler<(M, T1, T2, T3, T4, T5, T6, T7), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5, T6, T7) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequestParts<S> + Send,\n T2: FromRequestParts<S> + Send,\n T3: FromRequestParts<S> + Send,\n T4: FromRequestParts<S> + Send,\n T5: FromRequestParts<S> + Send,\n T6: FromRequestParts<S> + Send,\n T7: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1, T2, T3, T4, T5, T6, T7), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1, T2, T3, T4, T5, T6, T7), S>","servers::server::ServerHandler"],["
§

impl<F, Fut, S, Res, M, T1, T2, T3, T4, T5, T6, T7, T8> Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5, T6, T7, T8) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequestParts<S> + Send,\n T2: FromRequestParts<S> + Send,\n T3: FromRequestParts<S> + Send,\n T4: FromRequestParts<S> + Send,\n T5: FromRequestParts<S> + Send,\n T6: FromRequestParts<S> + Send,\n T7: FromRequestParts<S> + Send,\n T8: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8), S>","servers::server::ServerHandler"],["
§

impl<F, Fut, S, Res, M, T1, T2, T3, T4, T5, T6, T7, T8, T9> Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5, T6, T7, T8, T9) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequestParts<S> + Send,\n T2: FromRequestParts<S> + Send,\n T3: FromRequestParts<S> + Send,\n T4: FromRequestParts<S> + Send,\n T5: FromRequestParts<S> + Send,\n T6: FromRequestParts<S> + Send,\n T7: FromRequestParts<S> + Send,\n T8: FromRequestParts<S> + Send,\n T9: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9), S>","servers::server::ServerHandler"],["
§

impl<F, Fut, S, Res, M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequestParts<S> + Send,\n T2: FromRequestParts<S> + Send,\n T3: FromRequestParts<S> + Send,\n T4: FromRequestParts<S> + Send,\n T5: FromRequestParts<S> + Send,\n T6: FromRequestParts<S> + Send,\n T7: FromRequestParts<S> + Send,\n T8: FromRequestParts<S> + Send,\n T9: FromRequestParts<S> + Send,\n T10: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10), S>","servers::server::ServerHandler"],["
§

impl<F, Fut, S, Res, M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequestParts<S> + Send,\n T2: FromRequestParts<S> + Send,\n T3: FromRequestParts<S> + Send,\n T4: FromRequestParts<S> + Send,\n T5: FromRequestParts<S> + Send,\n T6: FromRequestParts<S> + Send,\n T7: FromRequestParts<S> + Send,\n T8: FromRequestParts<S> + Send,\n T9: FromRequestParts<S> + Send,\n T10: FromRequestParts<S> + Send,\n T11: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11), S>","servers::server::ServerHandler"],["
§

impl<F, Fut, S, Res, M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequestParts<S> + Send,\n T2: FromRequestParts<S> + Send,\n T3: FromRequestParts<S> + Send,\n T4: FromRequestParts<S> + Send,\n T5: FromRequestParts<S> + Send,\n T6: FromRequestParts<S> + Send,\n T7: FromRequestParts<S> + Send,\n T8: FromRequestParts<S> + Send,\n T9: FromRequestParts<S> + Send,\n T10: FromRequestParts<S> + Send,\n T11: FromRequestParts<S> + Send,\n T12: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12), S>","servers::server::ServerHandler"],["
§

impl<F, Fut, S, Res, M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequestParts<S> + Send,\n T2: FromRequestParts<S> + Send,\n T3: FromRequestParts<S> + Send,\n T4: FromRequestParts<S> + Send,\n T5: FromRequestParts<S> + Send,\n T6: FromRequestParts<S> + Send,\n T7: FromRequestParts<S> + Send,\n T8: FromRequestParts<S> + Send,\n T9: FromRequestParts<S> + Send,\n T10: FromRequestParts<S> + Send,\n T11: FromRequestParts<S> + Send,\n T12: FromRequestParts<S> + Send,\n T13: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13), S>","servers::server::ServerHandler"],["
§

impl<F, Fut, S, Res, M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequestParts<S> + Send,\n T2: FromRequestParts<S> + Send,\n T3: FromRequestParts<S> + Send,\n T4: FromRequestParts<S> + Send,\n T5: FromRequestParts<S> + Send,\n T6: FromRequestParts<S> + Send,\n T7: FromRequestParts<S> + Send,\n T8: FromRequestParts<S> + Send,\n T9: FromRequestParts<S> + Send,\n T10: FromRequestParts<S> + Send,\n T11: FromRequestParts<S> + Send,\n T12: FromRequestParts<S> + Send,\n T13: FromRequestParts<S> + Send,\n T14: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14), S>","servers::server::ServerHandler"],["
§

impl<F, Fut, S, Res, M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequestParts<S> + Send,\n T2: FromRequestParts<S> + Send,\n T3: FromRequestParts<S> + Send,\n T4: FromRequestParts<S> + Send,\n T5: FromRequestParts<S> + Send,\n T6: FromRequestParts<S> + Send,\n T7: FromRequestParts<S> + Send,\n T8: FromRequestParts<S> + Send,\n T9: FromRequestParts<S> + Send,\n T10: FromRequestParts<S> + Send,\n T11: FromRequestParts<S> + Send,\n T12: FromRequestParts<S> + Send,\n T13: FromRequestParts<S> + Send,\n T14: FromRequestParts<S> + Send,\n T15: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15), S>","servers::server::ServerHandler"],["
§

impl<F, Fut, S, Res, M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16> Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16) -> Fut + Clone + Send + Sync + 'static,\n Fut: Future<Output = Res> + Send,\n S: Send + Sync + 'static,\n Res: IntoResponse,\n T1: FromRequestParts<S> + Send,\n T2: FromRequestParts<S> + Send,\n T3: FromRequestParts<S> + Send,\n T4: FromRequestParts<S> + Send,\n T5: FromRequestParts<S> + Send,\n T6: FromRequestParts<S> + Send,\n T7: FromRequestParts<S> + Send,\n T8: FromRequestParts<S> + Send,\n T9: FromRequestParts<S> + Send,\n T10: FromRequestParts<S> + Send,\n T11: FromRequestParts<S> + Send,\n T12: FromRequestParts<S> + Send,\n T13: FromRequestParts<S> + Send,\n T14: FromRequestParts<S> + Send,\n T15: FromRequestParts<S> + Send,\n T16: FromRequest<S, M> + Send,

§

type Future = Pin<Box<dyn Future<Output = Response<Body>> + Send>>

The type of future calling this handler returns.
§

fn call(\n self,\n req: Request<Body>,\n state: S,\n) -> <F as Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16), S>>::Future

Call the handler with the given request.
§

fn layer<L>(self, layer: L) -> Layered<L, Self, T, S>
where\n L: Layer<HandlerService<Self, T, S>> + Clone,\n <L as Layer<HandlerService<Self, T, S>>>::Service: Service<Request<Body>>,

Apply a [tower::Layer] to the handler. Read more
§

fn with_state(self, state: S) -> HandlerService<Self, T, S>

Convert the handler into a [Service] by providing the state
","Handler<(M, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16), S>","servers::server::ServerHandler"],["
§

impl<F, Fut, S, T1> HandlerCallWithExtractors<(T1,), S> for F
where\n F: FnOnce(T1) -> Fut,\n Fut: Future + Send + 'static,\n <Fut as Future>::Output: IntoResponse,

§

type Future = Map<Fut, fn(<Fut as Future>::Output) -> Response<Body>>

The type of future calling this handler returns.
§

fn call(\n self,\n _: (T1,),\n _state: S,\n) -> <F as HandlerCallWithExtractors<(T1,), S>>::Future

Call the handler with the extracted inputs.
§

fn into_handler(self) -> IntoHandler<Self, T, S>

Convert this HandlerCallWithExtractors into [Handler].
§

fn or<R, Rt>(self, rhs: R) -> Or<Self, R, T, Rt, S>
where\n R: HandlerCallWithExtractors<Rt, S>,

Chain two handlers together, running the second one if the first one rejects. Read more
","HandlerCallWithExtractors<(T1,), S>","servers::server::ServerHandler"],["
§

impl<F, Fut, S, T1, T2> HandlerCallWithExtractors<(T1, T2), S> for F
where\n F: FnOnce(T1, T2) -> Fut,\n Fut: Future + Send + 'static,\n <Fut as Future>::Output: IntoResponse,

§

type Future = Map<Fut, fn(<Fut as Future>::Output) -> Response<Body>>

The type of future calling this handler returns.
§

fn call(\n self,\n _: (T1, T2),\n _state: S,\n) -> <F as HandlerCallWithExtractors<(T1, T2), S>>::Future

Call the handler with the extracted inputs.
§

fn into_handler(self) -> IntoHandler<Self, T, S>

Convert this HandlerCallWithExtractors into [Handler].
§

fn or<R, Rt>(self, rhs: R) -> Or<Self, R, T, Rt, S>
where\n R: HandlerCallWithExtractors<Rt, S>,

Chain two handlers together, running the second one if the first one rejects. Read more
","HandlerCallWithExtractors<(T1, T2), S>","servers::server::ServerHandler"],["
§

impl<F, Fut, S, T1, T2, T3> HandlerCallWithExtractors<(T1, T2, T3), S> for F
where\n F: FnOnce(T1, T2, T3) -> Fut,\n Fut: Future + Send + 'static,\n <Fut as Future>::Output: IntoResponse,

§

type Future = Map<Fut, fn(<Fut as Future>::Output) -> Response<Body>>

The type of future calling this handler returns.
§

fn call(\n self,\n _: (T1, T2, T3),\n _state: S,\n) -> <F as HandlerCallWithExtractors<(T1, T2, T3), S>>::Future

Call the handler with the extracted inputs.
§

fn into_handler(self) -> IntoHandler<Self, T, S>

Convert this HandlerCallWithExtractors into [Handler].
§

fn or<R, Rt>(self, rhs: R) -> Or<Self, R, T, Rt, S>
where\n R: HandlerCallWithExtractors<Rt, S>,

Chain two handlers together, running the second one if the first one rejects. Read more
","HandlerCallWithExtractors<(T1, T2, T3), S>","servers::server::ServerHandler"],["
§

impl<F, Fut, S, T1, T2, T3, T4> HandlerCallWithExtractors<(T1, T2, T3, T4), S> for F
where\n F: FnOnce(T1, T2, T3, T4) -> Fut,\n Fut: Future + Send + 'static,\n <Fut as Future>::Output: IntoResponse,

§

type Future = Map<Fut, fn(<Fut as Future>::Output) -> Response<Body>>

The type of future calling this handler returns.
§

fn call(\n self,\n _: (T1, T2, T3, T4),\n _state: S,\n) -> <F as HandlerCallWithExtractors<(T1, T2, T3, T4), S>>::Future

Call the handler with the extracted inputs.
§

fn into_handler(self) -> IntoHandler<Self, T, S>

Convert this HandlerCallWithExtractors into [Handler].
§

fn or<R, Rt>(self, rhs: R) -> Or<Self, R, T, Rt, S>
where\n R: HandlerCallWithExtractors<Rt, S>,

Chain two handlers together, running the second one if the first one rejects. Read more
","HandlerCallWithExtractors<(T1, T2, T3, T4), S>","servers::server::ServerHandler"],["
§

impl<F, Fut, S, T1, T2, T3, T4, T5> HandlerCallWithExtractors<(T1, T2, T3, T4, T5), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5) -> Fut,\n Fut: Future + Send + 'static,\n <Fut as Future>::Output: IntoResponse,

§

type Future = Map<Fut, fn(<Fut as Future>::Output) -> Response<Body>>

The type of future calling this handler returns.
§

fn call(\n self,\n _: (T1, T2, T3, T4, T5),\n _state: S,\n) -> <F as HandlerCallWithExtractors<(T1, T2, T3, T4, T5), S>>::Future

Call the handler with the extracted inputs.
§

fn into_handler(self) -> IntoHandler<Self, T, S>

Convert this HandlerCallWithExtractors into [Handler].
§

fn or<R, Rt>(self, rhs: R) -> Or<Self, R, T, Rt, S>
where\n R: HandlerCallWithExtractors<Rt, S>,

Chain two handlers together, running the second one if the first one rejects. Read more
","HandlerCallWithExtractors<(T1, T2, T3, T4, T5), S>","servers::server::ServerHandler"],["
§

impl<F, Fut, S, T1, T2, T3, T4, T5, T6> HandlerCallWithExtractors<(T1, T2, T3, T4, T5, T6), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5, T6) -> Fut,\n Fut: Future + Send + 'static,\n <Fut as Future>::Output: IntoResponse,

§

type Future = Map<Fut, fn(<Fut as Future>::Output) -> Response<Body>>

The type of future calling this handler returns.
§

fn call(\n self,\n _: (T1, T2, T3, T4, T5, T6),\n _state: S,\n) -> <F as HandlerCallWithExtractors<(T1, T2, T3, T4, T5, T6), S>>::Future

Call the handler with the extracted inputs.
§

fn into_handler(self) -> IntoHandler<Self, T, S>

Convert this HandlerCallWithExtractors into [Handler].
§

fn or<R, Rt>(self, rhs: R) -> Or<Self, R, T, Rt, S>
where\n R: HandlerCallWithExtractors<Rt, S>,

Chain two handlers together, running the second one if the first one rejects. Read more
","HandlerCallWithExtractors<(T1, T2, T3, T4, T5, T6), S>","servers::server::ServerHandler"],["
§

impl<F, Fut, S, T1, T2, T3, T4, T5, T6, T7> HandlerCallWithExtractors<(T1, T2, T3, T4, T5, T6, T7), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5, T6, T7) -> Fut,\n Fut: Future + Send + 'static,\n <Fut as Future>::Output: IntoResponse,

§

type Future = Map<Fut, fn(<Fut as Future>::Output) -> Response<Body>>

The type of future calling this handler returns.
§

fn call(\n self,\n _: (T1, T2, T3, T4, T5, T6, T7),\n _state: S,\n) -> <F as HandlerCallWithExtractors<(T1, T2, T3, T4, T5, T6, T7), S>>::Future

Call the handler with the extracted inputs.
§

fn into_handler(self) -> IntoHandler<Self, T, S>

Convert this HandlerCallWithExtractors into [Handler].
§

fn or<R, Rt>(self, rhs: R) -> Or<Self, R, T, Rt, S>
where\n R: HandlerCallWithExtractors<Rt, S>,

Chain two handlers together, running the second one if the first one rejects. Read more
","HandlerCallWithExtractors<(T1, T2, T3, T4, T5, T6, T7), S>","servers::server::ServerHandler"],["
§

impl<F, Fut, S, T1, T2, T3, T4, T5, T6, T7, T8> HandlerCallWithExtractors<(T1, T2, T3, T4, T5, T6, T7, T8), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5, T6, T7, T8) -> Fut,\n Fut: Future + Send + 'static,\n <Fut as Future>::Output: IntoResponse,

§

type Future = Map<Fut, fn(<Fut as Future>::Output) -> Response<Body>>

The type of future calling this handler returns.
§

fn call(\n self,\n _: (T1, T2, T3, T4, T5, T6, T7, T8),\n _state: S,\n) -> <F as HandlerCallWithExtractors<(T1, T2, T3, T4, T5, T6, T7, T8), S>>::Future

Call the handler with the extracted inputs.
§

fn into_handler(self) -> IntoHandler<Self, T, S>

Convert this HandlerCallWithExtractors into [Handler].
§

fn or<R, Rt>(self, rhs: R) -> Or<Self, R, T, Rt, S>
where\n R: HandlerCallWithExtractors<Rt, S>,

Chain two handlers together, running the second one if the first one rejects. Read more
","HandlerCallWithExtractors<(T1, T2, T3, T4, T5, T6, T7, T8), S>","servers::server::ServerHandler"],["
§

impl<F, Fut, S, T1, T2, T3, T4, T5, T6, T7, T8, T9> HandlerCallWithExtractors<(T1, T2, T3, T4, T5, T6, T7, T8, T9), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5, T6, T7, T8, T9) -> Fut,\n Fut: Future + Send + 'static,\n <Fut as Future>::Output: IntoResponse,

§

type Future = Map<Fut, fn(<Fut as Future>::Output) -> Response<Body>>

The type of future calling this handler returns.
§

fn call(\n self,\n _: (T1, T2, T3, T4, T5, T6, T7, T8, T9),\n _state: S,\n) -> <F as HandlerCallWithExtractors<(T1, T2, T3, T4, T5, T6, T7, T8, T9), S>>::Future

Call the handler with the extracted inputs.
§

fn into_handler(self) -> IntoHandler<Self, T, S>

Convert this HandlerCallWithExtractors into [Handler].
§

fn or<R, Rt>(self, rhs: R) -> Or<Self, R, T, Rt, S>
where\n R: HandlerCallWithExtractors<Rt, S>,

Chain two handlers together, running the second one if the first one rejects. Read more
","HandlerCallWithExtractors<(T1, T2, T3, T4, T5, T6, T7, T8, T9), S>","servers::server::ServerHandler"],["
§

impl<F, Fut, S, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> HandlerCallWithExtractors<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) -> Fut,\n Fut: Future + Send + 'static,\n <Fut as Future>::Output: IntoResponse,

§

type Future = Map<Fut, fn(<Fut as Future>::Output) -> Response<Body>>

The type of future calling this handler returns.
§

fn call(\n self,\n _: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10),\n _state: S,\n) -> <F as HandlerCallWithExtractors<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10), S>>::Future

Call the handler with the extracted inputs.
§

fn into_handler(self) -> IntoHandler<Self, T, S>

Convert this HandlerCallWithExtractors into [Handler].
§

fn or<R, Rt>(self, rhs: R) -> Or<Self, R, T, Rt, S>
where\n R: HandlerCallWithExtractors<Rt, S>,

Chain two handlers together, running the second one if the first one rejects. Read more
","HandlerCallWithExtractors<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10), S>","servers::server::ServerHandler"],["
§

impl<F, Fut, S, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> HandlerCallWithExtractors<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) -> Fut,\n Fut: Future + Send + 'static,\n <Fut as Future>::Output: IntoResponse,

§

type Future = Map<Fut, fn(<Fut as Future>::Output) -> Response<Body>>

The type of future calling this handler returns.
§

fn call(\n self,\n _: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11),\n _state: S,\n) -> <F as HandlerCallWithExtractors<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11), S>>::Future

Call the handler with the extracted inputs.
§

fn into_handler(self) -> IntoHandler<Self, T, S>

Convert this HandlerCallWithExtractors into [Handler].
§

fn or<R, Rt>(self, rhs: R) -> Or<Self, R, T, Rt, S>
where\n R: HandlerCallWithExtractors<Rt, S>,

Chain two handlers together, running the second one if the first one rejects. Read more
","HandlerCallWithExtractors<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11), S>","servers::server::ServerHandler"],["
§

impl<F, Fut, S, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> HandlerCallWithExtractors<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) -> Fut,\n Fut: Future + Send + 'static,\n <Fut as Future>::Output: IntoResponse,

§

type Future = Map<Fut, fn(<Fut as Future>::Output) -> Response<Body>>

The type of future calling this handler returns.
§

fn call(\n self,\n _: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12),\n _state: S,\n) -> <F as HandlerCallWithExtractors<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12), S>>::Future

Call the handler with the extracted inputs.
§

fn into_handler(self) -> IntoHandler<Self, T, S>

Convert this HandlerCallWithExtractors into [Handler].
§

fn or<R, Rt>(self, rhs: R) -> Or<Self, R, T, Rt, S>
where\n R: HandlerCallWithExtractors<Rt, S>,

Chain two handlers together, running the second one if the first one rejects. Read more
","HandlerCallWithExtractors<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12), S>","servers::server::ServerHandler"],["
§

impl<F, Fut, S, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> HandlerCallWithExtractors<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) -> Fut,\n Fut: Future + Send + 'static,\n <Fut as Future>::Output: IntoResponse,

§

type Future = Map<Fut, fn(<Fut as Future>::Output) -> Response<Body>>

The type of future calling this handler returns.
§

fn call(\n self,\n _: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13),\n _state: S,\n) -> <F as HandlerCallWithExtractors<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13), S>>::Future

Call the handler with the extracted inputs.
§

fn into_handler(self) -> IntoHandler<Self, T, S>

Convert this HandlerCallWithExtractors into [Handler].
§

fn or<R, Rt>(self, rhs: R) -> Or<Self, R, T, Rt, S>
where\n R: HandlerCallWithExtractors<Rt, S>,

Chain two handlers together, running the second one if the first one rejects. Read more
","HandlerCallWithExtractors<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13), S>","servers::server::ServerHandler"],["
§

impl<F, Fut, S, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> HandlerCallWithExtractors<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) -> Fut,\n Fut: Future + Send + 'static,\n <Fut as Future>::Output: IntoResponse,

§

type Future = Map<Fut, fn(<Fut as Future>::Output) -> Response<Body>>

The type of future calling this handler returns.
§

fn call(\n self,\n _: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14),\n _state: S,\n) -> <F as HandlerCallWithExtractors<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14), S>>::Future

Call the handler with the extracted inputs.
§

fn into_handler(self) -> IntoHandler<Self, T, S>

Convert this HandlerCallWithExtractors into [Handler].
§

fn or<R, Rt>(self, rhs: R) -> Or<Self, R, T, Rt, S>
where\n R: HandlerCallWithExtractors<Rt, S>,

Chain two handlers together, running the second one if the first one rejects. Read more
","HandlerCallWithExtractors<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14), S>","servers::server::ServerHandler"],["
§

impl<F, Fut, S, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> HandlerCallWithExtractors<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) -> Fut,\n Fut: Future + Send + 'static,\n <Fut as Future>::Output: IntoResponse,

§

type Future = Map<Fut, fn(<Fut as Future>::Output) -> Response<Body>>

The type of future calling this handler returns.
§

fn call(\n self,\n _: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15),\n _state: S,\n) -> <F as HandlerCallWithExtractors<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15), S>>::Future

Call the handler with the extracted inputs.
§

fn into_handler(self) -> IntoHandler<Self, T, S>

Convert this HandlerCallWithExtractors into [Handler].
§

fn or<R, Rt>(self, rhs: R) -> Or<Self, R, T, Rt, S>
where\n R: HandlerCallWithExtractors<Rt, S>,

Chain two handlers together, running the second one if the first one rejects. Read more
","HandlerCallWithExtractors<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15), S>","servers::server::ServerHandler"],["
§

impl<F, Fut, S, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16> HandlerCallWithExtractors<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16), S> for F
where\n F: FnOnce(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16) -> Fut,\n Fut: Future + Send + 'static,\n <Fut as Future>::Output: IntoResponse,

§

type Future = Map<Fut, fn(<Fut as Future>::Output) -> Response<Body>>

The type of future calling this handler returns.
§

fn call(\n self,\n _: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16),\n _state: S,\n) -> <F as HandlerCallWithExtractors<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16), S>>::Future

Call the handler with the extracted inputs.
§

fn into_handler(self) -> IntoHandler<Self, T, S>

Convert this HandlerCallWithExtractors into [Handler].
§

fn or<R, Rt>(self, rhs: R) -> Or<Self, R, T, Rt, S>
where\n R: HandlerCallWithExtractors<Rt, S>,

Chain two handlers together, running the second one if the first one rejects. Read more
","HandlerCallWithExtractors<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16), S>","servers::server::ServerHandler"],["
§

impl<A, B> IntoParallelIterator for (A, B)
where\n A: IntoParallelIterator,\n <A as IntoParallelIterator>::Iter: IndexedParallelIterator,\n B: IntoParallelIterator,\n <B as IntoParallelIterator>::Iter: IndexedParallelIterator,

§

type Item = (<A as IntoParallelIterator>::Item, <B as IntoParallelIterator>::Item)

The type of item that the parallel iterator will produce.
§

type Iter = MultiZip<(<A as IntoParallelIterator>::Iter, <B as IntoParallelIterator>::Iter)>

The parallel iterator type that will be created.
§

fn into_par_iter(self) -> <(A, B) as IntoParallelIterator>::Iter

Converts self into a parallel iterator. Read more
","IntoParallelIterator","servers::server::ServerHandler"],["
§

impl<R, T1> IntoResponse for (T1, R)
where\n T1: IntoResponseParts,\n R: IntoResponse,

§

fn into_response(self) -> Response<Body>

Create a response.
","IntoResponse","servers::server::ServerHandler"],["
§

impl<T1, T2> IntoResponseParts for (T1, T2)
where\n T1: IntoResponseParts,\n T2: IntoResponseParts,

§

type Error = Response<Body>

The type returned in the event of an error. Read more
§

fn into_response_parts(\n self,\n res: ResponseParts,\n) -> Result<ResponseParts, <(T1, T2) as IntoResponseParts>::Error>

Set parts of the response
","IntoResponseParts","servers::server::ServerHandler"],["
Source§

impl<Ix, E> IntoWeightedEdge<E> for (Ix, Ix)
where\n E: Default,

","IntoWeightedEdge","servers::server::ServerHandler"],["
Source§

impl<Ix, E> IntoWeightedEdge<E> for (Ix, Ix)
where\n E: Default,

","IntoWeightedEdge","servers::server::ServerHandler"],["
§

impl<S, L1, L2> Layer<S> for (L1, L2)
where\n L1: Layer<<L2 as Layer<S>>::Service>,\n L2: Layer<S>,

§

type Service = <L1 as Layer<<L2 as Layer<S>>::Service>>::Service

The wrapped service
§

fn layer(&self, service: S) -> <(L1, L2) as Layer<S>>::Service

Wrap the given service with the middleware, returning a new service\nthat has been decorated with the middleware.
","Layer","servers::server::ServerHandler"],["
§

impl<A, B> Monoid for (A, B)
where\n A: Monoid,\n B: Monoid,

§

fn empty() -> (A, B)

For a given Monoid, returns its empty/zero value Read more
","Monoid","servers::server::ServerHandler"],["
Source§

impl<IT, A, FromA> MultiUnzip<(FromA,)> for IT
where\n IT: Iterator<Item = (A,)>,\n FromA: Default + Extend<A>,

Source§

fn multiunzip(self) -> (FromA,)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA,)>","servers::server::ServerHandler"],["
§

impl<IT, A, FromA> MultiUnzip<(FromA,)> for IT
where\n IT: Iterator<Item = (A,)>,\n FromA: Default + Extend<A>,

§

fn multiunzip(self) -> (FromA,)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA,)>","servers::server::ServerHandler"],["
§

impl<IT, A, FromA> MultiUnzip<(FromA,)> for IT
where\n IT: Iterator<Item = (A,)>,\n FromA: Default + Extend<A>,

§

fn multiunzip(self) -> (FromA,)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA,)>","servers::server::ServerHandler"],["
Source§

impl<IT, A, FromA, B, FromB> MultiUnzip<(FromA, FromB)> for IT
where\n IT: Iterator<Item = (A, B)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,

Source§

fn multiunzip(self) -> (FromA, FromB)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB)>","servers::server::ServerHandler"],["
§

impl<IT, A, FromA, B, FromB> MultiUnzip<(FromA, FromB)> for IT
where\n IT: Iterator<Item = (A, B)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,

§

fn multiunzip(self) -> (FromA, FromB)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB)>","servers::server::ServerHandler"],["
§

impl<IT, A, FromA, B, FromB> MultiUnzip<(FromA, FromB)> for IT
where\n IT: Iterator<Item = (A, B)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,

§

fn multiunzip(self) -> (FromA, FromB)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB)>","servers::server::ServerHandler"],["
Source§

impl<IT, A, FromA, B, FromB, C, FromC> MultiUnzip<(FromA, FromB, FromC)> for IT
where\n IT: Iterator<Item = (A, B, C)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,

Source§

fn multiunzip(self) -> (FromA, FromB, FromC)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC)>","servers::server::ServerHandler"],["
§

impl<IT, A, FromA, B, FromB, C, FromC> MultiUnzip<(FromA, FromB, FromC)> for IT
where\n IT: Iterator<Item = (A, B, C)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,

§

fn multiunzip(self) -> (FromA, FromB, FromC)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC)>","servers::server::ServerHandler"],["
§

impl<IT, A, FromA, B, FromB, C, FromC> MultiUnzip<(FromA, FromB, FromC)> for IT
where\n IT: Iterator<Item = (A, B, C)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,

§

fn multiunzip(self) -> (FromA, FromB, FromC)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC)>","servers::server::ServerHandler"],["
Source§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD> MultiUnzip<(FromA, FromB, FromC, FromD)> for IT
where\n IT: Iterator<Item = (A, B, C, D)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,

Source§

fn multiunzip(self) -> (FromA, FromB, FromC, FromD)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD)>","servers::server::ServerHandler"],["
§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD> MultiUnzip<(FromA, FromB, FromC, FromD)> for IT
where\n IT: Iterator<Item = (A, B, C, D)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,

§

fn multiunzip(self) -> (FromA, FromB, FromC, FromD)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD)>","servers::server::ServerHandler"],["
§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD> MultiUnzip<(FromA, FromB, FromC, FromD)> for IT
where\n IT: Iterator<Item = (A, B, C, D)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,

§

fn multiunzip(self) -> (FromA, FromB, FromC, FromD)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD)>","servers::server::ServerHandler"],["
Source§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE> MultiUnzip<(FromA, FromB, FromC, FromD, FromE)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,

Source§

fn multiunzip(self) -> (FromA, FromB, FromC, FromD, FromE)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE)>","servers::server::ServerHandler"],["
§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE> MultiUnzip<(FromA, FromB, FromC, FromD, FromE)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,

§

fn multiunzip(self) -> (FromA, FromB, FromC, FromD, FromE)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE)>","servers::server::ServerHandler"],["
§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE> MultiUnzip<(FromA, FromB, FromC, FromD, FromE)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,

§

fn multiunzip(self) -> (FromA, FromB, FromC, FromD, FromE)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE)>","servers::server::ServerHandler"],["
Source§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E, F)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,\n FromF: Default + Extend<F>,

Source§

fn multiunzip(self) -> (FromA, FromB, FromC, FromD, FromE, FromF)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF)>","servers::server::ServerHandler"],["
§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E, F)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,\n FromF: Default + Extend<F>,

§

fn multiunzip(self) -> (FromA, FromB, FromC, FromD, FromE, FromF)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF)>","servers::server::ServerHandler"],["
§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E, F)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,\n FromF: Default + Extend<F>,

§

fn multiunzip(self) -> (FromA, FromB, FromC, FromD, FromE, FromF)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF)>","servers::server::ServerHandler"],["
Source§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E, F, G)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,\n FromF: Default + Extend<F>,\n FromG: Default + Extend<G>,

Source§

fn multiunzip(self) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG)>","servers::server::ServerHandler"],["
§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E, F, G)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,\n FromF: Default + Extend<F>,\n FromG: Default + Extend<G>,

§

fn multiunzip(self) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG)>","servers::server::ServerHandler"],["
§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E, F, G)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,\n FromF: Default + Extend<F>,\n FromG: Default + Extend<G>,

§

fn multiunzip(self) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG)>","servers::server::ServerHandler"],["
Source§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E, F, G, H)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,\n FromF: Default + Extend<F>,\n FromG: Default + Extend<G>,\n FromH: Default + Extend<H>,

Source§

fn multiunzip(self) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH)>","servers::server::ServerHandler"],["
§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E, F, G, H)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,\n FromF: Default + Extend<F>,\n FromG: Default + Extend<G>,\n FromH: Default + Extend<H>,

§

fn multiunzip(self) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH)>","servers::server::ServerHandler"],["
§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E, F, G, H)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,\n FromF: Default + Extend<F>,\n FromG: Default + Extend<G>,\n FromH: Default + Extend<H>,

§

fn multiunzip(self) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH)>","servers::server::ServerHandler"],["
Source§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E, F, G, H, I)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,\n FromF: Default + Extend<F>,\n FromG: Default + Extend<G>,\n FromH: Default + Extend<H>,\n FromI: Default + Extend<I>,

Source§

fn multiunzip(\n self,\n) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI)>","servers::server::ServerHandler"],["
§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E, F, G, H, I)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,\n FromF: Default + Extend<F>,\n FromG: Default + Extend<G>,\n FromH: Default + Extend<H>,\n FromI: Default + Extend<I>,

§

fn multiunzip(\n self,\n) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI)>","servers::server::ServerHandler"],["
§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E, F, G, H, I)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,\n FromF: Default + Extend<F>,\n FromG: Default + Extend<G>,\n FromH: Default + Extend<H>,\n FromI: Default + Extend<I>,

§

fn multiunzip(\n self,\n) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI)>","servers::server::ServerHandler"],["
Source§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,\n FromF: Default + Extend<F>,\n FromG: Default + Extend<G>,\n FromH: Default + Extend<H>,\n FromI: Default + Extend<I>,\n FromJ: Default + Extend<J>,

Source§

fn multiunzip(\n self,\n) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ)>","servers::server::ServerHandler"],["
§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,\n FromF: Default + Extend<F>,\n FromG: Default + Extend<G>,\n FromH: Default + Extend<H>,\n FromI: Default + Extend<I>,\n FromJ: Default + Extend<J>,

§

fn multiunzip(\n self,\n) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ)>","servers::server::ServerHandler"],["
§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,\n FromF: Default + Extend<F>,\n FromG: Default + Extend<G>,\n FromH: Default + Extend<H>,\n FromI: Default + Extend<I>,\n FromJ: Default + Extend<J>,

§

fn multiunzip(\n self,\n) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ)>","servers::server::ServerHandler"],["
Source§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ, K, FromK> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J, K)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,\n FromF: Default + Extend<F>,\n FromG: Default + Extend<G>,\n FromH: Default + Extend<H>,\n FromI: Default + Extend<I>,\n FromJ: Default + Extend<J>,\n FromK: Default + Extend<K>,

Source§

fn multiunzip(\n self,\n) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK)>","servers::server::ServerHandler"],["
§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ, K, FromK> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J, K)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,\n FromF: Default + Extend<F>,\n FromG: Default + Extend<G>,\n FromH: Default + Extend<H>,\n FromI: Default + Extend<I>,\n FromJ: Default + Extend<J>,\n FromK: Default + Extend<K>,

§

fn multiunzip(\n self,\n) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK)>","servers::server::ServerHandler"],["
§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ, K, FromK> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J, K)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,\n FromF: Default + Extend<F>,\n FromG: Default + Extend<G>,\n FromH: Default + Extend<H>,\n FromI: Default + Extend<I>,\n FromJ: Default + Extend<J>,\n FromK: Default + Extend<K>,

§

fn multiunzip(\n self,\n) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK)>","servers::server::ServerHandler"],["
Source§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ, K, FromK, L, FromL> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK, FromL)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J, K, L)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,\n FromF: Default + Extend<F>,\n FromG: Default + Extend<G>,\n FromH: Default + Extend<H>,\n FromI: Default + Extend<I>,\n FromJ: Default + Extend<J>,\n FromK: Default + Extend<K>,\n FromL: Default + Extend<L>,

","MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK, FromL)>","servers::server::ServerHandler"],["
§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ, K, FromK, L, FromL> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK, FromL)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J, K, L)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,\n FromF: Default + Extend<F>,\n FromG: Default + Extend<G>,\n FromH: Default + Extend<H>,\n FromI: Default + Extend<I>,\n FromJ: Default + Extend<J>,\n FromK: Default + Extend<K>,\n FromL: Default + Extend<L>,

§

fn multiunzip(\n self,\n) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK, FromL)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK, FromL)>","servers::server::ServerHandler"],["
§

impl<IT, A, FromA, B, FromB, C, FromC, D, FromD, E, FromE, F, FromF, G, FromG, H, FromH, I, FromI, J, FromJ, K, FromK, L, FromL> MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK, FromL)> for IT
where\n IT: Iterator<Item = (A, B, C, D, E, F, G, H, I, J, K, L)>,\n FromA: Default + Extend<A>,\n FromB: Default + Extend<B>,\n FromC: Default + Extend<C>,\n FromD: Default + Extend<D>,\n FromE: Default + Extend<E>,\n FromF: Default + Extend<F>,\n FromG: Default + Extend<G>,\n FromH: Default + Extend<H>,\n FromI: Default + Extend<I>,\n FromJ: Default + Extend<J>,\n FromK: Default + Extend<K>,\n FromL: Default + Extend<L>,

§

fn multiunzip(\n self,\n) -> (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK, FromL)

Unzip this iterator into multiple collections.
","MultiUnzip<(FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK, FromL)>","servers::server::ServerHandler"],["
§

impl<A, B, FromA, FromB> ParallelExtend<(A, B)> for (FromA, FromB)
where\n A: Send,\n B: Send,\n FromA: Send + ParallelExtend<A>,\n FromB: Send + ParallelExtend<B>,

§

fn par_extend<I>(&mut self, pi: I)
where\n I: IntoParallelIterator<Item = (A, B)>,

Extends an instance of the collection with the elements drawn\nfrom the parallel iterator par_iter. Read more
","ParallelExtend<(A, B)>","servers::server::ServerHandler"],["
§

impl<L, R, A, B> ParallelExtend<Either<L, R>> for (A, B)
where\n L: Send,\n R: Send,\n A: Send + ParallelExtend<L>,\n B: Send + ParallelExtend<R>,

§

fn par_extend<I>(&mut self, pi: I)
where\n I: IntoParallelIterator<Item = Either<L, R>>,

Extends an instance of the collection with the elements drawn\nfrom the parallel iterator par_iter. Read more
","ParallelExtend>","servers::server::ServerHandler"],["
§

impl<I, O1, O2, E, P1, P2> Parser<I> for (P1, P2)
where\n E: ParseError<I>,\n P1: Parser<I, Output = O1, Error = E>,\n P2: Parser<I, Output = O2, Error = E>,

§

type Output = (O1, O2)

Type of the produced value
§

type Error = E

Error type of this parser
§

fn process<OM>(\n &mut self,\n i: I,\n) -> Result<(I, <<OM as OutputMode>::Output as Mode>::Output<<(P1, P2) as Parser<I>>::Output>), Err<<(P1, P2) as Parser<I>>::Error, <<OM as OutputMode>::Error as Mode>::Output<<(P1, P2) as Parser<I>>::Error>>>
where\n OM: OutputMode,

A parser takes in input type, and returns a Result containing\neither the remaining input and the output value, or an error
§

fn parse(\n &mut self,\n input: Input,\n) -> Result<(Input, Self::Output), Err<Self::Error>>

A parser takes in input type, and returns a Result containing\neither the remaining input and the output value, or an error
§

fn parse_complete(\n &mut self,\n input: Input,\n) -> Result<(Input, Self::Output), Err<Self::Error>>

A parser takes in input type, and returns a Result containing\neither the remaining input and the output value, or an error
§

fn map<G, O2>(self, g: G) -> Map<Self, G>
where\n G: FnMut(Self::Output) -> O2,\n Self: Sized,

Maps a function over the result of a parser
§

fn map_res<G, O2, E2>(self, g: G) -> MapRes<Self, G>
where\n G: FnMut(Self::Output) -> Result<O2, E2>,\n Self::Error: FromExternalError<Input, E2>,\n Self: Sized,

Applies a function returning a Result over the result of a parser.
§

fn map_opt<G, O2>(self, g: G) -> MapOpt<Self, G>
where\n G: FnMut(Self::Output) -> Option<O2>,\n Self: Sized,

Applies a function returning an Option over the result of a parser.
§

fn flat_map<G, H>(self, g: G) -> FlatMap<Self, G>
where\n G: FnMut(Self::Output) -> H,\n H: Parser<Input, Error = Self::Error>,\n Self: Sized,

Creates a second parser from the output of the first one, then apply over the rest of the input
§

fn and_then<G>(self, g: G) -> AndThen<Self, G>
where\n G: Parser<Self::Output, Error = Self::Error>,\n Self: Sized,

Applies a second parser over the output of the first one
§

fn and<G, O2>(self, g: G) -> And<Self, G>
where\n G: Parser<Input, Output = O2, Error = Self::Error>,\n Self: Sized,

Applies a second parser after the first one, return their results as a tuple
§

fn or<G>(self, g: G) -> Or<Self, G>
where\n G: Parser<Input, Output = Self::Output, Error = Self::Error>,\n Self: Sized,

Applies a second parser over the input if the first one failed
§

fn into<O2, E2>(self) -> Into<Self, O2, E2>
where\n O2: From<Self::Output>,\n E2: From<Self::Error>,\n Self: Sized,

automatically converts the parser’s output and error values to another type, as long as they\nimplement the From trait
","Parser","servers::server::ServerHandler"],["
§

impl<I, O0, O1, E, P0, P1> Parser<I, (O0, O1), E> for (P0, P1)
where\n I: Stream,\n E: ParserError<I>,\n P0: Parser<I, O0, E>,\n P1: Parser<I, O1, E>,

§

fn parse_next(&mut self, i: &mut I) -> Result<(O0, O1), E>

Take tokens from the [Stream], turning it into the output Read more
§

fn parse(\n &mut self,\n input: I,\n) -> Result<O, ParseError<I, <E as ParserError<I>>::Inner>>
where\n Self: Sized,\n I: Stream + StreamIsPartial,\n E: ParserError<I>,\n <E as ParserError<I>>::Inner: ParserError<I>,

Parse all of input, generating O from it
§

fn parse_peek(&mut self, input: I) -> Result<(I, O), E>

Take tokens from the [Stream], turning it into the output Read more
§

fn by_ref(&mut self) -> ByRef<'_, Self, I, O, E>
where\n Self: Sized,

Treat &mut Self as a parser Read more
§

fn value<O2>(self, val: O2) -> Value<Self, I, O, O2, E>
where\n Self: Sized,\n O2: Clone,

Produce the provided value Read more
§

fn default_value<O2>(self) -> DefaultValue<Self, I, O, O2, E>
where\n Self: Sized,\n O2: Default,

Produce a type’s default value Read more
§

fn void(self) -> Void<Self, I, O, E>
where\n Self: Sized,

Discards the output of the Parser Read more
§

fn output_into<O2>(self) -> OutputInto<Self, I, O, O2, E>
where\n Self: Sized,\n O: Into<O2>,

Convert the parser’s output to another type using std::convert::From Read more
§

fn take(self) -> Take<Self, I, O, E>
where\n Self: Sized,\n I: Stream,

Produce the consumed input as produced value. Read more
§

fn with_taken(self) -> WithTaken<Self, I, O, E>
where\n Self: Sized,\n I: Stream,

Produce the consumed input with the output Read more
§

fn span(self) -> Span<Self, I, O, E>
where\n Self: Sized,\n I: Stream + Location,

Produce the location of the consumed input as produced value. Read more
§

fn with_span(self) -> WithSpan<Self, I, O, E>
where\n Self: Sized,\n I: Stream + Location,

Produce the location of consumed input with the output Read more
§

fn map<G, O2>(self, map: G) -> Map<Self, G, I, O, O2, E>
where\n G: FnMut(O) -> O2,\n Self: Sized,

Maps a function over the output of a parser Read more
§

fn try_map<G, O2, E2>(self, map: G) -> TryMap<Self, G, I, O, O2, E, E2>
where\n Self: Sized,\n G: FnMut(O) -> Result<O2, E2>,\n I: Stream,\n E: FromExternalError<I, E2> + ParserError<I>,

Applies a function returning a Result over the output of a parser. Read more
§

fn verify_map<G, O2>(self, map: G) -> VerifyMap<Self, G, I, O, O2, E>
where\n Self: Sized,\n G: FnMut(O) -> Option<O2>,\n I: Stream,\n E: ParserError<I>,

Apply both [Parser::verify] and [Parser::map]. Read more
§

fn flat_map<G, H, O2>(self, map: G) -> FlatMap<Self, G, H, I, O, O2, E>
where\n Self: Sized,\n G: FnMut(O) -> H,\n H: Parser<I, O2, E>,

Creates a parser from the output of this one Read more
§

fn and_then<G, O2>(self, inner: G) -> AndThen<Self, G, I, O, O2, E>
where\n Self: Sized,\n G: Parser<O, O2, E>,\n O: StreamIsPartial,\n I: Stream,

Applies a second parser over the output of the first one Read more
§

fn parse_to<O2>(self) -> ParseTo<Self, I, O, O2, E>
where\n Self: Sized,\n I: Stream,\n O: ParseSlice<O2>,\n E: ParserError<I>,

Apply std::str::FromStr to the output of the parser Read more
§

fn verify<G, O2>(self, filter: G) -> Verify<Self, G, I, O, O2, E>
where\n Self: Sized,\n G: FnMut(&O2) -> bool,\n I: Stream,\n O: Borrow<O2>,\n E: ParserError<I>,\n O2: ?Sized,

Returns the output of the child parser if it satisfies a verification function. Read more
§

fn context<C>(self, context: C) -> Context<Self, I, O, E, C>
where\n Self: Sized,\n I: Stream,\n E: AddContext<I, C> + ParserError<I>,\n C: Clone + Debug,

If parsing fails, add context to the error Read more
§

fn context_with<F, C, FI>(\n self,\n context: F,\n) -> ContextWith<Self, I, O, E, F, C, FI>
where\n Self: Sized,\n I: Stream,\n E: AddContext<I, C> + ParserError<I>,\n F: Fn() -> FI + Clone,\n C: Debug,\n FI: Iterator<Item = C>,

If parsing fails, dynamically add context to the error Read more
§

fn map_err<G, E2>(self, map: G) -> MapErr<Self, G, I, O, E, E2>
where\n G: FnMut(E) -> E2,\n Self: Sized,

Maps a function over the error of a parser Read more
§

fn complete_err(self) -> CompleteErr<Self, I, O, E>
where\n Self: Sized,

Transforms [Incomplete][crate::error::ErrMode::Incomplete] into [Backtrack][crate::error::ErrMode::Backtrack] Read more
§

fn err_into<E2>(self) -> ErrInto<Self, I, O, E, E2>
where\n Self: Sized,\n E: Into<E2>,

Convert the parser’s error to another type using std::convert::From
","Parser","servers::server::ServerHandler"],["
§

impl<I, O1, O2, Error, P1, P2> Permutation<I, (O1, O2), Error> for (P1, P2)
where\n I: Stream,\n Error: ParserError<I>,\n P1: Parser<I, O1, Error>,\n P2: Parser<I, O2, Error>,

§

fn permutation(&mut self, input: &mut I) -> Result<(O1, O2), Error>

Tries to apply all parsers in the tuple in various orders until all of them succeed
","Permutation","servers::server::ServerHandler"],["
§

impl<Input, A, B, Error, FnA, FnB> Permutation<Input, (A, B), Error> for (FnA, FnB)
where\n Input: Clone,\n Error: ParseError<Input>,\n FnA: Parser<Input, A, Error>,\n FnB: Parser<Input, B, Error>,

§

fn permutation(&mut self, input: Input) -> Result<(Input, (A, B)), Err<Error>>

Tries to apply all parsers in the tuple in various orders until all of them succeed
","Permutation","servers::server::ServerHandler"],["
§

impl<T1, T2> PgHasArrayType for (T1, T2)

§

fn array_type_info() -> PgTypeInfo

§

fn array_compatible(ty: &PgTypeInfo) -> bool

","PgHasArrayType","servers::server::ServerHandler"],["
§

impl<S> Point for (S, S)
where\n S: RTreeNum,

§

const DIMENSIONS: usize = 2usize

The number of dimensions of this point type.
§

type Scalar = S

The number type used by this point type.
§

fn generate(generator: impl FnMut(usize) -> S) -> (S, S)

Creates a new point value with given values for each dimension. Read more
§

fn nth(&self, index: usize) -> <(S, S) as Point>::Scalar

Returns a single coordinate of this point. Read more
§

fn nth_mut(&mut self, index: usize) -> &mut <(S, S) as Point>::Scalar

Mutable variant of nth.
","Point","servers::server::ServerHandler"],["
§

impl<A, B> Semigroup for (A, B)
where\n A: Semigroup,\n B: Semigroup,

§

fn combine(&self, other: &(A, B)) -> (A, B)

Associative operation taking which combines two values. Read more
","Semigroup","servers::server::ServerHandler"],["
Source§

impl<T0, T1> Serialize for (T0, T1)
where\n T0: Serialize,\n T1: Serialize,

Source§

fn serialize<S>(\n &self,\n serializer: S,\n) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>
where\n S: Serializer,

Serialize this value into the given Serde serializer. Read more
","Serialize","servers::server::ServerHandler"],["
Source§

impl<T0, As0, T1, As1> SerializeAs<(T0, T1)> for (As0, As1)
where\n As0: SerializeAs<T0>,\n As1: SerializeAs<T1>,

Source§

fn serialize_as<S>(\n tuple: &(T0, T1),\n serializer: S,\n) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>
where\n S: Serializer,

Serialize this value into the given Serde serializer.
","SerializeAs<(T0, T1)>","servers::server::ServerHandler"],["
§

impl<'a, T, C0, C1> TreeNodeContainer<'a, T> for (C0, C1)
where\n T: 'a,\n C0: TreeNodeContainer<'a, T>,\n C1: TreeNodeContainer<'a, T>,

§

fn apply_elements<F>(\n &'a self,\n f: F,\n) -> Result<TreeNodeRecursion, DataFusionError>
where\n F: FnMut(&'a T) -> Result<TreeNodeRecursion, DataFusionError>,

Applies f to all elements of the container.\nThis method is usually called from [TreeNode::apply_children] implementations as\na node is actually a container of the node’s children.
§

fn map_elements<F>(self, f: F) -> Result<Transformed<(C0, C1)>, DataFusionError>
where\n F: FnMut(T) -> Result<Transformed<T>, DataFusionError>,

Maps all elements of the container with f.\nThis method is usually called from [TreeNode::map_children] implementations as\na node is actually a container of the node’s children.
","TreeNodeContainer<'a, T>","servers::server::ServerHandler"],["
§

impl<Input, A, B, Error, FnA, FnB> Tuple<Input, (A, B), Error> for (FnA, FnB)
where\n Input: Clone,\n Error: ParseError<Input>,\n FnA: Parser<Input, A, Error>,\n FnB: Parser<Input, B, Error>,

§

fn parse(&mut self, input: Input) -> Result<(Input, (A, B)), Err<Error>>

Parses the input and returns a tuple of results of each parser.
","Tuple","servers::server::ServerHandler"],["
§

impl<Input, A, B, Error, FnA, FnB> Tuple<Input, (A, B), Error> for (FnA, FnB)
where\n Input: Clone,\n Error: ParseError<Input>,\n FnA: Parser<Input, Output = A, Error = Error>,\n FnB: Parser<Input, Output = B, Error = Error>,

§

fn parse_tuple(&mut self, input: Input) -> Result<(Input, (A, B)), Err<Error>>

👎Deprecated since 8.0.0: Parser is directly implemented for tuples
Parses the input and returns a tuple of results of each parser.
","Tuple","servers::server::ServerHandler"],["
§

impl<T1, T2> Type<Postgres> for (T1, T2)

§

fn type_info() -> PgTypeInfo

Returns the canonical SQL type for this Rust type. Read more
§

fn compatible(ty: &<DB as Database>::TypeInfo) -> bool

Determines if this Rust type is compatible with the given SQL type. Read more
","Type","servers::server::ServerHandler"],["
§

impl<A, B> UnsizedCopy for (A, B)
where\n A: Copy,\n B: UnsizedCopy + ?Sized,

§

type Alignment = (A, <B as UnsizedCopy>::Alignment)

A type with the same alignment as Self. Read more
§

fn ptr_with_addr(&self, addr: *const ()) -> *const (A, B)

Change the address of a pointer to Self. Read more
§

fn unsized_copy_into<T>(&self) -> T
where\n T: UnsizedCopyFrom<Source = Self>,

Copy self into a new container. Read more
§

fn copy(&self) -> Self
where\n Self: Sized,

Copy self and return it by value. Read more
","UnsizedCopy","servers::server::ServerHandler"],["
§

impl<T1, T0> Values for (T1, T0)
where\n T1: Values,\n T0: Values,

§

fn encoded_len(&self, mode: Mode) -> usize

Returns the length of the encoded values for the given mode.
§

fn write_encoded<W>(&self, mode: Mode, target: &mut W) -> Result<(), Error>
where\n W: Write,

Encodes the values in the given mode and writes them to target.
§

fn explicit(self, tag: Tag) -> Constructed<Self>
where\n Self: Sized,

Converts the encoder into one with an explicit tag.
§

fn to_captured(&self, mode: Mode) -> Captured

Captures the encoded values in the given mode.
","Values","servers::server::ServerHandler"],["
§

impl<'a, T1, T2> Yokeable<'a> for (T1, T2)
where\n T1: 'static + for<'b> Yokeable<'b>,\n T2: 'static + for<'b> Yokeable<'b>,

§

type Output = (<T1 as Yokeable<'a>>::Output, <T2 as Yokeable<'a>>::Output)

This type MUST be Self with the 'static replaced with 'a, i.e. Self<'a>
§

fn transform(&'a self) -> &'a <(T1, T2) as Yokeable<'a>>::Output

This method must cast self between &'a Self<'static> and &'a Self<'a>. Read more
§

fn transform_owned(self) -> <(T1, T2) as Yokeable<'a>>::Output

This method must cast self between Self<'static> and Self<'a>. Read more
§

unsafe fn make(from: <(T1, T2) as Yokeable<'a>>::Output) -> (T1, T2)

This method can be used to cast away Self<'a>’s lifetime. Read more
§

fn transform_mut<F>(&'a mut self, f: F)
where\n F: 'static + for<'b> FnOnce(&'b mut <(T1, T2) as Yokeable<'a>>::Output),

This method must cast self between &'a mut Self<'static> and &'a mut Self<'a>,\nand pass it to f. Read more
","Yokeable<'a>","servers::server::ServerHandler"],["
§

impl<'a, A, B, AE, BE, Format> ZeroFrom<'a, Tuple2VarULE<A, B, Format>> for (AE, BE)
where\n A: VarULE + ?Sized,\n B: VarULE + ?Sized,\n AE: ZeroFrom<'a, A>,\n BE: ZeroFrom<'a, B>,\n Format: VarZeroVecFormat,

§

fn zero_from(other: &'a Tuple2VarULE<A, B, Format>) -> (AE, BE)

Clone the other C into a struct that may retain references into C.
","ZeroFrom<'a, Tuple2VarULE>","servers::server::ServerHandler"],["
§

impl<'zf, C1, T1, C2, T2> ZeroFrom<'zf, (C1, C2)> for (T1, T2)
where\n T1: ZeroFrom<'zf, C1>,\n T2: ZeroFrom<'zf, C2>,

§

fn zero_from(other: &'zf (C1, C2)) -> (T1, T2)

Clone the other C into a struct that may retain references into C.
","ZeroFrom<'zf, (C1, C2)>","servers::server::ServerHandler"],["
§

impl<'a, A, B> ZeroMapKV<'a> for (A, B)
where\n A: Ord + AsULE + 'static,\n B: Ord + AsULE + 'static,

§

type Container = ZeroVec<'a, (A, B)>

The container that can be used with this type: [ZeroVec] or [VarZeroVec].
§

type Slice = ZeroSlice<(A, B)>

§

type GetType = Tuple2ULE<<A as AsULE>::ULE, <B as AsULE>::ULE>

The type produced by Container::get() Read more
§

type OwnedType = (A, B)

The type produced by Container::replace() and Container::remove(),\nalso used during deserialization. If Self is human readable serialized,\ndeserializing to Self::OwnedType should produce the same value once\npassed through Self::owned_as_self() Read more
","ZeroMapKV<'a>","servers::server::ServerHandler"],["
§

impl<A, B> Zeroable for (A, B)
where\n A: Zeroable,\n B: Zeroable,

§

fn zeroed() -> Self

","Zeroable","servers::server::ServerHandler"],["
§

impl<A, B> Zeroize for (A, B)
where\n A: Zeroize,\n B: Zeroize,

§

fn zeroize(&mut self)

Zero out this object from memory using Rust intrinsics which ensure the\nzeroization operation is not “optimized away” by the compiler.
","Zeroize","servers::server::ServerHandler"],["
§

impl<A, B> ZeroizeOnDrop for (A, B)
where\n A: ZeroizeOnDrop,\n B: ZeroizeOnDrop,

","ZeroizeOnDrop","servers::server::ServerHandler"]]]]); if (window.register_type_impls) { window.register_type_impls(type_impls); } else { window.pending_type_impls = type_impls; } })() //{"start":55,"fragment_lengths":[456309,344701,252584,224637,145293,454699,498526,391364,146685,464722]}