reproto-backend-java 0.3.36

Rethinking Protocol Generators 
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

//! Serialization strategy used for services.

use core::errors::Result;
use genco::java::{self, Field};
use genco::{Java, Tokens};
use std::fmt;

#[derive(Clone, Copy, Debug)]
pub enum Serialization {
    Jackson,
}

impl Serialization {
    /// Get the field containing the serialization.
    pub fn field(&self) -> Field<'static> {
        use self::Serialization::*;

        match *self {
            Jackson => {
                let ty = java::imported("com.fasterxml.jackson.databind", "ObjectMapper");
                Field::new(ty, "mapper")
            }
        }
    }

    /// Setup the default builder for the serialization strategy.
    pub fn default_builder<'el>(&self) -> Option<Tokens<'el, Java<'el>>> {
        use self::Serialization::*;

        match *self {
            Jackson => {
                let ty = java::imported("io.reproto", "JacksonSupport");
                Some(toks![ty, ".objectMapper()"])
            }
        }
    }

    /// Decode argument for the given type.
    pub fn decode<'el, E>(
        &self,
        m: &Field<'el>,
        ty: &'el Java<'static>,
        i: &'el str,
        o: &'el str,
        exc: E,
    ) -> Result<Tokens<'el, Java<'el>>>
    where
        E: FnOnce(&'el str) -> Result<Tokens<'el, Java<'el>>>,
    {
        use self::Serialization::*;

        match *self {
            Jackson => {
                let arg = if !ty.is_generic() {
                    toks![ty, ".class"]
                } else {
                    let ty = java::imported("com.fasterxml.jackson.core.type", "TypeReference")
                        .with_arguments(vec![ty.clone()]);

                    toks!["new ", ty, "() {}"]
                };

                let mut t = Tokens::new();

                push!(t, "final ", ty, " ", o, ";");

                t.push({
                    let mut t = Tokens::new();

                    push!(t, "try {");
                    nested!(t, o, " = ", m.var(), ".readValue(", i, ", ", arg, ");");
                    push!(t, "} catch(final Exception e) {");
                    t.nested(exc("e")?);
                    push!(t, "}");

                    t
                });

                Ok(t.join_line_spacing())
            }
        }
    }
}

impl fmt::Display for Serialization {
    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
        use self::Serialization::*;

        match *self {
            Jackson => "jackson".fmt(fmt),
        }
    }
}