token

type AccumulatorStream ¶

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

func NewAccumulatorStream() *AccumulatorStream

func (w *AccumulatorStream) GetTokens() []Token

func (w *AccumulatorStream) Put(tok Token)

type ChannelReadStream ¶

type ChannelReadStream <-chan Token

func (r ChannelReadStream) Next() Token

type ChannelWriteStream ¶

type ChannelWriteStream chan<- Token

func (w ChannelWriteStream) Put(tok Token)

type Cursor ¶

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

func NewCursorFromData(data []Token) *Cursor

func (c *Cursor) Clone() *Cursor

func (c *Cursor) Detach()

func (c *Cursor) Next() Token

type CursorPool ¶

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

func NewCursorPool(stream ReadStream) *CursorPool

func (p *CursorPool) AdvanceCursor(c *Cursor) Token

func (p *CursorPool) CloneCursor(c *Cursor) *Cursor

func (p *CursorPool) DetachCursor(c *Cursor)

func (p *CursorPool) NewCursor() *Cursor

type Elision ¶

type Elision struct{}

Elision is not part of the JSON syntax but is used to remove contents from an array or an object but signal to the user that the content has been 'elided'.

func (e *Elision) String() string

type EndArray ¶

type EndArray struct{}

EndArray represents the end of a JSON array (introduced by '}') Values of type *EndArray implement the StreamItem interface.

func (e *EndArray) String() string

type EndObject ¶

type EndObject struct{}

EndObject represents the end of a JSON object (introduced by '}') Values of type *EndObject implement the StreamItem interface.

func (e *EndObject) String() string

type ReadStream ¶

type ReadStream interface {
	Next() Token
}

type Reader ¶

type Reader interface {
	Read([]Token) (int, error)
}

type Scalar ¶

type Scalar struct {

	// Literal representation of the value, e.g.
	// - the string "foo" is represented as []byte("\"foo\"")
	// - the number 123.5 is represented as []byte("132.5")
	// - the boolean true is represented as []byte("true")
	Bytes []byte

	// Type of the value
	TypeAndFlags uint8
}

Scalar is the type used to represent all scalar JSON values, i.e. - strings - numbers - booleans (to values) - null (a single value)

The type is encoded in the Type field, while the Bytes fields contains the literal representation of the value as found in the input.

func BoolScalar(b bool) *Scalar

func Float64Scalar(x float64) *Scalar

func Int64Scalar(n int64) *Scalar

func NewKey(tp ScalarType, bytes []byte) *Scalar

func NewScalar(tp ScalarType, bytes []byte) *Scalar

func StringScalar(s string) *Scalar

func ToScalar(value any) (*Scalar, error)

func (s *Scalar) Equal(t *Scalar) bool

func (s *Scalar) EqualsString(str string) bool

func (s *Scalar) IsAlnum() bool

func (s *Scalar) IsKey() bool

func (s *Scalar) IsUnescaped() bool

func (s *Scalar) String() string

func (s *Scalar) ToGo() any

func (s *Scalar) ToString() string

func (s *Scalar) Type() ScalarType

type ScalarType ¶

type ScalarType uint8

ScalarType encodes the four possible JSON scalar types.

type SliceReadStream ¶

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

func NewSliceReadStream(toks []Token) *SliceReadStream

func (r *SliceReadStream) Next() (tok Token)

type StartArray ¶

type StartArray struct{}

StartArray represents the start of a JSON array (introduced by '['). Values of type *StartArray implement the StreamItem interface.

func (s *StartArray) String() string

type StartObject ¶

type StartObject struct{}

StartObject represents the start of a JSON object (introduced by '{'). Values of type *StartObject implement the StreamItem interface.

func (s *StartObject) String() string

type StreamSink ¶

type StreamSink interface {
	Consume(<-chan Token) error
}

type StreamSource ¶

type StreamSource interface {
	Produce(chan<- Token) error
}

type StreamTransformer ¶

type StreamTransformer interface {
	Transform(in <-chan Token, out WriteStream)
}

A StreamTransformer can transform a json stream into another. Use the TransformStream function to apply it.

type Token ¶

type Token interface {
	fmt.Stringer
}

A Token is an item in a stream that encodes a JSON value For example, the JSON value

{"id": 123, "tags": ["important", "new"]}

would be represented by the stream of Token (in pseudocode for clarity):

{            -> StartObject
"id":        -> Scalar("id", String)
123,         -> Scalar(123, Number)
"tags":      -> Scalar("tags", String)
[            -> StartArray
"important", -> Scalar("important", String)
"new"        -> Scalar("new", String)
]            -> EndArray
}            -> EndObject

encoded of a JSON input into a stream of Token values, processing of this stream and outputting the outcome can be done concurrently using channels of Token values.

type WriteStream ¶

type WriteStream interface {
	Put(Token)
}

type Writer ¶

type Writer interface {
	Write([]Token)
}