Subversion Repositories SmartDukaan

/*

 * 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 org.apache.thrift.protocol;

import org.apache.thrift.TException;

import org.apache.thrift.TByteArrayOutputStream;

import org.apache.thrift.transport.TTransport;

import java.io.UnsupportedEncodingException;

import java.util.Stack;

/**

 * JSON protocol implementation for thrift.

 *

 * This is a full-featured protocol supporting write and read.

 *

 * Please see the C++ class header for a detailed description of the

 * protocol's wire format.

 *

 */

public class TJSONProtocol extends TProtocol {

  /**

   * Factory for JSON protocol objects

   */

  public static class Factory implements TProtocolFactory {

    public TProtocol getProtocol(TTransport trans) {

      return new TJSONProtocol(trans);

    }

  }

  private static final byte[] COMMA = new byte[] {','};

  private static final byte[] COLON = new byte[] {':'};

  private static final byte[] LBRACE = new byte[] {'{'};

  private static final byte[] RBRACE = new byte[] {'}'};

  private static final byte[] LBRACKET = new byte[] {'['};

  private static final byte[] RBRACKET = new byte[] {']'};

  private static final byte[] QUOTE = new byte[] {'"'};

  private static final byte[] BACKSLASH = new byte[] {'\\'};

  private static final byte[] ZERO = new byte[] {'0'};

  private static final byte[] ESCSEQ = new byte[] {'\\','u','0','0'};

  private static final long  VERSION = 1;

  private static final byte[] JSON_CHAR_TABLE = {

    /*  0   1   2   3   4   5   6   7   8   9   A   B   C   D   E   F */

    0,  0,  0,  0,  0,  0,  0,  0,'b','t','n',  0,'f','r',  0,  0, // 0

    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, // 1

    1,  1,'"',  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1, // 2

  };

  private static final String ESCAPE_CHARS = "\"\\bfnrt";

  private static final byte[] ESCAPE_CHAR_VALS = {

    '"', '\\', '\b', '\f', '\n', '\r', '\t',

  };

  private static final int  DEF_STRING_SIZE = 16;

  private static final byte[] NAME_BOOL = new byte[] {'t', 'f'};

  private static final byte[] NAME_BYTE = new byte[] {'i','8'};

  private static final byte[] NAME_I16 = new byte[] {'i','1','6'};

  private static final byte[] NAME_I32 = new byte[] {'i','3','2'};

  private static final byte[] NAME_I64 = new byte[] {'i','6','4'};

  private static final byte[] NAME_DOUBLE = new byte[] {'d','b','l'};

  private static final byte[] NAME_STRUCT = new byte[] {'r','e','c'};

  private static final byte[] NAME_STRING = new byte[] {'s','t','r'};

  private static final byte[] NAME_MAP = new byte[] {'m','a','p'};

  private static final byte[] NAME_LIST = new byte[] {'l','s','t'};

  private static final byte[] NAME_SET = new byte[] {'s','e','t'};

  private static final TStruct ANONYMOUS_STRUCT = new TStruct();

  private static final byte[] getTypeNameForTypeID(byte typeID)

    throws TException {

    switch (typeID) {

    case TType.BOOL:

      return NAME_BOOL;

    case TType.BYTE:

      return NAME_BYTE;

    case TType.I16:

      return NAME_I16;

    case TType.I32:

      return NAME_I32;

    case TType.I64:

      return NAME_I64;

    case TType.DOUBLE:

      return NAME_DOUBLE;

    case TType.STRING:

      return NAME_STRING;

    case TType.STRUCT:

      return NAME_STRUCT;

    case TType.MAP:

      return NAME_MAP;

    case TType.SET:

      return NAME_SET;

    case TType.LIST:

      return NAME_LIST;

    default:

      throw new TProtocolException(TProtocolException.NOT_IMPLEMENTED,

                                   "Unrecognized type");

    }

  }

  private static final byte getTypeIDForTypeName(byte[] name)

