auser-poolparty 1.3.1 → 1.3.2

data/vendor/gems/thrift/lib/cpp/src/protocol/TCompactProtocol.h

@@ -1,279 +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_TCOMPACTPROTOCOL_H_
-#define _THRIFT_PROTOCOL_TCOMPACTPROTOCOL_H_ 1
-
-#include "TProtocol.h"
-
-#include <stack>
-#include <boost/shared_ptr.hpp>
-
-namespace apache { namespace thrift { namespace protocol {
-
-/**
- * C++ Implementation of the Compact Protocol as described in THRIFT-110
- */
-class TCompactProtocol : public TProtocol {
-
- protected:
-  static const int8_t  PROTOCOL_ID = 0x82;
-  static const int8_t  VERSION_N = 1;
-  static const int8_t  VERSION_MASK = 0x1f; // 0001 1111
-  static const int8_t  TYPE_MASK = 0xE0; // 1110 0000
-  static const int32_t TYPE_SHIFT_AMOUNT = 5;
-
-  /**
-   * (Writing) If we encounter a boolean field begin, save the TField here
-   * so it can have the value incorporated.
-   */
-  struct {
-    const char* name;
-    TType fieldType;
-    int16_t fieldId;
-  } booleanField_;
-
-  /**
-   * (Reading) If we read a field header, and it's a boolean field, save
-   * the boolean value here so that readBool can use it.
-   */
-  struct {
-    bool hasBoolValue;
-    bool boolValue;
-  } boolValue_;
-
-  /**
-   * Used to keep track of the last field for the current and previous structs,
-   * so we can do the delta stuff.
-   */
-
-  std::stack<int16_t> lastField_;
-  int16_t lastFieldId_;
-
-  enum Types {
-    CT_STOP           = 0x00,
-    CT_BOOLEAN_TRUE   = 0x01,
-    CT_BOOLEAN_FALSE  = 0x02,
-    CT_BYTE           = 0x03,
-    CT_I16            = 0x04,
-    CT_I32            = 0x05,
-    CT_I64            = 0x06,
-    CT_DOUBLE         = 0x07,
-    CT_BINARY         = 0x08,
-    CT_LIST           = 0x09,
-    CT_SET            = 0x0A,
-    CT_MAP            = 0x0B,
-    CT_STRUCT         = 0x0C,
-  };
-
-  static const int8_t TTypeToCType[16];
-
- public:
-  TCompactProtocol(boost::shared_ptr<TTransport> trans) :
-    TProtocol(trans),
-    lastFieldId_(0),
-    string_limit_(0),
-    string_buf_(NULL),
-    string_buf_size_(0),
-    container_limit_(0) {
-    booleanField_.name = NULL;
-    boolValue_.hasBoolValue = false;
-  }
-
-  TCompactProtocol(boost::shared_ptr<TTransport> trans,
-                   int32_t string_limit,
-                   int32_t container_limit) :
-    TProtocol(trans),
-    lastFieldId_(0),
-    string_limit_(string_limit),
-    string_buf_(NULL),
-    string_buf_size_(0),
-    container_limit_(container_limit) {
-    booleanField_.name = NULL;
-    boolValue_.hasBoolValue = false;
-  }
-
-
-
-  /**
-   * Writing functions
-   */
-
-  virtual uint32_t writeMessageBegin(const std::string& name,
-                                     const TMessageType messageType,
-                                     const int32_t seqid);
-
-  uint32_t writeStructBegin(const char* name);
-
-  uint32_t writeStructEnd();
-
-  uint32_t writeFieldBegin(const char* name,
-                           const TType fieldType,
-                           const int16_t fieldId);
-
-  uint32_t writeFieldStop();
-
-  uint32_t writeListBegin(const TType elemType,
-                          const uint32_t size);
-
-  uint32_t writeSetBegin(const TType elemType,
-                         const uint32_t size);
-
-  virtual uint32_t writeMapBegin(const TType keyType,
-                                 const TType valType,
-                                 const uint32_t size);
-
-  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);
-
-  /**
-  * These methods are called by structs, but don't actually have any wired
-  * output or purpose
-  */
-  virtual uint32_t writeMessageEnd() { return 0; }
-  uint32_t writeMapEnd() { return 0; }
-  uint32_t writeListEnd() { return 0; }
-  uint32_t writeSetEnd() { return 0; }
-  uint32_t writeFieldEnd() { return 0; }
-
- protected:
-  int32_t writeFieldBeginInternal(const char* name,
-                                  const TType fieldType,
-                                  const int16_t fieldId,
-                                  int8_t typeOverride);
-  uint32_t writeCollectionBegin(int8_t elemType, int32_t size);
-  uint32_t writeVarint32(uint32_t n);
-  uint32_t writeVarint64(uint64_t n);
-  uint64_t i64ToZigzag(const int64_t l);
-  uint32_t i32ToZigzag(const int32_t n);
-  inline int8_t getCompactType(int8_t ttype);
-
- public:
-  uint32_t readMessageBegin(std::string& name,
-                            TMessageType& messageType,
-                            int32_t& seqid);
-
-  uint32_t readStructBegin(std::string& name);
-
-  uint32_t readStructEnd();
-
-  uint32_t readFieldBegin(std::string& name,
-                          TType& fieldType,
-                          int16_t& fieldId);
-
-  uint32_t readMapBegin(TType& keyType,
-                        TType& valType,
-                        uint32_t& size);
-
-  uint32_t readListBegin(TType& elemType,
-                         uint32_t& size);
-
-  uint32_t readSetBegin(TType& elemType,
-                        uint32_t& size);
-
-  uint32_t readBool(bool& value);
-
-  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);
-
-  /*
-   *These methods are here for the struct to call, but don't have any wire
-   * encoding.
-   */
-  uint32_t readMessageEnd() { return 0; }
-  uint32_t readFieldEnd() { return 0; }
-  uint32_t readMapEnd() { return 0; }
-  uint32_t readListEnd() { return 0; }
-  uint32_t readSetEnd() { return 0; }
-
- protected:
-  uint32_t readVarint32(int32_t& i32);
-  uint32_t readVarint64(int64_t& i64);
-  int32_t zigzagToI32(uint32_t n);
-  int64_t zigzagToI64(uint64_t n);
-  TType getTType(int8_t type);
-
-  // Buffer for reading strings, save for the lifetime of the protocol to
-  // avoid memory churn allocating memory on every string read
-  int32_t string_limit_;
-  uint8_t* string_buf_;
-  int32_t string_buf_size_;
-  int32_t container_limit_;
-};
-
-/**
- * Constructs compact protocol handlers
- */
-class TCompactProtocolFactory : public TProtocolFactory {
- public:
-  TCompactProtocolFactory() :
-    string_limit_(0),
-    container_limit_(0) {}
-
-  TCompactProtocolFactory(int32_t string_limit, int32_t container_limit) :
-    string_limit_(string_limit),
-    container_limit_(container_limit) {}
-
-  virtual ~TCompactProtocolFactory() {}
-
-  void setStringSizeLimit(int32_t string_limit) {
-    string_limit_ = string_limit;
-  }
-
-  void setContainerSizeLimit(int32_t container_limit) {
-    container_limit_ = container_limit;
-  }
-
-  boost::shared_ptr<TProtocol> getProtocol(boost::shared_ptr<TTransport> trans) {
-    return boost::shared_ptr<TProtocol>(new TCompactProtocol(trans, string_limit_, container_limit_));
-  }
-
- private:
-  int32_t string_limit_;
-  int32_t container_limit_;
-
-};
-
-}}} // apache::thrift::protocol
-
-#endif

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

