135 lines
2.6 KiB
Odin
135 lines
2.6 KiB
Odin
package mustache
|
|
|
|
import "base:runtime"
|
|
import "core:reflect"
|
|
import "core:strings"
|
|
import "core:mem"
|
|
import "core:fmt"
|
|
|
|
import "core:log"
|
|
|
|
decode :: proc( v: any, key: string ) -> any {
|
|
v := reflect.any_base(v)
|
|
ti := type_info_of(v.id)
|
|
|
|
#partial switch i in runtime.type_info_base(ti).variant {
|
|
case runtime.Type_Info_Enumerated_Array:
|
|
return decode(any{v.data, ti.id}, key)
|
|
|
|
case runtime.Type_Info_Union:
|
|
return decode(any{v.data, reflect.union_variant_typeid(v) }, key)
|
|
|
|
case runtime.Type_Info_Struct:
|
|
newkey, err := strings.split_after_n(key, ".", 2)
|
|
|
|
if err != nil {
|
|
return nil
|
|
}
|
|
|
|
defer delete(newkey)
|
|
|
|
newkey_0 := newkey[0]
|
|
newkey_1 := "."
|
|
|
|
if len(newkey) != 2 {
|
|
newkey_0 = newkey[0][:len(newkey[0])-1]
|
|
newkey_1 = newkey[1]
|
|
}
|
|
|
|
return decode( reflect.struct_field_value_by_name(v, newkey_0), newkey_1 )
|
|
|
|
|
|
case runtime.Type_Info_Map:
|
|
newkey, err := strings.split_after_n(key, ".", 2)
|
|
|
|
if err!= nil {
|
|
return nil
|
|
}
|
|
|
|
defer delete(newkey)
|
|
|
|
newkey_0 := newkey[0]
|
|
newkey_1 := "."
|
|
|
|
if len(newkey) == 2 {
|
|
newkey_0 = newkey[0][:len(newkey[0])-1]
|
|
newkey_1 = newkey[1]
|
|
}
|
|
|
|
|
|
m := (^mem.Raw_Map)(v.data)
|
|
ks, vs, _, _, _ := runtime.map_kvh_data_dynamic(m^, i.map_info)
|
|
|
|
for j in 0..<runtime.map_cap(m^) {
|
|
key_data := runtime.map_cell_index_dynamic(ks, i.map_info.ks, uintptr(j))
|
|
ky, ok := reflect.as_string(any{rawptr(key_data), i.key.id})
|
|
|
|
if !ok {
|
|
return nil
|
|
}
|
|
|
|
if ky == newkey_0 {
|
|
t := any{rawptr(runtime.map_cell_index_dynamic(vs, i.map_info.vs, uintptr(j))), i.value.id}
|
|
return decode(t, newkey_1 )
|
|
}
|
|
}
|
|
|
|
return ""
|
|
}
|
|
|
|
if key == "." {
|
|
return v
|
|
}
|
|
|
|
return ""
|
|
}
|
|
|
|
decode_string :: proc( v: any, key: string ) -> string {
|
|
return fmt.tprintf("%v", decode(v, key))
|
|
}
|
|
|
|
@private
|
|
mustache_section :: proc( r: ^strings.Reader, v: any, key: string, inv: bool = false ) -> string {
|
|
tmp := mustache(r, v, key)
|
|
|
|
if inv {
|
|
return tmp
|
|
}
|
|
|
|
defer delete(tmp)
|
|
return ""
|
|
}
|
|
|
|
section :: proc( r: ^strings.Reader, v: any, key: string, inv: bool = false ) -> string {
|
|
save := r.i
|
|
|
|
t := reflect.any_base(decode(v, key))
|
|
ti := type_info_of(t.id)
|
|
|
|
#partial switch i in runtime.type_info_base(ti).variant {
|
|
case runtime.Type_Info_Slice:
|
|
ret : string= ""
|
|
for i in 0..<reflect.length(t) {
|
|
elem :=reflect.index(t, i);
|
|
strings.reader_seek(r, save, .Start)
|
|
|
|
tmp := mustache_section(r, elem, key, !inv)
|
|
defer delete(tmp)
|
|
|
|
ret = strings.concatenate({ret, tmp})
|
|
}
|
|
return ret
|
|
case runtime.Type_Info_Boolean:
|
|
b, _ := reflect.as_bool(t)
|
|
|
|
return mustache_section(r, t, key, b~inv)
|
|
}
|
|
|
|
if t == nil {
|
|
return mustache_section(r, t, key, inv)
|
|
}
|
|
|
|
return mustache_section(r, t, key, !inv)
|
|
}
|
|
|