1338 lines
35 KiB
Go
1338 lines
35 KiB
Go
/*
|
|
* Licensed to the Apache Software Foundation (ASF) under one
|
|
* or more contributor license agreements. See the NOTICE file
|
|
* distributed with this work for additional information
|
|
* regarding copyright ownership. The ASF licenses this file
|
|
* to you under the Apache License, Version 2.0 (the
|
|
* "License"); you may not use this file except in compliance
|
|
* with the License. You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing,
|
|
* software distributed under the License is distributed on an
|
|
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
|
|
* KIND, either express or implied. See the License for the
|
|
* specific language governing permissions and limitations
|
|
* under the License.
|
|
*/
|
|
|
|
package thrift
|
|
|
|
import (
|
|
"bufio"
|
|
"bytes"
|
|
"encoding/base64"
|
|
"encoding/json"
|
|
"fmt"
|
|
"io"
|
|
"math"
|
|
"strconv"
|
|
)
|
|
|
|
type _ParseContext int
|
|
|
|
const (
|
|
_CONTEXT_IN_TOPLEVEL _ParseContext = 1
|
|
_CONTEXT_IN_LIST_FIRST _ParseContext = 2
|
|
_CONTEXT_IN_LIST _ParseContext = 3
|
|
_CONTEXT_IN_OBJECT_FIRST _ParseContext = 4
|
|
_CONTEXT_IN_OBJECT_NEXT_KEY _ParseContext = 5
|
|
_CONTEXT_IN_OBJECT_NEXT_VALUE _ParseContext = 6
|
|
)
|
|
|
|
func (p _ParseContext) String() string {
|
|
switch p {
|
|
case _CONTEXT_IN_TOPLEVEL:
|
|
return "TOPLEVEL"
|
|
case _CONTEXT_IN_LIST_FIRST:
|
|
return "LIST-FIRST"
|
|
case _CONTEXT_IN_LIST:
|
|
return "LIST"
|
|
case _CONTEXT_IN_OBJECT_FIRST:
|
|
return "OBJECT-FIRST"
|
|
case _CONTEXT_IN_OBJECT_NEXT_KEY:
|
|
return "OBJECT-NEXT-KEY"
|
|
case _CONTEXT_IN_OBJECT_NEXT_VALUE:
|
|
return "OBJECT-NEXT-VALUE"
|
|
}
|
|
return "UNKNOWN-PARSE-CONTEXT"
|
|
}
|
|
|
|
// JSON protocol implementation for thrift.
|
|
//
|
|
// This protocol produces/consumes a simple output format
|
|
// suitable for parsing by scripting languages. It should not be
|
|
// confused with the full-featured TJSONProtocol.
|
|
//
|
|
type TSimpleJSONProtocol struct {
|
|
trans TTransport
|
|
|
|
parseContextStack []int
|
|
dumpContext []int
|
|
|
|
writer *bufio.Writer
|
|
reader *bufio.Reader
|
|
}
|
|
|
|
// Constructor
|
|
func NewTSimpleJSONProtocol(t TTransport) *TSimpleJSONProtocol {
|
|
v := &TSimpleJSONProtocol{trans: t,
|
|
writer: bufio.NewWriter(t),
|
|
reader: bufio.NewReader(t),
|
|
}
|
|
v.parseContextStack = append(v.parseContextStack, int(_CONTEXT_IN_TOPLEVEL))
|
|
v.dumpContext = append(v.dumpContext, int(_CONTEXT_IN_TOPLEVEL))
|
|
return v
|
|
}
|
|
|
|
// Factory
|
|
type TSimpleJSONProtocolFactory struct{}
|
|
|
|
func (p *TSimpleJSONProtocolFactory) GetProtocol(trans TTransport) TProtocol {
|
|
return NewTSimpleJSONProtocol(trans)
|
|
}
|
|
|
|
func NewTSimpleJSONProtocolFactory() *TSimpleJSONProtocolFactory {
|
|
return &TSimpleJSONProtocolFactory{}
|
|
}
|
|
|
|
var (
|
|
JSON_COMMA []byte
|
|
JSON_COLON []byte
|
|
JSON_LBRACE []byte
|
|
JSON_RBRACE []byte
|
|
JSON_LBRACKET []byte
|
|
JSON_RBRACKET []byte
|
|
JSON_QUOTE byte
|
|
JSON_QUOTE_BYTES []byte
|
|
JSON_NULL []byte
|
|
JSON_TRUE []byte
|
|
JSON_FALSE []byte
|
|
JSON_INFINITY string
|
|
JSON_NEGATIVE_INFINITY string
|
|
JSON_NAN string
|
|
JSON_INFINITY_BYTES []byte
|
|
JSON_NEGATIVE_INFINITY_BYTES []byte
|
|
JSON_NAN_BYTES []byte
|
|
json_nonbase_map_elem_bytes []byte
|
|
)
|
|
|
|
func init() {
|
|
JSON_COMMA = []byte{','}
|
|
JSON_COLON = []byte{':'}
|
|
JSON_LBRACE = []byte{'{'}
|
|
JSON_RBRACE = []byte{'}'}
|
|
JSON_LBRACKET = []byte{'['}
|
|
JSON_RBRACKET = []byte{']'}
|
|
JSON_QUOTE = '"'
|
|
JSON_QUOTE_BYTES = []byte{'"'}
|
|
JSON_NULL = []byte{'n', 'u', 'l', 'l'}
|
|
JSON_TRUE = []byte{'t', 'r', 'u', 'e'}
|
|
JSON_FALSE = []byte{'f', 'a', 'l', 's', 'e'}
|
|
JSON_INFINITY = "Infinity"
|
|
JSON_NEGATIVE_INFINITY = "-Infinity"
|
|
JSON_NAN = "NaN"
|
|
JSON_INFINITY_BYTES = []byte{'I', 'n', 'f', 'i', 'n', 'i', 't', 'y'}
|
|
JSON_NEGATIVE_INFINITY_BYTES = []byte{'-', 'I', 'n', 'f', 'i', 'n', 'i', 't', 'y'}
|
|
JSON_NAN_BYTES = []byte{'N', 'a', 'N'}
|
|
json_nonbase_map_elem_bytes = []byte{']', ',', '['}
|
|
}
|
|
|
|
func jsonQuote(s string) string {
|
|
b, _ := json.Marshal(s)
|
|
s1 := string(b)
|
|
return s1
|
|
}
|
|
|
|
func jsonUnquote(s string) (string, bool) {
|
|
s1 := new(string)
|
|
err := json.Unmarshal([]byte(s), s1)
|
|
return *s1, err == nil
|
|
}
|
|
|
|
func mismatch(expected, actual string) error {
|
|
return fmt.Errorf("Expected '%s' but found '%s' while parsing JSON.", expected, actual)
|
|
}
|
|
|
|
func (p *TSimpleJSONProtocol) WriteMessageBegin(name string, typeId TMessageType, seqId int32) error {
|
|
p.resetContextStack() // THRIFT-3735
|
|
if e := p.OutputListBegin(); e != nil {
|
|
return e
|
|
}
|
|
if e := p.WriteString(name); e != nil {
|
|
return e
|
|
}
|
|
if e := p.WriteByte(int8(typeId)); e != nil {
|
|
return e
|
|
}
|
|
if e := p.WriteI32(seqId); e != nil {
|
|
return e
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *TSimpleJSONProtocol) WriteMessageEnd() error {
|
|
return p.OutputListEnd()
|
|
}
|
|
|
|
func (p *TSimpleJSONProtocol) WriteStructBegin(name string) error {
|
|
if e := p.OutputObjectBegin(); e != nil {
|
|
return e
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *TSimpleJSONProtocol) WriteStructEnd() error {
|
|
return p.OutputObjectEnd()
|
|
}
|
|
|
|
func (p *TSimpleJSONProtocol) WriteFieldBegin(name string, typeId TType, id int16) error {
|
|
if e := p.WriteString(name); e != nil {
|
|
return e
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *TSimpleJSONProtocol) WriteFieldEnd() error {
|
|
//return p.OutputListEnd()
|
|
return nil
|
|
}
|
|
|
|
func (p *TSimpleJSONProtocol) WriteFieldStop() error { return nil }
|
|
|
|
func (p *TSimpleJSONProtocol) WriteMapBegin(keyType TType, valueType TType, size int) error {
|
|
if e := p.OutputListBegin(); e != nil {
|
|
return e
|
|
}
|
|
if e := p.WriteByte(int8(keyType)); e != nil {
|
|
return e
|
|
}
|
|
if e := p.WriteByte(int8(valueType)); e != nil {
|
|
return e
|
|
}
|
|
return p.WriteI32(int32(size))
|
|
}
|
|
|
|
func (p *TSimpleJSONProtocol) WriteMapEnd() error {
|
|
return p.OutputListEnd()
|
|
}
|
|
|
|
func (p *TSimpleJSONProtocol) WriteListBegin(elemType TType, size int) error {
|
|
return p.OutputElemListBegin(elemType, size)
|
|
}
|
|
|
|
func (p *TSimpleJSONProtocol) WriteListEnd() error {
|
|
return p.OutputListEnd()
|
|
}
|
|
|
|
func (p *TSimpleJSONProtocol) WriteSetBegin(elemType TType, size int) error {
|
|
return p.OutputElemListBegin(elemType, size)
|
|
}
|
|
|
|
func (p *TSimpleJSONProtocol) WriteSetEnd() error {
|
|
return p.OutputListEnd()
|
|
}
|
|
|
|
func (p *TSimpleJSONProtocol) WriteBool(b bool) error {
|
|
return p.OutputBool(b)
|
|
}
|
|
|
|
func (p *TSimpleJSONProtocol) WriteByte(b int8) error {
|
|
return p.WriteI32(int32(b))
|
|
}
|
|
|
|
func (p *TSimpleJSONProtocol) WriteI16(v int16) error {
|
|
return p.WriteI32(int32(v))
|
|
}
|
|
|
|
func (p *TSimpleJSONProtocol) WriteI32(v int32) error {
|
|
return p.OutputI64(int64(v))
|
|
}
|
|
|
|
func (p *TSimpleJSONProtocol) WriteI64(v int64) error {
|
|
return p.OutputI64(int64(v))
|
|
}
|
|
|
|
func (p *TSimpleJSONProtocol) WriteDouble(v float64) error {
|
|
return p.OutputF64(v)
|
|
}
|
|
|
|
func (p *TSimpleJSONProtocol) WriteString(v string) error {
|
|
return p.OutputString(v)
|
|
}
|
|
|
|
func (p *TSimpleJSONProtocol) WriteBinary(v []byte) error {
|
|
// JSON library only takes in a string,
|
|
// not an arbitrary byte array, to ensure bytes are transmitted
|
|
// efficiently we must convert this into a valid JSON string
|
|
// therefore we use base64 encoding to avoid excessive escaping/quoting
|
|
if e := p.OutputPreValue(); e != nil {
|
|
return e
|
|
}
|
|
if _, e := p.write(JSON_QUOTE_BYTES); e != nil {
|
|
return NewTProtocolException(e)
|
|
}
|
|
writer := base64.NewEncoder(base64.StdEncoding, p.writer)
|
|
if _, e := writer.Write(v); e != nil {
|
|
p.writer.Reset(p.trans) // THRIFT-3735
|
|
return NewTProtocolException(e)
|
|
}
|
|
if e := writer.Close(); e != nil {
|
|
return NewTProtocolException(e)
|
|
}
|
|
if _, e := p.write(JSON_QUOTE_BYTES); e != nil {
|
|
return NewTProtocolException(e)
|
|
}
|
|
return p.OutputPostValue()
|
|
}
|
|
|
|
// Reading methods.
|
|
func (p *TSimpleJSONProtocol) ReadMessageBegin() (name string, typeId TMessageType, seqId int32, err error) {
|
|
p.resetContextStack() // THRIFT-3735
|
|
if isNull, err := p.ParseListBegin(); isNull || err != nil {
|
|
return name, typeId, seqId, err
|
|
}
|
|
if name, err = p.ReadString(); err != nil {
|
|
return name, typeId, seqId, err
|
|
}
|
|
bTypeId, err := p.ReadByte()
|
|
typeId = TMessageType(bTypeId)
|
|
if err != nil {
|
|
return name, typeId, seqId, err
|
|
}
|
|
if seqId, err = p.ReadI32(); err != nil {
|
|
return name, typeId, seqId, err
|
|
}
|
|
return name, typeId, seqId, nil
|
|
}
|
|
|
|
func (p *TSimpleJSONProtocol) ReadMessageEnd() error {
|
|
return p.ParseListEnd()
|
|
}
|
|
|
|
func (p *TSimpleJSONProtocol) ReadStructBegin() (name string, err error) {
|
|
_, err = p.ParseObjectStart()
|
|
return "", err
|
|
}
|
|
|
|
func (p *TSimpleJSONProtocol) ReadStructEnd() error {
|
|
return p.ParseObjectEnd()
|
|
}
|
|
|
|
func (p *TSimpleJSONProtocol) ReadFieldBegin() (string, TType, int16, error) {
|
|
if err := p.ParsePreValue(); err != nil {
|
|
return "", STOP, 0, err
|
|
}
|
|
b, _ := p.reader.Peek(1)
|
|
if len(b) > 0 {
|
|
switch b[0] {
|
|
case JSON_RBRACE[0]:
|
|
return "", STOP, 0, nil
|
|
case JSON_QUOTE:
|
|
p.reader.ReadByte()
|
|
name, err := p.ParseStringBody()
|
|
// simplejson is not meant to be read back into thrift
|
|
// - see http://wiki.apache.org/thrift/ThriftUsageJava
|
|
// - use JSON instead
|
|
if err != nil {
|
|
return name, STOP, 0, err
|
|
}
|
|
return name, STOP, -1, p.ParsePostValue()
|
|
/*
|
|
if err = p.ParsePostValue(); err != nil {
|
|
return name, STOP, 0, err
|
|
}
|
|
if isNull, err := p.ParseListBegin(); isNull || err != nil {
|
|
return name, STOP, 0, err
|
|
}
|
|
bType, err := p.ReadByte()
|
|
thetype := TType(bType)
|
|
if err != nil {
|
|
return name, thetype, 0, err
|
|
}
|
|
id, err := p.ReadI16()
|
|
return name, thetype, id, err
|
|
*/
|
|
}
|
|
e := fmt.Errorf("Expected \"}\" or '\"', but found: '%s'", string(b))
|
|
return "", STOP, 0, NewTProtocolExceptionWithType(INVALID_DATA, e)
|
|
}
|
|
return "", STOP, 0, NewTProtocolException(io.EOF)
|
|
}
|
|
|
|
func (p *TSimpleJSONProtocol) ReadFieldEnd() error {
|
|
return nil
|
|
//return p.ParseListEnd()
|
|
}
|
|
|
|
func (p *TSimpleJSONProtocol) ReadMapBegin() (keyType TType, valueType TType, size int, e error) {
|
|
if isNull, e := p.ParseListBegin(); isNull || e != nil {
|
|
return VOID, VOID, 0, e
|
|
}
|
|
|
|
// read keyType
|
|
bKeyType, e := p.ReadByte()
|
|
keyType = TType(bKeyType)
|
|
if e != nil {
|
|
return keyType, valueType, size, e
|
|
}
|
|
|
|
// read valueType
|
|
bValueType, e := p.ReadByte()
|
|
valueType = TType(bValueType)
|
|
if e != nil {
|
|
return keyType, valueType, size, e
|
|
}
|
|
|
|
// read size
|
|
iSize, err := p.ReadI64()
|
|
size = int(iSize)
|
|
return keyType, valueType, size, err
|
|
}
|
|
|
|
func (p *TSimpleJSONProtocol) ReadMapEnd() error {
|
|
return p.ParseListEnd()
|
|
}
|
|
|
|
func (p *TSimpleJSONProtocol) ReadListBegin() (elemType TType, size int, e error) {
|
|
return p.ParseElemListBegin()
|
|
}
|
|
|
|
func (p *TSimpleJSONProtocol) ReadListEnd() error {
|
|
return p.ParseListEnd()
|
|
}
|
|
|
|
func (p *TSimpleJSONProtocol) ReadSetBegin() (elemType TType, size int, e error) {
|
|
return p.ParseElemListBegin()
|
|
}
|
|
|
|
func (p *TSimpleJSONProtocol) ReadSetEnd() error {
|
|
return p.ParseListEnd()
|
|
}
|
|
|
|
func (p *TSimpleJSONProtocol) ReadBool() (bool, error) {
|
|
var value bool
|
|
|
|
if err := p.ParsePreValue(); err != nil {
|
|
return value, err
|
|
}
|
|
f, _ := p.reader.Peek(1)
|
|
if len(f) > 0 {
|
|
switch f[0] {
|
|
case JSON_TRUE[0]:
|
|
b := make([]byte, len(JSON_TRUE))
|
|
_, err := p.reader.Read(b)
|
|
if err != nil {
|
|
return false, NewTProtocolException(err)
|
|
}
|
|
if string(b) == string(JSON_TRUE) {
|
|
value = true
|
|
} else {
|
|
e := fmt.Errorf("Expected \"true\" but found: %s", string(b))
|
|
return value, NewTProtocolExceptionWithType(INVALID_DATA, e)
|
|
}
|
|
break
|
|
case JSON_FALSE[0]:
|
|
b := make([]byte, len(JSON_FALSE))
|
|
_, err := p.reader.Read(b)
|
|
if err != nil {
|
|
return false, NewTProtocolException(err)
|
|
}
|
|
if string(b) == string(JSON_FALSE) {
|
|
value = false
|
|
} else {
|
|
e := fmt.Errorf("Expected \"false\" but found: %s", string(b))
|
|
return value, NewTProtocolExceptionWithType(INVALID_DATA, e)
|
|
}
|
|
break
|
|
case JSON_NULL[0]:
|
|
b := make([]byte, len(JSON_NULL))
|
|
_, err := p.reader.Read(b)
|
|
if err != nil {
|
|
return false, NewTProtocolException(err)
|
|
}
|
|
if string(b) == string(JSON_NULL) {
|
|
value = false
|
|
} else {
|
|
e := fmt.Errorf("Expected \"null\" but found: %s", string(b))
|
|
return value, NewTProtocolExceptionWithType(INVALID_DATA, e)
|
|
}
|
|
default:
|
|
e := fmt.Errorf("Expected \"true\", \"false\", or \"null\" but found: %s", string(f))
|
|
return value, NewTProtocolExceptionWithType(INVALID_DATA, e)
|
|
}
|
|
}
|
|
return value, p.ParsePostValue()
|
|
}
|
|
|
|
func (p *TSimpleJSONProtocol) ReadByte() (int8, error) {
|
|
v, err := p.ReadI64()
|
|
return int8(v), err
|
|
}
|
|
|
|
func (p *TSimpleJSONProtocol) ReadI16() (int16, error) {
|
|
v, err := p.ReadI64()
|
|
return int16(v), err
|
|
}
|
|
|
|
func (p *TSimpleJSONProtocol) ReadI32() (int32, error) {
|
|
v, err := p.ReadI64()
|
|
return int32(v), err
|
|
}
|
|
|
|
func (p *TSimpleJSONProtocol) ReadI64() (int64, error) {
|
|
v, _, err := p.ParseI64()
|
|
return v, err
|
|
}
|
|
|
|
func (p *TSimpleJSONProtocol) ReadDouble() (float64, error) {
|
|
v, _, err := p.ParseF64()
|
|
return v, err
|
|
}
|
|
|
|
func (p *TSimpleJSONProtocol) ReadString() (string, error) {
|
|
var v string
|
|
if err := p.ParsePreValue(); err != nil {
|
|
return v, err
|
|
}
|
|
f, _ := p.reader.Peek(1)
|
|
if len(f) > 0 && f[0] == JSON_QUOTE {
|
|
p.reader.ReadByte()
|
|
value, err := p.ParseStringBody()
|
|
v = value
|
|
if err != nil {
|
|
return v, err
|
|
}
|
|
} else if len(f) > 0 && f[0] == JSON_NULL[0] {
|
|
b := make([]byte, len(JSON_NULL))
|
|
_, err := p.reader.Read(b)
|
|
if err != nil {
|
|
return v, NewTProtocolException(err)
|
|
}
|
|
if string(b) != string(JSON_NULL) {
|
|
e := fmt.Errorf("Expected a JSON string, found unquoted data started with %s", string(b))
|
|
return v, NewTProtocolExceptionWithType(INVALID_DATA, e)
|
|
}
|
|
} else {
|
|
e := fmt.Errorf("Expected a JSON string, found unquoted data started with %s", string(f))
|
|
return v, NewTProtocolExceptionWithType(INVALID_DATA, e)
|
|
}
|
|
return v, p.ParsePostValue()
|
|
}
|
|
|
|
func (p *TSimpleJSONProtocol) ReadBinary() ([]byte, error) {
|
|
var v []byte
|
|
if err := p.ParsePreValue(); err != nil {
|
|
return nil, err
|
|
}
|
|
f, _ := p.reader.Peek(1)
|
|
if len(f) > 0 && f[0] == JSON_QUOTE {
|
|
p.reader.ReadByte()
|
|
value, err := p.ParseBase64EncodedBody()
|
|
v = value
|
|
if err != nil {
|
|
return v, err
|
|
}
|
|
} else if len(f) > 0 && f[0] == JSON_NULL[0] {
|
|
b := make([]byte, len(JSON_NULL))
|
|
_, err := p.reader.Read(b)
|
|
if err != nil {
|
|
return v, NewTProtocolException(err)
|
|
}
|
|
if string(b) != string(JSON_NULL) {
|
|
e := fmt.Errorf("Expected a JSON string, found unquoted data started with %s", string(b))
|
|
return v, NewTProtocolExceptionWithType(INVALID_DATA, e)
|
|
}
|
|
} else {
|
|
e := fmt.Errorf("Expected a JSON string, found unquoted data started with %s", string(f))
|
|
return v, NewTProtocolExceptionWithType(INVALID_DATA, e)
|
|
}
|
|
|
|
return v, p.ParsePostValue()
|
|
}
|
|
|
|
func (p *TSimpleJSONProtocol) Flush() (err error) {
|
|
return NewTProtocolException(p.writer.Flush())
|
|
}
|
|
|
|
func (p *TSimpleJSONProtocol) Skip(fieldType TType) (err error) {
|
|
return SkipDefaultDepth(p, fieldType)
|
|
}
|
|
|
|
func (p *TSimpleJSONProtocol) Transport() TTransport {
|
|
return p.trans
|
|
}
|
|
|
|
func (p *TSimpleJSONProtocol) OutputPreValue() error {
|
|
cxt := _ParseContext(p.dumpContext[len(p.dumpContext)-1])
|
|
switch cxt {
|
|
case _CONTEXT_IN_LIST, _CONTEXT_IN_OBJECT_NEXT_KEY:
|
|
if _, e := p.write(JSON_COMMA); e != nil {
|
|
return NewTProtocolException(e)
|
|
}
|
|
break
|
|
case _CONTEXT_IN_OBJECT_NEXT_VALUE:
|
|
if _, e := p.write(JSON_COLON); e != nil {
|
|
return NewTProtocolException(e)
|
|
}
|
|
break
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *TSimpleJSONProtocol) OutputPostValue() error {
|
|
cxt := _ParseContext(p.dumpContext[len(p.dumpContext)-1])
|
|
switch cxt {
|
|
case _CONTEXT_IN_LIST_FIRST:
|
|
p.dumpContext = p.dumpContext[:len(p.dumpContext)-1]
|
|
p.dumpContext = append(p.dumpContext, int(_CONTEXT_IN_LIST))
|
|
break
|
|
case _CONTEXT_IN_OBJECT_FIRST:
|
|
p.dumpContext = p.dumpContext[:len(p.dumpContext)-1]
|
|
p.dumpContext = append(p.dumpContext, int(_CONTEXT_IN_OBJECT_NEXT_VALUE))
|
|
break
|
|
case _CONTEXT_IN_OBJECT_NEXT_KEY:
|
|
p.dumpContext = p.dumpContext[:len(p.dumpContext)-1]
|
|
p.dumpContext = append(p.dumpContext, int(_CONTEXT_IN_OBJECT_NEXT_VALUE))
|
|
break
|
|
case _CONTEXT_IN_OBJECT_NEXT_VALUE:
|
|
p.dumpContext = p.dumpContext[:len(p.dumpContext)-1]
|
|
p.dumpContext = append(p.dumpContext, int(_CONTEXT_IN_OBJECT_NEXT_KEY))
|
|
break
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *TSimpleJSONProtocol) OutputBool(value bool) error {
|
|
if e := p.OutputPreValue(); e != nil {
|
|
return e
|
|
}
|
|
var v string
|
|
if value {
|
|
v = string(JSON_TRUE)
|
|
} else {
|
|
v = string(JSON_FALSE)
|
|
}
|
|
switch _ParseContext(p.dumpContext[len(p.dumpContext)-1]) {
|
|
case _CONTEXT_IN_OBJECT_FIRST, _CONTEXT_IN_OBJECT_NEXT_KEY:
|
|
v = jsonQuote(v)
|
|
default:
|
|
}
|
|
if e := p.OutputStringData(v); e != nil {
|
|
return e
|
|
}
|
|
return p.OutputPostValue()
|
|
}
|
|
|
|
func (p *TSimpleJSONProtocol) OutputNull() error {
|
|
if e := p.OutputPreValue(); e != nil {
|
|
return e
|
|
}
|
|
if _, e := p.write(JSON_NULL); e != nil {
|
|
return NewTProtocolException(e)
|
|
}
|
|
return p.OutputPostValue()
|
|
}
|
|
|
|
func (p *TSimpleJSONProtocol) OutputF64(value float64) error {
|
|
if e := p.OutputPreValue(); e != nil {
|
|
return e
|
|
}
|
|
var v string
|
|
if math.IsNaN(value) {
|
|
v = string(JSON_QUOTE) + JSON_NAN + string(JSON_QUOTE)
|
|
} else if math.IsInf(value, 1) {
|
|
v = string(JSON_QUOTE) + JSON_INFINITY + string(JSON_QUOTE)
|
|
} else if math.IsInf(value, -1) {
|
|
v = string(JSON_QUOTE) + JSON_NEGATIVE_INFINITY + string(JSON_QUOTE)
|
|
} else {
|
|
v = strconv.FormatFloat(value, 'g', -1, 64)
|
|
switch _ParseContext(p.dumpContext[len(p.dumpContext)-1]) {
|
|
case _CONTEXT_IN_OBJECT_FIRST, _CONTEXT_IN_OBJECT_NEXT_KEY:
|
|
v = string(JSON_QUOTE) + v + string(JSON_QUOTE)
|
|
default:
|
|
}
|
|
}
|
|
if e := p.OutputStringData(v); e != nil {
|
|
return e
|
|
}
|
|
return p.OutputPostValue()
|
|
}
|
|
|
|
func (p *TSimpleJSONProtocol) OutputI64(value int64) error {
|
|
if e := p.OutputPreValue(); e != nil {
|
|
return e
|
|
}
|
|
v := strconv.FormatInt(value, 10)
|
|
switch _ParseContext(p.dumpContext[len(p.dumpContext)-1]) {
|
|
case _CONTEXT_IN_OBJECT_FIRST, _CONTEXT_IN_OBJECT_NEXT_KEY:
|
|
v = jsonQuote(v)
|
|
default:
|
|
}
|
|
if e := p.OutputStringData(v); e != nil {
|
|
return e
|
|
}
|
|
return p.OutputPostValue()
|
|
}
|
|
|
|
func (p *TSimpleJSONProtocol) OutputString(s string) error {
|
|
if e := p.OutputPreValue(); e != nil {
|
|
return e
|
|
}
|
|
if e := p.OutputStringData(jsonQuote(s)); e != nil {
|
|
return e
|
|
}
|
|
return p.OutputPostValue()
|
|
}
|
|
|
|
func (p *TSimpleJSONProtocol) OutputStringData(s string) error {
|
|
_, e := p.write([]byte(s))
|
|
return NewTProtocolException(e)
|
|
}
|
|
|
|
func (p *TSimpleJSONProtocol) OutputObjectBegin() error {
|
|
if e := p.OutputPreValue(); e != nil {
|
|
return e
|
|
}
|
|
if _, e := p.write(JSON_LBRACE); e != nil {
|
|
return NewTProtocolException(e)
|
|
}
|
|
p.dumpContext = append(p.dumpContext, int(_CONTEXT_IN_OBJECT_FIRST))
|
|
return nil
|
|
}
|
|
|
|
func (p *TSimpleJSONProtocol) OutputObjectEnd() error {
|
|
if _, e := p.write(JSON_RBRACE); e != nil {
|
|
return NewTProtocolException(e)
|
|
}
|
|
p.dumpContext = p.dumpContext[:len(p.dumpContext)-1]
|
|
if e := p.OutputPostValue(); e != nil {
|
|
return e
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *TSimpleJSONProtocol) OutputListBegin() error {
|
|
if e := p.OutputPreValue(); e != nil {
|
|
return e
|
|
}
|
|
if _, e := p.write(JSON_LBRACKET); e != nil {
|
|
return NewTProtocolException(e)
|
|
}
|
|
p.dumpContext = append(p.dumpContext, int(_CONTEXT_IN_LIST_FIRST))
|
|
return nil
|
|
}
|
|
|
|
func (p *TSimpleJSONProtocol) OutputListEnd() error {
|
|
if _, e := p.write(JSON_RBRACKET); e != nil {
|
|
return NewTProtocolException(e)
|
|
}
|
|
p.dumpContext = p.dumpContext[:len(p.dumpContext)-1]
|
|
if e := p.OutputPostValue(); e != nil {
|
|
return e
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *TSimpleJSONProtocol) OutputElemListBegin(elemType TType, size int) error {
|
|
if e := p.OutputListBegin(); e != nil {
|
|
return e
|
|
}
|
|
if e := p.WriteByte(int8(elemType)); e != nil {
|
|
return e
|
|
}
|
|
if e := p.WriteI64(int64(size)); e != nil {
|
|
return e
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *TSimpleJSONProtocol) ParsePreValue() error {
|
|
if e := p.readNonSignificantWhitespace(); e != nil {
|
|
return NewTProtocolException(e)
|
|
}
|
|
cxt := _ParseContext(p.parseContextStack[len(p.parseContextStack)-1])
|
|
b, _ := p.reader.Peek(1)
|
|
switch cxt {
|
|
case _CONTEXT_IN_LIST:
|
|
if len(b) > 0 {
|
|
switch b[0] {
|
|
case JSON_RBRACKET[0]:
|
|
return nil
|
|
case JSON_COMMA[0]:
|
|
p.reader.ReadByte()
|
|
if e := p.readNonSignificantWhitespace(); e != nil {
|
|
return NewTProtocolException(e)
|
|
}
|
|
return nil
|
|
default:
|
|
e := fmt.Errorf("Expected \"]\" or \",\" in list context, but found \"%s\"", string(b))
|
|
return NewTProtocolExceptionWithType(INVALID_DATA, e)
|
|
}
|
|
}
|
|
break
|
|
case _CONTEXT_IN_OBJECT_NEXT_KEY:
|
|
if len(b) > 0 {
|
|
switch b[0] {
|
|
case JSON_RBRACE[0]:
|
|
return nil
|
|
case JSON_COMMA[0]:
|
|
p.reader.ReadByte()
|
|
if e := p.readNonSignificantWhitespace(); e != nil {
|
|
return NewTProtocolException(e)
|
|
}
|
|
return nil
|
|
default:
|
|
e := fmt.Errorf("Expected \"}\" or \",\" in object context, but found \"%s\"", string(b))
|
|
return NewTProtocolExceptionWithType(INVALID_DATA, e)
|
|
}
|
|
}
|
|
break
|
|
case _CONTEXT_IN_OBJECT_NEXT_VALUE:
|
|
if len(b) > 0 {
|
|
switch b[0] {
|
|
case JSON_COLON[0]:
|
|
p.reader.ReadByte()
|
|
if e := p.readNonSignificantWhitespace(); e != nil {
|
|
return NewTProtocolException(e)
|
|
}
|
|
return nil
|
|
default:
|
|
e := fmt.Errorf("Expected \":\" in object context, but found \"%s\"", string(b))
|
|
return NewTProtocolExceptionWithType(INVALID_DATA, e)
|
|
}
|
|
}
|
|
break
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *TSimpleJSONProtocol) ParsePostValue() error {
|
|
if e := p.readNonSignificantWhitespace(); e != nil {
|
|
return NewTProtocolException(e)
|
|
}
|
|
cxt := _ParseContext(p.parseContextStack[len(p.parseContextStack)-1])
|
|
switch cxt {
|
|
case _CONTEXT_IN_LIST_FIRST:
|
|
p.parseContextStack = p.parseContextStack[:len(p.parseContextStack)-1]
|
|
p.parseContextStack = append(p.parseContextStack, int(_CONTEXT_IN_LIST))
|
|
break
|
|
case _CONTEXT_IN_OBJECT_FIRST, _CONTEXT_IN_OBJECT_NEXT_KEY:
|
|
p.parseContextStack = p.parseContextStack[:len(p.parseContextStack)-1]
|
|
p.parseContextStack = append(p.parseContextStack, int(_CONTEXT_IN_OBJECT_NEXT_VALUE))
|
|
break
|
|
case _CONTEXT_IN_OBJECT_NEXT_VALUE:
|
|
p.parseContextStack = p.parseContextStack[:len(p.parseContextStack)-1]
|
|
p.parseContextStack = append(p.parseContextStack, int(_CONTEXT_IN_OBJECT_NEXT_KEY))
|
|
break
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *TSimpleJSONProtocol) readNonSignificantWhitespace() error {
|
|
for {
|
|
b, _ := p.reader.Peek(1)
|
|
if len(b) < 1 {
|
|
return nil
|
|
}
|
|
switch b[0] {
|
|
case ' ', '\r', '\n', '\t':
|
|
p.reader.ReadByte()
|
|
continue
|
|
default:
|
|
break
|
|
}
|
|
break
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *TSimpleJSONProtocol) ParseStringBody() (string, error) {
|
|
line, err := p.reader.ReadString(JSON_QUOTE)
|
|
if err != nil {
|
|
return "", NewTProtocolException(err)
|
|
}
|
|
l := len(line)
|
|
// count number of escapes to see if we need to keep going
|
|
i := 1
|
|
for ; i < l; i++ {
|
|
if line[l-i-1] != '\\' {
|
|
break
|
|
}
|
|
}
|
|
if i&0x01 == 1 {
|
|
v, ok := jsonUnquote(string(JSON_QUOTE) + line)
|
|
if !ok {
|
|
return "", NewTProtocolException(err)
|
|
}
|
|
return v, nil
|
|
}
|
|
s, err := p.ParseQuotedStringBody()
|
|
if err != nil {
|
|
return "", NewTProtocolException(err)
|
|
}
|
|
str := string(JSON_QUOTE) + line + s
|
|
v, ok := jsonUnquote(str)
|
|
if !ok {
|
|
e := fmt.Errorf("Unable to parse as JSON string %s", str)
|
|
return "", NewTProtocolExceptionWithType(INVALID_DATA, e)
|
|
}
|
|
return v, nil
|
|
}
|
|
|
|
func (p *TSimpleJSONProtocol) ParseQuotedStringBody() (string, error) {
|
|
line, err := p.reader.ReadString(JSON_QUOTE)
|
|
if err != nil {
|
|
return "", NewTProtocolException(err)
|
|
}
|
|
l := len(line)
|
|
// count number of escapes to see if we need to keep going
|
|
i := 1
|
|
for ; i < l; i++ {
|
|
if line[l-i-1] != '\\' {
|
|
break
|
|
}
|
|
}
|
|
if i&0x01 == 1 {
|
|
return line, nil
|
|
}
|
|
s, err := p.ParseQuotedStringBody()
|
|
if err != nil {
|
|
return "", NewTProtocolException(err)
|
|
}
|
|
v := line + s
|
|
return v, nil
|
|
}
|
|
|
|
func (p *TSimpleJSONProtocol) ParseBase64EncodedBody() ([]byte, error) {
|
|
line, err := p.reader.ReadBytes(JSON_QUOTE)
|
|
if err != nil {
|
|
return line, NewTProtocolException(err)
|
|
}
|
|
line2 := line[0 : len(line)-1]
|
|
l := len(line2)
|
|
if (l % 4) != 0 {
|
|
pad := 4 - (l % 4)
|
|
fill := [...]byte{'=', '=', '='}
|
|
line2 = append(line2, fill[:pad]...)
|
|
l = len(line2)
|
|
}
|
|
output := make([]byte, base64.StdEncoding.DecodedLen(l))
|
|
n, err := base64.StdEncoding.Decode(output, line2)
|
|
return output[0:n], NewTProtocolException(err)
|
|
}
|
|
|
|
func (p *TSimpleJSONProtocol) ParseI64() (int64, bool, error) {
|
|
if err := p.ParsePreValue(); err != nil {
|
|
return 0, false, err
|
|
}
|
|
var value int64
|
|
var isnull bool
|
|
if p.safePeekContains(JSON_NULL) {
|
|
p.reader.Read(make([]byte, len(JSON_NULL)))
|
|
isnull = true
|
|
} else {
|
|
num, err := p.readNumeric()
|
|
isnull = (num == nil)
|
|
if !isnull {
|
|
value = num.Int64()
|
|
}
|
|
if err != nil {
|
|
return value, isnull, err
|
|
}
|
|
}
|
|
return value, isnull, p.ParsePostValue()
|
|
}
|
|
|
|
func (p *TSimpleJSONProtocol) ParseF64() (float64, bool, error) {
|
|
if err := p.ParsePreValue(); err != nil {
|
|
return 0, false, err
|
|
}
|
|
var value float64
|
|
var isnull bool
|
|
if p.safePeekContains(JSON_NULL) {
|
|
p.reader.Read(make([]byte, len(JSON_NULL)))
|
|
isnull = true
|
|
} else {
|
|
num, err := p.readNumeric()
|
|
isnull = (num == nil)
|
|
if !isnull {
|
|
value = num.Float64()
|
|
}
|
|
if err != nil {
|
|
return value, isnull, err
|
|
}
|
|
}
|
|
return value, isnull, p.ParsePostValue()
|
|
}
|
|
|
|
func (p *TSimpleJSONProtocol) ParseObjectStart() (bool, error) {
|
|
if err := p.ParsePreValue(); err != nil {
|
|
return false, err
|
|
}
|
|
var b []byte
|
|
b, err := p.reader.Peek(1)
|
|
if err != nil {
|
|
return false, err
|
|
}
|
|
if len(b) > 0 && b[0] == JSON_LBRACE[0] {
|
|
p.reader.ReadByte()
|
|
p.parseContextStack = append(p.parseContextStack, int(_CONTEXT_IN_OBJECT_FIRST))
|
|
return false, nil
|
|
} else if p.safePeekContains(JSON_NULL) {
|
|
return true, nil
|
|
}
|
|
e := fmt.Errorf("Expected '{' or null, but found '%s'", string(b))
|
|
return false, NewTProtocolExceptionWithType(INVALID_DATA, e)
|
|
}
|
|
|
|
func (p *TSimpleJSONProtocol) ParseObjectEnd() error {
|
|
if isNull, err := p.readIfNull(); isNull || err != nil {
|
|
return err
|
|
}
|
|
cxt := _ParseContext(p.parseContextStack[len(p.parseContextStack)-1])
|
|
if (cxt != _CONTEXT_IN_OBJECT_FIRST) && (cxt != _CONTEXT_IN_OBJECT_NEXT_KEY) {
|
|
e := fmt.Errorf("Expected to be in the Object Context, but not in Object Context (%d)", cxt)
|
|
return NewTProtocolExceptionWithType(INVALID_DATA, e)
|
|
}
|
|
line, err := p.reader.ReadString(JSON_RBRACE[0])
|
|
if err != nil {
|
|
return NewTProtocolException(err)
|
|
}
|
|
for _, char := range line {
|
|
switch char {
|
|
default:
|
|
e := fmt.Errorf("Expecting end of object \"}\", but found: \"%s\"", line)
|
|
return NewTProtocolExceptionWithType(INVALID_DATA, e)
|
|
case ' ', '\n', '\r', '\t', '}':
|
|
break
|
|
}
|
|
}
|
|
p.parseContextStack = p.parseContextStack[:len(p.parseContextStack)-1]
|
|
return p.ParsePostValue()
|
|
}
|
|
|
|
func (p *TSimpleJSONProtocol) ParseListBegin() (isNull bool, err error) {
|
|
if e := p.ParsePreValue(); e != nil {
|
|
return false, e
|
|
}
|
|
var b []byte
|
|
b, err = p.reader.Peek(1)
|
|
if err != nil {
|
|
return false, err
|
|
}
|
|
if len(b) >= 1 && b[0] == JSON_LBRACKET[0] {
|
|
p.parseContextStack = append(p.parseContextStack, int(_CONTEXT_IN_LIST_FIRST))
|
|
p.reader.ReadByte()
|
|
isNull = false
|
|
} else if p.safePeekContains(JSON_NULL) {
|
|
isNull = true
|
|
} else {
|
|
err = fmt.Errorf("Expected \"null\" or \"[\", received %q", b)
|
|
}
|
|
return isNull, NewTProtocolExceptionWithType(INVALID_DATA, err)
|
|
}
|
|
|
|
func (p *TSimpleJSONProtocol) ParseElemListBegin() (elemType TType, size int, e error) {
|
|
if isNull, e := p.ParseListBegin(); isNull || e != nil {
|
|
return VOID, 0, e
|
|
}
|
|
bElemType, err := p.ReadByte()
|
|
elemType = TType(bElemType)
|
|
if err != nil {
|
|
return elemType, size, err
|
|
}
|
|
nSize, err2 := p.ReadI64()
|
|
size = int(nSize)
|
|
return elemType, size, err2
|
|
}
|
|
|
|
func (p *TSimpleJSONProtocol) ParseListEnd() error {
|
|
if isNull, err := p.readIfNull(); isNull || err != nil {
|
|
return err
|
|
}
|
|
cxt := _ParseContext(p.parseContextStack[len(p.parseContextStack)-1])
|
|
if cxt != _CONTEXT_IN_LIST {
|
|
e := fmt.Errorf("Expected to be in the List Context, but not in List Context (%d)", cxt)
|
|
return NewTProtocolExceptionWithType(INVALID_DATA, e)
|
|
}
|
|
line, err := p.reader.ReadString(JSON_RBRACKET[0])
|
|
if err != nil {
|
|
return NewTProtocolException(err)
|
|
}
|
|
for _, char := range line {
|
|
switch char {
|
|
default:
|
|
e := fmt.Errorf("Expecting end of list \"]\", but found: \"%s\"", line)
|
|
return NewTProtocolExceptionWithType(INVALID_DATA, e)
|
|
case ' ', '\n', '\r', '\t', rune(JSON_RBRACKET[0]):
|
|
break
|
|
}
|
|
}
|
|
p.parseContextStack = p.parseContextStack[:len(p.parseContextStack)-1]
|
|
if _ParseContext(p.parseContextStack[len(p.parseContextStack)-1]) == _CONTEXT_IN_TOPLEVEL {
|
|
return nil
|
|
}
|
|
return p.ParsePostValue()
|
|
}
|
|
|
|
func (p *TSimpleJSONProtocol) readSingleValue() (interface{}, TType, error) {
|
|
e := p.readNonSignificantWhitespace()
|
|
if e != nil {
|
|
return nil, VOID, NewTProtocolException(e)
|
|
}
|
|
b, e := p.reader.Peek(1)
|
|
if len(b) > 0 {
|
|
c := b[0]
|
|
switch c {
|
|
case JSON_NULL[0]:
|
|
buf := make([]byte, len(JSON_NULL))
|
|
_, e := p.reader.Read(buf)
|
|
if e != nil {
|
|
return nil, VOID, NewTProtocolException(e)
|
|
}
|
|
if string(JSON_NULL) != string(buf) {
|
|
e = mismatch(string(JSON_NULL), string(buf))
|
|
return nil, VOID, NewTProtocolExceptionWithType(INVALID_DATA, e)
|
|
}
|
|
return nil, VOID, nil
|
|
case JSON_QUOTE:
|
|
p.reader.ReadByte()
|
|
v, e := p.ParseStringBody()
|
|
if e != nil {
|
|
return v, UTF8, NewTProtocolException(e)
|
|
}
|
|
if v == JSON_INFINITY {
|
|
return INFINITY, DOUBLE, nil
|
|
} else if v == JSON_NEGATIVE_INFINITY {
|
|
return NEGATIVE_INFINITY, DOUBLE, nil
|
|
} else if v == JSON_NAN {
|
|
return NAN, DOUBLE, nil
|
|
}
|
|
return v, UTF8, nil
|
|
case JSON_TRUE[0]:
|
|
buf := make([]byte, len(JSON_TRUE))
|
|
_, e := p.reader.Read(buf)
|
|
if e != nil {
|
|
return true, BOOL, NewTProtocolException(e)
|
|
}
|
|
if string(JSON_TRUE) != string(buf) {
|
|
e := mismatch(string(JSON_TRUE), string(buf))
|
|
return true, BOOL, NewTProtocolExceptionWithType(INVALID_DATA, e)
|
|
}
|
|
return true, BOOL, nil
|
|
case JSON_FALSE[0]:
|
|
buf := make([]byte, len(JSON_FALSE))
|
|
_, e := p.reader.Read(buf)
|
|
if e != nil {
|
|
return false, BOOL, NewTProtocolException(e)
|
|
}
|
|
if string(JSON_FALSE) != string(buf) {
|
|
e := mismatch(string(JSON_FALSE), string(buf))
|
|
return false, BOOL, NewTProtocolExceptionWithType(INVALID_DATA, e)
|
|
}
|
|
return false, BOOL, nil
|
|
case JSON_LBRACKET[0]:
|
|
_, e := p.reader.ReadByte()
|
|
return make([]interface{}, 0), LIST, NewTProtocolException(e)
|
|
case JSON_LBRACE[0]:
|
|
_, e := p.reader.ReadByte()
|
|
return make(map[string]interface{}), STRUCT, NewTProtocolException(e)
|
|
case '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'e', 'E', '.', '+', '-', JSON_INFINITY[0], JSON_NAN[0]:
|
|
// assume numeric
|
|
v, e := p.readNumeric()
|
|
return v, DOUBLE, e
|
|
default:
|
|
e := fmt.Errorf("Expected element in list but found '%s' while parsing JSON.", string(c))
|
|
return nil, VOID, NewTProtocolExceptionWithType(INVALID_DATA, e)
|
|
}
|
|
}
|
|
e = fmt.Errorf("Cannot read a single element while parsing JSON.")
|
|
return nil, VOID, NewTProtocolExceptionWithType(INVALID_DATA, e)
|
|
|
|
}
|
|
|
|
func (p *TSimpleJSONProtocol) readIfNull() (bool, error) {
|
|
cont := true
|
|
for cont {
|
|
b, _ := p.reader.Peek(1)
|
|
if len(b) < 1 {
|
|
return false, nil
|
|
}
|
|
switch b[0] {
|
|
default:
|
|
return false, nil
|
|
case JSON_NULL[0]:
|
|
cont = false
|
|
break
|
|
case ' ', '\n', '\r', '\t':
|
|
p.reader.ReadByte()
|
|
break
|
|
}
|
|
}
|
|
if p.safePeekContains(JSON_NULL) {
|
|
p.reader.Read(make([]byte, len(JSON_NULL)))
|
|
return true, nil
|
|
}
|
|
return false, nil
|
|
}
|
|
|
|
func (p *TSimpleJSONProtocol) readQuoteIfNext() {
|
|
b, _ := p.reader.Peek(1)
|
|
if len(b) > 0 && b[0] == JSON_QUOTE {
|
|
p.reader.ReadByte()
|
|
}
|
|
}
|
|
|
|
func (p *TSimpleJSONProtocol) readNumeric() (Numeric, error) {
|
|
isNull, err := p.readIfNull()
|
|
if isNull || err != nil {
|
|
return NUMERIC_NULL, err
|
|
}
|
|
hasDecimalPoint := false
|
|
nextCanBeSign := true
|
|
hasE := false
|
|
MAX_LEN := 40
|
|
buf := bytes.NewBuffer(make([]byte, 0, MAX_LEN))
|
|
continueFor := true
|
|
inQuotes := false
|
|
for continueFor {
|
|
c, err := p.reader.ReadByte()
|
|
if err != nil {
|
|
if err == io.EOF {
|
|
break
|
|
}
|
|
return NUMERIC_NULL, NewTProtocolException(err)
|
|
}
|
|
switch c {
|
|
case '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
|
|
buf.WriteByte(c)
|
|
nextCanBeSign = false
|
|
case '.':
|
|
if hasDecimalPoint {
|
|
e := fmt.Errorf("Unable to parse number with multiple decimal points '%s.'", buf.String())
|
|
return NUMERIC_NULL, NewTProtocolExceptionWithType(INVALID_DATA, e)
|
|
}
|
|
if hasE {
|
|
e := fmt.Errorf("Unable to parse number with decimal points in the exponent '%s.'", buf.String())
|
|
return NUMERIC_NULL, NewTProtocolExceptionWithType(INVALID_DATA, e)
|
|
}
|
|
buf.WriteByte(c)
|
|
hasDecimalPoint, nextCanBeSign = true, false
|
|
case 'e', 'E':
|
|
if hasE {
|
|
e := fmt.Errorf("Unable to parse number with multiple exponents '%s%c'", buf.String(), c)
|
|
return NUMERIC_NULL, NewTProtocolExceptionWithType(INVALID_DATA, e)
|
|
}
|
|
buf.WriteByte(c)
|
|
hasE, nextCanBeSign = true, true
|
|
case '-', '+':
|
|
if !nextCanBeSign {
|
|
e := fmt.Errorf("Negative sign within number")
|
|
return NUMERIC_NULL, NewTProtocolExceptionWithType(INVALID_DATA, e)
|
|
}
|
|
buf.WriteByte(c)
|
|
nextCanBeSign = false
|
|
case ' ', 0, '\t', '\n', '\r', JSON_RBRACE[0], JSON_RBRACKET[0], JSON_COMMA[0], JSON_COLON[0]:
|
|
p.reader.UnreadByte()
|
|
continueFor = false
|
|
case JSON_NAN[0]:
|
|
if buf.Len() == 0 {
|
|
buffer := make([]byte, len(JSON_NAN))
|
|
buffer[0] = c
|
|
_, e := p.reader.Read(buffer[1:])
|
|
if e != nil {
|
|
return NUMERIC_NULL, NewTProtocolException(e)
|
|
}
|
|
if JSON_NAN != string(buffer) {
|
|
e := mismatch(JSON_NAN, string(buffer))
|
|
return NUMERIC_NULL, NewTProtocolExceptionWithType(INVALID_DATA, e)
|
|
}
|
|
if inQuotes {
|
|
p.readQuoteIfNext()
|
|
}
|
|
return NAN, nil
|
|
} else {
|
|
e := fmt.Errorf("Unable to parse number starting with character '%c'", c)
|
|
return NUMERIC_NULL, NewTProtocolExceptionWithType(INVALID_DATA, e)
|
|
}
|
|
case JSON_INFINITY[0]:
|
|
if buf.Len() == 0 || (buf.Len() == 1 && buf.Bytes()[0] == '+') {
|
|
buffer := make([]byte, len(JSON_INFINITY))
|
|
buffer[0] = c
|
|
_, e := p.reader.Read(buffer[1:])
|
|
if e != nil {
|
|
return NUMERIC_NULL, NewTProtocolException(e)
|
|
}
|
|
if JSON_INFINITY != string(buffer) {
|
|
e := mismatch(JSON_INFINITY, string(buffer))
|
|
return NUMERIC_NULL, NewTProtocolExceptionWithType(INVALID_DATA, e)
|
|
}
|
|
if inQuotes {
|
|
p.readQuoteIfNext()
|
|
}
|
|
return INFINITY, nil
|
|
} else if buf.Len() == 1 && buf.Bytes()[0] == JSON_NEGATIVE_INFINITY[0] {
|
|
buffer := make([]byte, len(JSON_NEGATIVE_INFINITY))
|
|
buffer[0] = JSON_NEGATIVE_INFINITY[0]
|
|
buffer[1] = c
|
|
_, e := p.reader.Read(buffer[2:])
|
|
if e != nil {
|
|
return NUMERIC_NULL, NewTProtocolException(e)
|
|
}
|
|
if JSON_NEGATIVE_INFINITY != string(buffer) {
|
|
e := mismatch(JSON_NEGATIVE_INFINITY, string(buffer))
|
|
return NUMERIC_NULL, NewTProtocolExceptionWithType(INVALID_DATA, e)
|
|
}
|
|
if inQuotes {
|
|
p.readQuoteIfNext()
|
|
}
|
|
return NEGATIVE_INFINITY, nil
|
|
} else {
|
|
e := fmt.Errorf("Unable to parse number starting with character '%c' due to existing buffer %s", c, buf.String())
|
|
return NUMERIC_NULL, NewTProtocolExceptionWithType(INVALID_DATA, e)
|
|
}
|
|
case JSON_QUOTE:
|
|
if !inQuotes {
|
|
inQuotes = true
|
|
} else {
|
|
break
|
|
}
|
|
default:
|
|
e := fmt.Errorf("Unable to parse number starting with character '%c'", c)
|
|
return NUMERIC_NULL, NewTProtocolExceptionWithType(INVALID_DATA, e)
|
|
}
|
|
}
|
|
if buf.Len() == 0 {
|
|
e := fmt.Errorf("Unable to parse number from empty string ''")
|
|
return NUMERIC_NULL, NewTProtocolExceptionWithType(INVALID_DATA, e)
|
|
}
|
|
return NewNumericFromJSONString(buf.String(), false), nil
|
|
}
|
|
|
|
// Safely peeks into the buffer, reading only what is necessary
|
|
func (p *TSimpleJSONProtocol) safePeekContains(b []byte) bool {
|
|
for i := 0; i < len(b); i++ {
|
|
a, _ := p.reader.Peek(i + 1)
|
|
if len(a) == 0 || a[i] != b[i] {
|
|
return false
|
|
}
|
|
}
|
|
return true
|
|
}
|
|
|
|
// Reset the context stack to its initial state.
|
|
func (p *TSimpleJSONProtocol) resetContextStack() {
|
|
p.parseContextStack = []int{int(_CONTEXT_IN_TOPLEVEL)}
|
|
p.dumpContext = []int{int(_CONTEXT_IN_TOPLEVEL)}
|
|
}
|
|
|
|
func (p *TSimpleJSONProtocol) write(b []byte) (int, error) {
|
|
n, err := p.writer.Write(b)
|
|
if err != nil {
|
|
p.writer.Reset(p.trans) // THRIFT-3735
|
|
}
|
|
return n, err
|
|
}
|