gojay

package module
v1.2.15 Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: Nov 18, 2020 License: MIT Imports: 13 Imported by: 0

README

Build Status codecov Go Report Card Go doc MIT License Sourcegraph stability-stable

GoJay

GoJay is a performant JSON encoder/decoder for Golang (currently the most performant, see benchmarks).

It has a simple API and doesn't use reflection. It relies on small interfaces to decode/encode structures and slices.

Gojay also comes with powerful stream decoding features and an even faster Unsafe API.

There is also a code generation tool to make usage easier and faster.

Why another JSON parser?

I looked at other fast decoder/encoder and realised it was mostly hardly readable static code generation or a lot of reflection, poor streaming features, and not so fast in the end.

Also, I wanted to build a decoder that could consume an io.Reader of line or comma delimited JSON, in a JIT way. To consume a flow of JSON objects from a TCP connection for example or from a standard output. Same way I wanted to build an encoder that could encode a flow of data to a io.Writer.

This is how GoJay aims to be a very fast, JIT stream parser with 0 reflection, low allocation with a friendly API.

Get started

go get github.com/francoispqt/gojay

Decoding

Decoding is done through two different API similar to standard encoding/json:

Example of basic stucture decoding with Unmarshal:

import "github.com/francoispqt/gojay"

type user struct {
    id int
    name string
    email string
}
// implement gojay.UnmarshalerJSONObject
func (u *user) UnmarshalJSONObject(dec *gojay.Decoder, key string) error {
    switch key {
    case "id":
        return dec.Int(&u.id)
    case "name":
        return dec.String(&u.name)
    case "email":
        return dec.String(&u.email)
    }
    return nil
}
func (u *user) NKeys() int {
    return 3
}

func main() {
    u := &user{}
    d := []byte(`{"id":1,"name":"gojay","email":"gojay@email.com"}`)
    err := gojay.UnmarshalJSONObject(d, u)
    if err != nil {
        log.Fatal(err)
    }
}

with Decode:

func main() {
    u := &user{}
    dec := gojay.NewDecoder(bytes.NewReader([]byte(`{"id":1,"name":"gojay","email":"gojay@email.com"}`)))
    err := dec.DecodeObject(d, u)
    if err != nil {
        log.Fatal(err)
    }
}
Unmarshal API

Unmarshal API decodes a []byte to a given pointer with a single function.

Behind the doors, Unmarshal API borrows a *gojay.Decoder resets its settings and decodes the data to the given pointer and releases the *gojay.Decoder to the pool when it finishes, whether it encounters an error or not.

If it cannot find the right Decoding strategy for the type of the given pointer, it returns an InvalidUnmarshalError. You can test the error returned by doing if ok := err.(InvalidUnmarshalError); ok {}.

Unmarshal API comes with three functions:

  • Unmarshal
func Unmarshal(data []byte, v interface{}) error
  • UnmarshalJSONObject
func UnmarshalJSONObject(data []byte, v gojay.UnmarshalerJSONObject) error
  • UnmarshalJSONArray
func UnmarshalJSONArray(data []byte, v gojay.UnmarshalerJSONArray) error
Decode API

Decode API decodes a []byte to a given pointer by creating or borrowing a *gojay.Decoder with an io.Reader and calling Decode methods.

Getting a *gojay.Decoder or Borrowing

You can either get a fresh *gojay.Decoder calling dec := gojay.NewDecoder(io.Reader) or borrow one from the pool by calling dec := gojay.BorrowDecoder(io.Reader).

After using a decoder, you can release it by calling dec.Release(). Beware, if you reuse the decoder after releasing it, it will panic with an error of type InvalidUsagePooledDecoderError. If you want to fully benefit from the pooling, you must release your decoders after using.

Example getting a fresh an releasing:

str := ""
dec := gojay.NewDecoder(strings.NewReader(`"test"`))
defer dec.Release()
if err := dec.Decode(&str); err != nil {
    log.Fatal(err)
}

Example borrowing a decoder and releasing:

str := ""
dec := gojay.BorrowDecoder(strings.NewReader(`"test"`))
defer dec.Release()
if err := dec.Decode(&str); err != nil {
    log.Fatal(err)
}

*gojay.Decoder has multiple methods to decode to specific types:

  • Decode
func (dec *gojay.Decoder) Decode(v interface{}) error
  • DecodeObject
func (dec *gojay.Decoder) DecodeObject(v gojay.UnmarshalerJSONObject) error
  • DecodeArray
func (dec *gojay.Decoder) DecodeArray(v gojay.UnmarshalerJSONArray) error
  • DecodeInt
func (dec *gojay.Decoder) DecodeInt(v *int) error
  • DecodeBool
func (dec *gojay.Decoder) DecodeBool(v *bool) error
  • DecodeString
func (dec *gojay.Decoder) DecodeString(v *string) error

All DecodeXxx methods are used to decode top level JSON values. If you are decoding keys or items of a JSON object or array, don't use the Decode methods.

Example:

reader := strings.NewReader(`"John Doe"`)
dec := NewDecoder(reader)

var str string
err := dec.DecodeString(&str)
if err != nil {
    log.Fatal(err)
}

fmt.Println(str) // John Doe
Structs and Maps
UnmarshalerJSONObject Interface

To unmarshal a JSON object to a structure, the structure must implement the UnmarshalerJSONObject interface:

type UnmarshalerJSONObject interface {
	UnmarshalJSONObject(*gojay.Decoder, string) error
	NKeys() int
}

UnmarshalJSONObject method takes two arguments, the first one is a pointer to the Decoder (*gojay.Decoder) and the second one is the string value of the current key being parsed. If the JSON data is not an object, the UnmarshalJSONObject method will never be called.

NKeys method must return the number of keys to Unmarshal in the JSON object or 0. If zero is returned, all keys will be parsed.

Example of implementation for a struct:

type user struct {
    id int
    name string
    email string
}
// implement UnmarshalerJSONObject
func (u *user) UnmarshalJSONObject(dec *gojay.Decoder, key string) error {
    switch key {
    case "id":
        return dec.Int(&u.id)
    case "name":
        return dec.String(&u.name)
    case "email":
        return dec.String(&u.email)
    }
    return nil
}
func (u *user) NKeys() int {
    return 3
}

Example of implementation for a map[string]string:

// define our custom map type implementing UnmarshalerJSONObject
type message map[string]string

// Implementing Unmarshaler
func (m message) UnmarshalJSONObject(dec *gojay.Decoder, k string) error {
	str := ""
	err := dec.String(&str)
	if err != nil {
		return err
	}
	m[k] = str
	return nil
}

// we return 0, it tells the Decoder to decode all keys
func (m message) NKeys() int {
	return 0
}
Arrays, Slices and Channels

To unmarshal a JSON object to a slice an array or a channel, it must implement the UnmarshalerJSONArray interface:

type UnmarshalerJSONArray interface {
	UnmarshalJSONArray(*gojay.Decoder) error
}

UnmarshalJSONArray method takes one argument, a pointer to the Decoder (*gojay.Decoder). If the JSON data is not an array, the Unmarshal method will never be called.

Example of implementation with a slice:

type testSlice []string
// implement UnmarshalerJSONArray
func (t *testSlice) UnmarshalJSONArray(dec *gojay.Decoder) error {
	str := ""
	if err := dec.String(&str); err != nil {
		return err
	}
	*t = append(*t, str)
	return nil
}

func main() {
	dec := gojay.BorrowDecoder(strings.NewReader(`["Tom", "Jim"]`))
	var slice testSlice
	err := dec.DecodeArray(&slice)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println(slice) // [Tom Jim]
	dec.Release()
}

Example of implementation with a channel:

type testChannel chan string
// implement UnmarshalerJSONArray
func (c testChannel) UnmarshalJSONArray(dec *gojay.Decoder) error {
	str := ""
	if err := dec.String(&str); err != nil {
		return err
	}
	c <- str
	return nil
}

func main() {
	dec := gojay.BorrowDecoder(strings.NewReader(`["Tom", "Jim"]`))
	c := make(testChannel, 2)
	err := dec.DecodeArray(c)
	if err != nil {
		log.Fatal(err)
	}
	for i := 0; i < 2; i++ {
		fmt.Println(<-c)
	}
	close(c)
	dec.Release()
}

Example of implementation with an array:

type testArray [3]string
// implement UnmarshalerJSONArray
func (a *testArray) UnmarshalJSONArray(dec *Decoder) error {
	var str string
	if err := dec.String(&str); err != nil {
		return err
	}
	a[dec.Index()] = str
	return nil
}

func main() {
	dec := gojay.BorrowDecoder(strings.NewReader(`["Tom", "Jim", "Bob"]`))
	var a testArray
	err := dec.DecodeArray(&a)
	fmt.Println(a) // [Tom Jim Bob]
	dec.Release()
}
Other types

To decode other types (string, int, int32, int64, uint32, uint64, float, booleans), you don't need to implement any interface.

Example of encoding strings:

func main() {
    json := []byte(`"Jay"`)
    var v string
    err := gojay.Unmarshal(json, &v)
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println(v) // Jay
}
Decode values methods

When decoding a JSON object of a JSON array using UnmarshalerJSONObject or UnmarshalerJSONArray interface, the gojay.Decoder provides dozens of methods to Decode multiple types.

Non exhaustive list of methods available (to see all methods, check the godoc):

dec.Int
dec.Int8
dec.Int16
dec.Int32
dec.Int64
dec.Uint8
dec.Uint16
dec.Uint32
dec.Uint64
dec.String
dec.Time
dec.Bool
dec.SQLNullString
dec.SQLNullInt64

Encoding

Encoding is done through two different API similar to standard encoding/json:

Example of basic structure encoding with Marshal:

import "github.com/francoispqt/gojay"

type user struct {
	id    int
	name  string
	email string
}

// implement MarshalerJSONObject
func (u *user) MarshalJSONObject(enc *gojay.Encoder) {
	enc.IntKey("id", u.id)
	enc.StringKey("name", u.name)
	enc.StringKey("email", u.email)
}
func (u *user) IsNil() bool {
	return u == nil
}

func main() {
	u := &user{1, "gojay", "gojay@email.com"}
	b, err := gojay.MarshalJSONObject(u)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println(string(b)) // {"id":1,"name":"gojay","email":"gojay@email.com"}
}

with Encode:

func main() {
	u := &user{1, "gojay", "gojay@email.com"}
	b := strings.Builder{}
	enc := gojay.NewEncoder(&b)
	if err := enc.Encode(u); err != nil {
		log.Fatal(err)
	}
	fmt.Println(b.String()) // {"id":1,"name":"gojay","email":"gojay@email.com"}
}
Marshal API

Marshal API encodes a value to a JSON []byte with a single function.

Behind the doors, Marshal API borrows a *gojay.Encoder resets its settings and encodes the data to an internal byte buffer and releases the *gojay.Encoder to the pool when it finishes, whether it encounters an error or not.

If it cannot find the right Encoding strategy for the type of the given value, it returns an InvalidMarshalError. You can test the error returned by doing if ok := err.(InvalidMarshalError); ok {}.

Marshal API comes with three functions:

  • Marshal
func Marshal(v interface{}) ([]byte, error)
  • MarshalJSONObject
func MarshalJSONObject(v gojay.MarshalerJSONObject) ([]byte, error)
  • MarshalJSONArray
func MarshalJSONArray(v gojay.MarshalerJSONArray) ([]byte, error)
Encode API

Encode API decodes a value to JSON by creating or borrowing a *gojay.Encoder sending it to an io.Writer and calling Encode methods.

Getting a *gojay.Encoder or Borrowing

You can either get a fresh *gojay.Encoder calling enc := gojay.NewEncoder(io.Writer) or borrow one from the pool by calling enc := gojay.BorrowEncoder(io.Writer).

After using an encoder, you can release it by calling enc.Release(). Beware, if you reuse the encoder after releasing it, it will panic with an error of type InvalidUsagePooledEncoderError. If you want to fully benefit from the pooling, you must release your encoders after using.

Example getting a fresh encoder an releasing:

str := "test"
b := strings.Builder{}
enc := gojay.NewEncoder(&b)
defer enc.Release()
if err := enc.Encode(str); err != nil {
    log.Fatal(err)
}

Example borrowing an encoder and releasing:

str := "test"
b := strings.Builder{}
enc := gojay.BorrowEncoder(b)
defer enc.Release()
if err := enc.Encode(str); err != nil {
    log.Fatal(err)
}

*gojay.Encoder has multiple methods to encoder specific types to JSON:

  • Encode
func (enc *gojay.Encoder) Encode(v interface{}) error
  • EncodeObject
func (enc *gojay.Encoder) EncodeObject(v gojay.MarshalerJSONObject) error
  • EncodeArray
func (enc *gojay.Encoder) EncodeArray(v gojay.MarshalerJSONArray) error
  • EncodeInt
func (enc *gojay.Encoder) EncodeInt(n int) error
  • EncodeInt64
func (enc *gojay.Encoder) EncodeInt64(n int64) error
  • EncodeFloat
func (enc *gojay.Encoder) EncodeFloat(n float64) error
  • EncodeBool
func (enc *gojay.Encoder) EncodeBool(v bool) error
  • EncodeString
func (enc *gojay.Encoder) EncodeString(s string) error
Structs and Maps

To encode a structure, the structure must implement the MarshalerJSONObject interface:

type MarshalerJSONObject interface {
	MarshalJSONObject(enc *gojay.Encoder)
	IsNil() bool
}

MarshalJSONObject method takes one argument, a pointer to the Encoder (*gojay.Encoder). The method must add all the keys in the JSON Object by calling Decoder's methods.

IsNil method returns a boolean indicating if the interface underlying value is nil or not. It is used to safely ensure that the underlying value is not nil without using Reflection.

Example of implementation for a struct:

type user struct {
	id    int
	name  string
	email string
}

// implement MarshalerJSONObject
func (u *user) MarshalJSONObject(enc *gojay.Encoder) {
	enc.IntKey("id", u.id)
	enc.StringKey("name", u.name)
	enc.StringKey("email", u.email)
}
func (u *user) IsNil() bool {
	return u == nil
}

Example of implementation for a map[string]string:

// define our custom map type implementing MarshalerJSONObject
type message map[string]string

// Implementing Marshaler
func (m message) MarshalJSONObject(enc *gojay.Encoder) {
	for k, v := range m {
		enc.StringKey(k, v)
	}
}

func (m message) IsNil() bool {
	return m == nil
}
Arrays and Slices

To encode an array or a slice, the slice/array must implement the MarshalerJSONArray interface:

type MarshalerJSONArray interface {
	MarshalJSONArray(enc *gojay.Encoder)
	IsNil() bool
}

MarshalJSONArray method takes one argument, a pointer to the Encoder (*gojay.Encoder). The method must add all element in the JSON Array by calling Decoder's methods.

IsNil method returns a boolean indicating if the interface underlying value is nil(empty) or not. It is used to safely ensure that the underlying value is not nil without using Reflection and also to in OmitEmpty feature.

Example of implementation:

type users []*user
// implement MarshalerJSONArray
func (u *users) MarshalJSONArray(enc *gojay.Encoder) {
	for _, e := range u {
		enc.Object(e)
	}
}
func (u *users) IsNil() bool {
	return len(u) == 0
}
Other types

To encode other types (string, int, float, booleans), you don't need to implement any interface.

Example of encoding strings:

func main() {
	name := "Jay"
	b, err := gojay.Marshal(name)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println(string(b)) // "Jay"
}

Stream API

Stream Decoding

GoJay ships with a powerful stream decoder.

It allows to read continuously from an io.Reader stream and do JIT decoding writing unmarshalled JSON to a channel to allow async consuming.

When using the Stream API, the Decoder implements context.Context to provide graceful cancellation.

To decode a stream of JSON, you must call gojay.Stream.DecodeStream and pass it a UnmarshalerStream implementation.

type UnmarshalerStream interface {
	UnmarshalStream(*StreamDecoder) error
}

Example of implementation of stream reading from a WebSocket connection:

// implement UnmarshalerStream
type ChannelStream chan *user

func (c ChannelStream) UnmarshalStream(dec *gojay.StreamDecoder) error {
	u := &user{}
	if err := dec.Object(u); err != nil {
		return err
	}
	c <- u
	return nil
}

func main() {
	// get our websocket connection
	origin := "http://localhost/"
	url := "ws://localhost:12345/ws"
	ws, err := websocket.Dial(url, "", origin)
	if err != nil {
		log.Fatal(err)
	}
	// create our channel which will receive our objects
	streamChan := ChannelStream(make(chan *user))
	// borrow a decoder
	dec := gojay.Stream.BorrowDecoder(ws)
	// start decoding, it will block until a JSON message is decoded from the WebSocket
	// or until Done channel is closed
	go dec.DecodeStream(streamChan)
	for {
		select {
		case v := <-streamChan:
			// Got something from my websocket!
			log.Println(v)
		case <-dec.Done():
			log.Println("finished reading from WebSocket")
			os.Exit(0)
		}
	}
}
Stream Encoding

GoJay ships with a powerful stream encoder part of the Stream API.

