tower-sesh 0.1.0-alpha.3

A Tower middleware for strongly typed, efficient sessions.
Documentation 
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
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110

// The code in this module is derived from the `tokio` crate by Tokio Contributors.
//
// Licensed under the MIT license.

#![allow(clippy::diverging_sub_expression)]

use std::{cell::Cell, rc::Rc};

// Send: Yes, Sync: Yes
#[derive(Clone)]
#[allow(unused)]
struct YY {}

// Send: Yes, Sync: No
#[derive(Clone)]
#[allow(unused)]
struct YN {
    _value: Cell<u8>,
}

// Send: No, Sync: No
#[derive(Clone)]
#[allow(unused)]
struct NN {
    _value: Rc<u8>,
}

#[allow(dead_code)]
fn require_send<T: Send>(_t: &T) {}
#[allow(dead_code)]
fn require_sync<T: Sync>(_t: &T) {}
#[allow(dead_code)]
fn require_unpin<T: Unpin>(_t: &T) {}

#[allow(dead_code)]
struct Invalid;

#[allow(unused)]
trait AmbiguousIfSend<A> {
    fn some_item(&self) {}
}
impl<T: ?Sized> AmbiguousIfSend<()> for T {}
impl<T: ?Sized + Send> AmbiguousIfSend<Invalid> for T {}

#[allow(unused)]
trait AmbiguousIfSync<A> {
    fn some_item(&self) {}
}
impl<T: ?Sized> AmbiguousIfSync<()> for T {}
impl<T: ?Sized + Sync> AmbiguousIfSync<Invalid> for T {}

#[allow(unused)]
trait AmbiguousIfUnpin<A> {
    fn some_item(&self) {}
}
impl<T: ?Sized> AmbiguousIfUnpin<()> for T {}
impl<T: ?Sized + Unpin> AmbiguousIfUnpin<Invalid> for T {}

macro_rules! async_assert_fn_send {
    (Send & $(!)?Sync & $(!)?Unpin, $value:expr) => {
        require_send(&$value);
    };
    (!Send & $(!)?Sync & $(!)?Unpin, $value:expr) => {
        AmbiguousIfSend::some_item(&$value);
    };
}
macro_rules! async_assert_fn_sync {
    ($(!)?Send & Sync & $(!)?Unpin, $value:expr) => {
        require_sync(&$value);
    };
    ($(!)?Send & !Sync & $(!)?Unpin, $value:expr) => {
        AmbiguousIfSync::some_item(&$value);
    };
}
macro_rules! async_assert_fn_unpin {
    ($(!)?Send & $(!)?Sync & Unpin, $value:expr) => {
        require_unpin(&$value);
    };
    ($(!)?Send & $(!)?Sync & !Unpin, $value:expr) => {
        AmbiguousIfUnpin::some_item(&$value);
    };
}

macro_rules! assert_value {
    ($type:ty: $($tok:tt)*) => {
        #[allow(unreachable_code)]
        #[allow(unused_variables)]
        const _: fn() = || {
            let f: $type = todo!();
            async_assert_fn_send!($($tok)*, f);
            async_assert_fn_sync!($($tok)*, f);
            async_assert_fn_unpin!($($tok)*, f);
        };
    };
}

assert_value!(tower_sesh::Session<YY>: Send & Sync & Unpin);
assert_value!(tower_sesh::Session<YN>: Send & Sync & Unpin);
assert_value!(tower_sesh::Session<NN>: !Send & !Sync & Unpin);
assert_value!(tower_sesh::SessionLayer<YY, tower_sesh::store::MemoryStore<YY>>: Send & Sync & Unpin);
assert_value!(tower_sesh::Value: Send & Sync & Unpin);
assert_value!(tower_sesh::middleware::SessionManager<(), YY, tower_sesh::store::MemoryStore<YY>, tower_sesh::config::PrivateCookie>: Send & Sync & Unpin);
assert_value!(tower_sesh::session::SessionGuard<YY>: !Send & Sync & Unpin);
assert_value!(tower_sesh::session::SessionGuard<YN>: !Send & !Sync & Unpin);
assert_value!(tower_sesh::session::SessionGuard<NN>: !Send & !Sync & Unpin);
#[cfg(feature = "axum")]
assert_value!(tower_sesh::session::SessionRejection: Send & Sync & Unpin);
assert_value!(tower_sesh::store::CachingStore<YY, tower_sesh::store::MemoryStore<YY>, tower_sesh::store::MemoryStore<YY>>: Send & Sync & Unpin);
assert_value!(tower_sesh::value::Map<String, tower_sesh::Value>: Send & Sync & Unpin);
assert_value!(tower_sesh::value::Number: Send & Sync & Unpin);