airavata-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From scnakand...@apache.org
Subject [09/51] [partial] airavata-php-gateway git commit: removing files from wrong merge
Date Tue, 13 Dec 2016 22:09:22 GMT
http://git-wip-us.apache.org/repos/asf/airavata-php-gateway/blob/d55608f1/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/thrift/protocol/TDebugProtocol.h
----------------------------------------------------------------------
diff --git a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/thrift/protocol/TDebugProtocol.h b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/thrift/protocol/TDebugProtocol.h
deleted file mode 100644
index f85e691..0000000
--- a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/thrift/protocol/TDebugProtocol.h
+++ /dev/null
@@ -1,227 +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.
- */
-
-#ifndef _THRIFT_PROTOCOL_TDEBUGPROTOCOL_H_
-#define _THRIFT_PROTOCOL_TDEBUGPROTOCOL_H_ 1
-
-#include <thrift/protocol/TVirtualProtocol.h>
-
-#include <boost/shared_ptr.hpp>
-
-namespace apache { namespace thrift { namespace protocol {
-
-/*
-
-!!! EXPERIMENTAL CODE !!!
-
-This protocol is very much a work in progress.
-It doesn't handle many cases properly.
-It throws exceptions in many cases.
-It probably segfaults in many cases.
-Bug reports and feature requests are welcome.
-Complaints are not. :R
-
-*/
-
-
-/**
- * Protocol that prints the payload in a nice human-readable format.
- * Reading from this protocol is not supported.
- *
- */
-class TDebugProtocol : public TVirtualProtocol<TDebugProtocol> {
- private:
-  enum write_state_t
-  { UNINIT
-  , STRUCT
-  , LIST
-  , SET
-  , MAP_KEY
-  , MAP_VALUE
-  };
-
- public:
-  TDebugProtocol(boost::shared_ptr<TTransport> trans)
-    : TVirtualProtocol<TDebugProtocol>(trans)
-    , trans_(trans.get())
-    , string_limit_(DEFAULT_STRING_LIMIT)
-    , string_prefix_size_(DEFAULT_STRING_PREFIX_SIZE)
-  {
-    write_state_.push_back(UNINIT);
-  }
-
-  static const int32_t DEFAULT_STRING_LIMIT = 256;
-  static const int32_t DEFAULT_STRING_PREFIX_SIZE = 16;
-
-  void setStringSizeLimit(int32_t string_limit) {
-    string_limit_ = string_limit;
-  }
-
-  void setStringPrefixSize(int32_t string_prefix_size) {
-    string_prefix_size_ = string_prefix_size;
-  }
-
-
-  uint32_t writeMessageBegin(const std::string& name,
-                             const TMessageType messageType,
-                             const int32_t seqid);
-
-  uint32_t writeMessageEnd();
-
-
-  uint32_t writeStructBegin(const char* name);
-
-  uint32_t writeStructEnd();
-
-  uint32_t writeFieldBegin(const char* name,
-                           const TType fieldType,
-                           const int16_t fieldId);
-
-  uint32_t writeFieldEnd();
-
-  uint32_t writeFieldStop();
-
-  uint32_t writeMapBegin(const TType keyType,
-                         const TType valType,
-                         const uint32_t size);
-
-  uint32_t writeMapEnd();
-
-  uint32_t writeListBegin(const TType elemType,
-                          const uint32_t size);
-
-  uint32_t writeListEnd();
-
-  uint32_t writeSetBegin(const TType elemType,
-                         const uint32_t size);
-
-  uint32_t writeSetEnd();
-
-  uint32_t writeBool(const bool value);
-
-  uint32_t writeByte(const int8_t byte);
-
-  uint32_t writeI16(const int16_t i16);
-
-  uint32_t writeI32(const int32_t i32);
-
-  uint32_t writeI64(const int64_t i64);
-
-  uint32_t writeDouble(const double dub);
-
-  uint32_t writeString(const std::string& str);
-
-  uint32_t writeBinary(const std::string& str);
-
-
- private:
-  void indentUp();
-  void indentDown();
-  uint32_t writePlain(const std::string& str);
-  uint32_t writeIndented(const std::string& str);
-  uint32_t startItem();
-  uint32_t endItem();
-  uint32_t writeItem(const std::string& str);
-
-  static std::string fieldTypeName(TType type);
-
-  TTransport* trans_;
-
-  int32_t string_limit_;
-  int32_t string_prefix_size_;
-
-  std::string indent_str_;
-  static const int indent_inc = 2;
-
-  std::vector<write_state_t> write_state_;
-  std::vector<int> list_idx_;
-};
-
-/**
- * Constructs debug protocol handlers
- */
-class TDebugProtocolFactory : public TProtocolFactory {
- public:
-  TDebugProtocolFactory() {}
-  virtual ~TDebugProtocolFactory() {}
-
-  boost::shared_ptr<TProtocol> getProtocol(boost::shared_ptr<TTransport> trans) {
-    return boost::shared_ptr<TProtocol>(new TDebugProtocol(trans));
-  }
-
-};
-
-}}} // apache::thrift::protocol
-
-
-// TODO(dreiss): Move (part of) ThriftDebugString into a .cpp file and remove this.
-#include <thrift/transport/TBufferTransports.h>
-
-namespace apache { namespace thrift {
-
-template<typename ThriftStruct>
-std::string ThriftDebugString(const ThriftStruct& ts) {
-  using namespace apache::thrift::transport;
-  using namespace apache::thrift::protocol;
-  TMemoryBuffer* buffer = new TMemoryBuffer;
-  boost::shared_ptr<TTransport> trans(buffer);
-  TDebugProtocol protocol(trans);
-
-  ts.write(&protocol);
-
-  uint8_t* buf;
-  uint32_t size;
-  buffer->getBuffer(&buf, &size);
-  return std::string((char*)buf, (unsigned int)size);
-}
-
-// TODO(dreiss): This is badly broken.  Don't use it unless you are me.
-#if 0
-template<typename Object>
-std::string DebugString(const std::vector<Object>& vec) {
-  using namespace apache::thrift::transport;
-  using namespace apache::thrift::protocol;
-  TMemoryBuffer* buffer = new TMemoryBuffer;
-  boost::shared_ptr<TTransport> trans(buffer);
-  TDebugProtocol protocol(trans);
-
-  // I am gross!
-  protocol.writeStructBegin("SomeRandomVector");
-
-  // TODO: Fix this with a trait.
-  protocol.writeListBegin((TType)99, vec.size());
-  typename std::vector<Object>::const_iterator it;
-  for (it = vec.begin(); it != vec.end(); ++it) {
-    it->write(&protocol);
-  }
-  protocol.writeListEnd();
-
-  uint8_t* buf;
-  uint32_t size;
-  buffer->getBuffer(&buf, &size);
-  return std::string((char*)buf, (unsigned int)size);
-}
-#endif // 0
-
-}} // apache::thrift
-
-
-#endif // #ifndef _THRIFT_PROTOCOL_TDEBUGPROTOCOL_H_
-
-

