v

1
// Copyright (c) 2019-2024 Alexander Medvednikov. All rights reserved.
2
// Use of this source code is governed by an MIT license
3
// that can be found in the LICENSE file.
4
module json2
5

6
import time
7

8
// i8 uses `Any` as a 16-bit integer.
9
pub fn (f Any) i8() i8 {
10
	match f {
11
		i8 {
12
			return f
13
		}
14
		i16, i32, int, i64, u8, u16, u32, u64, f32, f64, bool {
15
			return i8(f)
16
		}
17
		string {
18
			return f.i8()
19
		}
20
		else {
21
			return 0
22
		}
23
	}
24
}
25

26
// i16 uses `Any` as a 16-bit integer.
27
pub fn (f Any) i16() i16 {
28
	match f {
29
		i16 {
30
			return f
31
		}
32
		i8, i32, int, i64, u8, u16, u32, u64, f32, f64, bool {
33
			return i16(f)
34
		}
35
		string {
36
			return f.i16()
37
		}
38
		else {
39
			return 0
40
		}
41
	}
42
}
43

44
// int uses `Any` as an integer.
45
pub fn (f Any) int() int {
46
	match f {
47
		int {
48
			return f
49
		}
50
		i8, i16, i32, i64, u8, u16, u32, u64, f32, f64, bool {
51
			return int(f)
52
		}
53
		string {
54
			return f.int()
55
		}
56
		else {
57
			return 0
58
		}
59
	}
60
}
61

62
// i32 uses `Any` as a 32-bit integer.
63
pub fn (f Any) i32() i32 {
64
	match f {
65
		i32 {
66
			return f
67
		}
68
		i8, i16, int, i64, u8, u16, u32, u64, f32, f64, bool {
69
			return i32(f)
70
		}
71
		string {
72
			return f.i32()
73
		}
74
		else {
75
			return 0
76
		}
77
	}
78
}
79

80
// i64 uses `Any` as a 64-bit integer.
81
pub fn (f Any) i64() i64 {
82
	match f {
83
		i64 {
84
			return f
85
		}
86
		i8, i16, i32, int, u8, u16, u32, u64, f32, f64, bool {
87
			return i64(f)
88
		}
89
		string {
90
			return f.i64()
91
		}
92
		else {
93
			return 0
94
		}
95
	}
96
}
97

98
// u64 uses `Any` as a 64-bit unsigned integer.
99
pub fn (f Any) u64() u64 {
100
	match f {
101
		u64 {
102
			return f
103
		}
104
		u8, u16, u32, i8, i16, i32, int, i64, f32, f64, bool {
105
			return u64(f)
106
		}
107
		string {
108
			return f.u64()
109
		}
110
		else {
111
			return 0
112
		}
113
	}
114
}
115

116
// f32 uses `Any` as a 32-bit float.
117
pub fn (f Any) f32() f32 {
118
	match f {
119
		f32 {
120
			return f
121
		}
122
		bool, i8, i16, i32, int, i64, u8, u16, u32, u64, f64 {
123
			return f32(f)
124
		}
125
		string {
126
			return f.f32()
127
		}
128
		else {
129
			return 0.0
130
		}
131
	}
132
}
133

134
// f64 uses `Any` as a 64-bit float.
135
pub fn (f Any) f64() f64 {
136
	match f {
137
		f64 {
138
			return f
139
		}
140
		i8, i16, i32, int, i64, u8, u16, u32, u64, f32 {
141
			return f64(f)
142
		}
143
		string {
144
			return f.f64()
145
		}
146
		else {
147
			return 0.0
148
		}
149
	}
150
}
151

152
// bool uses `Any` as a bool.
153
pub fn (f Any) bool() bool {
154
	match f {
155
		bool {
156
			return f
157
		}
158
		string {
159
			if f == 'false' {
160
				return false
161
			}
162
			if f == 'true' {
163
				return true
164
			}
165
			if f.len > 0 {
166
				return f != '0' && f != '0.0'
167
			} else {
168
				return false
169
			}
170
		}
171
		i8, i16, i32, int, i64 {
172
			return i64(f) != 0
173
		}
174
		u8, u16, u32, u64 {
175
			return u64(f) != 0
176
		}
177
		f32, f64 {
178
			return f64(f) != 0.0
179
		}
180
		else {
181
			return false
182
		}
183
	}
184
}
185

