interact 0.3.6

A framework for online program state introspection
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

/// Cover private Mutex derive
///
/// This module checks that we can manually derive `Access` and `Deser` for types for which we
/// cannot use #[derive(Interact)]
///
use interact::access::{Access, ReflectDirect};
use interact::climber::{ClimbError, Climber};
use interact::deser::{self, Tracker};
use interact::{Deser, NodeTree, Reflector};

use std::ops::Deref;
use std::ops::DerefMut;
use std::sync::Arc;

pub struct PseudoMutex<T> {
    _t: T,
}

impl<T> PseudoMutex<T> {
    pub fn new(_t: T) -> Self {
        PseudoMutex { _t }
    }
}

struct Guard<'a, T>(&'a T);

impl<T> PseudoMutex<T> {
    fn lock(&self) -> Guard<T> {
        Guard(&self._t)
    }
}

impl<'a, T> Deref for Guard<'a, T> {
    type Target = T;

    fn deref(&self) -> &T {
        self.0
    }
}

impl<'a, T> DerefMut for Guard<'a, T> {
    fn deref_mut(&mut self) -> &mut T {
        panic!("cannot get mutable refs for PseudoMutex");
    }
}

impl<T> ReflectDirect for PseudoMutex<T>
where
    T: Access,
{
    fn immut_reflector(&self, reflector: &Arc<Reflector>) -> NodeTree {
        let locked = self.lock();
        Reflector::reflect(reflector, &*locked)
    }

    fn immut_climber<'a>(&self, climber: &mut Climber<'a>) -> Result<Option<NodeTree>, ClimbError> {
        let save = climber.clone();
        let retval = {
            let locked = self.lock();
            climber.general_access_immut(&*locked).map(Some)
        };

        if let Err(ClimbError::NeedMutPath) = &retval {
            *climber = save;
            let mut locked = self.lock();
            climber.general_access_mut(&mut *locked).map(Some)
        } else {
            retval
        }
    }

    fn mut_climber<'a>(
        &mut self,
        climber: &mut Climber<'a>,
    ) -> Result<Option<NodeTree>, ClimbError> {
        let mut locked = self.lock();
        climber.general_access_mut(&mut *locked).map(Some)
    }
}

impl<T> Deser for PseudoMutex<T>
where
    T: Deser,
{
    fn deser<'a, 'b>(tracker: &mut Tracker<'a, 'b>) -> deser::Result<Self> {
        Ok(PseudoMutex::new(T::deser(tracker)?))
    }
}

use interact::derive_interact_extern_opqaue;
derive_interact_extern_opqaue! {
    struct PseudoMutex<T>;
}