http://git-wip-us.apache.org/repos/asf/airavata-php-gateway/blob/d55608f1/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/thrift/protocol/TDenseProtocol.cpp
----------------------------------------------------------------------
diff --git a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/thrift/protocol/TDenseProtocol.cpp b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/thrift/protocol/TDenseProtocol.cpp
deleted file mode 100644
index 4fbfc13..0000000
--- a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/thrift/protocol/TDenseProtocol.cpp
+++ /dev/null
@@ -1,768 +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.
- */
-
-/*
-
-IMPLEMENTATION DETAILS
-
-TDenseProtocol was designed to have a smaller serialized form than
-TBinaryProtocol.  This is accomplished using two techniques.  The first is
-variable-length integer encoding.  We use the same technique that the Standard
-MIDI File format uses for "variable-length quantities"
-(http://en.wikipedia.org/wiki/Variable-length_quantity).
-All integers (including i16, but not byte) are first cast to uint64_t,
-then written out as variable-length quantities.  This has the unfortunate side
-effect that all negative numbers require 10 bytes, but negative numbers tend
-to be far less common than positive ones.
-
-The second technique eliminating the field ids used by TBinaryProtocol.  This
-decision required support from the Thrift compiler and also sacrifices some of
-the backward and forward compatibility of TBinaryProtocol.
-
-We considered implementing this technique by generating separate readers and
-writers for the dense protocol (this is how Pillar, Thrift's predecessor,
-worked), but this idea had a few problems:
-- Our abstractions go out the window.
-- We would have to maintain a second code generator.
-- Preserving compatibility with old versions of the structures would be a
-  nightmare.
-
-Therefore, we chose an alternate implementation that stored the description of
-the data neither in the data itself (like TBinaryProtocol) nor in the
-serialization code (like Pillar), but instead in a separate data structure,
-called a TypeSpec.  TypeSpecs are generated by the Thrift compiler
-(specifically in the t_cpp_generator), and their structure should be
-documented there (TODO(dreiss): s/should be/is/).
-
-We maintain a stack of TypeSpecs within the protocol so it knows where the
-generated code is in the reading/writing process.  For example, if we are
-writing an i32 contained in a struct bar, contained in a struct foo, then the
-stack would look like: TOP , i32 , struct bar , struct foo , BOTTOM.
-The following invariant: whenever we are about to read/write an object
-(structBegin, containerBegin, or a scalar), the TypeSpec on the top of the
-stack must match the type being read/written.  The main reasons that this
-invariant must be maintained is that if we ever start reading a structure, we
-must have its exact TypeSpec in order to pass the right tags to the
-deserializer.
-
-We use the following strategies for maintaining this invariant:
-
-- For structures, we have a separate stack of indexes, one for each structure
-  on the TypeSpec stack.  These are indexes into the list of fields in the
-  structure's TypeSpec.  When we {read,write}FieldBegin, we push on the
-  TypeSpec for the field.
-- When we begin writing a list or set, we push on the TypeSpec for the
-  element type.
-- For maps, we have a separate stack of booleans, one for each map on the
-  TypeSpec stack.  The boolean is true if we are writing the key for that
-  map, and false if we are writing the value.  Maps are the trickiest case
-  because the generated code does not call any protocol method between
-  the key and the value.  As a result, we potentially have to switch
-  between map key state and map value state after reading/writing any object.
-- This job is handled by the stateTransition method.  It is called after
-  reading/writing every object.  It pops the current TypeSpec off the stack,
-  then optionally pushes a new one on, depending on what the next TypeSpec is.
-  If it is a struct, the job is left to the next writeFieldBegin.  If it is a
-  set or list, the just-popped typespec is pushed back on.  If it is a map,
-  the top of the key/value stack is toggled, and the appropriate TypeSpec
-  is pushed.
-
-Optional fields are a little tricky also.  We write a zero byte if they are
-absent and prefix them with an 0x01 byte if they are present
-*/
-
-#define __STDC_LIMIT_MACROS
-#include <stdint.h>
-#include <thrift/protocol/TDenseProtocol.h>
-#include <thrift/TReflectionLocal.h>
-
-// Leaving this on for now.  Disabling it will turn off asserts, which should
-// give a performance boost.  When we have *really* thorough test cases,
-// we should drop this.
-#define DEBUG_TDENSEPROTOCOL
-
-// NOTE: Assertions should *only* be used to detect bugs in code,
-//       either in TDenseProtocol itself, or in code using it.
-//       (For example, using the wrong TypeSpec.)
-//       Invalid data should NEVER cause an assertion failure,
-//       no matter how grossly corrupted, nor how ingeniously crafted.
-#ifdef DEBUG_TDENSEPROTOCOL
-#undef NDEBUG
-#else
-#define NDEBUG
-#endif
-#include <cassert>
-
-using std::string;
-
-#ifdef __GNUC__
-#define UNLIKELY(val) (__builtin_expect((val), 0))
-#else
-#define UNLIKELY(val) (val)
-#endif
-
-namespace apache { namespace thrift { namespace protocol {
-
-const int TDenseProtocol::FP_PREFIX_LEN =
-  apache::thrift::reflection::local::FP_PREFIX_LEN;
-
-// Top TypeSpec.  TypeSpec of the structure being encoded.
-#define TTS  (ts_stack_.back())  // type = TypeSpec*
-// InDeX.  Index into TTS of the current/next field to encode.
-#define IDX (idx_stack_.back())  // type = int
-// Field TypeSpec.  TypeSpec of the current/next field to encode.
-#define FTS (TTS->tstruct.specs[IDX])  // type = TypeSpec*
-// Field MeTa.  Metadata of the current/next field to encode.
-#define FMT (TTS->tstruct.metas[IDX])  // type = FieldMeta
-// SubType 1/2.  TypeSpec of the first/second subtype of this container.
-#define ST1 (TTS->tcontainer.subtype1)
-#define ST2 (TTS->tcontainer.subtype2)
-
-
-/**
- * Checks that @c ttype is indeed the ttype that we should be writing,
- * according to our typespec.  Aborts if the test fails and debugging in on.
- */
-inline void TDenseProtocol::checkTType(const TType ttype) {
-  assert(!ts_stack_.empty());
-  assert(TTS->ttype == ttype);
-}
-
-/**
- * Makes sure that the TypeSpec stack is correct for the next object.
- * See top-of-file comments.
- */
-inline void TDenseProtocol::stateTransition() {
-  TypeSpec* old_tts = ts_stack_.back();
-  ts_stack_.pop_back();
-
-  // If this is the end of the top-level write, we should have just popped
-  // the TypeSpec passed to the constructor.
-  if (ts_stack_.empty()) {
-    assert(old_tts = type_spec_);
-    return;
-  }
-
-  switch (TTS->ttype) {
-
-    case T_STRUCT:
-      assert(old_tts == FTS);
-      break;
-
-    case T_LIST:
-    case T_SET:
-      assert(old_tts == ST1);
-      ts_stack_.push_back(old_tts);
-      break;
-
-    case T_MAP:
-      assert(old_tts == (mkv_stack_.back() ? ST1 : ST2));
-      mkv_stack_.back() = !mkv_stack_.back();
-      ts_stack_.push_back(mkv_stack_.back() ? ST1 : ST2);
-      break;
-
-    default:
-      assert(!"Invalid TType in stateTransition.");
-      break;
-
-  }
-}
-
-
-/*
- * Variable-length quantity functions.
- */
-
-inline uint32_t TDenseProtocol::vlqRead(uint64_t& vlq) {
-  uint32_t used = 0;
-  uint64_t val = 0;
-  uint8_t buf[10];  // 64 bits / (7 bits/byte) = 10 bytes.
-  uint32_t buf_size = sizeof(buf);
-  const uint8_t* borrowed = trans_->borrow(buf, &buf_size);
-
-  // Fast path.  TODO(dreiss): Make it faster.
-  if (borrowed != NULL) {
-    while (true) {
-      uint8_t byte = borrowed[used];
-      used++;
-      val = (val << 7) | (byte & 0x7f);
-      if (!(byte & 0x80)) {
-        vlq = val;
-        trans_->consume(used);
-        return used;
-      }
-      // Have to check for invalid data so we don't crash.
-      if (UNLIKELY(used == sizeof(buf))) {
-        resetState();
-        throw TProtocolException(TProtocolException::INVALID_DATA, "Variable-length int over 10 bytes.");
-      }
-    }
-  }
-
-  // Slow path.
-  else {
-    while (true) {
-      uint8_t byte;
-      used += trans_->readAll(&byte, 1);
-      val = (val << 7) | (byte & 0x7f);
-      if (!(byte & 0x80)) {
-        vlq = val;
-        return used;
-      }
-      // Might as well check for invalid data on the slow path too.
-      if (UNLIKELY(used >= sizeof(buf))) {
-        resetState();
-        throw TProtocolException(TProtocolException::INVALID_DATA, "Variable-length int over 10 bytes.");
-      }
-    }
-  }
-}
-
-inline uint32_t TDenseProtocol::vlqWrite(uint64_t vlq) {
-  uint8_t buf[10];  // 64 bits / (7 bits/byte) = 10 bytes.
-  int32_t pos = sizeof(buf) - 1;
-
-  // Write the thing from back to front.
-  buf[pos] = vlq & 0x7f;
-  vlq >>= 7;
-  pos--;
-
-  while (vlq > 0) {
-    assert(pos >= 0);
-    buf[pos] = static_cast<uint8_t>(vlq | 0x80);
-    vlq >>= 7;
-    pos--;
-  }
-
-  // Back up one step before writing.
-  pos++;
-
-  trans_->write(buf+pos, static_cast<uint32_t>(sizeof(buf) - pos));
-  return static_cast<uint32_t>(sizeof(buf) - pos);
-}
-
-
-
-/*
- * Writing functions.
- */
-
-uint32_t TDenseProtocol::writeMessageBegin(const std::string& name,
-                                           const TMessageType messageType,
-                                           const int32_t seqid) {
-  throw TException("TDenseProtocol doesn't work with messages (yet).");
-
-  int32_t version = (VERSION_2) | ((int32_t)messageType);
-  uint32_t wsize = 0;
-  wsize += subWriteI32(version);
-  wsize += subWriteString(name);
-  wsize += subWriteI32(seqid);
-  return wsize;
-}
-
-uint32_t TDenseProtocol::writeMessageEnd() {
-  return 0;
-}
-
-uint32_t TDenseProtocol::writeStructBegin(const char* name) {
-  (void) name;
-  uint32_t xfer = 0;
-
-  // The TypeSpec stack should be empty if this is the top-level read/write.
-  // If it is, we push the TypeSpec passed to the constructor.
-  if (ts_stack_.empty()) {
-    assert(standalone_);
-
-    if (type_spec_ == NULL) {
-      resetState();
-      throw TException("TDenseProtocol: No type specified.");
-    } else {
-      assert(type_spec_->ttype == T_STRUCT);
-      ts_stack_.push_back(type_spec_);
-      // Write out a prefix of the structure fingerprint.
-      trans_->write(type_spec_->fp_prefix, FP_PREFIX_LEN);
-      xfer += FP_PREFIX_LEN;
-    }
-  }
-
-  // We need a new field index for this structure.
-  idx_stack_.push_back(0);
-  return 0;
-}
-
-uint32_t TDenseProtocol::writeStructEnd() {
-  idx_stack_.pop_back();
-  stateTransition();
-  return 0;
-}
-
-uint32_t TDenseProtocol::writeFieldBegin(const char* name,
-                                         const TType fieldType,
-                                         const int16_t fieldId) {
-  (void) name;
-  uint32_t xfer = 0;
-
-  // Skip over optional fields.
-  while (FMT.tag != fieldId) {
-    // TODO(dreiss): Old meta here.
-    assert(FTS->ttype != T_STOP);
-    assert(FMT.is_optional);
-    // Write a zero byte so the reader can skip it.
-    xfer += subWriteBool(false);
-    // And advance to the next field.
-    IDX++;
-  }
-
-  // TODO(dreiss): give a better exception.
-  assert(FTS->ttype == fieldType);
-
-  if (FMT.is_optional) {
-    subWriteBool(true);
-    xfer += 1;
-  }
-
-  // writeFieldStop shares all lot of logic up to this point.
-  // Instead of replicating it all, we just call this method from that one
-  // and use a gross special case here.
-  if (UNLIKELY(FTS->ttype != T_STOP)) {
-    // For normal fields, push the TypeSpec that we're about to use.
-    ts_stack_.push_back(FTS);
-  }
-  return xfer;
-}
-
-uint32_t TDenseProtocol::writeFieldEnd() {
-  // Just move on to the next field.
-  IDX++;
-  return 0;
-}
-
-uint32_t TDenseProtocol::writeFieldStop() {
-  return TDenseProtocol::writeFieldBegin("", T_STOP, 0);
-}
-
-uint32_t TDenseProtocol::writeMapBegin(const TType keyType,
-                                       const TType valType,
-                                       const uint32_t size) {
-  checkTType(T_MAP);
-
-  assert(keyType == ST1->ttype);
-  assert(valType == ST2->ttype);
-
-  ts_stack_.push_back(ST1);
-  mkv_stack_.push_back(true);
-
-  return subWriteI32((int32_t)size);
-}
-
-uint32_t TDenseProtocol::writeMapEnd() {
-  // Pop off the value type, as well as our entry in the map key/value stack.
-  // stateTransition takes care of popping off our TypeSpec.
-  ts_stack_.pop_back();
-  mkv_stack_.pop_back();
-  stateTransition();
-  return 0;
-}
-
-uint32_t TDenseProtocol::writeListBegin(const TType elemType,
-                                        const uint32_t size) {
-  checkTType(T_LIST);
-
-  assert(elemType == ST1->ttype);
-  ts_stack_.push_back(ST1);
-  return subWriteI32((int32_t)size);
-}
-
-uint32_t TDenseProtocol::writeListEnd() {
-  // Pop off the element type.  stateTransition takes care of popping off ours.
-  ts_stack_.pop_back();
-  stateTransition();
-  return 0;
-}
-
-uint32_t TDenseProtocol::writeSetBegin(const TType elemType,
-                                       const uint32_t size) {
-  checkTType(T_SET);
-
-  assert(elemType == ST1->ttype);
-  ts_stack_.push_back(ST1);
-  return subWriteI32((int32_t)size);
-}
-
-uint32_t TDenseProtocol::writeSetEnd() {
-  // Pop off the element type.  stateTransition takes care of popping off ours.
-  ts_stack_.pop_back();
-  stateTransition();
-  return 0;
-}
-
-uint32_t TDenseProtocol::writeBool(const bool value) {
-  checkTType(T_BOOL);
-  stateTransition();
-  return TBinaryProtocol::writeBool(value);
-}
-
-uint32_t TDenseProtocol::writeByte(const int8_t byte) {
-  checkTType(T_BYTE);
-  stateTransition();
-  return TBinaryProtocol::writeByte(byte);
-}
-
-uint32_t TDenseProtocol::writeI16(const int16_t i16) {
-  checkTType(T_I16);
-  stateTransition();
-  return vlqWrite(i16);
-}
-
-uint32_t TDenseProtocol::writeI32(const int32_t i32) {
-  checkTType(T_I32);
-  stateTransition();
-  return vlqWrite(i32);
-}
-
-uint32_t TDenseProtocol::writeI64(const int64_t i64) {
-  checkTType(T_I64);
-  stateTransition();
-  return vlqWrite(i64);
-}
-
-uint32_t TDenseProtocol::writeDouble(const double dub) {
-  checkTType(T_DOUBLE);
-  stateTransition();
-  return TBinaryProtocol::writeDouble(dub);
-}
-
-uint32_t TDenseProtocol::writeString(const std::string& str) {
-  checkTType(T_STRING);
-  stateTransition();
-  return subWriteString(str);
-}
-
-uint32_t TDenseProtocol::writeBinary(const std::string& str) {
-  return TDenseProtocol::writeString(str);
-}
-
-inline uint32_t TDenseProtocol::subWriteI32(const int32_t i32) {
-  return vlqWrite(i32);
-}
-
-uint32_t TDenseProtocol::subWriteString(const std::string& str) {
-  if(str.size() > static_cast<size_t>((std::numeric_limits<int32_t>::max)()))
-    throw TProtocolException(TProtocolException::SIZE_LIMIT);
-  uint32_t size = static_cast<uint32_t>(str.size());
-  uint32_t xfer = subWriteI32((int32_t)size);
-  if (size > 0) {
-    trans_->write((uint8_t*)str.data(), size);
-  }
-  return xfer + size;
-}
-
-
-
-/*
- * Reading functions
- *
- * These have a lot of the same logic as the writing functions, so if
- * something is confusing, look for comments in the corresponding writer.
- */
-
-uint32_t TDenseProtocol::readMessageBegin(std::string& name,
-                                          TMessageType& messageType,
-                                          int32_t& seqid) {
-  throw TException("TDenseProtocol doesn't work with messages (yet).");
-
-  uint32_t xfer = 0;
-  int32_t sz;
-  xfer += subReadI32(sz);
-
-  if (sz < 0) {
-    // Check for correct version number
-    int32_t version = sz & VERSION_MASK;
-    if (version != VERSION_2) {
-      throw TProtocolException(TProtocolException::BAD_VERSION, "Bad version identifier");
-    }
-    messageType = (TMessageType)(sz & 0x000000ff);
-    xfer += subReadString(name);
-    xfer += subReadI32(seqid);
-  } else {
-    throw TProtocolException(TProtocolException::BAD_VERSION, "No version identifier... old protocol client in strict mode?");
-  }
-  return xfer;
-}
-
-uint32_t TDenseProtocol::readMessageEnd() {
-  return 0;
-}
-
-uint32_t TDenseProtocol::readStructBegin(string& name) {
-  (void) name;
-  uint32_t xfer = 0;
-
-  if (ts_stack_.empty()) {
-    assert(standalone_);
-
-    if (type_spec_ == NULL) {
-      resetState();
-      throw TException("TDenseProtocol: No type specified.");
-    } else {
-      assert(type_spec_->ttype == T_STRUCT);
-      ts_stack_.push_back(type_spec_);
-
-      // Check the fingerprint prefix.
-      uint8_t buf[FP_PREFIX_LEN];
-      xfer += trans_->read(buf, FP_PREFIX_LEN);
-      if (std::memcmp(buf, type_spec_->fp_prefix, FP_PREFIX_LEN) != 0) {
-        resetState();
-        throw TProtocolException(TProtocolException::INVALID_DATA,
-            "Fingerprint in data does not match type_spec.");
-      }
-    }
-  }
-
-  // We need a new field index for this structure.
-  idx_stack_.push_back(0);
-  return 0;
-}
-
-uint32_t TDenseProtocol::readStructEnd() {
-  idx_stack_.pop_back();
-  stateTransition();
-  return 0;
-}
-
-uint32_t TDenseProtocol::readFieldBegin(string& name,
-                                        TType& fieldType,
-                                        int16_t& fieldId) {
-  (void) name;
-  uint32_t xfer = 0;
-
-  // For optional fields, check to see if they are there.
-  while (FMT.is_optional) {
-    bool is_present;
-    xfer += subReadBool(is_present);
-    if (is_present) {
-      break;
-    }
-    IDX++;
-  }
-
-  // Once we hit a mandatory field, or an optional field that is present,
-  // we know that FMT and FTS point to the appropriate field.
-
-  fieldId   = FMT.tag;
-  fieldType = FTS->ttype;
-
-  // Normally, we push the TypeSpec that we are about to read,
-  // but no reading is done for T_STOP.
-  if (FTS->ttype != T_STOP) {
-    ts_stack_.push_back(FTS);
-  }
-  return xfer;
-}
-
-uint32_t TDenseProtocol::readFieldEnd() {
-  IDX++;
-  return 0;
-}
-
-uint32_t TDenseProtocol::readMapBegin(TType& keyType,
-                                      TType& valType,
-                                      uint32_t& size) {
-  checkTType(T_MAP);
-
-  uint32_t xfer = 0;
-  int32_t sizei;
-  xfer += subReadI32(sizei);
-  if (sizei < 0) {
-    resetState();
-    throw TProtocolException(TProtocolException::NEGATIVE_SIZE);
-  } else if (container_limit_ && sizei > container_limit_) {
-    resetState();
-    throw TProtocolException(TProtocolException::SIZE_LIMIT);
-  }
-  size = (uint32_t)sizei;
-
-  keyType = ST1->ttype;
-  valType = ST2->ttype;
-
-  ts_stack_.push_back(ST1);
-  mkv_stack_.push_back(true);
-
-  return xfer;
-}
-
-uint32_t TDenseProtocol::readMapEnd() {
-  ts_stack_.pop_back();
-  mkv_stack_.pop_back();
-  stateTransition();
-  return 0;
-}
-
-uint32_t TDenseProtocol::readListBegin(TType& elemType,
-                                       uint32_t& size) {
-  checkTType(T_LIST);
-
-  uint32_t xfer = 0;
-  int32_t sizei;
-  xfer += subReadI32(sizei);
-  if (sizei < 0) {
-    resetState();
-    throw TProtocolException(TProtocolException::NEGATIVE_SIZE);
-  } else if (container_limit_ && sizei > container_limit_) {
-    resetState();
-    throw TProtocolException(TProtocolException::SIZE_LIMIT);
-  }
-  size = (uint32_t)sizei;
-
-  elemType = ST1->ttype;
-
-  ts_stack_.push_back(ST1);
-
-  return xfer;
-}
-
-uint32_t TDenseProtocol::readListEnd() {
-  ts_stack_.pop_back();
-  stateTransition();
-  return 0;
-}
-
-uint32_t TDenseProtocol::readSetBegin(TType& elemType,
-                                      uint32_t& size) {
-  checkTType(T_SET);
-
-  uint32_t xfer = 0;
-  int32_t sizei;
-  xfer += subReadI32(sizei);
-  if (sizei < 0) {
-    resetState();
-    throw TProtocolException(TProtocolException::NEGATIVE_SIZE);
-  } else if (container_limit_ && sizei > container_limit_) {
-    resetState();
-    throw TProtocolException(TProtocolException::SIZE_LIMIT);
-  }
-  size = (uint32_t)sizei;
-
-  elemType = ST1->ttype;
-
-  ts_stack_.push_back(ST1);
-
-  return xfer;
-}
-
-uint32_t TDenseProtocol::readSetEnd() {
-  ts_stack_.pop_back();
-  stateTransition();
-  return 0;
-}
-
-uint32_t TDenseProtocol::readBool(bool& value) {
-  checkTType(T_BOOL);
-  stateTransition();
-  return TBinaryProtocol::readBool(value);
-}
-
-uint32_t TDenseProtocol::readByte(int8_t& byte) {
-  checkTType(T_BYTE);
-  stateTransition();
-  return TBinaryProtocol::readByte(byte);
-}
-
-uint32_t TDenseProtocol::readI16(int16_t& i16) {
-  checkTType(T_I16);
-  stateTransition();
-  uint64_t u64;
-  uint32_t rv = vlqRead(u64);
-  int64_t val = (int64_t)u64;
-  if (UNLIKELY(val > INT16_MAX || val < INT16_MIN)) {
-    resetState();
-    throw TProtocolException(TProtocolException::INVALID_DATA,
-                             "i16 out of range.");
-  }
-  i16 = (int16_t)val;
-  return rv;
-}
-
-uint32_t TDenseProtocol::readI32(int32_t& i32) {
-  checkTType(T_I32);
-  stateTransition();
-  uint64_t u64;
-  uint32_t rv = vlqRead(u64);
-  int64_t val = (int64_t)u64;
-  if (UNLIKELY(val > INT32_MAX || val < INT32_MIN)) {
-    resetState();
-    throw TProtocolException(TProtocolException::INVALID_DATA,
-                             "i32 out of range.");
-  }
-  i32 = (int32_t)val;
-  return rv;
-}
-
-uint32_t TDenseProtocol::readI64(int64_t& i64) {
-  checkTType(T_I64);
-  stateTransition();
-  uint64_t u64;
-  uint32_t rv = vlqRead(u64);
-  int64_t val = (int64_t)u64;
-  if (UNLIKELY(val > INT64_MAX || val < INT64_MIN)) {
-    resetState();
-    throw TProtocolException(TProtocolException::INVALID_DATA,
-                             "i64 out of range.");
-  }
-  i64 = (int64_t)val;
-  return rv;
-}
-
-uint32_t TDenseProtocol::readDouble(double& dub) {
-  checkTType(T_DOUBLE);
-  stateTransition();
-  return TBinaryProtocol::readDouble(dub);
-}
-
-uint32_t TDenseProtocol::readString(std::string& str) {
-  checkTType(T_STRING);
-  stateTransition();
-  return subReadString(str);
-}
-
-uint32_t TDenseProtocol::readBinary(std::string& str) {
-  return TDenseProtocol::readString(str);
-}
-
-uint32_t TDenseProtocol::subReadI32(int32_t& i32) {
-  uint64_t u64;
-  uint32_t rv = vlqRead(u64);
-  int64_t val = (int64_t)u64;
-  if (UNLIKELY(val > INT32_MAX || val < INT32_MIN)) {
-    resetState();
-    throw TProtocolException(TProtocolException::INVALID_DATA,
-                             "i32 out of range.");
-  }
-  i32 = (int32_t)val;
-  return rv;
-}
-
-uint32_t TDenseProtocol::subReadString(std::string& str) {
-  uint32_t xfer;
-  int32_t size;
-  xfer = subReadI32(size);
-  return xfer + readStringBody(str, size);
-}
-
-}}} // apache::thrift::protocol

