xidl-parser 0.44.0

A IDL codegen.
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::{Annotation, AnnotationParams};
use serde::{Deserialize, Serialize};

#[derive(Debug, Serialize, Deserialize, Clone, Copy)]
pub enum SerializeKind {
    Cdr,
    PlainCdr,
    PlCdr,
    PlainCdr2,
    DelimitedCdr,
    PlCdr2,
}

#[derive(Debug, Serialize, Deserialize, Clone, Copy)]
pub enum SerializeVersion {
    Xcdr1,
    Xcdr2,
}

#[derive(Debug, Default, Serialize, Deserialize, Clone, Copy)]
pub struct SerializeConfig {
    pub explicit_kind: Option<SerializeKind>,
    pub version: Option<SerializeVersion>,
}

#[derive(Debug, Serialize, Deserialize, Clone, Copy)]
pub enum Extensibility {
    Final,
    Appendable,
    Mutable,
    None,
}

impl SerializeConfig {
    pub fn apply_pragma(&mut self, pragma: super::Pragma) {
        match pragma {
            super::Pragma::XidlcSerialize(kind) => self.explicit_kind = Some(kind),
            super::Pragma::XidlcVersion(version) => {
                self.version = Some(version);
                self.explicit_kind = None;
            }
            super::Pragma::XidlcPackage(_)
            | super::Pragma::XidlcOpenApiVersion(_)
            | super::Pragma::XidlcOpenApiService { .. } => {}
        }
    }

    pub fn resolve(&self, extensibility: Extensibility) -> SerializeKind {
        if let Some(kind) = self.explicit_kind {
            return kind;
        }

        match self.version {
            None => SerializeKind::Cdr,
            Some(SerializeVersion::Xcdr1) => match extensibility {
                Extensibility::Mutable => SerializeKind::PlCdr,
                Extensibility::Final | Extensibility::Appendable => SerializeKind::Cdr,
                Extensibility::None => SerializeKind::PlainCdr,
            },
            Some(SerializeVersion::Xcdr2) => match extensibility {
                Extensibility::Final => SerializeKind::PlainCdr2,
                Extensibility::Appendable => SerializeKind::DelimitedCdr,
                Extensibility::Mutable => SerializeKind::PlCdr2,
                Extensibility::None => SerializeKind::Cdr,
            },
        }
    }

    pub fn resolve_for_annotations(&self, annotations: &[Annotation]) -> SerializeKind {
        self.resolve(extensibility_from_annotations(annotations))
    }
}

pub fn extensibility_from_annotations(annotations: &[Annotation]) -> Extensibility {
    let mut final_flag = false;
    let mut appendable = false;
    let mut mutable = false;

    for annotation in annotations {
        if let Annotation::Builtin { name, .. } = annotation {
            if name.eq_ignore_ascii_case("final") {
                final_flag = true;
            } else if name.eq_ignore_ascii_case("appendable") {
                appendable = true;
            } else if name.eq_ignore_ascii_case("mutable") {
                mutable = true;
            }
        }

        if let Annotation::Builtin { name, params } = annotation {
            if name.eq_ignore_ascii_case("extensibility") {
                if let Some(AnnotationParams::Raw(raw)) = params {
                    let value = raw.trim().trim_matches('"');
                    if value.eq_ignore_ascii_case("final") {
                        final_flag = true;
                    } else if value.eq_ignore_ascii_case("appendable") {
                        appendable = true;
                    } else if value.eq_ignore_ascii_case("mutable") {
                        mutable = true;
                    }
                }
            }
        }
    }

    if mutable {
        Extensibility::Mutable
    } else if appendable {
        Extensibility::Appendable
    } else if final_flag {
        Extensibility::Final
    } else {
        Extensibility::None
    }
}

#[cfg(test)]
mod tests;