gob/collection/json/convert.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)
}