| /* |
| * 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_TPROTOCOL_H_ |
| #define _THRIFT_PROTOCOL_TPROTOCOL_H_ 1 |
| |
| #include <transport/TTransport.h> |
| #include <protocol/TProtocolException.h> |
| |
| #include <boost/shared_ptr.hpp> |
| #include <boost/static_assert.hpp> |
| |
| #include <netinet/in.h> |
| #include <sys/types.h> |
| #include <string> |
| #include <map> |
| |
| |
| // Use this to get around strict aliasing rules. |
| // For example, uint64_t i = bitwise_cast<uint64_t>(returns_double()); |
| // The most obvious implementation is to just cast a pointer, |
| // but that doesn't work. |
| // For a pretty in-depth explanation of the problem, see |
| // http://www.cellperformance.com/mike_acton/2006/06/ (...) |
| // understanding_strict_aliasing.html |
| template <typename To, typename From> |
| static inline To bitwise_cast(From from) { |
| BOOST_STATIC_ASSERT(sizeof(From) == sizeof(To)); |
| |
| // BAD!!! These are all broken with -O2. |
| //return *reinterpret_cast<To*>(&from); // BAD!!! |
| //return *static_cast<To*>(static_cast<void*>(&from)); // BAD!!! |
| //return *(To*)(void*)&from; // BAD!!! |
| |
| // Super clean and paritally blessed by section 3.9 of the standard. |
| //unsigned char c[sizeof(from)]; |
| //memcpy(c, &from, sizeof(from)); |
| //To to; |
| //memcpy(&to, c, sizeof(c)); |
| //return to; |
| |
| // Slightly more questionable. |
| // Same code emitted by GCC. |
| //To to; |
| //memcpy(&to, &from, sizeof(from)); |
| //return to; |
| |
| // Technically undefined, but almost universally supported, |
| // and the most efficient implementation. |
| union { |
| From f; |
| To t; |
| } u; |
| u.f = from; |
| return u.t; |
| } |
| |
| |
| namespace apache { namespace thrift { namespace protocol { |
| |
| using apache::thrift::transport::TTransport; |
| |
| #ifdef HAVE_ENDIAN_H |
| #include <endian.h> |
| #endif |
| |
| #ifndef __BYTE_ORDER |
| # if defined(BYTE_ORDER) && defined(LITTLE_ENDIAN) && defined(BIG_ENDIAN) |
| # define __BYTE_ORDER BYTE_ORDER |
| # define __LITTLE_ENDIAN LITTLE_ENDIAN |
| # define __BIG_ENDIAN BIG_ENDIAN |
| # else |
| # error "Cannot determine endianness" |
| # endif |
| #endif |
| |
| #if __BYTE_ORDER == __BIG_ENDIAN |
| # define ntohll(n) (n) |
| # define htonll(n) (n) |
| # if defined(__GNUC__) && defined(__GLIBC__) |
| # include <byteswap.h> |
| # define htolell(n) bswap_64(n) |
| # define letohll(n) bswap_64(n) |
| # else /* GNUC & GLIBC */ |
| # define bswap_64(n) \ |
| ( (((n) & 0xff00000000000000ull) >> 56) \ |
| | (((n) & 0x00ff000000000000ull) >> 40) \ |
| | (((n) & 0x0000ff0000000000ull) >> 24) \ |
| | (((n) & 0x000000ff00000000ull) >> 8) \ |
| | (((n) & 0x00000000ff000000ull) << 8) \ |
| | (((n) & 0x0000000000ff0000ull) << 24) \ |
| | (((n) & 0x000000000000ff00ull) << 40) \ |
| | (((n) & 0x00000000000000ffull) << 56) ) |
| # define ntolell(n) bswap_64(n) |
| # define letonll(n) bswap_64(n) |
| # endif /* GNUC & GLIBC */ |
| #elif __BYTE_ORDER == __LITTLE_ENDIAN |
| # define htolell(n) (n) |
| # define letohll(n) (n) |
| # if defined(__GNUC__) && defined(__GLIBC__) |
| # include <byteswap.h> |
| # define ntohll(n) bswap_64(n) |
| # define htonll(n) bswap_64(n) |
| # else /* GNUC & GLIBC */ |
| # define ntohll(n) ( (((unsigned long long)ntohl(n)) << 32) + ntohl(n >> 32) ) |
| # define htonll(n) ( (((unsigned long long)htonl(n)) << 32) + htonl(n >> 32) ) |
| # endif /* GNUC & GLIBC */ |
| #else /* __BYTE_ORDER */ |
| # error "Can't define htonll or ntohll!" |
| #endif |
| |
| /** |
| * Enumerated definition of the types that the Thrift protocol supports. |
| * Take special note of the T_END type which is used specifically to mark |
| * the end of a sequence of fields. |
| */ |
| enum TType { |
| T_STOP = 0, |
| T_VOID = 1, |
| T_BOOL = 2, |
| T_BYTE = 3, |
| T_I08 = 3, |
| T_I16 = 6, |
| T_I32 = 8, |
| T_U64 = 9, |
| T_I64 = 10, |
| T_DOUBLE = 4, |
| T_STRING = 11, |
| T_UTF7 = 11, |
| T_STRUCT = 12, |
| T_MAP = 13, |
| T_SET = 14, |
| T_LIST = 15, |
| T_UTF8 = 16, |
| T_UTF16 = 17 |
| }; |
| |
| /** |
| * Enumerated definition of the message types that the Thrift protocol |
| * supports. |
| */ |
| enum TMessageType { |
| T_CALL = 1, |
| T_REPLY = 2, |
| T_EXCEPTION = 3, |
| T_ONEWAY = 4 |
| }; |
| |
| /** |
| * Abstract class for a thrift protocol driver. These are all the methods that |
| * a protocol must implement. Essentially, there must be some way of reading |
| * and writing all the base types, plus a mechanism for writing out structs |
| * with indexed fields. |
| * |
| * TProtocol objects should not be shared across multiple encoding contexts, |
| * as they may need to maintain internal state in some protocols (i.e. XML). |
| * Note that is is acceptable for the TProtocol module to do its own internal |
| * buffered reads/writes to the underlying TTransport where appropriate (i.e. |
| * when parsing an input XML stream, reading should be batched rather than |
| * looking ahead character by character for a close tag). |
| * |
| */ |
| class TProtocol { |
| public: |
| virtual ~TProtocol() {} |
| |
| /** |
| * Writing functions. |
| */ |
| |
| virtual uint32_t writeMessageBegin(const std::string& name, |
| const TMessageType messageType, |
| const int32_t seqid) = 0; |
| |
| virtual uint32_t writeMessageEnd() = 0; |
| |
| |
| virtual uint32_t writeStructBegin(const char* name) = 0; |
| |
| virtual uint32_t writeStructEnd() = 0; |
| |
| virtual uint32_t writeFieldBegin(const char* name, |
| const TType fieldType, |
| const int16_t fieldId) = 0; |
| |
| virtual uint32_t writeFieldEnd() = 0; |
| |
| virtual uint32_t writeFieldStop() = 0; |
| |
| virtual uint32_t writeMapBegin(const TType keyType, |
| const TType valType, |
| const uint32_t size) = 0; |
| |
| virtual uint32_t writeMapEnd() = 0; |
| |
| virtual uint32_t writeListBegin(const TType elemType, |
| const uint32_t size) = 0; |
| |
| virtual uint32_t writeListEnd() = 0; |
| |
| virtual uint32_t writeSetBegin(const TType elemType, |
| const uint32_t size) = 0; |
| |
| virtual uint32_t writeSetEnd() = 0; |
| |
| virtual uint32_t writeBool(const bool value) = 0; |
| |
| virtual uint32_t writeByte(const int8_t byte) = 0; |
| |
| virtual uint32_t writeI16(const int16_t i16) = 0; |
| |
| virtual uint32_t writeI32(const int32_t i32) = 0; |
| |
| virtual uint32_t writeI64(const int64_t i64) = 0; |
| |
| virtual uint32_t writeDouble(const double dub) = 0; |
| |
| virtual uint32_t writeString(const std::string& str) = 0; |
| |
| virtual uint32_t writeBinary(const std::string& str) = 0; |
| |
| /** |
| * Reading functions |
| */ |
| |
| virtual uint32_t readMessageBegin(std::string& name, |
| TMessageType& messageType, |
| int32_t& seqid) = 0; |
| |
| virtual uint32_t readMessageEnd() = 0; |
| |
| virtual uint32_t readStructBegin(std::string& name) = 0; |
| |
| virtual uint32_t readStructEnd() = 0; |
| |
| virtual uint32_t readFieldBegin(std::string& name, |
| TType& fieldType, |
| int16_t& fieldId) = 0; |
| |
| virtual uint32_t readFieldEnd() = 0; |
| |
| virtual uint32_t readMapBegin(TType& keyType, |
| TType& valType, |
| uint32_t& size) = 0; |
| |
| virtual uint32_t readMapEnd() = 0; |
| |
| virtual uint32_t readListBegin(TType& elemType, |
| uint32_t& size) = 0; |
| |
| virtual uint32_t readListEnd() = 0; |
| |
| virtual uint32_t readSetBegin(TType& elemType, |
| uint32_t& size) = 0; |
| |
| virtual uint32_t readSetEnd() = 0; |
| |
| virtual uint32_t readBool(bool& value) = 0; |
| |
| virtual uint32_t readByte(int8_t& byte) = 0; |
| |
| virtual uint32_t readI16(int16_t& i16) = 0; |
| |
| virtual uint32_t readI32(int32_t& i32) = 0; |
| |
| virtual uint32_t readI64(int64_t& i64) = 0; |
| |
| virtual uint32_t readDouble(double& dub) = 0; |
| |
| virtual uint32_t readString(std::string& str) = 0; |
| |
| virtual uint32_t readBinary(std::string& str) = 0; |
| |
| uint32_t readBool(std::vector<bool>::reference ref) { |
| bool value; |
| uint32_t rv = readBool(value); |
| ref = value; |
| return rv; |
| } |
| |
| /** |
| * Method to arbitrarily skip over data. |
| */ |
| uint32_t skip(TType type) { |
| switch (type) { |
| case T_BOOL: |
| { |
| bool boolv; |
| return readBool(boolv); |
| } |
| case T_BYTE: |
| { |
| int8_t bytev; |
| return readByte(bytev); |
| } |
| case T_I16: |
| { |
| int16_t i16; |
| return readI16(i16); |
| } |
| case T_I32: |
| { |
| int32_t i32; |
| return readI32(i32); |
| } |
| case T_I64: |
| { |
| int64_t i64; |
| return readI64(i64); |
| } |
| case T_DOUBLE: |
| { |
| double dub; |
| return readDouble(dub); |
| } |
| case T_STRING: |
| { |
| std::string str; |
| return readBinary(str); |
| } |
| case T_STRUCT: |
| { |
| uint32_t result = 0; |
| std::string name; |
| int16_t fid; |
| TType ftype; |
| result += readStructBegin(name); |
| while (true) { |
| result += readFieldBegin(name, ftype, fid); |
| if (ftype == T_STOP) { |
| break; |
| } |
| result += skip(ftype); |
| result += readFieldEnd(); |
| } |
| result += readStructEnd(); |
| return result; |
| } |
| case T_MAP: |
| { |
| uint32_t result = 0; |
| TType keyType; |
| TType valType; |
| uint32_t i, size; |
| result += readMapBegin(keyType, valType, size); |
| for (i = 0; i < size; i++) { |
| result += skip(keyType); |
| result += skip(valType); |
| } |
| result += readMapEnd(); |
| return result; |
| } |
| case T_SET: |
| { |
| uint32_t result = 0; |
| TType elemType; |
| uint32_t i, size; |
| result += readSetBegin(elemType, size); |
| for (i = 0; i < size; i++) { |
| result += skip(elemType); |
| } |
| result += readSetEnd(); |
| return result; |
| } |
| case T_LIST: |
| { |
| uint32_t result = 0; |
| TType elemType; |
| uint32_t i, size; |
| result += readListBegin(elemType, size); |
| for (i = 0; i < size; i++) { |
| result += skip(elemType); |
| } |
| result += readListEnd(); |
| return result; |
| } |
| default: |
| return 0; |
| } |
| } |
| |
| inline boost::shared_ptr<TTransport> getTransport() { |
| return ptrans_; |
| } |
| |
| // TODO: remove these two calls, they are for backwards |
| // compatibility |
| inline boost::shared_ptr<TTransport> getInputTransport() { |
| return ptrans_; |
| } |
| inline boost::shared_ptr<TTransport> getOutputTransport() { |
| return ptrans_; |
| } |
| |
| protected: |
| TProtocol(boost::shared_ptr<TTransport> ptrans): |
| ptrans_(ptrans) { |
| trans_ = ptrans.get(); |
| } |
| |
| boost::shared_ptr<TTransport> ptrans_; |
| TTransport* trans_; |
| |
| private: |
| TProtocol() {} |
| }; |
| |
| /** |
| * Constructs input and output protocol objects given transports. |
| */ |
| class TProtocolFactory { |
| public: |
| TProtocolFactory() {} |
| |
| virtual ~TProtocolFactory() {} |
| |
| virtual boost::shared_ptr<TProtocol> getProtocol(boost::shared_ptr<TTransport> trans) = 0; |
| }; |
| |
| }}} // apache::thrift::protocol |
| |
| #endif // #define _THRIFT_PROTOCOL_TPROTOCOL_H_ 1 |