http://git-wip-us.apache.org/repos/asf/airavata-php-gateway/blob/d55608f1/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/thrift/protocol/TDenseProtocol.h
----------------------------------------------------------------------
diff --git a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/thrift/protocol/TDenseProtocol.h b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/thrift/protocol/TDenseProtocol.h
deleted file mode 100644
index 4808d79..0000000
--- a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/thrift/protocol/TDenseProtocol.h
+++ /dev/null
@@ -1,254 +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.
- */
-
-#ifndef _THRIFT_PROTOCOL_TDENSEPROTOCOL_H_
-#define _THRIFT_PROTOCOL_TDENSEPROTOCOL_H_ 1
-
-#include <thrift/protocol/TBinaryProtocol.h>
-
-namespace apache { namespace thrift { namespace protocol {
-
-/**
- * !!!WARNING!!!
- * This class is still highly experimental.  Incompatible changes
- * WILL be made to it without notice.  DO NOT USE IT YET unless
- * you are coordinating your testing with the author.
- *
- * The dense protocol is designed to use as little space as possible.
- *
- * There are two types of dense protocol instances.  Standalone instances
- * are not used for RPC and just encoded and decode structures of
- * a predetermined type.  Non-standalone instances are used for RPC.
- * Currently, only standalone instances exist.
- *
- * To use a standalone dense protocol object, you must set the type_spec
- * property (either in the constructor, or with setTypeSpec) to the local
- * reflection TypeSpec of the structures you will write to (or read from) the
- * protocol instance.
- *
- * BEST PRACTICES:
- * - Never use optional for primitives or containers.
- * - Only use optional for structures if they are very big and very rarely set.
- * - All integers are variable-length, so you can use i64 without bloating.
- * - NEVER EVER change the struct definitions IN ANY WAY without either
- *   changing your cache keys or talking to dreiss.
- *
- * TODO(dreiss): New class write with old meta.
- *
- * We override all of TBinaryProtocol's methods.
- * We inherit so that we can can explicitly call TBPs's primitive-writing
- * methods within our versions.
- *
- */
-class TDenseProtocol
-  : public TVirtualProtocol<TDenseProtocol, TBinaryProtocol> {
- protected:
-  static const int32_t VERSION_MASK = ((int32_t)0xffff0000);
-  // VERSION_1 (0x80010000)  is taken by TBinaryProtocol.
-  static const int32_t VERSION_2 = ((int32_t)0x80020000);
-
- public:
-  typedef apache::thrift::reflection::local::TypeSpec TypeSpec;
-  static const int FP_PREFIX_LEN;
-
-  /**
-   * @param tran       The transport to use.
-   * @param type_spec  The TypeSpec of the structures using this protocol.
-   */
-  TDenseProtocol(boost::shared_ptr<TTransport> trans,
-                 TypeSpec* type_spec = NULL) :
-    TVirtualProtocol<TDenseProtocol, TBinaryProtocol>(trans),
-    type_spec_(type_spec),
-    standalone_(true)
-  {}
-
-  void setTypeSpec(TypeSpec* type_spec) {
-    type_spec_ = type_spec;
-  }
-  TypeSpec* getTypeSpec() {
-    return type_spec_;
-  }
-
-
-  /*
-   * Writing functions.
-   */
-
-  uint32_t writeMessageBegin(const std::string& name,
-                             const TMessageType messageType,
-                             const int32_t seqid);
-
-  uint32_t writeMessageEnd();
-
-
-  uint32_t writeStructBegin(const char* name);
-
-  uint32_t writeStructEnd();
-
-  uint32_t writeFieldBegin(const char* name,
-                           const TType fieldType,
-                           const int16_t fieldId);
-
-  uint32_t writeFieldEnd();
-
-  uint32_t writeFieldStop();
-
-  uint32_t writeMapBegin(const TType keyType,
-                         const TType valType,
-                         const uint32_t size);
-
-  uint32_t writeMapEnd();
-
-  uint32_t writeListBegin(const TType elemType, const uint32_t size);
-
-  uint32_t writeListEnd();
-
-  uint32_t writeSetBegin(const TType elemType, const uint32_t size);
-
-  uint32_t writeSetEnd();
-
-  uint32_t writeBool(const bool value);
-
-  uint32_t writeByte(const int8_t byte);
-
-  uint32_t writeI16(const int16_t i16);
-
-  uint32_t writeI32(const int32_t i32);
-
-  uint32_t writeI64(const int64_t i64);
-
-  uint32_t writeDouble(const double dub);
-
-  uint32_t writeString(const std::string& str);
-
-  uint32_t writeBinary(const std::string& str);
-
-
-  /*
-   * Helper writing functions (don't do state transitions).
-   */
-  inline uint32_t subWriteI32(const int32_t i32);
-
-  inline uint32_t subWriteString(const std::string& str);
-
-  uint32_t subWriteBool(const bool value) {
-    return TBinaryProtocol::writeBool(value);
-  }
-
-
-  /*
-   * Reading functions
-   */
-
-  uint32_t readMessageBegin(std::string& name,
-                            TMessageType& messageType,
-                            int32_t& seqid);
-
-  uint32_t readMessageEnd();
-
-  uint32_t readStructBegin(std::string& name);
-
-  uint32_t readStructEnd();
-
-  uint32_t readFieldBegin(std::string& name,
-                          TType& fieldType,
-                          int16_t& fieldId);
-
-  uint32_t readFieldEnd();
-
-  uint32_t readMapBegin(TType& keyType,
-                        TType& valType,
-                        uint32_t& size);
-
-  uint32_t readMapEnd();
-
-  uint32_t readListBegin(TType& elemType,
-                         uint32_t& size);
-
-  uint32_t readListEnd();
-
-  uint32_t readSetBegin(TType& elemType,
-                        uint32_t& size);
-
-  uint32_t readSetEnd();
-
-  uint32_t readBool(bool& value);
-  // Provide the default readBool() implementation for std::vector<bool>
-  using TVirtualProtocol<TDenseProtocol, TBinaryProtocol>::readBool;
-
-  uint32_t readByte(int8_t& byte);
-
-  uint32_t readI16(int16_t& i16);
-
-  uint32_t readI32(int32_t& i32);
-
-  uint32_t readI64(int64_t& i64);
-
-  uint32_t readDouble(double& dub);
-
-  uint32_t readString(std::string& str);
-
-  uint32_t readBinary(std::string& str);
-
-  /*
-   * Helper reading functions (don't do state transitions).
-   */
-  inline uint32_t subReadI32(int32_t& i32);
-
-  inline uint32_t subReadString(std::string& str);
-
-  uint32_t subReadBool(bool& value) {
-    return TBinaryProtocol::readBool(value);
-  }
-
-
- private:
-
-  // Implementation functions, documented in the .cpp.
-  inline void checkTType(const TType ttype);
-  inline void stateTransition();
-
-  // Read and write variable-length integers.
-  // Uses the same technique as the MIDI file format.
-  inline uint32_t vlqRead(uint64_t& vlq);
-  inline uint32_t vlqWrite(uint64_t vlq);
-
-  // Called before throwing an exception to make the object reusable.
-  void resetState() {
-    ts_stack_.clear();
-    idx_stack_.clear();
-    mkv_stack_.clear();
-  }
-
-  // TypeSpec of the top-level structure to write,
-  // for standalone protocol objects.
-  TypeSpec* type_spec_;
-
-  std::vector<TypeSpec*> ts_stack_;   // TypeSpec stack.
-  std::vector<int>       idx_stack_;  // InDeX stack.
-  std::vector<bool>      mkv_stack_;  // Map Key/Vlue stack.
-                                      // True = key, False = value.
-
-  // True iff this is a standalone instance (no RPC).
-  bool standalone_;
-};
-
-}}} // apache::thrift::protocol
-
-#endif // #ifndef _THRIFT_PROTOCOL_TDENSEPROTOCOL_H_

