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

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

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

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<One, Two, Three> Collector for (One, Two, Three)
where\n One: Collector,\n Two: Collector,\n Three: Collector,

§

type Fruit = (<One as Collector>::Fruit, <Two as Collector>::Fruit, <Three 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)

Type of the SegmentCollector associated with this collector.
§

fn check_schema(&self, schema: &Schema) -> Result<(), TantivyError>

Returns an error if the schema is not compatible with the collector.
§

fn for_segment(\n &self,\n segment_local_id: u32,\n segment: &SegmentReader,\n) -> Result<<(One, Two, Three) 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) as Collector>::Child as SegmentCollector>::Fruit>,\n) -> Result<<(One, Two, Three) 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","cli::data::export::TableReference"],["
§

impl<Type1, Type2, Type3, Comparator1, Comparator2, Comparator3> Comparator<(Type1, (Type2, Type3))> for (Comparator1, Comparator2, Comparator3)
where\n Comparator1: Comparator<Type1>,\n Comparator2: Comparator<Type2>,\n Comparator3: Comparator<Type3>,

§

fn compare(\n &self,\n lhs: &(Type1, (Type2, Type3)),\n rhs: &(Type1, (Type2, Type3)),\n) -> Ordering

Return the order between two values.
","Comparator<(Type1, (Type2, Type3))>","cli::data::export::TableReference"],["
§

impl<Type1, Type2, Type3, Comparator1, Comparator2, Comparator3> Comparator<(Type1, Type2, Type3)> for (Comparator1, Comparator2, Comparator3)
where\n Comparator1: Comparator<Type1>,\n Comparator2: Comparator<Type2>,\n Comparator3: Comparator<Type3>,

§

fn compare(\n &self,\n lhs: &(Type1, Type2, Type3),\n rhs: &(Type1, Type2, Type3),\n) -> Ordering

Return the order between two values.
","Comparator<(Type1, Type2, Type3)>","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 + Send + Sync>>

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"],["
Source§

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

Source§