It allows to write continuously to an io.Writer and do JIT encoding of data fed to a channel to allow async consuming. You can set multiple consumers on the channel to be as performant as possible. Consumers are non blocking and are scheduled individually in their own go routine.

When using the Stream API, the Encoder implements context.Context to provide graceful cancellation.

To encode a stream of data, you must call EncodeStream and pass it a MarshalerStream implementation.

type MarshalerStream interface {
	MarshalStream(enc *gojay.StreamEncoder)
}

Example of implementation of stream writing to a WebSocket:

// Our structure which will be pushed to our stream
type user struct {
	id    int
	name  string
	email string
}

func (u *user) MarshalJSONObject(enc *gojay.Encoder) {
	enc.IntKey("id", u.id)
	enc.StringKey("name", u.name)
	enc.StringKey("email", u.email)
}
func (u *user) IsNil() bool {
	return u == nil
}

// Our MarshalerStream implementation
type StreamChan chan *user

func (s StreamChan) MarshalStream(enc *gojay.StreamEncoder) {
	select {
	case <-enc.Done():
		return
	case o := <-s:
		enc.Object(o)
	}
}

// Our main function
func main() {
	// get our websocket connection
	origin := "http://localhost/"
	url := "ws://localhost:12345/ws"
	ws, err := websocket.Dial(url, "", origin)
	if err != nil {
		log.Fatal(err)
	}
	// we borrow an encoder set stdout as the writer,
	// set the number of consumer to 10
	// and tell the encoder to separate each encoded element
	// added to the channel by a new line character
	enc := gojay.Stream.BorrowEncoder(ws).NConsumer(10).LineDelimited()
	// instantiate our MarshalerStream
	s := StreamChan(make(chan *user))
	// start the stream encoder
	// will block its goroutine until enc.Cancel(error) is called
	// or until something is written to the channel
	go enc.EncodeStream(s)
	// write to our MarshalerStream
	for i := 0; i < 1000; i++ {
		s <- &user{i, "username", "user@email.com"}
	}
	// Wait
	<-enc.Done()
}

Unsafe API

Unsafe API has the same functions than the regular API, it only has Unmarshal API for now. It is unsafe because it makes assumptions on the quality of the given JSON.

If you are not sure if your JSON is valid, don't use the Unsafe API.

Also, the Unsafe API does not copy the buffer when using Unmarshal API, which, in case of string decoding, can lead to data corruption if a byte buffer is reused. Using the Decode API makes Unsafe API safer as the io.Reader relies on copy builtin method and Decoder will have its own internal buffer :)

Access the Unsafe API this way:

gojay.Unsafe.Unmarshal(b, v)

Benchmarks

Benchmarks encode and decode three different data based on size (small, medium, large).

To run benchmark for decoder:

cd $GOPATH/src/github.com/francoispqt/gojay/benchmarks/decoder && make bench

To run benchmark for encoder:

cd $GOPATH/src/github.com/francoispqt/gojay/benchmarks/encoder && make bench

Benchmark Results

Decode

Small Payload

benchmark code is here

benchmark data is here

ns/op bytes/op allocs/op
Std Library 2547 496 4
JsonIter 2046 312 12
JsonParser 1408 0 0
EasyJson 929 240 2
GoJay 807 256 2
GoJay-unsafe 712 112 1
Medium Payload

benchmark code is here

benchmark data is here

ns/op bytes/op allocs/op
Std Library 30148 2152 496
JsonIter 16309 2976 80
JsonParser 7793 0 0
EasyJson 7957 232 6
GoJay 4984 2448 8
GoJay-unsafe 4809 144 7
Large Payload

benchmark code is here

benchmark data is here

ns/op bytes/op allocs/op
JsonIter 210078 41712 1136
EasyJson 106626 160 2
JsonParser 66813 0 0
GoJay 52153 31241 77
GoJay-unsafe 48277 2561 76

Encode

Small Struct

benchmark code is here

benchmark data is here

ns/op bytes/op allocs/op
Std Library 1280 464 3
EasyJson 871 944 6
JsonIter 866 272 3
GoJay 543 112 1
GoJay-func 347 0 0
Medium Struct

benchmark code is here

benchmark data is here

ns/op bytes/op allocs/op
Std Library 5006 1496 25
JsonIter 2232 1544 20
EasyJson 1997 1544 19
GoJay 1522 312 14
Large Struct

benchmark code is here

benchmark data is here

ns/op bytes/op allocs/op
Std Library 66441 20576 332
JsonIter 35247 20255 328
EasyJson 32053 15474 327
GoJay 27847 9802 318

Contributing

Contributions are welcome :)

If you encounter issues please report it in Github and/or send an email at francois@parquet.ninja

Documentation

Overview

Package gojay implements encoding and decoding of JSON as defined in RFC 7159. The mapping between JSON and Go values is described in the documentation for the Marshal and Unmarshal functions.

It aims at performance and usability by relying on simple interfaces to decode and encode structures, slices, arrays and even channels.

On top of the simple interfaces to implement, gojay provides lots of helpers to decode and encode multiple of different types natively such as bit.Int, sql.NullString or time.Time

Example (DecodeEncode)
package main

import (
	"fmt"
	"log"
	"os"
	"strings"

	"github.com/francoispqt/gojay"
)

type User struct {
	ID    int
	Name  string
	Email string
}

func (u *User) UnmarshalJSONObject(dec *gojay.Decoder, k string) error {
	switch k {
	case "id":
		return dec.Int(&u.ID)
	case "name":
		return dec.String(&u.Name)
	case "email":
		return dec.String(&u.Email)
	}
	return nil
}

func (u *User) NKeys() int {
	return 3
}

func (u *User) MarshalJSONObject(enc *gojay.Encoder) {
	enc.IntKey("id", u.ID)
	enc.StringKey("name", u.Name)
	enc.StringKey("email", u.Email)
}

func (u *User) IsNil() bool {
	return u == nil
}

func main() {
	reader := strings.NewReader(`{
		"id": 1,
		"name": "John Doe",
		"email": "john.doe@email.com"
	}`)
	dec := gojay.BorrowDecoder(reader)
	defer dec.Release()

	u := &User{}
	err := dec.Decode(u)
	if err != nil {
		log.Fatal(err)
	}

	enc := gojay.BorrowEncoder(os.Stdout)
	err = enc.Encode(u)
	if err != nil {
		log.Fatal(err)
	}

	fmt.Printf("\nUser ID: %d\nName: %s\nEmail: %s\n",
		u.ID, u.Name, u.Email)

}
Output:

{"id":1,"name":"John Doe","email":"john.doe@email.com"}
User ID: 1
Name: John Doe
Email: john.doe@email.com

Index

Examples

Constants

This section is empty.

Variables

View Source
var ErrUnmarshalPtrExpected = errors.New("Cannot unmarshal to given value, a pointer is expected")

ErrUnmarshalPtrExpected is the error returned when unmarshal expects a pointer value, When using `dec.ObjectNull` or `dec.ArrayNull` for example.

View Source
var Stream = stream{}

Stream is a struct holding the Stream api

View Source
var Unsafe = decUnsafe{}

Unsafe is the structure holding the unsafe version of the API. The difference between unsafe api and regular api is that the regular API copies the buffer passed to Unmarshal functions to a new internal buffer. Making it safer because internally GoJay uses unsafe.Pointer to transform slice of bytes into a string.

Functions

func Marshal

func Marshal(v interface{}) ([]byte, error)

Marshal returns the JSON encoding of v.

If v is nil, not an implementation MarshalerJSONObject or MarshalerJSONArray or not one of the following types:

string, int, int8, int16, int32, int64, uint8, uint16, uint32, uint64, float64, float32, bool

Marshal returns an InvalidMarshalError.

Example (Bool)
package main

import (
	"fmt"
	"log"

	"github.com/francoispqt/gojay"
)

func main() {
	b := true
	d, err := gojay.Marshal(b)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println(string(d)) // true
}
Output:

Example (String)
package main

import (
	"fmt"
	"log"

	"github.com/francoispqt/gojay"
)

func main() {
	str := "gojay"
	d, err := gojay.Marshal(str)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println(string(d)) // "gojay"
}
Output:

func MarshalAny

func MarshalAny(v interface{}) ([]byte, error)

MarshalAny returns the JSON encoding of v.

If v is nil, not an implementation MarshalerJSONObject or MarshalerJSONArray or not one of the following types:

string, int, int8, int16, int32, int64, uint8, uint16, uint32, uint64, float64, float32, bool

MarshalAny falls back to "json/encoding" package to marshal the value.

func MarshalJSONArray

func MarshalJSONArray(v MarshalerJSONArray) ([]byte, error)

MarshalJSONArray returns the JSON encoding of v, an implementation of MarshalerJSONArray.

Example:

type TestSlice []*TestStruct

func (t TestSlice) MarshalJSONArray(enc *Encoder) {
	for _, e := range t {
		enc.AddObject(e)
	}
}

func main() {
	test := &TestSlice{
		&TestStruct{123456},
		&TestStruct{7890},
	}
	b, _ := Marshal(test)
	fmt.Println(b) // [{"id":123456},{"id":7890}]
}

func MarshalJSONObject

func MarshalJSONObject(v MarshalerJSONObject) ([]byte, error)

MarshalJSONObject returns the JSON encoding of v, an implementation of MarshalerJSONObject.

Example:

type Object struct {
	id int
}
func (s *Object) MarshalJSONObject(enc *gojay.Encoder) {
	enc.IntKey("id", s.id)
}
func (s *Object) IsNil() bool {
	return s == nil
}

func main() {
	test := &Object{
		id: 123456,
	}
	b, _ := gojay.Marshal(test)
	fmt.Println(b) // {"id":123456}
}

func Unmarshal

func Unmarshal(data []byte, v interface{}) error

Unmarshal parses the JSON-encoded data and stores the result in the value pointed to by v. If v is nil, not an implementation of UnmarshalerJSONObject or UnmarshalerJSONArray or not one of the following types:

*string, **string, *int, **int, *int8, **int8, *int16, **int16, *int32, **int32, *int64, **int64, *uint8, **uint8, *uint16, **uint16,
*uint32, **uint32, *uint64, **uint64, *float64, **float64, *float32, **float32, *bool, **bool

Unmarshal returns an InvalidUnmarshalError.

If a JSON value is not appropriate for a given target type, or if a JSON number overflows the target type, Unmarshal skips that field and completes the unmarshaling as best it can. If no more serious errors are encountered, Unmarshal returns an UnmarshalTypeError describing the earliest such error. In any case, it's not guaranteed that all the remaining fields following the problematic one will be unmarshaled into the target object.

Example (Bool)
package main

import (
	"fmt"
	"log"

	"github.com/francoispqt/gojay"
)

func main() {
	data := []byte(`true`)
	var b bool
	err := gojay.Unmarshal(data, &b)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println(b) // true
}
Output:

Example (InvalidType)
package main

import (
	"fmt"

	"github.com/francoispqt/gojay"
)

func main() {
	data := []byte(`"gojay"`)
	someStruct := struct{}{}
	err := gojay.Unmarshal(data, &someStruct)

	fmt.Println(err) // "Cannot unmarshal JSON to type '*struct{}'"
}
Output:

Example (String)
package main

import (
	"fmt"
	"log"

	"github.com/francoispqt/gojay"
)

func main() {
	data := []byte(`"gojay"`)
	var str string
	err := gojay.Unmarshal(data, &str)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println(str) // true
}
Output:

func UnmarshalJSONArray

func UnmarshalJSONArray(data []byte, v UnmarshalerJSONArray) error

UnmarshalJSONArray parses the JSON-encoded data and stores the result in the value pointed to by v.

v must implement UnmarshalerJSONArray.

If a JSON value is not appropriate for a given target type, or if a JSON number overflows the target type, UnmarshalJSONArray skips that field and completes the unmarshaling as best it can.

func UnmarshalJSONObject

func UnmarshalJSONObject(data []byte, v UnmarshalerJSONObject) error

UnmarshalJSONObject parses the JSON-encoded data and stores the result in the value pointed to by v.

v must implement UnmarshalerJSONObject.

If a JSON value is not appropriate for a given target type, or if a JSON number overflows the target type, UnmarshalJSONObject skips that field and completes the unmarshaling as best it can.

Types

type DecodeArrayFunc

type DecodeArrayFunc func(*Decoder) error
Example
package main

import (
	"fmt"
	"log"
	"strings"

	"github.com/francoispqt/gojay"
)

func main() {
	reader := strings.NewReader(`[
		"foo",
		"bar"
	]`)
	dec := gojay.NewDecoder(reader)

	strSlice := make([]string, 0)
	err := dec.DecodeArray(gojay.DecodeArrayFunc(func(dec *gojay.Decoder) error {
		var str string
		if err := dec.AddString(&str); err != nil {
			return err
		}
		strSlice = append(strSlice, str)
		return nil
	}))

	if err != nil {
		log.Fatal(err)
	}

	fmt.Print(strSlice)
}
Output:

[foo bar]

func (DecodeArrayFunc) IsNil

func (f DecodeArrayFunc) IsNil() bool

IsNil implements UnmarshalerJSONArray.

func (DecodeArrayFunc) UnmarshalJSONArray

func (f DecodeArrayFunc) UnmarshalJSONArray(dec *Decoder) error

UnmarshalJSONArray implements UnmarshalerJSONArray.

type DecodeObjectFunc

type DecodeObjectFunc func(*Decoder, string) error

DecodeObjectFunc is a func type implementing UnmarshalerJSONObject. Use it to cast a `func(*Decoder, k string) error` to Unmarshal an object on the fly.

Example
package main

import (
	"fmt"
	"strings"

	"github.com/francoispqt/gojay"
)

func main() {
	reader := strings.NewReader(`{
		"name": "John Doe",
		"email": "john.doe@email.com" 
	}`)
	dec := gojay.NewDecoder(reader)

	user := struct {
		name  string
		email string
	}{}
	dec.DecodeObject(gojay.DecodeObjectFunc(func(dec *gojay.Decoder, k string) error {
		switch k {
		case "name":
			return dec.String(&user.name)
		case "email":
			return dec.String(&user.email)
		}
		return nil
	}))

	fmt.Printf("User\nname: %s\nemail: %s", user.name, user.email)

}
Output:

User
name: John Doe
email: john.doe@email.com

func (DecodeObjectFunc) NKeys

func (f DecodeObjectFunc) NKeys() int

NKeys implements UnmarshalerJSONObject.

func (DecodeObjectFunc) UnmarshalJSONObject

func (f DecodeObjectFunc) UnmarshalJSONObject(dec *Decoder, k string) error

UnmarshalJSONObject implements UnmarshalerJSONObject.

type Decoder

type Decoder struct {
	// contains filtered or unexported fields
}

A Decoder reads and decodes JSON values from an input stream.

func BorrowDecoder

func BorrowDecoder(r io.Reader) *Decoder

BorrowDecoder borrows a Decoder from the pool. It takes an io.Reader implementation as data input.

In order to benefit from the pool, a borrowed decoder must be released after usage.

Example
package main

import (
	"fmt"
	"log"
	"strings"

	"github.com/francoispqt/gojay"
)

func main() {
	reader := strings.NewReader(`"gojay"`)
	dec := gojay.BorrowDecoder(reader)
	defer dec.Release()

	var str string
	err := dec.DecodeString(&str)
	if err != nil {
		log.Fatal(err)
	}

	fmt.Println(str)
}
Output:

gojay

func NewDecoder

func NewDecoder(r io.Reader) *Decoder

NewDecoder returns a new decoder. It takes an io.Reader implementation as data input.

Example
package main

import (
	"fmt"
	"log"
	"strings"

	"github.com/francoispqt/gojay"
)

func main() {
	reader := strings.NewReader(`"gojay"`)
	dec := gojay.NewDecoder(reader)

	var str string
	err := dec.DecodeString(&str)
	if err != nil {
		log.Fatal(err)
	}

	fmt.Println(str)
}
Output:

gojay

func (*Decoder) AddArray

func (dec *Decoder) AddArray(v UnmarshalerJSONArray) error

AddArray decodes the JSON value within an object or an array to a UnmarshalerJSONArray.

func (*Decoder) AddArrayNull

func (dec *Decoder) AddArrayNull(v interface{}) error

AddArrayNull decodes the JSON value within an object or an array to a UnmarshalerJSONArray.

func (*Decoder) AddBool

func (dec *Decoder) AddBool(v *bool) error

AddBool decodes the JSON value within an object or an array to a *bool. If next key is neither null nor a JSON boolean, an InvalidUnmarshalError will be returned. If next key is null, bool will be false.

func (*Decoder) AddBoolNull

func (dec *Decoder) AddBoolNull(v **bool) error

AddBoolNull decodes the JSON value within an object or an array to a *bool. If next key is neither null nor a JSON boolean, an InvalidUnmarshalError will be returned. If next key is null, bool will be false. If a `null` is encountered, gojay does not change the value of the pointer.

func (*Decoder) AddEmbeddedJSON

func (dec *Decoder) AddEmbeddedJSON(v *EmbeddedJSON) error

AddEmbeddedJSON adds an EmbeddedsJSON to the value pointed by v. It can be used to delay JSON decoding or precompute a JSON encoding.

