| /* |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You under the Apache License, Version 2.0 |
| * (the "License"); you may not use this file except in compliance with |
| * the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| /** |
| * Autogenerated by Thrift Compiler (0.9.3) |
| * |
| * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING |
| * @generated |
| */ |
| #include "proxy_types.h" |
| |
| #include <algorithm> |
| #include <ostream> |
| |
| #include <thrift/TToString.h> |
| |
| namespace accumulo { |
| |
| int _kPartialKeyValues[] = { |
| PartialKey::ROW, |
| PartialKey::ROW_COLFAM, |
| PartialKey::ROW_COLFAM_COLQUAL, |
| PartialKey::ROW_COLFAM_COLQUAL_COLVIS, |
| PartialKey::ROW_COLFAM_COLQUAL_COLVIS_TIME, |
| PartialKey::ROW_COLFAM_COLQUAL_COLVIS_TIME_DEL |
| }; |
| const char* _kPartialKeyNames[] = { |
| "ROW", |
| "ROW_COLFAM", |
| "ROW_COLFAM_COLQUAL", |
| "ROW_COLFAM_COLQUAL_COLVIS", |
| "ROW_COLFAM_COLQUAL_COLVIS_TIME", |
| "ROW_COLFAM_COLQUAL_COLVIS_TIME_DEL" |
| }; |
| const std::map<int, const char*> _PartialKey_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(6, _kPartialKeyValues, _kPartialKeyNames), ::apache::thrift::TEnumIterator(-1, NULL, NULL)); |
| |
| int _kTablePermissionValues[] = { |
| TablePermission::READ, |
| TablePermission::WRITE, |
| TablePermission::BULK_IMPORT, |
| TablePermission::ALTER_TABLE, |
| TablePermission::GRANT, |
| TablePermission::DROP_TABLE |
| }; |
| const char* _kTablePermissionNames[] = { |
| "READ", |
| "WRITE", |
| "BULK_IMPORT", |
| "ALTER_TABLE", |
| "GRANT", |
| "DROP_TABLE" |
| }; |
| const std::map<int, const char*> _TablePermission_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(6, _kTablePermissionValues, _kTablePermissionNames), ::apache::thrift::TEnumIterator(-1, NULL, NULL)); |
| |
| int _kSystemPermissionValues[] = { |
| SystemPermission::GRANT, |
| SystemPermission::CREATE_TABLE, |
| SystemPermission::DROP_TABLE, |
| SystemPermission::ALTER_TABLE, |
| SystemPermission::CREATE_USER, |
| SystemPermission::DROP_USER, |
| SystemPermission::ALTER_USER, |
| SystemPermission::SYSTEM, |
| SystemPermission::CREATE_NAMESPACE, |
| SystemPermission::DROP_NAMESPACE, |
| SystemPermission::ALTER_NAMESPACE, |
| SystemPermission::OBTAIN_DELEGATION_TOKEN |
| }; |
| const char* _kSystemPermissionNames[] = { |
| "GRANT", |
| "CREATE_TABLE", |
| "DROP_TABLE", |
| "ALTER_TABLE", |
| "CREATE_USER", |
| "DROP_USER", |
| "ALTER_USER", |
| "SYSTEM", |
| "CREATE_NAMESPACE", |
| "DROP_NAMESPACE", |
| "ALTER_NAMESPACE", |
| "OBTAIN_DELEGATION_TOKEN" |
| }; |
| const std::map<int, const char*> _SystemPermission_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(12, _kSystemPermissionValues, _kSystemPermissionNames), ::apache::thrift::TEnumIterator(-1, NULL, NULL)); |
| |
| int _kNamespacePermissionValues[] = { |
| NamespacePermission::READ, |
| NamespacePermission::WRITE, |
| NamespacePermission::ALTER_NAMESPACE, |
| NamespacePermission::GRANT, |
| NamespacePermission::ALTER_TABLE, |
| NamespacePermission::CREATE_TABLE, |
| NamespacePermission::DROP_TABLE, |
| NamespacePermission::BULK_IMPORT, |
| NamespacePermission::DROP_NAMESPACE |
| }; |
| const char* _kNamespacePermissionNames[] = { |
| "READ", |
| "WRITE", |
| "ALTER_NAMESPACE", |
| "GRANT", |
| "ALTER_TABLE", |
| "CREATE_TABLE", |
| "DROP_TABLE", |
| "BULK_IMPORT", |
| "DROP_NAMESPACE" |
| }; |
| const std::map<int, const char*> _NamespacePermission_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(9, _kNamespacePermissionValues, _kNamespacePermissionNames), ::apache::thrift::TEnumIterator(-1, NULL, NULL)); |
| |
| int _kScanTypeValues[] = { |
| ScanType::SINGLE, |
| ScanType::BATCH |
| }; |
| const char* _kScanTypeNames[] = { |
| "SINGLE", |
| "BATCH" |
| }; |
| const std::map<int, const char*> _ScanType_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(2, _kScanTypeValues, _kScanTypeNames), ::apache::thrift::TEnumIterator(-1, NULL, NULL)); |
| |
| int _kScanStateValues[] = { |
| ScanState::IDLE, |
| ScanState::RUNNING, |
| ScanState::QUEUED |
| }; |
| const char* _kScanStateNames[] = { |
| "IDLE", |
| "RUNNING", |
| "QUEUED" |
| }; |
| const std::map<int, const char*> _ScanState_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(3, _kScanStateValues, _kScanStateNames), ::apache::thrift::TEnumIterator(-1, NULL, NULL)); |
| |
| int _kConditionalStatusValues[] = { |
| ConditionalStatus::ACCEPTED, |
| ConditionalStatus::REJECTED, |
| ConditionalStatus::VIOLATED, |
| ConditionalStatus::UNKNOWN, |
| ConditionalStatus::INVISIBLE_VISIBILITY |
| }; |
| const char* _kConditionalStatusNames[] = { |
| "ACCEPTED", |
| "REJECTED", |
| "VIOLATED", |
| "UNKNOWN", |
| "INVISIBLE_VISIBILITY" |
| }; |
| const std::map<int, const char*> _ConditionalStatus_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(5, _kConditionalStatusValues, _kConditionalStatusNames), ::apache::thrift::TEnumIterator(-1, NULL, NULL)); |
| |
| int _kDurabilityValues[] = { |
| Durability::DEFAULT, |
| Durability::NONE, |
| Durability::LOG, |
| Durability::FLUSH, |
| Durability::SYNC |
| }; |
| const char* _kDurabilityNames[] = { |
| "DEFAULT", |
| "NONE", |
| "LOG", |
| "FLUSH", |
| "SYNC" |
| }; |
| const std::map<int, const char*> _Durability_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(5, _kDurabilityValues, _kDurabilityNames), ::apache::thrift::TEnumIterator(-1, NULL, NULL)); |
| |
| int _kCompactionTypeValues[] = { |
| CompactionType::MINOR, |
| CompactionType::MERGE, |
| CompactionType::MAJOR, |
| CompactionType::FULL |
| }; |
| const char* _kCompactionTypeNames[] = { |
| "MINOR", |
| "MERGE", |
| "MAJOR", |
| "FULL" |
| }; |
| const std::map<int, const char*> _CompactionType_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(4, _kCompactionTypeValues, _kCompactionTypeNames), ::apache::thrift::TEnumIterator(-1, NULL, NULL)); |
| |
| int _kCompactionReasonValues[] = { |
| CompactionReason::USER, |
| CompactionReason::SYSTEM, |
| CompactionReason::CHOP, |
| CompactionReason::IDLE, |
| CompactionReason::CLOSE |
| }; |
| const char* _kCompactionReasonNames[] = { |
| "USER", |
| "SYSTEM", |
| "CHOP", |
| "IDLE", |
| "CLOSE" |
| }; |
| const std::map<int, const char*> _CompactionReason_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(5, _kCompactionReasonValues, _kCompactionReasonNames), ::apache::thrift::TEnumIterator(-1, NULL, NULL)); |
| |
| int _kIteratorScopeValues[] = { |
| IteratorScope::MINC, |
| IteratorScope::MAJC, |
| IteratorScope::SCAN |
| }; |
| const char* _kIteratorScopeNames[] = { |
| "MINC", |
| "MAJC", |
| "SCAN" |
| }; |
| const std::map<int, const char*> _IteratorScope_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(3, _kIteratorScopeValues, _kIteratorScopeNames), ::apache::thrift::TEnumIterator(-1, NULL, NULL)); |
| |
| int _kTimeTypeValues[] = { |
| TimeType::LOGICAL, |
| TimeType::MILLIS |
| }; |
| const char* _kTimeTypeNames[] = { |
| "LOGICAL", |
| "MILLIS" |
| }; |
| const std::map<int, const char*> _TimeType_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(2, _kTimeTypeValues, _kTimeTypeNames), ::apache::thrift::TEnumIterator(-1, NULL, NULL)); |
| |
| |
| 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; |
| int16_t fid; |
| |
| xfer += iprot->readStructBegin(fname); |
| |
| using ::apache::thrift::protocol::TProtocolException; |
| |
| |
| while (true) |
| { |
| xfer += iprot->readFieldBegin(fname, ftype, fid); |
| if (ftype == ::apache::thrift::protocol::T_STOP) { |
| break; |
| } |
| switch (fid) |
| { |
| case 1: |
| if (ftype == ::apache::thrift::protocol::T_STRING) { |
| xfer += iprot->readBinary(this->row); |
| this->__isset.row = true; |
| } else { |
| xfer += iprot->skip(ftype); |
| } |
| break; |
| case 2: |
| if (ftype == ::apache::thrift::protocol::T_STRING) { |
| xfer += iprot->readBinary(this->colFamily); |
| this->__isset.colFamily = true; |
| } else { |
| xfer += iprot->skip(ftype); |
| } |
| break; |
| case 3: |
| if (ftype == ::apache::thrift::protocol::T_STRING) { |
| xfer += iprot->readBinary(this->colQualifier); |
| this->__isset.colQualifier = true; |
| } else { |
| xfer += iprot->skip(ftype); |
| } |
| break; |
| case 4: |
| if (ftype == ::apache::thrift::protocol::T_STRING) { |
| xfer += iprot->readBinary(this->colVisibility); |
| this->__isset.colVisibility = true; |
| } else { |
| xfer += iprot->skip(ftype); |
| } |
| break; |
| case 5: |
| if (ftype == ::apache::thrift::protocol::T_I64) { |
| xfer += iprot->readI64(this->timestamp); |
| this->__isset.timestamp = true; |
| } else { |
| xfer += iprot->skip(ftype); |
| } |
| break; |
| default: |
| xfer += iprot->skip(ftype); |
| break; |
| } |
| xfer += iprot->readFieldEnd(); |
| } |
| |
| xfer += iprot->readStructEnd(); |
| |
| return xfer; |
| } |
| |
| 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); |
| xfer += oprot->writeBinary(this->row); |
| xfer += oprot->writeFieldEnd(); |
| |
| xfer += oprot->writeFieldBegin("colFamily", ::apache::thrift::protocol::T_STRING, 2); |
| xfer += oprot->writeBinary(this->colFamily); |
| xfer += oprot->writeFieldEnd(); |
| |
| xfer += oprot->writeFieldBegin("colQualifier", ::apache::thrift::protocol::T_STRING, 3); |
| xfer += oprot->writeBinary(this->colQualifier); |
| xfer += oprot->writeFieldEnd(); |
| |
| xfer += oprot->writeFieldBegin("colVisibility", ::apache::thrift::protocol::T_STRING, 4); |
| xfer += oprot->writeBinary(this->colVisibility); |
| xfer += oprot->writeFieldEnd(); |
| |
| if (this->__isset.timestamp) { |
| xfer += oprot->writeFieldBegin("timestamp", ::apache::thrift::protocol::T_I64, 5); |
| xfer += oprot->writeI64(this->timestamp); |
| xfer += oprot->writeFieldEnd(); |
| } |
| xfer += oprot->writeFieldStop(); |
| xfer += oprot->writeStructEnd(); |
| return xfer; |
| } |
| |
| void swap(Key &a, Key &b) { |
| using ::std::swap; |
| swap(a.row, b.row); |
| swap(a.colFamily, b.colFamily); |
| swap(a.colQualifier, b.colQualifier); |
| swap(a.colVisibility, b.colVisibility); |
| swap(a.timestamp, b.timestamp); |
| swap(a.__isset, b.__isset); |
| } |
| |
| 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; |
| int16_t fid; |
| |
| xfer += iprot->readStructBegin(fname); |
| |
| using ::apache::thrift::protocol::TProtocolException; |
| |
| |
| while (true) |
| { |
| xfer += iprot->readFieldBegin(fname, ftype, fid); |
| if (ftype == ::apache::thrift::protocol::T_STOP) { |
| break; |
| } |
| switch (fid) |
| { |
| case 1: |
| if (ftype == ::apache::thrift::protocol::T_STRING) { |
| xfer += iprot->readBinary(this->colFamily); |
| this->__isset.colFamily = true; |
| } else { |
| xfer += iprot->skip(ftype); |
| } |
| break; |
| case 2: |
| if (ftype == ::apache::thrift::protocol::T_STRING) { |
| xfer += iprot->readBinary(this->colQualifier); |
| this->__isset.colQualifier = true; |
| } else { |
| xfer += iprot->skip(ftype); |
| } |
| break; |
| case 3: |
| if (ftype == ::apache::thrift::protocol::T_STRING) { |
| xfer += iprot->readBinary(this->colVisibility); |
| this->__isset.colVisibility = true; |
| } else { |
| xfer += iprot->skip(ftype); |
| } |
| break; |
| case 4: |
| if (ftype == ::apache::thrift::protocol::T_I64) { |
| xfer += iprot->readI64(this->timestamp); |
| this->__isset.timestamp = true; |
| } else { |
| xfer += iprot->skip(ftype); |
| } |
| break; |
| case 5: |
| if (ftype == ::apache::thrift::protocol::T_STRING) { |
| xfer += iprot->readBinary(this->value); |
| this->__isset.value = true; |
| } else { |
| xfer += iprot->skip(ftype); |
| } |
| break; |
| case 6: |
| if (ftype == ::apache::thrift::protocol::T_BOOL) { |
| xfer += iprot->readBool(this->deleteCell); |
| this->__isset.deleteCell = true; |
| } else { |
| xfer += iprot->skip(ftype); |
| } |
| break; |
| default: |
| xfer += iprot->skip(ftype); |
| break; |
| } |
| xfer += iprot->readFieldEnd(); |
| } |
| |
| xfer += iprot->readStructEnd(); |
| |
| return xfer; |
| } |
| |
| 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); |
| xfer += oprot->writeBinary(this->colFamily); |
| xfer += oprot->writeFieldEnd(); |
| |
| xfer += oprot->writeFieldBegin("colQualifier", ::apache::thrift::protocol::T_STRING, 2); |
| xfer += oprot->writeBinary(this->colQualifier); |
| xfer += oprot->writeFieldEnd(); |
| |
| if (this->__isset.colVisibility) { |
| xfer += oprot->writeFieldBegin("colVisibility", ::apache::thrift::protocol::T_STRING, 3); |
| xfer += oprot->writeBinary(this->colVisibility); |
| xfer += oprot->writeFieldEnd(); |
| } |
| if (this->__isset.timestamp) { |
| xfer += oprot->writeFieldBegin("timestamp", ::apache::thrift::protocol::T_I64, 4); |
| xfer += oprot->writeI64(this->timestamp); |
| xfer += oprot->writeFieldEnd(); |
| } |
| if (this->__isset.value) { |
| xfer += oprot->writeFieldBegin("value", ::apache::thrift::protocol::T_STRING, 5); |
| xfer += oprot->writeBinary(this->value); |
| xfer += oprot->writeFieldEnd(); |
| } |
| if (this->__isset.deleteCell) { |
| xfer += oprot->writeFieldBegin("deleteCell", ::apache::thrift::protocol::T_BOOL, 6); |
| xfer += oprot->writeBool(this->deleteCell); |
| xfer += oprot->writeFieldEnd(); |
| } |
| xfer += oprot->writeFieldStop(); |
| xfer += oprot->writeStructEnd(); |
| return xfer; |
| } |
| |
| void swap(ColumnUpdate &a, ColumnUpdate &b) { |
| using ::std::swap; |
| swap(a.colFamily, b.colFamily); |
| swap(a.colQualifier, b.colQualifier); |
| swap(a.colVisibility, b.colVisibility); |
| swap(a.timestamp, b.timestamp); |
| swap(a.value, b.value); |
| swap(a.deleteCell, b.deleteCell); |
| swap(a.__isset, b.__isset); |
| } |
| |
| 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; |
| int16_t fid; |
| |
| xfer += iprot->readStructBegin(fname); |
| |
| using ::apache::thrift::protocol::TProtocolException; |
| |
| |
| while (true) |
| { |
| xfer += iprot->readFieldBegin(fname, ftype, fid); |
| if (ftype == ::apache::thrift::protocol::T_STOP) { |
| break; |
| } |
| switch (fid) |
| { |
| case 1: |
| if (ftype == ::apache::thrift::protocol::T_LIST) { |
| { |
| this->tables.clear(); |
| 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[_i8]); |
| } |
| xfer += iprot->readListEnd(); |
| } |
| this->__isset.tables = true; |
| } else { |
| xfer += iprot->skip(ftype); |
| } |
| break; |
| case 2: |
| if (ftype == ::apache::thrift::protocol::T_I64) { |
| xfer += iprot->readI64(this->usage); |
| this->__isset.usage = true; |
| } else { |
| xfer += iprot->skip(ftype); |
| } |
| break; |
| default: |
| xfer += iprot->skip(ftype); |
| break; |
| } |
| xfer += iprot->readFieldEnd(); |
| } |
| |
| xfer += iprot->readStructEnd(); |
| |
| return xfer; |
| } |
| |
| 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 _iter9; |
| for (_iter9 = this->tables.begin(); _iter9 != this->tables.end(); ++_iter9) |
| { |
| xfer += oprot->writeString((*_iter9)); |
| } |
| xfer += oprot->writeListEnd(); |
| } |
| xfer += oprot->writeFieldEnd(); |
| |
| xfer += oprot->writeFieldBegin("usage", ::apache::thrift::protocol::T_I64, 2); |
| xfer += oprot->writeI64(this->usage); |
| xfer += oprot->writeFieldEnd(); |
| |
| xfer += oprot->writeFieldStop(); |
| xfer += oprot->writeStructEnd(); |
| return xfer; |
| } |
| |
| void swap(DiskUsage &a, DiskUsage &b) { |
| using ::std::swap; |
| swap(a.tables, b.tables); |
| swap(a.usage, b.usage); |
| swap(a.__isset, b.__isset); |
| } |
| |
| 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; |
| int16_t fid; |
| |
| xfer += iprot->readStructBegin(fname); |
| |
| using ::apache::thrift::protocol::TProtocolException; |
| |
| |
| while (true) |
| { |
| xfer += iprot->readFieldBegin(fname, ftype, fid); |
| if (ftype == ::apache::thrift::protocol::T_STOP) { |
| break; |
| } |
| switch (fid) |
| { |
| case 1: |
| if (ftype == ::apache::thrift::protocol::T_STRUCT) { |
| xfer += this->key.read(iprot); |
| this->__isset.key = true; |
| } else { |
| xfer += iprot->skip(ftype); |
| } |
| break; |
| case 2: |
| if (ftype == ::apache::thrift::protocol::T_STRING) { |
| xfer += iprot->readBinary(this->value); |
| this->__isset.value = true; |
| } else { |
| xfer += iprot->skip(ftype); |
| } |
| break; |
| default: |
| xfer += iprot->skip(ftype); |
| break; |
| } |
| xfer += iprot->readFieldEnd(); |
| } |
| |
| xfer += iprot->readStructEnd(); |
| |
| return xfer; |
| } |
| |
| uint32_t 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); |
| xfer += this->key.write(oprot); |
| xfer += oprot->writeFieldEnd(); |
| |
| xfer += oprot->writeFieldBegin("value", ::apache::thrift::protocol::T_STRING, 2); |
| xfer += oprot->writeBinary(this->value); |
| xfer += oprot->writeFieldEnd(); |
| |
| xfer += oprot->writeFieldStop(); |
| xfer += oprot->writeStructEnd(); |
| return xfer; |
| } |
| |
| void swap(KeyValue &a, KeyValue &b) { |
| using ::std::swap; |
| swap(a.key, b.key); |
| swap(a.value, b.value); |
| swap(a.__isset, b.__isset); |
| } |
| |
| 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; |
| int16_t fid; |
| |
| xfer += iprot->readStructBegin(fname); |
| |
| using ::apache::thrift::protocol::TProtocolException; |
| |
| |
| while (true) |
| { |
| xfer += iprot->readFieldBegin(fname, ftype, fid); |
| if (ftype == ::apache::thrift::protocol::T_STOP) { |
| break; |
| } |
| switch (fid) |
| { |
| case 1: |
| if (ftype == ::apache::thrift::protocol::T_LIST) { |
| { |
| this->results.clear(); |
| 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[_i18].read(iprot); |
| } |
| xfer += iprot->readListEnd(); |
| } |
| this->__isset.results = true; |
| } else { |
| xfer += iprot->skip(ftype); |
| } |
| break; |
| case 2: |
| if (ftype == ::apache::thrift::protocol::T_BOOL) { |
| xfer += iprot->readBool(this->more); |
| this->__isset.more = true; |
| } else { |
| xfer += iprot->skip(ftype); |
| } |
| break; |
| default: |
| xfer += iprot->skip(ftype); |
| break; |
| } |
| xfer += iprot->readFieldEnd(); |
| } |
| |
| xfer += iprot->readStructEnd(); |
| |
| return xfer; |
| } |
| |
| 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 _iter19; |
| for (_iter19 = this->results.begin(); _iter19 != this->results.end(); ++_iter19) |
| { |
| xfer += (*_iter19).write(oprot); |
| } |
| xfer += oprot->writeListEnd(); |
| } |
| xfer += oprot->writeFieldEnd(); |
| |
| xfer += oprot->writeFieldBegin("more", ::apache::thrift::protocol::T_BOOL, 2); |
| xfer += oprot->writeBool(this->more); |
| xfer += oprot->writeFieldEnd(); |
| |
| xfer += oprot->writeFieldStop(); |
| xfer += oprot->writeStructEnd(); |
| return xfer; |
| } |
| |
| void swap(ScanResult &a, ScanResult &b) { |
| using ::std::swap; |
| swap(a.results, b.results); |
| swap(a.more, b.more); |
| swap(a.__isset, b.__isset); |
| } |
| |
| 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; |
| int16_t fid; |
| |
| xfer += iprot->readStructBegin(fname); |
| |
| using ::apache::thrift::protocol::TProtocolException; |
| |
| |
| while (true) |
| { |
| xfer += iprot->readFieldBegin(fname, ftype, fid); |
| if (ftype == ::apache::thrift::protocol::T_STOP) { |
| break; |
| } |
| switch (fid) |
| { |
| case 1: |
| if (ftype == ::apache::thrift::protocol::T_STRUCT) { |
| xfer += this->start.read(iprot); |
| this->__isset.start = true; |
| } else { |
| xfer += iprot->skip(ftype); |
| } |
| break; |
| case 2: |
| if (ftype == ::apache::thrift::protocol::T_BOOL) { |
| xfer += iprot->readBool(this->startInclusive); |
| this->__isset.startInclusive = true; |
| } else { |
| xfer += iprot->skip(ftype); |
| } |
| break; |
| case 3: |
| if (ftype == ::apache::thrift::protocol::T_STRUCT) { |
| xfer += this->stop.read(iprot); |
| this->__isset.stop = true; |
| } else { |
| xfer += iprot->skip(ftype); |
| } |
| break; |
| case 4: |
| if (ftype == ::apache::thrift::protocol::T_BOOL) { |
| xfer += iprot->readBool(this->stopInclusive); |
| this->__isset.stopInclusive = true; |
| } else { |
| xfer += iprot->skip(ftype); |
| } |
| break; |
| default: |
| xfer += iprot->skip(ftype); |
| break; |
| } |
| xfer += iprot->readFieldEnd(); |
| } |
| |
| xfer += iprot->readStructEnd(); |
| |
| return xfer; |
| } |
| |
| 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); |
| xfer += this->start.write(oprot); |
| xfer += oprot->writeFieldEnd(); |
| |
| xfer += oprot->writeFieldBegin("startInclusive", ::apache::thrift::protocol::T_BOOL, 2); |
| xfer += oprot->writeBool(this->startInclusive); |
| xfer += oprot->writeFieldEnd(); |
| |
| xfer += oprot->writeFieldBegin("stop", ::apache::thrift::protocol::T_STRUCT, 3); |
| xfer += this->stop.write(oprot); |
| xfer += oprot->writeFieldEnd(); |
| |
| xfer += oprot->writeFieldBegin("stopInclusive", ::apache::thrift::protocol::T_BOOL, 4); |
| xfer += oprot->writeBool(this->stopInclusive); |
| xfer += oprot->writeFieldEnd(); |
| |
| xfer += oprot->writeFieldStop(); |
| xfer += oprot->writeStructEnd(); |
| return xfer; |
| } |
| |
| void swap(Range &a, Range &b) { |
| using ::std::swap; |
| swap(a.start, b.start); |
| swap(a.startInclusive, b.startInclusive); |
| swap(a.stop, b.stop); |
| swap(a.stopInclusive, b.stopInclusive); |
| swap(a.__isset, b.__isset); |
| } |
| |
| 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; |
| int16_t fid; |
| |
| xfer += iprot->readStructBegin(fname); |
| |
| using ::apache::thrift::protocol::TProtocolException; |
| |
| |
| while (true) |
| { |
| xfer += iprot->readFieldBegin(fname, ftype, fid); |
| if (ftype == ::apache::thrift::protocol::T_STOP) { |
| break; |
| } |
| switch (fid) |
| { |
| case 1: |
| if (ftype == ::apache::thrift::protocol::T_STRING) { |
| xfer += iprot->readBinary(this->colFamily); |
| this->__isset.colFamily = true; |
| } else { |
| xfer += iprot->skip(ftype); |
| } |
| break; |
| case 2: |
| if (ftype == ::apache::thrift::protocol::T_STRING) { |
| xfer += iprot->readBinary(this->colQualifier); |
| this->__isset.colQualifier = true; |
| } else { |
| xfer += iprot->skip(ftype); |
| } |
| break; |
| default: |
| xfer += iprot->skip(ftype); |
| break; |
| } |
| xfer += iprot->readFieldEnd(); |
| } |
| |
| xfer += iprot->readStructEnd(); |
| |
| return xfer; |
| } |
| |
| 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); |
| xfer += oprot->writeBinary(this->colFamily); |
| xfer += oprot->writeFieldEnd(); |
| |
| if (this->__isset.colQualifier) { |
| xfer += oprot->writeFieldBegin("colQualifier", ::apache::thrift::protocol::T_STRING, 2); |
| xfer += oprot->writeBinary(this->colQualifier); |
| xfer += oprot->writeFieldEnd(); |
| } |
| xfer += oprot->writeFieldStop(); |
| xfer += oprot->writeStructEnd(); |
| return xfer; |
| } |
| |
| void swap(ScanColumn &a, ScanColumn &b) { |
| using ::std::swap; |
| swap(a.colFamily, b.colFamily); |
| swap(a.colQualifier, b.colQualifier); |
| swap(a.__isset, b.__isset); |
| } |
| |
| 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; |
| int16_t fid; |
| |
| xfer += iprot->readStructBegin(fname); |
| |
| using ::apache::thrift::protocol::TProtocolException; |
| |
| |
| while (true) |
| { |
| xfer += iprot->readFieldBegin(fname, ftype, fid); |
| if (ftype == ::apache::thrift::protocol::T_STOP) { |
| break; |
| } |
| switch (fid) |
| { |
| case 1: |
| if (ftype == ::apache::thrift::protocol::T_I32) { |
| xfer += iprot->readI32(this->priority); |
| this->__isset.priority = true; |
| } else { |
| xfer += iprot->skip(ftype); |
| } |
| break; |
| case 2: |
| if (ftype == ::apache::thrift::protocol::T_STRING) { |
| xfer += iprot->readString(this->name); |
| this->__isset.name = true; |
| } else { |
| xfer += iprot->skip(ftype); |
| } |
| break; |
| case 3: |
| if (ftype == ::apache::thrift::protocol::T_STRING) { |
| xfer += iprot->readString(this->iteratorClass); |
| this->__isset.iteratorClass = true; |
| } else { |
| xfer += iprot->skip(ftype); |
| } |
| break; |
| case 4: |
| if (ftype == ::apache::thrift::protocol::T_MAP) { |
| { |
| this->properties.clear(); |
| 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 _key31; |
| xfer += iprot->readString(_key31); |
| std::string& _val32 = this->properties[_key31]; |
| xfer += iprot->readString(_val32); |
| } |
| xfer += iprot->readMapEnd(); |
| } |
| this->__isset.properties = true; |
| } else { |
| xfer += iprot->skip(ftype); |
| } |
| break; |
| default: |
| xfer += iprot->skip(ftype); |
| break; |
| } |
| xfer += iprot->readFieldEnd(); |
| } |
| |
| xfer += iprot->readStructEnd(); |
| |
| return xfer; |
| } |
| |
| 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); |
| xfer += oprot->writeI32(this->priority); |
| xfer += oprot->writeFieldEnd(); |
| |
| xfer += oprot->writeFieldBegin("name", ::apache::thrift::protocol::T_STRING, 2); |
| xfer += oprot->writeString(this->name); |
| xfer += oprot->writeFieldEnd(); |
| |
| xfer += oprot->writeFieldBegin("iteratorClass", ::apache::thrift::protocol::T_STRING, 3); |
| xfer += oprot->writeString(this->iteratorClass); |
| xfer += oprot->writeFieldEnd(); |
| |
| 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 _iter33; |
| for (_iter33 = this->properties.begin(); _iter33 != this->properties.end(); ++_iter33) |
| { |
| xfer += oprot->writeString(_iter33->first); |
| xfer += oprot->writeString(_iter33->second); |
| } |
| xfer += oprot->writeMapEnd(); |
| } |
| xfer += oprot->writeFieldEnd(); |
| |
| xfer += oprot->writeFieldStop(); |
| xfer += oprot->writeStructEnd(); |
| return xfer; |
| } |
| |
| void swap(IteratorSetting &a, IteratorSetting &b) { |
| using ::std::swap; |
| swap(a.priority, b.priority); |
| swap(a.name, b.name); |
| swap(a.iteratorClass, b.iteratorClass); |
| swap(a.properties, b.properties); |
| swap(a.__isset, b.__isset); |
| } |
| |
| 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; |
| int16_t fid; |
| |
| xfer += iprot->readStructBegin(fname); |
| |
| using ::apache::thrift::protocol::TProtocolException; |
| |
| |
| while (true) |
| { |
| xfer += iprot->readFieldBegin(fname, ftype, fid); |
| if (ftype == ::apache::thrift::protocol::T_STOP) { |
| break; |
| } |
| switch (fid) |
| { |
| case 1: |
| if (ftype == ::apache::thrift::protocol::T_SET) { |
| { |
| this->authorizations.clear(); |
| uint32_t _size36; |
| ::apache::thrift::protocol::TType _etype39; |
| xfer += iprot->readSetBegin(_etype39, _size36); |
| uint32_t _i40; |
| for (_i40 = 0; _i40 < _size36; ++_i40) |
| { |
| std::string _elem41; |
| xfer += iprot->readBinary(_elem41); |
| this->authorizations.insert(_elem41); |
| } |
| xfer += iprot->readSetEnd(); |
| } |
| this->__isset.authorizations = true; |
| } else { |
| xfer += iprot->skip(ftype); |
| } |
| break; |
| case 2: |
| if (ftype == ::apache::thrift::protocol::T_STRUCT) { |
| xfer += this->range.read(iprot); |
| this->__isset.range = true; |
| } else { |
| xfer += iprot->skip(ftype); |
| } |
| break; |
| case 3: |
| if (ftype == ::apache::thrift::protocol::T_LIST) { |
| { |
| this->columns.clear(); |
| 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[_i46].read(iprot); |
| } |
| xfer += iprot->readListEnd(); |
| } |
| this->__isset.columns = true; |
| } else { |
| xfer += iprot->skip(ftype); |
| } |
| break; |
| case 4: |
| if (ftype == ::apache::thrift::protocol::T_LIST) { |
| { |
| this->iterators.clear(); |
| 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[_i51].read(iprot); |
| } |
| xfer += iprot->readListEnd(); |
| } |
| this->__isset.iterators = true; |
| } else { |
| xfer += iprot->skip(ftype); |
| } |
| break; |
| case 5: |
| if (ftype == ::apache::thrift::protocol::T_I32) { |
| xfer += iprot->readI32(this->bufferSize); |
| this->__isset.bufferSize = true; |
| } else { |
| xfer += iprot->skip(ftype); |
| } |
| break; |
| default: |
| xfer += iprot->skip(ftype); |
| break; |
| } |
| xfer += iprot->readFieldEnd(); |
| } |
| |
| xfer += iprot->readStructEnd(); |
| |
| return xfer; |
| } |
| |
| 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 _iter52; |
| for (_iter52 = this->authorizations.begin(); _iter52 != this->authorizations.end(); ++_iter52) |
| { |
| xfer += oprot->writeBinary((*_iter52)); |
| } |
| xfer += oprot->writeSetEnd(); |
| } |
| xfer += oprot->writeFieldEnd(); |
| } |
| if (this->__isset.range) { |
| xfer += oprot->writeFieldBegin("range", ::apache::thrift::protocol::T_STRUCT, 2); |
| xfer += this->range.write(oprot); |
| xfer += oprot->writeFieldEnd(); |
| } |
| if (this->__isset.columns) { |
| 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 _iter53; |
| for (_iter53 = this->columns.begin(); _iter53 != this->columns.end(); ++_iter53) |
| { |
| xfer += (*_iter53).write(oprot); |
| } |
| xfer += oprot->writeListEnd(); |
| } |
| xfer += oprot->writeFieldEnd(); |
| } |
| if (this->__isset.iterators) { |
| 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 _iter54; |
| for (_iter54 = this->iterators.begin(); _iter54 != this->iterators.end(); ++_iter54) |
| { |
| xfer += (*_iter54).write(oprot); |
| } |
| xfer += oprot->writeListEnd(); |
| } |
| xfer += oprot->writeFieldEnd(); |
| } |
| if (this->__isset.bufferSize) { |
| xfer += oprot->writeFieldBegin("bufferSize", ::apache::thrift::protocol::T_I32, 5); |
| xfer += oprot->writeI32(this->bufferSize); |
| xfer += oprot->writeFieldEnd(); |
| } |
| xfer += oprot->writeFieldStop(); |
| xfer += oprot->writeStructEnd(); |
| return xfer; |
| } |
| |
| void swap(ScanOptions &a, ScanOptions &b) { |
| using ::std::swap; |
| swap(a.authorizations, b.authorizations); |
| swap(a.range, b.range); |
| swap(a.columns, b.columns); |
| swap(a.iterators, b.iterators); |
| swap(a.bufferSize, b.bufferSize); |
| swap(a.__isset, b.__isset); |
| } |
| |
| 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; |
| int16_t fid; |
| |
| xfer += iprot->readStructBegin(fname); |
| |
| using ::apache::thrift::protocol::TProtocolException; |
| |
| |
| while (true) |
| { |
| xfer += iprot->readFieldBegin(fname, ftype, fid); |
| if (ftype == ::apache::thrift::protocol::T_STOP) { |
| break; |
| } |
| switch (fid) |
| { |
| case 1: |
| if (ftype == ::apache::thrift::protocol::T_SET) { |
| { |
| this->authorizations.clear(); |
| uint32_t _size57; |
| ::apache::thrift::protocol::TType _etype60; |
| xfer += iprot->readSetBegin(_etype60, _size57); |
| uint32_t _i61; |
| for (_i61 = 0; _i61 < _size57; ++_i61) |
| { |
| std::string _elem62; |
| xfer += iprot->readBinary(_elem62); |
| this->authorizations.insert(_elem62); |
| } |
| xfer += iprot->readSetEnd(); |
| } |
| this->__isset.authorizations = true; |
| } else { |
| xfer += iprot->skip(ftype); |
| } |
| break; |
| case 2: |
| if (ftype == ::apache::thrift::protocol::T_LIST) { |
| { |
| this->ranges.clear(); |
| 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[_i67].read(iprot); |
| } |
| xfer += iprot->readListEnd(); |
| } |
| this->__isset.ranges = true; |
| } else { |
| xfer += iprot->skip(ftype); |
| } |
| break; |
| case 3: |
| if (ftype == ::apache::thrift::protocol::T_LIST) { |
| { |
| this->columns.clear(); |
| 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[_i72].read(iprot); |
| } |
| xfer += iprot->readListEnd(); |
| } |
| this->__isset.columns = true; |
| } else { |
| xfer += iprot->skip(ftype); |
| } |
| break; |
| case 4: |
| if (ftype == ::apache::thrift::protocol::T_LIST) { |
| { |
| this->iterators.clear(); |
| 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[_i77].read(iprot); |
| } |
| xfer += iprot->readListEnd(); |
| } |
| this->__isset.iterators = true; |
| } else { |
| xfer += iprot->skip(ftype); |
| } |
| break; |
| case 5: |
| if (ftype == ::apache::thrift::protocol::T_I32) { |
| xfer += iprot->readI32(this->threads); |
| this->__isset.threads = true; |
| } else { |
| xfer += iprot->skip(ftype); |
| } |
| break; |
| default: |
| xfer += iprot->skip(ftype); |
| break; |
| } |
| xfer += iprot->readFieldEnd(); |
| } |
| |
| xfer += iprot->readStructEnd(); |
| |
| return xfer; |
| } |
| |
| 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 _iter78; |
| for (_iter78 = this->authorizations.begin(); _iter78 != this->authorizations.end(); ++_iter78) |
| { |
| xfer += oprot->writeBinary((*_iter78)); |
| } |
| xfer += oprot->writeSetEnd(); |
| } |
| xfer += oprot->writeFieldEnd(); |
| } |
| if (this->__isset.ranges) { |
| 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 _iter79; |
| for (_iter79 = this->ranges.begin(); _iter79 != this->ranges.end(); ++_iter79) |
| { |
| xfer += (*_iter79).write(oprot); |
| } |
| xfer += oprot->writeListEnd(); |
| } |
| xfer += oprot->writeFieldEnd(); |
| } |
| if (this->__isset.columns) { |
| 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 _iter80; |
| for (_iter80 = this->columns.begin(); _iter80 != this->columns.end(); ++_iter80) |
| { |
| xfer += (*_iter80).write(oprot); |
| } |
| xfer += oprot->writeListEnd(); |
| } |
| xfer += oprot->writeFieldEnd(); |
| } |
| if (this->__isset.iterators) { |
| 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 _iter81; |
| for (_iter81 = this->iterators.begin(); _iter81 != this->iterators.end(); ++_iter81) |
| { |
| xfer += (*_iter81).write(oprot); |
| } |
| xfer += oprot->writeListEnd(); |
| } |
| xfer += oprot->writeFieldEnd(); |
| } |
| if (this->__isset.threads) { |
| xfer += oprot->writeFieldBegin("threads", ::apache::thrift::protocol::T_I32, 5); |
| xfer += oprot->writeI32(this->threads); |
| xfer += oprot->writeFieldEnd(); |
| } |
| xfer += oprot->writeFieldStop(); |
| xfer += oprot->writeStructEnd(); |
| return xfer; |
| } |
| |
| void swap(BatchScanOptions &a, BatchScanOptions &b) { |
| using ::std::swap; |
| swap(a.authorizations, b.authorizations); |
| swap(a.ranges, b.ranges); |
| swap(a.columns, b.columns); |
| swap(a.iterators, b.iterators); |
| swap(a.threads, b.threads); |
| swap(a.__isset, b.__isset); |
| } |
| |
| 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; |
| int16_t fid; |
| |
| xfer += iprot->readStructBegin(fname); |
| |
| using ::apache::thrift::protocol::TProtocolException; |
| |
| |
| while (true) |
| { |
| xfer += iprot->readFieldBegin(fname, ftype, fid); |
| if (ftype == ::apache::thrift::protocol::T_STOP) { |
| break; |
| } |
| switch (fid) |
| { |
| case 1: |
| if (ftype == ::apache::thrift::protocol::T_STRUCT) { |
| xfer += this->keyValue.read(iprot); |
| this->__isset.keyValue = true; |
| } else { |
| xfer += iprot->skip(ftype); |
| } |
| break; |
| case 2: |
| if (ftype == ::apache::thrift::protocol::T_BOOL) { |
| xfer += iprot->readBool(this->hasNext); |
| this->__isset.hasNext = true; |
| } else { |
| xfer += iprot->skip(ftype); |
| } |
| break; |
| default: |
| xfer += iprot->skip(ftype); |
| break; |
| } |
| xfer += iprot->readFieldEnd(); |
| } |
| |
| xfer += iprot->readStructEnd(); |
| |
| return xfer; |
| } |
| |
| 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); |
| xfer += this->keyValue.write(oprot); |
| xfer += oprot->writeFieldEnd(); |
| |
| xfer += oprot->writeFieldBegin("hasNext", ::apache::thrift::protocol::T_BOOL, 2); |
| xfer += oprot->writeBool(this->hasNext); |
| xfer += oprot->writeFieldEnd(); |
| |
| xfer += oprot->writeFieldStop(); |
| xfer += oprot->writeStructEnd(); |
| return xfer; |
| } |
| |
| void swap(KeyValueAndPeek &a, KeyValueAndPeek &b) { |
| using ::std::swap; |
| swap(a.keyValue, b.keyValue); |
| swap(a.hasNext, b.hasNext); |
| swap(a.__isset, b.__isset); |
| } |
| |
| 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; |
| int16_t fid; |
| |
| xfer += iprot->readStructBegin(fname); |
| |
| using ::apache::thrift::protocol::TProtocolException; |
| |
| |
| while (true) |
| { |
| xfer += iprot->readFieldBegin(fname, ftype, fid); |
| if (ftype == ::apache::thrift::protocol::T_STOP) { |
| break; |
| } |
| switch (fid) |
| { |
| case 1: |
| if (ftype == ::apache::thrift::protocol::T_STRING) { |
| xfer += iprot->readString(this->tableId); |
| this->__isset.tableId = true; |
| } else { |
| xfer += iprot->skip(ftype); |
| } |
| break; |
| case 2: |
| if (ftype == ::apache::thrift::protocol::T_STRING) { |
| xfer += iprot->readBinary(this->endRow); |
| this->__isset.endRow = true; |
| } else { |
| xfer += iprot->skip(ftype); |
| } |
| break; |
| case 3: |
| if (ftype == ::apache::thrift::protocol::T_STRING) { |
| xfer += iprot->readBinary(this->prevEndRow); |
| this->__isset.prevEndRow = true; |
| } else { |
| xfer += iprot->skip(ftype); |
| } |
| break; |
| default: |
| xfer += iprot->skip(ftype); |
| break; |
| } |
| xfer += iprot->readFieldEnd(); |
| } |
| |
| xfer += iprot->readStructEnd(); |
| |
| return xfer; |
| } |
| |
| 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); |
| xfer += oprot->writeString(this->tableId); |
| xfer += oprot->writeFieldEnd(); |
| |
| xfer += oprot->writeFieldBegin("endRow", ::apache::thrift::protocol::T_STRING, 2); |
| xfer += oprot->writeBinary(this->endRow); |
| xfer += oprot->writeFieldEnd(); |
| |
| xfer += oprot->writeFieldBegin("prevEndRow", ::apache::thrift::protocol::T_STRING, 3); |
| xfer += oprot->writeBinary(this->prevEndRow); |
| xfer += oprot->writeFieldEnd(); |
| |
| xfer += oprot->writeFieldStop(); |
| xfer += oprot->writeStructEnd(); |
| return xfer; |
| } |
| |
| void swap(KeyExtent &a, KeyExtent &b) { |
| using ::std::swap; |
| swap(a.tableId, b.tableId); |
| swap(a.endRow, b.endRow); |
| swap(a.prevEndRow, b.prevEndRow); |
| swap(a.__isset, b.__isset); |
| } |
| |
| 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; |
| int16_t fid; |
| |
| xfer += iprot->readStructBegin(fname); |
| |
| using ::apache::thrift::protocol::TProtocolException; |
| |
| |
| while (true) |
| { |
| xfer += iprot->readFieldBegin(fname, ftype, fid); |
| if (ftype == ::apache::thrift::protocol::T_STOP) { |
| break; |
| } |
| switch (fid) |
| { |
| case 1: |
| if (ftype == ::apache::thrift::protocol::T_STRING) { |
| xfer += iprot->readBinary(this->colFamily); |
| this->__isset.colFamily = true; |
| } else { |
| xfer += iprot->skip(ftype); |
| } |
| break; |
| case 2: |
| if (ftype == ::apache::thrift::protocol::T_STRING) { |
| xfer += iprot->readBinary(this->colQualifier); |
| this->__isset.colQualifier = true; |
| } else { |
| xfer += iprot->skip(ftype); |
| } |
| break; |
| case 3: |
| if (ftype == ::apache::thrift::protocol::T_STRING) { |
| xfer += iprot->readBinary(this->colVisibility); |
| this->__isset.colVisibility = true; |
| } else { |
| xfer += iprot->skip(ftype); |
| } |
| break; |
| default: |
| xfer += iprot->skip(ftype); |
| break; |
| } |
| xfer += iprot->readFieldEnd(); |
| } |
| |
| xfer += iprot->readStructEnd(); |
| |
| return xfer; |
| } |
| |
| 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); |
| xfer += oprot->writeBinary(this->colFamily); |
| xfer += oprot->writeFieldEnd(); |
| |
| xfer += oprot->writeFieldBegin("colQualifier", ::apache::thrift::protocol::T_STRING, 2); |
| xfer += oprot->writeBinary(this->colQualifier); |
| xfer += oprot->writeFieldEnd(); |
| |
| xfer += oprot->writeFieldBegin("colVisibility", ::apache::thrift::protocol::T_STRING, 3); |
| xfer += oprot->writeBinary(this->colVisibility); |
| xfer += oprot->writeFieldEnd(); |
| |
| xfer += oprot->writeFieldStop(); |
| xfer += oprot->writeStructEnd(); |
| return xfer; |
| } |
| |
| void swap(Column &a, Column &b) { |
| using ::std::swap; |
| swap(a.colFamily, b.colFamily); |
| swap(a.colQualifier, b.colQualifier); |
| swap(a.colVisibility, b.colVisibility); |
| swap(a.__isset, b.__isset); |
| } |
| |
| 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; |
| int16_t fid; |
| |
| xfer += iprot->readStructBegin(fname); |
| |
| using ::apache::thrift::protocol::TProtocolException; |
| |
| |
| while (true) |
| { |
| xfer += iprot->readFieldBegin(fname, ftype, fid); |
| if (ftype == ::apache::thrift::protocol::T_STOP) { |
| break; |
| } |
| switch (fid) |
| { |
| case 1: |
| if (ftype == ::apache::thrift::protocol::T_STRUCT) { |
| xfer += this->column.read(iprot); |
| this->__isset.column = true; |
| } else { |
| xfer += iprot->skip(ftype); |
| } |
| break; |
| case 2: |
| if (ftype == ::apache::thrift::protocol::T_I64) { |
| xfer += iprot->readI64(this->timestamp); |
| this->__isset.timestamp = true; |
| } else { |
| xfer += iprot->skip(ftype); |
| } |
| break; |
| case 3: |
| if (ftype == ::apache::thrift::protocol::T_STRING) { |
| xfer += iprot->readBinary(this->value); |
| this->__isset.value = true; |
| } else { |
| xfer += iprot->skip(ftype); |
| } |
| break; |
| case 4: |
| if (ftype == ::apache::thrift::protocol::T_LIST) { |
| { |
| this->iterators.clear(); |
| 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[_i94].read(iprot); |
| } |
| xfer += iprot->readListEnd(); |
| } |
| this->__isset.iterators = true; |
| } else { |
| xfer += iprot->skip(ftype); |
| } |
| break; |
| default: |
| xfer += iprot->skip(ftype); |
| break; |
| } |
| xfer += iprot->readFieldEnd(); |
| } |
| |
| xfer += iprot->readStructEnd(); |
| |
| return xfer; |
| } |
| |
| 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); |
| xfer += this->column.write(oprot); |
| xfer += oprot->writeFieldEnd(); |
| |
| if (this->__isset.timestamp) { |
| xfer += oprot->writeFieldBegin("timestamp", ::apache::thrift::protocol::T_I64, 2); |
| xfer += oprot->writeI64(this->timestamp); |
| xfer += oprot->writeFieldEnd(); |
| } |
| if (this->__isset.value) { |
| xfer += oprot->writeFieldBegin("value", ::apache::thrift::protocol::T_STRING, 3); |
| xfer += oprot->writeBinary(this->value); |
| xfer += oprot->writeFieldEnd(); |
| } |
| if (this->__isset.iterators) { |
| 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 _iter95; |
| for (_iter95 = this->iterators.begin(); _iter95 != this->iterators.end(); ++_iter95) |
| { |
| xfer += (*_iter95).write(oprot); |
| } |
| xfer += oprot->writeListEnd(); |
| } |
| xfer += oprot->writeFieldEnd(); |
| } |
| xfer += oprot->writeFieldStop(); |
| xfer += oprot->writeStructEnd(); |
| return xfer; |
| } |
| |
| void swap(Condition &a, Condition &b) { |
| using ::std::swap; |
| swap(a.column, b.column); |
| swap(a.timestamp, b.timestamp); |
| swap(a.value, b.value); |
| swap(a.iterators, b.iterators); |
| swap(a.__isset, b.__isset); |
| } |
| |
| 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; |
| int16_t fid; |
| |
| xfer += iprot->readStructBegin(fname); |
| |
| using ::apache::thrift::protocol::TProtocolException; |
| |
| |
| while (true) |
| { |
| xfer += iprot->readFieldBegin(fname, ftype, fid); |
| if (ftype == ::apache::thrift::protocol::T_STOP) { |
| break; |
| } |
| switch (fid) |
| { |
| case 2: |
| if (ftype == ::apache::thrift::protocol::T_LIST) { |
| { |
| this->conditions.clear(); |
| 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[_i102].read(iprot); |
| } |
| xfer += iprot->readListEnd(); |
| } |
| this->__isset.conditions = true; |
| } else { |
| xfer += iprot->skip(ftype); |
| } |
| break; |
| case 3: |
| if (ftype == ::apache::thrift::protocol::T_LIST) { |
| { |
| this->updates.clear(); |
| 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[_i107].read(iprot); |
| } |
| xfer += iprot->readListEnd(); |
| } |
| this->__isset.updates = true; |
| } else { |
| xfer += iprot->skip(ftype); |
| } |
| break; |
| default: |
| xfer += iprot->skip(ftype); |
| break; |
| } |
| xfer += iprot->readFieldEnd(); |
| } |
| |
| xfer += iprot->readStructEnd(); |
| |
| return xfer; |
| } |
| |
| 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 _iter108; |
| for (_iter108 = this->conditions.begin(); _iter108 != this->conditions.end(); ++_iter108) |
| { |
| xfer += (*_iter108).write(oprot); |
| } |
| xfer += oprot->writeListEnd(); |
| } |
| xfer += oprot->writeFieldEnd(); |
| |
| 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 _iter109; |
| for (_iter109 = this->updates.begin(); _iter109 != this->updates.end(); ++_iter109) |
| { |
| xfer += (*_iter109).write(oprot); |
| } |
| xfer += oprot->writeListEnd(); |
| } |
| xfer += oprot->writeFieldEnd(); |
| |
| xfer += oprot->writeFieldStop(); |
| xfer += oprot->writeStructEnd(); |
| return xfer; |
| } |
| |
| void swap(ConditionalUpdates &a, ConditionalUpdates &b) { |
| using ::std::swap; |
| swap(a.conditions, b.conditions); |
| swap(a.updates, b.updates); |
| swap(a.__isset, b.__isset); |
| } |
| |
| 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; |
| int16_t fid; |
| |
| xfer += iprot->readStructBegin(fname); |
| |
| using ::apache::thrift::protocol::TProtocolException; |
| |
| |
| while (true) |
| { |
| xfer += iprot->readFieldBegin(fname, ftype, fid); |
| if (ftype == ::apache::thrift::protocol::T_STOP) { |
| break; |
| } |
| switch (fid) |
| { |
| case 1: |
| if (ftype == ::apache::thrift::protocol::T_I64) { |
| xfer += iprot->readI64(this->maxMemory); |
| this->__isset.maxMemory = true; |
| } else { |
| xfer += iprot->skip(ftype); |
| } |
| break; |
| case 2: |
| if (ftype == ::apache::thrift::protocol::T_I64) { |
| xfer += iprot->readI64(this->timeoutMs); |
| this->__isset.timeoutMs = true; |
| } else { |
| xfer += iprot->skip(ftype); |
| } |
| break; |
| case 3: |
| if (ftype == ::apache::thrift::protocol::T_I32) { |
| xfer += iprot->readI32(this->threads); |
| this->__isset.threads = true; |
| } else { |
| xfer += iprot->skip(ftype); |
| } |
| break; |
| case 4: |
| if (ftype == ::apache::thrift::protocol::T_SET) { |
| { |
| this->authorizations.clear(); |
| uint32_t _size112; |
| ::apache::thrift::protocol::TType _etype115; |
| xfer += iprot->readSetBegin(_etype115, _size112); |
| uint32_t _i116; |
| for (_i116 = 0; _i116 < _size112; ++_i116) |
| { |
| std::string _elem117; |
| xfer += iprot->readBinary(_elem117); |
| this->authorizations.insert(_elem117); |
| } |
| xfer += iprot->readSetEnd(); |
| } |
| this->__isset.authorizations = true; |
| } else { |
| xfer += iprot->skip(ftype); |
| } |
| break; |
| case 5: |
| if (ftype == ::apache::thrift::protocol::T_I32) { |
| int32_t ecast118; |
| xfer += iprot->readI32(ecast118); |
| this->durability = (Durability::type)ecast118; |
| this->__isset.durability = true; |
| } else { |
| xfer += iprot->skip(ftype); |
| } |
| break; |
| default: |
| xfer += iprot->skip(ftype); |
| break; |
| } |
| xfer += iprot->readFieldEnd(); |
| } |
| |
| xfer += iprot->readStructEnd(); |
| |
| return xfer; |
| } |
| |
| 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) { |
| xfer += oprot->writeFieldBegin("maxMemory", ::apache::thrift::protocol::T_I64, 1); |
| xfer += oprot->writeI64(this->maxMemory); |
| xfer += oprot->writeFieldEnd(); |
| } |
| if (this->__isset.timeoutMs) { |
| xfer += oprot->writeFieldBegin("timeoutMs", ::apache::thrift::protocol::T_I64, 2); |
| xfer += oprot->writeI64(this->timeoutMs); |
| xfer += oprot->writeFieldEnd(); |
| } |
| if (this->__isset.threads) { |
| xfer += oprot->writeFieldBegin("threads", ::apache::thrift::protocol::T_I32, 3); |
| xfer += oprot->writeI32(this->threads); |
| xfer += oprot->writeFieldEnd(); |
| } |
| if (this->__isset.authorizations) { |
| 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 _iter119; |
| for (_iter119 = this->authorizations.begin(); _iter119 != this->authorizations.end(); ++_iter119) |
| { |
| xfer += oprot->writeBinary((*_iter119)); |
| } |
| xfer += oprot->writeSetEnd(); |
| } |
| xfer += oprot->writeFieldEnd(); |
| } |
| if (this->__isset.durability) { |
| xfer += oprot->writeFieldBegin("durability", ::apache::thrift::protocol::T_I32, 5); |
| xfer += oprot->writeI32((int32_t)this->durability); |
| xfer += oprot->writeFieldEnd(); |
| } |
| xfer += oprot->writeFieldStop(); |
| xfer += oprot->writeStructEnd(); |
| return xfer; |
| } |
| |
| void swap(ConditionalWriterOptions &a, ConditionalWriterOptions &b) { |
| using ::std::swap; |
| swap(a.maxMemory, b.maxMemory); |
| swap(a.timeoutMs, b.timeoutMs); |
| swap(a.threads, b.threads); |
| swap(a.authorizations, b.authorizations); |
| swap(a.durability, b.durability); |
| swap(a.__isset, b.__isset); |
| } |
| |
| 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; |
| int16_t fid; |
| |
| xfer += iprot->readStructBegin(fname); |
| |
| using ::apache::thrift::protocol::TProtocolException; |
| |
| |
| while (true) |
| { |
| xfer += iprot->readFieldBegin(fname, ftype, fid); |
| if (ftype == ::apache::thrift::protocol::T_STOP) { |
| break; |
| } |
| switch (fid) |
| { |
| case 1: |
| if (ftype == ::apache::thrift::protocol::T_STRING) { |
| xfer += iprot->readString(this->client); |
| this->__isset.client = true; |
| } else { |
| xfer += iprot->skip(ftype); |
| } |
| break; |
| case 2: |
| if (ftype == ::apache::thrift::protocol::T_STRING) { |
| xfer += iprot->readString(this->user); |
| this->__isset.user = true; |
| } else { |
| xfer += iprot->skip(ftype); |
| } |
| break; |
| case 3: |
| if (ftype == ::apache::thrift::protocol::T_STRING) { |
| xfer += iprot->readString(this->table); |
| this->__isset.table = true; |
| } else { |
| xfer += iprot->skip(ftype); |
| } |
| break; |
| case 4: |
| if (ftype == ::apache::thrift::protocol::T_I64) { |
| xfer += iprot->readI64(this->age); |
| this->__isset.age = true; |
| } else { |
| xfer += iprot->skip(ftype); |
| } |
| break; |
| case 5: |
| if (ftype == ::apache::thrift::protocol::T_I64) { |
| xfer += iprot->readI64(this->idleTime); |
| this->__isset.idleTime = true; |
| } else { |
| xfer += iprot->skip(ftype); |
| } |
| break; |
| case 6: |
| if (ftype == ::apache::thrift::protocol::T_I32) { |
| int32_t ecast122; |
| xfer += iprot->readI32(ecast122); |
| this->type = (ScanType::type)ecast122; |
| this->__isset.type = true; |
| } else { |
| xfer += iprot->skip(ftype); |
| } |
| break; |
| case 7: |
| if (ftype == ::apache::thrift::protocol::T_I32) { |
| int32_t ecast123; |
| xfer += iprot->readI32(ecast123); |
| this->state = (ScanState::type)ecast123; |
| this->__isset.state = true; |
| } else { |
| xfer += iprot->skip(ftype); |
| } |
| break; |
| case 8: |
| if (ftype == ::apache::thrift::protocol::T_STRUCT) { |
| xfer += this->extent.read(iprot); |
| this->__isset.extent = true; |
| } else { |
| xfer += iprot->skip(ftype); |
| } |
| break; |
| case 9: |
| if (ftype == ::apache::thrift::protocol::T_LIST) { |
| { |
| this->columns.clear(); |
| 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[_i128].read(iprot); |
| } |
| xfer += iprot->readListEnd(); |
| } |
| this->__isset.columns = true; |
| } else { |
| xfer += iprot->skip(ftype); |
| } |
| break; |
| case 10: |
| if (ftype == ::apache::thrift::protocol::T_LIST) { |
| { |
| this->iterators.clear(); |
| 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[_i133].read(iprot); |
| } |
| xfer += iprot->readListEnd(); |
| } |
| this->__isset.iterators = true; |
| } else { |
| xfer += iprot->skip(ftype); |
| } |
| break; |
| case 11: |
| if (ftype == ::apache::thrift::protocol::T_LIST) { |
| { |
| this->authorizations.clear(); |
| 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[_i138]); |
| } |
| xfer += iprot->readListEnd(); |
| } |
| this->__isset.authorizations = true; |
| } else { |
| xfer += iprot->skip(ftype); |
| } |
| break; |
| default: |
| xfer += iprot->skip(ftype); |
| break; |
| } |
| xfer += iprot->readFieldEnd(); |
| } |
| |
| xfer += iprot->readStructEnd(); |
| |
| return xfer; |
| } |
| |
| 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); |
| xfer += oprot->writeString(this->client); |
| xfer += oprot->writeFieldEnd(); |
| |
| xfer += oprot->writeFieldBegin("user", ::apache::thrift::protocol::T_STRING, 2); |
| xfer += oprot->writeString(this->user); |
| xfer += oprot->writeFieldEnd(); |
| |
| xfer += oprot->writeFieldBegin("table", ::apache::thrift::protocol::T_STRING, 3); |
| xfer += oprot->writeString(this->table); |
| xfer += oprot->writeFieldEnd(); |
| |
| xfer += oprot->writeFieldBegin("age", ::apache::thrift::protocol::T_I64, 4); |
| xfer += oprot->writeI64(this->age); |
| xfer += oprot->writeFieldEnd(); |
| |
| xfer += oprot->writeFieldBegin("idleTime", ::apache::thrift::protocol::T_I64, 5); |
| xfer += oprot->writeI64(this->idleTime); |
| xfer += oprot->writeFieldEnd(); |
| |
| xfer += oprot->writeFieldBegin("type", ::apache::thrift::protocol::T_I32, 6); |
| xfer += oprot->writeI32((int32_t)this->type); |
| xfer += oprot->writeFieldEnd(); |
| |
| xfer += oprot->writeFieldBegin("state", ::apache::thrift::protocol::T_I32, 7); |
| xfer += oprot->writeI32((int32_t)this->state); |
| xfer += oprot->writeFieldEnd(); |
| |
| xfer += oprot->writeFieldBegin("extent", ::apache::thrift::protocol::T_STRUCT, 8); |
| xfer += this->extent.write(oprot); |
| xfer += oprot->writeFieldEnd(); |
| |
| 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 _iter139; |
| for (_iter139 = this->columns.begin(); _iter139 != this->columns.end(); ++_iter139) |
| { |
| xfer += (*_iter139).write(oprot); |
| } |
| xfer += oprot->writeListEnd(); |
| } |
| xfer += oprot->writeFieldEnd(); |
| |
| 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 _iter140; |
| for (_iter140 = this->iterators.begin(); _iter140 != this->iterators.end(); ++_iter140) |
| { |
| xfer += (*_iter140).write(oprot); |
| } |
| xfer += oprot->writeListEnd(); |
| } |
| xfer += oprot->writeFieldEnd(); |
| |
| 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 _iter141; |
| for (_iter141 = this->authorizations.begin(); _iter141 != this->authorizations.end(); ++_iter141) |
| { |
| xfer += oprot->writeBinary((*_iter141)); |
| } |
| xfer += oprot->writeListEnd(); |
| } |
| xfer += oprot->writeFieldEnd(); |
| |
| xfer += oprot->writeFieldStop(); |
| xfer += oprot->writeStructEnd(); |
| return xfer; |
| } |
| |
| void swap(ActiveScan &a, ActiveScan &b) { |
| using ::std::swap; |
| swap(a.client, b.client); |
| swap(a.user, b.user); |
| swap(a.table, b.table); |
| swap(a.age, b.age); |
| swap(a.idleTime, b.idleTime); |
| swap(a.type, b.type); |
| swap(a.state, b.state); |
| swap(a.extent, b.extent); |
| swap(a.columns, b.columns); |
| swap(a.iterators, b.iterators); |
| swap(a.authorizations, b.authorizations); |
| swap(a.__isset, b.__isset); |
| } |
| |
| 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; |
| int16_t fid; |
| |
| xfer += iprot->readStructBegin(fname); |
| |
| using ::apache::thrift::protocol::TProtocolException; |
| |
| |
| while (true) |
| { |
| xfer += iprot->readFieldBegin(fname, ftype, fid); |
| if (ftype == ::apache::thrift::protocol::T_STOP) { |
| break; |
| } |
| switch (fid) |
| { |
| case 1: |
| if (ftype == ::apache::thrift::protocol::T_STRUCT) { |
| xfer += this->extent.read(iprot); |
| this->__isset.extent = true; |
| } else { |
| xfer += iprot->skip(ftype); |
| } |
| break; |
| case 2: |
| if (ftype == ::apache::thrift::protocol::T_I64) { |
| xfer += iprot->readI64(this->age); |
| this->__isset.age = true; |
| } else { |
| xfer += iprot->skip(ftype); |
| } |
| break; |
| case 3: |
| if (ftype == ::apache::thrift::protocol::T_LIST) { |
| { |
| this->inputFiles.clear(); |
| 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[_i148]); |
| } |
| xfer += iprot->readListEnd(); |
| } |
| this->__isset.inputFiles = true; |
| } else { |
| xfer += iprot->skip(ftype); |
| } |
| break; |
| case 4: |
| if (ftype == ::apache::thrift::protocol::T_STRING) { |
| xfer += iprot->readString(this->outputFile); |
| this->__isset.outputFile = true; |
| } else { |
| xfer += iprot->skip(ftype); |
| } |
| break; |
| case 5: |
| if (ftype == ::apache::thrift::protocol::T_I32) { |
| int32_t ecast149; |
| xfer += iprot->readI32(ecast149); |
| this->type = (CompactionType::type)ecast149; |
| this->__isset.type = true; |
| } else { |
| xfer += iprot->skip(ftype); |
| } |
| break; |
| case 6: |
| if (ftype == ::apache::thrift::protocol::T_I32) { |
| int32_t ecast150; |
| xfer += iprot->readI32(ecast150); |
| this->reason = (CompactionReason::type)ecast150; |
| this->__isset.reason = true; |
| } else { |
| xfer += iprot->skip(ftype); |
| } |
| break; |
| case 7: |
| if (ftype == ::apache::thrift::protocol::T_STRING) { |
| xfer += iprot->readString(this->localityGroup); |
| this->__isset.localityGroup = true; |
| } else { |
| xfer += iprot->skip(ftype); |
| } |
| break; |
| case 8: |
| if (ftype == ::apache::thrift::protocol::T_I64) { |
| xfer += iprot->readI64(this->entriesRead); |
| this->__isset.entriesRead = true; |
| } else { |
| xfer += iprot->skip(ftype); |
| } |
| break; |
| case 9: |
| if (ftype == ::apache::thrift::protocol::T_I64) { |
| xfer += iprot->readI64(this->entriesWritten); |
| this->__isset.entriesWritten = true; |
| } else { |
| xfer += iprot->skip(ftype); |
| } |
| break; |
| case 10: |
| if (ftype == ::apache::thrift::protocol::T_LIST) { |
| { |
| this->iterators.clear(); |
| 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[_i155].read(iprot); |
| } |
| xfer += iprot->readListEnd(); |
| } |
| this->__isset.iterators = true; |
| } else { |
| xfer += iprot->skip(ftype); |
| } |
| break; |
| default: |
| xfer += iprot->skip(ftype); |
| break; |
| } |
| xfer += iprot->readFieldEnd(); |
| } |
| |
| xfer += iprot->readStructEnd(); |
| |
| return xfer; |
| } |
| |
| 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); |
| xfer += this->extent.write(oprot); |
| xfer += oprot->writeFieldEnd(); |
| |
| xfer += oprot->writeFieldBegin("age", ::apache::thrift::protocol::T_I64, 2); |
| xfer += oprot->writeI64(this->age); |
| xfer += oprot->writeFieldEnd(); |
| |
| 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 _iter156; |
| for (_iter156 = this->inputFiles.begin(); _iter156 != this->inputFiles.end(); ++_iter156) |
| { |
| xfer += oprot->writeString((*_iter156)); |
| } |
| xfer += oprot->writeListEnd(); |
| } |
| xfer += oprot->writeFieldEnd(); |
| |
| xfer += oprot->writeFieldBegin("outputFile", ::apache::thrift::protocol::T_STRING, 4); |
| xfer += oprot->writeString(this->outputFile); |
| xfer += oprot->writeFieldEnd(); |
| |
| xfer += oprot->writeFieldBegin("type", ::apache::thrift::protocol::T_I32, 5); |
| xfer += oprot->writeI32((int32_t)this->type); |
| xfer += oprot->writeFieldEnd(); |
| |
| xfer += oprot->writeFieldBegin("reason", ::apache::thrift::protocol::T_I32, 6); |
| xfer += oprot->writeI32((int32_t)this->reason); |
| xfer += oprot->writeFieldEnd(); |
| |
| xfer += oprot->writeFieldBegin("localityGroup", ::apache::thrift::protocol::T_STRING, 7); |
| xfer += oprot->writeString(this->localityGroup); |
| xfer += oprot->writeFieldEnd(); |
| |
| xfer += oprot->writeFieldBegin("entriesRead", ::apache::thrift::protocol::T_I64, 8); |
| xfer += oprot->writeI64(this->entriesRead); |
| xfer += oprot->writeFieldEnd(); |
| |
| xfer += oprot->writeFieldBegin("entriesWritten", ::apache::thrift::protocol::T_I64, 9); |
| xfer += oprot->writeI64(this->entriesWritten); |
| xfer += oprot->writeFieldEnd(); |
| |
| 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 _iter157; |
| for (_iter157 = this->iterators.begin(); _iter157 != this->iterators.end(); ++_iter157) |
| { |
| xfer += (*_iter157).write(oprot); |
| } |
| xfer += oprot->writeListEnd(); |
| } |
| xfer += oprot->writeFieldEnd(); |
| |
| xfer += oprot->writeFieldStop(); |
| xfer += oprot->writeStructEnd(); |
| return xfer; |
| } |
| |
| void swap(ActiveCompaction &a, ActiveCompaction &b) { |
| using ::std::swap; |
| swap(a.extent, b.extent); |
| swap(a.age, b.age); |
| swap(a.inputFiles, b.inputFiles); |
| swap(a.outputFile, b.outputFile); |
| swap(a.type, b.type); |
| swap(a.reason, b.reason); |
| swap(a.localityGroup, b.localityGroup); |
| swap(a.entriesRead, b.entriesRead); |
| swap(a.entriesWritten, b.entriesWritten); |
| swap(a.iterators, b.iterators); |
| swap(a.__isset, b.__isset); |
| } |
| |
| 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; |
| int16_t fid; |
| |
| xfer += iprot->readStructBegin(fname); |
| |
| using ::apache::thrift::protocol::TProtocolException; |
| |
| |
| while (true) |
| { |
| xfer += iprot->readFieldBegin(fname, ftype, fid); |
| if (ftype == ::apache::thrift::protocol::T_STOP) { |
| break; |
| } |
| switch (fid) |
| { |
| case 1: |
| if (ftype == ::apache::thrift::protocol::T_I64) { |
| xfer += iprot->readI64(this->maxMemory); |
| this->__isset.maxMemory = true; |
| } else { |
| xfer += iprot->skip(ftype); |
| } |
| break; |
| case 2: |
| if (ftype == ::apache::thrift::protocol::T_I64) { |
| xfer += iprot->readI64(this->latencyMs); |
| this->__isset.latencyMs = true; |
| } else { |
| xfer += iprot->skip(ftype); |
| } |
| break; |
| case 3: |
| if (ftype == ::apache::thrift::protocol::T_I64) { |
| xfer += iprot->readI64(this->timeoutMs); |
| this->__isset.timeoutMs = true; |
| } else { |
| xfer += iprot->skip(ftype); |
| } |
| break; |
| case 4: |
| if (ftype == ::apache::thrift::protocol::T_I32) { |
| xfer += iprot->readI32(this->threads); |
| this->__isset.threads = true; |
| } else { |
| xfer += iprot->skip(ftype); |
| } |
| break; |
| case 5: |
| if (ftype == ::apache::thrift::protocol::T_I32) { |
| int32_t ecast160; |
| xfer += iprot->readI32(ecast160); |
| this->durability = (Durability::type)ecast160; |
| this->__isset.durability = true; |
| } else { |
| xfer += iprot->skip(ftype); |
| } |
| break; |
| default: |
| xfer += iprot->skip(ftype); |
| break; |
| } |
| xfer += iprot->readFieldEnd(); |
| } |
| |
| xfer += iprot->readStructEnd(); |
| |
| return xfer; |
| } |
| |
| 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); |
| xfer += oprot->writeI64(this->maxMemory); |
| xfer += oprot->writeFieldEnd(); |
| |
| xfer += oprot->writeFieldBegin("latencyMs", ::apache::thrift::protocol::T_I64, 2); |
| xfer += oprot->writeI64(this->latencyMs); |
| xfer += oprot->writeFieldEnd(); |
| |
| xfer += oprot->writeFieldBegin("timeoutMs", ::apache::thrift::protocol::T_I64, 3); |
| xfer += oprot->writeI64(this->timeoutMs); |
| xfer += oprot->writeFieldEnd(); |
| |
| xfer += oprot->writeFieldBegin("threads", ::apache::thrift::protocol::T_I32, 4); |
| xfer += oprot->writeI32(this->threads); |
| xfer += oprot->writeFieldEnd(); |
| |
| if (this->__isset.durability) { |
| xfer += oprot->writeFieldBegin("durability", ::apache::thrift::protocol::T_I32, 5); |
| xfer += oprot->writeI32((int32_t)this->durability); |
| xfer += oprot->writeFieldEnd(); |
| } |
| xfer += oprot->writeFieldStop(); |
| xfer += oprot->writeStructEnd(); |
| return xfer; |
| } |
| |
| void swap(WriterOptions &a, WriterOptions &b) { |
| using ::std::swap; |
| swap(a.maxMemory, b.maxMemory); |
| swap(a.latencyMs, b.latencyMs); |
| swap(a.timeoutMs, b.timeoutMs); |
| swap(a.threads, b.threads); |
| swap(a.durability, b.durability); |
| swap(a.__isset, b.__isset); |
| } |
| |
| 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; |
| int16_t fid; |
| |
| xfer += iprot->readStructBegin(fname); |
| |
| using ::apache::thrift::protocol::TProtocolException; |
| |
| |
| while (true) |
| { |
| xfer += iprot->readFieldBegin(fname, ftype, fid); |
| if (ftype == ::apache::thrift::protocol::T_STOP) { |
| break; |
| } |
| switch (fid) |
| { |
| case 1: |
| if (ftype == ::apache::thrift::protocol::T_STRING) { |
| xfer += iprot->readString(this->className); |
| this->__isset.className = true; |
| } else { |
| xfer += iprot->skip(ftype); |
| } |
| break; |
| case 2: |
| if (ftype == ::apache::thrift::protocol::T_MAP) { |
| { |
| this->options.clear(); |
| 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 _key168; |
| xfer += iprot->readString(_key168); |
| std::string& _val169 = this->options[_key168]; |
| xfer += iprot->readString(_val169); |
| } |
| xfer += iprot->readMapEnd(); |
| } |
| this->__isset.options = true; |
| } else { |
| xfer += iprot->skip(ftype); |
| } |
| break; |
| default: |
| xfer += iprot->skip(ftype); |
| break; |
| } |
| xfer += iprot->readFieldEnd(); |
| } |
| |
| xfer += iprot->readStructEnd(); |
| |
| return xfer; |
| } |
| |
| 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); |
| xfer += oprot->writeString(this->className); |
| xfer += oprot->writeFieldEnd(); |
| |
| 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 _iter170; |
| for (_iter170 = this->options.begin(); _iter170 != this->options.end(); ++_iter170) |
| { |
| xfer += oprot->writeString(_iter170->first); |
| xfer += oprot->writeString(_iter170->second); |
| } |
| xfer += oprot->writeMapEnd(); |
| } |
| xfer += oprot->writeFieldEnd(); |
| |
| xfer += oprot->writeFieldStop(); |
| xfer += oprot->writeStructEnd(); |
| return xfer; |
| } |
| |
| void swap(CompactionStrategyConfig &a, CompactionStrategyConfig &b) { |
| using ::std::swap; |
| swap(a.className, b.className); |
| swap(a.options, b.options); |
| swap(a.__isset, b.__isset); |
| } |
| |
| 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; |
| int16_t fid; |
| |
| xfer += iprot->readStructBegin(fname); |
| |
| using ::apache::thrift::protocol::TProtocolException; |
| |
| |
| while (true) |
| { |
| xfer += iprot->readFieldBegin(fname, ftype, fid); |
| if (ftype == ::apache::thrift::protocol::T_STOP) { |
| break; |
| } |
| switch (fid) |
| { |
| case 1: |
| if (ftype == ::apache::thrift::protocol::T_STRING) { |
| xfer += iprot->readString(this->msg); |
| this->__isset.msg = true; |
| } else { |
| xfer += iprot->skip(ftype); |
| } |
| break; |
| default: |
| xfer += iprot->skip(ftype); |
| break; |
| } |
| xfer += iprot->readFieldEnd(); |
| } |
| |
| xfer += iprot->readStructEnd(); |
| |
| return xfer; |
| } |
| |
| 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); |
| xfer += oprot->writeString(this->msg); |
| xfer += oprot->writeFieldEnd(); |
| |
| xfer += oprot->writeFieldStop(); |
| xfer += oprot->writeStructEnd(); |
| return xfer; |
| } |
| |
| void swap(UnknownScanner &a, UnknownScanner &b) { |
| using ::std::swap; |
| swap(a.msg, b.msg); |
| swap(a.__isset, b.__isset); |
| } |
| |
| 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; |
| int16_t fid; |
| |
| xfer += iprot->readStructBegin(fname); |
| |
| using ::apache::thrift::protocol::TProtocolException; |
| |
| |
| while (true) |
| { |
| xfer += iprot->readFieldBegin(fname, ftype, fid); |
| if (ftype == ::apache::thrift::protocol::T_STOP) { |
| break; |
| } |
| switch (fid) |
| { |
| case 1: |
| if (ftype == ::apache::thrift::protocol::T_STRING) { |
| xfer += iprot->readString(this->msg); |
| this->__isset.msg = true; |
| } else { |
| xfer += iprot->skip(ftype); |
| } |
| break; |
| default: |
| xfer += iprot->skip(ftype); |
| break; |
| } |
| xfer += iprot->readFieldEnd(); |
| } |
| |
| xfer += iprot->readStructEnd(); |
| |
| return xfer; |
| } |
| |
| uint32_t UnknownWriter::write(::apache::thrift::protocol::TProtocol* oprot) const { |
| uint32_t xfer = 0; |
| apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); |
| xfer += oprot->writeStructBegin("UnknownWriter"); |
| |
| xfer += oprot->writeFieldBegin("msg", ::apache::thrift::protocol::T_STRING, 1); |
| xfer += oprot->writeString(this->msg); |
| xfer += oprot->writeFieldEnd(); |
| |
| xfer += oprot->writeFieldStop(); |
| xfer += oprot->writeStructEnd(); |
| return xfer; |
| } |
| |
| void swap(UnknownWriter &a, UnknownWriter &b) { |
| using ::std::swap; |
| swap(a.msg, b.msg); |
| swap(a.__isset, b.__isset); |
| } |
| |
| UnknownWriter::UnknownWriter(const UnknownWriter& other175) : TException() { |
| msg = other175.msg; |
| __isset = other175.__isset; |
| } |
| UnknownWriter& UnknownWriter::operator=(const UnknownWriter& other176) { |
| msg = other176.msg; |
| __isset = other176.__isset; |
| return *this; |
| } |
| void UnknownWriter::printTo(std::ostream& out) const { |
| using ::apache::thrift::to_string; |
| out << "UnknownWriter("; |
| out << "msg=" << to_string(msg); |
| out << ")"; |
| } |
| |
| const char* UnknownWriter::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: UnknownWriter"; |
| } |
| } |
| |
| |
| NoMoreEntriesException::~NoMoreEntriesException() throw() { |
| } |
| |
| |
| void NoMoreEntriesException::__set_msg(const std::string& val) { |
| this->msg = val; |
| } |
| |
| uint32_t NoMoreEntriesException::read(::apache::thrift::protocol::TProtocol* iprot) { |
| |
| apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); |
| uint32_t xfer = 0; |
| std::string fname; |
| ::apache::thrift::protocol::TType ftype; |
| int16_t fid; |
| |
| xfer += iprot->readStructBegin(fname); |
| |
| using ::apache::thrift::protocol::TProtocolException; |
| |
| |
| while (true) |
| { |
| xfer += iprot->readFieldBegin(fname, ftype, fid); |
| if (ftype == ::apache::thrift::protocol::T_STOP) { |
| break; |
| } |
| switch (fid) |
| { |
| case 1: |
| if (ftype == ::apache::thrift::protocol::T_STRING) { |
| xfer += iprot->readString(this->msg); |
| this->__isset.msg = true; |
| } else { |
| xfer += iprot->skip(ftype); |
| } |
| break; |
| default: |
| xfer += iprot->skip(ftype); |
| break; |
| } |
| xfer += iprot->readFieldEnd(); |
| } |
| |
| xfer += iprot->readStructEnd(); |
| |
| return xfer; |
| } |
| |
| uint32_t NoMoreEntriesException::write(::apache::thrift::protocol::TProtocol* oprot) const { |
| uint32_t xfer = 0; |
| apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); |
| xfer += oprot->writeStructBegin("NoMoreEntriesException"); |
| |
| xfer += oprot->writeFieldBegin("msg", ::apache::thrift::protocol::T_STRING, 1); |
| xfer += oprot->writeString(this->msg); |
| xfer += oprot->writeFieldEnd(); |
| |
| xfer += oprot->writeFieldStop(); |
| xfer += oprot->writeStructEnd(); |
| return xfer; |
| } |
| |
| void swap(NoMoreEntriesException &a, NoMoreEntriesException &b) { |
| using ::std::swap; |
| swap(a.msg, b.msg); |
| swap(a.__isset, b.__isset); |
| } |
| |
| NoMoreEntriesException::NoMoreEntriesException(const NoMoreEntriesException& other177) : TException() { |
| msg = other177.msg; |
| __isset = other177.__isset; |
| } |
| NoMoreEntriesException& NoMoreEntriesException::operator=(const NoMoreEntriesException& other178) { |
| msg = other178.msg; |
| __isset = other178.__isset; |
| return *this; |
| } |
| void NoMoreEntriesException::printTo(std::ostream& out) const { |
| using ::apache::thrift::to_string; |
| out << "NoMoreEntriesException("; |
| out << "msg=" << to_string(msg); |
| out << ")"; |
| } |
| |
| const char* NoMoreEntriesException::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: NoMoreEntriesException"; |
| } |
| } |
| |
| |
| AccumuloException::~AccumuloException() throw() { |
| } |
| |
| |
| void AccumuloException::__set_msg(const std::string& val) { |
| this->msg = val; |
| } |
| |
| uint32_t AccumuloException::read(::apache::thrift::protocol::TProtocol* iprot) { |
| |
| apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); |
| uint32_t xfer = 0; |
| std::string fname; |
| ::apache::thrift::protocol::TType ftype; |
| int16_t fid; |
| |
| xfer += iprot->readStructBegin(fname); |
| |
| using ::apache::thrift::protocol::TProtocolException; |
| |
| |
| while (true) |
| { |
| xfer += iprot->readFieldBegin(fname, ftype, fid); |
| if (ftype == ::apache::thrift::protocol::T_STOP) { |
| break; |
| } |
| switch (fid) |
| { |
| case 1: |
| if (ftype == ::apache::thrift::protocol::T_STRING) { |
| xfer += iprot->readString(this->msg); |
| this->__isset.msg = true; |
| } else { |
| xfer += iprot->skip(ftype); |
| } |
| break; |
| default: |
| xfer += iprot->skip(ftype); |
| break; |
| } |
| xfer += iprot->readFieldEnd(); |
| } |
| |
| xfer += iprot->readStructEnd(); |
| |
| return xfer; |
| } |
| |
| uint32_t AccumuloException::write(::apache::thrift::protocol::TProtocol* oprot) const { |
| uint32_t xfer = 0; |
| apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); |
| xfer += oprot->writeStructBegin("AccumuloException"); |
| |
| xfer += oprot->writeFieldBegin("msg", ::apache::thrift::protocol::T_STRING, 1); |
| xfer += oprot->writeString(this->msg); |
| xfer += oprot->writeFieldEnd(); |
| |
| xfer += oprot->writeFieldStop(); |
| xfer += oprot->writeStructEnd(); |
| return xfer; |
| } |
| |
| void swap(AccumuloException &a, AccumuloException &b) { |
| using ::std::swap; |
| swap(a.msg, b.msg); |
| swap(a.__isset, b.__isset); |
| } |
| |
| AccumuloException::AccumuloException(const AccumuloException& other179) : TException() { |
| msg = other179.msg; |
| __isset = other179.__isset; |
| } |
| AccumuloException& AccumuloException::operator=(const AccumuloException& other180) { |
| msg = other180.msg; |
| __isset = other180.__isset; |
| return *this; |
| } |
| void AccumuloException::printTo(std::ostream& out) const { |
| using ::apache::thrift::to_string; |
| out << "AccumuloException("; |
| out << "msg=" << to_string(msg); |
| out << ")"; |
| } |
| |
| const char* AccumuloException::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: AccumuloException"; |
| } |
| } |
| |
| |
| AccumuloSecurityException::~AccumuloSecurityException() throw() { |
| } |
| |
| |
| void AccumuloSecurityException::__set_msg(const std::string& val) { |
| this->msg = val; |
| } |
| |
| uint32_t AccumuloSecurityException::read(::apache::thrift::protocol::TProtocol* iprot) { |
| |
| apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); |
| uint32_t xfer = 0; |
| std::string fname; |
| ::apache::thrift::protocol::TType ftype; |
| int16_t fid; |
| |
| xfer += iprot->readStructBegin(fname); |
| |
| using ::apache::thrift::protocol::TProtocolException; |
| |
| |
| while (true) |
| { |
| xfer += iprot->readFieldBegin(fname, ftype, fid); |
| if (ftype == ::apache::thrift::protocol::T_STOP) { |
| break; |
| } |
| switch (fid) |
| { |
| case 1: |
| if (ftype == ::apache::thrift::protocol::T_STRING) { |
| xfer += iprot->readString(this->msg); |
| this->__isset.msg = true; |
| } else { |
| xfer += iprot->skip(ftype); |
| } |
| break; |
| default: |
| xfer += iprot->skip(ftype); |
| break; |
| } |
| xfer += iprot->readFieldEnd(); |
| } |
| |
| xfer += iprot->readStructEnd(); |
| |
| return xfer; |
| } |
| |
| uint32_t AccumuloSecurityException::write(::apache::thrift::protocol::TProtocol* oprot) const { |
| uint32_t xfer = 0; |
| apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); |
| xfer += oprot->writeStructBegin("AccumuloSecurityException"); |
| |
| xfer += oprot->writeFieldBegin("msg", ::apache::thrift::protocol::T_STRING, 1); |
| xfer += oprot->writeString(this->msg); |
| xfer += oprot->writeFieldEnd(); |
| |
| xfer += oprot->writeFieldStop(); |
| xfer += oprot->writeStructEnd(); |
| return xfer; |
| } |
| |
| void swap(AccumuloSecurityException &a, AccumuloSecurityException &b) { |
| using ::std::swap; |
| swap(a.msg, b.msg); |
| swap(a.__isset, b.__isset); |
| } |
| |
| AccumuloSecurityException::AccumuloSecurityException(const AccumuloSecurityException& other181) : TException() { |
| msg = other181.msg; |
| __isset = other181.__isset; |
| } |
| AccumuloSecurityException& AccumuloSecurityException::operator=(const AccumuloSecurityException& other182) { |
| msg = other182.msg; |
| __isset = other182.__isset; |
| return *this; |
| } |
| void AccumuloSecurityException::printTo(std::ostream& out) const { |
| using ::apache::thrift::to_string; |
| out << "AccumuloSecurityException("; |
| out << "msg=" << to_string(msg); |
| out << ")"; |
| } |
| |
| const char* AccumuloSecurityException::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: AccumuloSecurityException"; |
| } |
| } |
| |
| |
| TableNotFoundException::~TableNotFoundException() throw() { |
| } |
| |
| |
| void TableNotFoundException::__set_msg(const std::string& val) { |
| this->msg = val; |
| } |
| |
| uint32_t TableNotFoundException::read(::apache::thrift::protocol::TProtocol* iprot) { |
| |
| apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); |
| uint32_t xfer = 0; |
| std::string fname; |
| ::apache::thrift::protocol::TType ftype; |
| int16_t fid; |
| |
| xfer += iprot->readStructBegin(fname); |
| |
| using ::apache::thrift::protocol::TProtocolException; |
| |
| |
| while (true) |
| { |
| xfer += iprot->readFieldBegin(fname, ftype, fid); |
| if (ftype == ::apache::thrift::protocol::T_STOP) { |
| break; |
| } |
| switch (fid) |
| { |
| case 1: |
| if (ftype == ::apache::thrift::protocol::T_STRING) { |
| xfer += iprot->readString(this->msg); |
| this->__isset.msg = true; |
| } else { |
| xfer += iprot->skip(ftype); |
| } |
| break; |
| default: |
| xfer += iprot->skip(ftype); |
| break; |
| } |
| xfer += iprot->readFieldEnd(); |
| } |
| |
| xfer += iprot->readStructEnd(); |
| |
| return xfer; |
| } |
| |
| uint32_t TableNotFoundException::write(::apache::thrift::protocol::TProtocol* oprot) const { |
| uint32_t xfer = 0; |
| apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); |
| xfer += oprot->writeStructBegin("TableNotFoundException"); |
| |
| xfer += oprot->writeFieldBegin("msg", ::apache::thrift::protocol::T_STRING, 1); |
| xfer += oprot->writeString(this->msg); |
| xfer += oprot->writeFieldEnd(); |
| |
| xfer += oprot->writeFieldStop(); |
| xfer += oprot->writeStructEnd(); |
| return xfer; |
| } |
| |
| void swap(TableNotFoundException &a, TableNotFoundException &b) { |
| using ::std::swap; |
| swap(a.msg, b.msg); |
| swap(a.__isset, b.__isset); |
| } |
| |
| TableNotFoundException::TableNotFoundException(const TableNotFoundException& other183) : TException() { |
| msg = other183.msg; |
| __isset = other183.__isset; |
| } |
| TableNotFoundException& TableNotFoundException::operator=(const TableNotFoundException& other184) { |
| msg = other184.msg; |
| __isset = other184.__isset; |
| return *this; |
| } |
| void TableNotFoundException::printTo(std::ostream& out) const { |
| using ::apache::thrift::to_string; |
| out << "TableNotFoundException("; |
| out << "msg=" << to_string(msg); |
| out << ")"; |
| } |
| |
| const char* TableNotFoundException::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: TableNotFoundException"; |
| } |
| } |
| |
| |
| TableExistsException::~TableExistsException() throw() { |
| } |
| |
| |
| void TableExistsException::__set_msg(const std::string& val) { |
| this->msg = val; |
| } |
| |
| uint32_t TableExistsException::read(::apache::thrift::protocol::TProtocol* iprot) { |
| |
| apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); |
| uint32_t xfer = 0; |
| std::string fname; |
| ::apache::thrift::protocol::TType ftype; |
| int16_t fid; |
| |
| xfer += iprot->readStructBegin(fname); |
| |
| using ::apache::thrift::protocol::TProtocolException; |
| |
| |
| while (true) |
| { |
| xfer += iprot->readFieldBegin(fname, ftype, fid); |
| if (ftype == ::apache::thrift::protocol::T_STOP) { |
| break; |
| } |
| switch (fid) |
| { |
| case 1: |
| if (ftype == ::apache::thrift::protocol::T_STRING) { |
| xfer += iprot->readString(this->msg); |
| this->__isset.msg = true; |
| } else { |
| xfer += iprot->skip(ftype); |
| } |
| break; |
| default: |
| xfer += iprot->skip(ftype); |
| break; |
| } |
| xfer += iprot->readFieldEnd(); |
| } |
| |
| xfer += iprot->readStructEnd(); |
| |
| return xfer; |
| } |
| |
| uint32_t TableExistsException::write(::apache::thrift::protocol::TProtocol* oprot) const { |
| uint32_t xfer = 0; |
| apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); |
| xfer += oprot->writeStructBegin("TableExistsException"); |
| |
| xfer += oprot->writeFieldBegin("msg", ::apache::thrift::protocol::T_STRING, 1); |
| xfer += oprot->writeString(this->msg); |
| xfer += oprot->writeFieldEnd(); |
| |
| xfer += oprot->writeFieldStop(); |
| xfer += oprot->writeStructEnd(); |
| return xfer; |
| } |
| |
| void swap(TableExistsException &a, TableExistsException &b) { |
| using ::std::swap; |
| swap(a.msg, b.msg); |
| swap(a.__isset, b.__isset); |
| } |
| |
| TableExistsException::TableExistsException(const TableExistsException& other185) : TException() { |
| msg = other185.msg; |
| __isset = other185.__isset; |
| } |
| TableExistsException& TableExistsException::operator=(const TableExistsException& other186) { |
| msg = other186.msg; |
| __isset = other186.__isset; |
| return *this; |
| } |
| void TableExistsException::printTo(std::ostream& out) const { |
| using ::apache::thrift::to_string; |
| out << "TableExistsException("; |
| out << "msg=" << to_string(msg); |
| out << ")"; |
| } |
| |
| const char* TableExistsException::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: TableExistsException"; |
| } |
| } |
| |
| |
| MutationsRejectedException::~MutationsRejectedException() throw() { |
| } |
| |
| |
| void MutationsRejectedException::__set_msg(const std::string& val) { |
| this->msg = val; |
| } |
| |
| uint32_t MutationsRejectedException::read(::apache::thrift::protocol::TProtocol* iprot) { |
| |
| apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); |
| uint32_t xfer = 0; |
| std::string fname; |
| ::apache::thrift::protocol::TType ftype; |
| int16_t fid; |
| |
| xfer += iprot->readStructBegin(fname); |
| |
| using ::apache::thrift::protocol::TProtocolException; |
| |
| |
| while (true) |
| { |
| xfer += iprot->readFieldBegin(fname, ftype, fid); |
| if (ftype == ::apache::thrift::protocol::T_STOP) { |
| break; |
| } |
| switch (fid) |
| { |
| case 1: |
| if (ftype == ::apache::thrift::protocol::T_STRING) { |
| xfer += iprot->readString(this->msg); |
| this->__isset.msg = true; |
| } else { |
| xfer += iprot->skip(ftype); |
| } |
| break; |
| default: |
| xfer += iprot->skip(ftype); |
| break; |
| } |
| xfer += iprot->readFieldEnd(); |
| } |
| |
| xfer += iprot->readStructEnd(); |
| |
| return xfer; |
| } |
| |
| uint32_t MutationsRejectedException::write(::apache::thrift::protocol::TProtocol* oprot) const { |
| uint32_t xfer = 0; |
| apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); |
| xfer += oprot->writeStructBegin("MutationsRejectedException"); |
| |
| xfer += oprot->writeFieldBegin("msg", ::apache::thrift::protocol::T_STRING, 1); |
| xfer += oprot->writeString(this->msg); |
| xfer += oprot->writeFieldEnd(); |
| |
| xfer += oprot->writeFieldStop(); |
| xfer += oprot->writeStructEnd(); |
| return xfer; |
| } |
| |
| void swap(MutationsRejectedException &a, MutationsRejectedException &b) { |
| using ::std::swap; |
| swap(a.msg, b.msg); |
| swap(a.__isset, b.__isset); |
| } |
| |
| MutationsRejectedException::MutationsRejectedException(const MutationsRejectedException& other187) : TException() { |
| msg = other187.msg; |
| __isset = other187.__isset; |
| } |
| MutationsRejectedException& MutationsRejectedException::operator=(const MutationsRejectedException& other188) { |
| msg = other188.msg; |
| __isset = other188.__isset; |
| return *this; |
| } |
| void MutationsRejectedException::printTo(std::ostream& out) const { |
| using ::apache::thrift::to_string; |
| out << "MutationsRejectedException("; |
| out << "msg=" << to_string(msg); |
| out << ")"; |
| } |
| |
| const char* MutationsRejectedException::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: MutationsRejectedException"; |
| } |
| } |
| |
| |
| NamespaceExistsException::~NamespaceExistsException() throw() { |
| } |
| |
| |
| void NamespaceExistsException::__set_msg(const std::string& val) { |
| this->msg = val; |
| } |
| |
| uint32_t NamespaceExistsException::read(::apache::thrift::protocol::TProtocol* iprot) { |
| |
| apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); |
| uint32_t xfer = 0; |
| std::string fname; |
| ::apache::thrift::protocol::TType ftype; |
| int16_t fid; |
| |
| xfer += iprot->readStructBegin(fname); |
| |
| using ::apache::thrift::protocol::TProtocolException; |
| |
| |
| while (true) |
| { |
| xfer += iprot->readFieldBegin(fname, ftype, fid); |
| if (ftype == ::apache::thrift::protocol::T_STOP) { |
| break; |
| } |
| switch (fid) |
| { |
| case 1: |
| if (ftype == ::apache::thrift::protocol::T_STRING) { |
| xfer += iprot->readString(this->msg); |
| this->__isset.msg = true; |
| } else { |
| xfer += iprot->skip(ftype); |
| } |
| break; |
| default: |
| xfer += iprot->skip(ftype); |
| break; |
| } |
| xfer += iprot->readFieldEnd(); |
| } |
| |
| xfer += iprot->readStructEnd(); |
| |
| return xfer; |
| } |
| |
| uint32_t NamespaceExistsException::write(::apache::thrift::protocol::TProtocol* oprot) const { |
| uint32_t xfer = 0; |
| apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); |
| xfer += oprot->writeStructBegin("NamespaceExistsException"); |
| |
| xfer += oprot->writeFieldBegin("msg", ::apache::thrift::protocol::T_STRING, 1); |
| xfer += oprot->writeString(this->msg); |
| xfer += oprot->writeFieldEnd(); |
| |
| xfer += oprot->writeFieldStop(); |
| xfer += oprot->writeStructEnd(); |
| return xfer; |
| } |
| |
| void swap(NamespaceExistsException &a, NamespaceExistsException &b) { |
| using ::std::swap; |
| swap(a.msg, b.msg); |
| swap(a.__isset, b.__isset); |
| } |
| |
| NamespaceExistsException::NamespaceExistsException(const NamespaceExistsException& other189) : TException() { |
| msg = other189.msg; |
| __isset = other189.__isset; |
| } |
| NamespaceExistsException& NamespaceExistsException::operator=(const NamespaceExistsException& other190) { |
| msg = other190.msg; |
| __isset = other190.__isset; |
| return *this; |
| } |
| void NamespaceExistsException::printTo(std::ostream& out) const { |
| using ::apache::thrift::to_string; |
| out << "NamespaceExistsException("; |
| out << "msg=" << to_string(msg); |
| out << ")"; |
| } |
| |
| const char* NamespaceExistsException::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: NamespaceExistsException"; |
| } |
| } |
| |
| |
| NamespaceNotFoundException::~NamespaceNotFoundException() throw() { |
| } |
| |
| |
| void NamespaceNotFoundException::__set_msg(const std::string& val) { |
| this->msg = val; |
| } |
| |
| uint32_t NamespaceNotFoundException::read(::apache::thrift::protocol::TProtocol* iprot) { |
| |
| apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); |
| uint32_t xfer = 0; |
| std::string fname; |
| ::apache::thrift::protocol::TType ftype; |
| int16_t fid; |
| |
| xfer += iprot->readStructBegin(fname); |
| |
| using ::apache::thrift::protocol::TProtocolException; |
| |
| |
| while (true) |
| { |
| xfer += iprot->readFieldBegin(fname, ftype, fid); |
| if (ftype == ::apache::thrift::protocol::T_STOP) { |
| break; |
| } |
| switch (fid) |
| { |
| case 1: |
| if (ftype == ::apache::thrift::protocol::T_STRING) { |
| xfer += iprot->readString(this->msg); |
| this->__isset.msg = true; |
| } else { |
| xfer += iprot->skip(ftype); |
| } |
| break; |
| default: |
| xfer += iprot->skip(ftype); |
| break; |
| } |
| xfer += iprot->readFieldEnd(); |
| } |
| |
| xfer += iprot->readStructEnd(); |
| |
| return xfer; |
| } |
| |
| uint32_t NamespaceNotFoundException::write(::apache::thrift::protocol::TProtocol* oprot) const { |
| uint32_t xfer = 0; |
| apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); |
| xfer += oprot->writeStructBegin("NamespaceNotFoundException"); |
| |
| xfer += oprot->writeFieldBegin("msg", ::apache::thrift::protocol::T_STRING, 1); |
| xfer += oprot->writeString(this->msg); |
| xfer += oprot->writeFieldEnd(); |
| |
| xfer += oprot->writeFieldStop(); |
| xfer += oprot->writeStructEnd(); |
| return xfer; |
| } |
| |
| void swap(NamespaceNotFoundException &a, NamespaceNotFoundException &b) { |
| using ::std::swap; |
| swap(a.msg, b.msg); |
| swap(a.__isset, b.__isset); |
| } |
| |
| NamespaceNotFoundException::NamespaceNotFoundException(const NamespaceNotFoundException& other191) : TException() { |
| msg = other191.msg; |
| __isset = other191.__isset; |
| } |
| NamespaceNotFoundException& NamespaceNotFoundException::operator=(const NamespaceNotFoundException& other192) { |
| msg = other192.msg; |
| __isset = other192.__isset; |
| return *this; |
| } |
| void NamespaceNotFoundException::printTo(std::ostream& out) const { |
| using ::apache::thrift::to_string; |
| out << "NamespaceNotFoundException("; |
| out << "msg=" << to_string(msg); |
| out << ")"; |
| } |
| |
| const char* NamespaceNotFoundException::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: NamespaceNotFoundException"; |
| } |
| } |
| |
| |
| NamespaceNotEmptyException::~NamespaceNotEmptyException() throw() { |
| } |
| |
| |
| void NamespaceNotEmptyException::__set_msg(const std::string& val) { |
| this->msg = val; |
| } |
| |
| uint32_t NamespaceNotEmptyException::read(::apache::thrift::protocol::TProtocol* iprot) { |
| |
| apache::thrift::protocol::TInputRecursionTracker tracker(*iprot); |
| uint32_t xfer = 0; |
| std::string fname; |
| ::apache::thrift::protocol::TType ftype; |
| int16_t fid; |
| |
| xfer += iprot->readStructBegin(fname); |
| |
| using ::apache::thrift::protocol::TProtocolException; |
| |
| |
| while (true) |
| { |
| xfer += iprot->readFieldBegin(fname, ftype, fid); |
| if (ftype == ::apache::thrift::protocol::T_STOP) { |
| break; |
| } |
| switch (fid) |
| { |
| case 1: |
| if (ftype == ::apache::thrift::protocol::T_STRING) { |
| xfer += iprot->readString(this->msg); |
| this->__isset.msg = true; |
| } else { |
| xfer += iprot->skip(ftype); |
| } |
| break; |
| default: |
| xfer += iprot->skip(ftype); |
| break; |
| } |
| xfer += iprot->readFieldEnd(); |
| } |
| |
| xfer += iprot->readStructEnd(); |
| |
| return xfer; |
| } |
| |
| uint32_t NamespaceNotEmptyException::write(::apache::thrift::protocol::TProtocol* oprot) const { |
| uint32_t xfer = 0; |
| apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot); |
| xfer += oprot->writeStructBegin("NamespaceNotEmptyException"); |
| |
| xfer += oprot->writeFieldBegin("msg", ::apache::thrift::protocol::T_STRING, 1); |
| xfer += oprot->writeString(this->msg); |
| xfer += oprot->writeFieldEnd(); |
| |
| xfer += oprot->writeFieldStop(); |
| xfer += oprot->writeStructEnd(); |
| return xfer; |
| } |
| |
| void swap(NamespaceNotEmptyException &a, NamespaceNotEmptyException &b) { |
| using ::std::swap; |
| swap(a.msg, b.msg); |
| swap(a.__isset, b.__isset); |
| } |
| |
| NamespaceNotEmptyException::NamespaceNotEmptyException(const NamespaceNotEmptyException& other193) : TException() { |
| msg = other193.msg; |
| __isset = other193.__isset; |
| } |
| NamespaceNotEmptyException& NamespaceNotEmptyException::operator=(const NamespaceNotEmptyException& other194) { |
| msg = other194.msg; |
| __isset = other194.__isset; |
| return *this; |
| } |
| void NamespaceNotEmptyException::printTo(std::ostream& out) const { |
| using ::apache::thrift::to_string; |
| out << "NamespaceNotEmptyException("; |
| out << "msg=" << to_string(msg); |
| out << ")"; |
| } |
| |
| const char* NamespaceNotEmptyException::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: NamespaceNotEmptyException"; |
| } |
| } |
| |
| } // namespace |