| /* |
| * 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> |
| #include <vector> |
| |
| |
| // 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_SYS_PARAM_H_ |
| #include <sys/param.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 |
| # include <boost/config.hpp> |
| # define __BYTE_ORDER BOOST_BYTE_ORDER |
| # define __LITTLE_ENDIAN BOOST_LITTLE_ENDIAN |
| # define __BIG_ENDIAN BOOST_BIG_ENDIAN |
| # 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 htolell(n) bswap_64(n) |
| # define letohll(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) ( (((uint64_t)ntohl(n)) << 32) + ntohl(n >> 32) ) |
| # define htonll(n) ( (((uint64_t)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 |
| }; |
| |
| |
| /** |
| * Helper template for implementing TProtocol::skip(). |
| * |
| * Templatized to avoid having to make virtual function calls. |
| */ |
| template <class Protocol_> |
| uint32_t skip(Protocol_& prot, TType type) { |
| switch (type) { |
| case T_BOOL: |
| { |
| bool boolv; |
| return prot.readBool(boolv); |
| } |
| case T_BYTE: |
| { |
| int8_t bytev; |
| return prot.readByte(bytev); |
| } |
| case T_I16: |
| { |
| int16_t i16; |
| return prot.readI16(i16); |
| } |
| case T_I32: |
| { |
| int32_t i32; |
| return prot.readI32(i32); |
| } |
| case T_I64: |
| { |
| int64_t i64; |
| return prot.readI64(i64); |
| } |
| case T_DOUBLE: |
| { |
| double dub; |
| return prot.readDouble(dub); |
| } |
| case T_STRING: |
| { |
| std::string str; |
| return prot.readBinary(str); |
| } |
| case T_STRUCT: |
| { |
| uint32_t result = 0; |
| std::string name; |
| int16_t fid; |
| TType ftype; |
| result += prot.readStructBegin(name); |
| while (true) { |
| result += prot.readFieldBegin(name, ftype, fid); |
| if (ftype == T_STOP) { |
| break; |
| } |
| result += skip(prot, ftype); |
| result += prot.readFieldEnd(); |
| } |
| result += prot.readStructEnd(); |
| return result; |
| } |
| case T_MAP: |
| { |
| uint32_t result = 0; |
| TType keyType; |
| TType valType; |
| uint32_t i, size; |
| result += prot.readMapBegin(keyType, valType, size); |
| for (i = 0; i < size; i++) { |
| result += skip(prot, keyType); |
| result += skip(prot, valType); |
| } |
| result += prot.readMapEnd(); |
| return result; |
| } |
| case T_SET: |
| { |
| uint32_t result = 0; |
| TType elemType; |
| uint32_t i, size; |
| result += prot.readSetBegin(elemType, size); |
| for (i = 0; i < size; i++) { |
| result += skip(prot, elemType); |
| } |
| result += prot.readSetEnd(); |
| return result; |
| } |
| case T_LIST: |
| { |
| uint32_t result = 0; |
| TType elemType; |
| uint32_t i, size; |
| result += prot.readListBegin(elemType, size); |
| for (i = 0; i < size; i++) { |
| result += skip(prot, elemType); |
| } |
| result += prot.readListEnd(); |
| return result; |
| } |
| default: |
| return 0; |
| } |
| } |
| |
| /** |
| * 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_virt(const std::string& name, |
| const TMessageType messageType, |
| const int32_t seqid) = 0; |
| |
| virtual uint32_t writeMessageEnd_virt() = 0; |
| |
| |
| virtual uint32_t writeStructBegin_virt(const char* name) = 0; |
| |
| virtual uint32_t writeStructEnd_virt() = 0; |
| |
| virtual uint32_t writeFieldBegin_virt(const char* name, |
| const TType fieldType, |
| const int16_t fieldId) = 0; |
| |
| virtual uint32_t writeFieldEnd_virt() = 0; |
| |
| virtual uint32_t writeFieldStop_virt() = 0; |
| |
| virtual uint32_t writeMapBegin_virt(const TType keyType, |
| const TType valType, |
| const uint32_t size) = 0; |
| |
| virtual uint32_t writeMapEnd_virt() = 0; |
| |
| virtual uint32_t writeListBegin_virt(const TType elemType, |
| const uint32_t size) = 0; |
| |
| virtual uint32_t writeListEnd_virt() = 0; |
| |
| virtual uint32_t writeSetBegin_virt(const TType elemType, |
| const uint32_t size) = 0; |
| |
| virtual uint32_t writeSetEnd_virt() = 0; |
| |
| virtual uint32_t writeBool_virt(const bool value) = 0; |
| |
| virtual uint32_t writeByte_virt(const int8_t byte) = 0; |
| |
| virtual uint32_t writeI16_virt(const int16_t i16) = 0; |
| |
| virtual uint32_t writeI32_virt(const int32_t i32) = 0; |
| |
| virtual uint32_t writeI64_virt(const int64_t i64) = 0; |
| |
| virtual uint32_t writeDouble_virt(const double dub) = 0; |
| |
| virtual uint32_t writeString_virt(const std::string& str) = 0; |
| |
| virtual uint32_t writeBinary_virt(const std::string& str) = 0; |
| |
| uint32_t writeMessageBegin(const std::string& name, |
| const TMessageType messageType, |
| const int32_t seqid) { |
| T_VIRTUAL_CALL(); |
| return writeMessageBegin_virt(name, messageType, seqid); |
| } |
| |
| uint32_t writeMessageEnd() { |
| T_VIRTUAL_CALL(); |
| return writeMessageEnd_virt(); |
| } |
| |
| |
| uint32_t writeStructBegin(const char* name) { |
| T_VIRTUAL_CALL(); |
| return writeStructBegin_virt(name); |
| } |
| |
| uint32_t writeStructEnd() { |
| T_VIRTUAL_CALL(); |
| return writeStructEnd_virt(); |
| } |
| |
| uint32_t writeFieldBegin(const char* name, |
| const TType fieldType, |
| const int16_t fieldId) { |
| T_VIRTUAL_CALL(); |
| return writeFieldBegin_virt(name, fieldType, fieldId); |
| } |
| |
| uint32_t writeFieldEnd() { |
| T_VIRTUAL_CALL(); |
| return writeFieldEnd_virt(); |
| } |
| |
| uint32_t writeFieldStop() { |
| T_VIRTUAL_CALL(); |
| return writeFieldStop_virt(); |
| } |
| |
| uint32_t writeMapBegin(const TType keyType, |
| const TType valType, |
| const uint32_t size) { |
| T_VIRTUAL_CALL(); |
| return writeMapBegin_virt(keyType, valType, size); |
| } |
| |
| uint32_t writeMapEnd() { |
| T_VIRTUAL_CALL(); |
| return writeMapEnd_virt(); |
| } |
| |
| uint32_t writeListBegin(const TType elemType, const uint32_t size) { |
| T_VIRTUAL_CALL(); |
| return writeListBegin_virt(elemType, size); |
| } |
| |
| uint32_t writeListEnd() { |
| T_VIRTUAL_CALL(); |
| return writeListEnd_virt(); |
| } |
| |
| uint32_t writeSetBegin(const TType elemType, const uint32_t size) { |
| T_VIRTUAL_CALL(); |
| return writeSetBegin_virt(elemType, size); |
| } |
| |
| uint32_t writeSetEnd() { |
| T_VIRTUAL_CALL(); |
| return writeSetEnd_virt(); |
| } |
| |
| uint32_t writeBool(const bool value) { |
| T_VIRTUAL_CALL(); |
| return writeBool_virt(value); |
| } |
| |
| uint32_t writeByte(const int8_t byte) { |
| T_VIRTUAL_CALL(); |
| return writeByte_virt(byte); |
| } |
| |
| uint32_t writeI16(const int16_t i16) { |
| T_VIRTUAL_CALL(); |
| return writeI16_virt(i16); |
| } |
| |
| uint32_t writeI32(const int32_t i32) { |
| T_VIRTUAL_CALL(); |
| return writeI32_virt(i32); |
| } |
| |
| uint32_t writeI64(const int64_t i64) { |
| T_VIRTUAL_CALL(); |
| return writeI64_virt(i64); |
| } |
| |
| uint32_t writeDouble(const double dub) { |
| T_VIRTUAL_CALL(); |
| return writeDouble_virt(dub); |
| } |
| |
| uint32_t writeString(const std::string& str) { |
| T_VIRTUAL_CALL(); |
| return writeString_virt(str); |
| } |
| |
| uint32_t writeBinary(const std::string& str) { |
| T_VIRTUAL_CALL(); |
| return writeBinary_virt(str); |
| } |
| |
| /** |
| * Reading functions |
| */ |
| |
| virtual uint32_t readMessageBegin_virt(std::string& name, |
| TMessageType& messageType, |
| int32_t& seqid) = 0; |
| |
| virtual uint32_t readMessageEnd_virt() = 0; |
| |
| virtual uint32_t readStructBegin_virt(std::string& name) = 0; |
| |
| virtual uint32_t readStructEnd_virt() = 0; |
| |
| virtual uint32_t readFieldBegin_virt(std::string& name, |
| TType& fieldType, |
| int16_t& fieldId) = 0; |
| |
| virtual uint32_t readFieldEnd_virt() = 0; |
| |
| virtual uint32_t readMapBegin_virt(TType& keyType, |
| TType& valType, |
| uint32_t& size) = 0; |
| |
| virtual uint32_t readMapEnd_virt() = 0; |
| |
| virtual uint32_t readListBegin_virt(TType& elemType, |
| uint32_t& size) = 0; |
| |
| virtual uint32_t readListEnd_virt() = 0; |
| |
| virtual uint32_t readSetBegin_virt(TType& elemType, |
| uint32_t& size) = 0; |
| |
| virtual uint32_t readSetEnd_virt() = 0; |
| |
| virtual uint32_t readBool_virt(bool& value) = 0; |
| |
| virtual uint32_t readBool_virt(std::vector<bool>::reference value) = 0; |
| |
| virtual uint32_t readByte_virt(int8_t& byte) = 0; |
| |
| virtual uint32_t readI16_virt(int16_t& i16) = 0; |
| |
| virtual uint32_t readI32_virt(int32_t& i32) = 0; |
| |
| virtual uint32_t readI64_virt(int64_t& i64) = 0; |
| |
| virtual uint32_t readDouble_virt(double& dub) = 0; |
| |
| virtual uint32_t readString_virt(std::string& str) = 0; |
| |
| virtual uint32_t readBinary_virt(std::string& str) = 0; |
| |
| uint32_t readMessageBegin(std::string& name, |
| TMessageType& messageType, |
| int32_t& seqid) { |
| T_VIRTUAL_CALL(); |
| return readMessageBegin_virt(name, messageType, seqid); |
| } |
| |
| uint32_t readMessageEnd() { |
| T_VIRTUAL_CALL(); |
| return readMessageEnd_virt(); |
| } |
| |
| uint32_t readStructBegin(std::string& name) { |
| T_VIRTUAL_CALL(); |
| return readStructBegin_virt(name); |
| } |
| |
| uint32_t readStructEnd() { |
| T_VIRTUAL_CALL(); |
| return readStructEnd_virt(); |
| } |
| |
| uint32_t readFieldBegin(std::string& name, |
| TType& fieldType, |
| int16_t& fieldId) { |
| T_VIRTUAL_CALL(); |
| return readFieldBegin_virt(name, fieldType, fieldId); |
| } |
| |
| uint32_t readFieldEnd() { |
| T_VIRTUAL_CALL(); |
| return readFieldEnd_virt(); |
| } |
| |
| uint32_t readMapBegin(TType& keyType, TType& valType, uint32_t& size) { |
| T_VIRTUAL_CALL(); |
| return readMapBegin_virt(keyType, valType, size); |
| } |
| |
| uint32_t readMapEnd() { |
| T_VIRTUAL_CALL(); |
| return readMapEnd_virt(); |
| } |
| |
| uint32_t readListBegin(TType& elemType, uint32_t& size) { |
| T_VIRTUAL_CALL(); |
| return readListBegin_virt(elemType, size); |
| } |
| |
| uint32_t readListEnd() { |
| T_VIRTUAL_CALL(); |
| return readListEnd_virt(); |
| } |
| |
| uint32_t readSetBegin(TType& elemType, uint32_t& size) { |
| T_VIRTUAL_CALL(); |
| return readSetBegin_virt(elemType, size); |
| } |
| |
| uint32_t readSetEnd() { |
| T_VIRTUAL_CALL(); |
| return readSetEnd_virt(); |
| } |
| |
| uint32_t readBool(bool& value) { |
| T_VIRTUAL_CALL(); |
| return readBool_virt(value); |
| } |
| |
| uint32_t readByte(int8_t& byte) { |
| T_VIRTUAL_CALL(); |
| return readByte_virt(byte); |
| } |
| |
| uint32_t readI16(int16_t& i16) { |
| T_VIRTUAL_CALL(); |
| return readI16_virt(i16); |
| } |
| |
| uint32_t readI32(int32_t& i32) { |
| T_VIRTUAL_CALL(); |
| return readI32_virt(i32); |
| } |
| |
| uint32_t readI64(int64_t& i64) { |
| T_VIRTUAL_CALL(); |
| return readI64_virt(i64); |
| } |
| |
| uint32_t readDouble(double& dub) { |
| T_VIRTUAL_CALL(); |
| return readDouble_virt(dub); |
| } |
| |
| uint32_t readString(std::string& str) { |
| T_VIRTUAL_CALL(); |
| return readString_virt(str); |
| } |
| |
| uint32_t readBinary(std::string& str) { |
| T_VIRTUAL_CALL(); |
| return readBinary_virt(str); |
| } |
| |
| /* |
| * std::vector is specialized for bool, and its elements are individual bits |
| * rather than bools. We need to define a different version of readBool() |
| * to work with std::vector<bool>. |
| */ |
| uint32_t readBool(std::vector<bool>::reference value) { |
| T_VIRTUAL_CALL(); |
| return readBool_virt(value); |
| } |
| |
| /** |
| * Method to arbitrarily skip over data. |
| */ |
| uint32_t skip(TType type) { |
| T_VIRTUAL_CALL(); |
| return skip_virt(type); |
| } |
| virtual uint32_t skip_virt(TType type) { |
| return ::apache::thrift::protocol::skip(*this, type); |
| } |
| |
| 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) { |
| } |
| |
| boost::shared_ptr<TTransport> ptrans_; |
| |
| 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; |
| }; |
| |
| /** |
| * Dummy protocol class. |
| * |
| * This class does nothing, and should never be instantiated. |
| * It is used only by the generator code. |
| */ |
| class TDummyProtocol : public TProtocol { |
| }; |
| |
| }}} // apache::thrift::protocol |
| |
| #endif // #define _THRIFT_PROTOCOL_TPROTOCOL_H_ 1 |