    throws TException {

    byte result = TType.STOP;

    if (name.length > 1) {

      switch (name[0]) {

      case 'd':

        result = TType.DOUBLE;

        break;

      case 'i':

        switch (name[1]) {

        case '8':

          result = TType.BYTE;

          break;

        case '1':

          result = TType.I16;

          break;

        case '3':

          result = TType.I32;

          break;

        case '6':

          result = TType.I64;

          break;

        }

        break;

      case 'l':

        result = TType.LIST;

        break;

      case 'm':

        result = TType.MAP;

        break;

      case 'r':

        result = TType.STRUCT;

        break;

      case 's':

        if (name[1] == 't') {

          result = TType.STRING;

        }

        else if (name[1] == 'e') {

          result = TType.SET;

        }

        break;

      case 't':

        result = TType.BOOL;

        break;

      }

    }

    if (result == TType.STOP) {

      throw new TProtocolException(TProtocolException.NOT_IMPLEMENTED,

                                   "Unrecognized type");

    }

    return result;

  }

  // Base class for tracking JSON contexts that may require inserting/reading

  // additional JSON syntax characters

  // This base context does nothing.

  protected class JSONBaseContext {

    protected void write() throws TException {}

    protected void read() throws TException {}

    protected boolean escapeNum() { return false; }

  }

  // Context for JSON lists. Will insert/read commas before each item except

  // for the first one

  protected class JSONListContext extends JSONBaseContext {

    private boolean first_ = true;

    @Override

    protected void write() throws TException {

      if (first_) {

        first_ = false;

      } else {

        trans_.write(COMMA);

      }

    }

    @Override

    protected void read() throws TException {

      if (first_) {

        first_ = false;

      } else {

        readJSONSyntaxChar(COMMA);

      }

    }

  }

  // Context for JSON records. Will insert/read colons before the value portion

  // of each record pair, and commas before each key except the first. In

  // addition, will indicate that numbers in the key position need to be

  // escaped in quotes (since JSON keys must be strings).

  protected class JSONPairContext extends JSONBaseContext {

    private boolean first_ = true;

    private boolean colon_ = true;

    @Override

    protected void write() throws TException {

      if (first_) {

        first_ = false;

        colon_ = true;

      } else {

        trans_.write(colon_ ? COLON : COMMA);

        colon_ = !colon_;

      }

    }

    @Override

    protected void read() throws TException {

      if (first_) {

        first_ = false;

        colon_ = true;

      } else {

        readJSONSyntaxChar(colon_ ? COLON : COMMA);

        colon_ = !colon_;

      }

    }

    @Override

    protected boolean escapeNum() {

      return colon_;

    }

  }

  // Holds up to one byte from the transport

  protected class LookaheadReader {

    private boolean hasData_;

    private byte[] data_ = new byte[1];

    // Return and consume the next byte to be read, either taking it from the

    // data buffer if present or getting it from the transport otherwise.

    protected byte read() throws TException {

      if (hasData_) {

        hasData_ = false;

      }

      else {

        trans_.readAll(data_, 0, 1);

      }

      return data_[0];

    }

    // Return the next byte to be read without consuming, filling the data

    // buffer if it has not been filled already.

    protected byte peek() throws TException {

      if (!hasData_) {

        trans_.readAll(data_, 0, 1);

      }

      hasData_ = true;

      return data_[0];

    }

  }

  // Stack of nested contexts that we may be in

  private Stack<JSONBaseContext> contextStack_ = new Stack<JSONBaseContext>();

  // Current context that we are in

  private JSONBaseContext context_ = new JSONBaseContext();

  // Reader that manages a 1-byte buffer

  private LookaheadReader reader_ = new LookaheadReader();

  // Push a new JSON context onto the stack.

  private void pushContext(JSONBaseContext c) {

    contextStack_.push(context_);

    context_ = c;

  }

  // Pop the last JSON context off the stack

  private void popContext() {

    context_ = contextStack_.pop();

  }

  /**

   * Constructor

   */

  public TJSONProtocol(TTransport trans) {

    super(trans);

  }

  // Temporary buffer used by several methods

  private byte[] tmpbuf_ = new byte[4];

  // Read a byte that must match b[0]; otherwise an excpetion is thrown.

  // Marked protected to avoid synthetic accessor in JSONListContext.read

  // and JSONPairContext.read

  protected void readJSONSyntaxChar(byte[] b) throws TException {

    byte ch = reader_.read();

    if (ch != b[0]) {

      throw new TProtocolException(TProtocolException.INVALID_DATA,

                                   "Unexpected character:" + (char)ch);

    }

  }