func (*Decoder) AddFloat

func (dec *Decoder) AddFloat(v *float64) error

AddFloat decodes the JSON value within an object or an array to a *float64. If next key value overflows float64, an InvalidUnmarshalError error will be returned.

func (*Decoder) AddFloat32

func (dec *Decoder) AddFloat32(v *float32) error

AddFloat32 decodes the JSON value within an object or an array to a *float64. If next key value overflows float64, an InvalidUnmarshalError error will be returned.

func (*Decoder) AddFloat32Null

func (dec *Decoder) AddFloat32Null(v **float32) error

AddFloat32Null decodes the JSON value within an object or an array to a *float64. If next key value overflows float64, an InvalidUnmarshalError error will be returned. If a `null` is encountered, gojay does not change the value of the pointer.

func (*Decoder) AddFloat64

func (dec *Decoder) AddFloat64(v *float64) error

AddFloat64 decodes the JSON value within an object or an array to a *float64. If next key value overflows float64, an InvalidUnmarshalError error will be returned.

func (*Decoder) AddFloat64Null

func (dec *Decoder) AddFloat64Null(v **float64) error

AddFloat64Null decodes the JSON value within an object or an array to a *float64. If next key value overflows float64, an InvalidUnmarshalError error will be returned. If a `null` is encountered, gojay does not change the value of the pointer.

func (*Decoder) AddFloatNull

func (dec *Decoder) AddFloatNull(v **float64) error

AddFloatNull decodes the JSON value within an object or an array to a *float64. If next key value overflows float64, an InvalidUnmarshalError error will be returned. If a `null` is encountered, gojay does not change the value of the pointer.

func (*Decoder) AddInt

func (dec *Decoder) AddInt(v *int) error

AddInt decodes the JSON value within an object or an array to an *int. If next key value overflows int, an InvalidUnmarshalError error will be returned.

func (*Decoder) AddInt16

func (dec *Decoder) AddInt16(v *int16) error

AddInt16 decodes the JSON value within an object or an array to an *int. If next key value overflows int16, an InvalidUnmarshalError error will be returned.

func (*Decoder) AddInt16Null

func (dec *Decoder) AddInt16Null(v **int16) error

AddInt16Null decodes the JSON value within an object or an array to an *int. If next key value overflows int16, an InvalidUnmarshalError error will be returned. If a `null` is encountered, gojay does not change the value of the pointer.

func (*Decoder) AddInt32

func (dec *Decoder) AddInt32(v *int32) error

AddInt32 decodes the JSON value within an object or an array to an *int. If next key value overflows int32, an InvalidUnmarshalError error will be returned.

func (*Decoder) AddInt32Null

func (dec *Decoder) AddInt32Null(v **int32) error

AddInt32Null decodes the JSON value within an object or an array to an *int. If next key value overflows int32, an InvalidUnmarshalError error will be returned. If a `null` is encountered, gojay does not change the value of the pointer.

func (*Decoder) AddInt64

func (dec *Decoder) AddInt64(v *int64) error

AddInt64 decodes the JSON value within an object or an array to an *int. If next key value overflows int64, an InvalidUnmarshalError error will be returned.

func (*Decoder) AddInt64Null

func (dec *Decoder) AddInt64Null(v **int64) error

AddInt64Null decodes the JSON value within an object or an array to an *int. If next key value overflows int64, an InvalidUnmarshalError error will be returned. If a `null` is encountered, gojay does not change the value of the pointer.

func (*Decoder) AddInt8

func (dec *Decoder) AddInt8(v *int8) error

AddInt8 decodes the JSON value within an object or an array to an *int. If next key value overflows int8, an InvalidUnmarshalError error will be returned.

func (*Decoder) AddInt8Null

func (dec *Decoder) AddInt8Null(v **int8) error

AddInt8Null decodes the JSON value within an object or an array to an *int. If next key value overflows int8, an InvalidUnmarshalError error will be returned. If a `null` is encountered, gojay does not change the value of the pointer.

func (*Decoder) AddIntNull

func (dec *Decoder) AddIntNull(v **int) error

AddIntNull decodes the JSON value within an object or an array to an *int. If next key value overflows int, an InvalidUnmarshalError error will be returned. If a `null` is encountered, gojay does not change the value of the pointer.

func (*Decoder) AddInterface

func (dec *Decoder) AddInterface(v *interface{}) error

AddInterface decodes the JSON value within an object or an array to a interface{}.

func (*Decoder) AddObject

func (dec *Decoder) AddObject(v UnmarshalerJSONObject) error

AddObject decodes the JSON value within an object or an array to a UnmarshalerJSONObject.

func (*Decoder) AddObjectNull

func (dec *Decoder) AddObjectNull(v interface{}) error

AddObjectNull decodes the JSON value within an object or an array to a UnmarshalerJSONObject.

func (*Decoder) AddSQLNullBool

func (dec *Decoder) AddSQLNullBool(v *sql.NullBool) error

AddSQLNullBool decodes the JSON value within an object or an array to an *sql.NullBool

func (*Decoder) AddSQLNullFloat64

func (dec *Decoder) AddSQLNullFloat64(v *sql.NullFloat64) error

AddSQLNullFloat64 decodes the JSON value within an object or an array to qn *sql.NullFloat64

func (*Decoder) AddSQLNullInt64

func (dec *Decoder) AddSQLNullInt64(v *sql.NullInt64) error

AddSQLNullInt64 decodes the JSON value within an object or an array to qn *sql.NullInt64

func (*Decoder) AddSQLNullString

func (dec *Decoder) AddSQLNullString(v *sql.NullString) error

AddSQLNullString decodes the JSON value within an object or an array to qn *sql.NullString

func (*Decoder) AddSliceBool

func (dec *Decoder) AddSliceBool(s *[]bool) error

AddBool unmarshals the next JSON array of boolegers to the given *[]bool s

func (*Decoder) AddSliceFloat64

func (dec *Decoder) AddSliceFloat64(s *[]float64) error

AddFloat64 unmarshals the next JSON array of floats to the given *[]float64 s

func (*Decoder) AddSliceInt

func (dec *Decoder) AddSliceInt(s *[]int) error

AddSliceInt unmarshals the next JSON array of integers to the given *[]int s

func (*Decoder) AddSliceString

func (dec *Decoder) AddSliceString(s *[]string) error

AddSliceString unmarshals the next JSON array of strings to the given *[]string s

func (*Decoder) AddString

func (dec *Decoder) AddString(v *string) error

AddString decodes the JSON value within an object or an array to a *string. If next key is not a JSON string nor null, InvalidUnmarshalError will be returned.

func (*Decoder) AddStringNull

func (dec *Decoder) AddStringNull(v **string) error

AddStringNull decodes the JSON value within an object or an array to a *string. If next key is not a JSON string nor null, InvalidUnmarshalError will be returned. If a `null` is encountered, gojay does not change the value of the pointer.

func (*Decoder) AddTime

func (dec *Decoder) AddTime(v *time.Time, format string) error

AddTime decodes the JSON value within an object or an array to a *time.Time with the given format

func (*Decoder) AddUint16

func (dec *Decoder) AddUint16(v *uint16) error

AddUint16 decodes the JSON value within an object or an array to an *int. If next key value overflows uint16, an InvalidUnmarshalError error will be returned.

func (*Decoder) AddUint16Null

func (dec *Decoder) AddUint16Null(v **uint16) error

AddUint16Null decodes the JSON value within an object or an array to an *int. If next key value overflows uint16, an InvalidUnmarshalError error will be returned. If a `null` is encountered, gojay does not change the value of the pointer.

func (*Decoder) AddUint32

func (dec *Decoder) AddUint32(v *uint32) error

AddUint32 decodes the JSON value within an object or an array to an *int. If next key value overflows uint32, an InvalidUnmarshalError error will be returned.

func (*Decoder) AddUint32Null

func (dec *Decoder) AddUint32Null(v **uint32) error

AddUint32Null decodes the JSON value within an object or an array to an *int. If next key value overflows uint32, an InvalidUnmarshalError error will be returned. If a `null` is encountered, gojay does not change the value of the pointer.

func (*Decoder) AddUint64

func (dec *Decoder) AddUint64(v *uint64) error

AddUint64 decodes the JSON value within an object or an array to an *int. If next key value overflows uint64, an InvalidUnmarshalError error will be returned.

func (*Decoder) AddUint64Null

func (dec *Decoder) AddUint64Null(v **uint64) error

AddUint64Null decodes the JSON value within an object or an array to an *int. If next key value overflows uint64, an InvalidUnmarshalError error will be returned. If a `null` is encountered, gojay does not change the value of the pointer.

func (*Decoder) AddUint8

func (dec *Decoder) AddUint8(v *uint8) error

AddUint8 decodes the JSON value within an object or an array to an *int. If next key value overflows uint8, an InvalidUnmarshalError error will be returned.

func (*Decoder) AddUint8Null

func (dec *Decoder) AddUint8Null(v **uint8) error

AddUint8Null decodes the JSON value within an object or an array to an *int. If next key value overflows uint8, an InvalidUnmarshalError error will be returned. If a `null` is encountered, gojay does not change the value of the pointer.

func (*Decoder) Array

func (dec *Decoder) Array(v UnmarshalerJSONArray) error

Array decodes the JSON value within an object or an array to a UnmarshalerJSONArray.

func (*Decoder) ArrayNull

func (dec *Decoder) ArrayNull(v interface{}) error

ArrayNull decodes the JSON value within an object or an array to a UnmarshalerJSONArray. v should be a pointer to an UnmarshalerJSONArray, if `null` value is encountered in JSON, it will leave the value v untouched, else it will create a new instance of the UnmarshalerJSONArray behind v.

func (*Decoder) Bool

func (dec *Decoder) Bool(v *bool) error

Bool decodes the JSON value within an object or an array to a *bool. If next key is neither null nor a JSON boolean, an InvalidUnmarshalError will be returned. If next key is null, bool will be false.

func (*Decoder) BoolNull

func (dec *Decoder) BoolNull(v **bool) error

BoolNull decodes the JSON value within an object or an array to a *bool. If next key is neither null nor a JSON boolean, an InvalidUnmarshalError will be returned. If next key is null, bool will be false.

func (*Decoder) Decode

func (dec *Decoder) Decode(v interface{}) error

Decode reads the next JSON-encoded value from the decoder's input (io.Reader) and stores it in the value pointed to by v.

See the documentation for Unmarshal for details about the conversion of JSON into a Go value. The differences between Decode and Unmarshal are:

  • Decode reads from an io.Reader in the Decoder, whereas Unmarshal reads from a []byte
  • Decode leaves to the user the option of borrowing and releasing a Decoder, whereas Unmarshal internally always borrows a Decoder and releases it when the unmarshaling is completed
Example (String)
package main

import (
	"fmt"
	"log"
	"strings"

	"github.com/francoispqt/gojay"
)

func main() {
	var str string
	dec := gojay.BorrowDecoder(strings.NewReader(`"gojay"`))
	err := dec.Decode(&str)
	dec.Release()

	if err != nil {
		log.Fatal(err)
	}
	fmt.Println(str) // "gojay"
}
Output:

func (*Decoder) DecodeArray

func (dec *Decoder) DecodeArray(v UnmarshalerJSONArray) error

DecodeArray reads the next JSON-encoded value from the decoder's input (io.Reader) and stores it in the value pointed to by v.

v must implement UnmarshalerJSONArray.

See the documentation for Unmarshal for details about the conversion of JSON into a Go value.

func (*Decoder) DecodeBool

func (dec *Decoder) DecodeBool(v *bool) error

DecodeBool reads the next JSON-encoded value from the decoder's input (io.Reader) and stores it in the boolean pointed to by v.

See the documentation for Unmarshal for details about the conversion of JSON into a Go value.

Example
package main

import (
	"fmt"
	"log"
	"strings"

	"github.com/francoispqt/gojay"
)

func main() {
	reader := strings.NewReader(`true`)
	dec := gojay.NewDecoder(reader)

	var b bool
	err := dec.DecodeBool(&b)
	if err != nil {
		log.Fatal(err)
	}

	fmt.Println(b)
}
Output:

true

func (*Decoder) DecodeFloat32

func (dec *Decoder) DecodeFloat32(v *float32) error

DecodeFloat32 reads the next JSON-encoded value from the decoder's input (io.Reader) and stores it in the float32 pointed to by v.

See the documentation for Unmarshal for details about the conversion of JSON into a Go value.

func (*Decoder) DecodeFloat64

func (dec *Decoder) DecodeFloat64(v *float64) error

DecodeFloat64 reads the next JSON-encoded value from the decoder's input (io.Reader) and stores it in the float64 pointed to by v.

See the documentation for Unmarshal for details about the conversion of JSON into a Go value.

func (*Decoder) DecodeInt

func (dec *Decoder) DecodeInt(v *int) error

DecodeInt reads the next JSON-encoded value from the decoder's input (io.Reader) and stores it in the int pointed to by v.

See the documentation for Unmarshal for details about the conversion of JSON into a Go value.

func (*Decoder) DecodeInt16

func (dec *Decoder) DecodeInt16(v *int16) error

DecodeInt16 reads the next JSON-encoded value from the decoder's input (io.Reader) and stores it in the int16 pointed to by v.

See the documentation for Unmarshal for details about the conversion of JSON into a Go value.

func (*Decoder) DecodeInt32

func (dec *Decoder) DecodeInt32(v *int32) error

DecodeInt32 reads the next JSON-encoded value from the decoder's input (io.Reader) and stores it in the int32 pointed to by v.

See the documentation for Unmarshal for details about the conversion of JSON into a Go value.

func (*Decoder) DecodeInt64

func (dec *Decoder) DecodeInt64(v *int64) error

DecodeInt64 reads the next JSON-encoded value from the decoder's input (io.Reader) and stores it in the int64 pointed to by v.

See the documentation for Unmarshal for details about the conversion of JSON into a Go value.

func (*Decoder) DecodeInt8

func (dec *Decoder) DecodeInt8(v *int8) error

DecodeInt8 reads the next JSON-encoded value from the decoder's input (io.Reader) and stores it in the int8 pointed to by v.

See the documentation for Unmarshal for details about the conversion of JSON into a Go value.

func (*Decoder) DecodeInterface

func (dec *Decoder) DecodeInterface(i *interface{}) error

DecodeInterface reads the next JSON-encoded value from the decoder's input (io.Reader) and stores it in the value pointed to by i.

i must be an interface poiter

func (*Decoder) DecodeObject

func (dec *Decoder) DecodeObject(j UnmarshalerJSONObject) error

DecodeObject reads the next JSON-encoded value from the decoder's input (io.Reader) and stores it in the value pointed to by v.

v must implement UnmarshalerJSONObject.

See the documentation for Unmarshal for details about the conversion of JSON into a Go value.

func (*Decoder) DecodeSQLNullBool

func (dec *Decoder) DecodeSQLNullBool(v *sql.NullBool) error

DecodeSQLNullBool decodes a sql.NullString with the given format

func (*Decoder) DecodeSQLNullFloat64

func (dec *Decoder) DecodeSQLNullFloat64(v *sql.NullFloat64) error

DecodeSQLNullFloat64 decodes a sql.NullString with the given format

func (*Decoder) DecodeSQLNullInt64

func (dec *Decoder) DecodeSQLNullInt64(v *sql.NullInt64) error

DecodeSQLNullInt64 decodes a sql.NullInt64

func (*Decoder) DecodeSQLNullString

func (dec *Decoder) DecodeSQLNullString(v *sql.NullString) error

DecodeSQLNullString decodes a sql.NullString

func (*Decoder) DecodeString

func (dec *Decoder) DecodeString(v *string) error

DecodeString reads the next JSON-encoded value from the decoder's input (io.Reader) and stores it in the string pointed to by v.

See the documentation for Unmarshal for details about the conversion of JSON into a Go value.

func (*Decoder) DecodeTime

func (dec *Decoder) DecodeTime(v *time.Time, format string) error

DecodeTime decodes time with the given format

func (*Decoder) DecodeUint16

func (dec *Decoder) DecodeUint16(v *uint16) error

DecodeUint16 reads the next JSON-encoded value from the decoder's input (io.Reader) and stores it in the uint16 pointed to by v.

See the documentation for Unmarshal for details about the conversion of JSON into a Go value.

func (*Decoder) DecodeUint32

func (dec *Decoder) DecodeUint32(v *uint32) error

DecodeUint32 reads the next JSON-encoded value from the decoder's input (io.Reader) and stores it in the uint32 pointed to by v.

See the documentation for Unmarshal for details about the conversion of JSON into a Go value.

func (*Decoder) DecodeUint64

func (dec *Decoder) DecodeUint64(v *uint64) error

DecodeUint64 reads the next JSON-encoded value from the decoder's input (io.Reader) and stores it in the uint64 pointed to by v.

See the documentation for Unmarshal for details about the conversion of JSON into a Go value.

func (*Decoder) DecodeUint8

func (dec *Decoder) DecodeUint8(v *uint8) error

