Module collection (3)
This commit is contained in:
Benjamin VAUDOUR
parent
53d7e6c217
commit
6637db7be4
|
|
@ -0,0 +1,106 @@
|
||||||
|
package json
|
||||||
|
|
||||||
|
import (
|
||||||
|
j "encoding/json"
|
||||||
|
"io"
|
||||||
|
|
||||||
|
. "gitea.zaclys.com/bvaudour/gob/option"
|
||||||
|
)
|
||||||
|
|
||||||
|
// JsonDecoder permet de parser une entrée brute en un objet Json ou un tableau de Json.
|
||||||
|
type JsonDecoder struct {
|
||||||
|
d *j.Decoder
|
||||||
|
}
|
||||||
|
|
||||||
|
// NewJsonDecoder retourne un décodeur pour la donnée d’entrée spécifiée.
|
||||||
|
func NewJsonDecoder(r io.Reader) *JsonDecoder { return &JsonDecoder{d: j.NewDecoder(r)} }
|
||||||
|
|
||||||
|
// Decode retourne un objet Json décodé.
|
||||||
|
func (dec *JsonDecoder) Decode() Result[Json] {
|
||||||
|
o := make(Json)
|
||||||
|
if err := dec.d.Decode(&o); err != nil {
|
||||||
|
return Err[Json](err)
|
||||||
|
}
|
||||||
|
return Ok(o)
|
||||||
|
}
|
||||||
|
|
||||||
|
// DecodeSlice retourne un tableau de Json décodé.
|
||||||
|
func (dec *JsonDecoder) DecodeSlice() Result[Slice] {
|
||||||
|
var sl Slice
|
||||||
|
if err := dec.d.Decode(&sl); err != nil {
|
||||||
|
return Err[Slice](err)
|
||||||
|
}
|
||||||
|
return Ok(sl)
|
||||||
|
}
|
||||||
|
|
||||||
|
// Decode décode une entrée brute et la fusionne avec l’objet Json.
|
||||||
|
func (o Json) Decode(r io.Reader) Result[Json] {
|
||||||
|
dec := NewJsonDecoder(r)
|
||||||
|
result := dec.Decode()
|
||||||
|
|
||||||
|
if o2, ok := result.Ok(); ok {
|
||||||
|
o = o.Fusion(o2)
|
||||||
|
return Ok(o)
|
||||||
|
}
|
||||||
|
return result
|
||||||
|
}
|
||||||
|
|
||||||
|
// Decode décode une entrée brute et la fusionne avec le tableau de Json.
|
||||||
|
func (sl *Slice) Decode(r io.Reader) Result[Slice] {
|
||||||
|
dec := NewJsonDecoder(r)
|
||||||
|
result := dec.DecodeSlice()
|
||||||
|
|
||||||
|
if sl2, ok := result.Ok(); ok {
|
||||||
|
return Ok(sl.Add(sl2...))
|
||||||
|
}
|
||||||
|
return result
|
||||||
|
}
|
||||||
|
|
||||||
|
// JsonEncoder permet de convertir un objet Json ou un tableau de Json au format brut.
|
||||||
|
type JsonEncoder struct {
|
||||||
|
e *j.Encoder
|
||||||
|
}
|
||||||
|
|
||||||
|
// NewJsonEncoder fournit un encodeur pour la sortie fournie.
|
||||||
|
func NewJsonEncoder(w io.Writer) *JsonEncoder { return &JsonEncoder{e: j.NewEncoder(w)} }
|
||||||
|
|
||||||
|
// Encode encode un objet Json.
|
||||||
|
func (enc *JsonEncoder) Encode(o Json) error { return enc.e.Encode(o) }
|
||||||
|
|
||||||
|
// EncodeSlice encode un tableau Json.
|
||||||
|
func (enc *JsonEncoder) EncodeSlice(sl Slice) error { return enc.e.Encode(sl) }
|
||||||
|
|
||||||
|
// SetEscapeHTML configure l’encodeur pour que les caractère HTML soient échappés si on est vrai.
|
||||||
|
// Ainsi, les caractères &, <, et > sont transformés respectivement en \u0026, \u003c et \u003e
|
||||||
|
// Cela permet d’éviter des problèmes de sécurité lorsque du html est embarqué dans du Json.
|
||||||
|
func (enc *JsonEncoder) SetEscapeHTML(on bool) { enc.e.SetEscapeHTML(on) }
|
||||||
|
|
||||||
|
// SetIndent définit le préfixe et l’indentation du Json à la sortie.
|
||||||
|
// Cela permet de rendre un Json dans un format lisible (ie. non minifié).
|
||||||
|
func (enc *JsonEncoder) SetIndent(prefix, indent string) { enc.e.SetIndent(prefix, indent) }
|
||||||
|
|
||||||
|
// Encode minifie le Json dans la sortie donnée.
|
||||||
|
func (o Json) Encode(w io.Writer) error {
|
||||||
|
enc := NewJsonEncoder(w)
|
||||||
|
return enc.Encode(o)
|
||||||
|
}
|
||||||
|
|
||||||
|
// EncodeHuman encode le Json dans un format humainement lisible (indentation de deux espaces).
|
||||||
|
func (o Json) EncodeHuman(w io.Writer) error {
|
||||||
|
enc := NewJsonEncoder(w)
|
||||||
|
enc.SetIndent("", " ")
|
||||||
|
return enc.Encode(o)
|
||||||
|
}
|
||||||
|
|
||||||
|
// Encode minifie le tableau de Json dans la sortie donnée.
|
||||||
|
func (sl Slice) Encode(w io.Writer) error {
|
||||||
|
enc := NewJsonEncoder(w)
|
||||||
|
return enc.EncodeSlice(sl)
|
||||||
|
}
|
||||||
|
|
||||||
|
// EncodeHuman encode le tableau de Json dans un format humainement lisible (indentation de deux espaces).
|
||||||
|
func (sl Slice) EncodeHuman(w io.Writer) error {
|
||||||
|
enc := NewJsonEncoder(w)
|
||||||
|
enc.SetIndent("", " ")
|
||||||
|
return enc.EncodeSlice(sl)
|
||||||
|
}
|
||||||
|
|
@ -0,0 +1,548 @@
|
||||||
|
package json
|
||||||
|
|
||||||
|
import (
|
||||||
|
"errors"
|
||||||
|
"io"
|
||||||
|
"sort"
|
||||||
|
"strconv"
|
||||||
|
"strings"
|
||||||
|
|
||||||
|
"gitea.zaclys.com/bvaudour/gob/collection"
|
||||||
|
"gitea.zaclys.com/bvaudour/gob/convert"
|
||||||
|
. "gitea.zaclys.com/bvaudour/gob/option"
|
||||||
|
)
|
||||||
|
|
||||||
|
var (
|
||||||
|
ErrFailedToParse = errors.New("failed to parse")
|
||||||
|
)
|
||||||
|
|
||||||
|
func isSlice(c convert.Value) bool {
|
||||||
|
return c.Is(convert.Slice)
|
||||||
|
}
|
||||||
|
|
||||||
|
func isMap(c convert.Value) bool {
|
||||||
|
return c.Is(convert.Map) && c.Type().Key().Is(convert.String)
|
||||||
|
}
|
||||||
|
|
||||||
|
func isAssignableIn(v1, v2 convert.Value) bool {
|
||||||
|
return v1.Type().AssignableTo(v2.TypeElem())
|
||||||
|
}
|
||||||
|
|
||||||
|
func searchSlice(c convert.Value, k string) (out Option[convert.Value]) {
|
||||||
|
i, err := strconv.Atoi(k)
|
||||||
|
if err == nil && i >= 0 && i < c.Len() {
|
||||||
|
out = Some(c.Index(i))
|
||||||
|
}
|
||||||
|
return
|
||||||
|
}
|
||||||
|
|
||||||
|
func searchMap(c convert.Value, k string) (out Option[convert.Value]) {
|
||||||
|
return c.MapIndexIfExists(convert.ValueOf(k))
|
||||||
|
}
|
||||||
|
|
||||||
|
func search(c convert.Value, k string) (v Option[convert.Value]) {
|
||||||
|
if isSlice(c) {
|
||||||
|
v = searchSlice(c, k)
|
||||||
|
} else if isMap(c) {
|
||||||
|
v = searchMap(c, k)
|
||||||
|
}
|
||||||
|
return
|
||||||
|
}
|
||||||
|
|
||||||
|
func searchAll(c any, keys []string) (v Option[any]) {
|
||||||
|
vv := convert.ValueOf(c)
|
||||||
|
var ok bool
|
||||||
|
for _, k := range keys {
|
||||||
|
if vv, ok = search(vv, k).Get(); !ok {
|
||||||
|
return
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return Some(vv.Interface())
|
||||||
|
}
|
||||||
|
|
||||||
|
func setSlice(c convert.Value, v any, k string) (out Option[convert.Value]) {
|
||||||
|
i, err := strconv.Atoi(k)
|
||||||
|
vv := convert.ValueOf(v)
|
||||||
|
l := c.Len()
|
||||||
|
if err != nil && i >= 0 && i <= l && isAssignableIn(vv, c) {
|
||||||
|
if i < l {
|
||||||
|
c.SetIndex(i, vv)
|
||||||
|
out = Some(c)
|
||||||
|
} else {
|
||||||
|
out = Some(convert.Append(c, vv))
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return
|
||||||
|
}
|
||||||
|
|
||||||
|
func setMap(c convert.Value, v any, k string) (out Option[convert.Value]) {
|
||||||
|
vv := convert.ValueOf(v)
|
||||||
|
if isAssignableIn(vv, c) {
|
||||||
|
c.SetMapIndex(convert.ValueOf(k), vv)
|
||||||
|
out = Some(c)
|
||||||
|
}
|
||||||
|
return
|
||||||
|
}
|
||||||
|
|
||||||
|
func set(c convert.Value, v any, k string) (out Option[convert.Value]) {
|
||||||
|
if isSlice(c) {
|
||||||
|
return setSlice(c, v, k)
|
||||||
|
} else if isMap(c) {
|
||||||
|
return setMap(c, v, k)
|
||||||
|
}
|
||||||
|
return
|
||||||
|
}
|
||||||
|
|
||||||
|
func setAll(c, v any, keys []string) (ok bool) {
|
||||||
|
l := len(keys)
|
||||||
|
k1, k2 := keys[l-2], keys[l-1]
|
||||||
|
cc := convert.ValueOf(c)
|
||||||
|
for _, k := range keys[:l-2] {
|
||||||
|
if cc, ok = search(cc, k).Get(); !ok {
|
||||||
|
return
|
||||||
|
}
|
||||||
|
}
|
||||||
|
var ccl convert.Value
|
||||||
|
if ccl, ok = search(cc, k1).Get(); ok {
|
||||||
|
if ccl, ok = set(ccl, v, k2).Get(); ok {
|
||||||
|
set(cc, ccl.Interface(), k1)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return
|
||||||
|
}
|
||||||
|
|
||||||
|
func delSlice(c convert.Value, k string) (out Option[convert.Value]) {
|
||||||
|
i, err := strconv.Atoi(k)
|
||||||
|
l := c.Len()
|
||||||
|
if err != nil && i >= 0 && i < l {
|
||||||
|
v := convert.SliceOf(c.Type(), l-1, l-1)
|
||||||
|
convert.Copy(v.Slice(0, i), c.Slice(0, i))
|
||||||
|
convert.Copy(v.Slice(i, l-1), c.Slice(i+1, l))
|
||||||
|
return Some(v)
|
||||||
|
}
|
||||||
|
return
|
||||||
|
}
|
||||||
|
|
||||||
|
func delMap(c convert.Value, k string) (out Option[convert.Value]) {
|
||||||
|
kk := convert.ValueOf(k)
|
||||||
|
if ok := c.MapIndexIfExists(kk).IsDefined(); ok {
|
||||||
|
c.DelMapIndex(kk)
|
||||||
|
out = Some(c)
|
||||||
|
}
|
||||||
|
return
|
||||||
|
}
|
||||||
|
|
||||||
|
func del(c convert.Value, k string) (out Option[convert.Value]) {
|
||||||
|
if isSlice(c) {
|
||||||
|
return delSlice(c, k)
|
||||||
|
} else if isMap(c) {
|
||||||
|
return delMap(c, k)
|
||||||
|
}
|
||||||
|
return
|
||||||
|
}
|
||||||
|
|
||||||
|
func delAll(c any, keys []string) (ok bool) {
|
||||||
|
l := len(keys)
|
||||||
|
k1, k2 := keys[l-2], keys[l-1]
|
||||||
|
cc := convert.ValueOf(c)
|
||||||
|
for _, k := range keys[:l-2] {
|
||||||
|
if cc, ok = search(cc, k).Get(); !ok {
|
||||||
|
return
|
||||||
|
}
|
||||||
|
}
|
||||||
|
var ccl convert.Value
|
||||||
|
if ccl, ok = search(cc, k1).Get(); ok {
|
||||||
|
if ccl, ok = del(ccl, k2).Get(); ok {
|
||||||
|
set(cc, ccl.Interface(), k1)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return
|
||||||
|
}
|
||||||
|
|
||||||
|
func flat(v convert.Value, prefix ...string) (keys [][]string, values []any) {
|
||||||
|
if isSlice(v) {
|
||||||
|
it, l := v.SliceRange(), len(prefix)
|
||||||
|
for it.Next() {
|
||||||
|
k := make([]string, l+1)
|
||||||
|
copy(k[:l], prefix)
|
||||||
|
k[l] = strconv.Itoa(it.Index())
|
||||||
|
kk, vv := flat(it.Value(), k...)
|
||||||
|
collection.Add(&keys, kk...)
|
||||||
|
collection.Add(&values, vv...)
|
||||||
|
}
|
||||||
|
} else if isMap(v) {
|
||||||
|
it, l := v.MapRange(), len(prefix)
|
||||||
|
for it.Next() {
|
||||||
|
k := make([]string, l+1)
|
||||||
|
copy(k[:l], prefix)
|
||||||
|
k[l] = it.Key().String()
|
||||||
|
kk, vv := flat(it.Value(), k...)
|
||||||
|
collection.Add(&keys, kk...)
|
||||||
|
collection.Add(&values, vv...)
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
collection.Add(&keys, prefix)
|
||||||
|
collection.Add(&values, v.Interface())
|
||||||
|
}
|
||||||
|
return
|
||||||
|
}
|
||||||
|
|
||||||
|
func createRec(o Json, keys []string) Json {
|
||||||
|
e := o
|
||||||
|
for _, k := range keys {
|
||||||
|
v, ok := o[k]
|
||||||
|
if ok {
|
||||||
|
if m, ok := v.(Json); ok {
|
||||||
|
e = m
|
||||||
|
continue
|
||||||
|
}
|
||||||
|
}
|
||||||
|
m := make(Json)
|
||||||
|
e[k] = m
|
||||||
|
e = m
|
||||||
|
}
|
||||||
|
return o
|
||||||
|
}
|
||||||
|
|
||||||
|
func unflat(v convert.Value, split SplitFunc) (out convert.Value) {
|
||||||
|
if isSlice(v) {
|
||||||
|
it := v.SliceRange()
|
||||||
|
for it.Next() {
|
||||||
|
i, e := it.Index(), unflat(it.Value(), split)
|
||||||
|
v.SetIndex(i, e)
|
||||||
|
}
|
||||||
|
return v
|
||||||
|
} else if isMap(v) {
|
||||||
|
result := make(Json)
|
||||||
|
it := v.MapRange()
|
||||||
|
for it.Next() {
|
||||||
|
k, e := it.Key().String(), unflat(it.Value(), split)
|
||||||
|
spl := SplitKey(k, split)
|
||||||
|
if keys, ok := spl.Ok(); ok {
|
||||||
|
result = createRec(result, keys)
|
||||||
|
result.SetRecursive(e.Interface(), keys...)
|
||||||
|
} else {
|
||||||
|
result[k] = e.Interface()
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return convert.ValueOf(result)
|
||||||
|
}
|
||||||
|
return v
|
||||||
|
}
|
||||||
|
|
||||||
|
func sSlice(c convert.Value) convert.Value {
|
||||||
|
it := c.SliceRange()
|
||||||
|
for it.Next() {
|
||||||
|
i, v := it.Index(), slicify(it.Value())
|
||||||
|
c.SetIndex(i, v)
|
||||||
|
}
|
||||||
|
return c
|
||||||
|
}
|
||||||
|
|
||||||
|
func canSlice(c convert.Value) (out Option[map[int]string]) {
|
||||||
|
if !isMap(c) {
|
||||||
|
return
|
||||||
|
}
|
||||||
|
var keys []int
|
||||||
|
skeys := make(map[int]string)
|
||||||
|
it := c.MapRange()
|
||||||
|
for it.Next() {
|
||||||
|
k := it.Key().String()
|
||||||
|
i, err := strconv.Atoi(k)
|
||||||
|
if err != nil || i < 0 {
|
||||||
|
return
|
||||||
|
}
|
||||||
|
collection.Add(&keys, i)
|
||||||
|
skeys[i] = k
|
||||||
|
}
|
||||||
|
sort.Ints(keys)
|
||||||
|
for i, j := range keys {
|
||||||
|
if i != j {
|
||||||
|
return
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return Some(skeys)
|
||||||
|
}
|
||||||
|
|
||||||
|
func sMap(c convert.Value) convert.Value {
|
||||||
|
if keys, ok := canSlice(c).Get(); ok {
|
||||||
|
sl := convert.SliceOf(convert.SliceTypeOf(c.TypeElem()), len(keys), len(keys))
|
||||||
|
it := sl.SliceRange()
|
||||||
|
for it.Next() {
|
||||||
|
i := it.Index()
|
||||||
|
k := keys[i]
|
||||||
|
v := slicify(c.MapIndex(convert.ValueOf(k)))
|
||||||
|
sl.SetIndex(i, v)
|
||||||
|
}
|
||||||
|
return sl
|
||||||
|
}
|
||||||
|
it := c.MapRange()
|
||||||
|
for it.Next() {
|
||||||
|
k, v := it.Key(), slicify(it.Value())
|
||||||
|
c.SetMapIndex(k, v)
|
||||||
|
}
|
||||||
|
return c
|
||||||
|
}
|
||||||
|
|
||||||
|
func slicify(v convert.Value) convert.Value {
|
||||||
|
if isSlice(v) {
|
||||||
|
return sSlice(v)
|
||||||
|
} else if isMap(v) {
|
||||||
|
return sMap(v)
|
||||||
|
}
|
||||||
|
return v
|
||||||
|
}
|
||||||
|
|
||||||
|
// Json représente un simple objet JSON.
|
||||||
|
type Json map[string]any
|
||||||
|
|
||||||
|
// SplitFunc est une fonction qui découpe une clé en sous-clés.
|
||||||
|
//
|
||||||
|
// Paramètres :
|
||||||
|
// - key : la clé à découper
|
||||||
|
//
|
||||||
|
// Sortie :
|
||||||
|
// - current : la sous-clé parsée
|
||||||
|
// - next : la partie de clé qui reste à parser
|
||||||
|
// - err : une erreur retournée lors du parsage ou io.EOF si le parsage est terminé
|
||||||
|
type SplitFunc func(key string) (current, next string, err error)
|
||||||
|
|
||||||
|
// MergeFunc est la transformée inverse de SplitFunc.
|
||||||
|
type MergeFunc func(keys []string) (key string)
|
||||||
|
|
||||||
|
// SplitDot découpe une clé qui est sous la forme a.b.c…
|
||||||
|
func SplitDot(key string) (current, next string, err error) {
|
||||||
|
i := strings.Index(key, ".")
|
||||||
|
if i < 0 {
|
||||||
|
current, err = key, io.EOF
|
||||||
|
} else {
|
||||||
|
current, next = key[:i], key[i+1:]
|
||||||
|
}
|
||||||
|
|
||||||
|
return
|
||||||
|
}
|
||||||
|
|
||||||
|
// SplitBracket découpe une clé qui est sous la forme a[b][c]…
|
||||||
|
func SplitBracket(key string) (current, next string, err error) {
|
||||||
|
i0 := strings.Index(key, "[")
|
||||||
|
i1 := strings.Index(key, "]")
|
||||||
|
if i0 < 0 {
|
||||||
|
if i1 >= 0 {
|
||||||
|
err = ErrFailedToParse
|
||||||
|
} else {
|
||||||
|
current, err = key, io.EOF
|
||||||
|
}
|
||||||
|
} else if i0 >= i1 || (len(key) > i1+1 && key[i1+1] != '[') {
|
||||||
|
err = ErrFailedToParse
|
||||||
|
} else {
|
||||||
|
current, next = key[:i0], key[i0+1:i1]+key[i1:]
|
||||||
|
}
|
||||||
|
|
||||||
|
return
|
||||||
|
}
|
||||||
|
|
||||||
|
// SplitKey découpe la clé selon la fonction de découpage fournie.
|
||||||
|
func SplitKey(key string, split SplitFunc) (out Result[[]string]) {
|
||||||
|
current, next := key, ""
|
||||||
|
var err error
|
||||||
|
var keys []string
|
||||||
|
for current, next, err = split(current); err == nil; current, next, err = split(current) {
|
||||||
|
collection.Add(&keys, current)
|
||||||
|
current = next
|
||||||
|
}
|
||||||
|
|
||||||
|
if err == io.EOF {
|
||||||
|
return Ok(keys)
|
||||||
|
}
|
||||||
|
return Err[[]string](err)
|
||||||
|
}
|
||||||
|
|
||||||
|
// MergeDot crée une clé sous la forme a.b.c…
|
||||||
|
func MergeDot(keys []string) string {
|
||||||
|
return strings.Join(keys, ".")
|
||||||
|
}
|
||||||
|
|
||||||
|
// MergeBracket crée une clé sous la forme a[b][c]…
|
||||||
|
func MergeBracket(keys []string) (key string) {
|
||||||
|
if len(keys) == 0 {
|
||||||
|
return
|
||||||
|
}
|
||||||
|
key, keys = keys[0], keys[1:]
|
||||||
|
for _, k := range keys {
|
||||||
|
key += "[" + k + "]"
|
||||||
|
}
|
||||||
|
|
||||||
|
return
|
||||||
|
}
|
||||||
|
|
||||||
|
func (o Json) get(keys ...string) (v Option[any]) {
|
||||||
|
switch len(keys) {
|
||||||
|
case 0:
|
||||||
|
v = Some[any](o)
|
||||||
|
case 1:
|
||||||
|
v = Some[any](o[keys[0]])
|
||||||
|
default:
|
||||||
|
v = searchAll(o, keys)
|
||||||
|
}
|
||||||
|
return
|
||||||
|
}
|
||||||
|
|
||||||
|
// Get retourne la valeur de la clé.
|
||||||
|
// Si une fonction de découpage est fournie, la clé est recherchée de façon récursive après découpage.
|
||||||
|
func (o Json) Get(key string, split ...SplitFunc) (value Option[any]) {
|
||||||
|
if len(split) == 0 {
|
||||||
|
return o.get(key)
|
||||||
|
}
|
||||||
|
if keys, ok := SplitKey(key, split[0]).Ok(); ok {
|
||||||
|
return o.get(keys...)
|
||||||
|
}
|
||||||
|
|
||||||
|
return
|
||||||
|
}
|
||||||
|
|
||||||
|
// GetRecursive retourne la valeur de la clé (de façon récursive).
|
||||||
|
func (o Json) GetRecursive(keys ...string) (value Option[any]) {
|
||||||
|
return o.get(keys...)
|
||||||
|
}
|
||||||
|
|
||||||
|
// Parse injecte la valeur associée à la clé dans out, si possible,
|
||||||
|
// et retourne vrai si l’injection a été possible.
|
||||||
|
// out doit être un pointeur.
|
||||||
|
// Si split est fourni la clé est découpée.
|
||||||
|
func (o Json) Parse(out any, key string, split ...SplitFunc) (ok bool) {
|
||||||
|
var v any
|
||||||
|
if v, ok = o.Get(key, split...).Get(); ok {
|
||||||
|
ok = convert.Convert(out, v)
|
||||||
|
}
|
||||||
|
|
||||||
|
return
|
||||||
|
}
|
||||||
|
|
||||||
|
// ParseRecurive agit comme Parse, récursivement.
|
||||||
|
func (o Json) ParseRecursive(out any, keys ...string) (ok bool) {
|
||||||
|
var v any
|
||||||
|
if v, ok = o.GetRecursive(keys...).Get(); ok {
|
||||||
|
ok = convert.Convert(out, v)
|
||||||
|
}
|
||||||
|
|
||||||
|
return
|
||||||
|
}
|
||||||
|
|
||||||
|
// SafeParse agit comme Parse mais la valeur trouvée doit être compatible avec le type de out.
|
||||||
|
func (o Json) SafeParse(out any, key string, split ...SplitFunc) (ok bool) {
|
||||||
|
var v any
|
||||||
|
if v, ok = o.Get(key, split...).Get(); ok {
|
||||||
|
ok = convert.Convert(out, v, true)
|
||||||
|
}
|
||||||
|
|
||||||
|
return
|
||||||
|
}
|
||||||
|
|
||||||
|
// SafeParseRecursive agit comme SafeParse, récursivement.
|
||||||
|
func (o Json) SafeParseRecursive(out any, keys ...string) (ok bool) {
|
||||||
|
var v any
|
||||||
|
if v, ok = o.GetRecursive(keys...).Get(); ok {
|
||||||
|
ok = convert.Convert(out, v, true)
|
||||||
|
}
|
||||||
|
|
||||||
|
return
|
||||||
|
}
|
||||||
|
|
||||||
|
func (o Json) set(value any, keys ...string) (ok bool) {
|
||||||
|
l := len(keys)
|
||||||
|
switch l {
|
||||||
|
case 0:
|
||||||
|
case 1:
|
||||||
|
o[keys[0]], ok = value, true
|
||||||
|
default:
|
||||||
|
ok = setAll(o, value, keys)
|
||||||
|
}
|
||||||
|
return
|
||||||
|
}
|
||||||
|
|
||||||
|
// Set insère la valeur dans l’objet et retourne vrai si la valeur a été insérée.
|
||||||
|
// Si la fonction de découpage est fournie, la clé est découpée.
|
||||||
|
func (o Json) Set(value any, key string, split ...SplitFunc) (ok bool) {
|
||||||
|
if len(split) == 0 {
|
||||||
|
return o.set(value, key)
|
||||||
|
}
|
||||||
|
var keys []string
|
||||||
|
if keys, ok = SplitKey(key, split[0]).Ok(); ok {
|
||||||
|
return o.set(value, keys...)
|
||||||
|
}
|
||||||
|
return
|
||||||
|
}
|
||||||
|
|
||||||
|
// SetRecursive insère la valeur de façon récursive dans l’objet et retourne vrai si elle existe.
|
||||||
|
func (o Json) SetRecursive(value any, keys ...string) (ok bool) {
|
||||||
|
return o.set(value, keys...)
|
||||||
|
}
|
||||||
|
|
||||||
|
func (o Json) del(keys ...string) (ok bool) {
|
||||||
|
l := len(keys)
|
||||||
|
switch l {
|
||||||
|
case 0:
|
||||||
|
case 1:
|
||||||
|
if ok = o.Get(keys[0]).IsDefined(); ok {
|
||||||
|
delete(o, keys[0])
|
||||||
|
}
|
||||||
|
default:
|
||||||
|
ok = delAll(o, keys)
|
||||||
|
}
|
||||||
|
return
|
||||||
|
}
|
||||||
|
|
||||||
|
// Si la fonction de découpage est fournie, la clé est découpée.
|
||||||
|
func (o Json) Del(key string, split ...SplitFunc) (ok bool) {
|
||||||
|
if len(split) == 0 {
|
||||||
|
return o.del(key)
|
||||||
|
}
|
||||||
|
var keys []string
|
||||||
|
if keys, ok = SplitKey(key, split[0]).Ok(); ok {
|
||||||
|
return o.del(keys...)
|
||||||
|
}
|
||||||
|
return
|
||||||
|
}
|
||||||
|
|
||||||
|
// DelRecursive supprimer la clé de façon récursive dans l’objet et retourne vrai si elle existe.
|
||||||
|
func (o Json) DelRecursive(keys ...string) (ok bool) {
|
||||||
|
return o.del(keys...)
|
||||||
|
}
|
||||||
|
|
||||||
|
// Clone effectue une copie profonde de l’objet.
|
||||||
|
func (o Json) Clone(deep ...bool) Json {
|
||||||
|
c := make(Json)
|
||||||
|
for k, v := range o {
|
||||||
|
c.Set(convert.Clone(v, deep...), k)
|
||||||
|
}
|
||||||
|
return c
|
||||||
|
}
|
||||||
|
|
||||||
|
// Fusion ajoute toutes les entrées de o2 dans o1 et retourne o1
|
||||||
|
func (o1 Json) Fusion(o2 Json) Json {
|
||||||
|
for k, v := range o2 {
|
||||||
|
o1[k] = v
|
||||||
|
}
|
||||||
|
return o1
|
||||||
|
}
|
||||||
|
|
||||||
|
// Flat aplatit la structure du Json.
|
||||||
|
func (o Json) Flat(merge MergeFunc) (out Json) {
|
||||||
|
keys, values := flat(convert.ValueOf(o))
|
||||||
|
out = make(Json)
|
||||||
|
for i, k := range keys {
|
||||||
|
out[merge(k)] = values[i]
|
||||||
|
}
|
||||||
|
return
|
||||||
|
}
|
||||||
|
|
||||||
|
// Unflat est l’opération inverse de Flat.
|
||||||
|
func (o Json) Unflat(split SplitFunc) (out Json) {
|
||||||
|
vo := unflat(convert.ValueOf(o), split)
|
||||||
|
out = vo.Interface().(Json)
|
||||||
|
|
||||||
|
for k, v := range out {
|
||||||
|
out[k] = slicify(convert.ValueOf(v))
|
||||||
|
}
|
||||||
|
return
|
||||||
|
}
|
||||||
|
|
@ -0,0 +1,14 @@
|
||||||
|
package json
|
||||||
|
|
||||||
|
// Slice est un tableau d’objets JSON.
|
||||||
|
type Slice []Json
|
||||||
|
|
||||||
|
func (sl *Slice) Add(objects ...Json) Slice {
|
||||||
|
*sl = append(*sl, objects...)
|
||||||
|
return *sl
|
||||||
|
}
|
||||||
|
|
||||||
|
func (sl *Slice) Insert(objects ...Json) Slice {
|
||||||
|
*sl = append(objects, (*sl)...)
|
||||||
|
return *sl
|
||||||
|
}
|
||||||
Loading…
Reference in New Issue