hawq-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From m..@apache.org
Subject [01/70] [partial] incubator-hawq git commit: HAWQ-959. revert thrift build commands.
Date Thu, 08 Sep 2016 02:07:34 GMT
Repository: incubator-hawq
Updated Branches:
  refs/heads/master 429ae91ae -> b0cc5556c


http://git-wip-us.apache.org/repos/asf/incubator-hawq/blob/72ea8afd/depends/thirdparty/thrift/lib/cpp/src/thrift/protocol/TCompactProtocol.tcc
----------------------------------------------------------------------
diff --git a/depends/thirdparty/thrift/lib/cpp/src/thrift/protocol/TCompactProtocol.tcc b/depends/thirdparty/thrift/lib/cpp/src/thrift/protocol/TCompactProtocol.tcc
deleted file mode 100644
index 4d660e8..0000000
--- a/depends/thirdparty/thrift/lib/cpp/src/thrift/protocol/TCompactProtocol.tcc
+++ /dev/null
@@ -1,824 +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_TCC_
-#define _THRIFT_PROTOCOL_TCOMPACTPROTOCOL_TCC_ 1
-
-#include <limits>
-
-/*
- * TCompactProtocol::i*ToZigzag depend on the fact that the right shift
- * operator on a signed integer is an arithmetic (sign-extending) shift.
- * If this is not the case, the current implementation will not work.
- * If anyone encounters this error, we can try to figure out the best
- * way to implement an arithmetic right shift on their platform.
- */
-#if !defined(SIGNED_RIGHT_SHIFT_IS) || !defined(ARITHMETIC_RIGHT_SHIFT)
-# error "Unable to determine the behavior of a signed right shift"
-#endif
-#if SIGNED_RIGHT_SHIFT_IS != ARITHMETIC_RIGHT_SHIFT
-# error "TCompactProtocol currently only works if a signed right shift is arithmetic"
-#endif
-
-#ifdef __GNUC__
-#define UNLIKELY(val) (__builtin_expect((val), 0))
-#else
-#define UNLIKELY(val) (val)
-#endif
-
-namespace apache { namespace thrift { namespace protocol {
-
-namespace detail { namespace compact {
-
-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
-};
-
-const int8_t TTypeToCType[16] = {
-  CT_STOP, // T_STOP
-  0, // unused
-  CT_BOOLEAN_TRUE, // T_BOOL
-  CT_BYTE, // T_BYTE
-  CT_DOUBLE, // T_DOUBLE
-  0, // unused
-  CT_I16, // T_I16
-  0, // unused
-  CT_I32, // T_I32
-  0, // unused
-  CT_I64, // T_I64
-  CT_BINARY, // T_STRING
-  CT_STRUCT, // T_STRUCT
-  CT_MAP, // T_MAP
-  CT_SET, // T_SET
-  CT_LIST, // T_LIST
-};
-
-}} // end detail::compact namespace
-
-
-template <class Transport_>
-uint32_t TCompactProtocolT<Transport_>::writeMessageBegin(
-    const std::string& name,
-    const TMessageType messageType,
-    const int32_t seqid) {
-  uint32_t wsize = 0;
-  wsize += writeByte(PROTOCOL_ID);
-  wsize += writeByte((VERSION_N & VERSION_MASK) | (((int32_t)messageType << TYPE_SHIFT_AMOUNT)
& TYPE_MASK));
-  wsize += writeVarint32(seqid);
-  wsize += writeString(name);
-  return wsize;
-}
-
-/**
- * Write a field header containing the field id and field type. If the
- * difference between the current field id and the last one is small (< 15),
- * then the field id will be encoded in the 4 MSB as a delta. Otherwise, the
- * field id will follow the type header as a zigzag varint.
- */
-template <class Transport_>
-uint32_t TCompactProtocolT<Transport_>::writeFieldBegin(const char* name,
-                                                        const TType fieldType,
-                                                        const int16_t fieldId) {
-  if (fieldType == T_BOOL) {
-    booleanField_.name = name;
-    booleanField_.fieldType = fieldType;
-    booleanField_.fieldId = fieldId;
-  } else {
-    return writeFieldBeginInternal(name, fieldType, fieldId, -1);
-  }
-  return 0;
-}
-
-/**
- * Write the STOP symbol so we know there are no more fields in this struct.
- */
-template <class Transport_>
-uint32_t TCompactProtocolT<Transport_>::writeFieldStop() {
-  return writeByte(T_STOP);
-}
-
-/**
- * Write a struct begin. This doesn't actually put anything on the wire. We
- * use it as an opportunity to put special placeholder markers on the field
- * stack so we can get the field id deltas correct.
- */
-template <class Transport_>
-uint32_t TCompactProtocolT<Transport_>::writeStructBegin(const char* name) {
-  (void) name;
-  lastField_.push(lastFieldId_);
-  lastFieldId_ = 0;
-  return 0;
-}
-
-/**
- * Write a struct end. This doesn't actually put anything on the wire. We use
- * this as an opportunity to pop the last field from the current struct off
- * of the field stack.
- */
-template <class Transport_>
-uint32_t TCompactProtocolT<Transport_>::writeStructEnd() {
-  lastFieldId_ = lastField_.top();
-  lastField_.pop();
-  return 0;
-}
-
-/**
- * Write a List header.
- */
-template <class Transport_>
-uint32_t TCompactProtocolT<Transport_>::writeListBegin(const TType elemType,
-                                                       const uint32_t size) {
-  return writeCollectionBegin(elemType, size);
-}
-
-/**
- * Write a set header.
- */
-template <class Transport_>
-uint32_t TCompactProtocolT<Transport_>::writeSetBegin(const TType elemType,
-                                                      const uint32_t size) {
-  return writeCollectionBegin(elemType, size);
-}
-
-/**
- * Write a map header. If the map is empty, omit the key and value type
- * headers, as we don't need any additional information to skip it.
- */
-template <class Transport_>
-uint32_t TCompactProtocolT<Transport_>::writeMapBegin(const TType keyType,
-                                                      const TType valType,
-                                                      const uint32_t size) {
-  uint32_t wsize = 0;
-
-  if (size == 0) {
-    wsize += writeByte(0);
-  } else {
-    wsize += writeVarint32(size);
-    wsize += writeByte(getCompactType(keyType) << 4 | getCompactType(valType));
-  }
-  return wsize;
-}
-
-/**
- * Write a boolean value. Potentially, this could be a boolean field, in
- * which case the field header info isn't written yet. If so, decide what the
- * right type header is for the value and then write the field header.
- * Otherwise, write a single byte.
- */
-template <class Transport_>
-uint32_t TCompactProtocolT<Transport_>::writeBool(const bool value) {
-  uint32_t wsize = 0;
-
-  if (booleanField_.name != NULL) {
-    // we haven't written the field header yet
-    wsize
-      += writeFieldBeginInternal(booleanField_.name,
-                                 booleanField_.fieldType,
-                                 booleanField_.fieldId,
-                                 static_cast<int8_t>(value
-                                                     ? detail::compact::CT_BOOLEAN_TRUE
-                                                     : detail::compact::CT_BOOLEAN_FALSE));
-    booleanField_.name = NULL;
-  } else {
-    // we're not part of a field, so just write the value
-    wsize
-      += writeByte(static_cast<int8_t>(value
-                                       ? detail::compact::CT_BOOLEAN_TRUE
-                                       : detail::compact::CT_BOOLEAN_FALSE));
-  }
-  return wsize;
-}
-
-template <class Transport_>
-uint32_t TCompactProtocolT<Transport_>::writeByte(const int8_t byte) {
-  trans_->write((uint8_t*)&byte, 1);
-  return 1;
-}
-
-/**
- * Write an i16 as a zigzag varint.
- */
-template <class Transport_>
-uint32_t TCompactProtocolT<Transport_>::writeI16(const int16_t i16) {
-  return writeVarint32(i32ToZigzag(i16));
-}
-
-/**
- * Write an i32 as a zigzag varint.
- */
-template <class Transport_>
-uint32_t TCompactProtocolT<Transport_>::writeI32(const int32_t i32) {
-  return writeVarint32(i32ToZigzag(i32));
-}
-
-/**
- * Write an i64 as a zigzag varint.
- */
-template <class Transport_>
-uint32_t TCompactProtocolT<Transport_>::writeI64(const int64_t i64) {
-  return writeVarint64(i64ToZigzag(i64));
-}
-
-/**
- * Write a double to the wire as 8 bytes.
- */
-template <class Transport_>
-uint32_t TCompactProtocolT<Transport_>::writeDouble(const double dub) {
-  BOOST_STATIC_ASSERT(sizeof(double) == sizeof(uint64_t));
-  BOOST_STATIC_ASSERT(std::numeric_limits<double>::is_iec559);
-
-  uint64_t bits = bitwise_cast<uint64_t>(dub);
-  bits = THRIFT_htolell(bits);
-  trans_->write((uint8_t*)&bits, 8);
-  return 8;
-}
-
-/**
- * Write a string to the wire with a varint size preceding.
- */
-template <class Transport_>
-uint32_t TCompactProtocolT<Transport_>::writeString(const std::string& str) {
-  return writeBinary(str);
-}
-
-template <class Transport_>
-uint32_t TCompactProtocolT<Transport_>::writeBinary(const std::string& str) {
-  if(str.size() > (std::numeric_limits<uint32_t>::max)())
-    throw TProtocolException(TProtocolException::SIZE_LIMIT);
-  uint32_t ssize = static_cast<uint32_t>(str.size());
-  uint32_t wsize = writeVarint32(ssize) ;
-  // checking ssize + wsize > uint_max, but we don't want to overflow while checking for
overflows.
-  // transforming the check to ssize > uint_max - wsize
-  if(ssize > (std::numeric_limits<uint32_t>::max)() - wsize)
-    throw TProtocolException(TProtocolException::SIZE_LIMIT);
-  wsize += ssize;
-  trans_->write((uint8_t*)str.data(), ssize);
-  return wsize;
-}
-
-//
-// Internal Writing methods
-//
-
-/**
- * The workhorse of writeFieldBegin. It has the option of doing a
- * 'type override' of the type header. This is used specifically in the
- * boolean field case.
- */
-template <class Transport_>
-int32_t TCompactProtocolT<Transport_>::writeFieldBeginInternal(
-    const char* name,
-    const TType fieldType,
-    const int16_t fieldId,
-    int8_t typeOverride) {
-  (void) name;
-  uint32_t wsize = 0;
-
-  // if there's a type override, use that.
-  int8_t typeToWrite = (typeOverride == -1 ? getCompactType(fieldType) : typeOverride);
-
-  // check if we can use delta encoding for the field id
-  if (fieldId > lastFieldId_ && fieldId - lastFieldId_ <= 15) {
-    // write them together
-    wsize += writeByte(static_cast<int8_t>((fieldId - lastFieldId_)
-                                           << 4 | typeToWrite));
-  } else {
-    // write them separate
-    wsize += writeByte(typeToWrite);
-    wsize += writeI16(fieldId);
-  }
-
-  lastFieldId_ = fieldId;
-  return wsize;
-}
-
-/**
- * Abstract method for writing the start of lists and sets. List and sets on
- * the wire differ only by the type indicator.
- */
-template <class Transport_>
-uint32_t TCompactProtocolT<Transport_>::writeCollectionBegin(const TType elemType,
-                                                             int32_t size) {
-  uint32_t wsize = 0;
-  if (size <= 14) {
-    wsize += writeByte(static_cast<int8_t>(size
-                                           << 4 | getCompactType(elemType)));
-  } else {
-    wsize += writeByte(0xf0 | getCompactType(elemType));
-    wsize += writeVarint32(size);
-  }
-  return wsize;
-}
-
-/**
- * Write an i32 as a varint. Results in 1-5 bytes on the wire.
- */
-template <class Transport_>
-uint32_t TCompactProtocolT<Transport_>::writeVarint32(uint32_t n) {
-  uint8_t buf[5];
-  uint32_t wsize = 0;
-
-  while (true) {
-    if ((n & ~0x7F) == 0) {
-      buf[wsize++] = (int8_t)n;
-      break;
-    } else {
-      buf[wsize++] = (int8_t)((n & 0x7F) | 0x80);
-      n >>= 7;
-    }
-  }
-  trans_->write(buf, wsize);
-  return wsize;
-}
-
-/**
- * Write an i64 as a varint. Results in 1-10 bytes on the wire.
- */
-template <class Transport_>
-uint32_t TCompactProtocolT<Transport_>::writeVarint64(uint64_t n) {
-  uint8_t buf[10];
-  uint32_t wsize = 0;
-
-  while (true) {
-    if ((n & ~0x7FL) == 0) {
-      buf[wsize++] = (int8_t)n;
-      break;
-    } else {
-      buf[wsize++] = (int8_t)((n & 0x7F) | 0x80);
-      n >>= 7;
-    }
-  }
-  trans_->write(buf, wsize);
-  return wsize;
-}
-
-/**
- * Convert l into a zigzag long. This allows negative numbers to be
- * represented compactly as a varint.
- */
-template <class Transport_>
-uint64_t TCompactProtocolT<Transport_>::i64ToZigzag(const int64_t l) {
-  return (l << 1) ^ (l >> 63);
-}
-
-/**
- * Convert n into a zigzag int. This allows negative numbers to be
- * represented compactly as a varint.
- */
-template <class Transport_>
-uint32_t TCompactProtocolT<Transport_>::i32ToZigzag(const int32_t n) {
-  return (n << 1) ^ (n >> 31);
-}
-
-/**
- * Given a TType value, find the appropriate detail::compact::Types value
- */
-template <class Transport_>
-int8_t TCompactProtocolT<Transport_>::getCompactType(const TType ttype) {
-  return detail::compact::TTypeToCType[ttype];
-}
-
-//
-// Reading Methods
-//
-
-/**
- * Read a message header.
- */
-template <class Transport_>
-uint32_t TCompactProtocolT<Transport_>::readMessageBegin(
-    std::string& name,
-    TMessageType& messageType,
-    int32_t& seqid) {
-  uint32_t rsize = 0;
-  int8_t protocolId;
-  int8_t versionAndType;
-  int8_t version;
-
-  rsize += readByte(protocolId);
-  if (protocolId != PROTOCOL_ID) {
-    throw TProtocolException(TProtocolException::BAD_VERSION, "Bad protocol identifier");
-  }
-
-  rsize += readByte(versionAndType);
-  version = (int8_t)(versionAndType & VERSION_MASK);
-  if (version != VERSION_N) {
-    throw TProtocolException(TProtocolException::BAD_VERSION, "Bad protocol version");
-  }
-
-  messageType = (TMessageType)((versionAndType >> TYPE_SHIFT_AMOUNT) & TYPE_BITS);
-  rsize += readVarint32(seqid);
-  rsize += readString(name);
-
-  return rsize;
-}
-
-/**
- * Read a struct begin. There's nothing on the wire for this, but it is our
- * opportunity to push a new struct begin marker on the field stack.
- */
-template <class Transport_>
-uint32_t TCompactProtocolT<Transport_>::readStructBegin(std::string& name) {
-  name = "";
-  lastField_.push(lastFieldId_);
-  lastFieldId_ = 0;
-  return 0;
-}
-
-/**
- * Doesn't actually consume any wire data, just removes the last field for
- * this struct from the field stack.
- */
-template <class Transport_>
-uint32_t TCompactProtocolT<Transport_>::readStructEnd() {
-  lastFieldId_ = lastField_.top();
-  lastField_.pop();
-  return 0;
-}
-
-/**
- * Read a field header off the wire.
- */
-template <class Transport_>
-uint32_t TCompactProtocolT<Transport_>::readFieldBegin(std::string& name,
-                                                       TType& fieldType,
-                                                       int16_t& fieldId) {
-  (void) name;
-  uint32_t rsize = 0;
-  int8_t byte;
-  int8_t type;
-
-  rsize += readByte(byte);
-  type = (byte & 0x0f);
-
-  // if it's a stop, then we can return immediately, as the struct is over.
-  if (type == T_STOP) {
-    fieldType = T_STOP;
-    fieldId = 0;
-    return rsize;
-  }
-
-  // mask off the 4 MSB of the type header. it could contain a field id delta.
-  int16_t modifier = (int16_t)(((uint8_t)byte & 0xf0) >> 4);
-  if (modifier == 0) {
-    // not a delta, look ahead for the zigzag varint field id.
-    rsize += readI16(fieldId);
-  } else {
-    fieldId = (int16_t)(lastFieldId_ + modifier);
-  }
-  fieldType = getTType(type);
-
-  // if this happens to be a boolean field, the value is encoded in the type
-  if (type == detail::compact::CT_BOOLEAN_TRUE ||
-      type == detail::compact::CT_BOOLEAN_FALSE) {
-    // save the boolean value in a special instance variable.
-    boolValue_.hasBoolValue = true;
-    boolValue_.boolValue =
-      (type == detail::compact::CT_BOOLEAN_TRUE ? true : false);
-  }
-
-  // push the new field onto the field stack so we can keep the deltas going.
-  lastFieldId_ = fieldId;
-  return rsize;
-}
-
-/**
- * Read a map header off the wire. If the size is zero, skip reading the key
- * and value type. This means that 0-length maps will yield TMaps without the
- * "correct" types.
- */
-template <class Transport_>
-uint32_t TCompactProtocolT<Transport_>::readMapBegin(TType& keyType,
-                                                     TType& valType,
-                                                     uint32_t& size) {
-  uint32_t rsize = 0;
-  int8_t kvType = 0;
-  int32_t msize = 0;
-
-  rsize += readVarint32(msize);
-  if (msize != 0)
-    rsize += readByte(kvType);
-
-  if (msize < 0) {
-    throw TProtocolException(TProtocolException::NEGATIVE_SIZE);
-  } else if (container_limit_ && msize > container_limit_) {
-    throw TProtocolException(TProtocolException::SIZE_LIMIT);
-  }
-
-  keyType = getTType((int8_t)((uint8_t)kvType >> 4));
-  valType = getTType((int8_t)((uint8_t)kvType & 0xf));
-  size = (uint32_t)msize;
-
-  return rsize;
-}
-
-/**
- * Read a list header off the wire. If the list size is 0-14, the size will
- * be packed into the element type header. If it's a longer list, the 4 MSB
- * of the element type header will be 0xF, and a varint will follow with the
- * true size.
- */
-template <class Transport_>
-uint32_t TCompactProtocolT<Transport_>::readListBegin(TType& elemType,
-                                                      uint32_t& size) {
-  int8_t size_and_type;
-  uint32_t rsize = 0;
-  int32_t lsize;
-
-  rsize += readByte(size_and_type);
-
-  lsize = ((uint8_t)size_and_type >> 4) & 0x0f;
-  if (lsize == 15) {
-    rsize += readVarint32(lsize);
-  }
-
-  if (lsize < 0) {
-    throw TProtocolException(TProtocolException::NEGATIVE_SIZE);
-  } else if (container_limit_ && lsize > container_limit_) {
-    throw TProtocolException(TProtocolException::SIZE_LIMIT);
-  }
-
-  elemType = getTType((int8_t)(size_and_type & 0x0f));
-  size = (uint32_t)lsize;
-
-  return rsize;
-}
-
-/**
- * Read a set header off the wire. If the set size is 0-14, the size will
- * be packed into the element type header. If it's a longer set, the 4 MSB
- * of the element type header will be 0xF, and a varint will follow with the
- * true size.
- */
-template <class Transport_>
-uint32_t TCompactProtocolT<Transport_>::readSetBegin(TType& elemType,
-                                                     uint32_t& size) {
-  return readListBegin(elemType, size);
-}
-
-/**
- * Read a boolean off the wire. If this is a boolean field, the value should
- * already have been read during readFieldBegin, so we'll just consume the
- * pre-stored value. Otherwise, read a byte.
- */
-template <class Transport_>
-uint32_t TCompactProtocolT<Transport_>::readBool(bool& value) {
-  if (boolValue_.hasBoolValue == true) {
-    value = boolValue_.boolValue;
-    boolValue_.hasBoolValue = false;
-    return 0;
-  } else {
-    int8_t val;
-    readByte(val);
-    value = (val == detail::compact::CT_BOOLEAN_TRUE);
-    return 1;
-  }
-}
-
-/**
- * Read a single byte off the wire. Nothing interesting here.
- */
-template <class Transport_>
-uint32_t TCompactProtocolT<Transport_>::readByte(int8_t& byte) {
-  uint8_t b[1];
-  trans_->readAll(b, 1);
-  byte = *(int8_t*)b;
-  return 1;
-}
-
-/**
- * Read an i16 from the wire as a zigzag varint.
- */
-template <class Transport_>
-uint32_t TCompactProtocolT<Transport_>::readI16(int16_t& i16) {
-  int32_t value;
-  uint32_t rsize = readVarint32(value);
-  i16 = (int16_t)zigzagToI32(value);
-  return rsize;
-}
-
-/**
- * Read an i32 from the wire as a zigzag varint.
- */
-template <class Transport_>
-uint32_t TCompactProtocolT<Transport_>::readI32(int32_t& i32) {
-  int32_t value;
-  uint32_t rsize = readVarint32(value);
-  i32 = zigzagToI32(value);
-  return rsize;
-}
-
-/**
- * Read an i64 from the wire as a zigzag varint.
- */
-template <class Transport_>
-uint32_t TCompactProtocolT<Transport_>::readI64(int64_t& i64) {
-  int64_t value;
-  uint32_t rsize = readVarint64(value);
-  i64 = zigzagToI64(value);
-  return rsize;
-}
-
-/**
- * No magic here - just read a double off the wire.
- */
-template <class Transport_>
-uint32_t TCompactProtocolT<Transport_>::readDouble(double& dub) {
-  BOOST_STATIC_ASSERT(sizeof(double) == sizeof(uint64_t));
-  BOOST_STATIC_ASSERT(std::numeric_limits<double>::is_iec559);
-
-  union {
-    uint64_t bits;
-    uint8_t b[8];
-  } u;
-  trans_->readAll(u.b, 8);
-  u.bits = THRIFT_letohll(u.bits);
-  dub = bitwise_cast<double>(u.bits);
-  return 8;
-}
-
-template <class Transport_>
-uint32_t TCompactProtocolT<Transport_>::readString(std::string& str) {
-  return readBinary(str);
-}
-
-/**
- * Read a byte[] from the wire.
- */
-template <class Transport_>
-uint32_t TCompactProtocolT<Transport_>::readBinary(std::string& str) {
-  int32_t rsize = 0;
-  int32_t size;
-
-  rsize += readVarint32(size);
-  // Catch empty string case
-  if (size == 0) {
-    str = "";
-    return rsize;
-  }
-
-  // Catch error cases
-  if (size < 0) {
-    throw TProtocolException(TProtocolException::NEGATIVE_SIZE);
-  }
-  if (string_limit_ > 0 && size > string_limit_) {
-    throw TProtocolException(TProtocolException::SIZE_LIMIT);
-  }
-
-  // Use the heap here to prevent stack overflow for v. large strings
-  if (size > string_buf_size_ || string_buf_ == NULL) {
-    void* new_string_buf = std::realloc(string_buf_, (uint32_t)size);
-    if (new_string_buf == NULL) {
-      throw std::bad_alloc();
-    }
-    string_buf_ = (uint8_t*)new_string_buf;
-    string_buf_size_ = size;
-  }
-  trans_->readAll(string_buf_, size);
-  str.assign((char*)string_buf_, size);
-
-  return rsize + (uint32_t)size;
-}
-
-/**
- * Read an i32 from the wire as a varint. The MSB of each byte is set
- * if there is another byte to follow. This can read up to 5 bytes.
- */
-template <class Transport_>
-uint32_t TCompactProtocolT<Transport_>::readVarint32(int32_t& i32) {
-  int64_t val;
-  uint32_t rsize = readVarint64(val);
-  i32 = (int32_t)val;
-  return rsize;
-}
-
-/**
- * Read an i64 from the wire as a proper varint. The MSB of each byte is set
- * if there is another byte to follow. This can read up to 10 bytes.
- */
-template <class Transport_>
-uint32_t TCompactProtocolT<Transport_>::readVarint64(int64_t& i64) {
-  uint32_t rsize = 0;
-  uint64_t val = 0;
-  int shift = 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.
-  if (borrowed != NULL) {
-    while (true) {
-      uint8_t byte = borrowed[rsize];
-      rsize++;
-      val |= (uint64_t)(byte & 0x7f) << shift;
-      shift += 7;
-      if (!(byte & 0x80)) {
-        i64 = val;
-        trans_->consume(rsize);
-        return rsize;
-      }
-      // Have to check for invalid data so we don't crash.
-      if (UNLIKELY(rsize == sizeof(buf))) {
-        throw TProtocolException(TProtocolException::INVALID_DATA, "Variable-length int over
10 bytes.");
-      }
-    }
-  }
-
-  // Slow path.
-  else {
-    while (true) {
-      uint8_t byte;
-      rsize += trans_->readAll(&byte, 1);
-      val |= (uint64_t)(byte & 0x7f) << shift;
-      shift += 7;
-      if (!(byte & 0x80)) {
-        i64 = val;
-        return rsize;
-      }
-      // Might as well check for invalid data on the slow path too.
-      if (UNLIKELY(rsize >= sizeof(buf))) {
-        throw TProtocolException(TProtocolException::INVALID_DATA, "Variable-length int over
10 bytes.");
-      }
-    }
-  }
-}
-
-/**
- * Convert from zigzag int to int.
- */
-template <class Transport_>
-int32_t TCompactProtocolT<Transport_>::zigzagToI32(uint32_t n) {
-  return (n >> 1) ^ static_cast<uint32_t>(-static_cast<int32_t>(n &
1));
-}
-
-/**
- * Convert from zigzag long to long.
- */
-template <class Transport_>
-int64_t TCompactProtocolT<Transport_>::zigzagToI64(uint64_t n) {
-  return (n >> 1) ^ static_cast<uint64_t>(-static_cast<int64_t>(n &
1));
-}
-
-template <class Transport_>
-TType TCompactProtocolT<Transport_>::getTType(int8_t type) {
-  switch (type) {
-    case T_STOP:
-      return T_STOP;
-    case detail::compact::CT_BOOLEAN_FALSE:
-    case detail::compact::CT_BOOLEAN_TRUE:
-      return T_BOOL;
-    case detail::compact::CT_BYTE:
-      return T_BYTE;
-    case detail::compact::CT_I16:
-      return T_I16;
-    case detail::compact::CT_I32:
-      return T_I32;
-    case detail::compact::CT_I64:
-      return T_I64;
-    case detail::compact::CT_DOUBLE:
-      return T_DOUBLE;
-    case detail::compact::CT_BINARY:
-      return T_STRING;
-    case detail::compact::CT_LIST:
-      return T_LIST;
-    case detail::compact::CT_SET:
-      return T_SET;
-    case detail::compact::CT_MAP:
-      return T_MAP;
-    case detail::compact::CT_STRUCT:
-      return T_STRUCT;
-    default:
-      throw TException(std::string("don't know what type: ") + (char)type);
-  }
-}
-
-}}} // apache::thrift::protocol
-
-#endif // _THRIFT_PROTOCOL_TCOMPACTPROTOCOL_TCC_


Mime
View raw message