http://git-wip-us.apache.org/repos/asf/hive/blob/42216997/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 index 86eeea3..742cfdc 100644 --- a/service/src/gen/thrift/gen-cpp/TCLIService_types.cpp +++ b/service/src/gen/thrift/gen-cpp/TCLIService_types.cpp @@ -1,5 +1,5 @@ /** - * Autogenerated by Thrift Compiler (0.9.0) + * Autogenerated by Thrift Compiler (0.9.2) * * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING * @generated @@ -7,6 +7,9 @@ #include "TCLIService_types.h" #include <algorithm> +#include <ostream> + +#include <thrift/TToString.h> namespace apache { namespace hive { namespace service { namespace cli { namespace thrift { @@ -262,6 +265,21 @@ const char* _kTFetchOrientationNames[] = { }; 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; +} + const char* TTypeQualifierValue::ascii_fingerprint = "A7801670116150C65ACA43E6F679BA79"; const uint8_t TTypeQualifierValue::binary_fingerprint[16] = {0xA7,0x80,0x16,0x70,0x11,0x61,0x50,0xC6,0x5A,0xCA,0x43,0xE6,0xF6,0x79,0xBA,0x79}; @@ -315,6 +333,7 @@ uint32_t TTypeQualifierValue::read(::apache::thrift::protocol::TProtocol* iprot) uint32_t TTypeQualifierValue::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; + oprot->incrementRecursionDepth(); xfer += oprot->writeStructBegin("TTypeQualifierValue"); if (this->__isset.i32Value) { @@ -329,6 +348,7 @@ uint32_t TTypeQualifierValue::write(::apache::thrift::protocol::TProtocol* oprot } xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); + oprot->decrementRecursionDepth(); return xfer; } @@ -339,6 +359,35 @@ void swap(TTypeQualifierValue &a, TTypeQualifierValue &b) { 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; +} +std::ostream& operator<<(std::ostream& out, const TTypeQualifierValue& obj) { + using apache::thrift::to_string; + out << "TTypeQualifierValue("; + out << "i32Value="; (obj.__isset.i32Value ? (out << to_string(obj.i32Value)) : (out << "<null>")); + out << ", " << "stringValue="; (obj.__isset.stringValue ? (out << to_string(obj.stringValue)) : (out << "<null>")); + out << ")"; + return out; +} + + +TTypeQualifiers::~TTypeQualifiers() throw() { +} + + +void TTypeQualifiers::__set_qualifiers(const std::map<std::string, TTypeQualifierValue> & val) { + this->qualifiers = val; +} + const char* TTypeQualifiers::ascii_fingerprint = "6C72981CFA989214285648FA8C196C47"; const uint8_t TTypeQualifiers::binary_fingerprint[16] = {0x6C,0x72,0x98,0x1C,0xFA,0x98,0x92,0x14,0x28,0x56,0x48,0xFA,0x8C,0x19,0x6C,0x47}; @@ -367,17 +416,17 @@ uint32_t TTypeQualifiers::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_MAP) { { this->qualifiers.clear(); - uint32_t _size0; - ::apache::thrift::protocol::TType _ktype1; - ::apache::thrift::protocol::TType _vtype2; - xfer += iprot->readMapBegin(_ktype1, _vtype2, _size0); - uint32_t _i4; - for (_i4 = 0; _i4 < _size0; ++_i4) + 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 _key5; - xfer += iprot->readString(_key5); - TTypeQualifierValue& _val6 = this->qualifiers[_key5]; - xfer += _val6.read(iprot); + std::string _key7; + xfer += iprot->readString(_key7); + TTypeQualifierValue& _val8 = this->qualifiers[_key7]; + xfer += _val8.read(iprot); } xfer += iprot->readMapEnd(); } @@ -402,16 +451,17 @@ uint32_t TTypeQualifiers::read(::apache::thrift::protocol::TProtocol* iprot) { uint32_t TTypeQualifiers::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; + oprot->incrementRecursionDepth(); 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 _iter7; - for (_iter7 = this->qualifiers.begin(); _iter7 != this->qualifiers.end(); ++_iter7) + std::map<std::string, TTypeQualifierValue> ::const_iterator _iter9; + for (_iter9 = this->qualifiers.begin(); _iter9 != this->qualifiers.end(); ++_iter9) { - xfer += oprot->writeString(_iter7->first); - xfer += _iter7->second.write(oprot); + xfer += oprot->writeString(_iter9->first); + xfer += _iter9->second.write(oprot); } xfer += oprot->writeMapEnd(); } @@ -419,6 +469,7 @@ uint32_t TTypeQualifiers::write(::apache::thrift::protocol::TProtocol* oprot) co xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); + oprot->decrementRecursionDepth(); return xfer; } @@ -427,6 +478,35 @@ void swap(TTypeQualifiers &a, TTypeQualifiers &b) { swap(a.qualifiers, b.qualifiers); } +TTypeQualifiers::TTypeQualifiers(const TTypeQualifiers& other10) { + qualifiers = other10.qualifiers; +} +TTypeQualifiers& TTypeQualifiers::operator=(const TTypeQualifiers& other11) { + qualifiers = other11.qualifiers; + return *this; +} +std::ostream& operator<<(std::ostream& out, const TTypeQualifiers& obj) { + using apache::thrift::to_string; + out << "TTypeQualifiers("; + out << "qualifiers=" << to_string(obj.qualifiers); + out << ")"; + return 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; +} + const char* TPrimitiveTypeEntry::ascii_fingerprint = "755674F6A5C8EB47868686AE386FBC1C"; const uint8_t TPrimitiveTypeEntry::binary_fingerprint[16] = {0x75,0x56,0x74,0xF6,0xA5,0xC8,0xEB,0x47,0x86,0x86,0x86,0xAE,0x38,0x6F,0xBC,0x1C}; @@ -453,9 +533,9 @@ uint32_t TPrimitiveTypeEntry::read(::apache::thrift::protocol::TProtocol* iprot) { case 1: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast8; - xfer += iprot->readI32(ecast8); - this->type = (TTypeId::type)ecast8; + int32_t ecast12; + xfer += iprot->readI32(ecast12); + this->type = (TTypeId::type)ecast12; isset_type = true; } else { xfer += iprot->skip(ftype); @@ -485,6 +565,7 @@ uint32_t TPrimitiveTypeEntry::read(::apache::thrift::protocol::TProtocol* iprot) uint32_t TPrimitiveTypeEntry::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; + oprot->incrementRecursionDepth(); xfer += oprot->writeStructBegin("TPrimitiveTypeEntry"); xfer += oprot->writeFieldBegin("type", ::apache::thrift::protocol::T_I32, 1); @@ -498,6 +579,7 @@ uint32_t TPrimitiveTypeEntry::write(::apache::thrift::protocol::TProtocol* oprot } xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); + oprot->decrementRecursionDepth(); return xfer; } @@ -508,6 +590,35 @@ void swap(TPrimitiveTypeEntry &a, TPrimitiveTypeEntry &b) { 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; +} +std::ostream& operator<<(std::ostream& out, const TPrimitiveTypeEntry& obj) { + using apache::thrift::to_string; + out << "TPrimitiveTypeEntry("; + out << "type=" << to_string(obj.type); + out << ", " << "typeQualifiers="; (obj.__isset.typeQualifiers ? (out << to_string(obj.typeQualifiers)) : (out << "<null>")); + out << ")"; + return out; +} + + +TArrayTypeEntry::~TArrayTypeEntry() throw() { +} + + +void TArrayTypeEntry::__set_objectTypePtr(const TTypeEntryPtr val) { + this->objectTypePtr = val; +} + const char* TArrayTypeEntry::ascii_fingerprint = "E86CACEB22240450EDCBEFC3A83970E4"; const uint8_t TArrayTypeEntry::binary_fingerprint[16] = {0xE8,0x6C,0xAC,0xEB,0x22,0x24,0x04,0x50,0xED,0xCB,0xEF,0xC3,0xA8,0x39,0x70,0xE4}; @@ -556,6 +667,7 @@ uint32_t TArrayTypeEntry::read(::apache::thrift::protocol::TProtocol* iprot) { uint32_t TArrayTypeEntry::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; + oprot->incrementRecursionDepth(); xfer += oprot->writeStructBegin("TArrayTypeEntry"); xfer += oprot->writeFieldBegin("objectTypePtr", ::apache::thrift::protocol::T_I32, 1); @@ -564,6 +676,7 @@ uint32_t TArrayTypeEntry::write(::apache::thrift::protocol::TProtocol* oprot) co xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); + oprot->decrementRecursionDepth(); return xfer; } @@ -572,6 +685,34 @@ void swap(TArrayTypeEntry &a, TArrayTypeEntry &b) { swap(a.objectTypePtr, b.objectTypePtr); } +TArrayTypeEntry::TArrayTypeEntry(const TArrayTypeEntry& other15) { + objectTypePtr = other15.objectTypePtr; +} +TArrayTypeEntry& TArrayTypeEntry::operator=(const TArrayTypeEntry& other16) { + objectTypePtr = other16.objectTypePtr; + return *this; +} +std::ostream& operator<<(std::ostream& out, const TArrayTypeEntry& obj) { + using apache::thrift::to_string; + out << "TArrayTypeEntry("; + out << "objectTypePtr=" << to_string(obj.objectTypePtr); + out << ")"; + return out; +} + + +TMapTypeEntry::~TMapTypeEntry() throw() { +} + + +void TMapTypeEntry::__set_keyTypePtr(const TTypeEntryPtr val) { + this->keyTypePtr = val; +} + +void TMapTypeEntry::__set_valueTypePtr(const TTypeEntryPtr val) { + this->valueTypePtr = val; +} + const char* TMapTypeEntry::ascii_fingerprint = "989D1F1AE8D148D5E2119FFEC4BBBEE3"; const uint8_t TMapTypeEntry::binary_fingerprint[16] = {0x98,0x9D,0x1F,0x1A,0xE8,0xD1,0x48,0xD5,0xE2,0x11,0x9F,0xFE,0xC4,0xBB,0xBE,0xE3}; @@ -631,6 +772,7 @@ uint32_t TMapTypeEntry::read(::apache::thrift::protocol::TProtocol* iprot) { uint32_t TMapTypeEntry::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; + oprot->incrementRecursionDepth(); xfer += oprot->writeStructBegin("TMapTypeEntry"); xfer += oprot->writeFieldBegin("keyTypePtr", ::apache::thrift::protocol::T_I32, 1); @@ -643,6 +785,7 @@ uint32_t TMapTypeEntry::write(::apache::thrift::protocol::TProtocol* oprot) cons xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); + oprot->decrementRecursionDepth(); return xfer; } @@ -652,6 +795,33 @@ void swap(TMapTypeEntry &a, TMapTypeEntry &b) { 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; +} +std::ostream& operator<<(std::ostream& out, const TMapTypeEntry& obj) { + using apache::thrift::to_string; + out << "TMapTypeEntry("; + out << "keyTypePtr=" << to_string(obj.keyTypePtr); + out << ", " << "valueTypePtr=" << to_string(obj.valueTypePtr); + out << ")"; + return out; +} + + +TStructTypeEntry::~TStructTypeEntry() throw() { +} + + +void TStructTypeEntry::__set_nameToTypePtr(const std::map<std::string, TTypeEntryPtr> & val) { + this->nameToTypePtr = val; +} + const char* TStructTypeEntry::ascii_fingerprint = "91F548CA159B4AB4291F5741AC161402"; const uint8_t TStructTypeEntry::binary_fingerprint[16] = {0x91,0xF5,0x48,0xCA,0x15,0x9B,0x4A,0xB4,0x29,0x1F,0x57,0x41,0xAC,0x16,0x14,0x02}; @@ -680,17 +850,17 @@ uint32_t TStructTypeEntry::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_MAP) { { this->nameToTypePtr.clear(); - uint32_t _size9; - ::apache::thrift::protocol::TType _ktype10; - ::apache::thrift::protocol::TType _vtype11; - xfer += iprot->readMapBegin(_ktype10, _vtype11, _size9); - uint32_t _i13; - for (_i13 = 0; _i13 < _size9; ++_i13) + 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 _key14; - xfer += iprot->readString(_key14); - TTypeEntryPtr& _val15 = this->nameToTypePtr[_key14]; - xfer += iprot->readI32(_val15); + std::string _key24; + xfer += iprot->readString(_key24); + TTypeEntryPtr& _val25 = this->nameToTypePtr[_key24]; + xfer += iprot->readI32(_val25); } xfer += iprot->readMapEnd(); } @@ -715,16 +885,17 @@ uint32_t TStructTypeEntry::read(::apache::thrift::protocol::TProtocol* iprot) { uint32_t TStructTypeEntry::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; + oprot->incrementRecursionDepth(); 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 _iter16; - for (_iter16 = this->nameToTypePtr.begin(); _iter16 != this->nameToTypePtr.end(); ++_iter16) + std::map<std::string, TTypeEntryPtr> ::const_iterator _iter26; + for (_iter26 = this->nameToTypePtr.begin(); _iter26 != this->nameToTypePtr.end(); ++_iter26) { - xfer += oprot->writeString(_iter16->first); - xfer += oprot->writeI32(_iter16->second); + xfer += oprot->writeString(_iter26->first); + xfer += oprot->writeI32(_iter26->second); } xfer += oprot->writeMapEnd(); } @@ -732,6 +903,7 @@ uint32_t TStructTypeEntry::write(::apache::thrift::protocol::TProtocol* oprot) c xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); + oprot->decrementRecursionDepth(); return xfer; } @@ -740,6 +912,30 @@ void swap(TStructTypeEntry &a, TStructTypeEntry &b) { swap(a.nameToTypePtr, b.nameToTypePtr); } +TStructTypeEntry::TStructTypeEntry(const TStructTypeEntry& other27) { + nameToTypePtr = other27.nameToTypePtr; +} +TStructTypeEntry& TStructTypeEntry::operator=(const TStructTypeEntry& other28) { + nameToTypePtr = other28.nameToTypePtr; + return *this; +} +std::ostream& operator<<(std::ostream& out, const TStructTypeEntry& obj) { + using apache::thrift::to_string; + out << "TStructTypeEntry("; + out << "nameToTypePtr=" << to_string(obj.nameToTypePtr); + out << ")"; + return out; +} + + +TUnionTypeEntry::~TUnionTypeEntry() throw() { +} + + +void TUnionTypeEntry::__set_nameToTypePtr(const std::map<std::string, TTypeEntryPtr> & val) { + this->nameToTypePtr = val; +} + const char* TUnionTypeEntry::ascii_fingerprint = "91F548CA159B4AB4291F5741AC161402"; const uint8_t TUnionTypeEntry::binary_fingerprint[16] = {0x91,0xF5,0x48,0xCA,0x15,0x9B,0x4A,0xB4,0x29,0x1F,0x57,0x41,0xAC,0x16,0x14,0x02}; @@ -768,17 +964,17 @@ uint32_t TUnionTypeEntry::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_MAP) { { this->nameToTypePtr.clear(); - uint32_t _size17; - ::apache::thrift::protocol::TType _ktype18; - ::apache::thrift::protocol::TType _vtype19; - xfer += iprot->readMapBegin(_ktype18, _vtype19, _size17); - uint32_t _i21; - for (_i21 = 0; _i21 < _size17; ++_i21) + 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 _key22; - xfer += iprot->readString(_key22); - TTypeEntryPtr& _val23 = this->nameToTypePtr[_key22]; - xfer += iprot->readI32(_val23); + std::string _key34; + xfer += iprot->readString(_key34); + TTypeEntryPtr& _val35 = this->nameToTypePtr[_key34]; + xfer += iprot->readI32(_val35); } xfer += iprot->readMapEnd(); } @@ -803,16 +999,17 @@ uint32_t TUnionTypeEntry::read(::apache::thrift::protocol::TProtocol* iprot) { uint32_t TUnionTypeEntry::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; + oprot->incrementRecursionDepth(); 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 _iter24; - for (_iter24 = this->nameToTypePtr.begin(); _iter24 != this->nameToTypePtr.end(); ++_iter24) + std::map<std::string, TTypeEntryPtr> ::const_iterator _iter36; + for (_iter36 = this->nameToTypePtr.begin(); _iter36 != this->nameToTypePtr.end(); ++_iter36) { - xfer += oprot->writeString(_iter24->first); - xfer += oprot->writeI32(_iter24->second); + xfer += oprot->writeString(_iter36->first); + xfer += oprot->writeI32(_iter36->second); } xfer += oprot->writeMapEnd(); } @@ -820,6 +1017,7 @@ uint32_t TUnionTypeEntry::write(::apache::thrift::protocol::TProtocol* oprot) co xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); + oprot->decrementRecursionDepth(); return xfer; } @@ -828,6 +1026,30 @@ void swap(TUnionTypeEntry &a, TUnionTypeEntry &b) { swap(a.nameToTypePtr, b.nameToTypePtr); } +TUnionTypeEntry::TUnionTypeEntry(const TUnionTypeEntry& other37) { + nameToTypePtr = other37.nameToTypePtr; +} +TUnionTypeEntry& TUnionTypeEntry::operator=(const TUnionTypeEntry& other38) { + nameToTypePtr = other38.nameToTypePtr; + return *this; +} +std::ostream& operator<<(std::ostream& out, const TUnionTypeEntry& obj) { + using apache::thrift::to_string; + out << "TUnionTypeEntry("; + out << "nameToTypePtr=" << to_string(obj.nameToTypePtr); + out << ")"; + return out; +} + + +TUserDefinedTypeEntry::~TUserDefinedTypeEntry() throw() { +} + + +void TUserDefinedTypeEntry::__set_typeClassName(const std::string& val) { + this->typeClassName = val; +} + const char* TUserDefinedTypeEntry::ascii_fingerprint = "EFB929595D312AC8F305D5A794CFEDA1"; const uint8_t TUserDefinedTypeEntry::binary_fingerprint[16] = {0xEF,0xB9,0x29,0x59,0x5D,0x31,0x2A,0xC8,0xF3,0x05,0xD5,0xA7,0x94,0xCF,0xED,0xA1}; @@ -876,6 +1098,7 @@ uint32_t TUserDefinedTypeEntry::read(::apache::thrift::protocol::TProtocol* ipro uint32_t TUserDefinedTypeEntry::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; + oprot->incrementRecursionDepth(); xfer += oprot->writeStructBegin("TUserDefinedTypeEntry"); xfer += oprot->writeFieldBegin("typeClassName", ::apache::thrift::protocol::T_STRING, 1); @@ -884,6 +1107,7 @@ uint32_t TUserDefinedTypeEntry::write(::apache::thrift::protocol::TProtocol* opr xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); + oprot->decrementRecursionDepth(); return xfer; } @@ -892,6 +1116,50 @@ void swap(TUserDefinedTypeEntry &a, TUserDefinedTypeEntry &b) { swap(a.typeClassName, b.typeClassName); } +TUserDefinedTypeEntry::TUserDefinedTypeEntry(const TUserDefinedTypeEntry& other39) { + typeClassName = other39.typeClassName; +} +TUserDefinedTypeEntry& TUserDefinedTypeEntry::operator=(const TUserDefinedTypeEntry& other40) { + typeClassName = other40.typeClassName; + return *this; +} +std::ostream& operator<<(std::ostream& out, const TUserDefinedTypeEntry& obj) { + using apache::thrift::to_string; + out << "TUserDefinedTypeEntry("; + out << "typeClassName=" << to_string(obj.typeClassName); + out << ")"; + return 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; +} + const char* TTypeEntry::ascii_fingerprint = "2FE56D9097E325DAA7E933738C6D325F"; const uint8_t TTypeEntry::binary_fingerprint[16] = {0x2F,0xE5,0x6D,0x90,0x97,0xE3,0x25,0xDA,0xA7,0xE9,0x33,0x73,0x8C,0x6D,0x32,0x5F}; @@ -977,6 +1245,7 @@ uint32_t TTypeEntry::read(::apache::thrift::protocol::TProtocol* iprot) { uint32_t TTypeEntry::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; + oprot->incrementRecursionDepth(); xfer += oprot->writeStructBegin("TTypeEntry"); xfer += oprot->writeFieldBegin("primitiveEntry", ::apache::thrift::protocol::T_STRUCT, 1); @@ -1005,6 +1274,7 @@ uint32_t TTypeEntry::write(::apache::thrift::protocol::TProtocol* oprot) const { xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); + oprot->decrementRecursionDepth(); return xfer; } @@ -1019,6 +1289,47 @@ void swap(TTypeEntry &a, TTypeEntry &b) { 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; +} +std::ostream& operator<<(std::ostream& out, const TTypeEntry& obj) { + using apache::thrift::to_string; + out << "TTypeEntry("; + out << "primitiveEntry=" << to_string(obj.primitiveEntry); + out << ", " << "arrayEntry=" << to_string(obj.arrayEntry); + out << ", " << "mapEntry=" << to_string(obj.mapEntry); + out << ", " << "structEntry=" << to_string(obj.structEntry); + out << ", " << "unionEntry=" << to_string(obj.unionEntry); + out << ", " << "userDefinedTypeEntry=" << to_string(obj.userDefinedTypeEntry); + out << ")"; + return out; +} + + +TTypeDesc::~TTypeDesc() throw() { +} + + +void TTypeDesc::__set_types(const std::vector<TTypeEntry> & val) { + this->types = val; +} + const char* TTypeDesc::ascii_fingerprint = "90B3C5A0B73419A84E85E0E48C452AA5"; const uint8_t TTypeDesc::binary_fingerprint[16] = {0x90,0xB3,0xC5,0xA0,0xB7,0x34,0x19,0xA8,0x4E,0x85,0xE0,0xE4,0x8C,0x45,0x2A,0xA5}; @@ -1047,14 +1358,14 @@ uint32_t TTypeDesc::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->types.clear(); - uint32_t _size25; - ::apache::thrift::protocol::TType _etype28; - xfer += iprot->readListBegin(_etype28, _size25); - this->types.resize(_size25); - uint32_t _i29; - for (_i29 = 0; _i29 < _size25; ++_i29) + 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[_i29].read(iprot); + xfer += this->types[_i47].read(iprot); } xfer += iprot->readListEnd(); } @@ -1079,15 +1390,16 @@ uint32_t TTypeDesc::read(::apache::thrift::protocol::TProtocol* iprot) { uint32_t TTypeDesc::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; + oprot->incrementRecursionDepth(); 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 _iter30; - for (_iter30 = this->types.begin(); _iter30 != this->types.end(); ++_iter30) + std::vector<TTypeEntry> ::const_iterator _iter48; + for (_iter48 = this->types.begin(); _iter48 != this->types.end(); ++_iter48) { - xfer += (*_iter30).write(oprot); + xfer += (*_iter48).write(oprot); } xfer += oprot->writeListEnd(); } @@ -1095,6 +1407,7 @@ uint32_t TTypeDesc::write(::apache::thrift::protocol::TProtocol* oprot) const { xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); + oprot->decrementRecursionDepth(); return xfer; } @@ -1103,6 +1416,43 @@ void swap(TTypeDesc &a, TTypeDesc &b) { swap(a.types, b.types); } +TTypeDesc::TTypeDesc(const TTypeDesc& other49) { + types = other49.types; +} +TTypeDesc& TTypeDesc::operator=(const TTypeDesc& other50) { + types = other50.types; + return *this; +} +std::ostream& operator<<(std::ostream& out, const TTypeDesc& obj) { + using apache::thrift::to_string; + out << "TTypeDesc("; + out << "types=" << to_string(obj.types); + out << ")"; + return 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; +} + const char* TColumnDesc::ascii_fingerprint = "EABED9009D5FCABFCA65612069F2A849"; const uint8_t TColumnDesc::binary_fingerprint[16] = {0xEA,0xBE,0xD9,0x00,0x9D,0x5F,0xCA,0xBF,0xCA,0x65,0x61,0x20,0x69,0xF2,0xA8,0x49}; @@ -1181,6 +1531,7 @@ uint32_t TColumnDesc::read(::apache::thrift::protocol::TProtocol* iprot) { uint32_t TColumnDesc::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; + oprot->incrementRecursionDepth(); xfer += oprot->writeStructBegin("TColumnDesc"); xfer += oprot->writeFieldBegin("columnName", ::apache::thrift::protocol::T_STRING, 1); @@ -1202,6 +1553,7 @@ uint32_t TColumnDesc::write(::apache::thrift::protocol::TProtocol* oprot) const } xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); + oprot->decrementRecursionDepth(); return xfer; } @@ -1214,6 +1566,41 @@ void swap(TColumnDesc &a, TColumnDesc &b) { 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; +} +std::ostream& operator<<(std::ostream& out, const TColumnDesc& obj) { + using apache::thrift::to_string; + out << "TColumnDesc("; + out << "columnName=" << to_string(obj.columnName); + out << ", " << "typeDesc=" << to_string(obj.typeDesc); + out << ", " << "position=" << to_string(obj.position); + out << ", " << "comment="; (obj.__isset.comment ? (out << to_string(obj.comment)) : (out << "<null>")); + out << ")"; + return out; +} + + +TTableSchema::~TTableSchema() throw() { +} + + +void TTableSchema::__set_columns(const std::vector<TColumnDesc> & val) { + this->columns = val; +} + const char* TTableSchema::ascii_fingerprint = "7A1811E49313E5977107FC667B20E39D"; const uint8_t TTableSchema::binary_fingerprint[16] = {0x7A,0x18,0x11,0xE4,0x93,0x13,0xE5,0x97,0x71,0x07,0xFC,0x66,0x7B,0x20,0xE3,0x9D}; @@ -1242,14 +1629,14 @@ uint32_t TTableSchema::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->columns.clear(); - uint32_t _size31; - ::apache::thrift::protocol::TType _etype34; - xfer += iprot->readListBegin(_etype34, _size31); - this->columns.resize(_size31); - uint32_t _i35; - for (_i35 = 0; _i35 < _size31; ++_i35) + 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[_i35].read(iprot); + xfer += this->columns[_i57].read(iprot); } xfer += iprot->readListEnd(); } @@ -1274,15 +1661,16 @@ uint32_t TTableSchema::read(::apache::thrift::protocol::TProtocol* iprot) { uint32_t TTableSchema::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; + oprot->incrementRecursionDepth(); 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 _iter36; - for (_iter36 = this->columns.begin(); _iter36 != this->columns.end(); ++_iter36) + std::vector<TColumnDesc> ::const_iterator _iter58; + for (_iter58 = this->columns.begin(); _iter58 != this->columns.end(); ++_iter58) { - xfer += (*_iter36).write(oprot); + xfer += (*_iter58).write(oprot); } xfer += oprot->writeListEnd(); } @@ -1290,6 +1678,7 @@ uint32_t TTableSchema::write(::apache::thrift::protocol::TProtocol* oprot) const xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); + oprot->decrementRecursionDepth(); return xfer; } @@ -1298,6 +1687,31 @@ void swap(TTableSchema &a, TTableSchema &b) { swap(a.columns, b.columns); } +TTableSchema::TTableSchema(const TTableSchema& other59) { + columns = other59.columns; +} +TTableSchema& TTableSchema::operator=(const TTableSchema& other60) { + columns = other60.columns; + return *this; +} +std::ostream& operator<<(std::ostream& out, const TTableSchema& obj) { + using apache::thrift::to_string; + out << "TTableSchema("; + out << "columns=" << to_string(obj.columns); + out << ")"; + return out; +} + + +TBoolValue::~TBoolValue() throw() { +} + + +void TBoolValue::__set_value(const bool val) { + this->value = val; +__isset.value = true; +} + const char* TBoolValue::ascii_fingerprint = "BF054652DEF86253C2BEE7D947F167DD"; const uint8_t TBoolValue::binary_fingerprint[16] = {0xBF,0x05,0x46,0x52,0xDE,0xF8,0x62,0x53,0xC2,0xBE,0xE7,0xD9,0x47,0xF1,0x67,0xDD}; @@ -1343,6 +1757,7 @@ uint32_t TBoolValue::read(::apache::thrift::protocol::TProtocol* iprot) { uint32_t TBoolValue::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; + oprot->incrementRecursionDepth(); xfer += oprot->writeStructBegin("TBoolValue"); if (this->__isset.value) { @@ -1352,6 +1767,7 @@ uint32_t TBoolValue::write(::apache::thrift::protocol::TProtocol* oprot) const { } xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); + oprot->decrementRecursionDepth(); return xfer; } @@ -1361,6 +1777,33 @@ void swap(TBoolValue &a, TBoolValue &b) { 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; +} +std::ostream& operator<<(std::ostream& out, const TBoolValue& obj) { + using apache::thrift::to_string; + out << "TBoolValue("; + out << "value="; (obj.__isset.value ? (out << to_string(obj.value)) : (out << "<null>")); + out << ")"; + return out; +} + + +TByteValue::~TByteValue() throw() { +} + + +void TByteValue::__set_value(const int8_t val) { + this->value = val; +__isset.value = true; +} + const char* TByteValue::ascii_fingerprint = "9C15298ACB5D04AEA9B52D5DDE6F9208"; const uint8_t TByteValue::binary_fingerprint[16] = {0x9C,0x15,0x29,0x8A,0xCB,0x5D,0x04,0xAE,0xA9,0xB5,0x2D,0x5D,0xDE,0x6F,0x92,0x08}; @@ -1406,6 +1849,7 @@ uint32_t TByteValue::read(::apache::thrift::protocol::TProtocol* iprot) { uint32_t TByteValue::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; + oprot->incrementRecursionDepth(); xfer += oprot->writeStructBegin("TByteValue"); if (this->__isset.value) { @@ -1415,6 +1859,7 @@ uint32_t TByteValue::write(::apache::thrift::protocol::TProtocol* oprot) const { } xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); + oprot->decrementRecursionDepth(); return xfer; } @@ -1424,6 +1869,33 @@ void swap(TByteValue &a, TByteValue &b) { 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; +} +std::ostream& operator<<(std::ostream& out, const TByteValue& obj) { + using apache::thrift::to_string; + out << "TByteValue("; + out << "value="; (obj.__isset.value ? (out << to_string(obj.value)) : (out << "<null>")); + out << ")"; + return out; +} + + +TI16Value::~TI16Value() throw() { +} + + +void TI16Value::__set_value(const int16_t val) { + this->value = val; +__isset.value = true; +} + const char* TI16Value::ascii_fingerprint = "5DAC9C51C7E1106BF936FC71860BE9D5"; const uint8_t TI16Value::binary_fingerprint[16] = {0x5D,0xAC,0x9C,0x51,0xC7,0xE1,0x10,0x6B,0xF9,0x36,0xFC,0x71,0x86,0x0B,0xE9,0xD5}; @@ -1469,6 +1941,7 @@ uint32_t TI16Value::read(::apache::thrift::protocol::TProtocol* iprot) { uint32_t TI16Value::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; + oprot->incrementRecursionDepth(); xfer += oprot->writeStructBegin("TI16Value"); if (this->__isset.value) { @@ -1478,6 +1951,7 @@ uint32_t TI16Value::write(::apache::thrift::protocol::TProtocol* oprot) const { } xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); + oprot->decrementRecursionDepth(); return xfer; } @@ -1487,6 +1961,33 @@ void swap(TI16Value &a, TI16Value &b) { 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; +} +std::ostream& operator<<(std::ostream& out, const TI16Value& obj) { + using apache::thrift::to_string; + out << "TI16Value("; + out << "value="; (obj.__isset.value ? (out << to_string(obj.value)) : (out << "<null>")); + out << ")"; + return out; +} + + +TI32Value::~TI32Value() throw() { +} + + +void TI32Value::__set_value(const int32_t val) { + this->value = val; +__isset.value = true; +} + const char* TI32Value::ascii_fingerprint = "E7A96B151330359E84C0A3AC91BCBACD"; const uint8_t TI32Value::binary_fingerprint[16] = {0xE7,0xA9,0x6B,0x15,0x13,0x30,0x35,0x9E,0x84,0xC0,0xA3,0xAC,0x91,0xBC,0xBA,0xCD}; @@ -1532,6 +2033,7 @@ uint32_t TI32Value::read(::apache::thrift::protocol::TProtocol* iprot) { uint32_t TI32Value::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; + oprot->incrementRecursionDepth(); xfer += oprot->writeStructBegin("TI32Value"); if (this->__isset.value) { @@ -1541,6 +2043,7 @@ uint32_t TI32Value::write(::apache::thrift::protocol::TProtocol* oprot) const { } xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); + oprot->decrementRecursionDepth(); return xfer; } @@ -1550,6 +2053,33 @@ void swap(TI32Value &a, TI32Value &b) { 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; +} +std::ostream& operator<<(std::ostream& out, const TI32Value& obj) { + using apache::thrift::to_string; + out << "TI32Value("; + out << "value="; (obj.__isset.value ? (out << to_string(obj.value)) : (out << "<null>")); + out << ")"; + return out; +} + + +TI64Value::~TI64Value() throw() { +} + + +void TI64Value::__set_value(const int64_t val) { + this->value = val; +__isset.value = true; +} + const char* TI64Value::ascii_fingerprint = "148F3AAAC1D9859963D5E800D187BF26"; const uint8_t TI64Value::binary_fingerprint[16] = {0x14,0x8F,0x3A,0xAA,0xC1,0xD9,0x85,0x99,0x63,0xD5,0xE8,0x00,0xD1,0x87,0xBF,0x26}; @@ -1595,6 +2125,7 @@ uint32_t TI64Value::read(::apache::thrift::protocol::TProtocol* iprot) { uint32_t TI64Value::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; + oprot->incrementRecursionDepth(); xfer += oprot->writeStructBegin("TI64Value"); if (this->__isset.value) { @@ -1604,6 +2135,7 @@ uint32_t TI64Value::write(::apache::thrift::protocol::TProtocol* oprot) const { } xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); + oprot->decrementRecursionDepth(); return xfer; } @@ -1613,6 +2145,33 @@ void swap(TI64Value &a, TI64Value &b) { 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; +} +std::ostream& operator<<(std::ostream& out, const TI64Value& obj) { + using apache::thrift::to_string; + out << "TI64Value("; + out << "value="; (obj.__isset.value ? (out << to_string(obj.value)) : (out << "<null>")); + out << ")"; + return out; +} + + +TDoubleValue::~TDoubleValue() throw() { +} + + +void TDoubleValue::__set_value(const double val) { + this->value = val; +__isset.value = true; +} + const char* TDoubleValue::ascii_fingerprint = "3586E570A474C4A8603B4FF74903B3A6"; const uint8_t TDoubleValue::binary_fingerprint[16] = {0x35,0x86,0xE5,0x70,0xA4,0x74,0xC4,0xA8,0x60,0x3B,0x4F,0xF7,0x49,0x03,0xB3,0xA6}; @@ -1658,6 +2217,7 @@ uint32_t TDoubleValue::read(::apache::thrift::protocol::TProtocol* iprot) { uint32_t TDoubleValue::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; + oprot->incrementRecursionDepth(); xfer += oprot->writeStructBegin("TDoubleValue"); if (this->__isset.value) { @@ -1667,6 +2227,7 @@ uint32_t TDoubleValue::write(::apache::thrift::protocol::TProtocol* oprot) const } xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); + oprot->decrementRecursionDepth(); return xfer; } @@ -1676,6 +2237,33 @@ void swap(TDoubleValue &a, TDoubleValue &b) { 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; +} +std::ostream& operator<<(std::ostream& out, const TDoubleValue& obj) { + using apache::thrift::to_string; + out << "TDoubleValue("; + out << "value="; (obj.__isset.value ? (out << to_string(obj.value)) : (out << "<null>")); + out << ")"; + return out; +} + + +TStringValue::~TStringValue() throw() { +} + + +void TStringValue::__set_value(const std::string& val) { + this->value = val; +__isset.value = true; +} + const char* TStringValue::ascii_fingerprint = "66E694018C17E5B65A59AE8F55CCA3CD"; const uint8_t TStringValue::binary_fingerprint[16] = {0x66,0xE6,0x94,0x01,0x8C,0x17,0xE5,0xB6,0x5A,0x59,0xAE,0x8F,0x55,0xCC,0xA3,0xCD}; @@ -1721,6 +2309,7 @@ uint32_t TStringValue::read(::apache::thrift::protocol::TProtocol* iprot) { uint32_t TStringValue::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; + oprot->incrementRecursionDepth(); xfer += oprot->writeStructBegin("TStringValue"); if (this->__isset.value) { @@ -1730,6 +2319,7 @@ uint32_t TStringValue::write(::apache::thrift::protocol::TProtocol* oprot) const } xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); + oprot->decrementRecursionDepth(); return xfer; } @@ -1739,6 +2329,56 @@ void swap(TStringValue &a, TStringValue &b) { 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; +} +std::ostream& operator<<(std::ostream& out, const TStringValue& obj) { + using apache::thrift::to_string; + out << "TStringValue("; + out << "value="; (obj.__isset.value ? (out << to_string(obj.value)) : (out << "<null>")); + out << ")"; + return 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; +} + const char* TColumnValue::ascii_fingerprint = "C2DDD988447EA7999A8285AA38AAE9AD"; const uint8_t TColumnValue::binary_fingerprint[16] = {0xC2,0xDD,0xD9,0x88,0x44,0x7E,0xA7,0x99,0x9A,0x82,0x85,0xAA,0x38,0xAA,0xE9,0xAD}; @@ -1832,6 +2472,7 @@ uint32_t TColumnValue::read(::apache::thrift::protocol::TProtocol* iprot) { uint32_t TColumnValue::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; + oprot->incrementRecursionDepth(); xfer += oprot->writeStructBegin("TColumnValue"); xfer += oprot->writeFieldBegin("boolVal", ::apache::thrift::protocol::T_STRUCT, 1); @@ -1864,6 +2505,7 @@ uint32_t TColumnValue::write(::apache::thrift::protocol::TProtocol* oprot) const xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); + oprot->decrementRecursionDepth(); return xfer; } @@ -1879,6 +2521,50 @@ void swap(TColumnValue &a, TColumnValue &b) { 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; +} +std::ostream& operator<<(std::ostream& out, const TColumnValue& obj) { + using apache::thrift::to_string; + out << "TColumnValue("; + out << "boolVal=" << to_string(obj.boolVal); + out << ", " << "byteVal=" << to_string(obj.byteVal); + out << ", " << "i16Val=" << to_string(obj.i16Val); + out << ", " << "i32Val=" << to_string(obj.i32Val); + out << ", " << "i64Val=" << to_string(obj.i64Val); + out << ", " << "doubleVal=" << to_string(obj.doubleVal); + out << ", " << "stringVal=" << to_string(obj.stringVal); + out << ")"; + return out; +} + + +TRow::~TRow() throw() { +} + + +void TRow::__set_colVals(const std::vector<TColumnValue> & val) { + this->colVals = val; +} + const char* TRow::ascii_fingerprint = "E73FD1FCA0CA58A669FC3E02FB68D534"; const uint8_t TRow::binary_fingerprint[16] = {0xE7,0x3F,0xD1,0xFC,0xA0,0xCA,0x58,0xA6,0x69,0xFC,0x3E,0x02,0xFB,0x68,0xD5,0x34}; @@ -1907,14 +2593,14 @@ uint32_t TRow::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->colVals.clear(); - uint32_t _size37; - ::apache::thrift::protocol::TType _etype40; - xfer += iprot->readListBegin(_etype40, _size37); - this->colVals.resize(_size37); - uint32_t _i41; - for (_i41 = 0; _i41 < _size37; ++_i41) + 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[_i41].read(iprot); + xfer += this->colVals[_i81].read(iprot); } xfer += iprot->readListEnd(); } @@ -1939,15 +2625,16 @@ uint32_t TRow::read(::apache::thrift::protocol::TProtocol* iprot) { uint32_t TRow::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; + oprot->incrementRecursionDepth(); 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 _iter42; - for (_iter42 = this->colVals.begin(); _iter42 != this->colVals.end(); ++_iter42) + std::vector<TColumnValue> ::const_iterator _iter82; + for (_iter82 = this->colVals.begin(); _iter82 != this->colVals.end(); ++_iter82) { - xfer += (*_iter42).write(oprot); + xfer += (*_iter82).write(oprot); } xfer += oprot->writeListEnd(); } @@ -1955,6 +2642,7 @@ uint32_t TRow::write(::apache::thrift::protocol::TProtocol* oprot) const { xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); + oprot->decrementRecursionDepth(); return xfer; } @@ -1963,15 +2651,43 @@ void swap(TRow &a, TRow &b) { swap(a.colVals, b.colVals); } -const char* TBoolColumn::ascii_fingerprint = "F9058324D96DB7F974D8ACDC01C54219"; -const uint8_t TBoolColumn::binary_fingerprint[16] = {0xF9,0x05,0x83,0x24,0xD9,0x6D,0xB7,0xF9,0x74,0xD8,0xAC,0xDC,0x01,0xC5,0x42,0x19}; +TRow::TRow(const TRow& other83) { + colVals = other83.colVals; +} +TRow& TRow::operator=(const TRow& other84) { + colVals = other84.colVals; + return *this; +} +std::ostream& operator<<(std::ostream& out, const TRow& obj) { + using apache::thrift::to_string; + out << "TRow("; + out << "colVals=" << to_string(obj.colVals); + out << ")"; + return out; +} -uint32_t TBoolColumn::read(::apache::thrift::protocol::TProtocol* iprot) { - uint32_t xfer = 0; - std::string fname; - ::apache::thrift::protocol::TType ftype; - int16_t fid; +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; +} + +const char* TBoolColumn::ascii_fingerprint = "F9058324D96DB7F974D8ACDC01C54219"; +const uint8_t TBoolColumn::binary_fingerprint[16] = {0xF9,0x05,0x83,0x24,0xD9,0x6D,0xB7,0xF9,0x74,0xD8,0xAC,0xDC,0x01,0xC5,0x42,0x19}; + +uint32_t TBoolColumn::read(::apache::thrift::protocol::TProtocol* iprot) { + + uint32_t xfer = 0; + std::string fname; + ::apache::thrift::protocol::TType ftype; + int16_t fid; xfer += iprot->readStructBegin(fname); @@ -1992,14 +2708,14 @@ uint32_t TBoolColumn::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->values.clear(); - uint32_t _size43; - ::apache::thrift::protocol::TType _etype46; - xfer += iprot->readListBegin(_etype46, _size43); - this->values.resize(_size43); - uint32_t _i47; - for (_i47 = 0; _i47 < _size43; ++_i47) + 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[_i47]); + xfer += iprot->readBool(this->values[_i89]); } xfer += iprot->readListEnd(); } @@ -2034,15 +2750,16 @@ uint32_t TBoolColumn::read(::apache::thrift::protocol::TProtocol* iprot) { uint32_t TBoolColumn::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; + oprot->incrementRecursionDepth(); 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 _iter48; - for (_iter48 = this->values.begin(); _iter48 != this->values.end(); ++_iter48) + std::vector<bool> ::const_iterator _iter90; + for (_iter90 = this->values.begin(); _iter90 != this->values.end(); ++_iter90) { - xfer += oprot->writeBool((*_iter48)); + xfer += oprot->writeBool((*_iter90)); } xfer += oprot->writeListEnd(); } @@ -2054,6 +2771,7 @@ uint32_t TBoolColumn::write(::apache::thrift::protocol::TProtocol* oprot) const xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); + oprot->decrementRecursionDepth(); return xfer; } @@ -2063,6 +2781,37 @@ void swap(TBoolColumn &a, TBoolColumn &b) { 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; +} +std::ostream& operator<<(std::ostream& out, const TBoolColumn& obj) { + using apache::thrift::to_string; + out << "TBoolColumn("; + out << "values=" << to_string(obj.values); + out << ", " << "nulls=" << to_string(obj.nulls); + out << ")"; + return 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; +} + const char* TByteColumn::ascii_fingerprint = "1CB300106BAA463A70BB2A2395900F48"; const uint8_t TByteColumn::binary_fingerprint[16] = {0x1C,0xB3,0x00,0x10,0x6B,0xAA,0x46,0x3A,0x70,0xBB,0x2A,0x23,0x95,0x90,0x0F,0x48}; @@ -2092,14 +2841,14 @@ uint32_t TByteColumn::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->values.clear(); - uint32_t _size49; - ::apache::thrift::protocol::TType _etype52; - xfer += iprot->readListBegin(_etype52, _size49); - this->values.resize(_size49); - uint32_t _i53; - for (_i53 = 0; _i53 < _size49; ++_i53) + 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[_i53]); + xfer += iprot->readByte(this->values[_i97]); } xfer += iprot->readListEnd(); } @@ -2134,15 +2883,16 @@ uint32_t TByteColumn::read(::apache::thrift::protocol::TProtocol* iprot) { uint32_t TByteColumn::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; + oprot->incrementRecursionDepth(); 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 _iter54; - for (_iter54 = this->values.begin(); _iter54 != this->values.end(); ++_iter54) + std::vector<int8_t> ::const_iterator _iter98; + for (_iter98 = this->values.begin(); _iter98 != this->values.end(); ++_iter98) { - xfer += oprot->writeByte((*_iter54)); + xfer += oprot->writeByte((*_iter98)); } xfer += oprot->writeListEnd(); } @@ -2154,6 +2904,7 @@ uint32_t TByteColumn::write(::apache::thrift::protocol::TProtocol* oprot) const xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); + oprot->decrementRecursionDepth(); return xfer; } @@ -2163,6 +2914,37 @@ void swap(TByteColumn &a, TByteColumn &b) { 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; +} +std::ostream& operator<<(std::ostream& out, const TByteColumn& obj) { + using apache::thrift::to_string; + out << "TByteColumn("; + out << "values=" << to_string(obj.values); + out << ", " << "nulls=" << to_string(obj.nulls); + out << ")"; + return 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; +} + const char* TI16Column::ascii_fingerprint = "6574CDB1F121C8DB47FB257A3F104BDB"; const uint8_t TI16Column::binary_fingerprint[16] = {0x65,0x74,0xCD,0xB1,0xF1,0x21,0xC8,0xDB,0x47,0xFB,0x25,0x7A,0x3F,0x10,0x4B,0xDB}; @@ -2192,14 +2974,14 @@ uint32_t TI16Column::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->values.clear(); - uint32_t _size55; - ::apache::thrift::protocol::TType _etype58; - xfer += iprot->readListBegin(_etype58, _size55); - this->values.resize(_size55); - uint32_t _i59; - for (_i59 = 0; _i59 < _size55; ++_i59) + 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[_i59]); + xfer += iprot->readI16(this->values[_i105]); } xfer += iprot->readListEnd(); } @@ -2234,15 +3016,16 @@ uint32_t TI16Column::read(::apache::thrift::protocol::TProtocol* iprot) { uint32_t TI16Column::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; + oprot->incrementRecursionDepth(); 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 _iter60; - for (_iter60 = this->values.begin(); _iter60 != this->values.end(); ++_iter60) + std::vector<int16_t> ::const_iterator _iter106; + for (_iter106 = this->values.begin(); _iter106 != this->values.end(); ++_iter106) { - xfer += oprot->writeI16((*_iter60)); + xfer += oprot->writeI16((*_iter106)); } xfer += oprot->writeListEnd(); } @@ -2254,6 +3037,7 @@ uint32_t TI16Column::write(::apache::thrift::protocol::TProtocol* oprot) const { xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); + oprot->decrementRecursionDepth(); return xfer; } @@ -2263,6 +3047,37 @@ void swap(TI16Column &a, TI16Column &b) { 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; +} +std::ostream& operator<<(std::ostream& out, const TI16Column& obj) { + using apache::thrift::to_string; + out << "TI16Column("; + out << "values=" << to_string(obj.values); + out << ", " << "nulls=" << to_string(obj.nulls); + out << ")"; + return 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; +} + const char* TI32Column::ascii_fingerprint = "CCCCE89C7E9DA10280F5663700677313"; const uint8_t TI32Column::binary_fingerprint[16] = {0xCC,0xCC,0xE8,0x9C,0x7E,0x9D,0xA1,0x02,0x80,0xF5,0x66,0x37,0x00,0x67,0x73,0x13}; @@ -2292,14 +3107,14 @@ uint32_t TI32Column::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->values.clear(); - uint32_t _size61; - ::apache::thrift::protocol::TType _etype64; - xfer += iprot->readListBegin(_etype64, _size61); - this->values.resize(_size61); - uint32_t _i65; - for (_i65 = 0; _i65 < _size61; ++_i65) + 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[_i65]); + xfer += iprot->readI32(this->values[_i113]); } xfer += iprot->readListEnd(); } @@ -2334,15 +3149,16 @@ uint32_t TI32Column::read(::apache::thrift::protocol::TProtocol* iprot) { uint32_t TI32Column::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; + oprot->incrementRecursionDepth(); 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 _iter66; - for (_iter66 = this->values.begin(); _iter66 != this->values.end(); ++_iter66) + std::vector<int32_t> ::const_iterator _iter114; + for (_iter114 = this->values.begin(); _iter114 != this->values.end(); ++_iter114) { - xfer += oprot->writeI32((*_iter66)); + xfer += oprot->writeI32((*_iter114)); } xfer += oprot->writeListEnd(); } @@ -2354,6 +3170,7 @@ uint32_t TI32Column::write(::apache::thrift::protocol::TProtocol* oprot) const { xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); + oprot->decrementRecursionDepth(); return xfer; } @@ -2363,6 +3180,37 @@ void swap(TI32Column &a, TI32Column &b) { 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; +} +std::ostream& operator<<(std::ostream& out, const TI32Column& obj) { + using apache::thrift::to_string; + out << "TI32Column("; + out << "values=" << to_string(obj.values); + out << ", " << "nulls=" << to_string(obj.nulls); + out << ")"; + return 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; +} + const char* TI64Column::ascii_fingerprint = "925353917FC0AF87976A2338011F5A31"; const uint8_t TI64Column::binary_fingerprint[16] = {0x92,0x53,0x53,0x91,0x7F,0xC0,0xAF,0x87,0x97,0x6A,0x23,0x38,0x01,0x1F,0x5A,0x31}; @@ -2392,14 +3240,14 @@ uint32_t TI64Column::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->values.clear(); - uint32_t _size67; - ::apache::thrift::protocol::TType _etype70; - xfer += iprot->readListBegin(_etype70, _size67); - this->values.resize(_size67); - uint32_t _i71; - for (_i71 = 0; _i71 < _size67; ++_i71) + uint32_t _size117; + ::apache::thrift::protocol::TType _etype120; + xfer += iprot->readListBegin(_etype120, _size117); + this->values.resize(_size117); + uint32_t _i121; + for (_i121 = 0; _i121 < _size117; ++_i121) { - xfer += iprot->readI64(this->values[_i71]); + xfer += iprot->readI64(this->values[_i121]); } xfer += iprot->readListEnd(); } @@ -2434,15 +3282,16 @@ uint32_t TI64Column::read(::apache::thrift::protocol::TProtocol* iprot) { uint32_t TI64Column::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; + oprot->incrementRecursionDepth(); xfer += oprot->writeStructBegin("TI64Column"); xfer += oprot->writeFieldBegin("values", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_I64, static_cast<uint32_t>(this->values.size())); - std::vector<int64_t> ::const_iterator _iter72; - for (_iter72 = this->values.begin(); _iter72 != this->values.end(); ++_iter72) + std::vector<int64_t> ::const_iterator _iter122; + for (_iter122 = this->values.begin(); _iter122 != this->values.end(); ++_iter122) { - xfer += oprot->writeI64((*_iter72)); + xfer += oprot->writeI64((*_iter122)); } xfer += oprot->writeListEnd(); } @@ -2454,6 +3303,7 @@ uint32_t TI64Column::write(::apache::thrift::protocol::TProtocol* oprot) const { xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); + oprot->decrementRecursionDepth(); return xfer; } @@ -2463,6 +3313,37 @@ void swap(TI64Column &a, TI64Column &b) { swap(a.nulls, b.nulls); } +TI64Column::TI64Column(const TI64Column& other123) { + values = other123.values; + nulls = other123.nulls; +} +TI64Column& TI64Column::operator=(const TI64Column& other124) { + values = other124.values; + nulls = other124.nulls; + return *this; +} +std::ostream& operator<<(std::ostream& out, const TI64Column& obj) { + using apache::thrift::to_string; + out << "TI64Column("; + out << "values=" << to_string(obj.values); + out << ", " << "nulls=" << to_string(obj.nulls); + out << ")"; + return out; +} + + +TDoubleColumn::~TDoubleColumn() throw() { +} + + +void TDoubleColumn::__set_values(const std::vector<double> & val) { + this->values = val; +} + +void TDoubleColumn::__set_nulls(const std::string& val) { + this->nulls = val; +} + const char* TDoubleColumn::ascii_fingerprint = "8FF1C050A8D7FD247AEB23CD71539C09"; const uint8_t TDoubleColumn::binary_fingerprint[16] = {0x8F,0xF1,0xC0,0x50,0xA8,0xD7,0xFD,0x24,0x7A,0xEB,0x23,0xCD,0x71,0x53,0x9C,0x09}; @@ -2492,14 +3373,14 @@ uint32_t TDoubleColumn::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->values.clear(); - uint32_t _size73; - ::apache::thrift::protocol::TType _etype76; - xfer += iprot->readListBegin(_etype76, _size73); - this->values.resize(_size73); - uint32_t _i77; - for (_i77 = 0; _i77 < _size73; ++_i77) + uint32_t _size125; + ::apache::thrift::protocol::TType _etype128; + xfer += iprot->readListBegin(_etype128, _size125); + this->values.resize(_size125); + uint32_t _i129; + for (_i129 = 0; _i129 < _size125; ++_i129) { - xfer += iprot->readDouble(this->values[_i77]); + xfer += iprot->readDouble(this->values[_i129]); } xfer += iprot->readListEnd(); } @@ -2534,15 +3415,16 @@ uint32_t TDoubleColumn::read(::apache::thrift::protocol::TProtocol* iprot) { uint32_t TDoubleColumn::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; + oprot->incrementRecursionDepth(); xfer += oprot->writeStructBegin("TDoubleColumn"); xfer += oprot->writeFieldBegin("values", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_DOUBLE, static_cast<uint32_t>(this->values.size())); - std::vector<double> ::const_iterator _iter78; - for (_iter78 = this->values.begin(); _iter78 != this->values.end(); ++_iter78) + std::vector<double> ::const_iterator _iter130; + for (_iter130 = this->values.begin(); _iter130 != this->values.end(); ++_iter130) { - xfer += oprot->writeDouble((*_iter78)); + xfer += oprot->writeDouble((*_iter130)); } xfer += oprot->writeListEnd(); } @@ -2554,6 +3436,7 @@ uint32_t TDoubleColumn::write(::apache::thrift::protocol::TProtocol* oprot) cons xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); + oprot->decrementRecursionDepth(); return xfer; } @@ -2563,6 +3446,37 @@ void swap(TDoubleColumn &a, TDoubleColumn &b) { swap(a.nulls, b.nulls); } +TDoubleColumn::TDoubleColumn(const TDoubleColumn& other131) { + values = other131.values; + nulls = other131.nulls; +} +TDoubleColumn& TDoubleColumn::operator=(const TDoubleColumn& other132) { + values = other132.values; + nulls = other132.nulls; + return *this; +} +std::ostream& operator<<(std::ostream& out, const TDoubleColumn& obj) { + using apache::thrift::to_string; + out << "TDoubleColumn("; + out << "values=" << to_string(obj.values); + out << ", " << "nulls=" << to_string(obj.nulls); + out << ")"; + return out; +} + + +TStringColumn::~TStringColumn() throw() { +} + + +void TStringColumn::__set_values(const std::vector<std::string> & val) { + this->values = val; +} + +void TStringColumn::__set_nulls(const std::string& val) { + this->nulls = val; +} + const char* TStringColumn::ascii_fingerprint = "BE556BF7091B2DABBA1863D5E458B15F"; const uint8_t TStringColumn::binary_fingerprint[16] = {0xBE,0x55,0x6B,0xF7,0x09,0x1B,0x2D,0xAB,0xBA,0x18,0x63,0xD5,0xE4,0x58,0xB1,0x5F}; @@ -2592,14 +3506,14 @@ uint32_t TStringColumn::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->values.clear(); - uint32_t _size79; - ::apache::thrift::protocol::TType _etype82; - xfer += iprot->readListBegin(_etype82, _size79); - this->values.resize(_size79); - uint32_t _i83; - for (_i83 = 0; _i83 < _size79; ++_i83) + uint32_t _size133; + ::apache::thrift::protocol::TType _etype136; + xfer += iprot->readListBegin(_etype136, _size133); + this->values.resize(_size133); + uint32_t _i137; + for (_i137 = 0; _i137 < _size133; ++_i137) { - xfer += iprot->readString(this->values[_i83]); + xfer += iprot->readString(this->values[_i137]); } xfer += iprot->readListEnd(); } @@ -2634,15 +3548,16 @@ uint32_t TStringColumn::read(::apache::thrift::protocol::TProtocol* iprot) { uint32_t TStringColumn::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; + oprot->incrementRecursionDepth(); xfer += oprot->writeStructBegin("TStringColumn"); xfer += oprot->writeFieldBegin("values", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->values.size())); - std::vector<std::string> ::const_iterator _iter84; - for (_iter84 = this->values.begin(); _iter84 != this->values.end(); ++_iter84) + std::vector<std::string> ::const_iterator _iter138; + for (_iter138 = this->values.begin(); _iter138 != this->values.end(); ++_iter138) { - xfer += oprot->writeString((*_iter84)); + xfer += oprot->writeString((*_iter138)); } xfer += oprot->writeListEnd(); } @@ -2654,6 +3569,7 @@ uint32_t TStringColumn::write(::apache::thrift::protocol::TProtocol* oprot) cons xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); + oprot->decrementRecursionDepth(); return xfer; } @@ -2663,6 +3579,37 @@ void swap(TStringColumn &a, TStringColumn &b) { swap(a.nulls, b.nulls); } +TStringColumn::TStringColumn(const TStringColumn& other139) { + values = other139.values; + nulls = other139.nulls; +} +TStringColumn& TStringColumn::operator=(const TStringColumn& other140) { + values = other140.values; + nulls = other140.nulls; + return *this; +} +std::ostream& operator<<(std::ostream& out, const TStringColumn& obj) { + using apache::thrift::to_string; + out << "TStringColumn("; + out << "values=" << to_string(obj.values); + out << ", " << "nulls=" << to_string(obj.nulls); + out << ")"; + return out; +} + + +TBinaryColumn::~TBinaryColumn() throw() { +} + + +void TBinaryColumn::__set_values(const std::vector<std::string> & val) { + this->values = val; +} + +void TBinaryColumn::__set_nulls(const std::string& val) { + this->nulls = val; +} + const char* TBinaryColumn::ascii_fingerprint = "BE556BF7091B2DABBA1863D5E458B15F"; const uint8_t TBinaryColumn::binary_fingerprint[16] = {0xBE,0x55,0x6B,0xF7,0x09,0x1B,0x2D,0xAB,0xBA,0x18,0x63,0xD5,0xE4,0x58,0xB1,0x5F}; @@ -2692,14 +3639,14 @@ uint32_t TBinaryColumn::read(::apache::thrift::protocol::TProtocol* iprot) { 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) + uint32_t _size141; + ::apache::thrift::protocol::TType _etype144; + xfer += iprot->readListBegin(_etype144, _size141); + this->values.resize(_size141); + uint32_t _i145; + for (_i145 = 0; _i145 < _size141; ++_i145) { - xfer += iprot->readBinary(this->values[_i89]); + xfer += iprot->readBinary(this->values[_i145]); } xfer += iprot->readListEnd(); } @@ -2734,15 +3681,16 @@ uint32_t TBinaryColumn::read(::apache::thrift::protocol::TProtocol* iprot) { uint32_t TBinaryColumn::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; + oprot->incrementRecursionDepth(); xfer += oprot->writeStructBegin("TBinaryColumn"); xfer += oprot->writeFieldBegin("values", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->values.size())); - std::vector<std::string> ::const_iterator _iter90; - for (_iter90 = this->values.begin(); _iter90 != this->values.end(); ++_iter90) + std::vector<std::string> ::const_iterator _iter146; + for (_iter146 = this->values.begin(); _iter146 != this->values.end(); ++_iter146) { - xfer += oprot->writeBinary((*_iter90)); + xfer += oprot->writeBinary((*_iter146)); } xfer += oprot->writeListEnd(); } @@ -2754,6 +3702,7 @@ uint32_t TBinaryColumn::write(::apache::thrift::protocol::TProtocol* oprot) cons xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); + oprot->decrementRecursionDepth(); return xfer; } @@ -2763,6 +3712,61 @@ void swap(TBinaryColumn &a, TBinaryColumn &b) { swap(a.nulls, b.nulls); } +TBinaryColumn::TBinaryColumn(const TBinaryColumn& other147) { + values = other147.values; + nulls = other147.nulls; +} +TBinaryColumn& TBinaryColumn::operator=(const TBinaryColumn& other148) { + values = other148.values; + nulls = other148.nulls; + return *this; +} +std::ostream& operator<<(std::ostream& out, const TBinaryColumn& obj) { + using apache::thrift::to_string; + out << "TBinaryColumn("; + out << "values=" << to_string(obj.values); + out << ", " << "nulls=" << to_string(obj.nulls); + out << ")"; + return out; +} + + +TColumn::~TColumn() throw() { +} + + +void TColumn::__set_boolVal(const TBoolColumn& val) { + this->boolVal = val; +} + +void TColumn::__set_byteVal(const TByteColumn& val) { + this->byteVal = val; +} + +void TColumn::__set_i16Val(const TI16Column& val) { + this->i16Val = val; +} + +void TColumn::__set_i32Val(const TI32Column& val) { + this->i32Val = val; +} + +void TColumn::__set_i64Val(const TI64Column& val) { + this->i64Val = val; +} + +void TColumn::__set_doubleVal(const TDoubleColumn& val) { + this->doubleVal = val; +} + +void TColumn::__set_stringVal(const TStringColumn& val) { + this->stringVal = val; +} + +void TColumn::__set_binaryVal(const TBinaryColumn& val) { + this->binaryVal = val; +} + const char* TColumn::ascii_fingerprint = "E6ADD10B4CDDE61A19E8878CC7039A17"; const uint8_t TColumn::binary_fingerprint[16] = {0xE6,0xAD,0xD1,0x0B,0x4C,0xDD,0xE6,0x1A,0x19,0xE8,0x87,0x8C,0xC7,0x03,0x9A,0x17}; @@ -2864,6 +3868,7 @@ uint32_t TColumn::read(::apache::thrift::protocol::TProtocol* iprot) { uint32_t TColumn::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; + oprot->incrementRecursionDepth(); xfer += oprot->writeStructBegin("TColumn"); xfer += oprot->writeFieldBegin("boolVal", ::apache::thrift::protocol::T_STRUCT, 1); @@ -2900,6 +3905,7 @@ uint32_t TColumn::write(::apache::thrift::protocol::TProtocol* oprot) const { xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); + oprot->decrementRecursionDepth(); return xfer; } @@ -2916,6 +3922,62 @@ void swap(TColumn &a, TColumn &b) { swap(a.__isset, b.__isset); } +TColumn::TColumn(const TColumn& other149) { + boolVal = other149.boolVal; + byteVal = other149.byteVal; + i16Val = other149.i16Val; + i32Val = other149.i32Val; + i64Val = other149.i64Val; + doubleVal = other149.doubleVal; + stringVal = other149.stringVal; + binaryVal = other149.binaryVal; + __isset = other149.__isset; +} +TColumn& TColumn::operator=(const TColumn& other150) { + boolVal = other150.boolVal; + byteVal = other150.byteVal; + i16Val = other150.i16Val; + i32Val = other150.i32Val; + i64Val = other150.i64Val; + doubleVal = other150.doubleVal; + stringVal = other150.stringVal; + binaryVal = other150.binaryVal; + __isset = other150.__isset; + return *this; +} +std::ostream& operator<<(std::ostream& out, const TColumn& obj) { + using apache::thrift::to_string; + out << "TColumn("; + out << "boolVal=" << to_string(obj.boolVal); + out << ", " << "byteVal=" << to_string(obj.byteVal); + out << ", " << "i16Val=" << to_string(obj.i16Val); + out << ", " << "i32Val=" << to_string(obj.i32Val); + out << ", " << "i64Val=" << to_string(obj.i64Val); + out << ", " << "doubleVal=" << to_string(obj.doubleVal); + out << ", " << "stringVal=" << to_string(obj.stringVal); + out << ", " << "binaryVal=" << to_string(obj.binaryVal); + out << ")"; + return out; +} + + +TRowSet::~TRowSet() throw() { +} + + +void TRowSet::__set_startRowOffset(const int64_t val) { + this->startRowOffset = val; +} + +void TRowSet::__set_rows(const std::vector<TRow> & val) { + this->rows = val; +} + +void TRowSet::__set_columns(const std::vector<TColumn> & val) { + this->columns = val; +__isset.columns = true; +} + const char* TRowSet::ascii_fingerprint = "46DA30A870489C7A58105AE0080DAEBF"; const uint8_t TRowSet::binary_fingerprint[16] = {0x46,0xDA,0x30,0xA8,0x70,0x48,0x9C,0x7A,0x58,0x10,0x5A,0xE0,0x08,0x0D,0xAE,0xBF}; @@ -2953,14 +4015,14 @@ uint32_t TRowSet::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->rows.clear(); - uint32_t _size91; - ::apache::thrift::protocol::TType _etype94; - xfer += iprot->readListBegin(_etype94, _size91); - this->rows.resize(_size91); - uint32_t _i95; - for (_i95 = 0; _i95 < _size91; ++_i95) + uint32_t _size151; + ::apache::thrift::protocol::TType _etype154; + xfer += iprot->readListBegin(_etype154, _size151); + this->rows.resize(_size151); + uint32_t _i155; + for (_i155 = 0; _i155 < _size151; ++_i155) { - xfer += this->rows[_i95].read(iprot); + xfer += this->rows[_i155].read(iprot); } xfer += iprot->readListEnd(); } @@ -2973,14 +4035,14 @@ uint32_t TRowSet::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->columns.clear(); - uint32_t _size96; - ::apache::thrift::protocol::TType _etype99; - xfer += iprot->readListBegin(_etype99, _size96); - this->columns.resize(_size96); - uint32_t _i100; - for (_i100 = 0; _i100 < _size96; ++_i100) + uint32_t _size156; + ::apache::thrift::protocol::TType _etype159; + xfer += iprot->readListBegin(_etype159, _size156); + this->columns.resize(_size156); + uint32_t _i160; + for (_i160 = 0; _i160 < _size156; ++_i160) { - xfer += this->columns[_i100].read(iprot); + xfer += this->columns[_i160].read(iprot); } xfer += iprot->readListEnd(); } @@ -3007,6 +4069,7 @@ uint32_t TRowSet::read(::apache::thrift::protocol::TProtocol* iprot) { uint32_t TRowSet::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; + oprot->incrementRecursionDepth(); xfer += oprot->writeStructBegin("TRowSet"); xfer += oprot->writeFieldBegin("startRowOffset", ::apache::thrift::protocol::T_I64, 1); @@ -3016,10 +4079,10 @@ uint32_t TRowSet::write(::apache::thrift::protocol::TProtocol* oprot) const { xfer += oprot->writeFieldBegin("rows", ::apache::thrift::protocol::T_LIST, 2); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->rows.size())); - std::vector<TRow> ::const_iterator _iter101; - for (_iter101 = this->rows.begin(); _iter101 != this->rows.end(); ++_iter101) + std::vector<TRow> ::const_iterator _iter161; + for (_iter161 = this->rows.begin(); _iter161 != this->rows.end(); ++_iter161) { - xfer += (*_iter101).write(oprot); + xfer += (*_iter161).write(oprot); } xfer += oprot->writeListEnd(); } @@ -3029,10 +4092,10 @@ uint32_t TRowSet::write(::apache::thrift::protocol::TProtocol* oprot) const { xfer += oprot->writeFieldBegin("columns", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->columns.size())); - std::vector<TColumn> ::const_iterator _iter102; - for (_iter102 = this->columns.begin(); _iter102 != this->columns.end(); ++_iter102) + std::vector<TColumn> ::const_iterator _iter162; + for (_iter162 = this->columns.begin(); _iter162 != this->columns.end(); ++_iter162) { - xfer += (*_iter102).write(oprot); + xfer += (*_iter162).write(oprot); } xfer += oprot->writeListEnd(); } @@ -3040,6 +4103,7 @@ uint32_t TRowSet::write(::apache::thrift::protocol::TProtocol* oprot) const { } xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); + oprot->decrementRecursionDepth(); return xfer; } @@ -3051,6 +4115,58 @@ void swap(TRowSet &a, TRowSet &b) { swap(a.__isset, b.__isset); } +TRowSet::TRowSet(const TRowSet& other163) { + startRowOffset = other163.startRowOffset; + rows = other163.rows; + columns = other163.columns; + __isset = other163.__isset; +} +TRowSet& TRowSet::operator=(const TRowSet& other164) { + startRowOffset = other164.startRowOffset; + rows = other164.rows; + columns = other164.columns; + __isset = other164.__isset; + return *this; +} +std::ostream& operator<<(std::ostream& out, const TRowSet& obj) { + using apache::thrift::to_string; + out << "TRowSet("; + out << "startRowOffset=" << to_string(obj.startRowOffset); + out << ", " << "rows=" << to_string(obj.rows); + out << ", " << "columns="; (obj.__isset.columns ? (out << to_string(obj.columns)) : (out << "<null>")); + out << ")"; + return out; +} + + +TStatus::~TStatus() throw() { +} + + +void TStatus::__set_statusCode(const TStatusCode::type val) { + this->statusCode = val; +} + +void TStatus::__set_infoMessages(const std::vector<std::string> & val) { + this->infoMessages = val; +__isset.infoMessages = true; +} + +void TStatus::__set_sqlState(const std::string& val) { + this->sqlState = val; +__isset.sqlState = true; +} + +void TStatus::__set_errorCode(const int32_t val) { + this->errorCode = val; +__isset.errorCode = true; +} + +void TStatus::__set_errorMessage(const std::string& val) { + this->errorMessage = val; +__isset.errorMessage = true; +} + const char* TStatus::ascii_fingerprint = "D5DEF49634A59C615C1B3A6F7D0DADB5"; const uint8_t TStatus::binary_fingerprint[16] = {0xD5,0xDE,0xF4,0x96,0x34,0xA5,0x9C,0x61,0x5C,0x1B,0x3A,0x6F,0x7D,0x0D,0xAD,0xB5}; @@ -3077,9 +4193,9 @@ uint32_t TStatus::read(::apache::thrift::protocol::TProtocol* iprot) { { case 1: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast103; - xfer += iprot->readI32(ecast103); - this->statusCode = (TStatusCode::type)ecast103; + int32_t ecast165; + xfer += iprot->readI32(ecast165); + this->statusCode = (TStatusCode::type)ecast165; isset_statusCode = true; } else { xfer += iprot->skip(ftype); @@ -3089,14 +4205,14 @@ uint32_t TStatus::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->infoMessages.clear(); - uint32_t _size104; - ::apache::thrift::protocol::TType _etype107; - xfer += iprot->readListBegin(_etype107, _size104); - this->infoMessages.resize(_size104); - uint32_t _i108; - for (_i108 = 0; _i108 < _size104; ++_i108) + uint32_t _size166; + ::apache::thrift::protocol::TType _etype169; + xfer += iprot->readListBegin(_etype169, _size166); + this->infoMessages.resize(_size166); + uint32_t _i170; + for (_i170 = 0; _i170 < _size166; ++_i170) { - xfer += iprot->readString(this->infoMessages[_i108]); + xfer += iprot->readString(this->infoMessages[_i170]); } xfer += iprot->readListEnd(); } @@ -3145,6 +4261,7 @@ uint32_t TStatus::read(::apache::thrift::protocol::TProtocol* iprot) { uint32_t TStatus::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; + oprot->incrementRecursionDepth(); xfer += oprot->writeStructBegin("TStatus"); xfer += oprot->writeFieldBegin("statusCode", ::apache::thrift::protocol::T_I32, 1); @@ -3155,10 +4272,10 @@ uint32_t TStatus::write(::apache::thrift::protocol::TProtocol* oprot) const { xfer += oprot->writeFieldBegin("infoMessages", ::apache::thrift::protocol::T_LIST, 2); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->infoMessages.size())); - std::vector<std::string> ::const_iterator _iter109; - for (_iter109 = this->infoMessages.begin(); _iter109 != this->infoMessages.end(); ++_iter109) + std::vector<std::string> ::const_iterator _iter171; + for (_iter171 = this->infoMessages.begin(); _iter171 != this->infoMessages.end(); ++_iter171) { - xfer += oprot->writeString((*_iter109)); + xfer += oprot->writeString((*_iter171)); } xfer += oprot->writeListEnd(); } @@ -3181,6 +4298,7 @@ uint32_t TStatus::write(::apache::thrift::protocol::TProtocol* oprot) const { } xfer += oprot->writeFieldStop(); xfer += oprot->writeStructEnd(); + oprot->decrementRecursionDepth(); return xfer; } @@ -3194,6 +4312,48 @@ void swap(TStatus &a, TStatus &b) { swap(a.__isset, b.__isset); } +TStatus::TStatus(const TStatus& other172) { + statusCode = other172.statusCode; + infoMessages = other172.infoMessages; + sqlState = other172.sqlState; + errorCode = other172.errorCode; + errorMessage = other172.errorMessage; + __isset = other172.__isset; +} +TStatus& TStatus::operator=(const TStatus& other173) { + statusCode = other173.statusCode; + infoMessages = other173.infoMessages; + sqlState = other173.sqlState; + errorCode = other173.errorCode; + errorMessage = other173.errorMessage; + __isset = other173.__isset; + return *this; +} +std::ostream& operator<<(std::ostream& out, const TStatus& obj) { + using apache::thrift::to_string; + out << "TStatus("; + out << "statusCode=" << to_string(obj.statusCode); + out << ", " << "infoMessages="; (obj.__isset.infoMessages ? (out << to_string(obj.infoMessages)) : (out << "<null>")); + out << ", " << "sqlState="; (obj.__isset.sqlState ? (out << to_string(obj.sqlState)) : (out << "<null>")); + out << ", " << "errorCode="; (obj.__isset.errorCode ? (out << to_string(obj.errorCode)) : (out << "<null>")); + out << ", " << "errorMessage="; (obj.__isset.errorMessage ? (out << to_string(obj.errorMessage)) : (out << "<null>")); + out << ")"; + return out; +} + + +THandleIdentifier::~THandleIdentifier() throw() { +} + + +void THandleIdentifier::__set_guid(const std::string& val) { + this->guid = val; +} + +void THandleIdentifier::__set_secret(const std::string& val) { + this->secret = val; +} + const char* THandleIdentifier::ascii_fingerprint = "07A9615F837F7D0A952B595DD
<TRUNCATED>