  // Convert a byte containing a hex char ('0'-'9' or 'a'-'f') into its

  // corresponding hex value

  private static final byte hexVal(byte ch) throws TException {

    if ((ch >= '0') && (ch <= '9')) {

      return (byte)((char)ch - '0');

    }

    else if ((ch >= 'a') && (ch <= 'f')) {

      return (byte)((char)ch - 'a');

    }

    else {

      throw new TProtocolException(TProtocolException.INVALID_DATA,

                                   "Expected hex character");

    }

  }

  // Convert a byte containing a hex value to its corresponding hex character

  private static final byte hexChar(byte val) {

    val &= 0x0F;

    if (val < 10) {

      return (byte)((char)val + '0');

    }

    else {

      return (byte)((char)val + 'a');

    }

  }

  // Write the bytes in array buf as a JSON characters, escaping as needed

  private void writeJSONString(byte[] b) throws TException {

    context_.write();

    trans_.write(QUOTE);

    int len = b.length;

    for (int i = 0; i < len; i++) {

      if ((b[i] & 0x00FF) >= 0x30) {

        if (b[i] == BACKSLASH[0]) {

          trans_.write(BACKSLASH);

          trans_.write(BACKSLASH);

        }

        else {

          trans_.write(b, i, 1);

        }

      }

      else {

        tmpbuf_[0] = JSON_CHAR_TABLE[b[i]];

        if (tmpbuf_[0] == 1) {

          trans_.write(b, i, 1);

        }

        else if (tmpbuf_[0] > 1) {

          trans_.write(BACKSLASH);

          trans_.write(tmpbuf_, 0, 1);

        }

        else {

          trans_.write(ESCSEQ);

          tmpbuf_[0] = hexChar((byte)(b[i] >> 4));

          tmpbuf_[1] = hexChar(b[i]);

          trans_.write(tmpbuf_, 0, 2);

        }

      }

    }

    trans_.write(QUOTE);

  }

  // Write out number as a JSON value. If the context dictates so, it will be

  // wrapped in quotes to output as a JSON string.

  private void writeJSONInteger(long num) throws TException {

    context_.write();

    String str = Long.toString(num);

    boolean escapeNum = context_.escapeNum();

    if (escapeNum) {

      trans_.write(QUOTE);

    }

    try {

      byte[] buf = str.getBytes("UTF-8");

      trans_.write(buf);

    } catch (UnsupportedEncodingException uex) {

      throw new TException("JVM DOES NOT SUPPORT UTF-8");

    }

    if (escapeNum) {

      trans_.write(QUOTE);

    }

  }

  // Write out a double as a JSON value. If it is NaN or infinity or if the

  // context dictates escaping, write out as JSON string.

  private void writeJSONDouble(double num) throws TException {

    context_.write();

    String str = Double.toString(num);

    boolean special = false;

    switch (str.charAt(0)) {

    case 'N': // NaN

    case 'I': // Infinity

      special = true;

      break;

    case '-':

      if (str.charAt(1) == 'I') { // -Infinity

        special = true;

      }

      break;

    }

    boolean escapeNum = special || context_.escapeNum();

    if (escapeNum) {

      trans_.write(QUOTE);

    }

    try {

      byte[] b = str.getBytes("UTF-8");

      trans_.write(b, 0, b.length);

    } catch (UnsupportedEncodingException uex) {

      throw new TException("JVM DOES NOT SUPPORT UTF-8");

    }

    if (escapeNum) {

      trans_.write(QUOTE);

    }

  }

  // Write out contents of byte array b as a JSON string with base-64 encoded

  // data

  private void writeJSONBase64(byte[] b) throws TException {

    context_.write();

    trans_.write(QUOTE);

    int len = b.length;

    int off = 0;

    while (len >= 3) {

      // Encode 3 bytes at a time

      TBase64Utils.encode(b, off, 3, tmpbuf_, 0);

      trans_.write(tmpbuf_, 0, 4);

      off += 3;

      len -= 3;

    }

    if (len > 0) {

      // Encode remainder

      TBase64Utils.encode(b, off, len, tmpbuf_, 0);

      trans_.write(tmpbuf_, 0, len + 1);

    }

    trans_.write(QUOTE);

  }

