107 lines
3.1 KiB
Go
107 lines
3.1 KiB
Go
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)
|
||
}
|