186
// arr uses `Any` as an array.
187
pub fn (f Any) arr() []Any {
188
	if f is []Any {
189
		return f
190
	} else if f is map[string]Any {
191
		mut arr := []Any{}
192
		for _, v in f {
193
			arr << v
194
		}
195
		return arr
196
	}
197
	return [f]
198
}
199

200
// as_map uses `Any` as a map.
201
pub fn (f Any) as_map() map[string]Any {
202
	if f is map[string]Any {
203
		return f
204
	} else if f is []Any {
205
		mut mp := map[string]Any{}
206
		for i, fi in f {
207
			mp['${i}'] = fi
208
		}
209
		return mp
210
	}
211
	return {
212
		'0': f
213
	}
214
}
215

216
// to_time uses `Any` as a time.Time.
217
pub fn (f Any) to_time() !time.Time {
218
	match f {
219
		time.Time {
220
			return f
221
		}
222
		i64 {
223
			return time.unix(f)
224
		}
225
		string {
226
			is_iso8601 := f[4] == `-` && f[7] == `-`
227
			if is_iso8601 {
228
				return time.parse_iso8601(f)!
229
			}
230
			is_rfc3339 := f.len == 24 && f[23] == `Z` && f[10] == `T`
231
			if is_rfc3339 {
232
				return time.parse_rfc3339(f)!
233
			}
234
			mut is_unix_timestamp := true
235
			for c in f {
236
				if c == `-` || (c >= `0` && c <= `9`) {
237
					continue
238
				}
239
				is_unix_timestamp = false
240
				break
241
			}
242
			if is_unix_timestamp {
243
				return time.unix(f.i64())
244
			}
245
			// TODO: parse_iso8601
246
			// TODO: parse_rfc2822
247
			return time.parse(f)!
248
		}
249
		else {
250
			return error('not a time value: ${f} of type: ${f.type_name()}')
251
		}
252
	}
253
}
254

255
// map_from convert a struct to map of Any
256
pub fn map_from[T](t T) map[string]Any {
257
	mut m := map[string]Any{}
258
	$if T is $struct {
259
		$for field in T.fields {
260
			value := t.$(field.name)
261

262
			$if field.is_array {
263
				mut arr := []Any{}
264
				for variable in value {
265
					arr << Any(variable)
266
				}
267
				m[field.name] = arr
268
				arr.clear()
269
			} $else $if field.is_struct {
270
				m[field.name] = map_from(value)
271
			} $else $if field.is_map {
272
				// TODO
273
			} $else $if field.is_alias {
274
				// TODO
275
			} $else $if field.is_option {
276
				// TODO
277
			} $else {
278
				// TODO: improve memory usage when convert
279
				$if field.typ is string {
280
					m[field.name] = value.str()
281
				} $else $if field.typ is bool {
282
					m[field.name] = t.$(field.name).str().bool()
283
				} $else $if field.typ is i8 {
284
					m[field.name] = t.$(field.name).str().i8()
285
				} $else $if field.typ is i16 {
286
					m[field.name] = t.$(field.name).str().i16()
287
				} $else $if field.typ is i32 {
288
					m[field.name] = t.$(field.name).str().i32()
289
				} $else $if field.typ is int {
290
					m[field.name] = t.$(field.name).str().int()
291
				} $else $if field.typ is i64 {
292
					m[field.name] = t.$(field.name).str().i64()
293
				} $else $if field.typ is f32 {
294
					m[field.name] = t.$(field.name).str().f32()
295
				} $else $if field.typ is f64 {
296
					m[field.name] = t.$(field.name).str().f64()
297
				} $else $if field.typ is u8 {
298
					m[field.name] = t.$(field.name).str().u8()
299
				} $else $if field.typ is u16 {
300
					m[field.name] = t.$(field.name).str().u16()
301
				} $else $if field.typ is u32 {
302
					m[field.name] = t.$(field.name).str().u32()
303
				} $else $if field.typ is u64 {
304
					m[field.name] = t.$(field.name).str().u64()
305
				} $else {
306
					// return error("The type of `${field.name}` can't be decoded. Please open an issue at https://github.com/vlang/v/issues/new/choose")
307
				}
308
			}
309
		}
310
	}
311
	return m
312
}
313