fn fmt_const(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Print a const expression representing this value.
","FmtConst","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<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<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","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"],["
Source§

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

Source§

fn borrow(&self) -> &(A, B, C)

Convert a reference to self to a reference to the borrowed type.
","PhfBorrow<(A, B, C)>","cli::data::export::TableReference"],["
Source§

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

Source§

fn phf_hash<HS>(&self, state: &mut HS)
where\n HS: Hasher,

Feeds the value into the state given, updating the hasher as necessary.
Source§

fn phf_hash_slice<H>(data: &[Self], state: &mut H)
where\n H: Hasher,\n Self: Sized,

Feeds a slice of this type into the state provided.
","PhfHash","cli::data::export::TableReference"],["
§

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

§

const DIMENSIONS: usize

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<One, Two, Three> SegmentCollector for (One, Two, Three)
where\n One: SegmentCollector,\n Two: SegmentCollector,\n Three: SegmentCollector,

§

type Fruit = (<One as SegmentCollector>::Fruit, <Two as SegmentCollector>::Fruit, <Three 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 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
§

fn harvest(self) -> <(One, Two, Three) as SegmentCollector>::Fruit

Extract the fruit of the collection from the SegmentCollector.
","SegmentCollector","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<SortKeyComputer1, SortKeyComputer2, SortKeyComputer3> SortKeyComputer for (SortKeyComputer1, SortKeyComputer2, SortKeyComputer3)
where\n SortKeyComputer1: SortKeyComputer,\n SortKeyComputer2: SortKeyComputer,\n SortKeyComputer3: SortKeyComputer,

§

type SortKey = (<SortKeyComputer1 as SortKeyComputer>::SortKey, <SortKeyComputer2 as SortKeyComputer>::SortKey, <SortKeyComputer3 as SortKeyComputer>::SortKey)

The sort key type.
§

type Child = MappedSegmentSortKeyComputer<<(SortKeyComputer1, (SortKeyComputer2, SortKeyComputer3)) as SortKeyComputer>::Child, (<SortKeyComputer1 as SortKeyComputer>::SortKey, (<SortKeyComputer2 as SortKeyComputer>::SortKey, <SortKeyComputer3 as SortKeyComputer>::SortKey)), <(SortKeyComputer1, SortKeyComputer2, SortKeyComputer3) as SortKeyComputer>::SortKey>

Type of the associated [SegmentSortKeyComputer].
§

type Comparator = (<SortKeyComputer1 as SortKeyComputer>::Comparator, <SortKeyComputer2 as SortKeyComputer>::Comparator, <SortKeyComputer3 as SortKeyComputer>::Comparator)

Comparator type.
§

fn comparator(\n &self,\n) -> <(SortKeyComputer1, SortKeyComputer2, SortKeyComputer3) as SortKeyComputer>::Comparator

Returns the sort key comparator.
§

fn segment_sort_key_computer(\n &self,\n segment_reader: &SegmentReader,\n) -> Result<<(SortKeyComputer1, SortKeyComputer2, SortKeyComputer3) as SortKeyComputer>::Child, TantivyError>

Builds a child sort key computer for a specific segment.
§

fn check_schema(&self, schema: &Schema) -> Result<(), TantivyError>

Checks whether the schema is compatible with the sort key computer.
§

fn requires_scoring(&self) -> bool

Indicates whether the sort key actually uses the similarity score (by default BM25).\nIf set to false, the similary score might not be computed (as an optimization),\nand the score fed in the segment sort key computer could take any value.
§

fn collect_segment_top_k(\n &self,\n k: usize,\n weight: &(dyn Weight + 'static),\n reader: &SegmentReader,\n segment_ord: u32,\n) -> Result<Vec<(Self::SortKey, DocAddress)>, TantivyError>

Sorting by score has a overriding implementation for BM25 scores, using Block-WAND.
","SortKeyComputer","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<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,

Available on crate feature alloc only.
§

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<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

\n
Parses the input and returns a tuple of results of each parser.
","Tuple","common_function::scalars::primary_key::NameValuePair"],["
§

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 + Send + Sync>>

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<O, K, V> IntoOperatorUri for (String, O)
where\n O: IntoIterator<Item = (K, V)>,\n K: Into<String>,\n V: Into<String>,

§

fn into_operator_uri(self) -> Result<OperatorUri, Error>

Convert the input into an [OperatorUri].
","IntoOperatorUri","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

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<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,

Available on crate feature alloc only.
§

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::OutgoingMessage"],["
§

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","common_meta::heartbeat::mailbox::IncomingMessage"],["
§

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::OutgoingMessage"],["
§

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","common_meta::heartbeat::mailbox::IncomingMessage"],["
§

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::OutgoingMessage"],["
§

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","common_meta::heartbeat::mailbox::IncomingMessage"],["
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","common_meta::heartbeat::mailbox::IncomingMessage"],["
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::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::OutgoingMessage"],["
§

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","common_meta::heartbeat::mailbox::IncomingMessage"],["
§

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 + Send + Sync>>

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::OutgoingMessage"],["
§

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 + Send + Sync>>

Decode a new value of this type using a raw value from the database.
","Decode<'r, Postgres>","common_meta::heartbeat::mailbox::IncomingMessage"],["
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::OutgoingMessage"],["
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>","common_meta::heartbeat::mailbox::IncomingMessage"],["
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::OutgoingMessage"],["
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)>","common_meta::heartbeat::mailbox::IncomingMessage"],["
§

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::OutgoingMessage"],["
§

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>","common_meta::heartbeat::mailbox::IncomingMessage"],["
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::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::OutgoingMessage"],["
§

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","common_meta::heartbeat::mailbox::IncomingMessage"],["
§

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::OutgoingMessage"],["
§

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","common_meta::heartbeat::mailbox::IncomingMessage"],["
§

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::OutgoingMessage"],["
§

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>","common_meta::heartbeat::mailbox::IncomingMessage"],["
§

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::OutgoingMessage"],["
§

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","common_meta::heartbeat::mailbox::IncomingMessage"],["
§

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::OutgoingMessage"],["
§

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","common_meta::heartbeat::mailbox::IncomingMessage"],["
Source§

impl<Ix, E> IntoWeightedEdge<E> for (Ix, Ix)
where\n E: Default,

","IntoWeightedEdge","common_meta::ddl::DetectingRegion","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::OutgoingMessage"],["
Source§

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

","IntoWeightedEdge","common_meta::heartbeat::mailbox::IncomingMessage"],["
Source§

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

","IntoWeightedEdge","common_meta::heartbeat::mailbox::IncomingMessage"],["
§

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::OutgoingMessage"],["
§

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","common_meta::heartbeat::mailbox::IncomingMessage"],["
§

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, 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::OutgoingMessage"],["
§

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","common_meta::heartbeat::mailbox::IncomingMessage"],["
§

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::OutgoingMessage"],["
§

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","common_meta::heartbeat::mailbox::IncomingMessage"],["
§

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::OutgoingMessage"],["
§

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","common_meta::heartbeat::mailbox::IncomingMessage"],["
§

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::OutgoingMessage"],["
§

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

§

fn array_type_info() -> PgTypeInfo

§

fn array_compatible(ty: &PgTypeInfo) -> bool

","PgHasArrayType","common_meta::heartbeat::mailbox::IncomingMessage"],["
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::OutgoingMessage"],["
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","common_meta::heartbeat::mailbox::IncomingMessage"],["
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::OutgoingMessage"],["
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)>","common_meta::heartbeat::mailbox::IncomingMessage"],["
§

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::OutgoingMessage"],["
§

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>","common_meta::heartbeat::mailbox::IncomingMessage"],["
§

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::OutgoingMessage"],["
§

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","common_meta::heartbeat::mailbox::IncomingMessage"],["
§

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::OutgoingMessage"],["
§

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","common_meta::heartbeat::mailbox::IncomingMessage"],["
§

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::OutgoingMessage"],["
§

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","common_meta::heartbeat::mailbox::IncomingMessage"],["
§

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::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::OutgoingMessage"],["
§

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>","common_meta::heartbeat::mailbox::IncomingMessage"],["
§

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::OutgoingMessage"],["
§

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)>","common_meta::heartbeat::mailbox::IncomingMessage"],["
§

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

Available on crate feature alloc only.
§

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::OutgoingMessage"],["
§

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,

Available on crate feature alloc only.
§

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>","common_meta::heartbeat::mailbox::IncomingMessage"],["
§

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::OutgoingMessage"],["
§

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

§

fn zeroed() -> Self

","Zeroable","common_meta::heartbeat::mailbox::IncomingMessage"],["
§

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::OutgoingMessage"],["
§

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","common_meta::heartbeat::mailbox::IncomingMessage"],["
§

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

","ZeroizeOnDrop","common_meta::ddl::DetectingRegion","common_meta::heartbeat::mailbox::OutgoingMessage"],["
§

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

","ZeroizeOnDrop","common_meta::heartbeat::mailbox::IncomingMessage"]]],["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,

Available on crate feature alloc only.
§

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<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

\n
Parses the input and returns a tuple of results of each parser.
","Tuple","flow::repr::DiffRow","flow::repr::KeyValDiffRow"],["
§

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<One, Two, Three> Collector for (One, Two, Three)
where\n One: Collector,\n Two: Collector,\n Three: Collector,

§

type Fruit = (<One as Collector>::Fruit, <Two as Collector>::Fruit, <Three 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)

Type of the SegmentCollector associated with this collector.
§

fn check_schema(&self, schema: &Schema) -> Result<(), TantivyError>

Returns an error if the schema is not compatible with the collector.
§

fn for_segment(\n &self,\n segment_local_id: u32,\n segment: &SegmentReader,\n) -> Result<<(One, Two, Three) 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) as Collector>::Child as SegmentCollector>::Fruit>,\n) -> Result<<(One, Two, Three) 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","flow::repr::DiffRow","flow::repr::KeyValDiffRow"],["
§

