seedle-macros 1.8.2

cbor codegeneration
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

use super::node::{Fields, LinkedNode, Literal};
use std::borrow::Cow;
use std::collections::BTreeMap;
use std::hash::Hash;

#[allow(unused)]
pub struct Context(BTreeMap<String, LinkedNode>);

#[allow(unused)]
pub type GroupedBorrowed<'a, T> = BTreeMap<String, Vec<(String, &'a T)>>;
#[allow(unused)]
pub type GroupedCow<'a, T> = BTreeMap<String, Vec<(String, Cow<'a, T>)>>;
#[allow(unused)]
pub type Grouped<T> = BTreeMap<String, Vec<(String, T)>>;

#[allow(unused)]
pub fn structs_owned<K: Hash>(kv: (K, LinkedNode)) -> Option<(K, Fields)> {
    filter_structs((kv.0, Cow::Owned(kv.1))).map(|(k, v)| (k, v.into_owned()))
}

pub fn structs_borrowed<'a, K: Hash>(kv: (K, &'a LinkedNode)) -> Option<(K, Cow<'a, Fields>)> {
    filter_structs((kv.0, Cow::Borrowed(kv.1)))
}

#[allow(unused)]
pub fn literals_owned<K: Hash>(kv: (K, LinkedNode)) -> Option<(K, Literal)> {
    filter_literals((kv.0, Cow::Owned(kv.1))).map(|(k, v)| (k, v.into_owned()))
}

pub fn literals_borrowed<'a, K: Hash>(kv: (K, &'a LinkedNode)) -> Option<(K, Cow<'a, Literal>)> {
    filter_literals((kv.0, Cow::Borrowed(kv.1)))
}

#[allow(unused)]
pub fn fold_group_owned<'a, K, T>(
    split: &'a str,
) -> impl Fn(GroupedCow<'a, T>, (K, T)) -> GroupedCow<'a, T>
where
    K: Into<Cow<'a, str>>,
    T: Clone + 'a,
{
    move |state, kv| {
        let folder = fold_group(split);
        folder(state, (kv.0, Cow::Owned(kv.1)))
    }
}

#[allow(unused)]
pub fn fold_group_borrowed<'a, T>(
    split: &'a str,
) -> impl Fn(GroupedCow<'a, T>, (&'a String, Cow<'a, T>)) -> GroupedCow<'a, T>
where
    T: Clone + 'a,
{
    move |state, kv| {
        let folder = fold_group(split);
        folder(state, (kv.0, kv.1))
    }
}

#[inline]
fn fold_group<'a, K, T>(
    split: &'a str,
) -> impl Fn(GroupedCow<'a, T>, (K, Cow<'a, T>)) -> GroupedCow<'a, T>
where
    K: Into<Cow<'a, str>>,
    T: Clone,
{
    move |mut state, kv| {
        let key = kv.0.into();
        if let Some((group, rest)) = key.split_once(split) {
            insert(&mut state, group, rest, kv.1);
        } else {
            insert(&mut state, "_", &key, kv.1);
        }
        state
    }
}

#[inline]
#[allow(unused)]
fn insert<'a, T: Clone>(obj: &mut GroupedCow<'a, T>, group: &str, key: &str, node: Cow<'a, T>) {
    if let Some(inner) = obj.get_mut(group) {
        inner.push((key.to_string(), node));
    } else {
        let mut inner = Vec::new();
        inner.push((key.to_string(), node));
        obj.insert(group.to_string(), inner);
    }
}

#[inline]
fn filter_structs<'a, K, V>((key, cow): (K, V)) -> Option<(K, Cow<'a, Fields>)>
where
    K: Hash,
    V: Into<Cow<'a, LinkedNode>>,
{
    let val = cow.into();
    match val {
        Cow::Borrowed(LinkedNode::Struct(s)) => Some((key, Cow::Borrowed(s))),
        Cow::Owned(LinkedNode::Struct(s)) => Some((key, Cow::Owned(s))),
        _ => None,
    }
}

#[inline]
fn filter_literals<'a, K, V>((key, cow): (K, V)) -> Option<(K, Cow<'a, Literal>)>
where
    K: Hash,
    V: Into<Cow<'a, LinkedNode>>,
{
    let val = cow.into();
    match val {
        Cow::Borrowed(LinkedNode::Literal(l)) => Some((key, Cow::Borrowed(l))),
        Cow::Owned(LinkedNode::Literal(l)) => Some((key, Cow::Owned(l))),
        _ => None,
    }
}