DecodeUint8 reads the next JSON-encoded value from the decoder's input (io.Reader) and stores it in the uint8 pointed to by v.

See the documentation for Unmarshal for details about the conversion of JSON into a Go value.

func (*Decoder) EmbeddedJSON

func (dec *Decoder) EmbeddedJSON(v *EmbeddedJSON) error

EmbeddedJSON adds an EmbeddedsJSON to the value pointed by v. It can be used to delay JSON decoding or precompute a JSON encoding.

func (*Decoder) Float

func (dec *Decoder) Float(v *float64) error

Float decodes the JSON value within an object or an array to a *float64. If next key value overflows float64, an InvalidUnmarshalError error will be returned.

func (*Decoder) Float32

func (dec *Decoder) Float32(v *float32) error

Float32 decodes the JSON value within an object or an array to a *float64. If next key value overflows float64, an InvalidUnmarshalError error will be returned.

func (*Decoder) Float32Null

func (dec *Decoder) Float32Null(v **float32) error

Float32Null decodes the JSON value within an object or an array to a *float64. If next key value overflows float64, an InvalidUnmarshalError error will be returned.

func (*Decoder) Float64

func (dec *Decoder) Float64(v *float64) error

Float64 decodes the JSON value within an object or an array to a *float64. If next key value overflows float64, an InvalidUnmarshalError error will be returned.

func (*Decoder) Float64Null

func (dec *Decoder) Float64Null(v **float64) error

Float64Null decodes the JSON value within an object or an array to a *float64. If next key value overflows float64, an InvalidUnmarshalError error will be returned.

func (*Decoder) FloatNull

func (dec *Decoder) FloatNull(v **float64) error

FloatNull decodes the JSON value within an object or an array to a *float64. If next key value overflows float64, an InvalidUnmarshalError error will be returned.

func (*Decoder) Index

func (dec *Decoder) Index() int

Index returns the index of an array being decoded.

func (*Decoder) Int

func (dec *Decoder) Int(v *int) error

Int decodes the JSON value within an object or an array to an *int. If next key value overflows int, an InvalidUnmarshalError error will be returned.

func (*Decoder) Int16

func (dec *Decoder) Int16(v *int16) error

Int16 decodes the JSON value within an object or an array to an *int. If next key value overflows int16, an InvalidUnmarshalError error will be returned.

func (*Decoder) Int16Null

func (dec *Decoder) Int16Null(v **int16) error

Int16Null decodes the JSON value within an object or an array to an *int. If next key value overflows int16, an InvalidUnmarshalError error will be returned.

func (*Decoder) Int32

func (dec *Decoder) Int32(v *int32) error

Int32 decodes the JSON value within an object or an array to an *int. If next key value overflows int32, an InvalidUnmarshalError error will be returned.

func (*Decoder) Int32Null

func (dec *Decoder) Int32Null(v **int32) error

Int32Null decodes the JSON value within an object or an array to an *int. If next key value overflows int32, an InvalidUnmarshalError error will be returned.

func (*Decoder) Int64

func (dec *Decoder) Int64(v *int64) error

Int64 decodes the JSON value within an object or an array to an *int. If next key value overflows int64, an InvalidUnmarshalError error will be returned.

func (*Decoder) Int64Null

func (dec *Decoder) Int64Null(v **int64) error

Int64Null decodes the JSON value within an object or an array to an *int. If next key value overflows int64, an InvalidUnmarshalError error will be returned.

func (*Decoder) Int8

func (dec *Decoder) Int8(v *int8) error

Int8 decodes the JSON value within an object or an array to an *int. If next key value overflows int8, an InvalidUnmarshalError error will be returned.

func (*Decoder) Int8Null

func (dec *Decoder) Int8Null(v **int8) error

Int8Null decodes the JSON value within an object or an array to an *int. If next key value overflows int8, an InvalidUnmarshalError error will be returned.

func (*Decoder) IntNull

func (dec *Decoder) IntNull(v **int) error

IntNull decodes the JSON value within an object or an array to an *int. If next key value overflows int, an InvalidUnmarshalError error will be returned.

func (*Decoder) Interface

func (dec *Decoder) Interface(value *interface{}) error

Interface decodes the JSON value within an object or an array to an interface{}.

func (*Decoder) Object

func (dec *Decoder) Object(value UnmarshalerJSONObject) error

Object decodes the JSON value within an object or an array to a UnmarshalerJSONObject.

func (*Decoder) ObjectNull

func (dec *Decoder) ObjectNull(v interface{}) error

ObjectNull decodes the JSON value within an object or an array to a UnmarshalerJSONObject. v should be a pointer to an UnmarshalerJSONObject, if `null` value is encountered in JSON, it will leave the value v untouched, else it will create a new instance of the UnmarshalerJSONObject behind v.

func (*Decoder) Release

func (dec *Decoder) Release()

Release sends back a Decoder to the pool. If a decoder is used after calling Release a panic will be raised with an InvalidUsagePooledDecoderError error.

func (*Decoder) SQLNullBool

func (dec *Decoder) SQLNullBool(v *sql.NullBool) error

SQLNullBool decodes the JSON value within an object or an array to an *sql.NullBool

func (*Decoder) SQLNullFloat64

func (dec *Decoder) SQLNullFloat64(v *sql.NullFloat64) error

SQLNullFloat64 decodes the JSON value within an object or an array to an *sql.NullFloat64

func (*Decoder) SQLNullInt64

func (dec *Decoder) SQLNullInt64(v *sql.NullInt64) error

SQLNullInt64 decodes the JSON value within an object or an array to an *sql.NullInt64

func (*Decoder) SQLNullString

func (dec *Decoder) SQLNullString(v *sql.NullString) error

SQLNullString decodes the JSON value within an object or an array to an *sql.NullString

func (*Decoder) SliceBool

func (dec *Decoder) SliceBool(s *[]bool) error

SliceBool unmarshals the next JSON array of boolegers to the given *[]bool s

func (*Decoder) SliceFloat64

func (dec *Decoder) SliceFloat64(s *[]float64) error

SliceFloat64 unmarshals the next JSON array of floats to the given *[]float64 s

func (*Decoder) SliceInt

func (dec *Decoder) SliceInt(s *[]int) error

SliceInt unmarshals the next JSON array of integers to the given *[]int s

func (*Decoder) SliceString

func (dec *Decoder) SliceString(s *[]string) error

SliceString unmarshals the next JSON array of strings to the given *[]string s

func (*Decoder) String

func (dec *Decoder) String(v *string) error

String decodes the JSON value within an object or an array to a *string. If next key is not a JSON string nor null, InvalidUnmarshalError will be returned.

func (*Decoder) StringNull

func (dec *Decoder) StringNull(v **string) error

StringNull decodes the JSON value within an object or an array to a **string. If next key is not a JSON string nor null, InvalidUnmarshalError will be returned. If a `null` is encountered, gojay does not change the value of the pointer.

func (*Decoder) Time

func (dec *Decoder) Time(v *time.Time, format string) error

Time decodes the JSON value within an object or an array to a *time.Time with the given format

func (*Decoder) Uint16

func (dec *Decoder) Uint16(v *uint16) error

Uint16 decodes the JSON value within an object or an array to an *int. If next key value overflows uint16, an InvalidUnmarshalError error will be returned.

func (*Decoder) Uint16Null

func (dec *Decoder) Uint16Null(v **uint16) error

Uint16Null decodes the JSON value within an object or an array to an *int. If next key value overflows uint16, an InvalidUnmarshalError error will be returned.

func (*Decoder) Uint32

func (dec *Decoder) Uint32(v *uint32) error

Uint32 decodes the JSON value within an object or an array to an *int. If next key value overflows uint32, an InvalidUnmarshalError error will be returned.

func (*Decoder) Uint32Null

func (dec *Decoder) Uint32Null(v **uint32) error

Uint32Null decodes the JSON value within an object or an array to an *int. If next key value overflows uint32, an InvalidUnmarshalError error will be returned.

func (*Decoder) Uint64

func (dec *Decoder) Uint64(v *uint64) error

Uint64 decodes the JSON value within an object or an array to an *int. If next key value overflows uint64, an InvalidUnmarshalError error will be returned.

func (*Decoder) Uint64Null

func (dec *Decoder) Uint64Null(v **uint64) error

Uint64Null decodes the JSON value within an object or an array to an *int. If next key value overflows uint64, an InvalidUnmarshalError error will be returned.

func (*Decoder) Uint8

func (dec *Decoder) Uint8(v *uint8) error

Uint8 decodes the JSON value within an object or an array to an *int. If next key value overflows uint8, an InvalidUnmarshalError error will be returned.

func (*Decoder) Uint8Null

func (dec *Decoder) Uint8Null(v **uint8) error

Uint8Null decodes the JSON value within an object or an array to an *int. If next key value overflows uint8, an InvalidUnmarshalError error will be returned.

type EmbeddedJSON

type EmbeddedJSON []byte

EmbeddedJSON is a raw encoded JSON value. It can be used to delay JSON decoding or precompute a JSON encoding.

type EncodeArrayFunc

type EncodeArrayFunc func(*Encoder)

EncodeArrayFunc is a custom func type implementing MarshaleArray. Use it to cast a func(*Encoder) to Marshal an object.

enc := gojay.NewEncoder(io.Writer)
enc.EncodeArray(gojay.EncodeArrayFunc(func(enc *gojay.Encoder) {
	enc.AddStringKey("hello", "world")
}))

func (EncodeArrayFunc) IsNil

func (f EncodeArrayFunc) IsNil() bool

IsNil implements MarshalerJSONArray.

func (EncodeArrayFunc) MarshalJSONArray

func (f EncodeArrayFunc) MarshalJSONArray(enc *Encoder)

MarshalJSONArray implements MarshalerJSONArray.

type EncodeObjectFunc

type EncodeObjectFunc func(*Encoder)

EncodeObjectFunc is a custom func type implementing MarshaleObject. Use it to cast a func(*Encoder) to Marshal an object.

enc := gojay.NewEncoder(io.Writer)
enc.EncodeObject(gojay.EncodeObjectFunc(func(enc *gojay.Encoder) {
	enc.AddStringKey("hello", "world")
}))

func (EncodeObjectFunc) IsNil

func (f EncodeObjectFunc) IsNil() bool

IsNil implements MarshalerJSONObject.

func (EncodeObjectFunc) MarshalJSONObject

func (f EncodeObjectFunc) MarshalJSONObject(enc *Encoder)

MarshalJSONObject implements MarshalerJSONObject.

type Encoder

type Encoder struct {
	// contains filtered or unexported fields
}

An Encoder writes JSON values to an output stream.

func BorrowEncoder

func BorrowEncoder(w io.Writer) *Encoder

BorrowEncoder borrows an Encoder from the pool.

Example
package main

import (
	"log"
	"os"

	"github.com/francoispqt/gojay"
)

func main() {
	enc := gojay.BorrowEncoder(os.Stdout)
	defer enc.Release()

	var str = "gojay"
	err := enc.EncodeString(str)
	if err != nil {
		log.Fatal(err)
	}
}
Output:

"gojay"

func NewEncoder

func NewEncoder(w io.Writer) *Encoder

NewEncoder returns a new encoder or borrows one from the pool

Example
package main

import (
	"log"
	"os"

	"github.com/francoispqt/gojay"
)

func main() {
	enc := gojay.BorrowEncoder(os.Stdout)

	var str = "gojay"
	err := enc.EncodeString(str)
	if err != nil {
		log.Fatal(err)
	}
}
Output:

"gojay"

func (*Encoder) AddArray

func (enc *Encoder) AddArray(v MarshalerJSONArray)

AddArray adds an implementation of MarshalerJSONArray to be encoded, must be used inside a slice or array encoding (does not encode a key) value must implement Marshaler

func (*Encoder) AddArrayKey

func (enc *Encoder) AddArrayKey(key string, v MarshalerJSONArray)

AddArrayKey adds an array or slice to be encoded, must be used inside an object as it will encode a key value must implement Marshaler

func (*Encoder) AddArrayKeyNullEmpty

func (enc *Encoder) AddArrayKeyNullEmpty(key string, v MarshalerJSONArray)

AddArrayKeyNullEmpty adds an array or slice to be encoded and skips it if it is nil. Must be called inside an object as it will encode a key. `null` will be encoded`

func (*Encoder) AddArrayKeyOmitEmpty

func (enc *Encoder) AddArrayKeyOmitEmpty(key string, v MarshalerJSONArray)

AddArrayKeyOmitEmpty adds an array or slice to be encoded and skips it if it is nil. Must be called inside an object as it will encode a key.

func (*Encoder) AddArrayNullEmpty

func (enc *Encoder) AddArrayNullEmpty(v MarshalerJSONArray)

AddArrayNullEmpty adds an array or slice to be encoded, must be used inside a slice or array encoding (does not encode a key) value must implement Marshaler, if v is empty, `null` will be encoded`

func (*Encoder) AddArrayOmitEmpty

func (enc *Encoder) AddArrayOmitEmpty(v MarshalerJSONArray)

AddArrayOmitEmpty adds an array or slice to be encoded, must be used inside a slice or array encoding (does not encode a key) value must implement MarshalerAddArrayOmitEmpty

func (*Encoder) AddBool

func (enc *Encoder) AddBool(v bool)

AddBool adds a bool to be encoded, must be used inside a slice or array encoding (does not encode a key)

func (*Encoder) AddBoolKey

func (enc *Encoder) AddBoolKey(key string, v bool)

AddBoolKey adds a bool to be encoded, must be used inside an object as it will encode a key.

func (*Encoder) AddBoolKeyNullEmpty

func (enc *Encoder) AddBoolKeyNullEmpty(key string, v bool)

AddBoolKeyNullEmpty adds a bool to be encoded and encodes `null` if it is zero value. Must be used inside an object as it will encode a key.

func (*Encoder) AddBoolKeyOmitEmpty

func (enc *Encoder) AddBoolKeyOmitEmpty(key string, v bool)

AddBoolKeyOmitEmpty adds a bool to be encoded and skips if it is zero value. Must be used inside an object as it will encode a key.

func (*Encoder) AddBoolNullEmpty

func (enc *Encoder) AddBoolNullEmpty(v bool)

AddBoolNullEmpty adds a bool to be encoded, must be used inside a slice or array encoding (does not encode a key)

func (*Encoder) AddBoolOmitEmpty

func (enc *Encoder) AddBoolOmitEmpty(v bool)

AddBoolOmitEmpty adds a bool to be encoded, must be used inside a slice or array encoding (does not encode a key)

func (*Encoder) AddEmbeddedJSON

func (enc *Encoder) AddEmbeddedJSON(v *EmbeddedJSON)

AddEmbeddedJSON adds an EmbeddedJSON to be encoded.

It basically blindly writes the bytes to the final buffer. Therefore, it expects the JSON to be of proper format.

func (*Encoder) AddEmbeddedJSONKey

func (enc *Encoder) AddEmbeddedJSONKey(key string, v *EmbeddedJSON)

AddEmbeddedJSONKey adds an EmbeddedJSON and a key to be encoded.

It basically blindly writes the bytes to the final buffer. Therefore, it expects the JSON to be of proper format.

func (*Encoder) AddEmbeddedJSONKeyOmitEmpty

func (enc *Encoder) AddEmbeddedJSONKeyOmitEmpty(key string, v *EmbeddedJSON)

AddEmbeddedJSONKeyOmitEmpty adds an EmbeddedJSON and a key to be encoded or skips it if nil pointer or empty.

It basically blindly writes the bytes to the final buffer. Therefore, it expects the JSON to be of proper format.

func (*Encoder) AddEmbeddedJSONOmitEmpty

func (enc *Encoder) AddEmbeddedJSONOmitEmpty(v *EmbeddedJSON)

AddEmbeddedJSONOmitEmpty adds an EmbeddedJSON to be encoded or skips it if nil pointer or empty.

It basically blindly writes the bytes to the final buffer. Therefore, it expects the JSON to be of proper format.

func (*Encoder) AddFloat

func (enc *Encoder) AddFloat(v float64)

AddFloat adds a float64 to be encoded, must be used inside a slice or array encoding (does not encode a key)

func (*Encoder) AddFloat32

func (enc *Encoder) AddFloat32(v float32)

AddFloat32 adds a float32 to be encoded, must be used inside a slice or array encoding (does not encode a key)

func (*Encoder) AddFloat32Key

func (enc *Encoder) AddFloat32Key(key string, v float32)

AddFloat32Key adds a float32 to be encoded, must be used inside an object as it will encode a key

func (*Encoder) AddFloat32KeyNullEmpty

func (enc *Encoder) AddFloat32KeyNullEmpty(key string, v float32)

AddFloat32KeyNullEmpty adds a float64 to be encoded and skips it if its value is 0. Must be used inside an object as it will encode a key

func (*Encoder) AddFloat32KeyOmitEmpty

func (enc *Encoder) AddFloat32KeyOmitEmpty(key string, v float32)

AddFloat32KeyOmitEmpty adds a float64 to be encoded and skips it if its value is 0. Must be used inside an object as it will encode a key

func (*Encoder) AddFloat32NullEmpty

func (enc *Encoder) AddFloat32NullEmpty(v float32)

