Files
anyhow
async_stream
async_stream_impl
async_trait
base64
bytes
cfg_if
either
fnv
futures_channel
futures_core
futures_sink
futures_task
futures_util
gapi_grpc
getrandom
h2
hashbrown
http
http_body
httparse
httpdate
hyper
indexmap
iovec
itertools
itoa
lazy_static
libc
log
memchr
mio
net2
once_cell
openssl_probe
percent_encoding
pin_project
pin_project_lite
pin_utils
ppv_lite86
proc_macro2
prost
prost_derive
prost_types
quote
rand
rand_chacha
rand_core
rand_pcg
ring
rustls
rustls_native_certs
sct
slab
socket2
spin
syn
tokio
future
io
loom
macros
net
park
runtime
stream
sync
task
time
util
tokio_rustls
tokio_util
tonic
tower
tower_balance
tower_buffer
tower_discover
tower_layer
tower_limit
tower_load
tower_load_shed
tower_make
tower_ready_cache
tower_retry
tower_service
tower_timeout
tower_util
tracing
tracing_attributes
tracing_core
tracing_futures
try_lock
unicode_xid
untrusted
want
webpki
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
use std::fmt;
use tower_layer::Layer;

use crate::LoadShed;

/// A `tower-layer` to wrap services in `LoadShed` middleware.
#[derive(Clone)]
pub struct LoadShedLayer {
    _p: (),
}

impl LoadShedLayer {
    /// Creates a new layer.
    pub fn new() -> Self {
        LoadShedLayer { _p: () }
    }
}

impl<S> Layer<S> for LoadShedLayer {
    type Service = LoadShed<S>;

    fn layer(&self, service: S) -> Self::Service {
        LoadShed::new(service)
    }
}

impl fmt::Debug for LoadShedLayer {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        f.debug_struct("LoadShedLayer").finish()
    }
}