gojay

package module
v1.2.17 Latest Latest
Warning

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

 Go to latest Published: Nov 22, 2023 License: MIT Imports: 13 Imported by: 7

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 

func (err InvalidUsagePooledDecoderError) Error() string

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 

func (err InvalidUsagePooledEncoderError) Error() string

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.

Source Files

View all Source files

Directories

Path Synopsis
decoder
examples
encode-decode-map
fuzz
http-benchmarks/gojay
http-benchmarks/standard
http-json
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.
websocket/client
websocket/comm
websocket/server
codegen
codegen/test/annotated_struct
codegen/test/basic_struct
codegen/test/embedded_struct
codegen/test/pooled_struct

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.