AddFloat32NullEmpty adds an int to be encoded and skips it if its value is 0, must be used inside a slice or array encoding (does not encode a key).

func (*Encoder) AddFloat32OmitEmpty

func (enc *Encoder) AddFloat32OmitEmpty(v float32)

AddFloat32OmitEmpty adds an int to be encoded and skips it if its value is 0, must be used inside a slice or array encoding (does not encode a key).

func (*Encoder) AddFloat64

func (enc *Encoder) AddFloat64(v float64)

AddFloat64 adds a float64 to be encoded, must be used inside a slice or array encoding (does not encode a key)

func (*Encoder) AddFloat64Key

func (enc *Encoder) AddFloat64Key(key string, v float64)

AddFloat64Key adds a float64 to be encoded, must be used inside an object as it will encode a key

func (*Encoder) AddFloat64KeyOmitEmpty

func (enc *Encoder) AddFloat64KeyOmitEmpty(key string, v float64)

AddFloat64KeyOmitEmpty adds a float64 to be encoded and skips it if its value is 0. Must be used inside an object as it will encode a key

func (*Encoder) AddFloat64OmitEmpty

func (enc *Encoder) AddFloat64OmitEmpty(v float64)

AddFloat64OmitEmpty adds a float64 to be encoded and skips it if its value is 0, must be used inside a slice or array encoding (does not encode a key).

func (*Encoder) AddFloatKey

func (enc *Encoder) AddFloatKey(key string, v float64)

AddFloatKey adds a float64 to be encoded, must be used inside an object as it will encode a key

func (*Encoder) AddFloatKeyNullEmpty

func (enc *Encoder) AddFloatKeyNullEmpty(key string, v float64)

AddFloatKeyNullEmpty adds a float64 to be encoded and skips it if its value is 0. Must be used inside an object as it will encode a key

func (*Encoder) AddFloatKeyOmitEmpty

func (enc *Encoder) AddFloatKeyOmitEmpty(key string, v float64)

AddFloatKeyOmitEmpty adds a float64 to be encoded and skips it if its value is 0. Must be used inside an object as it will encode a key

func (*Encoder) AddFloatNullEmpty

func (enc *Encoder) AddFloatNullEmpty(v float64)

AddFloatNullEmpty adds a float64 to be encoded and skips it if its value is 0, must be used inside a slice or array encoding (does not encode a key).

func (*Encoder) AddFloatOmitEmpty

func (enc *Encoder) AddFloatOmitEmpty(v float64)

AddFloatOmitEmpty adds a float64 to be encoded and skips it if its value is 0, must be used inside a slice or array encoding (does not encode a key).

func (*Encoder) AddInt

func (enc *Encoder) AddInt(v int)

AddInt adds an int to be encoded, must be used inside a slice or array encoding (does not encode a key)

func (*Encoder) AddInt16

func (enc *Encoder) AddInt16(v int16)

AddInt16 adds an int to be encoded, must be used inside a slice or array encoding (does not encode a key)

func (*Encoder) AddInt16Key

func (enc *Encoder) AddInt16Key(key string, v int16)

AddInt16Key adds an int16 to be encoded, must be used inside an object as it will encode a key

func (*Encoder) AddInt16KeyNullEmpty

func (enc *Encoder) AddInt16KeyNullEmpty(key string, v int16)

AddInt16KeyNullEmpty adds an int16 to be encoded and skips it if its value is 0. Must be used inside an object as it will encode a key.

func (*Encoder) AddInt16KeyOmitEmpty

func (enc *Encoder) AddInt16KeyOmitEmpty(key string, v int16)

AddInt16KeyOmitEmpty adds an int16 to be encoded and skips it if its value is 0. Must be used inside an object as it will encode a key.

func (*Encoder) AddInt16OmitEmpty

func (enc *Encoder) AddInt16OmitEmpty(v int16)

AddInt16OmitEmpty adds an int to be encoded and skips it if its value is 0, must be used inside a slice or array encoding (does not encode a key).

func (*Encoder) AddInt32

func (enc *Encoder) AddInt32(v int32)

AddInt32 adds an int to be encoded, must be used inside a slice or array encoding (does not encode a key)

func (*Encoder) AddInt32Key

func (enc *Encoder) AddInt32Key(key string, v int32)

AddInt32Key adds an int32 to be encoded, must be used inside an object as it will encode a key

func (*Encoder) AddInt32KeyOmitEmpty

func (enc *Encoder) AddInt32KeyOmitEmpty(key string, v int32)

AddInt32KeyOmitEmpty adds an int32 to be encoded and skips it if its value is 0. Must be used inside an object as it will encode a key.

func (*Encoder) AddInt32NullEmpty

func (enc *Encoder) AddInt32NullEmpty(v int32)

AddInt32NullEmpty adds an int to be encoded and skips it if its value is 0, must be used inside a slice or array encoding (does not encode a key).

func (*Encoder) AddInt32OmitEmpty

func (enc *Encoder) AddInt32OmitEmpty(v int32)

AddInt32OmitEmpty adds an int to be encoded and skips it if its value is 0, must be used inside a slice or array encoding (does not encode a key).

func (*Encoder) AddInt64

func (enc *Encoder) AddInt64(v int64)

AddInt64 adds an int to be encoded, must be used inside a slice or array encoding (does not encode a key)

func (*Encoder) AddInt64Key

func (enc *Encoder) AddInt64Key(key string, v int64)

AddInt64Key adds an int64 to be encoded, must be used inside an object as it will encode a key

func (*Encoder) AddInt64KeyNullEmpty

func (enc *Encoder) AddInt64KeyNullEmpty(key string, v int64)

AddInt64KeyNullEmpty adds an int64 to be encoded and skips it if its value is 0. Must be used inside an object as it will encode a key.

func (*Encoder) AddInt64KeyOmitEmpty

func (enc *Encoder) AddInt64KeyOmitEmpty(key string, v int64)

AddInt64KeyOmitEmpty adds an int64 to be encoded and skips it if its value is 0. Must be used inside an object as it will encode a key.

func (*Encoder) AddInt64NullEmpty

func (enc *Encoder) AddInt64NullEmpty(v int64)

AddInt64NullEmpty adds an int to be encoded and skips it if its value is 0, must be used inside a slice or array encoding (does not encode a key).

func (*Encoder) AddInt64OmitEmpty

func (enc *Encoder) AddInt64OmitEmpty(v int64)

AddInt64OmitEmpty adds an int to be encoded and skips it if its value is 0, must be used inside a slice or array encoding (does not encode a key).

func (*Encoder) AddInt8

func (enc *Encoder) AddInt8(v int8)

AddInt8 adds an int to be encoded, must be used inside a slice or array encoding (does not encode a key)

func (*Encoder) AddInt8Key

func (enc *Encoder) AddInt8Key(key string, v int8)

AddInt8Key adds an int8 to be encoded, must be used inside an object as it will encode a key

func (*Encoder) AddInt8KeyNullEmpty

func (enc *Encoder) AddInt8KeyNullEmpty(key string, v int8)

AddInt8KeyNullEmpty adds an int8 to be encoded and skips it if its value is 0. Must be used inside an object as it will encode a key.

func (*Encoder) AddInt8KeyOmitEmpty

func (enc *Encoder) AddInt8KeyOmitEmpty(key string, v int8)

AddInt8KeyOmitEmpty adds an int8 to be encoded and skips it if its value is 0. Must be used inside an object as it will encode a key.

func (*Encoder) AddInt8NullEmpty

func (enc *Encoder) AddInt8NullEmpty(v int8)

AddInt8NullEmpty adds an int to be encoded and skips it if its value is 0, must be used inside a slice or array encoding (does not encode a key).

func (*Encoder) AddInt8OmitEmpty

func (enc *Encoder) AddInt8OmitEmpty(v int8)

AddInt8OmitEmpty adds an int to be encoded and skips it if its value is 0, must be used inside a slice or array encoding (does not encode a key).

func (*Encoder) AddIntKey

func (enc *Encoder) AddIntKey(key string, v int)

AddIntKey adds an int to be encoded, must be used inside an object as it will encode a key

func (*Encoder) AddIntKeyNullEmpty

func (enc *Encoder) AddIntKeyNullEmpty(key string, v int)

AddIntKeyNullEmpty adds an int to be encoded and skips it if its value is 0. Must be used inside an object as it will encode a key.

func (*Encoder) AddIntKeyOmitEmpty

func (enc *Encoder) AddIntKeyOmitEmpty(key string, v int)

AddIntKeyOmitEmpty adds an int to be encoded and skips it if its value is 0. Must be used inside an object as it will encode a key.

func (*Encoder) AddIntNullEmpty

func (enc *Encoder) AddIntNullEmpty(v int)

AddIntNullEmpty adds an int to be encoded and skips it if its value is 0, must be used inside a slice or array encoding (does not encode a key).

func (*Encoder) AddIntOmitEmpty

func (enc *Encoder) AddIntOmitEmpty(v int)

AddIntOmitEmpty adds an int to be encoded and skips it if its value is 0, must be used inside a slice or array encoding (does not encode a key).

func (*Encoder) AddInterface

func (enc *Encoder) AddInterface(value interface{})

AddInterface adds an interface{} to be encoded, must be used inside a slice or array encoding (does not encode a key)

func (*Encoder) AddInterfaceKey

func (enc *Encoder) AddInterfaceKey(key string, value interface{})

AddInterfaceKey adds an interface{} to be encoded, must be used inside an object as it will encode a key

func (*Encoder) AddInterfaceKeyOmitEmpty

func (enc *Encoder) AddInterfaceKeyOmitEmpty(key string, v interface{})

AddInterfaceKeyOmitEmpty adds an interface{} to be encoded, must be used inside an object as it will encode a key

func (*Encoder) AddNull

func (enc *Encoder) AddNull()

AddNull adds a `null` to be encoded. Must be used while encoding an array.`

func (*Encoder) AddNullKey

func (enc *Encoder) AddNullKey(key string)

AddNullKey adds a `null` to be encoded. Must be used while encoding an array.`

func (*Encoder) AddObject

func (enc *Encoder) AddObject(v MarshalerJSONObject)

AddObject adds an object to be encoded, must be used inside a slice or array encoding (does not encode a key) value must implement MarshalerJSONObject

func (*Encoder) AddObjectKey

func (enc *Encoder) AddObjectKey(key string, v MarshalerJSONObject)

AddObjectKey adds a struct to be encoded, must be used inside an object as it will encode a key value must implement MarshalerJSONObject

func (*Encoder) AddObjectKeyNullEmpty

func (enc *Encoder) AddObjectKeyNullEmpty(key string, v MarshalerJSONObject)

AddObjectKeyNullEmpty adds an object to be encoded or skips it if IsNil returns true. Must be used inside a slice or array encoding (does not encode a key) value must implement MarshalerJSONObject

func (*Encoder) AddObjectKeyOmitEmpty

func (enc *Encoder) AddObjectKeyOmitEmpty(key string, v MarshalerJSONObject)

AddObjectKeyOmitEmpty adds an object to be encoded or skips it if IsNil returns true. Must be used inside a slice or array encoding (does not encode a key) value must implement MarshalerJSONObject

func (*Encoder) AddObjectNullEmpty

func (enc *Encoder) AddObjectNullEmpty(v MarshalerJSONObject)

AddObjectNullEmpty adds an object to be encoded or skips it if IsNil returns true. Must be used inside a slice or array encoding (does not encode a key) value must implement MarshalerJSONObject

func (*Encoder) AddObjectOmitEmpty

func (enc *Encoder) AddObjectOmitEmpty(v MarshalerJSONObject)

AddObjectOmitEmpty adds an object to be encoded or skips it if IsNil returns true. Must be used inside a slice or array encoding (does not encode a key) value must implement MarshalerJSONObject

func (*Encoder) AddSQLNullBool

func (enc *Encoder) AddSQLNullBool(v *sql.NullBool)

AddSQLNullBool adds a string to be encoded, must be used inside a slice or array encoding (does not encode a key)

func (*Encoder) AddSQLNullBoolKey

func (enc *Encoder) AddSQLNullBoolKey(key string, v *sql.NullBool)

AddSQLNullBoolKey adds a string to be encoded, must be used inside an object as it will encode a key

func (*Encoder) AddSQLNullBoolKeyNullEmpty

func (enc *Encoder) AddSQLNullBoolKeyNullEmpty(key string, v *sql.NullBool)

AddSQLNullBoolKeyNullEmpty adds a string to be encoded or skips it if it is zero value. Must be used inside an object as it will encode a key

func (*Encoder) AddSQLNullBoolKeyOmitEmpty

func (enc *Encoder) AddSQLNullBoolKeyOmitEmpty(key string, v *sql.NullBool)

AddSQLNullBoolKeyOmitEmpty adds a string to be encoded or skips it if it is zero value. Must be used inside an object as it will encode a key

func (*Encoder) AddSQLNullBoolOmitEmpty

func (enc *Encoder) AddSQLNullBoolOmitEmpty(v *sql.NullBool)

AddSQLNullBoolOmitEmpty adds a string to be encoded or skips it if it is zero value. Must be used inside a slice or array encoding (does not encode a key)

func (*Encoder) AddSQLNullFloat64

func (enc *Encoder) AddSQLNullFloat64(v *sql.NullFloat64)

AddSQLNullFloat64 adds a string to be encoded, must be used inside a slice or array encoding (does not encode a key)

func (*Encoder) AddSQLNullFloat64Key

func (enc *Encoder) AddSQLNullFloat64Key(key string, v *sql.NullFloat64)

AddSQLNullFloat64Key adds a string to be encoded, must be used inside an object as it will encode a key

func (*Encoder) AddSQLNullFloat64KeyNullEmpty

func (enc *Encoder) AddSQLNullFloat64KeyNullEmpty(key string, v *sql.NullFloat64)

AddSQLNullFloat64KeyNullEmpty adds a string to be encoded or skips it if it is zero value. Must be used inside an object as it will encode a key

func (*Encoder) AddSQLNullFloat64KeyOmitEmpty

func (enc *Encoder) AddSQLNullFloat64KeyOmitEmpty(key string, v *sql.NullFloat64)

AddSQLNullFloat64KeyOmitEmpty adds a string to be encoded or skips it if it is zero value. Must be used inside an object as it will encode a key

func (*Encoder) AddSQLNullFloat64NullEmpty

func (enc *Encoder) AddSQLNullFloat64NullEmpty(v *sql.NullFloat64)

AddSQLNullFloat64NullEmpty adds a string to be encoded or skips it if it is zero value. Must be used inside a slice or array encoding (does not encode a key)

func (*Encoder) AddSQLNullFloat64OmitEmpty

func (enc *Encoder) AddSQLNullFloat64OmitEmpty(v *sql.NullFloat64)

AddSQLNullFloat64OmitEmpty adds a string to be encoded or skips it if it is zero value. Must be used inside a slice or array encoding (does not encode a key)

func (*Encoder) AddSQLNullInt64

func (enc *Encoder) AddSQLNullInt64(v *sql.NullInt64)

AddSQLNullInt64 adds a string to be encoded, must be used inside a slice or array encoding (does not encode a key)

func (*Encoder) AddSQLNullInt64Key

func (enc *Encoder) AddSQLNullInt64Key(key string, v *sql.NullInt64)

AddSQLNullInt64Key adds a string to be encoded, must be used inside an object as it will encode a key

func (*Encoder) AddSQLNullInt64KeyNullEmpty

func (enc *Encoder) AddSQLNullInt64KeyNullEmpty(key string, v *sql.NullInt64)

AddSQLNullInt64KeyNullEmpty adds a string to be encoded or skips it if it is zero value. Must be used inside an object as it will encode a key

func (*Encoder) AddSQLNullInt64KeyOmitEmpty

func (enc *Encoder) AddSQLNullInt64KeyOmitEmpty(key string, v *sql.NullInt64)

AddSQLNullInt64KeyOmitEmpty adds a string to be encoded or skips it if it is zero value. Must be used inside an object as it will encode a key

func (*Encoder) AddSQLNullInt64NullEmpty

func (enc *Encoder) AddSQLNullInt64NullEmpty(v *sql.NullInt64)

AddSQLNullInt64NullEmpty adds a string to be encoded or skips it if it is zero value. Must be used inside a slice or array encoding (does not encode a key)

func (*Encoder) AddSQLNullInt64OmitEmpty

func (enc *Encoder) AddSQLNullInt64OmitEmpty(v *sql.NullInt64)

AddSQLNullInt64OmitEmpty adds a string to be encoded or skips it if it is zero value. Must be used inside a slice or array encoding (does not encode a key)

func (*Encoder) AddSQLNullString

func (enc *Encoder) AddSQLNullString(v *sql.NullString)

AddSQLNullString adds a string to be encoded, must be used inside a slice or array encoding (does not encode a key)

func (*Encoder) AddSQLNullStringKey

func (enc *Encoder) AddSQLNullStringKey(key string, v *sql.NullString)

AddSQLNullStringKey adds a string to be encoded, must be used inside an object as it will encode a key

func (*Encoder) AddSQLNullStringKeyOmitEmpty

