Initial project import
This commit is contained in:
Agila Forge Importer committed
commit
23f2d29e32
11957 files changed
+1754577
No files matched your search
@@ -0,0 +1,415 @@
|
||||
// Copyright (c) 2019-2024 Alexander Medvednikov. All rights reserved.
|
||||
// Use of this source code is governed by an MIT license
|
||||
// that can be found in the LICENSE file.
|
||||
module json2
|
||||
|
||||
import time
|
||||
|
||||
// i8 uses `Any` as a 16-bit integer.
|
||||
pub fn (f Any) i8() i8 {
|
||||
match f {
|
||||
i8 {
|
||||
return f
|
||||
}
|
||||
i16, i32, int, i64, u8, u16, u32, u64, f32, f64, bool {
|
||||
return i8(f)
|
||||
}
|
||||
string {
|
||||
return f.i8()
|
||||
}
|
||||
else {
|
||||
return 0
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// i16 uses `Any` as a 16-bit integer.
|
||||
pub fn (f Any) i16() i16 {
|
||||
match f {
|
||||
i16 {
|
||||
return f
|
||||
}
|
||||
i8, i32, int, i64, u8, u16, u32, u64, f32, f64, bool {
|
||||
return i16(f)
|
||||
}
|
||||
string {
|
||||
return f.i16()
|
||||
}
|
||||
else {
|
||||
return 0
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// int uses `Any` as an integer.
|
||||
pub fn (f Any) int() int {
|
||||
match f {
|
||||
int {
|
||||
return f
|
||||
}
|
||||
i8, i16, i32, i64, u8, u16, u32, u64, f32, f64, bool {
|
||||
return int(f)
|
||||
}
|
||||
string {
|
||||
return f.int()
|
||||
}
|
||||
else {
|
||||
return 0
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// i32 uses `Any` as a 32-bit integer.
|
||||
pub fn (f Any) i32() i32 {
|
||||
match f {
|
||||
i32 {
|
||||
return f
|
||||
}
|
||||
i8, i16, int, i64, u8, u16, u32, u64, f32, f64, bool {
|
||||
return i32(f)
|
||||
}
|
||||
string {
|
||||
return f.i32()
|
||||
}
|
||||
else {
|
||||
return 0
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// i64 uses `Any` as a 64-bit integer.
|
||||
pub fn (f Any) i64() i64 {
|
||||
match f {
|
||||
i64 {
|
||||
return f
|
||||
}
|
||||
i8, i16, i32, int, u8, u16, u32, u64, f32, f64, bool {
|
||||
return i64(f)
|
||||
}
|
||||
string {
|
||||
return f.i64()
|
||||
}
|
||||
else {
|
||||
return 0
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// u8 uses `Any` as a 8-bit unsigned integer.
|
||||
pub fn (f Any) u8() u8 {
|
||||
match f {
|
||||
u8 {
|
||||
return f
|
||||
}
|
||||
u16, u32, u64, i8, i16, i32, int, i64, f32, f64, bool {
|
||||
return u8(u16(f))
|
||||
}
|
||||
string {
|
||||
return f.u8()
|
||||
}
|
||||
else {
|
||||
return 0
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// u16 uses `Any` as a 16-bit unsigned integer.
|
||||
pub fn (f Any) u16() u16 {
|
||||
match f {
|
||||
u16 {
|
||||
return f
|
||||
}
|
||||
u8, u32, u64, i8, i16, i32, int, i64, f32, f64, bool {
|
||||
return u16(f)
|
||||
}
|
||||
string {
|
||||
return f.u16()
|
||||
}
|
||||
else {
|
||||
return 0
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// u32 uses `Any` as a 32-bit unsigned integer.
|
||||
pub fn (f Any) u32() u32 {
|
||||
match f {
|
||||
u32 {
|
||||
return f
|
||||
}
|
||||
u8, u16, u64, i8, i16, i32, int, i64, f32, f64, bool {
|
||||
return u32(f)
|
||||
}
|
||||
string {
|
||||
return f.u32()
|
||||
}
|
||||
else {
|
||||
return 0
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// u64 uses `Any` as a 64-bit unsigned integer.
|
||||
pub fn (f Any) u64() u64 {
|
||||
match f {
|
||||
u64 {
|
||||
return f
|
||||
}
|
||||
u8, u16, u32, i8, i16, i32, int, i64, f32, f64, bool {
|
||||
return u64(f)
|
||||
}
|
||||
string {
|
||||
return f.u64()
|
||||
}
|
||||
else {
|
||||
return 0
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// f32 uses `Any` as a 32-bit float.
|
||||
pub fn (f Any) f32() f32 {
|
||||
match f {
|
||||
f32 {
|
||||
return f
|
||||
}
|
||||
bool, i8, i16, i32, int, i64, u8, u16, u32, u64, f64 {
|
||||
return f32(f)
|
||||
}
|
||||
string {
|
||||
return f.f32()
|
||||
}
|
||||
else {
|
||||
return 0.0
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// f64 uses `Any` as a 64-bit float.
|
||||
pub fn (f Any) f64() f64 {
|
||||
match f {
|
||||
f64 {
|
||||
return f
|
||||
}
|
||||
i8, i16, i32, int, i64, u8, u16, u32, u64, f32 {
|
||||
return f64(f)
|
||||
}
|
||||
string {
|
||||
return f.f64()
|
||||
}
|
||||
else {
|
||||
return 0.0
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// bool uses `Any` as a bool.
|
||||
pub fn (f Any) bool() bool {
|
||||
match f {
|
||||
bool {
|
||||
return f
|
||||
}
|
||||
string {
|
||||
if f == 'false' {
|
||||
return false
|
||||
}
|
||||
if f == 'true' {
|
||||
return true
|
||||
}
|
||||
if f.len > 0 {
|
||||
return f != '0' && f != '0.0'
|
||||
} else {
|
||||
return false
|
||||
}
|
||||
}
|
||||
i8, i16, i32, int, i64 {
|
||||
return i64(f) != 0
|
||||
}
|
||||
u8, u16, u32, u64 {
|
||||
return u64(f) != 0
|
||||
}
|
||||
f32, f64 {
|
||||
return f64(f) != 0.0
|
||||
}
|
||||
else {
|
||||
return false
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// arr uses `Any` as an array.
|
||||
@[deprecated: 'use as_array() instead']
|
||||
@[deprecated_after: '2026-03-27']
|
||||
pub fn (f Any) arr() []Any {
|
||||
return f.as_array()
|
||||
}
|
||||
|
||||
// as_array uses `Any` as an array.
|
||||
pub fn (f Any) as_array() []Any {
|
||||
if f is []Any {
|
||||
return f
|
||||
} else if f is map[string]Any {
|
||||
mut arr := []Any{}
|
||||
for _, v in f {
|
||||
arr << v
|
||||
}
|
||||
return arr
|
||||
}
|
||||
return [f]
|
||||
}
|
||||
|
||||
// as_map uses `Any` as a map.
|
||||
pub fn (f Any) as_map() map[string]Any {
|
||||
if f is map[string]Any {
|
||||
return f
|
||||
} else if f is []Any {
|
||||
mut mp := map[string]Any{}
|
||||
for i, fi in f {
|
||||
mp['${i}'] = fi
|
||||
}
|
||||
return mp
|
||||
}
|
||||
return {
|
||||
'0': f
|
||||
}
|
||||
}
|
||||
|
||||
pub fn (f Any) as_map_of_strings() map[string]string {
|
||||
if f is map[string]Any {
|
||||
mut ms := map[string]string{}
|
||||
for k, v in f {
|
||||
ms[k] = v.str()
|
||||
}
|
||||
return ms
|
||||
}
|
||||
if f is []Any {
|
||||
mut ms := map[string]string{}
|
||||
for i, fi in f {
|
||||
ms['${i}'] = fi.str()
|
||||
}
|
||||
return ms
|
||||
}
|
||||
return {
|
||||
'0': f.str()
|
||||
}
|
||||
}
|
||||
|
||||
// to_time uses `Any` as a time.Time.
|
||||
pub fn (f Any) to_time() !time.Time {
|
||||
match f {
|
||||
time.Time {
|
||||
return f
|
||||
}
|
||||
i64 {
|
||||
return time.unix(f)
|
||||
}
|
||||
string {
|
||||
is_iso8601 := f[4] == `-` && f[7] == `-`
|
||||
if is_iso8601 {
|
||||
return time.parse_iso8601(f)!
|
||||
}
|
||||
is_rfc3339 := f.len == 24 && f[23] == `Z` && f[10] == `T`
|
||||
if is_rfc3339 {
|
||||
return time.parse_rfc3339(f)!
|
||||
}
|
||||
mut is_unix_timestamp := true
|
||||
for c in f {
|
||||
if c == `-` || (c >= `0` && c <= `9`) {
|
||||
continue
|
||||
}
|
||||
is_unix_timestamp = false
|
||||
break
|
||||
}
|
||||
if is_unix_timestamp {
|
||||
return time.unix(f.i64())
|
||||
}
|
||||
// TODO: parse_iso8601
|
||||
// TODO: parse_rfc2822
|
||||
return time.parse(f)!
|
||||
}
|
||||
else {
|
||||
return error('not a time value: ${f} of type: ${f.type_name()}')
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// map_from converts a struct to a map of Any.
|
||||
pub fn map_from[T](t T) map[string]Any {
|
||||
mut m := map[string]Any{}
|
||||
$if T is $struct {
|
||||
$for field in T.fields {
|
||||
value := t.$(field.name)
|
||||
|
||||
$if field.is_array {
|
||||
mut top_arr := unsafe { []Any{len: t.$(field.name).len} }
|
||||
for idx, variable in value {
|
||||
$if variable is $array {
|
||||
top_arr[idx] = flatten_array(variable)
|
||||
} $else {
|
||||
top_arr[idx] = variable
|
||||
}
|
||||
}
|
||||
m[field.name] = top_arr
|
||||
top_arr.clear()
|
||||
} $else $if field.is_struct {
|
||||
m[field.name] = map_from(value)
|
||||
} $else $if field.is_map {
|
||||
// TODO
|
||||
} $else $if field.is_alias {
|
||||
// TODO
|
||||
} $else $if field.is_option {
|
||||
// TODO
|
||||
} $else {
|
||||
// TODO: simplify check of type & improve memory usage when convert
|
||||
$if field.typ is string {
|
||||
m[field.name] = value
|
||||
} $else $if field.typ is bool {
|
||||
m[field.name] = t.$(field.name)
|
||||
} $else $if field.typ is i8 {
|
||||
m[field.name] = t.$(field.name)
|
||||
} $else $if field.typ is i16 {
|
||||
m[field.name] = t.$(field.name)
|
||||
} $else $if field.typ is i32 {
|
||||
m[field.name] = t.$(field.name)
|
||||
} $else $if field.typ is int {
|
||||
m[field.name] = t.$(field.name)
|
||||
} $else $if field.typ is i64 {
|
||||
m[field.name] = t.$(field.name)
|
||||
} $else $if field.typ is f32 {
|
||||
m[field.name] = t.$(field.name)
|
||||
} $else $if field.typ is f64 {
|
||||
m[field.name] = t.$(field.name)
|
||||
} $else $if field.typ is u8 {
|
||||
m[field.name] = t.$(field.name)
|
||||
} $else $if field.typ is u16 {
|
||||
m[field.name] = t.$(field.name)
|
||||
} $else $if field.typ is u32 {
|
||||
m[field.name] = t.$(field.name)
|
||||
} $else $if field.typ is u64 {
|
||||
m[field.name] = t.$(field.name)
|
||||
} $else {
|
||||
// return error("The type of `${field.name}` can't be decoded. Please open an issue at https://github.com/vlang/v/issues/new/choose")
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return m
|
||||
}
|
||||
|
||||
// flatten_array convert a array of values to array of Any
|
||||
@[inline]
|
||||
fn flatten_array[T](t []T) []Any {
|
||||
$if t !is $array {
|
||||
return Any(t)
|
||||
} $else {
|
||||
mut arr := []Any{}
|
||||
for variable in t {
|
||||
$if variable is $array {
|
||||
arr << flatten_array(variable)
|
||||
} $else {
|
||||
arr << Any(variable)
|
||||
}
|
||||
}
|
||||
return arr
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user