auser-poolparty 1.3.1 → 1.3.2

data/vendor/gems/thrift/lib/cpp/src/protocol/TJSONProtocol.cpp

@@ -1,998 +0,0 @@
-/*
- * 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.
- */
-
-#include "TJSONProtocol.h"
-
-#include <math.h>
-#include <boost/lexical_cast.hpp>
-#include "TBase64Utils.h"
-#include <transport/TTransportException.h>
-
-using namespace apache::thrift::transport;
-
-namespace apache { namespace thrift { namespace protocol {
-
-
-// Static data
-
-static const uint8_t kJSONObjectStart = '{';
-static const uint8_t kJSONObjectEnd = '}';
-static const uint8_t kJSONArrayStart = '[';
-static const uint8_t kJSONArrayEnd = ']';
-static const uint8_t kJSONNewline = '\n';
-static const uint8_t kJSONPairSeparator = ':';
-static const uint8_t kJSONElemSeparator = ',';
-static const uint8_t kJSONBackslash = '\\';
-static const uint8_t kJSONStringDelimiter = '"';
-static const uint8_t kJSONZeroChar = '0';
-static const uint8_t kJSONEscapeChar = 'u';
-
-static const std::string kJSONEscapePrefix("\\u00");
-
-static const uint32_t kThriftVersion1 = 1;
-
-static const std::string kThriftNan("NaN");
-static const std::string kThriftInfinity("Infinity");
-static const std::string kThriftNegativeInfinity("-Infinity");
-
-static const std::string kTypeNameBool("tf");
-static const std::string kTypeNameByte("i8");
-static const std::string kTypeNameI16("i16");
-static const std::string kTypeNameI32("i32");
-static const std::string kTypeNameI64("i64");
-static const std::string kTypeNameDouble("dbl");
-static const std::string kTypeNameStruct("rec");
-static const std::string kTypeNameString("str");
-static const std::string kTypeNameMap("map");
-static const std::string kTypeNameList("lst");
-static const std::string kTypeNameSet("set");
-
-static const std::string &getTypeNameForTypeID(TType typeID) {
-  switch (typeID) {
-  case T_BOOL:
-    return kTypeNameBool;
-  case T_BYTE:
-    return kTypeNameByte;
-  case T_I16:
-    return kTypeNameI16;
-  case T_I32:
-    return kTypeNameI32;
-  case T_I64:
-    return kTypeNameI64;
-  case T_DOUBLE:
-    return kTypeNameDouble;
-  case T_STRING:
-    return kTypeNameString;
-  case T_STRUCT:
-    return kTypeNameStruct;
-  case T_MAP:
-    return kTypeNameMap;
-  case T_SET:
-    return kTypeNameSet;
-  case T_LIST:
-    return kTypeNameList;
-  default:
-    throw TProtocolException(TProtocolException::NOT_IMPLEMENTED,
-                             "Unrecognized type");
-  }
-}
-
-static TType getTypeIDForTypeName(const std::string &name) {
-  TType result = T_STOP; // Sentinel value
-  if (name.length() > 1) {
-    switch (name[0]) {
-    case 'd':
-      result = T_DOUBLE;
-      break;
-    case 'i':
-      switch (name[1]) {
-      case '8':
-        result = T_BYTE;
-        break;
-      case '1':
-        result = T_I16;
-        break;
-      case '3':
-        result = T_I32;
-        break;
-      case '6':
-        result = T_I64;
-        break;
-      }
-      break;
-    case 'l':
-      result = T_LIST;
-      break;
-    case 'm':
-      result = T_MAP;
-      break;
-    case 'r':
-      result = T_STRUCT;
-      break;
-    case 's':
-      if (name[1] == 't') {
-        result = T_STRING;
-      }
-      else if (name[1] == 'e') {
-        result = T_SET;
-      }
-      break;
-    case 't':
-      result = T_BOOL;
-      break;
-    }
-  }
-  if (result == T_STOP) {
-    throw TProtocolException(TProtocolException::NOT_IMPLEMENTED,
-                             "Unrecognized type");
-  }
-  return result;
-}
-
-
-// This table describes the handling for the first 0x30 characters
-//  0 : escape using "\u00xx" notation
-//  1 : just output index
-// <other> : escape using "\<other>" notation
-static const uint8_t kJSONCharTable[0x30] = {
-//  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
-};
-
-
-// This string's characters must match up with the elements in kEscapeCharVals.
-// I don't have '/' on this list even though it appears on www.json.org --
-// it is not in the RFC
-const static std::string kEscapeChars("\"\\bfnrt");
-
-// The elements of this array must match up with the sequence of characters in
-// kEscapeChars
-const static uint8_t kEscapeCharVals[7] = {
-  '"', '\\', '\b', '\f', '\n', '\r', '\t',
-};
-
-
-// Static helper functions
-
-// Read 1 character from the transport trans and verify that it is the
-// expected character ch.
-// Throw a protocol exception if it is not.
-static uint32_t readSyntaxChar(TJSONProtocol::LookaheadReader &reader,
-                               uint8_t ch) {
-  uint8_t ch2 = reader.read();
-  if (ch2 != ch) {
-    throw TProtocolException(TProtocolException::INVALID_DATA,
-                             "Expected \'" + std::string((char *)&ch, 1) +
-                             "\'; got \'" + std::string((char *)&ch2, 1) +
-                             "\'.");
-  }
-  return 1;
-}
-
-// Return the integer value of a hex character ch.
-// Throw a protocol exception if the character is not [0-9a-f].
-static uint8_t hexVal(uint8_t ch) {
-  if ((ch >= '0') && (ch <= '9')) {
-    return ch - '0';
-  }
-  else if ((ch >= 'a') && (ch <= 'f')) {
-    return ch - 'a';
-  }
-  else {
-    throw TProtocolException(TProtocolException::INVALID_DATA,
-                             "Expected hex val ([0-9a-f]); got \'"
-                               + std::string((char *)&ch, 1) + "\'.");
-  }
-}
-
-// Return the hex character representing the integer val. The value is masked
-// to make sure it is in the correct range.
-static uint8_t hexChar(uint8_t val) {
-  val &= 0x0F;
-  if (val < 10) {
-    return val + '0';
-  }
-  else {
-    return val + 'a';
-  }
-}
-
-// Return true if the character ch is in [-+0-9.Ee]; false otherwise
-static bool isJSONNumeric(uint8_t ch) {
-  switch (ch) {
-  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;
-}
-
-
-/**
- * Class to serve as base JSON context and as base class for other context
- * implementations
- */
-class TJSONContext {
-
- public:
-
-  TJSONContext() {};
-
-  virtual ~TJSONContext() {};
-
-  /**
-   * Write context data to the transport. Default is to do nothing.
-   */
-  virtual uint32_t write(TTransport &trans) {
-    return 0;
-  };
-
-  /**
-   * Read context data from the transport. Default is to do nothing.
-   */
-  virtual uint32_t read(TJSONProtocol::LookaheadReader &reader) {
-    return 0;
-  };
-
-  /**
-   * Return true if numbers need to be escaped as strings in this context.
-   * Default behavior is to return false.
-   */
-  virtual bool escapeNum() {
-    return false;
-  }
-};
-
-// Context class for object member key-value pairs
-class JSONPairContext : public TJSONContext {
-
-public:
-
-  JSONPairContext() :
-    first_(true),
-    colon_(true) {
-  }
-
-  uint32_t write(TTransport &trans) {
-    if (first_) {
-      first_ = false;
-      colon_ = true;
-      return 0;
-    }
-    else {
-      trans.write(colon_ ? &kJSONPairSeparator : &kJSONElemSeparator, 1);
-      colon_ = !colon_;
-      return 1;
-    }
-  }
-
-  uint32_t read(TJSONProtocol::LookaheadReader &reader) {
-    if (first_) {
-      first_ = false;
-      colon_ = true;
-      return 0;
-    }
-    else {
-      uint8_t ch = (colon_ ? kJSONPairSeparator : kJSONElemSeparator);
-      colon_ = !colon_;
-      return readSyntaxChar(reader, ch);
-    }
-  }
-
-  // Numbers must be turned into strings if they are the key part of a pair
-  virtual bool escapeNum() {
-    return colon_;
-  }
-
-  private:
-
-    bool first_;
-    bool colon_;
-};
-
-// Context class for lists
-class JSONListContext : public TJSONContext {
-
-public:
-
-  JSONListContext() :
-    first_(true) {
-  }
-
-  uint32_t write(TTransport &trans) {
-    if (first_) {
-      first_ = false;
-      return 0;
-    }
-    else {
-      trans.write(&kJSONElemSeparator, 1);
-      return 1;
-    }
-  }
-
-  uint32_t read(TJSONProtocol::LookaheadReader &reader) {
-    if (first_) {
-      first_ = false;
-      return 0;
-    }
-    else {
-      return readSyntaxChar(reader, kJSONElemSeparator);
-    }
-  }
-
-  private:
-    bool first_;
-};
-
-
-TJSONProtocol::TJSONProtocol(boost::shared_ptr<TTransport> ptrans) :
-  TProtocol(ptrans),
-  context_(new TJSONContext()),
-  reader_(*ptrans) {
-}
-
-TJSONProtocol::~TJSONProtocol() {}
-
-void TJSONProtocol::pushContext(boost::shared_ptr<TJSONContext> c) {
-  contexts_.push(context_);
-  context_ = c;
-}
-
-void TJSONProtocol::popContext() {
-  context_ = contexts_.top();
-  contexts_.pop();
-}
-
-// Write the character ch as a JSON escape sequence ("\u00xx")
-uint32_t TJSONProtocol::writeJSONEscapeChar(uint8_t ch) {
-  trans_->write((const uint8_t *)kJSONEscapePrefix.c_str(),
-                kJSONEscapePrefix.length());
-  uint8_t outCh = hexChar(ch >> 4);
-  trans_->write(&outCh, 1);
-  outCh = hexChar(ch);
-  trans_->write(&outCh, 1);
-  return 6;
-}
-
-// Write the character ch as part of a JSON string, escaping as appropriate.
-uint32_t TJSONProtocol::writeJSONChar(uint8_t ch) {
-  if (ch >= 0x30) {
-    if (ch == kJSONBackslash) { // Only special character >= 0x30 is '\'
-      trans_->write(&kJSONBackslash, 1);
-      trans_->write(&kJSONBackslash, 1);
-      return 2;
-    }
-    else {
-      trans_->write(&ch, 1);
-      return 1;
-    }
-  }
-  else {
-    uint8_t outCh = kJSONCharTable[ch];
-    // Check if regular character, backslash escaped, or JSON escaped
-    if (outCh == 1) {
-      trans_->write(&ch, 1);
-      return 1;
-    }
-    else if (outCh > 1) {
-      trans_->write(&kJSONBackslash, 1);
-      trans_->write(&outCh, 1);
-      return 2;
-    }
-    else {
-      return writeJSONEscapeChar(ch);
-    }
-  }
-}
-
-// Write out the contents of the string str as a JSON string, escaping
-// characters as appropriate.
-uint32_t TJSONProtocol::writeJSONString(const std::string &str) {
-  uint32_t result = context_->write(*trans_);
-  result += 2; // For quotes
-  trans_->write(&kJSONStringDelimiter, 1);
-  std::string::const_iterator iter(str.begin());
-  std::string::const_iterator end(str.end());
-  while (iter != end) {
-    result += writeJSONChar(*iter++);
-  }
-  trans_->write(&kJSONStringDelimiter, 1);
-  return result;
-}
-
-// Write out the contents of the string as JSON string, base64-encoding
-// the string's contents, and escaping as appropriate
-uint32_t TJSONProtocol::writeJSONBase64(const std::string &str) {
-  uint32_t result = context_->write(*trans_);
-  result += 2; // For quotes
-  trans_->write(&kJSONStringDelimiter, 1);
-  uint8_t b[4];
-  const uint8_t *bytes = (const uint8_t *)str.c_str();
-  uint32_t len = str.length();
-  while (len >= 3) {
-    // Encode 3 bytes at a time
-    base64_encode(bytes, 3, b);
-    trans_->write(b, 4);
-    result += 4;
-    bytes += 3;
-    len -=3;
-  }
-  if (len) { // Handle remainder
-    base64_encode(bytes, len, b);
-    trans_->write(b, len + 1);
-    result += len + 1;
-  }
-  trans_->write(&kJSONStringDelimiter, 1);
-  return result;
-}
-
-// Convert the given integer type to a JSON number, or a string
-// if the context requires it (eg: key in a map pair).
-template <typename NumberType>
-uint32_t TJSONProtocol::writeJSONInteger(NumberType num) {
-  uint32_t result = context_->write(*trans_);
-  std::string val(boost::lexical_cast<std::string>(num));
-  bool escapeNum = context_->escapeNum();
-  if (escapeNum) {
-    trans_->write(&kJSONStringDelimiter, 1);
-    result += 1;
-  }
-  trans_->write((const uint8_t *)val.c_str(), val.length());
-  result += val.length();
-  if (escapeNum) {
-    trans_->write(&kJSONStringDelimiter, 1);
-    result += 1;
-  }
-  return result;
-}
-
-// Convert the given double to a JSON string, which is either the number,
-// "NaN" or "Infinity" or "-Infinity".
-uint32_t TJSONProtocol::writeJSONDouble(double num) {
-  uint32_t result = context_->write(*trans_);
-  std::string val(boost::lexical_cast<std::string>(num));
-
-  // Normalize output of boost::lexical_cast for NaNs and Infinities
-  bool special = false;
-  switch (val[0]) {
-  case 'N':
-  case 'n':
-    val = kThriftNan;
-    special = true;
-    break;
-  case 'I':
-  case 'i':
-    val = kThriftInfinity;
-    special = true;
-    break;
-  case '-':
-    if ((val[1] == 'I') || (val[1] == 'i')) {
-      val = kThriftNegativeInfinity;
-      special = true;
-    }
-    break;
-  }
-
-  bool escapeNum = special || context_->escapeNum();
-  if (escapeNum) {
-    trans_->write(&kJSONStringDelimiter, 1);
-    result += 1;
-  }
-  trans_->write((const uint8_t *)val.c_str(), val.length());
-  result += val.length();
-  if (escapeNum) {
-    trans_->write(&kJSONStringDelimiter, 1);
-    result += 1;
-  }
-  return result;
-}
-
-uint32_t TJSONProtocol::writeJSONObjectStart() {
-  uint32_t result = context_->write(*trans_);
-  trans_->write(&kJSONObjectStart, 1);
-  pushContext(boost::shared_ptr<TJSONContext>(new JSONPairContext()));
-  return result + 1;
-}
-
-uint32_t TJSONProtocol::writeJSONObjectEnd() {
-  popContext();
-  trans_->write(&kJSONObjectEnd, 1);
-  return 1;
-}
-
-uint32_t TJSONProtocol::writeJSONArrayStart() {
-  uint32_t result = context_->write(*trans_);
-  trans_->write(&kJSONArrayStart, 1);
-  pushContext(boost::shared_ptr<TJSONContext>(new JSONListContext()));
-  return result + 1;
-}
-
-uint32_t TJSONProtocol::writeJSONArrayEnd() {
-  popContext();
-  trans_->write(&kJSONArrayEnd, 1);
-  return 1;
-}
-
-uint32_t TJSONProtocol::writeMessageBegin(const std::string& name,
-                                          const TMessageType messageType,
-                                          const int32_t seqid) {
-  uint32_t result = writeJSONArrayStart();
-  result += writeJSONInteger(kThriftVersion1);
-  result += writeJSONString(name);
-  result += writeJSONInteger(messageType);
-  result += writeJSONInteger(seqid);
-  return result;
-}
-
-uint32_t TJSONProtocol::writeMessageEnd() {
-  return writeJSONArrayEnd();
-}
-
-uint32_t TJSONProtocol::writeStructBegin(const char* name) {
-  return writeJSONObjectStart();
-}
-
-uint32_t TJSONProtocol::writeStructEnd() {
-  return writeJSONObjectEnd();
-}
-
-uint32_t TJSONProtocol::writeFieldBegin(const char* name,
-                                        const TType fieldType,
-                                        const int16_t fieldId) {
-  uint32_t result = writeJSONInteger(fieldId);
-  result += writeJSONObjectStart();
-  result += writeJSONString(getTypeNameForTypeID(fieldType));
-  return result;
-}
-
-uint32_t TJSONProtocol::writeFieldEnd() {
-  return writeJSONObjectEnd();
-}
-
-uint32_t TJSONProtocol::writeFieldStop() {
-  return 0;
-}
-
-uint32_t TJSONProtocol::writeMapBegin(const TType keyType,
-                                      const TType valType,
-                                      const uint32_t size) {
-  uint32_t result = writeJSONArrayStart();
-  result += writeJSONString(getTypeNameForTypeID(keyType));
-  result += writeJSONString(getTypeNameForTypeID(valType));
-  result += writeJSONInteger((int64_t)size);
-  result += writeJSONObjectStart();
-  return result;
-}
-
-uint32_t TJSONProtocol::writeMapEnd() {
-  return writeJSONObjectEnd() + writeJSONArrayEnd();
-}
-
-uint32_t TJSONProtocol::writeListBegin(const TType elemType,
-                                       const uint32_t size) {
-  uint32_t result = writeJSONArrayStart();
-  result += writeJSONString(getTypeNameForTypeID(elemType));
-  result += writeJSONInteger((int64_t)size);
-  return result;
-}
-
-uint32_t TJSONProtocol::writeListEnd() {
-  return writeJSONArrayEnd();
-}
-
-uint32_t TJSONProtocol::writeSetBegin(const TType elemType,
-                                      const uint32_t size) {
-  uint32_t result = writeJSONArrayStart();
-  result += writeJSONString(getTypeNameForTypeID(elemType));
-  result += writeJSONInteger((int64_t)size);
-  return result;
-}
-
-uint32_t TJSONProtocol::writeSetEnd() {
-  return writeJSONArrayEnd();
-}
-
-uint32_t TJSONProtocol::writeBool(const bool value) {
-  return writeJSONInteger(value);
-}
-
-uint32_t TJSONProtocol::writeByte(const int8_t byte) {
-  // writeByte() must be handled specially becuase boost::lexical cast sees
-  // int8_t as a text type instead of an integer type
-  return writeJSONInteger((int16_t)byte);
-}
-
-uint32_t TJSONProtocol::writeI16(const int16_t i16) {
-  return writeJSONInteger(i16);
-}
-
-uint32_t TJSONProtocol::writeI32(const int32_t i32) {
-  return writeJSONInteger(i32);
-}
-
-uint32_t TJSONProtocol::writeI64(const int64_t i64) {
-  return writeJSONInteger(i64);
-}
-
-uint32_t TJSONProtocol::writeDouble(const double dub) {
-  return writeJSONDouble(dub);
-}
-
-uint32_t TJSONProtocol::writeString(const std::string& str) {
-  return writeJSONString(str);
-}
-
-uint32_t TJSONProtocol::writeBinary(const std::string& str) {
-  return writeJSONBase64(str);
-}
-
-  /**
-   * Reading functions
-   */
-
-// Reads 1 byte and verifies that it matches ch.
-uint32_t TJSONProtocol::readJSONSyntaxChar(uint8_t ch) {
-  return readSyntaxChar(reader_, ch);
-}
-
-// Decodes the four hex parts of a JSON escaped string character and returns
-// the character via out. The first two characters must be "00".
-uint32_t TJSONProtocol::readJSONEscapeChar(uint8_t *out) {
-  uint8_t b[2];
-  readJSONSyntaxChar(kJSONZeroChar);
-  readJSONSyntaxChar(kJSONZeroChar);
-  b[0] = reader_.read();
-  b[1] = reader_.read();
-  *out = (hexVal(b[0]) << 4) + hexVal(b[1]);
-  return 4;
-}
-
-// Decodes a JSON string, including unescaping, and returns the string via str
-uint32_t TJSONProtocol::readJSONString(std::string &str, bool skipContext) {
-  uint32_t result = (skipContext ? 0 : context_->read(reader_));
-  result += readJSONSyntaxChar(kJSONStringDelimiter);
-  uint8_t ch;
-  str.clear();
-  while (true) {
-    ch = reader_.read();
-    ++result;
-    if (ch == kJSONStringDelimiter) {
-      break;
-    }
-    if (ch == kJSONBackslash) {
-      ch = reader_.read();
-      ++result;
-      if (ch == kJSONEscapeChar) {
-        result += readJSONEscapeChar(&ch);
-      }
-      else {
-        size_t pos = kEscapeChars.find(ch);
-        if (pos == std::string::npos) {
-          throw TProtocolException(TProtocolException::INVALID_DATA,
-                                   "Expected control char, got '" +
-                                   std::string((const char *)&ch, 1)  + "'.");
-        }
-        ch = kEscapeCharVals[pos];
-      }
-    }
-    str += ch;
-  }
-  return result;
-}
-
-// Reads a block of base64 characters, decoding it, and returns via str
-uint32_t TJSONProtocol::readJSONBase64(std::string &str) {
-  std::string tmp;
-  uint32_t result = readJSONString(tmp);
-  uint8_t *b = (uint8_t *)tmp.c_str();
-  uint32_t len = tmp.length();
-  str.clear();
-  while (len >= 4) {
-    base64_decode(b, 4);
-    str.append((const char *)b, 3);
-    b += 4;
-    len -= 4;
-  }
-  // 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) {
-    base64_decode(b, len);
-    str.append((const char *)b, len - 1);
-  }
-  return result;
-}
-
-// Reads a sequence of characters, stopping at the first one that is not
-// a valid JSON numeric character.
-uint32_t TJSONProtocol::readJSONNumericChars(std::string &str) {
-  uint32_t result = 0;
-  str.clear();
-  while (true) {
-    uint8_t ch = reader_.peek();
-    if (!isJSONNumeric(ch)) {
-      break;
-    }
-    reader_.read();
-    str += ch;
-    ++result;
-  }
-  return result;
-}
-
-// Reads a sequence of characters and assembles them into a number,
-// returning them via num
-template <typename NumberType>
-uint32_t TJSONProtocol::readJSONInteger(NumberType &num) {
-  uint32_t result = context_->read(reader_);
-  if (context_->escapeNum()) {
-    result += readJSONSyntaxChar(kJSONStringDelimiter);
-  }
-  std::string str;
-  result += readJSONNumericChars(str);
-  try {
-    num = boost::lexical_cast<NumberType>(str);
-  }
-  catch (boost::bad_lexical_cast e) {
-    throw new TProtocolException(TProtocolException::INVALID_DATA,
-                                 "Expected numeric value; got \"" + str +
-                                  "\"");
-  }
-  if (context_->escapeNum()) {
-    result += readJSONSyntaxChar(kJSONStringDelimiter);
-  }
-  return result;
-}
-
-// Reads a JSON number or string and interprets it as a double.
-uint32_t TJSONProtocol::readJSONDouble(double &num) {
-  uint32_t result = context_->read(reader_);
-  std::string str;
-  if (reader_.peek() == kJSONStringDelimiter) {
-    result += readJSONString(str, true);
-    // Check for NaN, Infinity and -Infinity
-    if (str == kThriftNan) {
-      num = HUGE_VAL/HUGE_VAL; // generates NaN
-    }
-    else if (str == kThriftInfinity) {
-      num = HUGE_VAL;
-    }
-    else if (str == kThriftNegativeInfinity) {
-      num = -HUGE_VAL;
-    }
-    else {
-      if (!context_->escapeNum()) {
-        // Throw exception -- we should not be in a string in this case
-        throw new TProtocolException(TProtocolException::INVALID_DATA,
-                                     "Numeric data unexpectedly quoted");
-      }
-      try {
-        num = boost::lexical_cast<double>(str);
-      }
-      catch (boost::bad_lexical_cast e) {
-        throw new TProtocolException(TProtocolException::INVALID_DATA,
-                                     "Expected numeric value; got \"" + str +
-                                     "\"");
-      }
-    }
-  }
-  else {
-    if (context_->escapeNum()) {
-      // This will throw - we should have had a quote if escapeNum == true
-      readJSONSyntaxChar(kJSONStringDelimiter);
-    }
-    result += readJSONNumericChars(str);
-    try {
-      num = boost::lexical_cast<double>(str);
-    }
-    catch (boost::bad_lexical_cast e) {
-      throw new TProtocolException(TProtocolException::INVALID_DATA,
-                                   "Expected numeric value; got \"" + str +
-                                   "\"");
-    }
-  }
-  return result;
-}
-
-uint32_t TJSONProtocol::readJSONObjectStart() {
-  uint32_t result = context_->read(reader_);
-  result += readJSONSyntaxChar(kJSONObjectStart);
-  pushContext(boost::shared_ptr<TJSONContext>(new JSONPairContext()));
-  return result;
-}
-
-uint32_t TJSONProtocol::readJSONObjectEnd() {
-  uint32_t result = readJSONSyntaxChar(kJSONObjectEnd);
-  popContext();
-  return result;
-}
-
-uint32_t TJSONProtocol::readJSONArrayStart() {
-  uint32_t result = context_->read(reader_);
-  result += readJSONSyntaxChar(kJSONArrayStart);
-  pushContext(boost::shared_ptr<TJSONContext>(new JSONListContext()));
-  return result;
-}
-
-uint32_t TJSONProtocol::readJSONArrayEnd() {
-  uint32_t result = readJSONSyntaxChar(kJSONArrayEnd);
-  popContext();
-  return result;
-}
-
-uint32_t TJSONProtocol::readMessageBegin(std::string& name,
-                                         TMessageType& messageType,
-                                         int32_t& seqid) {
-  uint32_t result = readJSONArrayStart();
-  uint64_t tmpVal = 0;
-  result += readJSONInteger(tmpVal);
-  if (tmpVal != kThriftVersion1) {
-    throw TProtocolException(TProtocolException::BAD_VERSION,
-                             "Message contained bad version.");
-  }
-  result += readJSONString(name);
-  result += readJSONInteger(tmpVal);
-  messageType = (TMessageType)tmpVal;
-  result += readJSONInteger(tmpVal);
-  seqid = tmpVal;
-  return result;
-}
-
-uint32_t TJSONProtocol::readMessageEnd() {
-  return readJSONArrayEnd();
-}
-
-uint32_t TJSONProtocol::readStructBegin(std::string& name) {
-  return readJSONObjectStart();
-}
-
-uint32_t TJSONProtocol::readStructEnd() {
-  return readJSONObjectEnd();
-}
-
-uint32_t TJSONProtocol::readFieldBegin(std::string& name,
-                                       TType& fieldType,
-                                       int16_t& fieldId) {
-  uint32_t result = 0;
-  // Check if we hit the end of the list
-  uint8_t ch = reader_.peek();
-  if (ch == kJSONObjectEnd) {
-    fieldType = apache::thrift::protocol::T_STOP;
-  }
-  else {
-    uint64_t tmpVal = 0;
-    std::string tmpStr;
-    result += readJSONInteger(tmpVal);
-    fieldId = tmpVal;
-    result += readJSONObjectStart();
-    result += readJSONString(tmpStr);
-    fieldType = getTypeIDForTypeName(tmpStr);
-  }
-  return result;
-}
-
-uint32_t TJSONProtocol::readFieldEnd() {
-  return readJSONObjectEnd();
-}
-
-uint32_t TJSONProtocol::readMapBegin(TType& keyType,
-                                     TType& valType,
-                                     uint32_t& size) {
-  uint64_t tmpVal = 0;
-  std::string tmpStr;
-  uint32_t result = readJSONArrayStart();
-  result += readJSONString(tmpStr);
-  keyType = getTypeIDForTypeName(tmpStr);
-  result += readJSONString(tmpStr);
-  valType = getTypeIDForTypeName(tmpStr);
-  result += readJSONInteger(tmpVal);
-  size = tmpVal;
-  result += readJSONObjectStart();
-  return result;
-}
-
-uint32_t TJSONProtocol::readMapEnd() {
-  return readJSONObjectEnd() + readJSONArrayEnd();
-}
-
-uint32_t TJSONProtocol::readListBegin(TType& elemType,
-                                      uint32_t& size) {
-  uint64_t tmpVal = 0;
-  std::string tmpStr;
-  uint32_t result = readJSONArrayStart();
-  result += readJSONString(tmpStr);
-  elemType = getTypeIDForTypeName(tmpStr);
-  result += readJSONInteger(tmpVal);
-  size = tmpVal;
-  return result;
-}
-
-uint32_t TJSONProtocol::readListEnd() {
-  return readJSONArrayEnd();
-}
-
-uint32_t TJSONProtocol::readSetBegin(TType& elemType,
-                                     uint32_t& size) {
-  uint64_t tmpVal = 0;
-  std::string tmpStr;
-  uint32_t result = readJSONArrayStart();
-  result += readJSONString(tmpStr);
-  elemType = getTypeIDForTypeName(tmpStr);
-  result += readJSONInteger(tmpVal);
-  size = tmpVal;
-  return result;
-}
-
-uint32_t TJSONProtocol::readSetEnd() {
-  return readJSONArrayEnd();
-}
-
-uint32_t TJSONProtocol::readBool(bool& value) {
-  return readJSONInteger(value);
-}
-
-// readByte() must be handled properly becuase boost::lexical cast sees int8_t
-// as a text type instead of an integer type
-uint32_t TJSONProtocol::readByte(int8_t& byte) {
-  int16_t tmp = (int16_t) byte;
-  uint32_t result =  readJSONInteger(tmp);
-  assert(tmp < 256);
-  byte = (int8_t)tmp;
-  return result;
-}
-
-uint32_t TJSONProtocol::readI16(int16_t& i16) {
-  return readJSONInteger(i16);
-}
-
-uint32_t TJSONProtocol::readI32(int32_t& i32) {
-  return readJSONInteger(i32);
-}
-
-uint32_t TJSONProtocol::readI64(int64_t& i64) {
-  return readJSONInteger(i64);
-}
-
-uint32_t TJSONProtocol::readDouble(double& dub) {
-  return readJSONDouble(dub);
-}
-
-uint32_t TJSONProtocol::readString(std::string &str) {
-  return readJSONString(str);
-}
-
-uint32_t TJSONProtocol::readBinary(std::string &str) {
-  return readJSONBase64(str);
-}
-
-}}} // apache::thrift::protocol