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
//! [Kotlin](https://kotlinlang.org) language exporter for [Specta](specta).
//!
//! <div class="warning">
//! This crate is still in active development and is not yet ready for general purpose use!
//! </div>
//!
// use specta::{
// datatype::{DataType, Primitive},
// Type, Types,
// };
// /// TODO
// pub fn export<T: Type>() -> Result<String, String> {
// datatype(&T::definition(
// &mut Types::default(),
// Generics::Definition,
// ))
// }
// fn datatype(t: &DataType) -> Result<String, String> {
// Ok(match t {
// DataType::Primitive(p) => match p {
// Primitive::str => "String",
// Primitive::char => "Char",
// Primitive::i8 => "Byte",
// Primitive::i16 => "Short",
// Primitive::isize | Primitive::i32 => "Int",
// Primitive::i64 => "Long",
// Primitive::u8 => "UByte",
// Primitive::u16 => "UShort",
// Primitive::usize | Primitive::u32 => "UInt",
// Primitive::u64 => "ULong",
// Primitive::bool => "Boolean",
// Primitive::f32 => "Float",
// Primitive::f64 => "Double",
// Primitive::i128 | Primitive::u128 => {
// return Err("Swift does not support 128 numbers!".to_owned())
// }
// }
// .to_string(),
// DataType::List(t) => format!("List<{}>", datatype(t.ty())?),
// DataType::Tuple(_) => return Err("Kotlin does not support tuple types".to_owned()),
// DataType::Map(t) => format!(
// "HashMap<{}, {}>",
// datatype(&t.key_ty())?,
// datatype(&t.value_ty())?
// ),
// DataType::Generic(t) => t.to_string(),
// DataType::Reference(reference) => {
// // let name = reference.name();
// let generics = reference.generics();
// // match &generics[..] {
// // [] => name.to_string(),
// // generics => {
// // let generics = generics
// // .iter()
// // .map(|(_, t)| datatype(t))
// // .collect::<Result<Vec<_>, _>>()?
// // .join(", ");
// // format!("{name}<{generics}>")
// // }
// // }
// todo!();
// }
// DataType::Nullable(t) => format!("{}?", datatype(&t)?),
// DataType::Struct(s) => {
// let name = s.name();
// let generics = s.generics();
// let fields = s.fields();
// let tag = s.tag();
// // let decl = match &fields[..] {
// // [] => "class {name}".to_string(),
// // fields => {
// // let generics = (!generics.is_empty())
// // .then(|| format!("<{}>", generics.join(", ")))
// // .unwrap_or_default();
// // let fields = fields
// // .iter()
// // .map(|f| {
// // let name = &f.name;
// // let typ = datatype(&f.ty)?;
// // let optional = matches!(f.ty, DataType::Nullable(_))
// // .then(|| "= null")
// // .unwrap_or_default();
// // Ok(format!("\tvar {name}: {typ}{optional}"))
// // })
// // .collect::<Result<Vec<_>, String>>()?
// // .join(", ");
// // let tag = tag
// // .clone()
// // .map(|t| format!("var {t}: String"))
// // .unwrap_or_default();
// // format!("data class {name}{generics} ({fields}{tag})")
// // }
// // };
// // format!("@Serializable\n{decl}\n")
// todo!();
// }
// DataType::Literal(_) => return Err("Kotlin does not support literal types!".to_owned()),
// _ => todo!(),
// })
// }