Thrift now a TLP - INFRA-3116
git-svn-id: https://svn.apache.org/repos/asf/thrift/branches/0.1.x@1028168 13f79535-47bb-0310-9956-ffa450edef68
diff --git a/lib/cpp/src/protocol/TProtocol.h b/lib/cpp/src/protocol/TProtocol.h
new file mode 100644
index 0000000..4025827
--- /dev/null
+++ b/lib/cpp/src/protocol/TProtocol.h
@@ -0,0 +1,438 @@
+/*
+ * 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