ctx 0.2.0

Context defines a type, which carries deadlines, cancelation, and other request-scoped values across API boundaries and between processes.
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

use std::any::Any;
use std::time::Instant;
use {Context, InnerContext, ContextError};
use futures::{Future, Poll, Async};

pub struct WithValue<V>
    where V: Any
{
    parent: Context,
    val: V,
}

impl<V> InnerContext for WithValue<V>
    where V: Any
{
    fn deadline(&self) -> Option<Instant> {
        None
    }

    fn value(&self) -> Option<&Any> {
        let val_any = &self.val as &Any;
        Some(val_any)
    }

    fn parent(&self) -> Option<Context> {
        Some(self.parent.clone())
    }
}

impl<V> Future for WithValue<V>
    where V: Any
{
    type Item = ();
    type Error = ContextError;

    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
        Ok(Async::NotReady)
    }
}

/// Returns a copy of parent, but with the given value associated to it.
///
/// Context values should only be used for request-scoped data that transists
/// processes and API boundaries and not for passing optional parameters to
/// functions.
///
/// It is recommended to use structs as values instead of simple data types
/// like strings and ints to be very specific of what result to expect when
/// retrieving a value. Having values of the same data type among the ancestors
/// would always return the first hit.
///
/// # Examples
///
/// ```
/// use ctx::{Context, with_value, background};
///
/// let a = with_value(background(), 42);
/// let b = with_value(a, 1.0);
/// assert_eq!(b.value(), Some(42));
/// assert_eq!(b.value(), Some(1.0));
/// ```
pub fn with_value<V>(parent: Context, val: V) -> Context
    where V: Any
{
    Context::new(WithValue {
                     parent: parent,
                     val: val,
                 })
}

#[cfg(test)]
mod test {
    use with_value::with_value;
    use background;

    #[test]
    fn same_type_2test() {
        let a = with_value(background(), 42);
        let b = with_value(a, 1.0);
        assert_eq!(b.value(), Some(42));
        assert_eq!(b.value(), Some(1.0));
    }

    #[test]
    fn same_type_test() {
        let a = with_value(background(), 1);
        let b = with_value(a, 2);
        assert_eq!(b.value(), Some(2));
    }

    #[test]
    fn same_type_workaround_test() {
        #[derive(Debug, PartialEq, Clone)]
        struct A(i32);
        #[derive(Debug, PartialEq, Clone)]
        struct B(i32);
        let a = with_value(background(), A(1));
        let b = with_value(a, B(1));
        assert_eq!(b.value(), Some(A(1)));
    }

    #[test]
    fn clone_test() {
        let ctx = with_value(background(), 42);
        let clone = ctx.clone();

        assert_eq!(ctx.value(), Some(42));
        assert_eq!(clone.value(), Some(42));
    }
}