func (enc *Encoder) AddSQLNullStringKeyOmitEmpty(key string, v *sql.NullString)

AddSQLNullStringKeyOmitEmpty adds a string to be encoded or skips it if it is zero value. Must be used inside an object as it will encode a key

func (*Encoder) AddSQLNullStringNullEmpty

func (enc *Encoder) AddSQLNullStringNullEmpty(v *sql.NullString)

AddSQLNullStringNullEmpty adds a string to be encoded or skips it if it is zero value. Must be used inside a slice or array encoding (does not encode a key)

func (*Encoder) AddSQLNullStringOmitEmpty

func (enc *Encoder) AddSQLNullStringOmitEmpty(v *sql.NullString)

AddSQLNullStringOmitEmpty adds a string to be encoded or skips it if it is zero value. Must be used inside a slice or array encoding (does not encode a key)

func (*Encoder) AddSliceBool

func (enc *Encoder) AddSliceBool(s []bool)

AddSliceBool marshals the given []bool s

func (*Encoder) AddSliceBoolKey

func (enc *Encoder) AddSliceBoolKey(k string, s []bool)

AddSliceBoolKey marshals the given []bool s

func (*Encoder) AddSliceFloat64

func (enc *Encoder) AddSliceFloat64(s []float64)

AddSliceFloat64 marshals the given []float64 s

func (*Encoder) AddSliceFloat64Key

func (enc *Encoder) AddSliceFloat64Key(k string, s []float64)

AddSliceFloat64Key marshals the given []float64 s

func (*Encoder) AddSliceInt

func (enc *Encoder) AddSliceInt(s []int)

AddSliceInt marshals the given []int s

func (*Encoder) AddSliceIntKey

func (enc *Encoder) AddSliceIntKey(k string, s []int)

AddSliceIntKey marshals the given []int s

func (*Encoder) AddSliceString

func (enc *Encoder) AddSliceString(s []string)

AddSliceString marshals the given []string s

func (*Encoder) AddSliceStringKey

func (enc *Encoder) AddSliceStringKey(k string, s []string)

AddSliceStringKey marshals the given []string s

func (*Encoder) AddString

func (enc *Encoder) AddString(v string)

AddString adds a string to be encoded, must be used inside a slice or array encoding (does not encode a key)

func (*Encoder) AddStringKey

func (enc *Encoder) AddStringKey(key, v string)

AddStringKey adds a string to be encoded, must be used inside an object as it will encode a key

func (*Encoder) AddStringKeyNullEmpty

func (enc *Encoder) AddStringKeyNullEmpty(key, v string)

AddStringKeyNullEmpty adds a string to be encoded or skips it if it is zero value. Must be used inside an object as it will encode a key

func (*Encoder) AddStringKeyOmitEmpty

func (enc *Encoder) AddStringKeyOmitEmpty(key, v string)

AddStringKeyOmitEmpty adds a string to be encoded or skips it if it is zero value. Must be used inside an object as it will encode a key

func (*Encoder) AddStringNullEmpty

func (enc *Encoder) AddStringNullEmpty(v string)

AddStringNullEmpty adds a string to be encoded or skips it if it is zero value. Must be used inside a slice or array encoding (does not encode a key)

func (*Encoder) AddStringOmitEmpty

func (enc *Encoder) AddStringOmitEmpty(v string)

AddStringOmitEmpty adds a string to be encoded or skips it if it is zero value. Must be used inside a slice or array encoding (does not encode a key)

func (*Encoder) AddTime

func (enc *Encoder) AddTime(t *time.Time, format string)

AddTime adds an *time.Time to be encoded with the given format, must be used inside a slice or array encoding (does not encode a key)

func (*Encoder) AddTimeKey

func (enc *Encoder) AddTimeKey(key string, t *time.Time, format string)

AddTimeKey adds an *time.Time to be encoded with the given format, must be used inside an object as it will encode a key

func (*Encoder) AddUint16

func (enc *Encoder) AddUint16(v uint16)

AddUint16 adds an int to be encoded, must be used inside a slice or array encoding (does not encode a key)

func (*Encoder) AddUint16Key

func (enc *Encoder) AddUint16Key(key string, v uint16)

AddUint16Key adds an int to be encoded, must be used inside an object as it will encode a key

func (*Encoder) AddUint16KeyNullEmpty

func (enc *Encoder) AddUint16KeyNullEmpty(key string, v uint16)

AddUint16KeyNullEmpty adds an int to be encoded and skips it if its value is 0. Must be used inside an object as it will encode a key.

func (*Encoder) AddUint16KeyOmitEmpty

func (enc *Encoder) AddUint16KeyOmitEmpty(key string, v uint16)

AddUint16KeyOmitEmpty adds an int to be encoded and skips it if its value is 0. Must be used inside an object as it will encode a key.

func (*Encoder) AddUint16NullEmpty

func (enc *Encoder) AddUint16NullEmpty(v uint16)

AddUint16NullEmpty adds an int to be encoded and skips it if its value is 0, must be used inside a slice or array encoding (does not encode a key).

func (*Encoder) AddUint16OmitEmpty

func (enc *Encoder) AddUint16OmitEmpty(v uint16)

AddUint16OmitEmpty adds an int to be encoded and skips it if its value is 0, must be used inside a slice or array encoding (does not encode a key).

func (*Encoder) AddUint32

func (enc *Encoder) AddUint32(v uint32)

AddUint32 adds an int to be encoded, must be used inside a slice or array encoding (does not encode a key)

func (*Encoder) AddUint32Key

func (enc *Encoder) AddUint32Key(key string, v uint32)

AddUint32Key adds an int to be encoded, must be used inside an object as it will encode a key

func (*Encoder) AddUint32KeyNullEmpty

func (enc *Encoder) AddUint32KeyNullEmpty(key string, v uint32)

AddUint32KeyNullEmpty adds an int to be encoded and skips it if its value is 0. Must be used inside an object as it will encode a key.

func (*Encoder) AddUint32KeyOmitEmpty

func (enc *Encoder) AddUint32KeyOmitEmpty(key string, v uint32)

AddUint32KeyOmitEmpty adds an int to be encoded and skips it if its value is 0. Must be used inside an object as it will encode a key.

func (*Encoder) AddUint32NullEmpty

func (enc *Encoder) AddUint32NullEmpty(v uint32)

AddUint32NullEmpty adds an int to be encoded and skips it if its value is 0, must be used inside a slice or array encoding (does not encode a key).

func (*Encoder) AddUint32OmitEmpty

func (enc *Encoder) AddUint32OmitEmpty(v uint32)

AddUint32OmitEmpty adds an int to be encoded and skips it if its value is 0, must be used inside a slice or array encoding (does not encode a key).

func (*Encoder) AddUint64

func (enc *Encoder) AddUint64(v uint64)

AddUint64 adds an int to be encoded, must be used inside a slice or array encoding (does not encode a key)

func (*Encoder) AddUint64Key

func (enc *Encoder) AddUint64Key(key string, v uint64)

AddUint64Key adds an int to be encoded, must be used inside an object as it will encode a key

func (*Encoder) AddUint64KeyNullEmpty

func (enc *Encoder) AddUint64KeyNullEmpty(key string, v uint64)

AddUint64KeyNullEmpty adds an int to be encoded and skips it if its value is 0. Must be used inside an object as it will encode a key.

func (*Encoder) AddUint64KeyOmitEmpty

func (enc *Encoder) AddUint64KeyOmitEmpty(key string, v uint64)

AddUint64KeyOmitEmpty adds an int to be encoded and skips it if its value is 0. Must be used inside an object as it will encode a key.

func (*Encoder) AddUint64NullEmpty

func (enc *Encoder) AddUint64NullEmpty(v uint64)

AddUint64NullEmpty adds an int to be encoded and skips it if its value is 0, must be used inside a slice or array encoding (does not encode a key).

func (*Encoder) AddUint64OmitEmpty

func (enc *Encoder) AddUint64OmitEmpty(v uint64)

AddUint64OmitEmpty adds an int to be encoded and skips it if its value is 0, must be used inside a slice or array encoding (does not encode a key).

func (*Encoder) AddUint8

func (enc *Encoder) AddUint8(v uint8)

AddUint8 adds an int to be encoded, must be used inside a slice or array encoding (does not encode a key)

func (*Encoder) AddUint8Key

func (enc *Encoder) AddUint8Key(key string, v uint8)

AddUint8Key adds an int to be encoded, must be used inside an object as it will encode a key

func (*Encoder) AddUint8KeyNullEmpty

func (enc *Encoder) AddUint8KeyNullEmpty(key string, v uint8)

AddUint8KeyNullEmpty adds an int to be encoded and skips it if its value is 0. Must be used inside an object as it will encode a key.

func (*Encoder) AddUint8KeyOmitEmpty

func (enc *Encoder) AddUint8KeyOmitEmpty(key string, v uint8)

AddUint8KeyOmitEmpty adds an int to be encoded and skips it if its value is 0. Must be used inside an object as it will encode a key.

func (*Encoder) AddUint8NullEmpty

func (enc *Encoder) AddUint8NullEmpty(v uint8)

AddUint8NullEmpty adds an int to be encoded and skips it if its value is 0, must be used inside a slice or array encoding (does not encode a key).

func (*Encoder) AddUint8OmitEmpty

func (enc *Encoder) AddUint8OmitEmpty(v uint8)

AddUint8OmitEmpty adds an int to be encoded and skips it if its value is 0, must be used inside a slice or array encoding (does not encode a key).

func (*Encoder) AppendByte

func (enc *Encoder) AppendByte(b byte)

AppendByte allows a modular usage by appending a single byte manually to the current state of the buffer.

func (*Encoder) AppendBytes

func (enc *Encoder) AppendBytes(b []byte)

AppendBytes allows a modular usage by appending bytes manually to the current state of the buffer.

func (*Encoder) AppendString

func (enc *Encoder) AppendString(v string)

AppendString appends a string to the buffer

func (*Encoder) Array

func (enc *Encoder) Array(v MarshalerJSONArray)

Array adds an implementation of MarshalerJSONArray to be encoded, must be used inside a slice or array encoding (does not encode a key) value must implement Marshaler

func (*Encoder) ArrayKey

func (enc *Encoder) ArrayKey(key string, v MarshalerJSONArray)

ArrayKey adds an array or slice to be encoded, must be used inside an object as it will encode a key value must implement Marshaler

func (*Encoder) ArrayKeyNullEmpty

func (enc *Encoder) ArrayKeyNullEmpty(key string, v MarshalerJSONArray)

