FAQ
http://git-wip-us.apache.org/repos/asf/hive/blob/3a1c4b57/service-rpc/src/gen/thrift/gen-cpp/TCLIService_types.cpp
----------------------------------------------------------------------
diff --git a/service-rpc/src/gen/thrift/gen-cpp/TCLIService_types.cpp b/service-rpc/src/gen/thrift/gen-cpp/TCLIService_types.cpp
new file mode 100644
index 0000000..e62e8b7
--- /dev/null
+++ b/service-rpc/src/gen/thrift/gen-cpp/TCLIService_types.cpp
@@ -0,0 +1,9231 @@
+/**
+ * Autogenerated by Thrift Compiler (0.9.3)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ * @generated
+ */
+#include "TCLIService_types.h"
+
+#include <algorithm>
+#include <ostream>
+
+#include <thrift/TToString.h>
+
+namespace apache { namespace hive { namespace service { namespace rpc { namespace thrift {
+
+int _kTProtocolVersionValues[] = {
+ TProtocolVersion::HIVE_CLI_SERVICE_PROTOCOL_V1,
+ TProtocolVersion::HIVE_CLI_SERVICE_PROTOCOL_V2,
+ TProtocolVersion::HIVE_CLI_SERVICE_PROTOCOL_V3,
+ TProtocolVersion::HIVE_CLI_SERVICE_PROTOCOL_V4,
+ TProtocolVersion::HIVE_CLI_SERVICE_PROTOCOL_V5,
+ TProtocolVersion::HIVE_CLI_SERVICE_PROTOCOL_V6,
+ TProtocolVersion::HIVE_CLI_SERVICE_PROTOCOL_V7,
+ TProtocolVersion::HIVE_CLI_SERVICE_PROTOCOL_V8
+};
+const char* _kTProtocolVersionNames[] = {
+ "HIVE_CLI_SERVICE_PROTOCOL_V1",
+ "HIVE_CLI_SERVICE_PROTOCOL_V2",
+ "HIVE_CLI_SERVICE_PROTOCOL_V3",
+ "HIVE_CLI_SERVICE_PROTOCOL_V4",
+ "HIVE_CLI_SERVICE_PROTOCOL_V5",
+ "HIVE_CLI_SERVICE_PROTOCOL_V6",
+ "HIVE_CLI_SERVICE_PROTOCOL_V7",
+ "HIVE_CLI_SERVICE_PROTOCOL_V8"
+};
+const std::map<int, const char*> _TProtocolVersion_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(8, _kTProtocolVersionValues, _kTProtocolVersionNames), ::apache::thrift::TEnumIterator(-1, NULL, NULL));
+
+int _kTTypeIdValues[] = {
+ TTypeId::BOOLEAN_TYPE,
+ TTypeId::TINYINT_TYPE,
+ TTypeId::SMALLINT_TYPE,
+ TTypeId::INT_TYPE,
+ TTypeId::BIGINT_TYPE,
+ TTypeId::FLOAT_TYPE,
+ TTypeId::DOUBLE_TYPE,
+ TTypeId::STRING_TYPE,
+ TTypeId::TIMESTAMP_TYPE,
+ TTypeId::BINARY_TYPE,
+ TTypeId::ARRAY_TYPE,
+ TTypeId::MAP_TYPE,
+ TTypeId::STRUCT_TYPE,
+ TTypeId::UNION_TYPE,
+ TTypeId::USER_DEFINED_TYPE,
+ TTypeId::DECIMAL_TYPE,
+ TTypeId::NULL_TYPE,
+ TTypeId::DATE_TYPE,
+ TTypeId::VARCHAR_TYPE,
+ TTypeId::CHAR_TYPE,
+ TTypeId::INTERVAL_YEAR_MONTH_TYPE,
+ TTypeId::INTERVAL_DAY_TIME_TYPE
+};
+const char* _kTTypeIdNames[] = {
+ "BOOLEAN_TYPE",
+ "TINYINT_TYPE",
+ "SMALLINT_TYPE",
+ "INT_TYPE",
+ "BIGINT_TYPE",
+ "FLOAT_TYPE",
+ "DOUBLE_TYPE",
+ "STRING_TYPE",
+ "TIMESTAMP_TYPE",
+ "BINARY_TYPE",
+ "ARRAY_TYPE",
+ "MAP_TYPE",
+ "STRUCT_TYPE",
+ "UNION_TYPE",
+ "USER_DEFINED_TYPE",
+ "DECIMAL_TYPE",
+ "NULL_TYPE",
+ "DATE_TYPE",
+ "VARCHAR_TYPE",
+ "CHAR_TYPE",
+ "INTERVAL_YEAR_MONTH_TYPE",
+ "INTERVAL_DAY_TIME_TYPE"
+};
+const std::map<int, const char*> _TTypeId_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(22, _kTTypeIdValues, _kTTypeIdNames), ::apache::thrift::TEnumIterator(-1, NULL, NULL));
+
+int _kTStatusCodeValues[] = {
+ TStatusCode::SUCCESS_STATUS,
+ TStatusCode::SUCCESS_WITH_INFO_STATUS,
+ TStatusCode::STILL_EXECUTING_STATUS,
+ TStatusCode::ERROR_STATUS,
+ TStatusCode::INVALID_HANDLE_STATUS
+};
+const char* _kTStatusCodeNames[] = {
+ "SUCCESS_STATUS",
+ "SUCCESS_WITH_INFO_STATUS",
+ "STILL_EXECUTING_STATUS",
+ "ERROR_STATUS",
+ "INVALID_HANDLE_STATUS"
+};
+const std::map<int, const char*> _TStatusCode_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(5, _kTStatusCodeValues, _kTStatusCodeNames), ::apache::thrift::TEnumIterator(-1, NULL, NULL));
+
+int _kTOperationStateValues[] = {
+ TOperationState::INITIALIZED_STATE,
+ TOperationState::RUNNING_STATE,
+ TOperationState::FINISHED_STATE,
+ TOperationState::CANCELED_STATE,
+ TOperationState::CLOSED_STATE,
+ TOperationState::ERROR_STATE,
+ TOperationState::UKNOWN_STATE,
+ TOperationState::PENDING_STATE
+};
+const char* _kTOperationStateNames[] = {
+ "INITIALIZED_STATE",
+ "RUNNING_STATE",
+ "FINISHED_STATE",
+ "CANCELED_STATE",
+ "CLOSED_STATE",
+ "ERROR_STATE",
+ "UKNOWN_STATE",
+ "PENDING_STATE"
+};
+const std::map<int, const char*> _TOperationState_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(8, _kTOperationStateValues, _kTOperationStateNames), ::apache::thrift::TEnumIterator(-1, NULL, NULL));
+
+int _kTOperationTypeValues[] = {
+ TOperationType::EXECUTE_STATEMENT,
+ TOperationType::GET_TYPE_INFO,
+ TOperationType::GET_CATALOGS,
+ TOperationType::GET_SCHEMAS,
+ TOperationType::GET_TABLES,
+ TOperationType::GET_TABLE_TYPES,
+ TOperationType::GET_COLUMNS,
+ TOperationType::GET_FUNCTIONS,
+ TOperationType::UNKNOWN
+};
+const char* _kTOperationTypeNames[] = {
+ "EXECUTE_STATEMENT",
+ "GET_TYPE_INFO",
+ "GET_CATALOGS",
+ "GET_SCHEMAS",
+ "GET_TABLES",
+ "GET_TABLE_TYPES",
+ "GET_COLUMNS",
+ "GET_FUNCTIONS",
+ "UNKNOWN"
+};
+const std::map<int, const char*> _TOperationType_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(9, _kTOperationTypeValues, _kTOperationTypeNames), ::apache::thrift::TEnumIterator(-1, NULL, NULL));
+
+int _kTGetInfoTypeValues[] = {
+ TGetInfoType::CLI_MAX_DRIVER_CONNECTIONS,
+ TGetInfoType::CLI_MAX_CONCURRENT_ACTIVITIES,
+ TGetInfoType::CLI_DATA_SOURCE_NAME,
+ TGetInfoType::CLI_FETCH_DIRECTION,
+ TGetInfoType::CLI_SERVER_NAME,
+ TGetInfoType::CLI_SEARCH_PATTERN_ESCAPE,
+ TGetInfoType::CLI_DBMS_NAME,
+ TGetInfoType::CLI_DBMS_VER,
+ TGetInfoType::CLI_ACCESSIBLE_TABLES,
+ TGetInfoType::CLI_ACCESSIBLE_PROCEDURES,
+ TGetInfoType::CLI_CURSOR_COMMIT_BEHAVIOR,
+ TGetInfoType::CLI_DATA_SOURCE_READ_ONLY,
+ TGetInfoType::CLI_DEFAULT_TXN_ISOLATION,
+ TGetInfoType::CLI_IDENTIFIER_CASE,
+ TGetInfoType::CLI_IDENTIFIER_QUOTE_CHAR,
+ TGetInfoType::CLI_MAX_COLUMN_NAME_LEN,
+ TGetInfoType::CLI_MAX_CURSOR_NAME_LEN,
+ TGetInfoType::CLI_MAX_SCHEMA_NAME_LEN,
+ TGetInfoType::CLI_MAX_CATALOG_NAME_LEN,
+ TGetInfoType::CLI_MAX_TABLE_NAME_LEN,
+ TGetInfoType::CLI_SCROLL_CONCURRENCY,
+ TGetInfoType::CLI_TXN_CAPABLE,
+ TGetInfoType::CLI_USER_NAME,
+ TGetInfoType::CLI_TXN_ISOLATION_OPTION,
+ TGetInfoType::CLI_INTEGRITY,
+ TGetInfoType::CLI_GETDATA_EXTENSIONS,
+ TGetInfoType::CLI_NULL_COLLATION,
+ TGetInfoType::CLI_ALTER_TABLE,
+ TGetInfoType::CLI_ORDER_BY_COLUMNS_IN_SELECT,
+ TGetInfoType::CLI_SPECIAL_CHARACTERS,
+ TGetInfoType::CLI_MAX_COLUMNS_IN_GROUP_BY,
+ TGetInfoType::CLI_MAX_COLUMNS_IN_INDEX,
+ TGetInfoType::CLI_MAX_COLUMNS_IN_ORDER_BY,
+ TGetInfoType::CLI_MAX_COLUMNS_IN_SELECT,
+ TGetInfoType::CLI_MAX_COLUMNS_IN_TABLE,
+ TGetInfoType::CLI_MAX_INDEX_SIZE,
+ TGetInfoType::CLI_MAX_ROW_SIZE,
+ TGetInfoType::CLI_MAX_STATEMENT_LEN,
+ TGetInfoType::CLI_MAX_TABLES_IN_SELECT,
+ TGetInfoType::CLI_MAX_USER_NAME_LEN,
+ TGetInfoType::CLI_OJ_CAPABILITIES,
+ TGetInfoType::CLI_XOPEN_CLI_YEAR,
+ TGetInfoType::CLI_CURSOR_SENSITIVITY,
+ TGetInfoType::CLI_DESCRIBE_PARAMETER,
+ TGetInfoType::CLI_CATALOG_NAME,
+ TGetInfoType::CLI_COLLATION_SEQ,
+ TGetInfoType::CLI_MAX_IDENTIFIER_LEN
+};
+const char* _kTGetInfoTypeNames[] = {
+ "CLI_MAX_DRIVER_CONNECTIONS",
+ "CLI_MAX_CONCURRENT_ACTIVITIES",
+ "CLI_DATA_SOURCE_NAME",
+ "CLI_FETCH_DIRECTION",
+ "CLI_SERVER_NAME",
+ "CLI_SEARCH_PATTERN_ESCAPE",
+ "CLI_DBMS_NAME",
+ "CLI_DBMS_VER",
+ "CLI_ACCESSIBLE_TABLES",
+ "CLI_ACCESSIBLE_PROCEDURES",
+ "CLI_CURSOR_COMMIT_BEHAVIOR",
+ "CLI_DATA_SOURCE_READ_ONLY",
+ "CLI_DEFAULT_TXN_ISOLATION",
+ "CLI_IDENTIFIER_CASE",
+ "CLI_IDENTIFIER_QUOTE_CHAR",
+ "CLI_MAX_COLUMN_NAME_LEN",
+ "CLI_MAX_CURSOR_NAME_LEN",
+ "CLI_MAX_SCHEMA_NAME_LEN",
+ "CLI_MAX_CATALOG_NAME_LEN",
+ "CLI_MAX_TABLE_NAME_LEN",
+ "CLI_SCROLL_CONCURRENCY",
+ "CLI_TXN_CAPABLE",
+ "CLI_USER_NAME",
+ "CLI_TXN_ISOLATION_OPTION",
+ "CLI_INTEGRITY",
+ "CLI_GETDATA_EXTENSIONS",
+ "CLI_NULL_COLLATION",
+ "CLI_ALTER_TABLE",
+ "CLI_ORDER_BY_COLUMNS_IN_SELECT",
+ "CLI_SPECIAL_CHARACTERS",
+ "CLI_MAX_COLUMNS_IN_GROUP_BY",
+ "CLI_MAX_COLUMNS_IN_INDEX",
+ "CLI_MAX_COLUMNS_IN_ORDER_BY",
+ "CLI_MAX_COLUMNS_IN_SELECT",
+ "CLI_MAX_COLUMNS_IN_TABLE",
+ "CLI_MAX_INDEX_SIZE",
+ "CLI_MAX_ROW_SIZE",
+ "CLI_MAX_STATEMENT_LEN",
+ "CLI_MAX_TABLES_IN_SELECT",
+ "CLI_MAX_USER_NAME_LEN",
+ "CLI_OJ_CAPABILITIES",
+ "CLI_XOPEN_CLI_YEAR",
+ "CLI_CURSOR_SENSITIVITY",
+ "CLI_DESCRIBE_PARAMETER",
+ "CLI_CATALOG_NAME",
+ "CLI_COLLATION_SEQ",
+ "CLI_MAX_IDENTIFIER_LEN"
+};
+const std::map<int, const char*> _TGetInfoType_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(47, _kTGetInfoTypeValues, _kTGetInfoTypeNames), ::apache::thrift::TEnumIterator(-1, NULL, NULL));
+
+int _kTFetchOrientationValues[] = {
+ TFetchOrientation::FETCH_NEXT,
+ TFetchOrientation::FETCH_PRIOR,
+ TFetchOrientation::FETCH_RELATIVE,
+ TFetchOrientation::FETCH_ABSOLUTE,
+ TFetchOrientation::FETCH_FIRST,
+ TFetchOrientation::FETCH_LAST
+};
+const char* _kTFetchOrientationNames[] = {
+ "FETCH_NEXT",
+ "FETCH_PRIOR",
+ "FETCH_RELATIVE",
+ "FETCH_ABSOLUTE",
+ "FETCH_FIRST",
+ "FETCH_LAST"
+};
+const std::map<int, const char*> _TFetchOrientation_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(6, _kTFetchOrientationValues, _kTFetchOrientationNames), ::apache::thrift::TEnumIterator(-1, NULL, NULL));
+
+
+TTypeQualifierValue::~TTypeQualifierValue() throw() {
+}
+
+
+void TTypeQualifierValue::__set_i32Value(const int32_t val) {
+ this->i32Value = val;
+__isset.i32Value = true;
+}
+
+void TTypeQualifierValue::__set_stringValue(const std::string& val) {
+ this->stringValue = val;
+__isset.stringValue = true;
+}
+
+uint32_t TTypeQualifierValue::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case 1:
+ if (ftype == ::apache::thrift::protocol::T_I32) {
+ xfer += iprot->readI32(this->i32Value);
+ this->__isset.i32Value = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->stringValue);
+ this->__isset.stringValue = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t TTypeQualifierValue::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+ xfer += oprot->writeStructBegin("TTypeQualifierValue");
+
+ if (this->__isset.i32Value) {
+ xfer += oprot->writeFieldBegin("i32Value", ::apache::thrift::protocol::T_I32, 1);
+ xfer += oprot->writeI32(this->i32Value);
+ xfer += oprot->writeFieldEnd();
+ }
+ if (this->__isset.stringValue) {
+ xfer += oprot->writeFieldBegin("stringValue", ::apache::thrift::protocol::T_STRING, 2);
+ xfer += oprot->writeString(this->stringValue);
+ xfer += oprot->writeFieldEnd();
+ }
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+void swap(TTypeQualifierValue &a, TTypeQualifierValue &b) {
+ using ::std::swap;
+ swap(a.i32Value, b.i32Value);
+ swap(a.stringValue, b.stringValue);
+ swap(a.__isset, b.__isset);
+}
+
+TTypeQualifierValue::TTypeQualifierValue(const TTypeQualifierValue& other0) {
+ i32Value = other0.i32Value;
+ stringValue = other0.stringValue;
+ __isset = other0.__isset;
+}
+TTypeQualifierValue& TTypeQualifierValue::operator=(const TTypeQualifierValue& other1) {
+ i32Value = other1.i32Value;
+ stringValue = other1.stringValue;
+ __isset = other1.__isset;
+ return *this;
+}
+void TTypeQualifierValue::printTo(std::ostream& out) const {
+ using ::apache::thrift::to_string;
+ out << "TTypeQualifierValue(";
+ out << "i32Value="; (__isset.i32Value ? (out << to_string(i32Value)) : (out << "<null>"));
+ out << ", " << "stringValue="; (__isset.stringValue ? (out << to_string(stringValue)) : (out << "<null>"));
+ out << ")";
+}
+
+
+TTypeQualifiers::~TTypeQualifiers() throw() {
+}
+
+
+void TTypeQualifiers::__set_qualifiers(const std::map<std::string, TTypeQualifierValue> & val) {
+ this->qualifiers = val;
+}
+
+uint32_t TTypeQualifiers::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+ bool isset_qualifiers = false;
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case 1:
+ if (ftype == ::apache::thrift::protocol::T_MAP) {
+ {
+ this->qualifiers.clear();
+ uint32_t _size2;
+ ::apache::thrift::protocol::TType _ktype3;
+ ::apache::thrift::protocol::TType _vtype4;
+ xfer += iprot->readMapBegin(_ktype3, _vtype4, _size2);
+ uint32_t _i6;
+ for (_i6 = 0; _i6 < _size2; ++_i6)
+ {
+ std::string _key7;
+ xfer += iprot->readString(_key7);
+ TTypeQualifierValue& _val8 = this->qualifiers[_key7];
+ xfer += _val8.read(iprot);
+ }
+ xfer += iprot->readMapEnd();
+ }
+ isset_qualifiers = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ if (!isset_qualifiers)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ return xfer;
+}
+
+uint32_t TTypeQualifiers::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+ xfer += oprot->writeStructBegin("TTypeQualifiers");
+
+ xfer += oprot->writeFieldBegin("qualifiers", ::apache::thrift::protocol::T_MAP, 1);
+ {
+ xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->qualifiers.size()));
+ std::map<std::string, TTypeQualifierValue> ::const_iterator _iter9;
+ for (_iter9 = this->qualifiers.begin(); _iter9 != this->qualifiers.end(); ++_iter9)
+ {
+ xfer += oprot->writeString(_iter9->first);
+ xfer += _iter9->second.write(oprot);
+ }
+ xfer += oprot->writeMapEnd();
+ }
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+void swap(TTypeQualifiers &a, TTypeQualifiers &b) {
+ using ::std::swap;
+ swap(a.qualifiers, b.qualifiers);
+}
+
+TTypeQualifiers::TTypeQualifiers(const TTypeQualifiers& other10) {
+ qualifiers = other10.qualifiers;
+}
+TTypeQualifiers& TTypeQualifiers::operator=(const TTypeQualifiers& other11) {
+ qualifiers = other11.qualifiers;
+ return *this;
+}
+void TTypeQualifiers::printTo(std::ostream& out) const {
+ using ::apache::thrift::to_string;
+ out << "TTypeQualifiers(";
+ out << "qualifiers=" << to_string(qualifiers);
+ out << ")";
+}
+
+
+TPrimitiveTypeEntry::~TPrimitiveTypeEntry() throw() {
+}
+
+
+void TPrimitiveTypeEntry::__set_type(const TTypeId::type val) {
+ this->type = val;
+}
+
+void TPrimitiveTypeEntry::__set_typeQualifiers(const TTypeQualifiers& val) {
+ this->typeQualifiers = val;
+__isset.typeQualifiers = true;
+}
+
+uint32_t TPrimitiveTypeEntry::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+ bool isset_type = false;
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case 1:
+ if (ftype == ::apache::thrift::protocol::T_I32) {
+ int32_t ecast12;
+ xfer += iprot->readI32(ecast12);
+ this->type = (TTypeId::type)ecast12;
+ isset_type = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->typeQualifiers.read(iprot);
+ this->__isset.typeQualifiers = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ if (!isset_type)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ return xfer;
+}
+
+uint32_t TPrimitiveTypeEntry::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+ xfer += oprot->writeStructBegin("TPrimitiveTypeEntry");
+
+ xfer += oprot->writeFieldBegin("type", ::apache::thrift::protocol::T_I32, 1);
+ xfer += oprot->writeI32((int32_t)this->type);
+ xfer += oprot->writeFieldEnd();
+
+ if (this->__isset.typeQualifiers) {
+ xfer += oprot->writeFieldBegin("typeQualifiers", ::apache::thrift::protocol::T_STRUCT, 2);
+ xfer += this->typeQualifiers.write(oprot);
+ xfer += oprot->writeFieldEnd();
+ }
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+void swap(TPrimitiveTypeEntry &a, TPrimitiveTypeEntry &b) {
+ using ::std::swap;
+ swap(a.type, b.type);
+ swap(a.typeQualifiers, b.typeQualifiers);
+ swap(a.__isset, b.__isset);
+}
+
+TPrimitiveTypeEntry::TPrimitiveTypeEntry(const TPrimitiveTypeEntry& other13) {
+ type = other13.type;
+ typeQualifiers = other13.typeQualifiers;
+ __isset = other13.__isset;
+}
+TPrimitiveTypeEntry& TPrimitiveTypeEntry::operator=(const TPrimitiveTypeEntry& other14) {
+ type = other14.type;
+ typeQualifiers = other14.typeQualifiers;
+ __isset = other14.__isset;
+ return *this;
+}
+void TPrimitiveTypeEntry::printTo(std::ostream& out) const {
+ using ::apache::thrift::to_string;
+ out << "TPrimitiveTypeEntry(";
+ out << "type=" << to_string(type);
+ out << ", " << "typeQualifiers="; (__isset.typeQualifiers ? (out << to_string(typeQualifiers)) : (out << "<null>"));
+ out << ")";
+}
+
+
+TArrayTypeEntry::~TArrayTypeEntry() throw() {
+}
+
+
+void TArrayTypeEntry::__set_objectTypePtr(const TTypeEntryPtr val) {
+ this->objectTypePtr = val;
+}
+
+uint32_t TArrayTypeEntry::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+ bool isset_objectTypePtr = false;
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case 1:
+ if (ftype == ::apache::thrift::protocol::T_I32) {
+ xfer += iprot->readI32(this->objectTypePtr);
+ isset_objectTypePtr = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ if (!isset_objectTypePtr)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ return xfer;
+}
+
+uint32_t TArrayTypeEntry::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+ xfer += oprot->writeStructBegin("TArrayTypeEntry");
+
+ xfer += oprot->writeFieldBegin("objectTypePtr", ::apache::thrift::protocol::T_I32, 1);
+ xfer += oprot->writeI32(this->objectTypePtr);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+void swap(TArrayTypeEntry &a, TArrayTypeEntry &b) {
+ using ::std::swap;
+ swap(a.objectTypePtr, b.objectTypePtr);
+}
+
+TArrayTypeEntry::TArrayTypeEntry(const TArrayTypeEntry& other15) {
+ objectTypePtr = other15.objectTypePtr;
+}
+TArrayTypeEntry& TArrayTypeEntry::operator=(const TArrayTypeEntry& other16) {
+ objectTypePtr = other16.objectTypePtr;
+ return *this;
+}
+void TArrayTypeEntry::printTo(std::ostream& out) const {
+ using ::apache::thrift::to_string;
+ out << "TArrayTypeEntry(";
+ out << "objectTypePtr=" << to_string(objectTypePtr);
+ out << ")";
+}
+
+
+TMapTypeEntry::~TMapTypeEntry() throw() {
+}
+
+
+void TMapTypeEntry::__set_keyTypePtr(const TTypeEntryPtr val) {
+ this->keyTypePtr = val;
+}
+
+void TMapTypeEntry::__set_valueTypePtr(const TTypeEntryPtr val) {
+ this->valueTypePtr = val;
+}
+
+uint32_t TMapTypeEntry::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+ bool isset_keyTypePtr = false;
+ bool isset_valueTypePtr = false;
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case 1:
+ if (ftype == ::apache::thrift::protocol::T_I32) {
+ xfer += iprot->readI32(this->keyTypePtr);
+ isset_keyTypePtr = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_I32) {
+ xfer += iprot->readI32(this->valueTypePtr);
+ isset_valueTypePtr = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ if (!isset_keyTypePtr)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ if (!isset_valueTypePtr)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ return xfer;
+}
+
+uint32_t TMapTypeEntry::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+ xfer += oprot->writeStructBegin("TMapTypeEntry");
+
+ xfer += oprot->writeFieldBegin("keyTypePtr", ::apache::thrift::protocol::T_I32, 1);
+ xfer += oprot->writeI32(this->keyTypePtr);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("valueTypePtr", ::apache::thrift::protocol::T_I32, 2);
+ xfer += oprot->writeI32(this->valueTypePtr);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+void swap(TMapTypeEntry &a, TMapTypeEntry &b) {
+ using ::std::swap;
+ swap(a.keyTypePtr, b.keyTypePtr);
+ swap(a.valueTypePtr, b.valueTypePtr);
+}
+
+TMapTypeEntry::TMapTypeEntry(const TMapTypeEntry& other17) {
+ keyTypePtr = other17.keyTypePtr;
+ valueTypePtr = other17.valueTypePtr;
+}
+TMapTypeEntry& TMapTypeEntry::operator=(const TMapTypeEntry& other18) {
+ keyTypePtr = other18.keyTypePtr;
+ valueTypePtr = other18.valueTypePtr;
+ return *this;
+}
+void TMapTypeEntry::printTo(std::ostream& out) const {
+ using ::apache::thrift::to_string;
+ out << "TMapTypeEntry(";
+ out << "keyTypePtr=" << to_string(keyTypePtr);
+ out << ", " << "valueTypePtr=" << to_string(valueTypePtr);
+ out << ")";
+}
+
+
+TStructTypeEntry::~TStructTypeEntry() throw() {
+}
+
+
+void TStructTypeEntry::__set_nameToTypePtr(const std::map<std::string, TTypeEntryPtr> & val) {
+ this->nameToTypePtr = val;
+}
+
+uint32_t TStructTypeEntry::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+ bool isset_nameToTypePtr = false;
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case 1:
+ if (ftype == ::apache::thrift::protocol::T_MAP) {
+ {
+ this->nameToTypePtr.clear();
+ uint32_t _size19;
+ ::apache::thrift::protocol::TType _ktype20;
+ ::apache::thrift::protocol::TType _vtype21;
+ xfer += iprot->readMapBegin(_ktype20, _vtype21, _size19);
+ uint32_t _i23;
+ for (_i23 = 0; _i23 < _size19; ++_i23)
+ {
+ std::string _key24;
+ xfer += iprot->readString(_key24);
+ TTypeEntryPtr& _val25 = this->nameToTypePtr[_key24];
+ xfer += iprot->readI32(_val25);
+ }
+ xfer += iprot->readMapEnd();
+ }
+ isset_nameToTypePtr = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ if (!isset_nameToTypePtr)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ return xfer;
+}
+
+uint32_t TStructTypeEntry::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+ xfer += oprot->writeStructBegin("TStructTypeEntry");
+
+ xfer += oprot->writeFieldBegin("nameToTypePtr", ::apache::thrift::protocol::T_MAP, 1);
+ {
+ xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_I32, static_cast<uint32_t>(this->nameToTypePtr.size()));
+ std::map<std::string, TTypeEntryPtr> ::const_iterator _iter26;
+ for (_iter26 = this->nameToTypePtr.begin(); _iter26 != this->nameToTypePtr.end(); ++_iter26)
+ {
+ xfer += oprot->writeString(_iter26->first);
+ xfer += oprot->writeI32(_iter26->second);
+ }
+ xfer += oprot->writeMapEnd();
+ }
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+void swap(TStructTypeEntry &a, TStructTypeEntry &b) {
+ using ::std::swap;
+ swap(a.nameToTypePtr, b.nameToTypePtr);
+}
+
+TStructTypeEntry::TStructTypeEntry(const TStructTypeEntry& other27) {
+ nameToTypePtr = other27.nameToTypePtr;
+}
+TStructTypeEntry& TStructTypeEntry::operator=(const TStructTypeEntry& other28) {
+ nameToTypePtr = other28.nameToTypePtr;
+ return *this;
+}
+void TStructTypeEntry::printTo(std::ostream& out) const {
+ using ::apache::thrift::to_string;
+ out << "TStructTypeEntry(";
+ out << "nameToTypePtr=" << to_string(nameToTypePtr);
+ out << ")";
+}
+
+
+TUnionTypeEntry::~TUnionTypeEntry() throw() {
+}
+
+
+void TUnionTypeEntry::__set_nameToTypePtr(const std::map<std::string, TTypeEntryPtr> & val) {
+ this->nameToTypePtr = val;
+}
+
+uint32_t TUnionTypeEntry::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+ bool isset_nameToTypePtr = false;
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case 1:
+ if (ftype == ::apache::thrift::protocol::T_MAP) {
+ {
+ this->nameToTypePtr.clear();
+ uint32_t _size29;
+ ::apache::thrift::protocol::TType _ktype30;
+ ::apache::thrift::protocol::TType _vtype31;
+ xfer += iprot->readMapBegin(_ktype30, _vtype31, _size29);
+ uint32_t _i33;
+ for (_i33 = 0; _i33 < _size29; ++_i33)
+ {
+ std::string _key34;
+ xfer += iprot->readString(_key34);
+ TTypeEntryPtr& _val35 = this->nameToTypePtr[_key34];
+ xfer += iprot->readI32(_val35);
+ }
+ xfer += iprot->readMapEnd();
+ }
+ isset_nameToTypePtr = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ if (!isset_nameToTypePtr)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ return xfer;
+}
+
+uint32_t TUnionTypeEntry::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+ xfer += oprot->writeStructBegin("TUnionTypeEntry");
+
+ xfer += oprot->writeFieldBegin("nameToTypePtr", ::apache::thrift::protocol::T_MAP, 1);
+ {
+ xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_I32, static_cast<uint32_t>(this->nameToTypePtr.size()));
+ std::map<std::string, TTypeEntryPtr> ::const_iterator _iter36;
+ for (_iter36 = this->nameToTypePtr.begin(); _iter36 != this->nameToTypePtr.end(); ++_iter36)
+ {
+ xfer += oprot->writeString(_iter36->first);
+ xfer += oprot->writeI32(_iter36->second);
+ }
+ xfer += oprot->writeMapEnd();
+ }
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+void swap(TUnionTypeEntry &a, TUnionTypeEntry &b) {
+ using ::std::swap;
+ swap(a.nameToTypePtr, b.nameToTypePtr);
+}
+
+TUnionTypeEntry::TUnionTypeEntry(const TUnionTypeEntry& other37) {
+ nameToTypePtr = other37.nameToTypePtr;
+}
+TUnionTypeEntry& TUnionTypeEntry::operator=(const TUnionTypeEntry& other38) {
+ nameToTypePtr = other38.nameToTypePtr;
+ return *this;
+}
+void TUnionTypeEntry::printTo(std::ostream& out) const {
+ using ::apache::thrift::to_string;
+ out << "TUnionTypeEntry(";
+ out << "nameToTypePtr=" << to_string(nameToTypePtr);
+ out << ")";
+}
+
+
+TUserDefinedTypeEntry::~TUserDefinedTypeEntry() throw() {
+}
+
+
+void TUserDefinedTypeEntry::__set_typeClassName(const std::string& val) {
+ this->typeClassName = val;
+}
+
+uint32_t TUserDefinedTypeEntry::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+ bool isset_typeClassName = false;
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case 1:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->typeClassName);
+ isset_typeClassName = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ if (!isset_typeClassName)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ return xfer;
+}
+
+uint32_t TUserDefinedTypeEntry::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+ xfer += oprot->writeStructBegin("TUserDefinedTypeEntry");
+
+ xfer += oprot->writeFieldBegin("typeClassName", ::apache::thrift::protocol::T_STRING, 1);
+ xfer += oprot->writeString(this->typeClassName);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+void swap(TUserDefinedTypeEntry &a, TUserDefinedTypeEntry &b) {
+ using ::std::swap;
+ swap(a.typeClassName, b.typeClassName);
+}
+
+TUserDefinedTypeEntry::TUserDefinedTypeEntry(const TUserDefinedTypeEntry& other39) {
+ typeClassName = other39.typeClassName;
+}
+TUserDefinedTypeEntry& TUserDefinedTypeEntry::operator=(const TUserDefinedTypeEntry& other40) {
+ typeClassName = other40.typeClassName;
+ return *this;
+}
+void TUserDefinedTypeEntry::printTo(std::ostream& out) const {
+ using ::apache::thrift::to_string;
+ out << "TUserDefinedTypeEntry(";
+ out << "typeClassName=" << to_string(typeClassName);
+ out << ")";
+}
+
+
+TTypeEntry::~TTypeEntry() throw() {
+}
+
+
+void TTypeEntry::__set_primitiveEntry(const TPrimitiveTypeEntry& val) {
+ this->primitiveEntry = val;
+}
+
+void TTypeEntry::__set_arrayEntry(const TArrayTypeEntry& val) {
+ this->arrayEntry = val;
+}
+
+void TTypeEntry::__set_mapEntry(const TMapTypeEntry& val) {
+ this->mapEntry = val;
+}
+
+void TTypeEntry::__set_structEntry(const TStructTypeEntry& val) {
+ this->structEntry = val;
+}
+
+void TTypeEntry::__set_unionEntry(const TUnionTypeEntry& val) {
+ this->unionEntry = val;
+}
+
+void TTypeEntry::__set_userDefinedTypeEntry(const TUserDefinedTypeEntry& val) {
+ this->userDefinedTypeEntry = val;
+}
+
+uint32_t TTypeEntry::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case 1:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->primitiveEntry.read(iprot);
+ this->__isset.primitiveEntry = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->arrayEntry.read(iprot);
+ this->__isset.arrayEntry = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 3:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->mapEntry.read(iprot);
+ this->__isset.mapEntry = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 4:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->structEntry.read(iprot);
+ this->__isset.structEntry = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 5:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->unionEntry.read(iprot);
+ this->__isset.unionEntry = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 6:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->userDefinedTypeEntry.read(iprot);
+ this->__isset.userDefinedTypeEntry = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t TTypeEntry::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+ xfer += oprot->writeStructBegin("TTypeEntry");
+
+ xfer += oprot->writeFieldBegin("primitiveEntry", ::apache::thrift::protocol::T_STRUCT, 1);
+ xfer += this->primitiveEntry.write(oprot);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("arrayEntry", ::apache::thrift::protocol::T_STRUCT, 2);
+ xfer += this->arrayEntry.write(oprot);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("mapEntry", ::apache::thrift::protocol::T_STRUCT, 3);
+ xfer += this->mapEntry.write(oprot);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("structEntry", ::apache::thrift::protocol::T_STRUCT, 4);
+ xfer += this->structEntry.write(oprot);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("unionEntry", ::apache::thrift::protocol::T_STRUCT, 5);
+ xfer += this->unionEntry.write(oprot);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("userDefinedTypeEntry", ::apache::thrift::protocol::T_STRUCT, 6);
+ xfer += this->userDefinedTypeEntry.write(oprot);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+void swap(TTypeEntry &a, TTypeEntry &b) {
+ using ::std::swap;
+ swap(a.primitiveEntry, b.primitiveEntry);
+ swap(a.arrayEntry, b.arrayEntry);
+ swap(a.mapEntry, b.mapEntry);
+ swap(a.structEntry, b.structEntry);
+ swap(a.unionEntry, b.unionEntry);
+ swap(a.userDefinedTypeEntry, b.userDefinedTypeEntry);
+ swap(a.__isset, b.__isset);
+}
+
+TTypeEntry::TTypeEntry(const TTypeEntry& other41) {
+ primitiveEntry = other41.primitiveEntry;
+ arrayEntry = other41.arrayEntry;
+ mapEntry = other41.mapEntry;
+ structEntry = other41.structEntry;
+ unionEntry = other41.unionEntry;
+ userDefinedTypeEntry = other41.userDefinedTypeEntry;
+ __isset = other41.__isset;
+}
+TTypeEntry& TTypeEntry::operator=(const TTypeEntry& other42) {
+ primitiveEntry = other42.primitiveEntry;
+ arrayEntry = other42.arrayEntry;
+ mapEntry = other42.mapEntry;
+ structEntry = other42.structEntry;
+ unionEntry = other42.unionEntry;
+ userDefinedTypeEntry = other42.userDefinedTypeEntry;
+ __isset = other42.__isset;
+ return *this;
+}
+void TTypeEntry::printTo(std::ostream& out) const {
+ using ::apache::thrift::to_string;
+ out << "TTypeEntry(";
+ out << "primitiveEntry=" << to_string(primitiveEntry);
+ out << ", " << "arrayEntry=" << to_string(arrayEntry);
+ out << ", " << "mapEntry=" << to_string(mapEntry);
+ out << ", " << "structEntry=" << to_string(structEntry);
+ out << ", " << "unionEntry=" << to_string(unionEntry);
+ out << ", " << "userDefinedTypeEntry=" << to_string(userDefinedTypeEntry);
+ out << ")";
+}
+
+
+TTypeDesc::~TTypeDesc() throw() {
+}
+
+
+void TTypeDesc::__set_types(const std::vector<TTypeEntry> & val) {
+ this->types = val;
+}
+
+uint32_t TTypeDesc::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+ bool isset_types = false;
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case 1:
+ if (ftype == ::apache::thrift::protocol::T_LIST) {
+ {
+ this->types.clear();
+ uint32_t _size43;
+ ::apache::thrift::protocol::TType _etype46;
+ xfer += iprot->readListBegin(_etype46, _size43);
+ this->types.resize(_size43);
+ uint32_t _i47;
+ for (_i47 = 0; _i47 < _size43; ++_i47)
+ {
+ xfer += this->types[_i47].read(iprot);
+ }
+ xfer += iprot->readListEnd();
+ }
+ isset_types = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ if (!isset_types)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ return xfer;
+}
+
+uint32_t TTypeDesc::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+ xfer += oprot->writeStructBegin("TTypeDesc");
+
+ xfer += oprot->writeFieldBegin("types", ::apache::thrift::protocol::T_LIST, 1);
+ {
+ xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->types.size()));
+ std::vector<TTypeEntry> ::const_iterator _iter48;
+ for (_iter48 = this->types.begin(); _iter48 != this->types.end(); ++_iter48)
+ {
+ xfer += (*_iter48).write(oprot);
+ }
+ xfer += oprot->writeListEnd();
+ }
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+void swap(TTypeDesc &a, TTypeDesc &b) {
+ using ::std::swap;
+ swap(a.types, b.types);
+}
+
+TTypeDesc::TTypeDesc(const TTypeDesc& other49) {
+ types = other49.types;
+}
+TTypeDesc& TTypeDesc::operator=(const TTypeDesc& other50) {
+ types = other50.types;
+ return *this;
+}
+void TTypeDesc::printTo(std::ostream& out) const {
+ using ::apache::thrift::to_string;
+ out << "TTypeDesc(";
+ out << "types=" << to_string(types);
+ out << ")";
+}
+
+
+TColumnDesc::~TColumnDesc() throw() {
+}
+
+
+void TColumnDesc::__set_columnName(const std::string& val) {
+ this->columnName = val;
+}
+
+void TColumnDesc::__set_typeDesc(const TTypeDesc& val) {
+ this->typeDesc = val;
+}
+
+void TColumnDesc::__set_position(const int32_t val) {
+ this->position = val;
+}
+
+void TColumnDesc::__set_comment(const std::string& val) {
+ this->comment = val;
+__isset.comment = true;
+}
+
+uint32_t TColumnDesc::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+ bool isset_columnName = false;
+ bool isset_typeDesc = false;
+ bool isset_position = false;
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case 1:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->columnName);
+ isset_columnName = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->typeDesc.read(iprot);
+ isset_typeDesc = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 3:
+ if (ftype == ::apache::thrift::protocol::T_I32) {
+ xfer += iprot->readI32(this->position);
+ isset_position = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 4:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->comment);
+ this->__isset.comment = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ if (!isset_columnName)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ if (!isset_typeDesc)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ if (!isset_position)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ return xfer;
+}
+
+uint32_t TColumnDesc::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+ xfer += oprot->writeStructBegin("TColumnDesc");
+
+ xfer += oprot->writeFieldBegin("columnName", ::apache::thrift::protocol::T_STRING, 1);
+ xfer += oprot->writeString(this->columnName);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("typeDesc", ::apache::thrift::protocol::T_STRUCT, 2);
+ xfer += this->typeDesc.write(oprot);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("position", ::apache::thrift::protocol::T_I32, 3);
+ xfer += oprot->writeI32(this->position);
+ xfer += oprot->writeFieldEnd();
+
+ if (this->__isset.comment) {
+ xfer += oprot->writeFieldBegin("comment", ::apache::thrift::protocol::T_STRING, 4);
+ xfer += oprot->writeString(this->comment);
+ xfer += oprot->writeFieldEnd();
+ }
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+void swap(TColumnDesc &a, TColumnDesc &b) {
+ using ::std::swap;
+ swap(a.columnName, b.columnName);
+ swap(a.typeDesc, b.typeDesc);
+ swap(a.position, b.position);
+ swap(a.comment, b.comment);
+ swap(a.__isset, b.__isset);
+}
+
+TColumnDesc::TColumnDesc(const TColumnDesc& other51) {
+ columnName = other51.columnName;
+ typeDesc = other51.typeDesc;
+ position = other51.position;
+ comment = other51.comment;
+ __isset = other51.__isset;
+}
+TColumnDesc& TColumnDesc::operator=(const TColumnDesc& other52) {
+ columnName = other52.columnName;
+ typeDesc = other52.typeDesc;
+ position = other52.position;
+ comment = other52.comment;
+ __isset = other52.__isset;
+ return *this;
+}
+void TColumnDesc::printTo(std::ostream& out) const {
+ using ::apache::thrift::to_string;
+ out << "TColumnDesc(";
+ out << "columnName=" << to_string(columnName);
+ out << ", " << "typeDesc=" << to_string(typeDesc);
+ out << ", " << "position=" << to_string(position);
+ out << ", " << "comment="; (__isset.comment ? (out << to_string(comment)) : (out << "<null>"));
+ out << ")";
+}
+
+
+TTableSchema::~TTableSchema() throw() {
+}
+
+
+void TTableSchema::__set_columns(const std::vector<TColumnDesc> & val) {
+ this->columns = val;
+}
+
+uint32_t TTableSchema::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+ bool isset_columns = false;
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case 1:
+ if (ftype == ::apache::thrift::protocol::T_LIST) {
+ {
+ this->columns.clear();
+ uint32_t _size53;
+ ::apache::thrift::protocol::TType _etype56;
+ xfer += iprot->readListBegin(_etype56, _size53);
+ this->columns.resize(_size53);
+ uint32_t _i57;
+ for (_i57 = 0; _i57 < _size53; ++_i57)
+ {
+ xfer += this->columns[_i57].read(iprot);
+ }
+ xfer += iprot->readListEnd();
+ }
+ isset_columns = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ if (!isset_columns)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ return xfer;
+}
+
+uint32_t TTableSchema::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+ xfer += oprot->writeStructBegin("TTableSchema");
+
+ xfer += oprot->writeFieldBegin("columns", ::apache::thrift::protocol::T_LIST, 1);
+ {
+ xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->columns.size()));
+ std::vector<TColumnDesc> ::const_iterator _iter58;
+ for (_iter58 = this->columns.begin(); _iter58 != this->columns.end(); ++_iter58)
+ {
+ xfer += (*_iter58).write(oprot);
+ }
+ xfer += oprot->writeListEnd();
+ }
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+void swap(TTableSchema &a, TTableSchema &b) {
+ using ::std::swap;
+ swap(a.columns, b.columns);
+}
+
+TTableSchema::TTableSchema(const TTableSchema& other59) {
+ columns = other59.columns;
+}
+TTableSchema& TTableSchema::operator=(const TTableSchema& other60) {
+ columns = other60.columns;
+ return *this;
+}
+void TTableSchema::printTo(std::ostream& out) const {
+ using ::apache::thrift::to_string;
+ out << "TTableSchema(";
+ out << "columns=" << to_string(columns);
+ out << ")";
+}
+
+
+TBoolValue::~TBoolValue() throw() {
+}
+
+
+void TBoolValue::__set_value(const bool val) {
+ this->value = val;
+__isset.value = true;
+}
+
+uint32_t TBoolValue::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case 1:
+ if (ftype == ::apache::thrift::protocol::T_BOOL) {
+ xfer += iprot->readBool(this->value);
+ this->__isset.value = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t TBoolValue::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+ xfer += oprot->writeStructBegin("TBoolValue");
+
+ if (this->__isset.value) {
+ xfer += oprot->writeFieldBegin("value", ::apache::thrift::protocol::T_BOOL, 1);
+ xfer += oprot->writeBool(this->value);
+ xfer += oprot->writeFieldEnd();
+ }
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+void swap(TBoolValue &a, TBoolValue &b) {
+ using ::std::swap;
+ swap(a.value, b.value);
+ swap(a.__isset, b.__isset);
+}
+
+TBoolValue::TBoolValue(const TBoolValue& other61) {
+ value = other61.value;
+ __isset = other61.__isset;
+}
+TBoolValue& TBoolValue::operator=(const TBoolValue& other62) {
+ value = other62.value;
+ __isset = other62.__isset;
+ return *this;
+}
+void TBoolValue::printTo(std::ostream& out) const {
+ using ::apache::thrift::to_string;
+ out << "TBoolValue(";
+ out << "value="; (__isset.value ? (out << to_string(value)) : (out << "<null>"));
+ out << ")";
+}
+
+
+TByteValue::~TByteValue() throw() {
+}
+
+
+void TByteValue::__set_value(const int8_t val) {
+ this->value = val;
+__isset.value = true;
+}
+
+uint32_t TByteValue::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case 1:
+ if (ftype == ::apache::thrift::protocol::T_BYTE) {
+ xfer += iprot->readByte(this->value);
+ this->__isset.value = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t TByteValue::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+ xfer += oprot->writeStructBegin("TByteValue");
+
+ if (this->__isset.value) {
+ xfer += oprot->writeFieldBegin("value", ::apache::thrift::protocol::T_BYTE, 1);
+ xfer += oprot->writeByte(this->value);
+ xfer += oprot->writeFieldEnd();
+ }
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+void swap(TByteValue &a, TByteValue &b) {
+ using ::std::swap;
+ swap(a.value, b.value);
+ swap(a.__isset, b.__isset);
+}
+
+TByteValue::TByteValue(const TByteValue& other63) {
+ value = other63.value;
+ __isset = other63.__isset;
+}
+TByteValue& TByteValue::operator=(const TByteValue& other64) {
+ value = other64.value;
+ __isset = other64.__isset;
+ return *this;
+}
+void TByteValue::printTo(std::ostream& out) const {
+ using ::apache::thrift::to_string;
+ out << "TByteValue(";
+ out << "value="; (__isset.value ? (out << to_string(value)) : (out << "<null>"));
+ out << ")";
+}
+
+
+TI16Value::~TI16Value() throw() {
+}
+
+
+void TI16Value::__set_value(const int16_t val) {
+ this->value = val;
+__isset.value = true;
+}
+
+uint32_t TI16Value::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case 1:
+ if (ftype == ::apache::thrift::protocol::T_I16) {
+ xfer += iprot->readI16(this->value);
+ this->__isset.value = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t TI16Value::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+ xfer += oprot->writeStructBegin("TI16Value");
+
+ if (this->__isset.value) {
+ xfer += oprot->writeFieldBegin("value", ::apache::thrift::protocol::T_I16, 1);
+ xfer += oprot->writeI16(this->value);
+ xfer += oprot->writeFieldEnd();
+ }
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+void swap(TI16Value &a, TI16Value &b) {
+ using ::std::swap;
+ swap(a.value, b.value);
+ swap(a.__isset, b.__isset);
+}
+
+TI16Value::TI16Value(const TI16Value& other65) {
+ value = other65.value;
+ __isset = other65.__isset;
+}
+TI16Value& TI16Value::operator=(const TI16Value& other66) {
+ value = other66.value;
+ __isset = other66.__isset;
+ return *this;
+}
+void TI16Value::printTo(std::ostream& out) const {
+ using ::apache::thrift::to_string;
+ out << "TI16Value(";
+ out << "value="; (__isset.value ? (out << to_string(value)) : (out << "<null>"));
+ out << ")";
+}
+
+
+TI32Value::~TI32Value() throw() {
+}
+
+
+void TI32Value::__set_value(const int32_t val) {
+ this->value = val;
+__isset.value = true;
+}
+
+uint32_t TI32Value::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case 1:
+ if (ftype == ::apache::thrift::protocol::T_I32) {
+ xfer += iprot->readI32(this->value);
+ this->__isset.value = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t TI32Value::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+ xfer += oprot->writeStructBegin("TI32Value");
+
+ if (this->__isset.value) {
+ xfer += oprot->writeFieldBegin("value", ::apache::thrift::protocol::T_I32, 1);
+ xfer += oprot->writeI32(this->value);
+ xfer += oprot->writeFieldEnd();
+ }
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+void swap(TI32Value &a, TI32Value &b) {
+ using ::std::swap;
+ swap(a.value, b.value);
+ swap(a.__isset, b.__isset);
+}
+
+TI32Value::TI32Value(const TI32Value& other67) {
+ value = other67.value;
+ __isset = other67.__isset;
+}
+TI32Value& TI32Value::operator=(const TI32Value& other68) {
+ value = other68.value;
+ __isset = other68.__isset;
+ return *this;
+}
+void TI32Value::printTo(std::ostream& out) const {
+ using ::apache::thrift::to_string;
+ out << "TI32Value(";
+ out << "value="; (__isset.value ? (out << to_string(value)) : (out << "<null>"));
+ out << ")";
+}
+
+
+TI64Value::~TI64Value() throw() {
+}
+
+
+void TI64Value::__set_value(const int64_t val) {
+ this->value = val;
+__isset.value = true;
+}
+
+uint32_t TI64Value::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case 1:
+ if (ftype == ::apache::thrift::protocol::T_I64) {
+ xfer += iprot->readI64(this->value);
+ this->__isset.value = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t TI64Value::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+ xfer += oprot->writeStructBegin("TI64Value");
+
+ if (this->__isset.value) {
+ xfer += oprot->writeFieldBegin("value", ::apache::thrift::protocol::T_I64, 1);
+ xfer += oprot->writeI64(this->value);
+ xfer += oprot->writeFieldEnd();
+ }
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+void swap(TI64Value &a, TI64Value &b) {
+ using ::std::swap;
+ swap(a.value, b.value);
+ swap(a.__isset, b.__isset);
+}
+
+TI64Value::TI64Value(const TI64Value& other69) {
+ value = other69.value;
+ __isset = other69.__isset;
+}
+TI64Value& TI64Value::operator=(const TI64Value& other70) {
+ value = other70.value;
+ __isset = other70.__isset;
+ return *this;
+}
+void TI64Value::printTo(std::ostream& out) const {
+ using ::apache::thrift::to_string;
+ out << "TI64Value(";
+ out << "value="; (__isset.value ? (out << to_string(value)) : (out << "<null>"));
+ out << ")";
+}
+
+
+TDoubleValue::~TDoubleValue() throw() {
+}
+
+
+void TDoubleValue::__set_value(const double val) {
+ this->value = val;
+__isset.value = true;
+}
+
+uint32_t TDoubleValue::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case 1:
+ if (ftype == ::apache::thrift::protocol::T_DOUBLE) {
+ xfer += iprot->readDouble(this->value);
+ this->__isset.value = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t TDoubleValue::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+ xfer += oprot->writeStructBegin("TDoubleValue");
+
+ if (this->__isset.value) {
+ xfer += oprot->writeFieldBegin("value", ::apache::thrift::protocol::T_DOUBLE, 1);
+ xfer += oprot->writeDouble(this->value);
+ xfer += oprot->writeFieldEnd();
+ }
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+void swap(TDoubleValue &a, TDoubleValue &b) {
+ using ::std::swap;
+ swap(a.value, b.value);
+ swap(a.__isset, b.__isset);
+}
+
+TDoubleValue::TDoubleValue(const TDoubleValue& other71) {
+ value = other71.value;
+ __isset = other71.__isset;
+}
+TDoubleValue& TDoubleValue::operator=(const TDoubleValue& other72) {
+ value = other72.value;
+ __isset = other72.__isset;
+ return *this;
+}
+void TDoubleValue::printTo(std::ostream& out) const {
+ using ::apache::thrift::to_string;
+ out << "TDoubleValue(";
+ out << "value="; (__isset.value ? (out << to_string(value)) : (out << "<null>"));
+ out << ")";
+}
+
+
+TStringValue::~TStringValue() throw() {
+}
+
+
+void TStringValue::__set_value(const std::string& val) {
+ this->value = val;
+__isset.value = true;
+}
+
+uint32_t TStringValue::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case 1:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->value);
+ this->__isset.value = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t TStringValue::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+ xfer += oprot->writeStructBegin("TStringValue");
+
+ if (this->__isset.value) {
+ xfer += oprot->writeFieldBegin("value", ::apache::thrift::protocol::T_STRING, 1);
+ xfer += oprot->writeString(this->value);
+ xfer += oprot->writeFieldEnd();
+ }
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+void swap(TStringValue &a, TStringValue &b) {
+ using ::std::swap;
+ swap(a.value, b.value);
+ swap(a.__isset, b.__isset);
+}
+
+TStringValue::TStringValue(const TStringValue& other73) {
+ value = other73.value;
+ __isset = other73.__isset;
+}
+TStringValue& TStringValue::operator=(const TStringValue& other74) {
+ value = other74.value;
+ __isset = other74.__isset;
+ return *this;
+}
+void TStringValue::printTo(std::ostream& out) const {
+ using ::apache::thrift::to_string;
+ out << "TStringValue(";
+ out << "value="; (__isset.value ? (out << to_string(value)) : (out << "<null>"));
+ out << ")";
+}
+
+
+TColumnValue::~TColumnValue() throw() {
+}
+
+
+void TColumnValue::__set_boolVal(const TBoolValue& val) {
+ this->boolVal = val;
+}
+
+void TColumnValue::__set_byteVal(const TByteValue& val) {
+ this->byteVal = val;
+}
+
+void TColumnValue::__set_i16Val(const TI16Value& val) {
+ this->i16Val = val;
+}
+
+void TColumnValue::__set_i32Val(const TI32Value& val) {
+ this->i32Val = val;
+}
+
+void TColumnValue::__set_i64Val(const TI64Value& val) {
+ this->i64Val = val;
+}
+
+void TColumnValue::__set_doubleVal(const TDoubleValue& val) {
+ this->doubleVal = val;
+}
+
+void TColumnValue::__set_stringVal(const TStringValue& val) {
+ this->stringVal = val;
+}
+
+uint32_t TColumnValue::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case 1:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->boolVal.read(iprot);
+ this->__isset.boolVal = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->byteVal.read(iprot);
+ this->__isset.byteVal = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 3:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->i16Val.read(iprot);
+ this->__isset.i16Val = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 4:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->i32Val.read(iprot);
+ this->__isset.i32Val = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 5:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->i64Val.read(iprot);
+ this->__isset.i64Val = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 6:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->doubleVal.read(iprot);
+ this->__isset.doubleVal = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 7:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->stringVal.read(iprot);
+ this->__isset.stringVal = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t TColumnValue::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+ xfer += oprot->writeStructBegin("TColumnValue");
+
+ xfer += oprot->writeFieldBegin("boolVal", ::apache::thrift::protocol::T_STRUCT, 1);
+ xfer += this->boolVal.write(oprot);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("byteVal", ::apache::thrift::protocol::T_STRUCT, 2);
+ xfer += this->byteVal.write(oprot);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("i16Val", ::apache::thrift::protocol::T_STRUCT, 3);
+ xfer += this->i16Val.write(oprot);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("i32Val", ::apache::thrift::protocol::T_STRUCT, 4);
+ xfer += this->i32Val.write(oprot);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("i64Val", ::apache::thrift::protocol::T_STRUCT, 5);
+ xfer += this->i64Val.write(oprot);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("doubleVal", ::apache::thrift::protocol::T_STRUCT, 6);
+ xfer += this->doubleVal.write(oprot);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("stringVal", ::apache::thrift::protocol::T_STRUCT, 7);
+ xfer += this->stringVal.write(oprot);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+void swap(TColumnValue &a, TColumnValue &b) {
+ using ::std::swap;
+ swap(a.boolVal, b.boolVal);
+ swap(a.byteVal, b.byteVal);
+ swap(a.i16Val, b.i16Val);
+ swap(a.i32Val, b.i32Val);
+ swap(a.i64Val, b.i64Val);
+ swap(a.doubleVal, b.doubleVal);
+ swap(a.stringVal, b.stringVal);
+ swap(a.__isset, b.__isset);
+}
+
+TColumnValue::TColumnValue(const TColumnValue& other75) {
+ boolVal = other75.boolVal;
+ byteVal = other75.byteVal;
+ i16Val = other75.i16Val;
+ i32Val = other75.i32Val;
+ i64Val = other75.i64Val;
+ doubleVal = other75.doubleVal;
+ stringVal = other75.stringVal;
+ __isset = other75.__isset;
+}
+TColumnValue& TColumnValue::operator=(const TColumnValue& other76) {
+ boolVal = other76.boolVal;
+ byteVal = other76.byteVal;
+ i16Val = other76.i16Val;
+ i32Val = other76.i32Val;
+ i64Val = other76.i64Val;
+ doubleVal = other76.doubleVal;
+ stringVal = other76.stringVal;
+ __isset = other76.__isset;
+ return *this;
+}
+void TColumnValue::printTo(std::ostream& out) const {
+ using ::apache::thrift::to_string;
+ out << "TColumnValue(";
+ out << "boolVal=" << to_string(boolVal);
+ out << ", " << "byteVal=" << to_string(byteVal);
+ out << ", " << "i16Val=" << to_string(i16Val);
+ out << ", " << "i32Val=" << to_string(i32Val);
+ out << ", " << "i64Val=" << to_string(i64Val);
+ out << ", " << "doubleVal=" << to_string(doubleVal);
+ out << ", " << "stringVal=" << to_string(stringVal);
+ out << ")";
+}
+
+
+TRow::~TRow() throw() {
+}
+
+
+void TRow::__set_colVals(const std::vector<TColumnValue> & val) {
+ this->colVals = val;
+}
+
+uint32_t TRow::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+ bool isset_colVals = false;
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case 1:
+ if (ftype == ::apache::thrift::protocol::T_LIST) {
+ {
+ this->colVals.clear();
+ uint32_t _size77;
+ ::apache::thrift::protocol::TType _etype80;
+ xfer += iprot->readListBegin(_etype80, _size77);
+ this->colVals.resize(_size77);
+ uint32_t _i81;
+ for (_i81 = 0; _i81 < _size77; ++_i81)
+ {
+ xfer += this->colVals[_i81].read(iprot);
+ }
+ xfer += iprot->readListEnd();
+ }
+ isset_colVals = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ if (!isset_colVals)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ return xfer;
+}
+
+uint32_t TRow::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+ xfer += oprot->writeStructBegin("TRow");
+
+ xfer += oprot->writeFieldBegin("colVals", ::apache::thrift::protocol::T_LIST, 1);
+ {
+ xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->colVals.size()));
+ std::vector<TColumnValue> ::const_iterator _iter82;
+ for (_iter82 = this->colVals.begin(); _iter82 != this->colVals.end(); ++_iter82)
+ {
+ xfer += (*_iter82).write(oprot);
+ }
+ xfer += oprot->writeListEnd();
+ }
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+void swap(TRow &a, TRow &b) {
+ using ::std::swap;
+ swap(a.colVals, b.colVals);
+}
+
+TRow::TRow(const TRow& other83) {
+ colVals = other83.colVals;
+}
+TRow& TRow::operator=(const TRow& other84) {
+ colVals = other84.colVals;
+ return *this;
+}
+void TRow::printTo(std::ostream& out) const {
+ using ::apache::thrift::to_string;
+ out << "TRow(";
+ out << "colVals=" << to_string(colVals);
+ out << ")";
+}
+
+
+TBoolColumn::~TBoolColumn() throw() {
+}
+
+
+void TBoolColumn::__set_values(const std::vector<bool> & val) {
+ this->values = val;
+}
+
+void TBoolColumn::__set_nulls(const std::string& val) {
+ this->nulls = val;
+}
+
+uint32_t TBoolColumn::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+ bool isset_values = false;
+ bool isset_nulls = false;
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case 1:
+ if (ftype == ::apache::thrift::protocol::T_LIST) {
+ {
+ this->values.clear();
+ uint32_t _size85;
+ ::apache::thrift::protocol::TType _etype88;
+ xfer += iprot->readListBegin(_etype88, _size85);
+ this->values.resize(_size85);
+ uint32_t _i89;
+ for (_i89 = 0; _i89 < _size85; ++_i89)
+ {
+ xfer += iprot->readBool(this->values[_i89]);
+ }
+ xfer += iprot->readListEnd();
+ }
+ isset_values = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readBinary(this->nulls);
+ isset_nulls = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ if (!isset_values)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ if (!isset_nulls)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ return xfer;
+}
+
+uint32_t TBoolColumn::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+ xfer += oprot->writeStructBegin("TBoolColumn");
+
+ xfer += oprot->writeFieldBegin("values", ::apache::thrift::protocol::T_LIST, 1);
+ {
+ xfer += oprot->writeListBegin(::apache::thrift::protocol::T_BOOL, static_cast<uint32_t>(this->values.size()));
+ std::vector<bool> ::const_iterator _iter90;
+ for (_iter90 = this->values.begin(); _iter90 != this->values.end(); ++_iter90)
+ {
+ xfer += oprot->writeBool((*_iter90));
+ }
+ xfer += oprot->writeListEnd();
+ }
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("nulls", ::apache::thrift::protocol::T_STRING, 2);
+ xfer += oprot->writeBinary(this->nulls);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+void swap(TBoolColumn &a, TBoolColumn &b) {
+ using ::std::swap;
+ swap(a.values, b.values);
+ swap(a.nulls, b.nulls);
+}
+
+TBoolColumn::TBoolColumn(const TBoolColumn& other91) {
+ values = other91.values;
+ nulls = other91.nulls;
+}
+TBoolColumn& TBoolColumn::operator=(const TBoolColumn& other92) {
+ values = other92.values;
+ nulls = other92.nulls;
+ return *this;
+}
+void TBoolColumn::printTo(std::ostream& out) const {
+ using ::apache::thrift::to_string;
+ out << "TBoolColumn(";
+ out << "values=" << to_string(values);
+ out << ", " << "nulls=" << to_string(nulls);
+ out << ")";
+}
+
+
+TByteColumn::~TByteColumn() throw() {
+}
+
+
+void TByteColumn::__set_values(const std::vector<int8_t> & val) {
+ this->values = val;
+}
+
+void TByteColumn::__set_nulls(const std::string& val) {
+ this->nulls = val;
+}
+
+uint32_t TByteColumn::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+ bool isset_values = false;
+ bool isset_nulls = false;
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case 1:
+ if (ftype == ::apache::thrift::protocol::T_LIST) {
+ {
+ this->values.clear();
+ uint32_t _size93;
+ ::apache::thrift::protocol::TType _etype96;
+ xfer += iprot->readListBegin(_etype96, _size93);
+ this->values.resize(_size93);
+ uint32_t _i97;
+ for (_i97 = 0; _i97 < _size93; ++_i97)
+ {
+ xfer += iprot->readByte(this->values[_i97]);
+ }
+ xfer += iprot->readListEnd();
+ }
+ isset_values = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readBinary(this->nulls);
+ isset_nulls = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ if (!isset_values)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ if (!isset_nulls)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ return xfer;
+}
+
+uint32_t TByteColumn::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+ xfer += oprot->writeStructBegin("TByteColumn");
+
+ xfer += oprot->writeFieldBegin("values", ::apache::thrift::protocol::T_LIST, 1);
+ {
+ xfer += oprot->writeListBegin(::apache::thrift::protocol::T_BYTE, static_cast<uint32_t>(this->values.size()));
+ std::vector<int8_t> ::const_iterator _iter98;
+ for (_iter98 = this->values.begin(); _iter98 != this->values.end(); ++_iter98)
+ {
+ xfer += oprot->writeByte((*_iter98));
+ }
+ xfer += oprot->writeListEnd();
+ }
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("nulls", ::apache::thrift::protocol::T_STRING, 2);
+ xfer += oprot->writeBinary(this->nulls);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+void swap(TByteColumn &a, TByteColumn &b) {
+ using ::std::swap;
+ swap(a.values, b.values);
+ swap(a.nulls, b.nulls);
+}
+
+TByteColumn::TByteColumn(const TByteColumn& other99) {
+ values = other99.values;
+ nulls = other99.nulls;
+}
+TByteColumn& TByteColumn::operator=(const TByteColumn& other100) {
+ values = other100.values;
+ nulls = other100.nulls;
+ return *this;
+}
+void TByteColumn::printTo(std::ostream& out) const {
+ using ::apache::thrift::to_string;
+ out << "TByteColumn(";
+ out << "values=" << to_string(values);
+ out << ", " << "nulls=" << to_string(nulls);
+ out << ")";
+}
+
+
+TI16Column::~TI16Column() throw() {
+}
+
+
+void TI16Column::__set_values(const std::vector<int16_t> & val) {
+ this->values = val;
+}
+
+void TI16Column::__set_nulls(const std::string& val) {
+ this->nulls = val;
+}
+
+uint32_t TI16Column::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+ bool isset_values = false;
+ bool isset_nulls = false;
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case 1:
+ if (ftype == ::apache::thrift::protocol::T_LIST) {
+ {
+ this->values.clear();
+ uint32_t _size101;
+ ::apache::thrift::protocol::TType _etype104;
+ xfer += iprot->readListBegin(_etype104, _size101);
+ this->values.resize(_size101);
+ uint32_t _i105;
+ for (_i105 = 0; _i105 < _size101; ++_i105)
+ {
+ xfer += iprot->readI16(this->values[_i105]);
+ }
+ xfer += iprot->readListEnd();
+ }
+ isset_values = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readBinary(this->nulls);
+ isset_nulls = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ if (!isset_values)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ if (!isset_nulls)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ return xfer;
+}
+
+uint32_t TI16Column::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+ xfer += oprot->writeStructBegin("TI16Column");
+
+ xfer += oprot->writeFieldBegin("values", ::apache::thrift::protocol::T_LIST, 1);
+ {
+ xfer += oprot->writeListBegin(::apache::thrift::protocol::T_I16, static_cast<uint32_t>(this->values.size()));
+ std::vector<int16_t> ::const_iterator _iter106;
+ for (_iter106 = this->values.begin(); _iter106 != this->values.end(); ++_iter106)
+ {
+ xfer += oprot->writeI16((*_iter106));
+ }
+ xfer += oprot->writeListEnd();
+ }
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("nulls", ::apache::thrift::protocol::T_STRING, 2);
+ xfer += oprot->writeBinary(this->nulls);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+void swap(TI16Column &a, TI16Column &b) {
+ using ::std::swap;
+ swap(a.values, b.values);
+ swap(a.nulls, b.nulls);
+}
+
+TI16Column::TI16Column(const TI16Column& other107) {
+ values = other107.values;
+ nulls = other107.nulls;
+}
+TI16Column& TI16Column::operator=(const TI16Column& other108) {
+ values = other108.values;
+ nulls = other108.nulls;
+ return *this;
+}
+void TI16Column::printTo(std::ostream& out) const {
+ using ::apache::thrift::to_string;
+ out << "TI16Column(";
+ out << "values=" << to_string(values);
+ out << ", " << "nulls=" << to_string(nulls);
+ out << ")";
+}
+
+
+TI32Column::~TI32Column() throw() {
+}
+
+
+void TI32Column::__set_values(const std::vector<int32_t> & val) {
+ this->values = val;
+}
+
+void TI32Column::__set_nulls(const std::string& val) {
+ this->nulls = val;
+}
+
+uint32_t TI32Column::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+ bool isset_values = false;
+ bool isset_nulls = false;
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case 1:
+ if (ftype == ::apache::thrift::protocol::T_LIST) {
+ {
+ this->values.clear();
+ uint32_t _size109;
+ ::apache::thrift::protocol::TType _etype112;
+ xfer += iprot->readListBegin(_etype112, _size109);
+ this->values.resize(_size109);
+ uint32_t _i113;
+ for (_i113 = 0; _i113 < _size109; ++_i113)
+ {
+ xfer += iprot->readI32(this->values[_i113]);
+ }
+ xfer += iprot->readListEnd();
+ }
+ isset_values = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readBinary(this->nulls);
+ isset_nulls = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ if (!isset_values)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ if (!isset_nulls)
+ throw TProtocolException(TProtocolException::INVALID_DATA);
+ return xfer;
+}
+
+uint32_t TI32Column::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+ xfer += oprot->writeStructBegin("TI32Column");
+
+ xfer += oprot->writeFieldBegin("values", ::apache::thrift::protocol::T_LIST, 1);
+ {
+ xfer += oprot->writeListBegin(::apache::thrift::protocol::T_I32, static_cast<uint32_t>(this->values.size()));
+ std::vector<int32_t> ::const_iterator _iter114;
+ for (_iter114 = this->values.begin(); _iter114 != this->values.end(); ++_iter114)
+ {
+ xfer += oprot->writeI32((*_iter114));
+ }
+ xfer += oprot->writeListEnd();
+ }
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("nulls", ::apache::thrift::protocol::T_STRING, 2);
+ xfer += oprot->writeBinary(this->nulls);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+void swap(TI32Column &a, TI32Column &b) {
+ using ::std::swap;
+ swap(a.values, b.values);
+ swap(a.nulls, b.nulls);
+}
+
+TI32Column::TI32Column(const TI32Column& other115) {
+ values = other115.values;
+ nulls = other115.nulls;
+}
+TI32Column& TI32Column::operator=(const TI32Column& other116) {
+ values = other116.values;
+ nulls = other116.nulls;
+ return *this;
+}
+void TI32Column::printTo(std::ostream& out) const {
+ using ::apache::thrift::to_string;
+ out << "TI32Column(";
+ out << "values=" << to_string(values);
+ out << ", " << "nulls=" << to_string(nulls);
+ out << ")";
+}
+
+
+TI64Column::~TI64Column() throw() {
+}
+
+
+void TI64Column::__set_values(const std::vector<int64_t> & val) {
+ this->values = val;
+}
+
+void TI64Column::__set_nulls(const std::string& val) {
+ this->nulls = val;
+}
+
+uint32_t TI64Column::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ apache::thrift::protocol::TInputRecursionTracker track

<TRUNCATED>

Search Discussions

Discussion Posts

Previous

Follow ups

Related Discussions

Discussion Navigation
viewthread | post
posts ‹ prev | 96 of 102 | next ›
Discussion Overview
groupcommits @
categorieshive, hadoop
postedJan 8, '16 at 12:19a
activeJan 11, '16 at 8:25a
posts102
users1
websitehive.apache.org

1 user in discussion

Vgumashta: 102 posts

People

Translate

site design / logo © 2021 Grokbase