visit-rs 0.1.8

A generic visitor pattern library for Rust
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
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129

use std::marker::PhantomData;

use futures::Stream;

pub use visit_rs_derive::*;

#[cfg(feature = "serde")]
pub mod serde;

pub mod lib {
    pub use async_stream;
    pub use futures;
}

pub trait Visitor {
    type Result;
}

pub trait Visit<V: Visitor> {
    fn visit(&self, visitor: &mut V) -> V::Result;
}

pub trait VisitAsync<V: Visitor> {
    fn visit_async<'a>(&'a self, visitor: &'a mut V) -> impl Future<Output = V::Result> + Send + 'a
    where
        V: Send,
        V::Result: Send;
}

pub trait StructInfo {
    const NAME: &'static str;
    const NAMED_FIELDS: bool;
    const FIELD_COUNT: usize;
}

pub trait VisitFields<V: Visitor>: StructInfo {
    fn visit_fields<'a>(&'a self, visitor: &'a mut V) -> impl Iterator<Item = V::Result> + 'a;
}

pub trait VisitFieldsStatic<V: Visitor>: StructInfo {
    fn visit_fields_static<'a>(visitor: &'a mut V) -> impl Iterator<Item = V::Result> + 'a;
}

pub trait VisitFieldsAsync<V: Visitor>: StructInfo {
    fn visit_fields_async<'a>(
        &'a self,
        visitor: &'a mut V,
    ) -> impl Stream<Item = V::Result> + Send + 'a
    where
        V: Send,
        V::Result: Send;
}

pub trait VisitFieldsStaticAsync<V: Visitor>: StructInfo {
    fn visit_fields_static_async<'a>(visitor: &'a mut V) -> impl Stream<Item = V::Result> + 'a
    where
        V: Send,
        V::Result: Send;
}

pub trait VisitFieldsNamed<V: Visitor>: StructInfo {
    fn visit_fields_named<'a>(&'a self, visitor: &'a mut V)
        -> impl Iterator<Item = V::Result> + 'a;
}

pub trait VisitFieldsStaticNamed<V: Visitor>: StructInfo {
    fn visit_fields_static_named<'a>(visitor: &'a mut V) -> impl Iterator<Item = V::Result> + 'a;
}

pub trait VisitFieldsNamedAsync<V: Visitor>: StructInfo {
    fn visit_fields_named_async<'a>(
        &'a self,
        visitor: &'a mut V,
    ) -> impl Stream<Item = V::Result> + Send + 'a
    where
        V: Send,
        V::Result: Send;
}

pub trait VisitFieldsStaticNamedAsync<V: Visitor>: StructInfo {
    fn visit_fields_static_named_async<'a>(
        visitor: &'a mut V,
    ) -> impl Stream<Item = V::Result> + Send + 'a
    where
        V: Send,
        V::Result: Send;
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct Named<'a, T: ?Sized> {
    pub name: Option<&'static str>,
    pub value: &'a T,
}

pub struct Static<T: ?Sized> {
    _phantom: PhantomData<T>,
}
impl<T: ?Sized> std::fmt::Debug for Static<T> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct(std::any::type_name::<Self>()).finish()
    }
}
unsafe impl<T: ?Sized> Send for Static<T> {}
unsafe impl<T: ?Sized> Sync for Static<T> {}
impl<T: ?Sized> Default for Static<T> {
    fn default() -> Self {
        Static::new()
    }
}
impl<T: ?Sized> Clone for Static<T> {
    fn clone(&self) -> Self {
        Self::new()
    }
}
impl<T: ?Sized> Copy for Static<T> {}
impl<T: ?Sized + 'static, U: ?Sized + 'static> PartialEq<Static<U>> for Static<T> {
    fn eq(&self, _: &Static<U>) -> bool {
        std::any::TypeId::of::<T>() == std::any::TypeId::of::<U>()
    }
}
impl<T: ?Sized + 'static> Eq for Static<T> {}

impl<T: ?Sized> Static<T> {
    pub const fn new() -> Self {
        Static {
            _phantom: PhantomData,
        }
    }
}