ArrayKeyNullEmpty adds an array or slice to be encoded and encodes `null“ if it is nil. Must be called inside an object as it will encode a key.

func (*Encoder) ArrayKeyOmitEmpty

func (enc *Encoder) ArrayKeyOmitEmpty(key string, v MarshalerJSONArray)

ArrayKeyOmitEmpty adds an array or slice to be encoded and skips if it is nil. Must be called inside an object as it will encode a key.

func (*Encoder) ArrayNullEmpty

func (enc *Encoder) ArrayNullEmpty(v MarshalerJSONArray)

ArrayNullEmpty adds an array or slice to be encoded, must be used inside a slice or array encoding (does not encode a key) value must implement Marshaler

func (*Encoder) ArrayOmitEmpty

func (enc *Encoder) ArrayOmitEmpty(v MarshalerJSONArray)

ArrayOmitEmpty adds an array or slice to be encoded, must be used inside a slice or array encoding (does not encode a key) value must implement Marshaler

func (*Encoder) Bool

func (enc *Encoder) Bool(v bool)

Bool adds a bool to be encoded, must be used inside a slice or array encoding (does not encode a key)

func (*Encoder) BoolKey

func (enc *Encoder) BoolKey(key string, value bool)

BoolKey adds a bool to be encoded, must be used inside an object as it will encode a key.

func (*Encoder) BoolKeyNullEmpty

func (enc *Encoder) BoolKeyNullEmpty(key string, v bool)

BoolKeyNullEmpty adds a bool to be encoded and skips it if it is zero value. Must be used inside an object as it will encode a key.

func (*Encoder) BoolKeyOmitEmpty

func (enc *Encoder) BoolKeyOmitEmpty(key string, v bool)

BoolKeyOmitEmpty adds a bool to be encoded and skips it if it is zero value. Must be used inside an object as it will encode a key.

func (*Encoder) BoolNullEmpty

func (enc *Encoder) BoolNullEmpty(v bool)

BoolNullEmpty adds a bool to be encoded, must be used inside a slice or array encoding (does not encode a key)

func (*Encoder) BoolOmitEmpty

func (enc *Encoder) BoolOmitEmpty(v bool)

BoolOmitEmpty adds a bool to be encoded, must be used inside a slice or array encoding (does not encode a key)

func (*Encoder) Buf

func (enc *Encoder) Buf() []byte

Buf returns the Encoder's buffer.

func (*Encoder) Encode

func (enc *Encoder) Encode(v interface{}) error

Encode encodes a value to JSON.

If Encode cannot find a way to encode the type to JSON it will return an InvalidMarshalError.

func (*Encoder) EncodeArray

func (enc *Encoder) EncodeArray(v MarshalerJSONArray) error

EncodeArray encodes an implementation of MarshalerJSONArray to JSON

func (*Encoder) EncodeBool

func (enc *Encoder) EncodeBool(v bool) error

EncodeBool encodes a bool to JSON

func (*Encoder) EncodeEmbeddedJSON

func (enc *Encoder) EncodeEmbeddedJSON(v *EmbeddedJSON) error

EncodeEmbeddedJSON encodes an embedded JSON. is basically sets the internal buf as the value pointed by v and calls the io.Writer.Write()

func (*Encoder) EncodeFloat

func (enc *Encoder) EncodeFloat(n float64) error

EncodeFloat encodes a float64 to JSON

func (*Encoder) EncodeFloat32

func (enc *Encoder) EncodeFloat32(n float32) error

EncodeFloat32 encodes a float32 to JSON

func (*Encoder) EncodeInt

func (enc *Encoder) EncodeInt(n int) error

EncodeInt encodes an int to JSON

func (*Encoder) EncodeInt64

func (enc *Encoder) EncodeInt64(n int64) error

EncodeInt64 encodes an int64 to JSON

func (*Encoder) EncodeObject

func (enc *Encoder) EncodeObject(v MarshalerJSONObject) error

EncodeObject encodes an object to JSON

func (*Encoder) EncodeObjectKeys

func (enc *Encoder) EncodeObjectKeys(v MarshalerJSONObject, keys []string) error

EncodeObjectKeys encodes an object to JSON

func (*Encoder) EncodeSQLNullBool

func (enc *Encoder) EncodeSQLNullBool(v *sql.NullBool) error

EncodeSQLNullBool encodes a string to

func (*Encoder) EncodeSQLNullFloat64

func (enc *Encoder) EncodeSQLNullFloat64(v *sql.NullFloat64) error

EncodeSQLNullFloat64 encodes a string to

func (*Encoder) EncodeSQLNullInt64

func (enc *Encoder) EncodeSQLNullInt64(v *sql.NullInt64) error

EncodeSQLNullInt64 encodes a string to

func (*Encoder) EncodeSQLNullString

func (enc *Encoder) EncodeSQLNullString(v *sql.NullString) error

EncodeSQLNullString encodes a string to

func (*Encoder) EncodeString

func (enc *Encoder) EncodeString(s string) error

EncodeString encodes a string to

Example
package main

import (
	"log"
	"os"

	"github.com/francoispqt/gojay"
)

func main() {
	enc := gojay.BorrowEncoder(os.Stdout)
	defer enc.Release()

	var str = "gojay"
	err := enc.EncodeString(str)
	if err != nil {
		log.Fatal(err)
	}
}
Output:

"gojay"

func (*Encoder) EncodeTime

func (enc *Encoder) EncodeTime(t *time.Time, format string) error

EncodeTime encodes a *time.Time to JSON with the given format

func (*Encoder) EncodeUint64

func (enc *Encoder) EncodeUint64(n uint64) error

EncodeUint64 encodes an int64 to JSON

func (*Encoder) Float

func (enc *Encoder) Float(v float64)

Float adds a float64 to be encoded, must be used inside a slice or array encoding (does not encode a key)

func (*Encoder) Float32

func (enc *Encoder) Float32(v float32)

Float32 adds a float32 to be encoded, must be used inside a slice or array encoding (does not encode a key)

func (*Encoder) Float32Key

func (enc *Encoder) Float32Key(key string, v float32)

Float32Key adds a float32 to be encoded, must be used inside an object as it will encode a key

func (*Encoder) Float32KeyNullEmpty

func (enc *Encoder) Float32KeyNullEmpty(key string, v float32)

Float32KeyNullEmpty adds a float64 to be encoded and skips it if its value is 0. Must be used inside an object as it will encode a key

func (*Encoder) Float32KeyOmitEmpty

func (enc *Encoder) Float32KeyOmitEmpty(key string, v float32)

Float32KeyOmitEmpty adds a float64 to be encoded and skips it if its value is 0. Must be used inside an object as it will encode a key

func (*Encoder) Float32NullEmpty

func (enc *Encoder) Float32NullEmpty(v float32)

Float32NullEmpty adds an int to be encoded and skips it if its value is 0, must be used inside a slice or array encoding (does not encode a key).

func (*Encoder) Float32OmitEmpty

func (enc *Encoder) Float32OmitEmpty(v float32)

Float32OmitEmpty adds an int to be encoded and skips it if its value is 0, must be used inside a slice or array encoding (does not encode a key).

func (*Encoder) Float64

func (enc *Encoder) Float64(v float64)

Float64 adds a float64 to be encoded, must be used inside a slice or array encoding (does not encode a key)

func (*Encoder) Float64Key

func (enc *Encoder) Float64Key(key string, value float64)

Float64Key adds a float64 to be encoded, must be used inside an object as it will encode a key

func (*Encoder) Float64KeyNullEmpty

func (enc *Encoder) Float64KeyNullEmpty(key string, v float64)

Float64KeyNullEmpty adds a float64 to be encoded and skips it if its value is 0, must be used inside a slice or array encoding (does not encode a key).

func (*Encoder) Float64KeyOmitEmpty

func (enc *Encoder) Float64KeyOmitEmpty(key string, v float64)

Float64KeyOmitEmpty adds a float64 to be encoded and skips it if its value is 0. Must be used inside an object as it will encode a key

func (*Encoder) Float64NullEmpty

func (enc *Encoder) Float64NullEmpty(v float64)

Float64NullEmpty adds a float64 to be encoded and skips it if its value is 0, must be used inside a slice or array encoding (does not encode a key).

func (*Encoder) Float64OmitEmpty

func (enc *Encoder) Float64OmitEmpty(v float64)

Float64OmitEmpty adds a float64 to be encoded and skips it if its value is 0, must be used inside a slice or array encoding (does not encode a key).

func (*Encoder) FloatKey

func (enc *Encoder) FloatKey(key string, v float64)

FloatKey adds a float64 to be encoded, must be used inside an object as it will encode a key

func (*Encoder) FloatKeyNullEmpty

func (enc *Encoder) FloatKeyNullEmpty(key string, v float64)

FloatKeyNullEmpty adds a float64 to be encoded and skips it if its value is 0. Must be used inside an object as it will encode a key

func (*Encoder) FloatKeyOmitEmpty

func (enc *Encoder) FloatKeyOmitEmpty(key string, v float64)

FloatKeyOmitEmpty adds a float64 to be encoded and skips it if its value is 0. Must be used inside an object as it will encode a key

func (*Encoder) FloatNullEmpty

func (enc *Encoder) FloatNullEmpty(v float64)

FloatNullEmpty adds a float64 to be encoded and skips it if its value is 0, must be used inside a slice or array encoding (does not encode a key).

func (*Encoder) FloatOmitEmpty

func (enc *Encoder) FloatOmitEmpty(v float64)

FloatOmitEmpty adds a float64 to be encoded and skips it if its value is 0, must be used inside a slice or array encoding (does not encode a key).

func (*Encoder) Int

func (enc *Encoder) Int(v int)

Int adds an int to be encoded, must be used inside a slice or array encoding (does not encode a key)

func (*Encoder) Int16

func (enc *Encoder) Int16(v int16)

Int16 adds an int to be encoded, must be used inside a slice or array encoding (does not encode a key)

func (*Encoder) Int16Key

func (enc *Encoder) Int16Key(key string, v int16)

Int16Key adds an int16 to be encoded, must be used inside an object as it will encode a key

func (*Encoder) Int16KeyNullEmpty

func (enc *Encoder) Int16KeyNullEmpty(key string, v int16)

Int16KeyNullEmpty adds an int16 to be encoded and skips it if its value is 0. Must be used inside an object as it will encode a key.

func (*Encoder) Int16KeyOmitEmpty

func (enc *Encoder) Int16KeyOmitEmpty(key string, v int16)

Int16KeyOmitEmpty adds an int16 to be encoded and skips it if its value is 0. Must be used inside an object as it will encode a key.

func (*Encoder) Int16NullEmpty

func (enc *Encoder) Int16NullEmpty(v int16)

Int16NullEmpty adds an int to be encoded and skips it if its value is 0, must be used inside a slice or array encoding (does not encode a key).

func (*Encoder) Int16OmitEmpty

func (enc *Encoder) Int16OmitEmpty(v int16)

Int16OmitEmpty adds an int to be encoded and skips it if its value is 0, must be used inside a slice or array encoding (does not encode a key).

func (*Encoder) Int32

func (enc *Encoder) Int32(v int32)

Int32 adds an int to be encoded, must be used inside a slice or array encoding (does not encode a key)

func (*Encoder) Int32Key

func (enc *Encoder) Int32Key(key string, v int32)

Int32Key adds an int32 to be encoded, must be used inside an object as it will encode a key

func (*Encoder) Int32KeyNullEmpty

func (enc *Encoder) Int32KeyNullEmpty(key string, v int32)

Int32KeyNullEmpty adds an int32 to be encoded and skips it if its value is 0. Must be used inside an object as it will encode a key.

func (*Encoder) Int32KeyOmitEmpty

func (enc *Encoder) Int32KeyOmitEmpty(key string, v int32)

Int32KeyOmitEmpty adds an int32 to be encoded and skips it if its value is 0. Must be used inside an object as it will encode a key.

func (*Encoder) Int32NullEmpty

func (enc *Encoder) Int32NullEmpty(v int32)

Int32NullEmpty adds an int to be encoded and skips it if its value is 0, must be used inside a slice or array encoding (does not encode a key).

func (*Encoder) Int32OmitEmpty

func (enc *Encoder) Int32OmitEmpty(v int32)

Int32OmitEmpty adds an int to be encoded and skips it if its value is 0, must be used inside a slice or array encoding (does not encode a key).

func (*Encoder) Int64

func (enc *Encoder) Int64(v int64)

Int64 adds an int to be encoded, must be used inside a slice or array encoding (does not encode a key)

func (*Encoder) Int64Key

func (enc *Encoder) Int64Key(key string, v int64)

Int64Key adds an int64 to be encoded, must be used inside an object as it will encode a key

func (*Encoder) Int64KeyNullEmpty

func (enc *Encoder) Int64KeyNullEmpty(key string, v int64)

Int64KeyNullEmpty adds an int64 to be encoded and skips it if its value is 0. Must be used inside an object as it will encode a key.

func (*Encoder) Int64KeyOmitEmpty

func (enc *Encoder) Int64KeyOmitEmpty(key string, v int64)

Int64KeyOmitEmpty adds an int64 to be encoded and skips it if its value is 0. Must be used inside an object as it will encode a key.

func (*Encoder) Int64NullEmpty

func (enc *Encoder) Int64NullEmpty(v int64)

Int64NullEmpty adds an int to be encoded and skips it if its value is 0, must be used inside a slice or array encoding (does not encode a key).

func (*Encoder) Int64OmitEmpty

func (enc *Encoder) Int64OmitEmpty(v int64)

Int64OmitEmpty adds an int to be encoded and skips it if its value is 0, must be used inside a slice or array encoding (does not encode a key).

func (*Encoder) Int8

func (enc *Encoder) Int8(v int8)

Int8 adds an int to be encoded, must be used inside a slice or array encoding (does not encode a key)

func (*Encoder) Int8Key

func (enc *Encoder) Int8Key(key string, v int8)

Int8Key adds an int8 to be encoded, must be used inside an object as it will encode a key

func (*Encoder) Int8KeyNullEmpty

func (enc *Encoder) Int8KeyNullEmpty(key string, v int8)

Int8KeyNullEmpty adds an int8 to be encoded and skips it if its value is 0. Must be used inside an object as it will encode a key.

func (*Encoder) Int8KeyOmitEmpty

func (enc *Encoder) Int8KeyOmitEmpty(key string, v int8)

Int8KeyOmitEmpty adds an int8 to be encoded and skips it if its value is 0. Must be used inside an object as it will encode a key.

func (*Encoder) Int8NullEmpty

func (enc *Encoder) Int8NullEmpty(v int8)

Int8NullEmpty adds an int to be encoded and skips it if its value is 0, must be used inside a slice or array encoding (does not encode a key).

func (*Encoder) Int8OmitEmpty

func (enc *Encoder) Int8OmitEmpty(v int8)

Int8OmitEmpty adds an int to be encoded and skips it if its value is 0, must be used inside a slice or array encoding (does not encode a key).

func (*Encoder) IntKey

func (enc *Encoder) IntKey(key string, v int)

IntKey adds an int to be encoded, must be used inside an object as it will encode a key

func (*Encoder) IntKeyNullEmpty

func (enc *Encoder) IntKeyNullEmpty(key string, v int)

IntKeyNullEmpty adds an int to be encoded and skips it if its value is 0. Must be used inside an object as it will encode a key.

func (*Encoder) IntKeyOmitEmpty

func (enc *Encoder) IntKeyOmitEmpty(key string, v int)

IntKeyOmitEmpty adds an int to be encoded and skips it if its value is 0. Must be used inside an object as it will encode a key.

func (*Encoder) IntNullEmpty

func (enc *Encoder) IntNullEmpty(v int)

IntNullEmpty adds an int to be encoded and skips it if its value is 0, must be used inside a slice or array encoding (does not encode a key).

func (*Encoder) IntOmitEmpty

func (enc *Encoder) IntOmitEmpty(v int)

IntOmitEmpty adds an int to be encoded and skips it if its value is 0, must be used inside a slice or array encoding (does not encode a key).

func (*Encoder) Null

func (enc *Encoder) Null()

Null adds a `null` to be encoded. Must be used while encoding an array.`

func (*Encoder) NullKey

func (enc *Encoder) NullKey(key string)