  private void writeJSONObjectStart() throws TException {

    context_.write();

    trans_.write(LBRACE);

    pushContext(new JSONPairContext());

  }

  private void writeJSONObjectEnd() throws TException {

    popContext();

    trans_.write(RBRACE);

  }

  private void writeJSONArrayStart() throws TException {

    context_.write();

    trans_.write(LBRACKET);

    pushContext(new JSONListContext());

  }

  private void writeJSONArrayEnd() throws TException {

    popContext();

    trans_.write(RBRACKET);

  }

  @Override

  public void writeMessageBegin(TMessage message) throws TException {

    writeJSONArrayStart();

    writeJSONInteger(VERSION);

    try {

      byte[] b = message.name.getBytes("UTF-8");

      writeJSONString(b);

    } catch (UnsupportedEncodingException uex) {

      throw new TException("JVM DOES NOT SUPPORT UTF-8");

    }

    writeJSONInteger(message.type);

    writeJSONInteger(message.seqid);

  }

  @Override

  public void writeMessageEnd() throws TException {

    writeJSONArrayEnd();

  }

  @Override

  public void writeStructBegin(TStruct struct) throws TException {

    writeJSONObjectStart();

  }

  @Override

  public void writeStructEnd() throws TException {

    writeJSONObjectEnd();

  }

  @Override

  public void writeFieldBegin(TField field) throws TException {

    writeJSONInteger(field.id);

    writeJSONObjectStart();

    writeJSONString(getTypeNameForTypeID(field.type));

  }

  @Override

  public void writeFieldEnd() throws TException {

    writeJSONObjectEnd();

  }

  @Override

  public void writeFieldStop() {}

  @Override

  public void writeMapBegin(TMap map) throws TException {

    writeJSONArrayStart();

    writeJSONString(getTypeNameForTypeID(map.keyType));

    writeJSONString(getTypeNameForTypeID(map.valueType));

    writeJSONInteger(map.size);

    writeJSONObjectStart();

  }

  @Override

  public void writeMapEnd() throws TException {

    writeJSONObjectEnd();

    writeJSONArrayEnd();

  }

  @Override

  public void writeListBegin(TList list) throws TException {

    writeJSONArrayStart();

    writeJSONString(getTypeNameForTypeID(list.elemType));

    writeJSONInteger(list.size);

  }

  @Override

  public void writeListEnd() throws TException {

    writeJSONArrayEnd();

  }

  @Override

  public void writeSetBegin(TSet set) throws TException {

    writeJSONArrayStart();

    writeJSONString(getTypeNameForTypeID(set.elemType));

    writeJSONInteger(set.size);

  }

  @Override

  public void writeSetEnd() throws TException {

    writeJSONArrayEnd();

  }

  @Override

  public void writeBool(boolean b) throws TException {

    writeJSONInteger(b ? (long)1 : (long)0);

  }

  @Override

  public void writeByte(byte b) throws TException {

    writeJSONInteger((long)b);

  }

  @Override

  public void writeI16(short i16) throws TException {

    writeJSONInteger((long)i16);

  }

  @Override

  public void writeI32(int i32) throws TException {

    writeJSONInteger((long)i32);

  }

  @Override

  public void writeI64(long i64) throws TException {

    writeJSONInteger(i64);

  }

  @Override

  public void writeDouble(double dub) throws TException {

    writeJSONDouble(dub);

  }

  @Override

  public void writeString(String str) throws TException {

    try {

      byte[] b = str.getBytes("UTF-8");

      writeJSONString(b);

    } catch (UnsupportedEncodingException uex) {

      throw new TException("JVM DOES NOT SUPPORT UTF-8");

    }

  }

  @Override

  public void writeBinary(byte[] bin) throws TException {

    writeJSONBase64(bin);

  }

  /**

   * Reading methods.

   */

  // Read in a JSON string, unescaping as appropriate.. Skip reading from the

  // context if skipContext is true.

  private TByteArrayOutputStream readJSONString(boolean skipContext)

