treaty -


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

pub mod recoverable {
    use crate::{error::UniError, protocol::Protocol, Visitor};

    pub trait Accessor<'value, 'ctx: 'value, WalkerErr, VisitorErr> {
        /// Each time this is called the walker resets.
        fn walk_new(
            &mut self,
            visitor: &mut dyn Visitor<'value, 'ctx, WalkerErr, Error = VisitorErr>,
        ) -> Result<(), UniError<WalkerErr, VisitorErr>>;
    }

    pub enum Recoverable {}

    impl<'value, 'ctx: 'value> Protocol<'value, 'ctx> for Recoverable {
        type Hint = ();

        type Known = ();

        type Accessor<'walking, WalkerErr: 'value, VisitorErr: 'value> = &'walking dyn Accessor<'value, 'ctx, WalkerErr, VisitorErr>
        where
            'value: 'walking;
    }
}

pub mod reference {
    use core::{any::Any, marker::PhantomData};

    use crate::protocol::Protocol;

    pub enum Kind {
        Walking,
        Value,
        Context,
        Static,
    }

    pub struct Hint {
        pub kind: Option<Kind>,

        pub min_len: Option<usize>,
        pub max_len: Option<usize>,
    }

    pub struct Known {
        pub kind: Option<Kind>,

        /// For dynamically sized types.
        pub len: Option<usize>,
    }

    pub enum Ref<'walking, 'value: 'walking, 'ctx: 'value, T: ?Sized + 'static> {
        Walking(&'walking T),
        Value(&'value T),
        Context(&'ctx T),
        Static(&'static T),
    }

    pub enum Mut<'walking, 'value: 'walking, 'ctx: 'value, T: ?Sized + 'static> {
        Walking(&'walking mut T),
        Value(&'value mut T),
        Context(&'ctx mut T),
        Static(&'static mut T),
    }

    pub struct Reference<T: ?Sized + Any>(PhantomData<fn() -> T>);

    pub struct ReferenceMut<T: ?Sized + Any>(PhantomData<fn() -> T>);

    impl<'value, 'ctx: 'value, T: ?Sized + Any> Protocol<'value, 'ctx> for Reference<T> {
        type Hint = Hint;

        type Known = Known;

        type Accessor<'walking, WalkerErr: 'value, VisitorErr: 'value> = Ref<'walking, 'value, 'ctx, T>
        where
            'value: 'walking;
    }
}