NullKey adds a `null` to be encoded. Must be used while encoding an array.`

func (*Encoder) Object

func (enc *Encoder) Object(v MarshalerJSONObject)

Object adds an object to be encoded, must be used inside a slice or array encoding (does not encode a key) value must implement MarshalerJSONObject

func (*Encoder) ObjectKey

func (enc *Encoder) ObjectKey(key string, v MarshalerJSONObject)

ObjectKey adds a struct to be encoded, must be used inside an object as it will encode a key value must implement MarshalerJSONObject

func (*Encoder) ObjectKeyNullEmpty

func (enc *Encoder) ObjectKeyNullEmpty(key string, v MarshalerJSONObject)

ObjectKeyNullEmpty adds an object to be encoded or skips it if IsNil returns true. Must be used inside a slice or array encoding (does not encode a key) value must implement MarshalerJSONObject

func (*Encoder) ObjectKeyOmitEmpty

func (enc *Encoder) ObjectKeyOmitEmpty(key string, v MarshalerJSONObject)

ObjectKeyOmitEmpty adds an object to be encoded or skips it if IsNil returns true. Must be used inside a slice or array encoding (does not encode a key) value must implement MarshalerJSONObject

func (*Encoder) ObjectKeyWithKeys

func (enc *Encoder) ObjectKeyWithKeys(key string, value MarshalerJSONObject, keys []string)

ObjectKeyWithKeys adds a struct to be encoded, must be used inside an object as it will encode a key. Value must implement MarshalerJSONObject. It will only encode the keys in keys.

func (*Encoder) ObjectNullEmpty

func (enc *Encoder) ObjectNullEmpty(v MarshalerJSONObject)

ObjectNullEmpty adds an object to be encoded or skips it if IsNil returns true. Must be used inside a slice or array encoding (does not encode a key) value must implement MarshalerJSONObject

func (*Encoder) ObjectOmitEmpty

func (enc *Encoder) ObjectOmitEmpty(v MarshalerJSONObject)

ObjectOmitEmpty adds an object to be encoded or skips it if IsNil returns true. Must be used inside a slice or array encoding (does not encode a key) value must implement MarshalerJSONObject

func (*Encoder) ObjectWithKeys

func (enc *Encoder) ObjectWithKeys(v MarshalerJSONObject, keys []string)

ObjectWithKeys adds an object to be encoded, must be used inside a slice or array encoding (does not encode a key) value must implement MarshalerJSONObject. It will only encode the keys in keys.

func (*Encoder) Release

func (enc *Encoder) Release()

Release sends back a Encoder to the pool.

func (*Encoder) SQLNullBool

func (enc *Encoder) SQLNullBool(v *sql.NullBool)

SQLNullBool adds a string to be encoded, must be used inside an object as it will encode a key

func (*Encoder) SQLNullBoolKey

func (enc *Encoder) SQLNullBoolKey(key string, v *sql.NullBool)

SQLNullBoolKey adds a string to be encoded, must be used inside an object as it will encode a key

func (*Encoder) SQLNullBoolKeyNullEmpty

func (enc *Encoder) SQLNullBoolKeyNullEmpty(key string, v *sql.NullBool)

SQLNullBoolKeyNullEmpty adds a string to be encoded or skips it if it is zero value. Must be used inside an object as it will encode a key

func (*Encoder) SQLNullBoolKeyOmitEmpty

func (enc *Encoder) SQLNullBoolKeyOmitEmpty(key string, v *sql.NullBool)

SQLNullBoolKeyOmitEmpty adds a string to be encoded or skips it if it is zero value. Must be used inside an object as it will encode a key

func (*Encoder) SQLNullBoolNullEmpty

func (enc *Encoder) SQLNullBoolNullEmpty(v *sql.NullBool)

SQLNullBoolNullEmpty adds a string to be encoded, must be used inside an object as it will encode a key

func (*Encoder) SQLNullBoolOmitEmpty

func (enc *Encoder) SQLNullBoolOmitEmpty(v *sql.NullBool)

SQLNullBoolOmitEmpty adds a string to be encoded, must be used inside an object as it will encode a key

func (*Encoder) SQLNullFloat64

func (enc *Encoder) SQLNullFloat64(v *sql.NullFloat64)

SQLNullFloat64 adds a string to be encoded, must be used inside an object as it will encode a key

func (*Encoder) SQLNullFloat64Key

func (enc *Encoder) SQLNullFloat64Key(key string, v *sql.NullFloat64)

SQLNullFloat64Key adds a string to be encoded, must be used inside an object as it will encode a key

func (*Encoder) SQLNullFloat64KeyNullEmpty

func (enc *Encoder) SQLNullFloat64KeyNullEmpty(key string, v *sql.NullFloat64)

SQLNullFloat64KeyNullEmpty adds a string to be encoded or skips it if it is zero value. Must be used inside an object as it will encode a key

func (*Encoder) SQLNullFloat64KeyOmitEmpty

func (enc *Encoder) SQLNullFloat64KeyOmitEmpty(key string, v *sql.NullFloat64)

SQLNullFloat64KeyOmitEmpty adds a string to be encoded or skips it if it is zero value. Must be used inside an object as it will encode a key

func (*Encoder) SQLNullFloat64NullEmpty

func (enc *Encoder) SQLNullFloat64NullEmpty(v *sql.NullFloat64)

SQLNullFloat64NullEmpty adds a string to be encoded, must be used inside an object as it will encode a key

func (*Encoder) SQLNullFloat64OmitEmpty

func (enc *Encoder) SQLNullFloat64OmitEmpty(v *sql.NullFloat64)

SQLNullFloat64OmitEmpty adds a string to be encoded, must be used inside an object as it will encode a key

func (*Encoder) SQLNullInt64

func (enc *Encoder) SQLNullInt64(v *sql.NullInt64)

SQLNullInt64 adds a string to be encoded, must be used inside an object as it will encode a key

func (*Encoder) SQLNullInt64Key

func (enc *Encoder) SQLNullInt64Key(key string, v *sql.NullInt64)

SQLNullInt64Key adds a string to be encoded, must be used inside an object as it will encode a key

func (*Encoder) SQLNullInt64KeyNullEmpty

func (enc *Encoder) SQLNullInt64KeyNullEmpty(key string, v *sql.NullInt64)

SQLNullInt64KeyNullEmpty adds a string to be encoded or skips it if it is zero value. Must be used inside an object as it will encode a key

func (*Encoder) SQLNullInt64KeyOmitEmpty

func (enc *Encoder) SQLNullInt64KeyOmitEmpty(key string, v *sql.NullInt64)

SQLNullInt64KeyOmitEmpty adds a string to be encoded or skips it if it is zero value. Must be used inside an object as it will encode a key

func (*Encoder) SQLNullInt64NullEmpty

func (enc *Encoder) SQLNullInt64NullEmpty(v *sql.NullInt64)

SQLNullInt64NullEmpty adds a string to be encoded, must be used inside an object as it will encode a key

func (*Encoder) SQLNullInt64OmitEmpty

func (enc *Encoder) SQLNullInt64OmitEmpty(v *sql.NullInt64)

SQLNullInt64OmitEmpty adds a string to be encoded, must be used inside an object as it will encode a key

func (*Encoder) SQLNullString

func (enc *Encoder) SQLNullString(v *sql.NullString)

SQLNullString adds a string to be encoded, must be used inside an object as it will encode a key

func (*Encoder) SQLNullStringKey

func (enc *Encoder) SQLNullStringKey(key string, v *sql.NullString)

SQLNullStringKey adds a string to be encoded, must be used inside an object as it will encode a key

func (*Encoder) SQLNullStringKeyNullEmpty

func (enc *Encoder) SQLNullStringKeyNullEmpty(key string, v *sql.NullString)

SQLNullStringKeyNullEmpty adds a string to be encoded or skips it if it is zero value. Must be used inside an object as it will encode a key

func (*Encoder) SQLNullStringKeyOmitEmpty

func (enc *Encoder) SQLNullStringKeyOmitEmpty(key string, v *sql.NullString)

SQLNullStringKeyOmitEmpty adds a string to be encoded or skips it if it is zero value. Must be used inside an object as it will encode a key

func (*Encoder) SQLNullStringNullEmpty

func (enc *Encoder) SQLNullStringNullEmpty(v *sql.NullString)

SQLNullStringNullEmpty adds a string to be encoded, must be used inside an object as it will encode a key

func (*Encoder) SQLNullStringOmitEmpty

func (enc *Encoder) SQLNullStringOmitEmpty(v *sql.NullString)

SQLNullStringOmitEmpty adds a string to be encoded, must be used inside an object as it will encode a key

func (*Encoder) SliceBool

func (enc *Encoder) SliceBool(s []bool)

SliceBool marshals the given []bool s

func (*Encoder) SliceBoolKey

func (enc *Encoder) SliceBoolKey(k string, s []bool)

SliceBoolKey marshals the given []bool s

func (*Encoder) SliceFloat64

func (enc *Encoder) SliceFloat64(s []float64)

SliceFloat64 marshals the given []float64 s

func (*Encoder) SliceFloat64Key

func (enc *Encoder) SliceFloat64Key(k string, s []float64)

SliceFloat64Key marshals the given []float64 s

func (*Encoder) SliceInt

func (enc *Encoder) SliceInt(s []int)

SliceInt marshals the given []int s

func (*Encoder) SliceIntKey

func (enc *Encoder) SliceIntKey(k string, s []int)

SliceIntKey marshals the given []int s

func (*Encoder) SliceString

func (enc *Encoder) SliceString(s []string)

SliceString marshals the given []string s

func (*Encoder) SliceStringKey

func (enc *Encoder) SliceStringKey(k string, s []string)

SliceStringKey marshals the given []string s

func (*Encoder) String

func (enc *Encoder) String(v string)

String adds a string to be encoded, must be used inside a slice or array encoding (does not encode a key)

func (*Encoder) StringKey

func (enc *Encoder) StringKey(key, v string)

StringKey adds a string to be encoded, must be used inside an object as it will encode a key

func (*Encoder) StringKeyNullEmpty

func (enc *Encoder) StringKeyNullEmpty(key, v string)

StringKeyNullEmpty adds a string to be encoded or skips it if it is zero value. Must be used inside an object as it will encode a key

func (*Encoder) StringKeyOmitEmpty

func (enc *Encoder) StringKeyOmitEmpty(key, v string)

StringKeyOmitEmpty adds a string to be encoded or skips it if it is zero value. Must be used inside an object as it will encode a key

func (*Encoder) StringNullEmpty

func (enc *Encoder) StringNullEmpty(v string)

StringNullEmpty adds a string to be encoded or skips it if it is zero value. Must be used inside a slice or array encoding (does not encode a key)

func (*Encoder) StringOmitEmpty

func (enc *Encoder) StringOmitEmpty(v string)

StringOmitEmpty adds a string to be encoded or skips it if it is zero value. Must be used inside a slice or array encoding (does not encode a key)

func (*Encoder) Time

func (enc *Encoder) Time(t *time.Time, format string)

Time adds an *time.Time to be encoded with the given format, must be used inside a slice or array encoding (does not encode a key)

func (*Encoder) TimeKey

func (enc *Encoder) TimeKey(key string, t *time.Time, format string)

TimeKey adds an *time.Time to be encoded with the given format, must be used inside an object as it will encode a key

func (*Encoder) Uint16

func (enc *Encoder) Uint16(v uint16)

Uint16 adds an int to be encoded, must be used inside a slice or array encoding (does not encode a key)

func (*Encoder) Uint16Key

func (enc *Encoder) Uint16Key(key string, v uint16)

Uint16Key adds an int to be encoded, must be used inside an object as it will encode a key

func (*Encoder) Uint16KeyNullEmpty

func (enc *Encoder) Uint16KeyNullEmpty(key string, v uint16)

Uint16KeyNullEmpty adds an int to be encoded and skips it if its value is 0. Must be used inside an object as it will encode a key.

func (*Encoder) Uint16KeyOmitEmpty

func (enc *Encoder) Uint16KeyOmitEmpty(key string, v uint16)

Uint16KeyOmitEmpty adds an int to be encoded and skips it if its value is 0. Must be used inside an object as it will encode a key.

func (*Encoder) Uint16NullEmpty

func (enc *Encoder) Uint16NullEmpty(v uint16)

Uint16NullEmpty adds an int to be encoded and skips it if its value is 0, must be used inside a slice or array encoding (does not encode a key).

func (*Encoder) Uint16OmitEmpty

func (enc *Encoder) Uint16OmitEmpty(v uint16)

Uint16OmitEmpty adds an int to be encoded and skips it if its value is 0, must be used inside a slice or array encoding (does not encode a key).

func (*Encoder) Uint32

func (enc *Encoder) Uint32(v uint32)

Uint32 adds an int to be encoded, must be used inside a slice or array encoding (does not encode a key)

func (*Encoder) Uint32Key

func (enc *Encoder) Uint32Key(key string, v uint32)

Uint32Key adds an int to be encoded, must be used inside an object as it will encode a key

func (*Encoder) Uint32KeyNullEmpty

func (enc *Encoder) Uint32KeyNullEmpty(key string, v uint32)

Uint32KeyNullEmpty adds an int to be encoded and skips it if its value is 0. Must be used inside an object as it will encode a key.

func (*Encoder) Uint32KeyOmitEmpty

func (enc *Encoder) Uint32KeyOmitEmpty(key string, v uint32)

Uint32KeyOmitEmpty adds an int to be encoded and skips it if its value is 0. Must be used inside an object as it will encode a key.

func (*Encoder) Uint32NullEmpty

func (enc *Encoder) Uint32NullEmpty(v uint32)

Uint32NullEmpty adds an int to be encoded and skips it if its value is 0, must be used inside a slice or array encoding (does not encode a key).

func (*Encoder) Uint32OmitEmpty

func (enc *Encoder) Uint32OmitEmpty(v uint32)

Uint32OmitEmpty adds an int to be encoded and skips it if its value is 0, must be used inside a slice or array encoding (does not encode a key).

func (*Encoder) Uint64

func (enc *Encoder) Uint64(v uint64)

Uint64 adds an int to be encoded, must be used inside a slice or array encoding (does not encode a key)

func (*Encoder) Uint64Key

func (enc *Encoder) Uint64Key(key string, v uint64)

Uint64Key adds an int to be encoded, must be used inside an object as it will encode a key

func (*Encoder) Uint64KeyNullEmpty

func (enc *Encoder) Uint64KeyNullEmpty(key string, v uint64)

Uint64KeyNullEmpty adds an int to be encoded and skips it if its value is 0. Must be used inside an object as it will encode a key.

func (*Encoder) Uint64KeyOmitEmpty

func (enc *Encoder) Uint64KeyOmitEmpty(key string, v uint64)

Uint64KeyOmitEmpty adds an int to be encoded and skips it if its value is 0. Must be used inside an object as it will encode a key.

func (*Encoder) Uint64NullEmpty

func (enc *Encoder) Uint64NullEmpty(v uint64)

Uint64NullEmpty adds an int to be encoded and skips it if its value is 0, must be used inside a slice or array encoding (does not encode a key).

func (*Encoder) Uint64OmitEmpty

func (enc *Encoder) Uint64OmitEmpty(v uint64)

Uint64OmitEmpty adds an int to be encoded and skips it if its value is 0, must be used inside a slice or array encoding (does not encode a key).

func (*Encoder) Uint8

func (enc *Encoder) Uint8(v uint8)

Uint8 adds an int to be encoded, must be used inside a slice or array encoding (does not encode a key)

func (*Encoder) Uint8Key

func (enc *Encoder) Uint8Key(key string, v uint8)

Uint8Key adds an int to be encoded, must be used inside an object as it will encode a key

func (*Encoder) Uint8KeyNullEmpty

func (enc *Encoder) Uint8KeyNullEmpty(key string, v uint8)

Uint8KeyNullEmpty adds an int to be encoded and skips it if its value is 0. Must be used inside an object as it will encode a key.

func (*Encoder) Uint8KeyOmitEmpty

func (enc *Encoder) Uint8KeyOmitEmpty(key string, v uint8)

Uint8KeyOmitEmpty adds an int to be encoded and skips it if its value is 0. Must be used inside an object as it will encode a key.

func (*Encoder) Uint8NullEmpty

func (enc *Encoder) Uint8NullEmpty(v uint8)

Uint8NullEmpty adds an int to be encoded and skips it if its value is 0, must be used inside a slice or array encoding (does not encode a key).

func (*Encoder) Uint8OmitEmpty

func (enc *Encoder) Uint8OmitEmpty(v uint8)

Uint8OmitEmpty adds an int to be encoded and skips it if its value is 0, must be used inside a slice or array encoding (does not encode a key).

func (*Encoder) Write

func (enc *Encoder) Write() (int, error)

Write writes to the io.Writer and resets the buffer.

type InvalidJSONError

type InvalidJSONError string

InvalidJSONError is a type representing an error returned when Decoding encounters invalid JSON.

func (InvalidJSONError) Error

func (err InvalidJSONError) Error() string

type InvalidMarshalError

type InvalidMarshalError string

InvalidMarshalError is a type representing an error returned when Encoding did not find the proper way to encode

func (InvalidMarshalError) Error

func (err InvalidMarshalError) Error() string

type InvalidUnmarshalError

type InvalidUnmarshalError string

InvalidUnmarshalError is a type representing an error returned when Decoding cannot unmarshal JSON to the receiver type for various reasons.

func (InvalidUnmarshalError) Error

func (err InvalidUnmarshalError) Error() string

type InvalidUsagePooledDecoderError

type InvalidUsagePooledDecoderError string

InvalidUsagePooledDecoderError is a type representing an error returned when decoding is called on a still pooled Decoder

func (InvalidUsagePooledDecoderError) Error

type InvalidUsagePooledEncoderError

type InvalidUsagePooledEncoderError string

InvalidUsagePooledEncoderError is a type representing an error returned when decoding is called on a still pooled Encoder

func (InvalidUsagePooledEncoderError) Error

type MarshalerJSONArray

type MarshalerJSONArray interface {
	MarshalJSONArray(enc *Encoder)
	IsNil() bool
}

MarshalerJSONArray is the interface to implement for a slice or an array to be encoded

type MarshalerJSONObject

type MarshalerJSONObject interface {
	MarshalJSONObject(enc *Encoder)
	IsNil() bool
}

MarshalerJSONObject is the interface to implement for struct to be encoded

type MarshalerStream

type MarshalerStream interface {
	MarshalStream(enc *StreamEncoder)
}

MarshalerStream is the interface to implement to continuously encode of stream of data.

type NoReaderError

type NoReaderError string

NoReaderError is a type representing an error returned when decoding requires a reader and none was given

func (NoReaderError) Error

func (err NoReaderError) Error() string

type StreamDecoder

type StreamDecoder struct {
	*Decoder
	// contains filtered or unexported fields
}

A StreamDecoder reads and decodes JSON values from an input stream.

It implements conext.Context and provide a channel to notify interruption.

func (*StreamDecoder) Deadline

func (dec *StreamDecoder) Deadline() (time.Time, bool)

Deadline returns the time when work done on behalf of this context should be canceled. Deadline returns ok==false when no deadline is set. Successive calls to Deadline return the same results.

func (*StreamDecoder) DecodeStream

func (dec *StreamDecoder) DecodeStream(c UnmarshalerStream) error

DecodeStream reads the next line delimited JSON-encoded value from the decoder's input (io.Reader) and stores it in the value pointed to by c.

c must implement UnmarshalerStream. Ideally c is a channel. See example for implementation.

See the documentation for Unmarshal for details about the conversion of JSON into a Go value.

func (*StreamDecoder) Done

func (dec *StreamDecoder) Done() <-chan struct{}

Done returns a channel that's closed when work is done. It implements context.Context

func (*StreamDecoder) Err

func (dec *StreamDecoder) Err() error

Err returns nil if Done is not yet closed. If Done is closed, Err returns a non-nil error explaining why. It implements context.Context

func (*StreamDecoder) Release

func (dec *StreamDecoder) Release()

Release sends back a Decoder to the pool. If a decoder is used after calling Release a panic will be raised with an InvalidUsagePooledDecoderError error.

func (*StreamDecoder) SetDeadline

func (dec *StreamDecoder) SetDeadline(t time.Time)

SetDeadline sets the deadline

func (*StreamDecoder) Value

func (dec *StreamDecoder) Value(key interface{}) interface{}

Value implements context.Context

type StreamEncoder

type StreamEncoder struct {
	*Encoder
	// contains filtered or unexported fields
}

A StreamEncoder reads and encodes values to JSON from an input stream.

It implements conext.Context and provide a channel to notify interruption.

func (*StreamEncoder) AddArray

func (s *StreamEncoder) AddArray(v MarshalerJSONArray)

AddArray adds an implementation of MarshalerJSONArray to be encoded.

func (*StreamEncoder) AddFloat

func (s *StreamEncoder) AddFloat(value float64)

AddFloat adds a float64 to be encoded.

func (*StreamEncoder) AddFloat64

func (s *StreamEncoder) AddFloat64(value float64)

AddFloat64 adds a float64 to be encoded.

func (*StreamEncoder) AddInt

func (s *StreamEncoder) AddInt(value int)

AddInt adds an int to be encoded.

func (*StreamEncoder) AddObject

func (s *StreamEncoder) AddObject(v MarshalerJSONObject)

AddObject adds an object to be encoded. value must implement MarshalerJSONObject.

func (*StreamEncoder) AddString

func (s *StreamEncoder) AddString(v string)

AddString adds a string to be encoded.

func (*StreamEncoder) Cancel

func (s *StreamEncoder) Cancel(err error)

Cancel cancels the consumers of the stream, interrupting the stream encoding.

After calling cancel, Done() will return a closed channel.

func (*StreamEncoder) CommaDelimited

func (s *StreamEncoder) CommaDelimited() *StreamEncoder

CommaDelimited sets the delimiter to a comma.

It will add a new line after each JSON marshaled by the MarshalerStream

func (*StreamEncoder) Deadline

func (s *StreamEncoder) Deadline() (time.Time, bool)

Deadline returns the time when work done on behalf of this context should be canceled. Deadline returns ok==false when no deadline is set. Successive calls to Deadline return the same results.

func (*StreamEncoder) Done

func (s *StreamEncoder) Done() <-chan struct{}

Done returns a channel that's closed when work is done. It implements context.Context

func (*StreamEncoder) EncodeStream

func (s *StreamEncoder) EncodeStream(m MarshalerStream)

EncodeStream spins up a defined number of non blocking consumers of the MarshalerStream m.

m must implement MarshalerStream. Ideally m is a channel. See example for implementation.

See the documentation for Marshal for details about the conversion of Go value to JSON.

func (*StreamEncoder) Err

func (s *StreamEncoder) Err() error

Err returns nil if Done is not yet closed. If Done is closed, Err returns a non-nil error explaining why. It implements context.Context

func (*StreamEncoder) LineDelimited

func (s *StreamEncoder) LineDelimited() *StreamEncoder

LineDelimited sets the delimiter to a new line character.

It will add a new line after each JSON marshaled by the MarshalerStream

func (*StreamEncoder) NConsumer

func (s *StreamEncoder) NConsumer(n int) *StreamEncoder

NConsumer sets the number of non blocking go routine to consume the stream.

func (*StreamEncoder) Release

func (s *StreamEncoder) Release()

Release sends back a Decoder to the pool. If a decoder is used after calling Release a panic will be raised with an InvalidUsagePooledDecoderError error.

func (*StreamEncoder) SetDeadline

func (s *StreamEncoder) SetDeadline(t time.Time)

SetDeadline sets the deadline

func (*StreamEncoder) Value

func (s *StreamEncoder) Value(key interface{}) interface{}

Value implements context.Context

type UnmarshalerJSONArray

type UnmarshalerJSONArray interface {
	UnmarshalJSONArray(*Decoder) error
}

UnmarshalerJSONArray is the interface to implement to decode a JSON Array.

type UnmarshalerJSONObject

type UnmarshalerJSONObject interface {
	UnmarshalJSONObject(*Decoder, string) error
	NKeys() int
}

UnmarshalerJSONObject is the interface to implement to decode a JSON Object.

type UnmarshalerStream

type UnmarshalerStream interface {
	UnmarshalStream(*StreamDecoder) error
}

UnmarshalerStream is the interface to implement for a slice, an array or a slice to decode a line delimited JSON to.

Directories

Path Synopsis
examples
websocket
package main simulates a conversation between a given set of websocket clients and a server.
package main simulates a conversation between a given set of websocket clients and a server.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL