FAQ
http://git-wip-us.apache.org/repos/asf/hive/blob/2542f5cc/service/src/gen/thrift/gen-cpp/TCLIService_types.cpp
----------------------------------------------------------------------
diff --git a/service/src/gen/thrift/gen-cpp/TCLIService_types.cpp b/service/src/gen/thrift/gen-cpp/TCLIService_types.cpp
deleted file mode 100644
index b852379..0000000
--- a/service/src/gen/thrift/gen-cpp/TCLIService_types.cpp
+++ /dev/null
@@ -1,9231 +0,0 @@
-/**
- * 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 cli { 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 tracker(*iprot);


<TRUNCATED>

Search Discussions

Discussion Posts

Previous

Follow ups

Related Discussions

Discussion Navigation
viewthread | post
posts ‹ prev | 17 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