Struct `MakeBalanceLayer`

struct MakeBalanceLayer<D, Req> { ... }

Construct load balancers (Balance) over dynamic service sets (Discover) produced by the "inner" service in response to requests coming from the "outer" service.

This construction may seem a little odd at first glance. This is not a layer that takes requests and produces responses in the traditional sense. Instead, it is more like MakeService in that it takes service descriptors (see Target on MakeService) and produces services. Since Balance spreads requests across a set of services, the inner service should produce a Discover, not just a single Service, given a service descriptor.

See the module-level documentation for details on load balancing.

Implementations

`impl<D, Req> MakeBalanceLayer<D, Req>`

const fn new() -> Self: Build balancers using operating system entropy.

`impl<D, Req> Clone for MakeBalanceLayer<D, Req>`

fn clone(self: &Self) -> Self

`impl<D, Req> Debug for MakeBalanceLayer<D, Req>`

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

`impl<D, Req> Default for MakeBalanceLayer<D, Req>`

fn default() -> Self

`impl<D, Req> Freeze for MakeBalanceLayer<D, Req>`

`impl<D, Req> RefUnwindSafe for MakeBalanceLayer<D, Req>`

`impl<D, Req> Send for MakeBalanceLayer<D, Req>`

`impl<D, Req> Sync for MakeBalanceLayer<D, Req>`

`impl<D, Req> Unpin for MakeBalanceLayer<D, Req>`

`impl<D, Req> UnsafeUnpin for MakeBalanceLayer<D, Req>`

`impl<D, Req> UnwindSafe for MakeBalanceLayer<D, Req>`

`impl<S, Req> Layer for MakeBalanceLayer<S, Req>`

fn layer(self: &Self, make_discover: S) -> <Self as >::Service

`impl<T> Any for MakeBalanceLayer<D, Req>`

fn type_id(self: &Self) -> TypeId

`impl<T> Borrow for MakeBalanceLayer<D, Req>`

fn borrow(self: &Self) -> &T

`impl<T> BorrowMut for MakeBalanceLayer<D, Req>`

fn borrow_mut(self: &mut Self) -> &mut T

`impl<T> CloneToUninit for MakeBalanceLayer<D, Req>`

unsafe fn clone_to_uninit(self: &Self, dest: *mut u8)

`impl<T> From for MakeBalanceLayer<D, Req>`

fn from(t: T) -> T: Returns the argument unchanged.

`impl<T> Instrument for MakeBalanceLayer<D, Req>`

`impl<T> ToOwned for MakeBalanceLayer<D, Req>`

fn to_owned(self: &Self) -> T
fn clone_into(self: &Self, target: &mut T)

`impl<T> WithSubscriber for MakeBalanceLayer<D, Req>`

`impl<T, U> Into for MakeBalanceLayer<D, Req>`

fn into(self: Self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of [From]<T> for U chooses to do.

`impl<T, U> TryFrom for MakeBalanceLayer<D, Req>`

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

`impl<T, U> TryInto for MakeBalanceLayer<D, Req>`

fn try_into(self: Self) -> Result<U, <U as TryFrom<T>>::Error>