    throws TException {

    TByteArrayOutputStream arr = new TByteArrayOutputStream(DEF_STRING_SIZE);

    if (!skipContext) {

      context_.read();

    }

    readJSONSyntaxChar(QUOTE);

    while (true) {

      byte ch = reader_.read();

      if (ch == QUOTE[0]) {

        break;

      }

      if (ch == ESCSEQ[0]) {

        ch = reader_.read();

        if (ch == ESCSEQ[1]) {

          readJSONSyntaxChar(ZERO);

          readJSONSyntaxChar(ZERO);

          trans_.readAll(tmpbuf_, 0, 2);

          ch = (byte)((hexVal((byte)tmpbuf_[0]) << 4) + hexVal(tmpbuf_[1]));

        }

        else {

          int off = ESCAPE_CHARS.indexOf(ch);

          if (off == -1) {

            throw new TProtocolException(TProtocolException.INVALID_DATA,

                                         "Expected control char");

          }

          ch = ESCAPE_CHAR_VALS[off];

        }

      }

      arr.write(ch);

    }

    return arr;

  }

  // Return true if the given byte could be a valid part of a JSON number.

  private boolean isJSONNumeric(byte b) {

    switch (b) {

    case '+':

    case '-':

    case '.':

    case '0':

    case '1':

    case '2':

    case '3':

    case '4':

    case '5':

    case '6':

    case '7':

    case '8':

    case '9':

    case 'E':

    case 'e':

      return true;

    }

    return false;

  }

  // Read in a sequence of characters that are all valid in JSON numbers. Does

  // not do a complete regex check to validate that this is actually a number.

  private String readJSONNumericChars() throws TException {

    StringBuilder strbld = new StringBuilder();

    while (true) {

      byte ch = reader_.peek();

      if (!isJSONNumeric(ch)) {

        break;

      }

      strbld.append((char)reader_.read());

    }

    return strbld.toString();

  }

  // Read in a JSON number. If the context dictates, read in enclosing quotes.

  private long readJSONInteger() throws TException {

    context_.read();

    if (context_.escapeNum()) {

      readJSONSyntaxChar(QUOTE);

    }

    String str = readJSONNumericChars();

    if (context_.escapeNum()) {

      readJSONSyntaxChar(QUOTE);

    }

    try {

      return Long.valueOf(str);

    }

    catch (NumberFormatException ex) {

      throw new TProtocolException(TProtocolException.INVALID_DATA,

                                   "Bad data encounted in numeric data");

    }

  }

  // Read in a JSON double value. Throw if the value is not wrapped in quotes

  // when expected or if wrapped in quotes when not expected.

  private double readJSONDouble() throws TException {

    context_.read();

    if (reader_.peek() == QUOTE[0]) {

      TByteArrayOutputStream arr = readJSONString(true);

      try {

        double dub = Double.valueOf(arr.toString("UTF-8"));

        if (!context_.escapeNum() && !Double.isNaN(dub) &&

            !Double.isInfinite(dub)) {

          // Throw exception -- we should not be in a string in this case

          throw new TProtocolException(TProtocolException.INVALID_DATA,

                                       "Numeric data unexpectedly quoted");

        }

        return dub;

      }

      catch (UnsupportedEncodingException ex) {

        throw new TException("JVM DOES NOT SUPPORT UTF-8");

      }

    }

    else {

      if (context_.escapeNum()) {

        // This will throw - we should have had a quote if escapeNum == true

        readJSONSyntaxChar(QUOTE);

      }

      try {

        return Double.valueOf(readJSONNumericChars());

      }

      catch (NumberFormatException ex) {

        throw new TProtocolException(TProtocolException.INVALID_DATA,

                                     "Bad data encounted in numeric data");

      }

    }

  }

  // Read in a JSON string containing base-64 encoded data and decode it.

  private byte[] readJSONBase64() throws TException {

    TByteArrayOutputStream arr = readJSONString(false);

    byte[] b = arr.get();

    int len = arr.len();

    int off = 0;

    int size = 0;

    while (len >= 4) {

      // Decode 4 bytes at a time

      TBase64Utils.decode(b, off, 4, b, size); // NB: decoded in place

      off += 4;

      len -= 4;

      size += 3;

    }

    // Don't decode if we hit the end or got a single leftover byte (invalid

    // base64 but legal for skip of regular string type)

    if (len > 1) {

      // Decode remainder

      TBase64Utils.decode(b, off, len, b, size); // NB: decoded in place

      size += len - 1;

    }

    // Sadly we must copy the byte[] (any way around this?)

    byte [] result = new byte[size];

    System.arraycopy(b, 0, result, 0, size);

    return result;

  }

