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
130
131
132
133
134
135
136
137
138
139
140
141
142

use std::any::{Any, type_name};
use std::fmt::{Debug, Display, Formatter};
use bytes::Bytes;
use serde::{Deserialize, Serialize};
use crate::api::ToStruct;
use crate::request::ResponseStatus;
use dce_util::mixed::{DceErr, DceResult};
use dce_util::mem::self_transmute;

#[derive(Debug)]
pub enum Serializable<Dto> {
    Dto(Dto),
    Status(ResponseStatus<Dto>),
}


#[derive(Debug)]
pub enum Serialized {
    String(String),
    Bytes(Bytes),
}

impl Serialized {
    pub fn unwrap<T: 'static>(self) -> T {
        match self {
            Serialized::String(v) => self_transmute::<String, T>(v),
            Serialized::Bytes(v) => self_transmute::<Bytes, T>(v),
        }
    }
}

impl Display for Serialized {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        f.write_str(&match self {
            Serialized::String(str) => str.to_string(),
            Serialized::Bytes(bytes) => String::from_utf8_lossy(bytes).to_string(),
        })
    }
}



pub trait Deserializer<Dto> {
    fn deserialize<'a>(&self, value: Serialized) -> DceResult<Dto>;
}

pub trait Serializer<Dto> {
    fn serialize(&self, value: Serializable<Dto>) -> DceResult<Serialized>;
}



// 无用序列器，用于不解析或不序列化的请求数据，默认序列器
/// unreachable serializer, just for no parse or no serialize request data, default serializer
pub struct UnreachableSerializer;

impl<Dto> Deserializer<Dto> for UnreachableSerializer {
    fn deserialize<'a>(&self, _: Serialized) -> DceResult<Dto> {
        panic!("missing serializer in api configuration, or try not using a serializable Request")
    }
}

impl<Dto> Serializer<Dto> for UnreachableSerializer {
    fn serialize(&self, _: Serializable<Dto>) -> DceResult<Serialized> {
        panic!("missing serializer in api configuration, or do not try respond in a not responsible Request")
    }
}

impl ToStruct for UnreachableSerializer {
    fn from<const N: usize>(_: [(&str, Box<dyn Any>); N]) -> Self {
        UnreachableSerializer
    }
}



pub struct StringSerializer;

impl<Dto: From<Serialized>> Deserializer<Dto> for StringSerializer {
    fn deserialize<'a>(&self, value: Serialized) -> DceResult<Dto> {
        Ok(Dto::from(value))
    }
}

impl<Dto: Into<Serialized> + 'static> Serializer<Dto> for StringSerializer {
    fn serialize(&self, value: Serializable<Dto>) -> DceResult<Serialized> {
        Ok(match value {
            Serializable::Dto(v) => v.into(),
            Serializable::Status(s) => Serialized::String((if s.status { "succeeded" } else { "failed" }).to_string())
        })
    }
}

impl ToStruct for StringSerializer {
    fn from<const N: usize>(_: [(&str, Box<dyn Any>); N]) -> Self {
        StringSerializer
    }
}



pub struct JsonSerializer {

}

impl<Dto: for<'a> Deserialize<'a>> Deserializer<Dto> for JsonSerializer {
    fn deserialize<'a>(&self, value: Serialized) -> DceResult<Dto> {
        Ok((match value {
            Serialized::String(v) => serde_json::from_str(v.as_str()),
            Serialized::Bytes(v) => serde_json::from_slice(v.as_ref()),
        }).or(Err(DceErr::closed(0, "Serialized cannot deserialize to ReqDto".to_owned())))?)
    }
}

impl<Dto: Serialize + 'static> Serializer<Dto> for JsonSerializer {
    fn serialize(&self, value: Serializable<Dto>) -> DceResult<Serialized> {
        Ok(Serialized::String(match value {
            Serializable::Dto(v) => serde_json::to_string::<Dto>(&v),
            Serializable::Status(v) => serde_json::to_string::<ResponseStatus<Dto>>(&v),
        }.or(Err(DceErr::closed(0, "RespDto not a jsonable".to_owned())))?))
    }
}

impl ToStruct for JsonSerializer {
    fn from<const N: usize>(_: [(&str, Box<dyn Any>); N]) -> Self {
        JsonSerializer {}
    }
}


impl<Dto> Debug for dyn Deserializer<Dto> + Send + Sync {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        f.write_str(format!("Deserializer: {}{{}}", type_name::<Self>()).as_str())
    }
}

impl<Dto> Debug for dyn Serializer<Dto> + Send + Sync {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        f.write_str(format!("Serializer: {}{{}}", type_name::<Self>()).as_str())
    }
}