http://git-wip-us.apache.org/repos/asf/airavata-php-gateway/blob/d55608f1/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/thrift/protocol/TJSONProtocol.cpp
----------------------------------------------------------------------
diff --git a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/thrift/protocol/TJSONProtocol.cpp b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/thrift/protocol/TJSONProtocol.cpp
deleted file mode 100644
index a0cc8e2..0000000
--- a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/thrift/protocol/TJSONProtocol.cpp
+++ /dev/null
@@ -1,1023 +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 <thrift/protocol/TJSONProtocol.h>
-
-#include <math.h>
-#include <boost/lexical_cast.hpp>
-#include <thrift/protocol/TBase64Utils.h>
-#include <thrift/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' + 10;
-  }
-  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 - 10 + '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) {
-    (void) trans;
-    return 0;
-  };
-
-  /**
-   * Read context data from the transport. Default is to do nothing.
-   */
-  virtual uint32_t read(TJSONProtocol::LookaheadReader &reader) {
-    (void) 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) :
-  TVirtualProtocol<TJSONProtocol>(ptrans),
-  trans_(ptrans.get()),
-  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(),
-                static_cast<uint32_t>(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();
-  if(str.length() > (std::numeric_limits<uint32_t>::max)())
-    throw TProtocolException(TProtocolException::SIZE_LIMIT);
-  uint32_t len = static_cast<uint32_t>(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;
-  }
-  if(val.length() > (std::numeric_limits<uint32_t>::max)())
-    throw TProtocolException(TProtocolException::SIZE_LIMIT);
-  trans_->write((const uint8_t *)val.c_str(), static_cast<uint32_t>(val.length()));
-  result += static_cast<uint32_t>(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;
-  }
-  if(val.length() > (std::numeric_limits<uint32_t>::max)())
-    throw TProtocolException(TProtocolException::SIZE_LIMIT);
-  trans_->write((const uint8_t *)val.c_str(), static_cast<uint32_t>(val.length()));
-  result += static_cast<uint32_t>(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) {
-  (void) name;
-  return writeJSONObjectStart();
-}
-
-uint32_t TJSONProtocol::writeStructEnd() {
-  return writeJSONObjectEnd();
-}
-
-uint32_t TJSONProtocol::writeFieldBegin(const char* name,
-                                        const TType fieldType,
-                                        const int16_t fieldId) {
-  (void) name;
-  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();
-  if(tmp.length() > (std::numeric_limits<uint32_t>::max)())
-    throw TProtocolException(TProtocolException::SIZE_LIMIT);
-  uint32_t len = static_cast<uint32_t>(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);
-  if(tmpVal > static_cast<uint64_t>((std::numeric_limits<int32_t>::max)()))
-    throw TProtocolException(TProtocolException::SIZE_LIMIT);
-  seqid = static_cast<int32_t>(tmpVal);
-  return result;
-}
-
-uint32_t TJSONProtocol::readMessageEnd() {
-  return readJSONArrayEnd();
-}
-
-uint32_t TJSONProtocol::readStructBegin(std::string& name) {
-  (void) name;
-  return readJSONObjectStart();
-}
-
-uint32_t TJSONProtocol::readStructEnd() {
-  return readJSONObjectEnd();
-}
-
-uint32_t TJSONProtocol::readFieldBegin(std::string& name,
-                                       TType& fieldType,
-                                       int16_t& fieldId) {
-  (void) name;
-  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);
-    if(tmpVal > static_cast<uint32_t>((std::numeric_limits<int16_t>::max)()))
-      throw TProtocolException(TProtocolException::SIZE_LIMIT);
-    fieldId = static_cast<int16_t>(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);
-  if(tmpVal > (std::numeric_limits<uint32_t>::max)())
-    throw TProtocolException(TProtocolException::SIZE_LIMIT);
-  size = static_cast<uint32_t>(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);
-  if(tmpVal > (std::numeric_limits<uint32_t>::max)())
-    throw TProtocolException(TProtocolException::SIZE_LIMIT);
-  size = static_cast<uint32_t>(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);
-  if(tmpVal > (std::numeric_limits<uint32_t>::max)())
-    throw TProtocolException(TProtocolException::SIZE_LIMIT);
-  size = static_cast<uint32_t>(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

http://git-wip-us.apache.org/repos/asf/airavata-php-gateway/blob/d55608f1/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/thrift/protocol/TJSONProtocol.h
----------------------------------------------------------------------
diff --git a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/thrift/protocol/TJSONProtocol.h b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/thrift/protocol/TJSONProtocol.h
deleted file mode 100644
index edfc744..0000000
--- a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/thrift/protocol/TJSONProtocol.h
+++ /dev/null
@@ -1,339 +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.
- */
-
-#ifndef _THRIFT_PROTOCOL_TJSONPROTOCOL_H_
-#define _THRIFT_PROTOCOL_TJSONPROTOCOL_H_ 1
-
-#include <thrift/protocol/TVirtualProtocol.h>
-
-#include <stack>
-
-namespace apache { namespace thrift { namespace protocol {
-
-// Forward declaration
-class TJSONContext;
-
-/**
- * JSON protocol for Thrift.
- *
- * Implements a protocol which uses JSON as the wire-format.
- *
- * Thrift types are represented as described below:
- *
- * 1. Every Thrift integer type is represented as a JSON number.
- *
- * 2. Thrift doubles are represented as JSON numbers. Some special values are
- *    represented as strings:
- *    a. "NaN" for not-a-number values
- *    b. "Infinity" for postive infinity
- *    c. "-Infinity" for negative infinity
- *
- * 3. Thrift string values are emitted as JSON strings, with appropriate
- *    escaping.
- *
- * 4. Thrift binary values are encoded into Base64 and emitted as JSON strings.
- *    The readBinary() method is written such that it will properly skip if
- *    called on a Thrift string (although it will decode garbage data).
- *
- * 5. Thrift structs are represented as JSON objects, with the field ID as the
- *    key, and the field value represented as a JSON object with a single
- *    key-value pair. The key is a short string identifier for that type,
- *    followed by the value. The valid type identifiers are: "tf" for bool,
- *    "i8" for byte, "i16" for 16-bit integer, "i32" for 32-bit integer, "i64"
- *    for 64-bit integer, "dbl" for double-precision loating point, "str" for
- *    string (including binary), "rec" for struct ("records"), "map" for map,
- *    "lst" for list, "set" for set.
- *
- * 6. Thrift lists and sets are represented as JSON arrays, with the first
- *    element of the JSON array being the string identifier for the Thrift
- *    element type and the second element of the JSON array being the count of
- *    the Thrift elements. The Thrift elements then follow.
- *
- * 7. Thrift maps are represented as JSON arrays, with the first two elements
- *    of the JSON array being the string identifiers for the Thrift key type
- *    and value type, followed by the count of the Thrift pairs, followed by a
- *    JSON object containing the key-value pairs. Note that JSON keys can only
- *    be strings, which means that the key type of the Thrift map should be
- *    restricted to numeric or string types -- in the case of numerics, they
- *    are serialized as strings.
- *
- * 8. Thrift messages are represented as JSON arrays, with the protocol
- *    version #, the message name, the message type, and the sequence ID as
- *    the first 4 elements.
- *
- * More discussion of the double handling is probably warranted. The aim of
- * the current implementation is to match as closely as possible the behavior
- * of Java's Double.toString(), which has no precision loss.  Implementors in
- * other languages should strive to achieve that where possible. I have not
- * yet verified whether boost:lexical_cast, which is doing that work for me in
- * C++, loses any precision, but I am leaving this as a future improvement. I
- * may try to provide a C component for this, so that other languages could
- * bind to the same underlying implementation for maximum consistency.
- *
- */
-class TJSONProtocol : public TVirtualProtocol<TJSONProtocol> {
- public:
-
-  TJSONProtocol(boost::shared_ptr<TTransport> ptrans);
-
-  ~TJSONProtocol();
-
- private:
-
-  void pushContext(boost::shared_ptr<TJSONContext> c);
-
-  void popContext();
-
-  uint32_t writeJSONEscapeChar(uint8_t ch);
-
-  uint32_t writeJSONChar(uint8_t ch);
-
-  uint32_t writeJSONString(const std::string &str);
-
-  uint32_t writeJSONBase64(const std::string &str);
-
-  template <typename NumberType>
-  uint32_t writeJSONInteger(NumberType num);
-
-  uint32_t writeJSONDouble(double num);
-
-  uint32_t writeJSONObjectStart() ;
-
-  uint32_t writeJSONObjectEnd();
-
-  uint32_t writeJSONArrayStart();
-
-  uint32_t writeJSONArrayEnd();
-
-  uint32_t readJSONSyntaxChar(uint8_t ch);
-
-  uint32_t readJSONEscapeChar(uint8_t *out);
-
-  uint32_t readJSONString(std::string &str, bool skipContext = false);
-
-  uint32_t readJSONBase64(std::string &str);
-
-  uint32_t readJSONNumericChars(std::string &str);
-
-  template <typename NumberType>
-  uint32_t readJSONInteger(NumberType &num);
-
-  uint32_t readJSONDouble(double &num);
-
-  uint32_t readJSONObjectStart();
-
-  uint32_t readJSONObjectEnd();
-
-  uint32_t readJSONArrayStart();
-
-  uint32_t readJSONArrayEnd();
-
- public:
-
-  /**
-   * Writing functions.
-   */
-
-  uint32_t writeMessageBegin(const std::string& name,
-                             const TMessageType messageType,
-                             const int32_t seqid);
-
-  uint32_t writeMessageEnd();
-
-  uint32_t writeStructBegin(const char* name);
-
-  uint32_t writeStructEnd();
-
-  uint32_t writeFieldBegin(const char* name,
-                           const TType fieldType,
-                           const int16_t fieldId);
-
-  uint32_t writeFieldEnd();
-
-  uint32_t writeFieldStop();
-
-  uint32_t writeMapBegin(const TType keyType,
-                         const TType valType,
-                         const uint32_t size);
-
-  uint32_t writeMapEnd();
-
-  uint32_t writeListBegin(const TType elemType,
-                          const uint32_t size);
-
-  uint32_t writeListEnd();
-
-  uint32_t writeSetBegin(const TType elemType,
-                         const uint32_t size);
-
-  uint32_t writeSetEnd();
-
-  uint32_t writeBool(const bool value);
-
-  uint32_t writeByte(const int8_t byte);
-
-  uint32_t writeI16(const int16_t i16);
-
-  uint32_t writeI32(const int32_t i32);
-
-  uint32_t writeI64(const int64_t i64);
-
-  uint32_t writeDouble(const double dub);
-
-  uint32_t writeString(const std::string& str);
-
-  uint32_t writeBinary(const std::string& str);
-
-  /**
-   * Reading functions
-   */
-
-  uint32_t readMessageBegin(std::string& name,
-                            TMessageType& messageType,
-                            int32_t& seqid);
-
-  uint32_t readMessageEnd();
-
-  uint32_t readStructBegin(std::string& name);
-
-  uint32_t readStructEnd();
-
-  uint32_t readFieldBegin(std::string& name,
-                          TType& fieldType,
-                          int16_t& fieldId);
-
-  uint32_t readFieldEnd();
-
-  uint32_t readMapBegin(TType& keyType,
-                        TType& valType,
-                        uint32_t& size);
-
-  uint32_t readMapEnd();
-
-  uint32_t readListBegin(TType& elemType,
-                         uint32_t& size);
-
-  uint32_t readListEnd();
-
-  uint32_t readSetBegin(TType& elemType,
-                        uint32_t& size);
-
-  uint32_t readSetEnd();
-
-  uint32_t readBool(bool& value);
-
-  // Provide the default readBool() implementation for std::vector<bool>
-  using TVirtualProtocol<TJSONProtocol>::readBool;
-
-  uint32_t readByte(int8_t& byte);
-
-  uint32_t readI16(int16_t& i16);
-
-  uint32_t readI32(int32_t& i32);
-
-  uint32_t readI64(int64_t& i64);
-
-  uint32_t readDouble(double& dub);
-
-  uint32_t readString(std::string& str);
-
-  uint32_t readBinary(std::string& str);
-
-  class LookaheadReader {
-
-   public:
-
-    LookaheadReader(TTransport &trans) :
-      trans_(&trans),
-      hasData_(false) {
-    }
-
-    uint8_t read() {
-      if (hasData_) {
-        hasData_ = false;
-      }
-      else {
-        trans_->readAll(&data_, 1);
-      }
-      return data_;
-    }
-
-    uint8_t peek() {
-      if (!hasData_) {
-        trans_->readAll(&data_, 1);
-      }
-      hasData_ = true;
-      return data_;
-    }
-
-   private:
-    TTransport *trans_;
-    bool hasData_;
-    uint8_t data_;
-  };
-
- private:
-  TTransport* trans_;
-
-  std::stack<boost::shared_ptr<TJSONContext> > contexts_;
-  boost::shared_ptr<TJSONContext> context_;
-  LookaheadReader reader_;
-};
-
-/**
- * Constructs input and output protocol objects given transports.
- */
-class TJSONProtocolFactory : public TProtocolFactory {
- public:
-  TJSONProtocolFactory() {}
-
-  virtual ~TJSONProtocolFactory() {}
-
-  boost::shared_ptr<TProtocol> getProtocol(boost::shared_ptr<TTransport> trans) {
-    return boost::shared_ptr<TProtocol>(new TJSONProtocol(trans));
-  }
-};
-
-}}} // apache::thrift::protocol
-
-
-// TODO(dreiss): Move part of ThriftJSONString into a .cpp file and remove this.
-#include <thrift/transport/TBufferTransports.h>
-
-namespace apache { namespace thrift {
-
-template<typename ThriftStruct>
-  std::string ThriftJSONString(const ThriftStruct& ts) {
-  using namespace apache::thrift::transport;
-  using namespace apache::thrift::protocol;
-  TMemoryBuffer* buffer = new TMemoryBuffer;
-  boost::shared_ptr<TTransport> trans(buffer);
-  TJSONProtocol protocol(trans);
-
-  ts.write(&protocol);
-
-  uint8_t* buf;
-  uint32_t size;
-  buffer->getBuffer(&buf, &size);
-  return std::string((char*)buf, (unsigned int)size);
-}
-
-}} // apache::thrift
-
-#endif // #define _THRIFT_PROTOCOL_TJSONPROTOCOL_H_ 1

http://git-wip-us.apache.org/repos/asf/airavata-php-gateway/blob/d55608f1/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/thrift/protocol/TMultiplexedProtocol.cpp
----------------------------------------------------------------------
diff --git a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/thrift/protocol/TMultiplexedProtocol.cpp b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/thrift/protocol/TMultiplexedProtocol.cpp
deleted file mode 100644
index a17eacc..0000000
--- a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/thrift/protocol/TMultiplexedProtocol.cpp
+++ /dev/null
@@ -1,47 +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 <thrift/protocol/TMultiplexedProtocol.h>
-#include <thrift/processor/TMultiplexedProcessor.h>
-#include <thrift/protocol/TProtocolDecorator.h>
-
-namespace apache 
-{ 
-    namespace thrift 
-    { 
-        namespace protocol 
-        {
-            uint32_t TMultiplexedProtocol::writeMessageBegin_virt(
-                const std::string& _name,
-                const TMessageType _type,
-                const int32_t _seqid)
-            {
-                if( _type == T_CALL || _type == T_ONEWAY )
-                {
-                    return TProtocolDecorator::writeMessageBegin_virt( serviceName + separator + _name, _type, _seqid );
-                }
-                else
-                {
-                    return TProtocolDecorator::writeMessageBegin_virt(_name, _type, _seqid);
-                }
-            }
-        }
-    }
-}
-

http://git-wip-us.apache.org/repos/asf/airavata-php-gateway/blob/d55608f1/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/thrift/protocol/TMultiplexedProtocol.h
----------------------------------------------------------------------
diff --git a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/thrift/protocol/TMultiplexedProtocol.h b/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/thrift/protocol/TMultiplexedProtocol.h
deleted file mode 100644
index a59c7b4..0000000
--- a/airavata-api/airavata-client-sdks/airavata-cpp-sdk/src/main/resources/lib/thrift/protocol/TMultiplexedProtocol.h
+++ /dev/null
@@ -1,103 +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.
- */
-
-#ifndef THRIFT_TMULTIPLEXEDPROTOCOL_H_
-#define THRIFT_TMULTIPLEXEDPROTOCOL_H_ 1
-
-#include <thrift/protocol/TProtocolDecorator.h>
-
-namespace apache 
-{ 
-    namespace thrift 
-    { 
-        namespace protocol 
-        {
-            using boost::shared_ptr;
-
-            /**
-             * <code>TMultiplexedProtocol</code> is a protocol-independent concrete decorator
-             * that allows a Thrift client to communicate with a multiplexing Thrift server,
-             * by prepending the service name to the function name during function calls.
-             *
-             * \note THIS IS NOT USED BY SERVERS.  On the server, use 
-             * {@link apache::thrift::TMultiplexedProcessor TMultiplexedProcessor} to handle requests
-             * from a multiplexing client.
-             *
-             * This example uses a single socket transport to invoke two services:
-             *
-             * <blockquote><code>
-             *     shared_ptr<TSocket> transport(new TSocket("localhost", 9090));
-             *     transport->open();
-             *
-             *     shared_ptr<TBinaryProtocol> protocol(new TBinaryProtocol(transport));
-             *
-             *     shared_ptr<TMultiplexedProtocol> mp1(new TMultiplexedProtocol(protocol, "Calculator"));
-             *     shared_ptr<CalculatorClient> service1(new CalculatorClient(mp1));
-             *
-             *     shared_ptr<TMultiplexedProtocol> mp2(new TMultiplexedProtocol(protocol, "WeatherReport"));
-             *     shared_ptr<WeatherReportClient> service2(new WeatherReportClient(mp2));
-             *
-             *     service1->add(2,2);
-             *     int temp = service2->getTemperature();
-             * </code></blockquote>
-             *
-             * @see apache::thrift::protocol::TProtocolDecorator
-             */
-             class TMultiplexedProtocol : public TProtocolDecorator
-            {
-            public:
-                /**
-                 * Wrap the specified protocol, allowing it to be used to communicate with a
-                 * multiplexing server.  The <code>serviceName</code> is required as it is
-                 * prepended to the message header so that the multiplexing server can broker
-                 * the function call to the proper service.
-                 *
-                 * \param _protocol    Your communication protocol of choice, e.g. <code>TBinaryProtocol</code>.
-                 * \param _serviceName The service name of the service communicating via this protocol.
-                 */
-                 TMultiplexedProtocol( shared_ptr<TProtocol> _protocol, const std::string& _serviceName ) 
-                    : TProtocolDecorator(_protocol),
-                      serviceName(_serviceName),
-                      separator(":")
-                { }
-                virtual ~TMultiplexedProtocol() {}
-
-                /**
-                 * Prepends the service name to the function name, separated by TMultiplexedProtocol::SEPARATOR.
-                 *
-                 * \param [in] _name   The name of the method to be called in the service.
-                 * \param [in] _type   The type of message
-                 * \param [in] _name   The sequential id of the message
-                 *
-                 * \throws TException  Passed through from wrapped <code>TProtocol</code> instance.
-                 */
-                uint32_t writeMessageBegin_virt(
-                    const std::string& _name, 
-                    const TMessageType _type, 
-                    const int32_t _seqid);
-            private:
-                const std::string serviceName;
-                const std::string separator;
-            };
-
-        }
-    }
-}
-
-#endif // THRIFT_TMULTIPLEXEDPROTOCOL_H_


Mime
View raw message