  private void readJSONObjectStart() throws TException {

    context_.read();

    readJSONSyntaxChar(LBRACE);

    pushContext(new JSONPairContext());

  }

  private void readJSONObjectEnd() throws TException {

    readJSONSyntaxChar(RBRACE);

    popContext();

  }

  private void readJSONArrayStart() throws TException {

    context_.read();

    readJSONSyntaxChar(LBRACKET);

    pushContext(new JSONListContext());

  }

  private void readJSONArrayEnd() throws TException {

    readJSONSyntaxChar(RBRACKET);

    popContext();

  }

  @Override

  public TMessage readMessageBegin() throws TException {

    readJSONArrayStart();

    if (readJSONInteger() != VERSION) {

      throw new TProtocolException(TProtocolException.BAD_VERSION,

                                   "Message contained bad version.");

    }

    String name;

    try {

      name = readJSONString(false).toString("UTF-8");

    }

    catch (UnsupportedEncodingException ex) {

      throw new TException("JVM DOES NOT SUPPORT UTF-8");

    }

    byte type = (byte) readJSONInteger();

    int seqid = (int) readJSONInteger();

    return new TMessage(name, type, seqid);

  }

  @Override

  public void readMessageEnd() throws TException {

    readJSONArrayEnd();

  }

  @Override

  public TStruct readStructBegin() throws TException {

    readJSONObjectStart();

    return ANONYMOUS_STRUCT;

  }

  @Override

  public void readStructEnd() throws TException {

    readJSONObjectEnd();

  }

  @Override

  public TField readFieldBegin() throws TException {

    byte ch = reader_.peek();

    byte type;

    short id = 0;

    if (ch == RBRACE[0]) {

      type = TType.STOP;

    }

    else {

      id = (short) readJSONInteger();

      readJSONObjectStart();

      type = getTypeIDForTypeName(readJSONString(false).get());

    }

    return new TField("", type, id);

  }

  @Override

  public void readFieldEnd() throws TException {

    readJSONObjectEnd();

  }

  @Override

  public TMap readMapBegin() throws TException {

    readJSONArrayStart();

    byte keyType = getTypeIDForTypeName(readJSONString(false).get());

    byte valueType = getTypeIDForTypeName(readJSONString(false).get());

    int size = (int)readJSONInteger();

    readJSONObjectStart();

    return new TMap(keyType, valueType, size);

  }

  @Override

  public void readMapEnd() throws TException {

    readJSONObjectEnd();

    readJSONArrayEnd();

  }

  @Override

  public TList readListBegin() throws TException {

    readJSONArrayStart();

    byte elemType = getTypeIDForTypeName(readJSONString(false).get());

    int size = (int)readJSONInteger();

    return new TList(elemType, size);

  }

  @Override

  public void readListEnd() throws TException {

    readJSONArrayEnd();

  }

  @Override

  public TSet readSetBegin() throws TException {

    readJSONArrayStart();

    byte elemType = getTypeIDForTypeName(readJSONString(false).get());

    int size = (int)readJSONInteger();

    return new TSet(elemType, size);

  }

  @Override

  public void readSetEnd() throws TException {

    readJSONArrayEnd();

  }

  @Override

  public boolean readBool() throws TException {

    return (readJSONInteger() == 0 ? false : true);

  }

  @Override

  public byte readByte() throws TException {

    return (byte) readJSONInteger();

  }

  @Override

  public short readI16() throws TException {

    return (short) readJSONInteger();

  }

  @Override

  public int readI32() throws TException {

    return (int) readJSONInteger();

  }

  @Override

  public long readI64() throws TException {

    return (long) readJSONInteger();

  }

  @Override

  public double readDouble() throws TException {

    return readJSONDouble();

  }

  @Override

  public String readString() throws TException {

    try {

      return readJSONString(false).toString("UTF-8");

    }

    catch (UnsupportedEncodingException ex) {

      throw new TException("JVM DOES NOT SUPPORT UTF-8");

    }

  }

  @Override

  public byte[] readBinary() throws TException {

    return readJSONBase64();

  }

}