impl<Type1, Type2, Type3, Comparator1, Comparator2, Comparator3> Comparator<(Type1, (Type2, Type3))> for (Comparator1, Comparator2, Comparator3)
where\n Comparator1: Comparator<Type1>,\n Comparator2: Comparator<Type2>,\n Comparator3: Comparator<Type3>,

§

fn compare(\n &self,\n lhs: &(Type1, (Type2, Type3)),\n rhs: &(Type1, (Type2, Type3)),\n) -> Ordering

Return the order between two values.
","Comparator<(Type1, (Type2, Type3))>","flow::repr::DiffRow","flow::repr::KeyValDiffRow"],["
§

impl<Type1, Type2, Type3, Comparator1, Comparator2, Comparator3> Comparator<(Type1, Type2, Type3)> for (Comparator1, Comparator2, Comparator3)
where\n Comparator1: Comparator<Type1>,\n Comparator2: Comparator<Type2>,\n Comparator3: Comparator<Type3>,

§

fn compare(\n &self,\n lhs: &(Type1, Type2, Type3),\n rhs: &(Type1, Type2, Type3),\n) -> Ordering

Return the order between two values.
","Comparator<(Type1, Type2, Type3)>","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 + Send + Sync>>

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"],["
Source§

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

Source§

fn fmt_const(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Print a const expression representing this value.
","FmtConst","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<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"],["
Source§

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

Source§

fn borrow(&self) -> &(A, B, C)

Convert a reference to self to a reference to the borrowed type.
","PhfBorrow<(A, B, C)>","flow::repr::DiffRow","flow::repr::KeyValDiffRow"],["
Source§

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

Source§

fn phf_hash<HS>(&self, state: &mut HS)
where\n HS: Hasher,

Feeds the value into the state given, updating the hasher as necessary.
Source§

fn phf_hash_slice<H>(data: &[Self], state: &mut H)
where\n H: Hasher,\n Self: Sized,

Feeds a slice of this type into the state provided.
","PhfHash","flow::repr::DiffRow","flow::repr::KeyValDiffRow"],["
§

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

§

const DIMENSIONS: usize

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<One, Two, Three> SegmentCollector for (One, Two, Three)
where\n One: SegmentCollector,\n Two: SegmentCollector,\n Three: SegmentCollector,

§

type Fruit = (<One as SegmentCollector>::Fruit, <Two as SegmentCollector>::Fruit, <Three 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 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
§

fn harvest(self) -> <(One, Two, Three) as SegmentCollector>::Fruit

Extract the fruit of the collection from the SegmentCollector.
","SegmentCollector","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<SortKeyComputer1, SortKeyComputer2, SortKeyComputer3> SortKeyComputer for (SortKeyComputer1, SortKeyComputer2, SortKeyComputer3)
where\n SortKeyComputer1: SortKeyComputer,\n SortKeyComputer2: SortKeyComputer,\n SortKeyComputer3: SortKeyComputer,

§

type SortKey = (<SortKeyComputer1 as SortKeyComputer>::SortKey, <SortKeyComputer2 as SortKeyComputer>::SortKey, <SortKeyComputer3 as SortKeyComputer>::SortKey)

The sort key type.
§

type Child = MappedSegmentSortKeyComputer<<(SortKeyComputer1, (SortKeyComputer2, SortKeyComputer3)) as SortKeyComputer>::Child, (<SortKeyComputer1 as SortKeyComputer>::SortKey, (<SortKeyComputer2 as SortKeyComputer>::SortKey, <SortKeyComputer3 as SortKeyComputer>::SortKey)), <(SortKeyComputer1, SortKeyComputer2, SortKeyComputer3) as SortKeyComputer>::SortKey>

Type of the associated [SegmentSortKeyComputer].
§

type Comparator = (<SortKeyComputer1 as SortKeyComputer>::Comparator, <SortKeyComputer2 as SortKeyComputer>::Comparator, <SortKeyComputer3 as SortKeyComputer>::Comparator)

Comparator type.
§

fn comparator(\n &self,\n) -> <(SortKeyComputer1, SortKeyComputer2, SortKeyComputer3) as SortKeyComputer>::Comparator

Returns the sort key comparator.
§

fn segment_sort_key_computer(\n &self,\n segment_reader: &SegmentReader,\n) -> Result<<(SortKeyComputer1, SortKeyComputer2, SortKeyComputer3) as SortKeyComputer>::Child, TantivyError>

Builds a child sort key computer for a specific segment.
§

fn check_schema(&self, schema: &Schema) -> Result<(), TantivyError>

Checks whether the schema is compatible with the sort key computer.
§

fn requires_scoring(&self) -> bool

Indicates whether the sort key actually uses the similarity score (by default BM25).\nIf set to false, the similary score might not be computed (as an optimization),\nand the score fed in the segment sort key computer could take any value.
§

fn collect_segment_top_k(\n &self,\n k: usize,\n weight: &(dyn Weight + 'static),\n reader: &SegmentReader,\n segment_ord: u32,\n) -> Result<Vec<(Self::SortKey, DocAddress)>, TantivyError>

Sorting by score has a overriding implementation for BM25 scores, using Block-WAND.
","SortKeyComputer","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<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,

Available on crate feature alloc only.
§

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<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

\n
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, 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

\n
Parses the input and returns a tuple of results of each parser.
","Tuple","mito2::cache::index::bloom_filter_index::BloomFilterIndexKey"],["
§

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 check_schema(&self, schema: &Schema) -> Result<(), TantivyError>

Returns an error if the schema is not compatible with the 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 check_schema(&self, schema: &Schema) -> Result<(), TantivyError>

Returns an error if the schema is not compatible with the 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<Head, Tail, LeftComparator, RightComparator> Comparator<(Head, Tail)> for (LeftComparator, RightComparator)
where\n LeftComparator: Comparator<Head>,\n RightComparator: Comparator<Tail>,

§

fn compare(&self, lhs: &(Head, Tail), rhs: &(Head, Tail)) -> Ordering

Return the order between two values.
","Comparator<(Head, Tail)>","mito2::sst::file::FileTimeRange"],["
§

impl<Type1, Type2, Type3, Type4, Comparator1, Comparator2, Comparator3, Comparator4> Comparator<(Type1, (Type2, (Type3, Type4)))> for (Comparator1, Comparator2, Comparator3, Comparator4)
where\n Comparator1: Comparator<Type1>,\n Comparator2: Comparator<Type2>,\n Comparator3: Comparator<Type3>,\n Comparator4: Comparator<Type4>,

§

fn compare(\n &self,\n lhs: &(Type1, (Type2, (Type3, Type4))),\n rhs: &(Type1, (Type2, (Type3, Type4))),\n) -> Ordering

Return the order between two values.
","Comparator<(Type1, (Type2, (Type3, Type4)))>","mito2::cache::index::bloom_filter_index::BloomFilterIndexKey"],["
§

impl<Type1, Type2, Type3, Type4, Comparator1, Comparator2, Comparator3, Comparator4> Comparator<(Type1, Type2, Type3, Type4)> for (Comparator1, Comparator2, Comparator3, Comparator4)
where\n Comparator1: Comparator<Type1>,\n Comparator2: Comparator<Type2>,\n Comparator3: Comparator<Type3>,\n Comparator4: Comparator<Type4>,

§

fn compare(\n &self,\n lhs: &(Type1, Type2, Type3, Type4),\n rhs: &(Type1, Type2, Type3, Type4),\n) -> Ordering

Return the order between two values.
","Comparator<(Type1, Type2, Type3, Type4)>","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 + Send + Sync>>

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 + Send + Sync>>

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"],["
Source§

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

Source§

fn fmt_const(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Print a const expression representing this value.
","FmtConst","mito2::sst::file::FileTimeRange"],["
Source§

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

Source§

fn fmt_const(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Print a const expression representing this value.
","FmtConst","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"],["
Source§

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

Source§

fn borrow(&self) -> &(A, B)

Convert a reference to self to a reference to the borrowed type.
","PhfBorrow<(A, B)>","mito2::sst::file::FileTimeRange"],["
Source§

impl<A, B, C, D> PhfBorrow<(A, B, C, D)> for (A, B, C, D)
where\n A: PhfHash,\n B: PhfHash,\n C: PhfHash,\n D: PhfHash,

Source§

fn borrow(&self) -> &(A, B, C, D)

Convert a reference to self to a reference to the borrowed type.
","PhfBorrow<(A, B, C, D)>","mito2::cache::index::bloom_filter_index::BloomFilterIndexKey"],["
Source§

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

Source§

fn phf_hash<HS>(&self, state: &mut HS)
where\n HS: Hasher,

Feeds the value into the state given, updating the hasher as necessary.
Source§

fn phf_hash_slice<H>(data: &[Self], state: &mut H)
where\n H: Hasher,\n Self: Sized,

Feeds a slice of this type into the state provided.
","PhfHash","mito2::sst::file::FileTimeRange"],["
Source§

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

Source§

fn phf_hash<HS>(&self, state: &mut HS)
where\n HS: Hasher,

Feeds the value into the state given, updating the hasher as necessary.
Source§

fn phf_hash_slice<H>(data: &[Self], state: &mut H)
where\n H: Hasher,\n Self: Sized,

Feeds a slice of this type into the state provided.
","PhfHash","mito2::cache::index::bloom_filter_index::BloomFilterIndexKey"],["
§

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

§

const DIMENSIONS: usize

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

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 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
§

fn harvest(self) -> <(Left, Right) as SegmentCollector>::Fruit

Extract the fruit of the collection from the SegmentCollector.
","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 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
§

fn harvest(self) -> <(One, Two, Three, Four) as SegmentCollector>::Fruit

Extract the fruit of the collection from the SegmentCollector.
","SegmentCollector","mito2::cache::index::bloom_filter_index::BloomFilterIndexKey"],["
§

impl<HeadSegmentSortKeyComputer, TailSegmentSortKeyComputer> SegmentSortKeyComputer for (HeadSegmentSortKeyComputer, TailSegmentSortKeyComputer)
where\n HeadSegmentSortKeyComputer: SegmentSortKeyComputer,\n TailSegmentSortKeyComputer: SegmentSortKeyComputer,

§

fn compare_segment_sort_key(\n &self,\n left: &<(HeadSegmentSortKeyComputer, TailSegmentSortKeyComputer) as SegmentSortKeyComputer>::SegmentSortKey,\n right: &<(HeadSegmentSortKeyComputer, TailSegmentSortKeyComputer) as SegmentSortKeyComputer>::SegmentSortKey,\n) -> Ordering

A SegmentSortKeyComputer maps to a SegmentSortKey, but it can also decide on\nits ordering.

\n

By default, it uses the natural ordering.

\n
§

type SortKey = (<HeadSegmentSortKeyComputer as SegmentSortKeyComputer>::SortKey, <TailSegmentSortKeyComputer as SegmentSortKeyComputer>::SortKey)

The final score being emitted.
§

type SegmentSortKey = (<HeadSegmentSortKeyComputer as SegmentSortKeyComputer>::SegmentSortKey, <TailSegmentSortKeyComputer as SegmentSortKeyComputer>::SegmentSortKey)

Sort key used by at the segment level by the SegmentSortKeyComputer. Read more
§

type SegmentComparator = (<HeadSegmentSortKeyComputer as SegmentSortKeyComputer>::SegmentComparator, <TailSegmentSortKeyComputer as SegmentSortKeyComputer>::SegmentComparator)

Comparator type.
§

fn compute_sort_key_and_collect<C>(\n &mut self,\n doc: u32,\n score: f32,\n top_n_computer: &mut TopNComputer<<(HeadSegmentSortKeyComputer, TailSegmentSortKeyComputer) as SegmentSortKeyComputer>::SegmentSortKey, u32, C>,\n)
where\n C: Comparator<<(HeadSegmentSortKeyComputer, TailSegmentSortKeyComputer) as SegmentSortKeyComputer>::SegmentSortKey>,

Computes the sort key and pushes the document in a TopN Computer. Read more
§

fn segment_sort_key(\n &mut self,\n doc: u32,\n score: f32,\n) -> <(HeadSegmentSortKeyComputer, TailSegmentSortKeyComputer) as SegmentSortKeyComputer>::SegmentSortKey

Computes the sort key for the given document and score.
§

fn accept_sort_key_lazy(\n &mut self,\n doc_id: u32,\n score: f32,\n threshold: &<(HeadSegmentSortKeyComputer, TailSegmentSortKeyComputer) as SegmentSortKeyComputer>::SegmentSortKey,\n) -> Option<(Ordering, <(HeadSegmentSortKeyComputer, TailSegmentSortKeyComputer) as SegmentSortKeyComputer>::SegmentSortKey)>

Implementing this method makes it possible to avoid computing\na sort_key entirely if we can assess that it won’t pass a threshold\nwith a partial computation. Read more
§

fn convert_segment_sort_key(\n &self,\n sort_key: <(HeadSegmentSortKeyComputer, TailSegmentSortKeyComputer) as SegmentSortKeyComputer>::SegmentSortKey,\n) -> <(HeadSegmentSortKeyComputer, TailSegmentSortKeyComputer) as SegmentSortKeyComputer>::SortKey

Convert a segment level sort key into the global sort key.
§

fn segment_comparator(&self) -> Self::SegmentComparator

Returns the segment sort key comparator.
","SegmentSortKeyComputer","mito2::sst::file::FileTimeRange"],["
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<HeadSortKeyComputer, TailSortKeyComputer> SortKeyComputer for (HeadSortKeyComputer, TailSortKeyComputer)
where\n HeadSortKeyComputer: SortKeyComputer,\n TailSortKeyComputer: SortKeyComputer,

§

fn check_schema(&self, schema: &Schema) -> Result<(), TantivyError>

Checks whether the schema is compatible with the sort key computer.

\n
§

fn requires_scoring(&self) -> bool

Indicates whether the sort key actually uses the similarity score (by default BM25).\nIf set to false, the similary score might not be computed (as an optimization),\nand the score fed in the segment sort key computer could take any value.

\n
§

type SortKey = (<HeadSortKeyComputer as SortKeyComputer>::SortKey, <TailSortKeyComputer as SortKeyComputer>::SortKey)

The sort key type.
§

type Child = (<HeadSortKeyComputer as SortKeyComputer>::Child, <TailSortKeyComputer as SortKeyComputer>::Child)

Type of the associated [SegmentSortKeyComputer].
§

type Comparator = (<HeadSortKeyComputer as SortKeyComputer>::Comparator, <TailSortKeyComputer as SortKeyComputer>::Comparator)

Comparator type.
§

fn comparator(\n &self,\n) -> <(HeadSortKeyComputer, TailSortKeyComputer) as SortKeyComputer>::Comparator

Returns the sort key comparator.
§

fn segment_sort_key_computer(\n &self,\n segment_reader: &SegmentReader,\n) -> Result<<(HeadSortKeyComputer, TailSortKeyComputer) as SortKeyComputer>::Child, TantivyError>

Builds a child sort key computer for a specific segment.
§

fn collect_segment_top_k(\n &self,\n k: usize,\n weight: &(dyn Weight + 'static),\n reader: &SegmentReader,\n segment_ord: u32,\n) -> Result<Vec<(Self::SortKey, DocAddress)>, TantivyError>

Sorting by score has a overriding implementation for BM25 scores, using Block-WAND.
","SortKeyComputer","mito2::sst::file::FileTimeRange"],["
§

impl<SortKeyComputer1, SortKeyComputer2, SortKeyComputer3, SortKeyComputer4> SortKeyComputer for (SortKeyComputer1, SortKeyComputer2, SortKeyComputer3, SortKeyComputer4)
where\n SortKeyComputer1: SortKeyComputer,\n SortKeyComputer2: SortKeyComputer,\n SortKeyComputer3: SortKeyComputer,\n SortKeyComputer4: SortKeyComputer,

§

type Child = MappedSegmentSortKeyComputer<<(SortKeyComputer1, (SortKeyComputer2, (SortKeyComputer3, SortKeyComputer4))) as SortKeyComputer>::Child, (<SortKeyComputer1 as SortKeyComputer>::SortKey, (<SortKeyComputer2 as SortKeyComputer>::SortKey, (<SortKeyComputer3 as SortKeyComputer>::SortKey, <SortKeyComputer4 as SortKeyComputer>::SortKey))), <(SortKeyComputer1, SortKeyComputer2, SortKeyComputer3, SortKeyComputer4) as SortKeyComputer>::SortKey>

Type of the associated [SegmentSortKeyComputer].
§

type SortKey = (<SortKeyComputer1 as SortKeyComputer>::SortKey, <SortKeyComputer2 as SortKeyComputer>::SortKey, <SortKeyComputer3 as SortKeyComputer>::SortKey, <SortKeyComputer4 as SortKeyComputer>::SortKey)

The sort key type.
§

type Comparator = (<SortKeyComputer1 as SortKeyComputer>::Comparator, <SortKeyComputer2 as SortKeyComputer>::Comparator, <SortKeyComputer3 as SortKeyComputer>::Comparator, <SortKeyComputer4 as SortKeyComputer>::Comparator)

Comparator type.
§

fn segment_sort_key_computer(\n &self,\n segment_reader: &SegmentReader,\n) -> Result<<(SortKeyComputer1, SortKeyComputer2, SortKeyComputer3, SortKeyComputer4) as SortKeyComputer>::Child, TantivyError>

Builds a child sort key computer for a specific segment.
§

fn check_schema(&self, schema: &Schema) -> Result<(), TantivyError>

Checks whether the schema is compatible with the sort key computer.
§

fn requires_scoring(&self) -> bool

Indicates whether the sort key actually uses the similarity score (by default BM25).\nIf set to false, the similary score might not be computed (as an optimization),\nand the score fed in the segment sort key computer could take any value.
§

fn comparator(&self) -> Self::Comparator

Returns the sort key comparator.
§

fn collect_segment_top_k(\n &self,\n k: usize,\n weight: &(dyn Weight + 'static),\n reader: &SegmentReader,\n segment_ord: u32,\n) -> Result<Vec<(Self::SortKey, DocAddress)>, TantivyError>

Sorting by score has a overriding implementation for BM25 scores, using Block-WAND.
","SortKeyComputer","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, 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<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,

Available on crate feature alloc only.
§

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,

Available on crate feature alloc only.
§

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<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

\n
Parses the input and returns a tuple of results of each parser.
","Tuple","pipeline::etl::transform::transformer::greptime::RowWithTableSuffix","pipeline::manager::PipelineInfo"],["
§

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 + Send + Sync>>

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

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<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,

Available on crate feature alloc only.
§

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<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

\n
Parses the input and returns a tuple of results of each parser.
","Tuple","servers::server::ServerHandler"],["
§

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"],["
§

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","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<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 check_schema(&self, schema: &Schema) -> Result<(), TantivyError>

Returns an error if the schema is not compatible with the 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","servers::server::ServerHandler"],["
§

impl<Head, Tail, LeftComparator, RightComparator> Comparator<(Head, Tail)> for (LeftComparator, RightComparator)
where\n LeftComparator: Comparator<Head>,\n RightComparator: Comparator<Tail>,

§

fn compare(&self, lhs: &(Head, Tail), rhs: &(Head, Tail)) -> Ordering

Return the order between two values.
","Comparator<(Head, Tail)>","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 + Send + Sync>>

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<Left, Right> FixedSize for (Left, Right)
where\n Left: BinarySerializable + FixedSize,\n Right: BinarySerializable + FixedSize,

","FixedSize","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"],["
Source§

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

Source§

fn fmt_const(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Print a const expression representing this value.
","FmtConst","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, 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"],["
Source§

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

Source§

fn borrow(&self) -> &(A, B)

Convert a reference to self to a reference to the borrowed type.
","PhfBorrow<(A, B)>","servers::server::ServerHandler"],["
Source§

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

Source§

fn phf_hash<HS>(&self, state: &mut HS)
where\n HS: Hasher,

Feeds the value into the state given, updating the hasher as necessary.
Source§

fn phf_hash_slice<H>(data: &[Self], state: &mut H)
where\n H: Hasher,\n Self: Sized,

Feeds a slice of this type into the state provided.
","PhfHash","servers::server::ServerHandler"],["
§

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

§

const DIMENSIONS: usize

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<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 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
§

fn harvest(self) -> <(Left, Right) as SegmentCollector>::Fruit

Extract the fruit of the collection from the SegmentCollector.
","SegmentCollector","servers::server::ServerHandler"],["
§

impl<HeadSegmentSortKeyComputer, TailSegmentSortKeyComputer> SegmentSortKeyComputer for (HeadSegmentSortKeyComputer, TailSegmentSortKeyComputer)
where\n HeadSegmentSortKeyComputer: SegmentSortKeyComputer,\n TailSegmentSortKeyComputer: SegmentSortKeyComputer,

§

fn compare_segment_sort_key(\n &self,\n left: &<(HeadSegmentSortKeyComputer, TailSegmentSortKeyComputer) as SegmentSortKeyComputer>::SegmentSortKey,\n right: &<(HeadSegmentSortKeyComputer, TailSegmentSortKeyComputer) as SegmentSortKeyComputer>::SegmentSortKey,\n) -> Ordering

A SegmentSortKeyComputer maps to a SegmentSortKey, but it can also decide on\nits ordering.

\n

By default, it uses the natural ordering.

\n
§

type SortKey = (<HeadSegmentSortKeyComputer as SegmentSortKeyComputer>::SortKey, <TailSegmentSortKeyComputer as SegmentSortKeyComputer>::SortKey)

The final score being emitted.
§

type SegmentSortKey = (<HeadSegmentSortKeyComputer as SegmentSortKeyComputer>::SegmentSortKey, <TailSegmentSortKeyComputer as SegmentSortKeyComputer>::SegmentSortKey)

Sort key used by at the segment level by the SegmentSortKeyComputer. Read more
§

type SegmentComparator = (<HeadSegmentSortKeyComputer as SegmentSortKeyComputer>::SegmentComparator, <TailSegmentSortKeyComputer as SegmentSortKeyComputer>::SegmentComparator)

Comparator type.
§

fn compute_sort_key_and_collect<C>(\n &mut self,\n doc: u32,\n score: f32,\n top_n_computer: &mut TopNComputer<<(HeadSegmentSortKeyComputer, TailSegmentSortKeyComputer) as SegmentSortKeyComputer>::SegmentSortKey, u32, C>,\n)
where\n C: Comparator<<(HeadSegmentSortKeyComputer, TailSegmentSortKeyComputer) as SegmentSortKeyComputer>::SegmentSortKey>,

Computes the sort key and pushes the document in a TopN Computer. Read more
§

fn segment_sort_key(\n &mut self,\n doc: u32,\n score: f32,\n) -> <(HeadSegmentSortKeyComputer, TailSegmentSortKeyComputer) as SegmentSortKeyComputer>::SegmentSortKey

Computes the sort key for the given document and score.
§

fn accept_sort_key_lazy(\n &mut self,\n doc_id: u32,\n score: f32,\n threshold: &<(HeadSegmentSortKeyComputer, TailSegmentSortKeyComputer) as SegmentSortKeyComputer>::SegmentSortKey,\n) -> Option<(Ordering, <(HeadSegmentSortKeyComputer, TailSegmentSortKeyComputer) as SegmentSortKeyComputer>::SegmentSortKey)>

Implementing this method makes it possible to avoid computing\na sort_key entirely if we can assess that it won’t pass a threshold\nwith a partial computation. Read more
§

fn convert_segment_sort_key(\n &self,\n sort_key: <(HeadSegmentSortKeyComputer, TailSegmentSortKeyComputer) as SegmentSortKeyComputer>::SegmentSortKey,\n) -> <(HeadSegmentSortKeyComputer, TailSegmentSortKeyComputer) as SegmentSortKeyComputer>::SortKey

Convert a segment level sort key into the global sort key.
§

fn segment_comparator(&self) -> Self::SegmentComparator

Returns the segment sort key comparator.
","SegmentSortKeyComputer","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<HeadSortKeyComputer, TailSortKeyComputer> SortKeyComputer for (HeadSortKeyComputer, TailSortKeyComputer)
where\n HeadSortKeyComputer: SortKeyComputer,\n TailSortKeyComputer: SortKeyComputer,

§

fn check_schema(&self, schema: &Schema) -> Result<(), TantivyError>

Checks whether the schema is compatible with the sort key computer.

\n
§

fn requires_scoring(&self) -> bool

Indicates whether the sort key actually uses the similarity score (by default BM25).\nIf set to false, the similary score might not be computed (as an optimization),\nand the score fed in the segment sort key computer could take any value.

\n
§

type SortKey = (<HeadSortKeyComputer as SortKeyComputer>::SortKey, <TailSortKeyComputer as SortKeyComputer>::SortKey)

The sort key type.
§

type Child = (<HeadSortKeyComputer as SortKeyComputer>::Child, <TailSortKeyComputer as SortKeyComputer>::Child)

Type of the associated [SegmentSortKeyComputer].
§

type Comparator = (<HeadSortKeyComputer as SortKeyComputer>::Comparator, <TailSortKeyComputer as SortKeyComputer>::Comparator)

Comparator type.
§

fn comparator(\n &self,\n) -> <(HeadSortKeyComputer, TailSortKeyComputer) as SortKeyComputer>::Comparator

Returns the sort key comparator.
§

fn segment_sort_key_computer(\n &self,\n segment_reader: &SegmentReader,\n) -> Result<<(HeadSortKeyComputer, TailSortKeyComputer) as SortKeyComputer>::Child, TantivyError>

Builds a child sort key computer for a specific segment.
§

fn collect_segment_top_k(\n &self,\n k: usize,\n weight: &(dyn Weight + 'static),\n reader: &SegmentReader,\n segment_ord: u32,\n) -> Result<Vec<(Self::SortKey, DocAddress)>, TantivyError>

Sorting by score has a overriding implementation for BM25 scores, using Block-WAND.
","SortKeyComputer","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<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,

Available on crate feature alloc only.
§

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":[487248,346901,323570,224776,145293,482480,541341,391525,146685,501153]}