sen

package main

import (
	"fmt"

	"github.com/ohler55/ojg/sen"
)

func main() {
	type Sample struct {
		X int
		Y string
	}
	b := sen.Bytes(&Sample{X: 3, Y: "why"})
	fmt.Println(string(b))

}

Output:

{x:3 y:why}

package main

import (
	"fmt"

	"github.com/ohler55/ojg/pretty"
	"github.com/ohler55/ojg/sen"
)

func main() {
	val := sen.MustParse([]byte("[true false [3 2 1] {a:1 b:2 c:3 d:[x y z []]}]"))
	fmt.Println(pretty.SEN(val, 80.3))

}

Output:

[
  true
  false
  [3 2 1]
  {a: 1 b: 2 c: 3 d: [x y z []]}
]

package main

import (
	"fmt"
	"strings"

	"github.com/ohler55/ojg/pretty"
	"github.com/ohler55/ojg/sen"
)

func main() {
	r := strings.NewReader("[true false [3 2 1] {a:1 b:2 c:3 d:[x y z []]}]")
	val := sen.MustParseReader(r)
	fmt.Println(pretty.SEN(val, 80.3))

}

Output:

[
  true
  false
  [3 2 1]
  {a: 1 b: 2 c: 3 d: [x y z []]}
]

package main

import (
	"fmt"
	"strings"

	"github.com/ohler55/ojg/sen"
)

func main() {
	type Sample struct {
		X int
		Y string
	}
	var buf strings.Builder
	sen.MustWrite(&buf, &Sample{X: 3, Y: "why"})
	fmt.Println(buf.String())

}

Output:

{x:3 y:why}

package main

import (
	"fmt"

	"github.com/ohler55/ojg/pretty"
	"github.com/ohler55/ojg/sen"
)

func main() {
	val, err := sen.Parse([]byte("[true false [3 2 1] {a:1 b:2 c:3 d:[x y z []]}]"))
	if err != nil {
		panic(err)
	}
	fmt.Println(pretty.SEN(val, 80.3))

}

Output:

[
  true
  false
  [3 2 1]
  {a: 1 b: 2 c: 3 d: [x y z []]}
]

package main

import (
	"fmt"
	"strings"

	"github.com/ohler55/ojg/pretty"
	"github.com/ohler55/ojg/sen"
)

func main() {
	r := strings.NewReader("[true false [3 2 1] {a:1 b:2 c:3 d:[x y z []]}]")
	val, err := sen.ParseReader(r)
	if err != nil {
		panic(err)
	}
	fmt.Println(pretty.SEN(val, 80.3))

}

Output:

[
  true
  false
  [3 2 1]
  {a: 1 b: 2 c: 3 d: [x y z []]}
]

package main

import (
	"fmt"

	"github.com/ohler55/ojg/sen"
)

func main() {
	type Sample struct {
		X int
		Y string
	}
	s := sen.String(&Sample{X: 3, Y: "why"})
	fmt.Println(s)

}

Output:

{x:3 y:why}

package main

import (
	"fmt"

	"github.com/ohler55/ojg/sen"
)

func main() {
	type Sample struct {
		X int
		Y string
	}
	var sample Sample
	if err := sen.Unmarshal([]byte("{x: 3 y: why}"), &sample); err != nil {
		panic(err)
	}
	fmt.Printf("sample.X: %d  sample.Y: %s\n", sample.X, sample.Y)

}

Output:

sample.X: 3  sample.Y: why

package main

import (
	"fmt"

	"github.com/ohler55/ojg"
	"github.com/ohler55/ojg/alt"
	"github.com/ohler55/ojg/sen"
)

// Encode and decode slice of interfaces.

type Animal interface {
	Kind() string
}

type Dog struct {
	Size string
}

func (d *Dog) Kind() string {
	return fmt.Sprintf("%s dog", d.Size)
}

type Cat struct {
	Color string
}

func (c *Cat) Kind() string {
	return fmt.Sprintf("%s cat", c.Color)
}

func main() {
	pets := []Animal{&Dog{Size: "big"}, &Cat{Color: "black"}}

	// Encode and use a create key to identify the encoded type.
	b := sen.Bytes(pets, &ojg.Options{CreateKey: "^", Sort: true})
	// Sort the object members in the output for repeatability.
	fmt.Printf("as JSON: %s\n", b)

	// Create a new Recomposer. This can be use over and over again. Register
	// the types with a nil creation function to let reflection do the work
	// since the types are exported.
	r, err := alt.NewRecomposer("^", map[any]alt.RecomposeFunc{&Dog{}: nil, &Cat{}: nil})
	if err != nil {
		panic(err)
	}
	var result any
	if err = sen.Unmarshal(b, &result, r); err != nil {
		panic(err)
	}
	list, _ := result.([]any)
	for _, item := range list {
		animal, _ := item.(Animal)
		fmt.Printf("  %s\n", animal.Kind())
	}
	// Unmarshal with a typed target.
	var animals []Animal
	if err = sen.Unmarshal(b, &animals, r); err != nil {
		panic(err)
	}
	fmt.Println("Unmarshal into a target struct")
	for _, animal := range animals {
		fmt.Printf("  %T - %s\n", animal, animal.Kind())
	}

}

Output:

as JSON: [{^:Dog size:big} {^:Cat color:black}]
  big dog
  black cat
Unmarshal into a target struct
  *sen_test.Dog - big dog
  *sen_test.Cat - black cat

package main

import (
	"fmt"
	"strings"

	"github.com/ohler55/ojg/sen"
)

func main() {
	type Sample struct {
		X int
		Y string
	}
	var buf strings.Builder
	if err := sen.Write(&buf, &Sample{X: 3, Y: "why"}); err != nil {
		panic(err)
	}
	fmt.Println(buf.String())

}

Output:

{x:3 y:why}