http://git-wip-us.apache.org/repos/asf/accumulo/blob/3af75fc6/proxy/src/main/cpp/proxy_types.cpp ---------------------------------------------------------------------- diff --git a/proxy/src/main/cpp/proxy_types.cpp b/proxy/src/main/cpp/proxy_types.cpp index a055b48..8c443e0 100644 --- a/proxy/src/main/cpp/proxy_types.cpp +++ b/proxy/src/main/cpp/proxy_types.cpp @@ -15,7 +15,7 @@ * limitations under the License. */ /** - * Autogenerated by Thrift Compiler (0.9.1) + * Autogenerated by Thrift Compiler (0.9.3) * * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING * @generated @@ -23,6 +23,9 @@ #include "proxy_types.h" #include <algorithm> +#include <ostream> + +#include <thrift/TToString.h> namespace accumulo { @@ -190,11 +193,35 @@ const char* _kTimeTypeNames[] = { }; const std::map<int, const char*> _TimeType_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(2, _kTimeTypeValues, _kTimeTypeNames), ::apache::thrift::TEnumIterator(-1, NULL, NULL)); -const char* Key::ascii_fingerprint = "91151A432E03F5E8564877B5194B48E2"; -const uint8_t Key::binary_fingerprint[16] = {0x91,0x15,0x1A,0x43,0x2E,0x03,0xF5,0xE8,0x56,0x48,0x77,0xB5,0x19,0x4B,0x48,0xE2}; + +Key::~Key() throw() { +} + + +void Key::__set_row(const std::string& val) { + this->row = val; +} + +void Key::__set_colFamily(const std::string& val) { + this->colFamily = val; +} + +void Key::__set_colQualifier(const std::string& val) { + this->colQualifier = val; +} + +void Key::__set_colVisibility(const std::string& val) { + this->colVisibility = val; +} + +void Key::__set_timestamp(const int64_t val) { + this->timestamp = val; +__isset.timestamp = true; +} uint32_t Key::read(::apache::thrift::protocol::TProtocol* iprot) { + apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; std::string fname; ::apache::thrift::protocol::TType ftype; @@ -267,6 +294,7 @@ uint32_t Key::read(::apache::thrift::protocol::TProtocol* iprot) { uint32_t Key::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); xfer += oprot->writeStructBegin("Key"); xfer += oprot->writeFieldBegin("row", ::apache::thrift::protocol::T_STRING, 1); @@ -305,11 +333,70 @@ void swap(Key &a, Key &b) { swap(a.__isset, b.__isset); } -const char* ColumnUpdate::ascii_fingerprint = "65CC1863F7DDC1DE75B9EAF9E2DC0D1F"; -const uint8_t ColumnUpdate::binary_fingerprint[16] = {0x65,0xCC,0x18,0x63,0xF7,0xDD,0xC1,0xDE,0x75,0xB9,0xEA,0xF9,0xE2,0xDC,0x0D,0x1F}; +Key::Key(const Key& other0) { + row = other0.row; + colFamily = other0.colFamily; + colQualifier = other0.colQualifier; + colVisibility = other0.colVisibility; + timestamp = other0.timestamp; + __isset = other0.__isset; +} +Key& Key::operator=(const Key& other1) { + row = other1.row; + colFamily = other1.colFamily; + colQualifier = other1.colQualifier; + colVisibility = other1.colVisibility; + timestamp = other1.timestamp; + __isset = other1.__isset; + return *this; +} +void Key::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "Key("; + out << "row=" << to_string(row); + out << ", " << "colFamily=" << to_string(colFamily); + out << ", " << "colQualifier=" << to_string(colQualifier); + out << ", " << "colVisibility=" << to_string(colVisibility); + out << ", " << "timestamp="; (__isset.timestamp ? (out << to_string(timestamp)) : (out << "<null>")); + out << ")"; +} + + +ColumnUpdate::~ColumnUpdate() throw() { +} + + +void ColumnUpdate::__set_colFamily(const std::string& val) { + this->colFamily = val; +} + +void ColumnUpdate::__set_colQualifier(const std::string& val) { + this->colQualifier = val; +} + +void ColumnUpdate::__set_colVisibility(const std::string& val) { + this->colVisibility = val; +__isset.colVisibility = true; +} + +void ColumnUpdate::__set_timestamp(const int64_t val) { + this->timestamp = val; +__isset.timestamp = true; +} + +void ColumnUpdate::__set_value(const std::string& val) { + this->value = val; +__isset.value = true; +} + +void ColumnUpdate::__set_deleteCell(const bool val) { + this->deleteCell = val; +__isset.deleteCell = true; +} uint32_t ColumnUpdate::read(::apache::thrift::protocol::TProtocol* iprot) { + apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; std::string fname; ::apache::thrift::protocol::TType ftype; @@ -390,6 +477,7 @@ uint32_t ColumnUpdate::read(::apache::thrift::protocol::TProtocol* iprot) { uint32_t ColumnUpdate::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); xfer += oprot->writeStructBegin("ColumnUpdate"); xfer += oprot->writeFieldBegin("colFamily", ::apache::thrift::protocol::T_STRING, 1); @@ -436,11 +524,53 @@ void swap(ColumnUpdate &a, ColumnUpdate &b) { swap(a.__isset, b.__isset); } -const char* DiskUsage::ascii_fingerprint = "D26F4F5E2867D41CF7E0391263932D6B"; -const uint8_t DiskUsage::binary_fingerprint[16] = {0xD2,0x6F,0x4F,0x5E,0x28,0x67,0xD4,0x1C,0xF7,0xE0,0x39,0x12,0x63,0x93,0x2D,0x6B}; +ColumnUpdate::ColumnUpdate(const ColumnUpdate& other2) { + colFamily = other2.colFamily; + colQualifier = other2.colQualifier; + colVisibility = other2.colVisibility; + timestamp = other2.timestamp; + value = other2.value; + deleteCell = other2.deleteCell; + __isset = other2.__isset; +} +ColumnUpdate& ColumnUpdate::operator=(const ColumnUpdate& other3) { + colFamily = other3.colFamily; + colQualifier = other3.colQualifier; + colVisibility = other3.colVisibility; + timestamp = other3.timestamp; + value = other3.value; + deleteCell = other3.deleteCell; + __isset = other3.__isset; + return *this; +} +void ColumnUpdate::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "ColumnUpdate("; + out << "colFamily=" << to_string(colFamily); + out << ", " << "colQualifier=" << to_string(colQualifier); + out << ", " << "colVisibility="; (__isset.colVisibility ? (out << to_string(colVisibility)) : (out << "<null>")); + out << ", " << "timestamp="; (__isset.timestamp ? (out << to_string(timestamp)) : (out << "<null>")); + out << ", " << "value="; (__isset.value ? (out << to_string(value)) : (out << "<null>")); + out << ", " << "deleteCell="; (__isset.deleteCell ? (out << to_string(deleteCell)) : (out << "<null>")); + out << ")"; +} + + +DiskUsage::~DiskUsage() throw() { +} + + +void DiskUsage::__set_tables(const std::vector<std::string> & val) { + this->tables = val; +} + +void DiskUsage::__set_usage(const int64_t val) { + this->usage = val; +} uint32_t DiskUsage::read(::apache::thrift::protocol::TProtocol* iprot) { + apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; std::string fname; ::apache::thrift::protocol::TType ftype; @@ -463,14 +593,14 @@ uint32_t DiskUsage::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->tables.clear(); - uint32_t _size0; - ::apache::thrift::protocol::TType _etype3; - xfer += iprot->readListBegin(_etype3, _size0); - this->tables.resize(_size0); - uint32_t _i4; - for (_i4 = 0; _i4 < _size0; ++_i4) + uint32_t _size4; + ::apache::thrift::protocol::TType _etype7; + xfer += iprot->readListBegin(_etype7, _size4); + this->tables.resize(_size4); + uint32_t _i8; + for (_i8 = 0; _i8 < _size4; ++_i8) { - xfer += iprot->readString(this->tables[_i4]); + xfer += iprot->readString(this->tables[_i8]); } xfer += iprot->readListEnd(); } @@ -501,15 +631,16 @@ uint32_t DiskUsage::read(::apache::thrift::protocol::TProtocol* iprot) { uint32_t DiskUsage::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); xfer += oprot->writeStructBegin("DiskUsage"); xfer += oprot->writeFieldBegin("tables", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->tables.size())); - std::vector<std::string> ::const_iterator _iter5; - for (_iter5 = this->tables.begin(); _iter5 != this->tables.end(); ++_iter5) + std::vector<std::string> ::const_iterator _iter9; + for (_iter9 = this->tables.begin(); _iter9 != this->tables.end(); ++_iter9) { - xfer += oprot->writeString((*_iter5)); + xfer += oprot->writeString((*_iter9)); } xfer += oprot->writeListEnd(); } @@ -531,11 +662,41 @@ void swap(DiskUsage &a, DiskUsage &b) { swap(a.__isset, b.__isset); } -const char* KeyValue::ascii_fingerprint = "0D0CA44F233F983E00E94228C31ABBD4"; -const uint8_t KeyValue::binary_fingerprint[16] = {0x0D,0x0C,0xA4,0x4F,0x23,0x3F,0x98,0x3E,0x00,0xE9,0x42,0x28,0xC3,0x1A,0xBB,0xD4}; +DiskUsage::DiskUsage(const DiskUsage& other10) { + tables = other10.tables; + usage = other10.usage; + __isset = other10.__isset; +} +DiskUsage& DiskUsage::operator=(const DiskUsage& other11) { + tables = other11.tables; + usage = other11.usage; + __isset = other11.__isset; + return *this; +} +void DiskUsage::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "DiskUsage("; + out << "tables=" << to_string(tables); + out << ", " << "usage=" << to_string(usage); + out << ")"; +} + + +KeyValue::~KeyValue() throw() { +} + + +void KeyValue::__set_key(const Key& val) { + this->key = val; +} + +void KeyValue::__set_value(const std::string& val) { + this->value = val; +} uint32_t KeyValue::read(::apache::thrift::protocol::TProtocol* iprot) { + apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; std::string fname; ::apache::thrift::protocol::TType ftype; @@ -584,6 +745,7 @@ uint32_t KeyValue::read(::apache::thrift::protocol::TProtocol* iprot) { uint32_t KeyValue::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); xfer += oprot->writeStructBegin("KeyValue"); xfer += oprot->writeFieldBegin("key", ::apache::thrift::protocol::T_STRUCT, 1); @@ -606,11 +768,41 @@ void swap(KeyValue &a, KeyValue &b) { swap(a.__isset, b.__isset); } -const char* ScanResult::ascii_fingerprint = "684A3FCA76EA202FE071A17F8B510E7A"; -const uint8_t ScanResult::binary_fingerprint[16] = {0x68,0x4A,0x3F,0xCA,0x76,0xEA,0x20,0x2F,0xE0,0x71,0xA1,0x7F,0x8B,0x51,0x0E,0x7A}; +KeyValue::KeyValue(const KeyValue& other12) { + key = other12.key; + value = other12.value; + __isset = other12.__isset; +} +KeyValue& KeyValue::operator=(const KeyValue& other13) { + key = other13.key; + value = other13.value; + __isset = other13.__isset; + return *this; +} +void KeyValue::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "KeyValue("; + out << "key=" << to_string(key); + out << ", " << "value=" << to_string(value); + out << ")"; +} + + +ScanResult::~ScanResult() throw() { +} + + +void ScanResult::__set_results(const std::vector<KeyValue> & val) { + this->results = val; +} + +void ScanResult::__set_more(const bool val) { + this->more = val; +} uint32_t ScanResult::read(::apache::thrift::protocol::TProtocol* iprot) { + apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; std::string fname; ::apache::thrift::protocol::TType ftype; @@ -633,14 +825,14 @@ uint32_t ScanResult::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->results.clear(); - uint32_t _size6; - ::apache::thrift::protocol::TType _etype9; - xfer += iprot->readListBegin(_etype9, _size6); - this->results.resize(_size6); - uint32_t _i10; - for (_i10 = 0; _i10 < _size6; ++_i10) + uint32_t _size14; + ::apache::thrift::protocol::TType _etype17; + xfer += iprot->readListBegin(_etype17, _size14); + this->results.resize(_size14); + uint32_t _i18; + for (_i18 = 0; _i18 < _size14; ++_i18) { - xfer += this->results[_i10].read(iprot); + xfer += this->results[_i18].read(iprot); } xfer += iprot->readListEnd(); } @@ -671,15 +863,16 @@ uint32_t ScanResult::read(::apache::thrift::protocol::TProtocol* iprot) { uint32_t ScanResult::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); xfer += oprot->writeStructBegin("ScanResult"); xfer += oprot->writeFieldBegin("results", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->results.size())); - std::vector<KeyValue> ::const_iterator _iter11; - for (_iter11 = this->results.begin(); _iter11 != this->results.end(); ++_iter11) + std::vector<KeyValue> ::const_iterator _iter19; + for (_iter19 = this->results.begin(); _iter19 != this->results.end(); ++_iter19) { - xfer += (*_iter11).write(oprot); + xfer += (*_iter19).write(oprot); } xfer += oprot->writeListEnd(); } @@ -701,11 +894,49 @@ void swap(ScanResult &a, ScanResult &b) { swap(a.__isset, b.__isset); } -const char* Range::ascii_fingerprint = "84C5BA8DB718E60BFBF3F83867647B45"; -const uint8_t Range::binary_fingerprint[16] = {0x84,0xC5,0xBA,0x8D,0xB7,0x18,0xE6,0x0B,0xFB,0xF3,0xF8,0x38,0x67,0x64,0x7B,0x45}; +ScanResult::ScanResult(const ScanResult& other20) { + results = other20.results; + more = other20.more; + __isset = other20.__isset; +} +ScanResult& ScanResult::operator=(const ScanResult& other21) { + results = other21.results; + more = other21.more; + __isset = other21.__isset; + return *this; +} +void ScanResult::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "ScanResult("; + out << "results=" << to_string(results); + out << ", " << "more=" << to_string(more); + out << ")"; +} + + +Range::~Range() throw() { +} + + +void Range::__set_start(const Key& val) { + this->start = val; +} + +void Range::__set_startInclusive(const bool val) { + this->startInclusive = val; +} + +void Range::__set_stop(const Key& val) { + this->stop = val; +} + +void Range::__set_stopInclusive(const bool val) { + this->stopInclusive = val; +} uint32_t Range::read(::apache::thrift::protocol::TProtocol* iprot) { + apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; std::string fname; ::apache::thrift::protocol::TType ftype; @@ -770,6 +1001,7 @@ uint32_t Range::read(::apache::thrift::protocol::TProtocol* iprot) { uint32_t Range::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); xfer += oprot->writeStructBegin("Range"); xfer += oprot->writeFieldBegin("start", ::apache::thrift::protocol::T_STRUCT, 1); @@ -802,11 +1034,48 @@ void swap(Range &a, Range &b) { swap(a.__isset, b.__isset); } -const char* ScanColumn::ascii_fingerprint = "5B708A954C550ECA9C1A49D3C5CAFAB9"; -const uint8_t ScanColumn::binary_fingerprint[16] = {0x5B,0x70,0x8A,0x95,0x4C,0x55,0x0E,0xCA,0x9C,0x1A,0x49,0xD3,0xC5,0xCA,0xFA,0xB9}; +Range::Range(const Range& other22) { + start = other22.start; + startInclusive = other22.startInclusive; + stop = other22.stop; + stopInclusive = other22.stopInclusive; + __isset = other22.__isset; +} +Range& Range::operator=(const Range& other23) { + start = other23.start; + startInclusive = other23.startInclusive; + stop = other23.stop; + stopInclusive = other23.stopInclusive; + __isset = other23.__isset; + return *this; +} +void Range::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "Range("; + out << "start=" << to_string(start); + out << ", " << "startInclusive=" << to_string(startInclusive); + out << ", " << "stop=" << to_string(stop); + out << ", " << "stopInclusive=" << to_string(stopInclusive); + out << ")"; +} + + +ScanColumn::~ScanColumn() throw() { +} + + +void ScanColumn::__set_colFamily(const std::string& val) { + this->colFamily = val; +} + +void ScanColumn::__set_colQualifier(const std::string& val) { + this->colQualifier = val; +__isset.colQualifier = true; +} uint32_t ScanColumn::read(::apache::thrift::protocol::TProtocol* iprot) { + apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; std::string fname; ::apache::thrift::protocol::TType ftype; @@ -855,6 +1124,7 @@ uint32_t ScanColumn::read(::apache::thrift::protocol::TProtocol* iprot) { uint32_t ScanColumn::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); xfer += oprot->writeStructBegin("ScanColumn"); xfer += oprot->writeFieldBegin("colFamily", ::apache::thrift::protocol::T_STRING, 1); @@ -878,11 +1148,49 @@ void swap(ScanColumn &a, ScanColumn &b) { swap(a.__isset, b.__isset); } -const char* IteratorSetting::ascii_fingerprint = "985C857916964E43205EAC92A157CB4E"; -const uint8_t IteratorSetting::binary_fingerprint[16] = {0x98,0x5C,0x85,0x79,0x16,0x96,0x4E,0x43,0x20,0x5E,0xAC,0x92,0xA1,0x57,0xCB,0x4E}; +ScanColumn::ScanColumn(const ScanColumn& other24) { + colFamily = other24.colFamily; + colQualifier = other24.colQualifier; + __isset = other24.__isset; +} +ScanColumn& ScanColumn::operator=(const ScanColumn& other25) { + colFamily = other25.colFamily; + colQualifier = other25.colQualifier; + __isset = other25.__isset; + return *this; +} +void ScanColumn::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "ScanColumn("; + out << "colFamily=" << to_string(colFamily); + out << ", " << "colQualifier="; (__isset.colQualifier ? (out << to_string(colQualifier)) : (out << "<null>")); + out << ")"; +} + + +IteratorSetting::~IteratorSetting() throw() { +} + + +void IteratorSetting::__set_priority(const int32_t val) { + this->priority = val; +} + +void IteratorSetting::__set_name(const std::string& val) { + this->name = val; +} + +void IteratorSetting::__set_iteratorClass(const std::string& val) { + this->iteratorClass = val; +} + +void IteratorSetting::__set_properties(const std::map<std::string, std::string> & val) { + this->properties = val; +} uint32_t IteratorSetting::read(::apache::thrift::protocol::TProtocol* iprot) { + apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; std::string fname; ::apache::thrift::protocol::TType ftype; @@ -929,17 +1237,17 @@ uint32_t IteratorSetting::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_MAP) { { this->properties.clear(); - uint32_t _size12; - ::apache::thrift::protocol::TType _ktype13; - ::apache::thrift::protocol::TType _vtype14; - xfer += iprot->readMapBegin(_ktype13, _vtype14, _size12); - uint32_t _i16; - for (_i16 = 0; _i16 < _size12; ++_i16) + uint32_t _size26; + ::apache::thrift::protocol::TType _ktype27; + ::apache::thrift::protocol::TType _vtype28; + xfer += iprot->readMapBegin(_ktype27, _vtype28, _size26); + uint32_t _i30; + for (_i30 = 0; _i30 < _size26; ++_i30) { - std::string _key17; - xfer += iprot->readString(_key17); - std::string& _val18 = this->properties[_key17]; - xfer += iprot->readString(_val18); + std::string _key31; + xfer += iprot->readString(_key31); + std::string& _val32 = this->properties[_key31]; + xfer += iprot->readString(_val32); } xfer += iprot->readMapEnd(); } @@ -962,6 +1270,7 @@ uint32_t IteratorSetting::read(::apache::thrift::protocol::TProtocol* iprot) { uint32_t IteratorSetting::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); xfer += oprot->writeStructBegin("IteratorSetting"); xfer += oprot->writeFieldBegin("priority", ::apache::thrift::protocol::T_I32, 1); @@ -979,11 +1288,11 @@ uint32_t IteratorSetting::write(::apache::thrift::protocol::TProtocol* oprot) co xfer += oprot->writeFieldBegin("properties", ::apache::thrift::protocol::T_MAP, 4); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->properties.size())); - std::map<std::string, std::string> ::const_iterator _iter19; - for (_iter19 = this->properties.begin(); _iter19 != this->properties.end(); ++_iter19) + std::map<std::string, std::string> ::const_iterator _iter33; + for (_iter33 = this->properties.begin(); _iter33 != this->properties.end(); ++_iter33) { - xfer += oprot->writeString(_iter19->first); - xfer += oprot->writeString(_iter19->second); + xfer += oprot->writeString(_iter33->first); + xfer += oprot->writeString(_iter33->second); } xfer += oprot->writeMapEnd(); } @@ -1003,11 +1312,64 @@ void swap(IteratorSetting &a, IteratorSetting &b) { swap(a.__isset, b.__isset); } -const char* ScanOptions::ascii_fingerprint = "3D87D0CD05FA62E15880C4D2C595907C"; -const uint8_t ScanOptions::binary_fingerprint[16] = {0x3D,0x87,0xD0,0xCD,0x05,0xFA,0x62,0xE1,0x58,0x80,0xC4,0xD2,0xC5,0x95,0x90,0x7C}; +IteratorSetting::IteratorSetting(const IteratorSetting& other34) { + priority = other34.priority; + name = other34.name; + iteratorClass = other34.iteratorClass; + properties = other34.properties; + __isset = other34.__isset; +} +IteratorSetting& IteratorSetting::operator=(const IteratorSetting& other35) { + priority = other35.priority; + name = other35.name; + iteratorClass = other35.iteratorClass; + properties = other35.properties; + __isset = other35.__isset; + return *this; +} +void IteratorSetting::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "IteratorSetting("; + out << "priority=" << to_string(priority); + out << ", " << "name=" << to_string(name); + out << ", " << "iteratorClass=" << to_string(iteratorClass); + out << ", " << "properties=" << to_string(properties); + out << ")"; +} + + +ScanOptions::~ScanOptions() throw() { +} + + +void ScanOptions::__set_authorizations(const std::set<std::string> & val) { + this->authorizations = val; +__isset.authorizations = true; +} + +void ScanOptions::__set_range(const Range& val) { + this->range = val; +__isset.range = true; +} + +void ScanOptions::__set_columns(const std::vector<ScanColumn> & val) { + this->columns = val; +__isset.columns = true; +} + +void ScanOptions::__set_iterators(const std::vector<IteratorSetting> & val) { + this->iterators = val; +__isset.iterators = true; +} + +void ScanOptions::__set_bufferSize(const int32_t val) { + this->bufferSize = val; +__isset.bufferSize = true; +} uint32_t ScanOptions::read(::apache::thrift::protocol::TProtocol* iprot) { + apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; std::string fname; ::apache::thrift::protocol::TType ftype; @@ -1030,15 +1392,15 @@ uint32_t ScanOptions::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_SET) { { this->authorizations.clear(); - uint32_t _size20; - ::apache::thrift::protocol::TType _etype23; - xfer += iprot->readSetBegin(_etype23, _size20); - uint32_t _i24; - for (_i24 = 0; _i24 < _size20; ++_i24) + uint32_t _size36; + ::apache::thrift::protocol::TType _etype39; + xfer += iprot->readSetBegin(_etype39, _size36); + uint32_t _i40; + for (_i40 = 0; _i40 < _size36; ++_i40) { - std::string _elem25; - xfer += iprot->readBinary(_elem25); - this->authorizations.insert(_elem25); + std::string _elem41; + xfer += iprot->readBinary(_elem41); + this->authorizations.insert(_elem41); } xfer += iprot->readSetEnd(); } @@ -1059,14 +1421,14 @@ uint32_t ScanOptions::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->columns.clear(); - uint32_t _size26; - ::apache::thrift::protocol::TType _etype29; - xfer += iprot->readListBegin(_etype29, _size26); - this->columns.resize(_size26); - uint32_t _i30; - for (_i30 = 0; _i30 < _size26; ++_i30) + uint32_t _size42; + ::apache::thrift::protocol::TType _etype45; + xfer += iprot->readListBegin(_etype45, _size42); + this->columns.resize(_size42); + uint32_t _i46; + for (_i46 = 0; _i46 < _size42; ++_i46) { - xfer += this->columns[_i30].read(iprot); + xfer += this->columns[_i46].read(iprot); } xfer += iprot->readListEnd(); } @@ -1079,14 +1441,14 @@ uint32_t ScanOptions::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->iterators.clear(); - uint32_t _size31; - ::apache::thrift::protocol::TType _etype34; - xfer += iprot->readListBegin(_etype34, _size31); - this->iterators.resize(_size31); - uint32_t _i35; - for (_i35 = 0; _i35 < _size31; ++_i35) + uint32_t _size47; + ::apache::thrift::protocol::TType _etype50; + xfer += iprot->readListBegin(_etype50, _size47); + this->iterators.resize(_size47); + uint32_t _i51; + for (_i51 = 0; _i51 < _size47; ++_i51) { - xfer += this->iterators[_i35].read(iprot); + xfer += this->iterators[_i51].read(iprot); } xfer += iprot->readListEnd(); } @@ -1117,16 +1479,17 @@ uint32_t ScanOptions::read(::apache::thrift::protocol::TProtocol* iprot) { uint32_t ScanOptions::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); xfer += oprot->writeStructBegin("ScanOptions"); if (this->__isset.authorizations) { xfer += oprot->writeFieldBegin("authorizations", ::apache::thrift::protocol::T_SET, 1); { xfer += oprot->writeSetBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->authorizations.size())); - std::set<std::string> ::const_iterator _iter36; - for (_iter36 = this->authorizations.begin(); _iter36 != this->authorizations.end(); ++_iter36) + std::set<std::string> ::const_iterator _iter52; + for (_iter52 = this->authorizations.begin(); _iter52 != this->authorizations.end(); ++_iter52) { - xfer += oprot->writeBinary((*_iter36)); + xfer += oprot->writeBinary((*_iter52)); } xfer += oprot->writeSetEnd(); } @@ -1141,10 +1504,10 @@ uint32_t ScanOptions::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<ScanColumn> ::const_iterator _iter37; - for (_iter37 = this->columns.begin(); _iter37 != this->columns.end(); ++_iter37) + std::vector<ScanColumn> ::const_iterator _iter53; + for (_iter53 = this->columns.begin(); _iter53 != this->columns.end(); ++_iter53) { - xfer += (*_iter37).write(oprot); + xfer += (*_iter53).write(oprot); } xfer += oprot->writeListEnd(); } @@ -1154,10 +1517,10 @@ uint32_t ScanOptions::write(::apache::thrift::protocol::TProtocol* oprot) const xfer += oprot->writeFieldBegin("iterators", ::apache::thrift::protocol::T_LIST, 4); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->iterators.size())); - std::vector<IteratorSetting> ::const_iterator _iter38; - for (_iter38 = this->iterators.begin(); _iter38 != this->iterators.end(); ++_iter38) + std::vector<IteratorSetting> ::const_iterator _iter54; + for (_iter54 = this->iterators.begin(); _iter54 != this->iterators.end(); ++_iter54) { - xfer += (*_iter38).write(oprot); + xfer += (*_iter54).write(oprot); } xfer += oprot->writeListEnd(); } @@ -1183,11 +1546,67 @@ void swap(ScanOptions &a, ScanOptions &b) { swap(a.__isset, b.__isset); } -const char* BatchScanOptions::ascii_fingerprint = "6ADFA1FBE31B1220D2C103284E002308"; -const uint8_t BatchScanOptions::binary_fingerprint[16] = {0x6A,0xDF,0xA1,0xFB,0xE3,0x1B,0x12,0x20,0xD2,0xC1,0x03,0x28,0x4E,0x00,0x23,0x08}; +ScanOptions::ScanOptions(const ScanOptions& other55) { + authorizations = other55.authorizations; + range = other55.range; + columns = other55.columns; + iterators = other55.iterators; + bufferSize = other55.bufferSize; + __isset = other55.__isset; +} +ScanOptions& ScanOptions::operator=(const ScanOptions& other56) { + authorizations = other56.authorizations; + range = other56.range; + columns = other56.columns; + iterators = other56.iterators; + bufferSize = other56.bufferSize; + __isset = other56.__isset; + return *this; +} +void ScanOptions::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "ScanOptions("; + out << "authorizations="; (__isset.authorizations ? (out << to_string(authorizations)) : (out << "<null>")); + out << ", " << "range="; (__isset.range ? (out << to_string(range)) : (out << "<null>")); + out << ", " << "columns="; (__isset.columns ? (out << to_string(columns)) : (out << "<null>")); + out << ", " << "iterators="; (__isset.iterators ? (out << to_string(iterators)) : (out << "<null>")); + out << ", " << "bufferSize="; (__isset.bufferSize ? (out << to_string(bufferSize)) : (out << "<null>")); + out << ")"; +} + + +BatchScanOptions::~BatchScanOptions() throw() { +} + + +void BatchScanOptions::__set_authorizations(const std::set<std::string> & val) { + this->authorizations = val; +__isset.authorizations = true; +} + +void BatchScanOptions::__set_ranges(const std::vector<Range> & val) { + this->ranges = val; +__isset.ranges = true; +} + +void BatchScanOptions::__set_columns(const std::vector<ScanColumn> & val) { + this->columns = val; +__isset.columns = true; +} + +void BatchScanOptions::__set_iterators(const std::vector<IteratorSetting> & val) { + this->iterators = val; +__isset.iterators = true; +} + +void BatchScanOptions::__set_threads(const int32_t val) { + this->threads = val; +__isset.threads = true; +} uint32_t BatchScanOptions::read(::apache::thrift::protocol::TProtocol* iprot) { + apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; std::string fname; ::apache::thrift::protocol::TType ftype; @@ -1210,15 +1629,15 @@ uint32_t BatchScanOptions::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_SET) { { this->authorizations.clear(); - uint32_t _size39; - ::apache::thrift::protocol::TType _etype42; - xfer += iprot->readSetBegin(_etype42, _size39); - uint32_t _i43; - for (_i43 = 0; _i43 < _size39; ++_i43) + uint32_t _size57; + ::apache::thrift::protocol::TType _etype60; + xfer += iprot->readSetBegin(_etype60, _size57); + uint32_t _i61; + for (_i61 = 0; _i61 < _size57; ++_i61) { - std::string _elem44; - xfer += iprot->readBinary(_elem44); - this->authorizations.insert(_elem44); + std::string _elem62; + xfer += iprot->readBinary(_elem62); + this->authorizations.insert(_elem62); } xfer += iprot->readSetEnd(); } @@ -1231,14 +1650,14 @@ uint32_t BatchScanOptions::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->ranges.clear(); - uint32_t _size45; - ::apache::thrift::protocol::TType _etype48; - xfer += iprot->readListBegin(_etype48, _size45); - this->ranges.resize(_size45); - uint32_t _i49; - for (_i49 = 0; _i49 < _size45; ++_i49) + uint32_t _size63; + ::apache::thrift::protocol::TType _etype66; + xfer += iprot->readListBegin(_etype66, _size63); + this->ranges.resize(_size63); + uint32_t _i67; + for (_i67 = 0; _i67 < _size63; ++_i67) { - xfer += this->ranges[_i49].read(iprot); + xfer += this->ranges[_i67].read(iprot); } xfer += iprot->readListEnd(); } @@ -1251,14 +1670,14 @@ uint32_t BatchScanOptions::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->columns.clear(); - uint32_t _size50; - ::apache::thrift::protocol::TType _etype53; - xfer += iprot->readListBegin(_etype53, _size50); - this->columns.resize(_size50); - uint32_t _i54; - for (_i54 = 0; _i54 < _size50; ++_i54) + uint32_t _size68; + ::apache::thrift::protocol::TType _etype71; + xfer += iprot->readListBegin(_etype71, _size68); + this->columns.resize(_size68); + uint32_t _i72; + for (_i72 = 0; _i72 < _size68; ++_i72) { - xfer += this->columns[_i54].read(iprot); + xfer += this->columns[_i72].read(iprot); } xfer += iprot->readListEnd(); } @@ -1271,14 +1690,14 @@ uint32_t BatchScanOptions::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->iterators.clear(); - uint32_t _size55; - ::apache::thrift::protocol::TType _etype58; - xfer += iprot->readListBegin(_etype58, _size55); - this->iterators.resize(_size55); - uint32_t _i59; - for (_i59 = 0; _i59 < _size55; ++_i59) + uint32_t _size73; + ::apache::thrift::protocol::TType _etype76; + xfer += iprot->readListBegin(_etype76, _size73); + this->iterators.resize(_size73); + uint32_t _i77; + for (_i77 = 0; _i77 < _size73; ++_i77) { - xfer += this->iterators[_i59].read(iprot); + xfer += this->iterators[_i77].read(iprot); } xfer += iprot->readListEnd(); } @@ -1309,16 +1728,17 @@ uint32_t BatchScanOptions::read(::apache::thrift::protocol::TProtocol* iprot) { uint32_t BatchScanOptions::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); xfer += oprot->writeStructBegin("BatchScanOptions"); if (this->__isset.authorizations) { xfer += oprot->writeFieldBegin("authorizations", ::apache::thrift::protocol::T_SET, 1); { xfer += oprot->writeSetBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->authorizations.size())); - std::set<std::string> ::const_iterator _iter60; - for (_iter60 = this->authorizations.begin(); _iter60 != this->authorizations.end(); ++_iter60) + std::set<std::string> ::const_iterator _iter78; + for (_iter78 = this->authorizations.begin(); _iter78 != this->authorizations.end(); ++_iter78) { - xfer += oprot->writeBinary((*_iter60)); + xfer += oprot->writeBinary((*_iter78)); } xfer += oprot->writeSetEnd(); } @@ -1328,10 +1748,10 @@ uint32_t BatchScanOptions::write(::apache::thrift::protocol::TProtocol* oprot) c xfer += oprot->writeFieldBegin("ranges", ::apache::thrift::protocol::T_LIST, 2); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->ranges.size())); - std::vector<Range> ::const_iterator _iter61; - for (_iter61 = this->ranges.begin(); _iter61 != this->ranges.end(); ++_iter61) + std::vector<Range> ::const_iterator _iter79; + for (_iter79 = this->ranges.begin(); _iter79 != this->ranges.end(); ++_iter79) { - xfer += (*_iter61).write(oprot); + xfer += (*_iter79).write(oprot); } xfer += oprot->writeListEnd(); } @@ -1341,10 +1761,10 @@ uint32_t BatchScanOptions::write(::apache::thrift::protocol::TProtocol* oprot) c 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<ScanColumn> ::const_iterator _iter62; - for (_iter62 = this->columns.begin(); _iter62 != this->columns.end(); ++_iter62) + std::vector<ScanColumn> ::const_iterator _iter80; + for (_iter80 = this->columns.begin(); _iter80 != this->columns.end(); ++_iter80) { - xfer += (*_iter62).write(oprot); + xfer += (*_iter80).write(oprot); } xfer += oprot->writeListEnd(); } @@ -1354,10 +1774,10 @@ uint32_t BatchScanOptions::write(::apache::thrift::protocol::TProtocol* oprot) c xfer += oprot->writeFieldBegin("iterators", ::apache::thrift::protocol::T_LIST, 4); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->iterators.size())); - std::vector<IteratorSetting> ::const_iterator _iter63; - for (_iter63 = this->iterators.begin(); _iter63 != this->iterators.end(); ++_iter63) + std::vector<IteratorSetting> ::const_iterator _iter81; + for (_iter81 = this->iterators.begin(); _iter81 != this->iterators.end(); ++_iter81) { - xfer += (*_iter63).write(oprot); + xfer += (*_iter81).write(oprot); } xfer += oprot->writeListEnd(); } @@ -1383,11 +1803,50 @@ void swap(BatchScanOptions &a, BatchScanOptions &b) { swap(a.__isset, b.__isset); } -const char* KeyValueAndPeek::ascii_fingerprint = "CBBC6AB9C7EA5E5E748C13F970862FAB"; -const uint8_t KeyValueAndPeek::binary_fingerprint[16] = {0xCB,0xBC,0x6A,0xB9,0xC7,0xEA,0x5E,0x5E,0x74,0x8C,0x13,0xF9,0x70,0x86,0x2F,0xAB}; +BatchScanOptions::BatchScanOptions(const BatchScanOptions& other82) { + authorizations = other82.authorizations; + ranges = other82.ranges; + columns = other82.columns; + iterators = other82.iterators; + threads = other82.threads; + __isset = other82.__isset; +} +BatchScanOptions& BatchScanOptions::operator=(const BatchScanOptions& other83) { + authorizations = other83.authorizations; + ranges = other83.ranges; + columns = other83.columns; + iterators = other83.iterators; + threads = other83.threads; + __isset = other83.__isset; + return *this; +} +void BatchScanOptions::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "BatchScanOptions("; + out << "authorizations="; (__isset.authorizations ? (out << to_string(authorizations)) : (out << "<null>")); + out << ", " << "ranges="; (__isset.ranges ? (out << to_string(ranges)) : (out << "<null>")); + out << ", " << "columns="; (__isset.columns ? (out << to_string(columns)) : (out << "<null>")); + out << ", " << "iterators="; (__isset.iterators ? (out << to_string(iterators)) : (out << "<null>")); + out << ", " << "threads="; (__isset.threads ? (out << to_string(threads)) : (out << "<null>")); + out << ")"; +} + + +KeyValueAndPeek::~KeyValueAndPeek() throw() { +} + + +void KeyValueAndPeek::__set_keyValue(const KeyValue& val) { + this->keyValue = val; +} + +void KeyValueAndPeek::__set_hasNext(const bool val) { + this->hasNext = val; +} uint32_t KeyValueAndPeek::read(::apache::thrift::protocol::TProtocol* iprot) { + apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; std::string fname; ::apache::thrift::protocol::TType ftype; @@ -1436,6 +1895,7 @@ uint32_t KeyValueAndPeek::read(::apache::thrift::protocol::TProtocol* iprot) { uint32_t KeyValueAndPeek::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); xfer += oprot->writeStructBegin("KeyValueAndPeek"); xfer += oprot->writeFieldBegin("keyValue", ::apache::thrift::protocol::T_STRUCT, 1); @@ -1458,11 +1918,45 @@ void swap(KeyValueAndPeek &a, KeyValueAndPeek &b) { swap(a.__isset, b.__isset); } -const char* KeyExtent::ascii_fingerprint = "AB879940BD15B6B25691265F7384B271"; -const uint8_t KeyExtent::binary_fingerprint[16] = {0xAB,0x87,0x99,0x40,0xBD,0x15,0xB6,0xB2,0x56,0x91,0x26,0x5F,0x73,0x84,0xB2,0x71}; +KeyValueAndPeek::KeyValueAndPeek(const KeyValueAndPeek& other84) { + keyValue = other84.keyValue; + hasNext = other84.hasNext; + __isset = other84.__isset; +} +KeyValueAndPeek& KeyValueAndPeek::operator=(const KeyValueAndPeek& other85) { + keyValue = other85.keyValue; + hasNext = other85.hasNext; + __isset = other85.__isset; + return *this; +} +void KeyValueAndPeek::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "KeyValueAndPeek("; + out << "keyValue=" << to_string(keyValue); + out << ", " << "hasNext=" << to_string(hasNext); + out << ")"; +} + + +KeyExtent::~KeyExtent() throw() { +} + + +void KeyExtent::__set_tableId(const std::string& val) { + this->tableId = val; +} + +void KeyExtent::__set_endRow(const std::string& val) { + this->endRow = val; +} + +void KeyExtent::__set_prevEndRow(const std::string& val) { + this->prevEndRow = val; +} uint32_t KeyExtent::read(::apache::thrift::protocol::TProtocol* iprot) { + apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; std::string fname; ::apache::thrift::protocol::TType ftype; @@ -1519,6 +2013,7 @@ uint32_t KeyExtent::read(::apache::thrift::protocol::TProtocol* iprot) { uint32_t KeyExtent::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); xfer += oprot->writeStructBegin("KeyExtent"); xfer += oprot->writeFieldBegin("tableId", ::apache::thrift::protocol::T_STRING, 1); @@ -1546,11 +2041,48 @@ void swap(KeyExtent &a, KeyExtent &b) { swap(a.__isset, b.__isset); } -const char* Column::ascii_fingerprint = "AB879940BD15B6B25691265F7384B271"; -const uint8_t Column::binary_fingerprint[16] = {0xAB,0x87,0x99,0x40,0xBD,0x15,0xB6,0xB2,0x56,0x91,0x26,0x5F,0x73,0x84,0xB2,0x71}; +KeyExtent::KeyExtent(const KeyExtent& other86) { + tableId = other86.tableId; + endRow = other86.endRow; + prevEndRow = other86.prevEndRow; + __isset = other86.__isset; +} +KeyExtent& KeyExtent::operator=(const KeyExtent& other87) { + tableId = other87.tableId; + endRow = other87.endRow; + prevEndRow = other87.prevEndRow; + __isset = other87.__isset; + return *this; +} +void KeyExtent::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "KeyExtent("; + out << "tableId=" << to_string(tableId); + out << ", " << "endRow=" << to_string(endRow); + out << ", " << "prevEndRow=" << to_string(prevEndRow); + out << ")"; +} + + +Column::~Column() throw() { +} + + +void Column::__set_colFamily(const std::string& val) { + this->colFamily = val; +} + +void Column::__set_colQualifier(const std::string& val) { + this->colQualifier = val; +} + +void Column::__set_colVisibility(const std::string& val) { + this->colVisibility = val; +} uint32_t Column::read(::apache::thrift::protocol::TProtocol* iprot) { + apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; std::string fname; ::apache::thrift::protocol::TType ftype; @@ -1607,6 +2139,7 @@ uint32_t Column::read(::apache::thrift::protocol::TProtocol* iprot) { uint32_t Column::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); xfer += oprot->writeStructBegin("Column"); xfer += oprot->writeFieldBegin("colFamily", ::apache::thrift::protocol::T_STRING, 1); @@ -1634,11 +2167,55 @@ void swap(Column &a, Column &b) { swap(a.__isset, b.__isset); } -const char* Condition::ascii_fingerprint = "C4022914C22D89E33B1A46A7D511C58F"; -const uint8_t Condition::binary_fingerprint[16] = {0xC4,0x02,0x29,0x14,0xC2,0x2D,0x89,0xE3,0x3B,0x1A,0x46,0xA7,0xD5,0x11,0xC5,0x8F}; +Column::Column(const Column& other88) { + colFamily = other88.colFamily; + colQualifier = other88.colQualifier; + colVisibility = other88.colVisibility; + __isset = other88.__isset; +} +Column& Column::operator=(const Column& other89) { + colFamily = other89.colFamily; + colQualifier = other89.colQualifier; + colVisibility = other89.colVisibility; + __isset = other89.__isset; + return *this; +} +void Column::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "Column("; + out << "colFamily=" << to_string(colFamily); + out << ", " << "colQualifier=" << to_string(colQualifier); + out << ", " << "colVisibility=" << to_string(colVisibility); + out << ")"; +} + + +Condition::~Condition() throw() { +} + + +void Condition::__set_column(const Column& val) { + this->column = val; +} + +void Condition::__set_timestamp(const int64_t val) { + this->timestamp = val; +__isset.timestamp = true; +} + +void Condition::__set_value(const std::string& val) { + this->value = val; +__isset.value = true; +} + +void Condition::__set_iterators(const std::vector<IteratorSetting> & val) { + this->iterators = val; +__isset.iterators = true; +} uint32_t Condition::read(::apache::thrift::protocol::TProtocol* iprot) { + apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; std::string fname; ::apache::thrift::protocol::TType ftype; @@ -1685,14 +2262,14 @@ uint32_t Condition::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->iterators.clear(); - uint32_t _size64; - ::apache::thrift::protocol::TType _etype67; - xfer += iprot->readListBegin(_etype67, _size64); - this->iterators.resize(_size64); - uint32_t _i68; - for (_i68 = 0; _i68 < _size64; ++_i68) + uint32_t _size90; + ::apache::thrift::protocol::TType _etype93; + xfer += iprot->readListBegin(_etype93, _size90); + this->iterators.resize(_size90); + uint32_t _i94; + for (_i94 = 0; _i94 < _size90; ++_i94) { - xfer += this->iterators[_i68].read(iprot); + xfer += this->iterators[_i94].read(iprot); } xfer += iprot->readListEnd(); } @@ -1715,6 +2292,7 @@ uint32_t Condition::read(::apache::thrift::protocol::TProtocol* iprot) { uint32_t Condition::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); xfer += oprot->writeStructBegin("Condition"); xfer += oprot->writeFieldBegin("column", ::apache::thrift::protocol::T_STRUCT, 1); @@ -1735,10 +2313,10 @@ uint32_t Condition::write(::apache::thrift::protocol::TProtocol* oprot) const { xfer += oprot->writeFieldBegin("iterators", ::apache::thrift::protocol::T_LIST, 4); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->iterators.size())); - std::vector<IteratorSetting> ::const_iterator _iter69; - for (_iter69 = this->iterators.begin(); _iter69 != this->iterators.end(); ++_iter69) + std::vector<IteratorSetting> ::const_iterator _iter95; + for (_iter95 = this->iterators.begin(); _iter95 != this->iterators.end(); ++_iter95) { - xfer += (*_iter69).write(oprot); + xfer += (*_iter95).write(oprot); } xfer += oprot->writeListEnd(); } @@ -1758,11 +2336,47 @@ void swap(Condition &a, Condition &b) { swap(a.__isset, b.__isset); } -const char* ConditionalUpdates::ascii_fingerprint = "1C1808872D1A8E04F114974ADD77F356"; -const uint8_t ConditionalUpdates::binary_fingerprint[16] = {0x1C,0x18,0x08,0x87,0x2D,0x1A,0x8E,0x04,0xF1,0x14,0x97,0x4A,0xDD,0x77,0xF3,0x56}; +Condition::Condition(const Condition& other96) { + column = other96.column; + timestamp = other96.timestamp; + value = other96.value; + iterators = other96.iterators; + __isset = other96.__isset; +} +Condition& Condition::operator=(const Condition& other97) { + column = other97.column; + timestamp = other97.timestamp; + value = other97.value; + iterators = other97.iterators; + __isset = other97.__isset; + return *this; +} +void Condition::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "Condition("; + out << "column=" << to_string(column); + out << ", " << "timestamp="; (__isset.timestamp ? (out << to_string(timestamp)) : (out << "<null>")); + out << ", " << "value="; (__isset.value ? (out << to_string(value)) : (out << "<null>")); + out << ", " << "iterators="; (__isset.iterators ? (out << to_string(iterators)) : (out << "<null>")); + out << ")"; +} + + +ConditionalUpdates::~ConditionalUpdates() throw() { +} + + +void ConditionalUpdates::__set_conditions(const std::vector<Condition> & val) { + this->conditions = val; +} + +void ConditionalUpdates::__set_updates(const std::vector<ColumnUpdate> & val) { + this->updates = val; +} uint32_t ConditionalUpdates::read(::apache::thrift::protocol::TProtocol* iprot) { + apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; std::string fname; ::apache::thrift::protocol::TType ftype; @@ -1785,14 +2399,14 @@ uint32_t ConditionalUpdates::read(::apache::thrift::protocol::TProtocol* iprot) if (ftype == ::apache::thrift::protocol::T_LIST) { { this->conditions.clear(); - uint32_t _size70; - ::apache::thrift::protocol::TType _etype73; - xfer += iprot->readListBegin(_etype73, _size70); - this->conditions.resize(_size70); - uint32_t _i74; - for (_i74 = 0; _i74 < _size70; ++_i74) + uint32_t _size98; + ::apache::thrift::protocol::TType _etype101; + xfer += iprot->readListBegin(_etype101, _size98); + this->conditions.resize(_size98); + uint32_t _i102; + for (_i102 = 0; _i102 < _size98; ++_i102) { - xfer += this->conditions[_i74].read(iprot); + xfer += this->conditions[_i102].read(iprot); } xfer += iprot->readListEnd(); } @@ -1805,14 +2419,14 @@ uint32_t ConditionalUpdates::read(::apache::thrift::protocol::TProtocol* iprot) if (ftype == ::apache::thrift::protocol::T_LIST) { { this->updates.clear(); - uint32_t _size75; - ::apache::thrift::protocol::TType _etype78; - xfer += iprot->readListBegin(_etype78, _size75); - this->updates.resize(_size75); - uint32_t _i79; - for (_i79 = 0; _i79 < _size75; ++_i79) + uint32_t _size103; + ::apache::thrift::protocol::TType _etype106; + xfer += iprot->readListBegin(_etype106, _size103); + this->updates.resize(_size103); + uint32_t _i107; + for (_i107 = 0; _i107 < _size103; ++_i107) { - xfer += this->updates[_i79].read(iprot); + xfer += this->updates[_i107].read(iprot); } xfer += iprot->readListEnd(); } @@ -1835,15 +2449,16 @@ uint32_t ConditionalUpdates::read(::apache::thrift::protocol::TProtocol* iprot) uint32_t ConditionalUpdates::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); xfer += oprot->writeStructBegin("ConditionalUpdates"); xfer += oprot->writeFieldBegin("conditions", ::apache::thrift::protocol::T_LIST, 2); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->conditions.size())); - std::vector<Condition> ::const_iterator _iter80; - for (_iter80 = this->conditions.begin(); _iter80 != this->conditions.end(); ++_iter80) + std::vector<Condition> ::const_iterator _iter108; + for (_iter108 = this->conditions.begin(); _iter108 != this->conditions.end(); ++_iter108) { - xfer += (*_iter80).write(oprot); + xfer += (*_iter108).write(oprot); } xfer += oprot->writeListEnd(); } @@ -1852,10 +2467,10 @@ uint32_t ConditionalUpdates::write(::apache::thrift::protocol::TProtocol* oprot) xfer += oprot->writeFieldBegin("updates", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->updates.size())); - std::vector<ColumnUpdate> ::const_iterator _iter81; - for (_iter81 = this->updates.begin(); _iter81 != this->updates.end(); ++_iter81) + std::vector<ColumnUpdate> ::const_iterator _iter109; + for (_iter109 = this->updates.begin(); _iter109 != this->updates.end(); ++_iter109) { - xfer += (*_iter81).write(oprot); + xfer += (*_iter109).write(oprot); } xfer += oprot->writeListEnd(); } @@ -1873,11 +2488,58 @@ void swap(ConditionalUpdates &a, ConditionalUpdates &b) { swap(a.__isset, b.__isset); } -const char* ConditionalWriterOptions::ascii_fingerprint = "C345C04E84A351638B6EACB741BD600E"; -const uint8_t ConditionalWriterOptions::binary_fingerprint[16] = {0xC3,0x45,0xC0,0x4E,0x84,0xA3,0x51,0x63,0x8B,0x6E,0xAC,0xB7,0x41,0xBD,0x60,0x0E}; +ConditionalUpdates::ConditionalUpdates(const ConditionalUpdates& other110) { + conditions = other110.conditions; + updates = other110.updates; + __isset = other110.__isset; +} +ConditionalUpdates& ConditionalUpdates::operator=(const ConditionalUpdates& other111) { + conditions = other111.conditions; + updates = other111.updates; + __isset = other111.__isset; + return *this; +} +void ConditionalUpdates::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "ConditionalUpdates("; + out << "conditions=" << to_string(conditions); + out << ", " << "updates=" << to_string(updates); + out << ")"; +} + + +ConditionalWriterOptions::~ConditionalWriterOptions() throw() { +} + + +void ConditionalWriterOptions::__set_maxMemory(const int64_t val) { + this->maxMemory = val; +__isset.maxMemory = true; +} + +void ConditionalWriterOptions::__set_timeoutMs(const int64_t val) { + this->timeoutMs = val; +__isset.timeoutMs = true; +} + +void ConditionalWriterOptions::__set_threads(const int32_t val) { + this->threads = val; +__isset.threads = true; +} + +void ConditionalWriterOptions::__set_authorizations(const std::set<std::string> & val) { + this->authorizations = val; +__isset.authorizations = true; +} + +void ConditionalWriterOptions::__set_durability(const Durability::type val) { + this->durability = val; +__isset.durability = true; +} uint32_t ConditionalWriterOptions::read(::apache::thrift::protocol::TProtocol* iprot) { + apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; std::string fname; ::apache::thrift::protocol::TType ftype; @@ -1924,15 +2586,15 @@ uint32_t ConditionalWriterOptions::read(::apache::thrift::protocol::TProtocol* i if (ftype == ::apache::thrift::protocol::T_SET) { { this->authorizations.clear(); - uint32_t _size82; - ::apache::thrift::protocol::TType _etype85; - xfer += iprot->readSetBegin(_etype85, _size82); - uint32_t _i86; - for (_i86 = 0; _i86 < _size82; ++_i86) + uint32_t _size112; + ::apache::thrift::protocol::TType _etype115; + xfer += iprot->readSetBegin(_etype115, _size112); + uint32_t _i116; + for (_i116 = 0; _i116 < _size112; ++_i116) { - std::string _elem87; - xfer += iprot->readBinary(_elem87); - this->authorizations.insert(_elem87); + std::string _elem117; + xfer += iprot->readBinary(_elem117); + this->authorizations.insert(_elem117); } xfer += iprot->readSetEnd(); } @@ -1943,9 +2605,9 @@ uint32_t ConditionalWriterOptions::read(::apache::thrift::protocol::TProtocol* i break; case 5: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast88; - xfer += iprot->readI32(ecast88); - this->durability = (Durability::type)ecast88; + int32_t ecast118; + xfer += iprot->readI32(ecast118); + this->durability = (Durability::type)ecast118; this->__isset.durability = true; } else { xfer += iprot->skip(ftype); @@ -1965,6 +2627,7 @@ uint32_t ConditionalWriterOptions::read(::apache::thrift::protocol::TProtocol* i uint32_t ConditionalWriterOptions::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); xfer += oprot->writeStructBegin("ConditionalWriterOptions"); if (this->__isset.maxMemory) { @@ -1986,10 +2649,10 @@ uint32_t ConditionalWriterOptions::write(::apache::thrift::protocol::TProtocol* xfer += oprot->writeFieldBegin("authorizations", ::apache::thrift::protocol::T_SET, 4); { xfer += oprot->writeSetBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->authorizations.size())); - std::set<std::string> ::const_iterator _iter89; - for (_iter89 = this->authorizations.begin(); _iter89 != this->authorizations.end(); ++_iter89) + std::set<std::string> ::const_iterator _iter119; + for (_iter119 = this->authorizations.begin(); _iter119 != this->authorizations.end(); ++_iter119) { - xfer += oprot->writeBinary((*_iter89)); + xfer += oprot->writeBinary((*_iter119)); } xfer += oprot->writeSetEnd(); } @@ -2015,11 +2678,86 @@ void swap(ConditionalWriterOptions &a, ConditionalWriterOptions &b) { swap(a.__isset, b.__isset); } -const char* ActiveScan::ascii_fingerprint = "1B97541CB4E900A054266BBBEE61D004"; -const uint8_t ActiveScan::binary_fingerprint[16] = {0x1B,0x97,0x54,0x1C,0xB4,0xE9,0x00,0xA0,0x54,0x26,0x6B,0xBB,0xEE,0x61,0xD0,0x04}; +ConditionalWriterOptions::ConditionalWriterOptions(const ConditionalWriterOptions& other120) { + maxMemory = other120.maxMemory; + timeoutMs = other120.timeoutMs; + threads = other120.threads; + authorizations = other120.authorizations; + durability = other120.durability; + __isset = other120.__isset; +} +ConditionalWriterOptions& ConditionalWriterOptions::operator=(const ConditionalWriterOptions& other121) { + maxMemory = other121.maxMemory; + timeoutMs = other121.timeoutMs; + threads = other121.threads; + authorizations = other121.authorizations; + durability = other121.durability; + __isset = other121.__isset; + return *this; +} +void ConditionalWriterOptions::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "ConditionalWriterOptions("; + out << "maxMemory="; (__isset.maxMemory ? (out << to_string(maxMemory)) : (out << "<null>")); + out << ", " << "timeoutMs="; (__isset.timeoutMs ? (out << to_string(timeoutMs)) : (out << "<null>")); + out << ", " << "threads="; (__isset.threads ? (out << to_string(threads)) : (out << "<null>")); + out << ", " << "authorizations="; (__isset.authorizations ? (out << to_string(authorizations)) : (out << "<null>")); + out << ", " << "durability="; (__isset.durability ? (out << to_string(durability)) : (out << "<null>")); + out << ")"; +} + + +ActiveScan::~ActiveScan() throw() { +} + + +void ActiveScan::__set_client(const std::string& val) { + this->client = val; +} + +void ActiveScan::__set_user(const std::string& val) { + this->user = val; +} + +void ActiveScan::__set_table(const std::string& val) { + this->table = val; +} + +void ActiveScan::__set_age(const int64_t val) { + this->age = val; +} + +void ActiveScan::__set_idleTime(const int64_t val) { + this->idleTime = val; +} + +void ActiveScan::__set_type(const ScanType::type val) { + this->type = val; +} + +void ActiveScan::__set_state(const ScanState::type val) { + this->state = val; +} + +void ActiveScan::__set_extent(const KeyExtent& val) { + this->extent = val; +} + +void ActiveScan::__set_columns(const std::vector<Column> & val) { + this->columns = val; +} + +void ActiveScan::__set_iterators(const std::vector<IteratorSetting> & val) { + this->iterators = val; +} + +void ActiveScan::__set_authorizations(const std::vector<std::string> & val) { + this->authorizations = val; +} uint32_t ActiveScan::read(::apache::thrift::protocol::TProtocol* iprot) { + apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; std::string fname; ::apache::thrift::protocol::TType ftype; @@ -2080,9 +2818,9 @@ uint32_t ActiveScan::read(::apache::thrift::protocol::TProtocol* iprot) { break; case 6: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast90; - xfer += iprot->readI32(ecast90); - this->type = (ScanType::type)ecast90; + int32_t ecast122; + xfer += iprot->readI32(ecast122); + this->type = (ScanType::type)ecast122; this->__isset.type = true; } else { xfer += iprot->skip(ftype); @@ -2090,9 +2828,9 @@ uint32_t ActiveScan::read(::apache::thrift::protocol::TProtocol* iprot) { break; case 7: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast91; - xfer += iprot->readI32(ecast91); - this->state = (ScanState::type)ecast91; + int32_t ecast123; + xfer += iprot->readI32(ecast123); + this->state = (ScanState::type)ecast123; this->__isset.state = true; } else { xfer += iprot->skip(ftype); @@ -2110,14 +2848,14 @@ uint32_t ActiveScan::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->columns.clear(); - uint32_t _size92; - ::apache::thrift::protocol::TType _etype95; - xfer += iprot->readListBegin(_etype95, _size92); - this->columns.resize(_size92); - uint32_t _i96; - for (_i96 = 0; _i96 < _size92; ++_i96) + uint32_t _size124; + ::apache::thrift::protocol::TType _etype127; + xfer += iprot->readListBegin(_etype127, _size124); + this->columns.resize(_size124); + uint32_t _i128; + for (_i128 = 0; _i128 < _size124; ++_i128) { - xfer += this->columns[_i96].read(iprot); + xfer += this->columns[_i128].read(iprot); } xfer += iprot->readListEnd(); } @@ -2130,14 +2868,14 @@ uint32_t ActiveScan::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->iterators.clear(); - uint32_t _size97; - ::apache::thrift::protocol::TType _etype100; - xfer += iprot->readListBegin(_etype100, _size97); - this->iterators.resize(_size97); - uint32_t _i101; - for (_i101 = 0; _i101 < _size97; ++_i101) + uint32_t _size129; + ::apache::thrift::protocol::TType _etype132; + xfer += iprot->readListBegin(_etype132, _size129); + this->iterators.resize(_size129); + uint32_t _i133; + for (_i133 = 0; _i133 < _size129; ++_i133) { - xfer += this->iterators[_i101].read(iprot); + xfer += this->iterators[_i133].read(iprot); } xfer += iprot->readListEnd(); } @@ -2150,14 +2888,14 @@ uint32_t ActiveScan::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->authorizations.clear(); - uint32_t _size102; - ::apache::thrift::protocol::TType _etype105; - xfer += iprot->readListBegin(_etype105, _size102); - this->authorizations.resize(_size102); - uint32_t _i106; - for (_i106 = 0; _i106 < _size102; ++_i106) + uint32_t _size134; + ::apache::thrift::protocol::TType _etype137; + xfer += iprot->readListBegin(_etype137, _size134); + this->authorizations.resize(_size134); + uint32_t _i138; + for (_i138 = 0; _i138 < _size134; ++_i138) { - xfer += iprot->readBinary(this->authorizations[_i106]); + xfer += iprot->readBinary(this->authorizations[_i138]); } xfer += iprot->readListEnd(); } @@ -2180,6 +2918,7 @@ uint32_t ActiveScan::read(::apache::thrift::protocol::TProtocol* iprot) { uint32_t ActiveScan::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); xfer += oprot->writeStructBegin("ActiveScan"); xfer += oprot->writeFieldBegin("client", ::apache::thrift::protocol::T_STRING, 1); @@ -2217,10 +2956,10 @@ uint32_t ActiveScan::write(::apache::thrift::protocol::TProtocol* oprot) const { xfer += oprot->writeFieldBegin("columns", ::apache::thrift::protocol::T_LIST, 9); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->columns.size())); - std::vector<Column> ::const_iterator _iter107; - for (_iter107 = this->columns.begin(); _iter107 != this->columns.end(); ++_iter107) + std::vector<Column> ::const_iterator _iter139; + for (_iter139 = this->columns.begin(); _iter139 != this->columns.end(); ++_iter139) { - xfer += (*_iter107).write(oprot); + xfer += (*_iter139).write(oprot); } xfer += oprot->writeListEnd(); } @@ -2229,10 +2968,10 @@ uint32_t ActiveScan::write(::apache::thrift::protocol::TProtocol* oprot) const { xfer += oprot->writeFieldBegin("iterators", ::apache::thrift::protocol::T_LIST, 10); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->iterators.size())); - std::vector<IteratorSetting> ::const_iterator _iter108; - for (_iter108 = this->iterators.begin(); _iter108 != this->iterators.end(); ++_iter108) + std::vector<IteratorSetting> ::const_iterator _iter140; + for (_iter140 = this->iterators.begin(); _iter140 != this->iterators.end(); ++_iter140) { - xfer += (*_iter108).write(oprot); + xfer += (*_iter140).write(oprot); } xfer += oprot->writeListEnd(); } @@ -2241,10 +2980,10 @@ uint32_t ActiveScan::write(::apache::thrift::protocol::TProtocol* oprot) const { xfer += oprot->writeFieldBegin("authorizations", ::apache::thrift::protocol::T_LIST, 11); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->authorizations.size())); - std::vector<std::string> ::const_iterator _iter109; - for (_iter109 = this->authorizations.begin(); _iter109 != this->authorizations.end(); ++_iter109) + std::vector<std::string> ::const_iterator _iter141; + for (_iter141 = this->authorizations.begin(); _iter141 != this->authorizations.end(); ++_iter141) { - xfer += oprot->writeBinary((*_iter109)); + xfer += oprot->writeBinary((*_iter141)); } xfer += oprot->writeListEnd(); } @@ -2271,11 +3010,100 @@ void swap(ActiveScan &a, ActiveScan &b) { swap(a.__isset, b.__isset); } -const char* ActiveCompaction::ascii_fingerprint = "2BB155CC901109464666B6C7E6A8C1A6"; -const uint8_t ActiveCompaction::binary_fingerprint[16] = {0x2B,0xB1,0x55,0xCC,0x90,0x11,0x09,0x46,0x46,0x66,0xB6,0xC7,0xE6,0xA8,0xC1,0xA6}; +ActiveScan::ActiveScan(const ActiveScan& other142) { + client = other142.client; + user = other142.user; + table = other142.table; + age = other142.age; + idleTime = other142.idleTime; + type = other142.type; + state = other142.state; + extent = other142.extent; + columns = other142.columns; + iterators = other142.iterators; + authorizations = other142.authorizations; + __isset = other142.__isset; +} +ActiveScan& ActiveScan::operator=(const ActiveScan& other143) { + client = other143.client; + user = other143.user; + table = other143.table; + age = other143.age; + idleTime = other143.idleTime; + type = other143.type; + state = other143.state; + extent = other143.extent; + columns = other143.columns; + iterators = other143.iterators; + authorizations = other143.authorizations; + __isset = other143.__isset; + return *this; +} +void ActiveScan::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "ActiveScan("; + out << "client=" << to_string(client); + out << ", " << "user=" << to_string(user); + out << ", " << "table=" << to_string(table); + out << ", " << "age=" << to_string(age); + out << ", " << "idleTime=" << to_string(idleTime); + out << ", " << "type=" << to_string(type); + out << ", " << "state=" << to_string(state); + out << ", " << "extent=" << to_string(extent); + out << ", " << "columns=" << to_string(columns); + out << ", " << "iterators=" << to_string(iterators); + out << ", " << "authorizations=" << to_string(authorizations); + out << ")"; +} + + +ActiveCompaction::~ActiveCompaction() throw() { +} + + +void ActiveCompaction::__set_extent(const KeyExtent& val) { + this->extent = val; +} + +void ActiveCompaction::__set_age(const int64_t val) { + this->age = val; +} + +void ActiveCompaction::__set_inputFiles(const std::vector<std::string> & val) { + this->inputFiles = val; +} + +void ActiveCompaction::__set_outputFile(const std::string& val) { + this->outputFile = val; +} + +void ActiveCompaction::__set_type(const CompactionType::type val) { + this->type = val; +} + +void ActiveCompaction::__set_reason(const CompactionReason::type val) { + this->reason = val; +} + +void ActiveCompaction::__set_localityGroup(const std::string& val) { + this->localityGroup = val; +} + +void ActiveCompaction::__set_entriesRead(const int64_t val) { + this->entriesRead = val; +} + +void ActiveCompaction::__set_entriesWritten(const int64_t val) { + this->entriesWritten = val; +} + +void ActiveCompaction::__set_iterators(const std::vector<IteratorSetting> & val) { + this->iterators = val; +} uint32_t ActiveCompaction::read(::apache::thrift::protocol::TProtocol* iprot) { + apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; std::string fname; ::apache::thrift::protocol::TType ftype; @@ -2314,14 +3142,14 @@ uint32_t ActiveCompaction::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->inputFiles.clear(); - uint32_t _size110; - ::apache::thrift::protocol::TType _etype113; - xfer += iprot->readListBegin(_etype113, _size110); - this->inputFiles.resize(_size110); - uint32_t _i114; - for (_i114 = 0; _i114 < _size110; ++_i114) + uint32_t _size144; + ::apache::thrift::protocol::TType _etype147; + xfer += iprot->readListBegin(_etype147, _size144); + this->inputFiles.resize(_size144); + uint32_t _i148; + for (_i148 = 0; _i148 < _size144; ++_i148) { - xfer += iprot->readString(this->inputFiles[_i114]); + xfer += iprot->readString(this->inputFiles[_i148]); } xfer += iprot->readListEnd(); } @@ -2340,9 +3168,9 @@ uint32_t ActiveCompaction::read(::apache::thrift::protocol::TProtocol* iprot) { break; case 5: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast115; - xfer += iprot->readI32(ecast115); - this->type = (CompactionType::type)ecast115; + int32_t ecast149; + xfer += iprot->readI32(ecast149); + this->type = (CompactionType::type)ecast149; this->__isset.type = true; } else { xfer += iprot->skip(ftype); @@ -2350,9 +3178,9 @@ uint32_t ActiveCompaction::read(::apache::thrift::protocol::TProtocol* iprot) { break; case 6: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast116; - xfer += iprot->readI32(ecast116); - this->reason = (CompactionReason::type)ecast116; + int32_t ecast150; + xfer += iprot->readI32(ecast150); + this->reason = (CompactionReason::type)ecast150; this->__isset.reason = true; } else { xfer += iprot->skip(ftype); @@ -2386,14 +3214,14 @@ uint32_t ActiveCompaction::read(::apache::thrift::protocol::TProtocol* iprot) { if (ftype == ::apache::thrift::protocol::T_LIST) { { this->iterators.clear(); - uint32_t _size117; - ::apache::thrift::protocol::TType _etype120; - xfer += iprot->readListBegin(_etype120, _size117); - this->iterators.resize(_size117); - uint32_t _i121; - for (_i121 = 0; _i121 < _size117; ++_i121) + uint32_t _size151; + ::apache::thrift::protocol::TType _etype154; + xfer += iprot->readListBegin(_etype154, _size151); + this->iterators.resize(_size151); + uint32_t _i155; + for (_i155 = 0; _i155 < _size151; ++_i155) { - xfer += this->iterators[_i121].read(iprot); + xfer += this->iterators[_i155].read(iprot); } xfer += iprot->readListEnd(); } @@ -2416,6 +3244,7 @@ uint32_t ActiveCompaction::read(::apache::thrift::protocol::TProtocol* iprot) { uint32_t ActiveCompaction::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); xfer += oprot->writeStructBegin("ActiveCompaction"); xfer += oprot->writeFieldBegin("extent", ::apache::thrift::protocol::T_STRUCT, 1); @@ -2429,10 +3258,10 @@ uint32_t ActiveCompaction::write(::apache::thrift::protocol::TProtocol* oprot) c xfer += oprot->writeFieldBegin("inputFiles", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->inputFiles.size())); - std::vector<std::string> ::const_iterator _iter122; - for (_iter122 = this->inputFiles.begin(); _iter122 != this->inputFiles.end(); ++_iter122) + std::vector<std::string> ::const_iterator _iter156; + for (_iter156 = this->inputFiles.begin(); _iter156 != this->inputFiles.end(); ++_iter156) { - xfer += oprot->writeString((*_iter122)); + xfer += oprot->writeString((*_iter156)); } xfer += oprot->writeListEnd(); } @@ -2465,10 +3294,10 @@ uint32_t ActiveCompaction::write(::apache::thrift::protocol::TProtocol* oprot) c xfer += oprot->writeFieldBegin("iterators", ::apache::thrift::protocol::T_LIST, 10); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->iterators.size())); - std::vector<IteratorSetting> ::const_iterator _iter123; - for (_iter123 = this->iterators.begin(); _iter123 != this->iterators.end(); ++_iter123) + std::vector<IteratorSetting> ::const_iterator _iter157; + for (_iter157 = this->iterators.begin(); _iter157 != this->iterators.end(); ++_iter157) { - xfer += (*_iter123).write(oprot); + xfer += (*_iter157).write(oprot); } xfer += oprot->writeListEnd(); } @@ -2494,11 +3323,78 @@ void swap(ActiveCompaction &a, ActiveCompaction &b) { swap(a.__isset, b.__isset); } -const char* WriterOptions::ascii_fingerprint = "6640C55D2C0D4C8C2E7589456EA0C61A"; -const uint8_t WriterOptions::binary_fingerprint[16] = {0x66,0x40,0xC5,0x5D,0x2C,0x0D,0x4C,0x8C,0x2E,0x75,0x89,0x45,0x6E,0xA0,0xC6,0x1A}; +ActiveCompaction::ActiveCompaction(const ActiveCompaction& other158) { + extent = other158.extent; + age = other158.age; + inputFiles = other158.inputFiles; + outputFile = other158.outputFile; + type = other158.type; + reason = other158.reason; + localityGroup = other158.localityGroup; + entriesRead = other158.entriesRead; + entriesWritten = other158.entriesWritten; + iterators = other158.iterators; + __isset = other158.__isset; +} +ActiveCompaction& ActiveCompaction::operator=(const ActiveCompaction& other159) { + extent = other159.extent; + age = other159.age; + inputFiles = other159.inputFiles; + outputFile = other159.outputFile; + type = other159.type; + reason = other159.reason; + localityGroup = other159.localityGroup; + entriesRead = other159.entriesRead; + entriesWritten = other159.entriesWritten; + iterators = other159.iterators; + __isset = other159.__isset; + return *this; +} +void ActiveCompaction::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "ActiveCompaction("; + out << "extent=" << to_string(extent); + out << ", " << "age=" << to_string(age); + out << ", " << "inputFiles=" << to_string(inputFiles); + out << ", " << "outputFile=" << to_string(outputFile); + out << ", " << "type=" << to_string(type); + out << ", " << "reason=" << to_string(reason); + out << ", " << "localityGroup=" << to_string(localityGroup); + out << ", " << "entriesRead=" << to_string(entriesRead); + out << ", " << "entriesWritten=" << to_string(entriesWritten); + out << ", " << "iterators=" << to_string(iterators); + out << ")"; +} + + +WriterOptions::~WriterOptions() throw() { +} + + +void WriterOptions::__set_maxMemory(const int64_t val) { + this->maxMemory = val; +} + +void WriterOptions::__set_latencyMs(const int64_t val) { + this->latencyMs = val; +} + +void WriterOptions::__set_timeoutMs(const int64_t val) { + this->timeoutMs = val; +} + +void WriterOptions::__set_threads(const int32_t val) { + this->threads = val; +} + +void WriterOptions::__set_durability(const Durability::type val) { + this->durability = val; +__isset.durability = true; +} uint32_t WriterOptions::read(::apache::thrift::protocol::TProtocol* iprot) { + apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; std::string fname; ::apache::thrift::protocol::TType ftype; @@ -2551,9 +3447,9 @@ uint32_t WriterOptions::read(::apache::thrift::protocol::TProtocol* iprot) { break; case 5: if (ftype == ::apache::thrift::protocol::T_I32) { - int32_t ecast124; - xfer += iprot->readI32(ecast124); - this->durability = (Durability::type)ecast124; + int32_t ecast160; + xfer += iprot->readI32(ecast160); + this->durability = (Durability::type)ecast160; this->__isset.durability = true; } else { xfer += iprot->skip(ftype); @@ -2573,6 +3469,7 @@ uint32_t WriterOptions::read(::apache::thrift::protocol::TProtocol* iprot) { uint32_t WriterOptions::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); xfer += oprot->writeStructBegin("WriterOptions"); xfer += oprot->writeFieldBegin("maxMemory", ::apache::thrift::protocol::T_I64, 1); @@ -2611,11 +3508,50 @@ void swap(WriterOptions &a, WriterOptions &b) { swap(a.__isset, b.__isset); } -const char* CompactionStrategyConfig::ascii_fingerprint = "F7C641917C22B35AE581CCD54910B00D"; -const uint8_t CompactionStrategyConfig::binary_fingerprint[16] = {0xF7,0xC6,0x41,0x91,0x7C,0x22,0xB3,0x5A,0xE5,0x81,0xCC,0xD5,0x49,0x10,0xB0,0x0D}; +WriterOptions::WriterOptions(const WriterOptions& other161) { + maxMemory = other161.maxMemory; + latencyMs = other161.latencyMs; + timeoutMs = other161.timeoutMs; + threads = other161.threads; + durability = other161.durability; + __isset = other161.__isset; +} +WriterOptions& WriterOptions::operator=(const WriterOptions& other162) { + maxMemory = other162.maxMemory; + latencyMs = other162.latencyMs; + timeoutMs = other162.timeoutMs; + threads = other162.threads; + durability = other162.durability; + __isset = other162.__isset; + return *this; +} +void WriterOptions::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "WriterOptions("; + out << "maxMemory=" << to_string(maxMemory); + out << ", " << "latencyMs=" << to_string(latencyMs); + out << ", " << "timeoutMs=" << to_string(timeoutMs); + out << ", " << "threads=" << to_string(threads); + out << ", " << "durability="; (__isset.durability ? (out << to_string(durability)) : (out << "<null>")); + out << ")"; +} + + +CompactionStrategyConfig::~CompactionStrategyConfig() throw() { +} + + +void CompactionStrategyConfig::__set_className(const std::string& val) { + this->className = val; +} + +void CompactionStrategyConfig::__set_options(const std::map<std::string, std::string> & val) { + this->options = val; +} uint32_t CompactionStrategyConfig::read(::apache::thrift::protocol::TProtocol* iprot) { + apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; std::string fname; ::apache::thrift::protocol::TType ftype; @@ -2646,17 +3582,17 @@ uint32_t CompactionStrategyConfig::read(::apache::thrift::protocol::TProtocol* i if (ftype == ::apache::thrift::protocol::T_MAP) { { this->options.clear(); - uint32_t _size125; - ::apache::thrift::protocol::TType _ktype126; - ::apache::thrift::protocol::TType _vtype127; - xfer += iprot->readMapBegin(_ktype126, _vtype127, _size125); - uint32_t _i129; - for (_i129 = 0; _i129 < _size125; ++_i129) + uint32_t _size163; + ::apache::thrift::protocol::TType _ktype164; + ::apache::thrift::protocol::TType _vtype165; + xfer += iprot->readMapBegin(_ktype164, _vtype165, _size163); + uint32_t _i167; + for (_i167 = 0; _i167 < _size163; ++_i167) { - std::string _key130; - xfer += iprot->readString(_key130); - std::string& _val131 = this->options[_key130]; - xfer += iprot->readString(_val131); + std::string _key168; + xfer += iprot->readString(_key168); + std::string& _val169 = this->options[_key168]; + xfer += iprot->readString(_val169); } xfer += iprot->readMapEnd(); } @@ -2679,6 +3615,7 @@ uint32_t CompactionStrategyConfig::read(::apache::thrift::protocol::TProtocol* i uint32_t CompactionStrategyConfig::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); xfer += oprot->writeStructBegin("CompactionStrategyConfig"); xfer += oprot->writeFieldBegin("className", ::apache::thrift::protocol::T_STRING, 1); @@ -2688,11 +3625,11 @@ uint32_t CompactionStrategyConfig::write(::apache::thrift::protocol::TProtocol* xfer += oprot->writeFieldBegin("options", ::apache::thrift::protocol::T_MAP, 2); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->options.size())); - std::map<std::string, std::string> ::const_iterator _iter132; - for (_iter132 = this->options.begin(); _iter132 != this->options.end(); ++_iter132) + std::map<std::string, std::string> ::const_iterator _iter170; + for (_iter170 = this->options.begin(); _iter170 != this->options.end(); ++_iter170) { - xfer += oprot->writeString(_iter132->first); - xfer += oprot->writeString(_iter132->second); + xfer += oprot->writeString(_iter170->first); + xfer += oprot->writeString(_iter170->second); } xfer += oprot->writeMapEnd(); } @@ -2710,11 +3647,37 @@ void swap(CompactionStrategyConfig &a, CompactionStrategyConfig &b) { swap(a.__isset, b.__isset); } -const char* UnknownScanner::ascii_fingerprint = "EFB929595D312AC8F305D5A794CFEDA1"; -const uint8_t UnknownScanner::binary_fingerprint[16] = {0xEF,0xB9,0x29,0x59,0x5D,0x31,0x2A,0xC8,0xF3,0x05,0xD5,0xA7,0x94,0xCF,0xED,0xA1}; +CompactionStrategyConfig::CompactionStrategyConfig(const CompactionStrategyConfig& other171) { + className = other171.className; + options = other171.options; + __isset = other171.__isset; +} +CompactionStrategyConfig& CompactionStrategyConfig::operator=(const CompactionStrategyConfig& other172) { + className = other172.className; + options = other172.options; + __isset = other172.__isset; + return *this; +} +void CompactionStrategyConfig::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "CompactionStrategyConfig("; + out << "className=" << to_string(className); + out << ", " << "options=" << to_string(options); + out << ")"; +} + + +UnknownScanner::~UnknownScanner() throw() { +} + + +void UnknownScanner::__set_msg(const std::string& val) { + this->msg = val; +} uint32_t UnknownScanner::read(::apache::thrift::protocol::TProtocol* iprot) { + apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; std::string fname; ::apache::thrift::protocol::TType ftype; @@ -2755,6 +3718,7 @@ uint32_t UnknownScanner::read(::apache::thrift::protocol::TProtocol* iprot) { uint32_t UnknownScanner::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); xfer += oprot->writeStructBegin("UnknownScanner"); xfer += oprot->writeFieldBegin("msg", ::apache::thrift::protocol::T_STRING, 1); @@ -2772,11 +3736,45 @@ void swap(UnknownScanner &a, UnknownScanner &b) { swap(a.__isset, b.__isset); } -const char* UnknownWriter::ascii_fingerprint = "EFB929595D312AC8F305D5A794CFEDA1"; -const uint8_t UnknownWriter::binary_fingerprint[16] = {0xEF,0xB9,0x29,0x59,0x5D,0x31,0x2A,0xC8,0xF3,0x05,0xD5,0xA7,0x94,0xCF,0xED,0xA1}; +UnknownScanner::UnknownScanner(const UnknownScanner& other173) : TException() { + msg = other173.msg; + __isset = other173.__isset; +} +UnknownScanner& UnknownScanner::operator=(const UnknownScanner& other174) { + msg = other174.msg; + __isset = other174.__isset; + return *this; +} +void UnknownScanner::printTo(std::ostream& out) const { + using ::apache::thrift::to_string; + out << "UnknownScanner("; + out << "msg=" << to_string(msg); + out << ")"; +} + +const char* UnknownScanner::what() const throw() { + try { + std::stringstream ss; + ss << "TException - service has thrown: " << *this; + this->thriftTExceptionMessageHolder_ = ss.str(); + return this->thriftTExceptionMessageHolder_.c_str(); + } catch (const std::exception&) { + return "TException - service has thrown: UnknownScanner"; + } +} + + +UnknownWriter::~UnknownWriter() throw() { +} + + +void UnknownWriter::__set_msg(const std::string& val) { + this->msg = val; +} uint32_t UnknownWriter::read(::apache::thrift::protocol::TProtocol* iprot) { + apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); uint32_t xfer = 0; std::string fname; ::apache::thrift::protocol::TType ftype; @@ -2817,6 +3815,7 @@ uint32_t UnknownWriter::read(::apache::thrift::protocol::TProtocol* iprot) { uint32_t UnknownWriter::write(::apache::thrift::protocol::TProtocol* oprot) const { uint32_t xfer = 0; + apache::thrift::protocol::TOutputRecursionTracker tracker(*op
<TRUNCATED>