@@ -1,346 +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 "TDebugProtocol.h"
-
-#include <cassert>
-#include <cctype>
-#include <cstdio>
-#include <stdexcept>
-#include <boost/static_assert.hpp>
-#include <boost/lexical_cast.hpp>
-
-using std::string;
-
-
-static string byte_to_hex(const uint8_t byte) {
-  char buf[3];
-  int ret = std::sprintf(buf, "%02x", (int)byte);
-  assert(ret == 2);
-  assert(buf[2] == '\0');
-  return buf;
-}
-
-
-namespace apache { namespace thrift { namespace protocol {
-
-string TDebugProtocol::fieldTypeName(TType type) {
-  switch (type) {
-    case T_STOP   : return "stop"   ;
-    case T_VOID   : return "void"   ;
-    case T_BOOL   : return "bool"   ;
-    case T_BYTE   : return "byte"   ;
-    case T_I16    : return "i16"    ;
-    case T_I32    : return "i32"    ;
-    case T_U64    : return "u64"    ;
-    case T_I64    : return "i64"    ;
-    case T_DOUBLE : return "double" ;
-    case T_STRING : return "string" ;
-    case T_STRUCT : return "struct" ;
-    case T_MAP    : return "map"    ;
-    case T_SET    : return "set"    ;
-    case T_LIST   : return "list"   ;
-    case T_UTF8   : return "utf8"   ;
-    case T_UTF16  : return "utf16"  ;
-    default: return "unknown";
-  }
-}
-
-void TDebugProtocol::indentUp() {
-  indent_str_ += string(indent_inc, ' ');
-}
-
-void TDebugProtocol::indentDown() {
-  if (indent_str_.length() < (string::size_type)indent_inc) {
-    throw TProtocolException(TProtocolException::INVALID_DATA);
-  }
-  indent_str_.erase(indent_str_.length() - indent_inc);
-}
-
-uint32_t TDebugProtocol::writePlain(const string& str) {
-  trans_->write((uint8_t*)str.data(), str.length());
-  return str.length();
-}
-
-uint32_t TDebugProtocol::writeIndented(const string& str) {
-  trans_->write((uint8_t*)indent_str_.data(), indent_str_.length());
-  trans_->write((uint8_t*)str.data(), str.length());
-  return indent_str_.length() + str.length();
-}
-
-uint32_t TDebugProtocol::startItem() {
-  uint32_t size;
-
-  switch (write_state_.back()) {
-    case UNINIT:
-      // XXX figure out what to do here.
-      //throw TProtocolException(TProtocolException::INVALID_DATA);
-      //return writeIndented(str);
-      return 0;
-    case STRUCT:
-      return 0;
-    case SET:
-      return writeIndented("");
-    case MAP_KEY:
-      return writeIndented("");
-    case MAP_VALUE:
-      return writePlain(" -> ");
-    case LIST:
-      size = writeIndented(
-          "[" + boost::lexical_cast<string>(list_idx_.back()) + "] = ");
-      list_idx_.back()++;
-      return size;
-    default:
-      throw std::logic_error("Invalid enum value.");
-  }
-}
-
-uint32_t TDebugProtocol::endItem() {
-  //uint32_t size;
-
-  switch (write_state_.back()) {
-    case UNINIT:
-      // XXX figure out what to do here.
-      //throw TProtocolException(TProtocolException::INVALID_DATA);
-      //return writeIndented(str);
-      return 0;
-    case STRUCT:
-      return writePlain(",\n");
-    case SET:
-      return writePlain(",\n");
-    case MAP_KEY:
-      write_state_.back() = MAP_VALUE;
-      return 0;
-    case MAP_VALUE:
-      write_state_.back() = MAP_KEY;
-      return writePlain(",\n");
-    case LIST:
-      return writePlain(",\n");
-    default:
-      throw std::logic_error("Invalid enum value.");
-  }
-}
-
-uint32_t TDebugProtocol::writeItem(const std::string& str) {
-  uint32_t size = 0;
-  size += startItem();
-  size += writePlain(str);
-  size += endItem();
-  return size;
-}
-
-uint32_t TDebugProtocol::writeMessageBegin(const std::string& name,
-                                           const TMessageType messageType,
-                                           const int32_t seqid) {
-  string mtype;
-  switch (messageType) {
-    case T_CALL      : mtype = "call"  ; break;
-    case T_REPLY     : mtype = "reply" ; break;
-    case T_EXCEPTION : mtype = "exn"   ; break;
-  }
-
-  uint32_t size = writeIndented("(" + mtype + ") " + name + "(");
-  indentUp();
-  return size;
-}
-
-uint32_t TDebugProtocol::writeMessageEnd() {
-  indentDown();
-  return writeIndented(")\n");
-}
-
-uint32_t TDebugProtocol::writeStructBegin(const char* name) {
-  uint32_t size = 0;
-  size += startItem();
-  size += writePlain(string(name) + " {\n");
-  indentUp();
-  write_state_.push_back(STRUCT);
-  return size;
-}
-
-uint32_t TDebugProtocol::writeStructEnd() {
-  indentDown();
-  write_state_.pop_back();
-  uint32_t size = 0;
-  size += writeIndented("}");
-  size += endItem();
-  return size;
-}
-
-uint32_t TDebugProtocol::writeFieldBegin(const char* name,
-                                         const TType fieldType,
-                                         const int16_t fieldId) {
-  // sprintf(id_str, "%02d", fieldId);
-  string id_str = boost::lexical_cast<string>(fieldId);
-  if (id_str.length() == 1) id_str = '0' + id_str;
-
-  return writeIndented(
-      id_str + ": " +
-      name + " (" +
-      fieldTypeName(fieldType) + ") = ");
-}
-
-uint32_t TDebugProtocol::writeFieldEnd() {
-  assert(write_state_.back() == STRUCT);
-  return 0;
-}
-
-uint32_t TDebugProtocol::writeFieldStop() {
-  return 0;
-    //writeIndented("***STOP***\n");
-}
-
-uint32_t TDebugProtocol::writeMapBegin(const TType keyType,
-                                       const TType valType,
-                                       const uint32_t size) {
-  // TODO(dreiss): Optimize short maps?
-  uint32_t bsize = 0;
-  bsize += startItem();
-  bsize += writePlain(
-      "map<" + fieldTypeName(keyType) + "," + fieldTypeName(valType) + ">"
-      "[" + boost::lexical_cast<string>(size) + "] {\n");
-  indentUp();
-  write_state_.push_back(MAP_KEY);
-  return bsize;
-}
-
-uint32_t TDebugProtocol::writeMapEnd() {
-  indentDown();
-  write_state_.pop_back();
-  uint32_t size = 0;
-  size += writeIndented("}");
-  size += endItem();
-  return size;
-}
-
-uint32_t TDebugProtocol::writeListBegin(const TType elemType,
-                                        const uint32_t size) {
-  // TODO(dreiss): Optimize short arrays.
-  uint32_t bsize = 0;
-  bsize += startItem();
-  bsize += writePlain(
-      "list<" + fieldTypeName(elemType) + ">"
-      "[" + boost::lexical_cast<string>(size) + "] {\n");
-  indentUp();
-  write_state_.push_back(LIST);
-  list_idx_.push_back(0);
-  return bsize;
-}
-
-uint32_t TDebugProtocol::writeListEnd() {
-  indentDown();
-  write_state_.pop_back();
-  list_idx_.pop_back();
-  uint32_t size = 0;
-  size += writeIndented("}");
-  size += endItem();
-  return size;
-}
-
-uint32_t TDebugProtocol::writeSetBegin(const TType elemType,
-                                       const uint32_t size) {
-  // TODO(dreiss): Optimize short sets.
-  uint32_t bsize = 0;
-  bsize += startItem();
-  bsize += writePlain(
-      "set<" + fieldTypeName(elemType) + ">"
-      "[" + boost::lexical_cast<string>(size) + "] {\n");
-  indentUp();
-  write_state_.push_back(SET);
-  return bsize;
-}
-
-uint32_t TDebugProtocol::writeSetEnd() {
-  indentDown();
-  write_state_.pop_back();
-  uint32_t size = 0;
-  size += writeIndented("}");
-  size += endItem();
-  return size;
-}
-
-uint32_t TDebugProtocol::writeBool(const bool value) {
-  return writeItem(value ? "true" : "false");
-}
-
-uint32_t TDebugProtocol::writeByte(const int8_t byte) {
-  return writeItem("0x" + byte_to_hex(byte));
-}
-
-uint32_t TDebugProtocol::writeI16(const int16_t i16) {
-  return writeItem(boost::lexical_cast<string>(i16));
-}
-
-uint32_t TDebugProtocol::writeI32(const int32_t i32) {
-  return writeItem(boost::lexical_cast<string>(i32));
-}
-
-uint32_t TDebugProtocol::writeI64(const int64_t i64) {
-  return writeItem(boost::lexical_cast<string>(i64));
-}
-
-uint32_t TDebugProtocol::writeDouble(const double dub) {
-  return writeItem(boost::lexical_cast<string>(dub));
-}
-
-
-uint32_t TDebugProtocol::writeString(const string& str) {
-  // XXX Raw/UTF-8?
-
-  string to_show = str;
-  if (to_show.length() > (string::size_type)string_limit_) {
-    to_show = str.substr(0, string_prefix_size_);
-    to_show += "[...](" + boost::lexical_cast<string>(str.length()) + ")";
-  }
-
-  string output = "\"";
-
-  for (string::const_iterator it = to_show.begin(); it != to_show.end(); ++it) {
-    if (*it == '\\') {
-      output += "\\\\";
-    } else if (*it == '"') {
-      output += "\\\"";
-    } else if (std::isprint(*it)) {
-      output += *it;
-    } else {
-      switch (*it) {
-        case '\a': output += "\\a"; break;
-        case '\b': output += "\\b"; break;
-        case '\f': output += "\\f"; break;
-        case '\n': output += "\\n"; break;
-        case '\r': output += "\\r"; break;
-        case '\t': output += "\\t"; break;
-        case '\v': output += "\\v"; break;
-        default:
-          output += "\\x";
-          output += byte_to_hex(*it);
-      }
-    }
-  }
-
-  output += '\"';
-  return writeItem(output);
-}
-
-uint32_t TDebugProtocol::writeBinary(const string& str) {
-  // XXX Hex?
-  return TDebugProtocol::writeString(str);
-}
-
-}}} // apache::thrift::protocol