| /* |
| * 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.1) |
| * |
| * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING |
| * @generated |
| */ |
| #include "proxy_types.h" |
| |
| #include <algorithm> |
| |
| 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 _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)); |
| |
| const char* Key::ascii_fingerprint = "91151A432E03F5E8564877B5194B48E2"; |
| const uint8_t Key::binary_fingerprint[16] = {0x91,0x15,0x1A,0x43,0x2E,0x03,0xF5,0xE8,0x56,0x48,0x77,0xB5,0x19,0x4B,0x48,0xE2}; |
| |
| uint32_t Key::read(::apache::thrift::protocol::TProtocol* iprot) { |
| |
| uint32_t xfer = 0; |
| std::string fname; |
| ::apache::thrift::protocol::TType ftype; |
| int16_t fid; |
| |
| xfer += iprot->readStructBegin(fname); |
| |
| 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; |
| 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); |
| } |
| |
| const char* ColumnUpdate::ascii_fingerprint = "65CC1863F7DDC1DE75B9EAF9E2DC0D1F"; |
| const uint8_t ColumnUpdate::binary_fingerprint[16] = {0x65,0xCC,0x18,0x63,0xF7,0xDD,0xC1,0xDE,0x75,0xB9,0xEA,0xF9,0xE2,0xDC,0x0D,0x1F}; |
| |
| uint32_t ColumnUpdate::read(::apache::thrift::protocol::TProtocol* iprot) { |
| |
| uint32_t xfer = 0; |
| std::string fname; |
| ::apache::thrift::protocol::TType ftype; |
| int16_t fid; |
| |
| xfer += iprot->readStructBegin(fname); |
| |
| 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; |
| 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); |
| } |
| |
| const char* DiskUsage::ascii_fingerprint = "D26F4F5E2867D41CF7E0391263932D6B"; |
| const uint8_t DiskUsage::binary_fingerprint[16] = {0xD2,0x6F,0x4F,0x5E,0x28,0x67,0xD4,0x1C,0xF7,0xE0,0x39,0x12,0x63,0x93,0x2D,0x6B}; |
| |
| uint32_t DiskUsage::read(::apache::thrift::protocol::TProtocol* iprot) { |
| |
| uint32_t xfer = 0; |
| std::string fname; |
| ::apache::thrift::protocol::TType ftype; |
| int16_t fid; |
| |
| xfer += iprot->readStructBegin(fname); |
| |
| 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 _size0; |
| ::apache::thrift::protocol::TType _etype3; |
| xfer += iprot->readListBegin(_etype3, _size0); |
| this->tables.resize(_size0); |
| uint32_t _i4; |
| for (_i4 = 0; _i4 < _size0; ++_i4) |
| { |
| xfer += iprot->readString(this->tables[_i4]); |
| } |
| 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; |
| xfer += oprot->writeStructBegin("DiskUsage"); |
| |
| xfer += oprot->writeFieldBegin("tables", ::apache::thrift::protocol::T_LIST, 1); |
| { |
| xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->tables.size())); |
| std::vector<std::string> ::const_iterator _iter5; |
| for (_iter5 = this->tables.begin(); _iter5 != this->tables.end(); ++_iter5) |
| { |
| xfer += oprot->writeString((*_iter5)); |
| } |
| 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); |
| } |
| |
| const char* KeyValue::ascii_fingerprint = "0D0CA44F233F983E00E94228C31ABBD4"; |
| const uint8_t KeyValue::binary_fingerprint[16] = {0x0D,0x0C,0xA4,0x4F,0x23,0x3F,0x98,0x3E,0x00,0xE9,0x42,0x28,0xC3,0x1A,0xBB,0xD4}; |
| |
| uint32_t KeyValue::read(::apache::thrift::protocol::TProtocol* iprot) { |
| |
| uint32_t xfer = 0; |
| std::string fname; |
| ::apache::thrift::protocol::TType ftype; |
| int16_t fid; |
| |
| xfer += iprot->readStructBegin(fname); |
| |
| 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; |
| 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); |
| } |
| |
| const char* ScanResult::ascii_fingerprint = "684A3FCA76EA202FE071A17F8B510E7A"; |
| const uint8_t ScanResult::binary_fingerprint[16] = {0x68,0x4A,0x3F,0xCA,0x76,0xEA,0x20,0x2F,0xE0,0x71,0xA1,0x7F,0x8B,0x51,0x0E,0x7A}; |
| |
| uint32_t ScanResult::read(::apache::thrift::protocol::TProtocol* iprot) { |
| |
| uint32_t xfer = 0; |
| std::string fname; |
| ::apache::thrift::protocol::TType ftype; |
| int16_t fid; |
| |
| xfer += iprot->readStructBegin(fname); |
| |
| 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 _size6; |
| ::apache::thrift::protocol::TType _etype9; |
| xfer += iprot->readListBegin(_etype9, _size6); |
| this->results.resize(_size6); |
| uint32_t _i10; |
| for (_i10 = 0; _i10 < _size6; ++_i10) |
| { |
| xfer += this->results[_i10].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; |
| xfer += oprot->writeStructBegin("ScanResult"); |
| |
| xfer += oprot->writeFieldBegin("results", ::apache::thrift::protocol::T_LIST, 1); |
| { |
| xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->results.size())); |
| std::vector<KeyValue> ::const_iterator _iter11; |
| for (_iter11 = this->results.begin(); _iter11 != this->results.end(); ++_iter11) |
| { |
| xfer += (*_iter11).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); |
| } |
| |
| const char* Range::ascii_fingerprint = "84C5BA8DB718E60BFBF3F83867647B45"; |
| const uint8_t Range::binary_fingerprint[16] = {0x84,0xC5,0xBA,0x8D,0xB7,0x18,0xE6,0x0B,0xFB,0xF3,0xF8,0x38,0x67,0x64,0x7B,0x45}; |
| |
| uint32_t Range::read(::apache::thrift::protocol::TProtocol* iprot) { |
| |
| uint32_t xfer = 0; |
| std::string fname; |
| ::apache::thrift::protocol::TType ftype; |
| int16_t fid; |
| |
| xfer += iprot->readStructBegin(fname); |
| |
| 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; |
| 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); |
| } |
| |
| const char* ScanColumn::ascii_fingerprint = "5B708A954C550ECA9C1A49D3C5CAFAB9"; |
| const uint8_t ScanColumn::binary_fingerprint[16] = {0x5B,0x70,0x8A,0x95,0x4C,0x55,0x0E,0xCA,0x9C,0x1A,0x49,0xD3,0xC5,0xCA,0xFA,0xB9}; |
| |
| uint32_t ScanColumn::read(::apache::thrift::protocol::TProtocol* iprot) { |
| |
| uint32_t xfer = 0; |
| std::string fname; |
| ::apache::thrift::protocol::TType ftype; |
| int16_t fid; |
| |
| xfer += iprot->readStructBegin(fname); |
| |
| 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; |
| 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); |
| } |
| |
| const char* IteratorSetting::ascii_fingerprint = "985C857916964E43205EAC92A157CB4E"; |
| const uint8_t IteratorSetting::binary_fingerprint[16] = {0x98,0x5C,0x85,0x79,0x16,0x96,0x4E,0x43,0x20,0x5E,0xAC,0x92,0xA1,0x57,0xCB,0x4E}; |
| |
| uint32_t IteratorSetting::read(::apache::thrift::protocol::TProtocol* iprot) { |
| |
| uint32_t xfer = 0; |
| std::string fname; |
| ::apache::thrift::protocol::TType ftype; |
| int16_t fid; |
| |
| xfer += iprot->readStructBegin(fname); |
| |
| 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 _size12; |
| ::apache::thrift::protocol::TType _ktype13; |
| ::apache::thrift::protocol::TType _vtype14; |
| xfer += iprot->readMapBegin(_ktype13, _vtype14, _size12); |
| uint32_t _i16; |
| for (_i16 = 0; _i16 < _size12; ++_i16) |
| { |
| std::string _key17; |
| xfer += iprot->readString(_key17); |
| std::string& _val18 = this->properties[_key17]; |
| xfer += iprot->readString(_val18); |
| } |
| 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; |
| 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 _iter19; |
| for (_iter19 = this->properties.begin(); _iter19 != this->properties.end(); ++_iter19) |
| { |
| xfer += oprot->writeString(_iter19->first); |
| xfer += oprot->writeString(_iter19->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); |
| } |
| |
| const char* ScanOptions::ascii_fingerprint = "3D87D0CD05FA62E15880C4D2C595907C"; |
| const uint8_t ScanOptions::binary_fingerprint[16] = {0x3D,0x87,0xD0,0xCD,0x05,0xFA,0x62,0xE1,0x58,0x80,0xC4,0xD2,0xC5,0x95,0x90,0x7C}; |
| |
| uint32_t ScanOptions::read(::apache::thrift::protocol::TProtocol* iprot) { |
| |
| uint32_t xfer = 0; |
| std::string fname; |
| ::apache::thrift::protocol::TType ftype; |
| int16_t fid; |
| |
| xfer += iprot->readStructBegin(fname); |
| |
| 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 _size20; |
| ::apache::thrift::protocol::TType _etype23; |
| xfer += iprot->readSetBegin(_etype23, _size20); |
| uint32_t _i24; |
| for (_i24 = 0; _i24 < _size20; ++_i24) |
| { |
| std::string _elem25; |
| xfer += iprot->readBinary(_elem25); |
| this->authorizations.insert(_elem25); |
| } |
| 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 _size26; |
| ::apache::thrift::protocol::TType _etype29; |
| xfer += iprot->readListBegin(_etype29, _size26); |
| this->columns.resize(_size26); |
| uint32_t _i30; |
| for (_i30 = 0; _i30 < _size26; ++_i30) |
| { |
| xfer += this->columns[_i30].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 _size31; |
| ::apache::thrift::protocol::TType _etype34; |
| xfer += iprot->readListBegin(_etype34, _size31); |
| this->iterators.resize(_size31); |
| uint32_t _i35; |
| for (_i35 = 0; _i35 < _size31; ++_i35) |
| { |
| xfer += this->iterators[_i35].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; |
| xfer += oprot->writeStructBegin("ScanOptions"); |
| |
| if (this->__isset.authorizations) { |
| xfer += oprot->writeFieldBegin("authorizations", ::apache::thrift::protocol::T_SET, 1); |
| { |
| xfer += oprot->writeSetBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->authorizations.size())); |
| std::set<std::string> ::const_iterator _iter36; |
| for (_iter36 = this->authorizations.begin(); _iter36 != this->authorizations.end(); ++_iter36) |
| { |
| xfer += oprot->writeBinary((*_iter36)); |
| } |
| 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 _iter37; |
| for (_iter37 = this->columns.begin(); _iter37 != this->columns.end(); ++_iter37) |
| { |
| xfer += (*_iter37).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 _iter38; |
| for (_iter38 = this->iterators.begin(); _iter38 != this->iterators.end(); ++_iter38) |
| { |
| xfer += (*_iter38).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); |
| } |
| |
| const char* BatchScanOptions::ascii_fingerprint = "6ADFA1FBE31B1220D2C103284E002308"; |
| const uint8_t BatchScanOptions::binary_fingerprint[16] = {0x6A,0xDF,0xA1,0xFB,0xE3,0x1B,0x12,0x20,0xD2,0xC1,0x03,0x28,0x4E,0x00,0x23,0x08}; |
| |
| uint32_t BatchScanOptions::read(::apache::thrift::protocol::TProtocol* iprot) { |
| |
| uint32_t xfer = 0; |
| std::string fname; |
| ::apache::thrift::protocol::TType ftype; |
| int16_t fid; |
| |
| xfer += iprot->readStructBegin(fname); |
| |
| 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 _size39; |
| ::apache::thrift::protocol::TType _etype42; |
| xfer += iprot->readSetBegin(_etype42, _size39); |
| uint32_t _i43; |
| for (_i43 = 0; _i43 < _size39; ++_i43) |
| { |
| std::string _elem44; |
| xfer += iprot->readBinary(_elem44); |
| this->authorizations.insert(_elem44); |
| } |
| 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 _size45; |
| ::apache::thrift::protocol::TType _etype48; |
| xfer += iprot->readListBegin(_etype48, _size45); |
| this->ranges.resize(_size45); |
| uint32_t _i49; |
| for (_i49 = 0; _i49 < _size45; ++_i49) |
| { |
| xfer += this->ranges[_i49].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 _size50; |
| ::apache::thrift::protocol::TType _etype53; |
| xfer += iprot->readListBegin(_etype53, _size50); |
| this->columns.resize(_size50); |
| uint32_t _i54; |
| for (_i54 = 0; _i54 < _size50; ++_i54) |
| { |
| xfer += this->columns[_i54].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 _size55; |
| ::apache::thrift::protocol::TType _etype58; |
| xfer += iprot->readListBegin(_etype58, _size55); |
| this->iterators.resize(_size55); |
| uint32_t _i59; |
| for (_i59 = 0; _i59 < _size55; ++_i59) |
| { |
| xfer += this->iterators[_i59].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; |
| xfer += oprot->writeStructBegin("BatchScanOptions"); |
| |
| if (this->__isset.authorizations) { |
| xfer += oprot->writeFieldBegin("authorizations", ::apache::thrift::protocol::T_SET, 1); |
| { |
| xfer += oprot->writeSetBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->authorizations.size())); |
| std::set<std::string> ::const_iterator _iter60; |
| for (_iter60 = this->authorizations.begin(); _iter60 != this->authorizations.end(); ++_iter60) |
| { |
| xfer += oprot->writeBinary((*_iter60)); |
| } |
| 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 _iter61; |
| for (_iter61 = this->ranges.begin(); _iter61 != this->ranges.end(); ++_iter61) |
| { |
| xfer += (*_iter61).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 _iter62; |
| for (_iter62 = this->columns.begin(); _iter62 != this->columns.end(); ++_iter62) |
| { |
| xfer += (*_iter62).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 _iter63; |
| for (_iter63 = this->iterators.begin(); _iter63 != this->iterators.end(); ++_iter63) |
| { |
| xfer += (*_iter63).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); |
| } |
| |
| const char* KeyValueAndPeek::ascii_fingerprint = "CBBC6AB9C7EA5E5E748C13F970862FAB"; |
| const uint8_t KeyValueAndPeek::binary_fingerprint[16] = {0xCB,0xBC,0x6A,0xB9,0xC7,0xEA,0x5E,0x5E,0x74,0x8C,0x13,0xF9,0x70,0x86,0x2F,0xAB}; |
| |
| uint32_t KeyValueAndPeek::read(::apache::thrift::protocol::TProtocol* iprot) { |
| |
| uint32_t xfer = 0; |
| std::string fname; |
| ::apache::thrift::protocol::TType ftype; |
| int16_t fid; |
| |
| xfer += iprot->readStructBegin(fname); |
| |
| 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; |
| 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); |
| } |
| |
| const char* KeyExtent::ascii_fingerprint = "AB879940BD15B6B25691265F7384B271"; |
| const uint8_t KeyExtent::binary_fingerprint[16] = {0xAB,0x87,0x99,0x40,0xBD,0x15,0xB6,0xB2,0x56,0x91,0x26,0x5F,0x73,0x84,0xB2,0x71}; |
| |
| uint32_t KeyExtent::read(::apache::thrift::protocol::TProtocol* iprot) { |
| |
| uint32_t xfer = 0; |
| std::string fname; |
| ::apache::thrift::protocol::TType ftype; |
| int16_t fid; |
| |
| xfer += iprot->readStructBegin(fname); |
| |
| 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; |
| 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); |
| } |
| |
| const char* Column::ascii_fingerprint = "AB879940BD15B6B25691265F7384B271"; |
| const uint8_t Column::binary_fingerprint[16] = {0xAB,0x87,0x99,0x40,0xBD,0x15,0xB6,0xB2,0x56,0x91,0x26,0x5F,0x73,0x84,0xB2,0x71}; |
| |
| uint32_t Column::read(::apache::thrift::protocol::TProtocol* iprot) { |
| |
| uint32_t xfer = 0; |
| std::string fname; |
| ::apache::thrift::protocol::TType ftype; |
| int16_t fid; |
| |
| xfer += iprot->readStructBegin(fname); |
| |
| 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; |
| 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); |
| } |
| |
| const char* Condition::ascii_fingerprint = "C4022914C22D89E33B1A46A7D511C58F"; |
| const uint8_t Condition::binary_fingerprint[16] = {0xC4,0x02,0x29,0x14,0xC2,0x2D,0x89,0xE3,0x3B,0x1A,0x46,0xA7,0xD5,0x11,0xC5,0x8F}; |
| |
| uint32_t Condition::read(::apache::thrift::protocol::TProtocol* iprot) { |
| |
| uint32_t xfer = 0; |
| std::string fname; |
| ::apache::thrift::protocol::TType ftype; |
| int16_t fid; |
| |
| xfer += iprot->readStructBegin(fname); |
| |
| 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 _size64; |
| ::apache::thrift::protocol::TType _etype67; |
| xfer += iprot->readListBegin(_etype67, _size64); |
| this->iterators.resize(_size64); |
| uint32_t _i68; |
| for (_i68 = 0; _i68 < _size64; ++_i68) |
| { |
| xfer += this->iterators[_i68].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; |
| 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 _iter69; |
| for (_iter69 = this->iterators.begin(); _iter69 != this->iterators.end(); ++_iter69) |
| { |
| xfer += (*_iter69).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); |
| } |
| |
| const char* ConditionalUpdates::ascii_fingerprint = "1C1808872D1A8E04F114974ADD77F356"; |
| const uint8_t ConditionalUpdates::binary_fingerprint[16] = {0x1C,0x18,0x08,0x87,0x2D,0x1A,0x8E,0x04,0xF1,0x14,0x97,0x4A,0xDD,0x77,0xF3,0x56}; |
| |
| uint32_t ConditionalUpdates::read(::apache::thrift::protocol::TProtocol* iprot) { |
| |
| uint32_t xfer = 0; |
| std::string fname; |
| ::apache::thrift::protocol::TType ftype; |
| int16_t fid; |
| |
| xfer += iprot->readStructBegin(fname); |
| |
| 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 _size70; |
| ::apache::thrift::protocol::TType _etype73; |
| xfer += iprot->readListBegin(_etype73, _size70); |
| this->conditions.resize(_size70); |
| uint32_t _i74; |
| for (_i74 = 0; _i74 < _size70; ++_i74) |
| { |
| xfer += this->conditions[_i74].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 _size75; |
| ::apache::thrift::protocol::TType _etype78; |
| xfer += iprot->readListBegin(_etype78, _size75); |
| this->updates.resize(_size75); |
| uint32_t _i79; |
| for (_i79 = 0; _i79 < _size75; ++_i79) |
| { |
| xfer += this->updates[_i79].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; |
| xfer += oprot->writeStructBegin("ConditionalUpdates"); |
| |
| xfer += oprot->writeFieldBegin("conditions", ::apache::thrift::protocol::T_LIST, 2); |
| { |
| xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->conditions.size())); |
| std::vector<Condition> ::const_iterator _iter80; |
| for (_iter80 = this->conditions.begin(); _iter80 != this->conditions.end(); ++_iter80) |
| { |
| xfer += (*_iter80).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 _iter81; |
| for (_iter81 = this->updates.begin(); _iter81 != this->updates.end(); ++_iter81) |
| { |
| xfer += (*_iter81).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); |
| } |
| |
| const char* ConditionalWriterOptions::ascii_fingerprint = "C345C04E84A351638B6EACB741BD600E"; |
| const uint8_t ConditionalWriterOptions::binary_fingerprint[16] = {0xC3,0x45,0xC0,0x4E,0x84,0xA3,0x51,0x63,0x8B,0x6E,0xAC,0xB7,0x41,0xBD,0x60,0x0E}; |
| |
| uint32_t ConditionalWriterOptions::read(::apache::thrift::protocol::TProtocol* iprot) { |
| |
| uint32_t xfer = 0; |
| std::string fname; |
| ::apache::thrift::protocol::TType ftype; |
| int16_t fid; |
| |
| xfer += iprot->readStructBegin(fname); |
| |
| 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 _size82; |
| ::apache::thrift::protocol::TType _etype85; |
| xfer += iprot->readSetBegin(_etype85, _size82); |
| uint32_t _i86; |
| for (_i86 = 0; _i86 < _size82; ++_i86) |
| { |
| std::string _elem87; |
| xfer += iprot->readBinary(_elem87); |
| this->authorizations.insert(_elem87); |
| } |
| xfer += iprot->readSetEnd(); |
| } |
| this->__isset.authorizations = true; |
| } else { |
| xfer += iprot->skip(ftype); |
| } |
| break; |
| case 5: |
| if (ftype == ::apache::thrift::protocol::T_I32) { |
| int32_t ecast88; |
| xfer += iprot->readI32(ecast88); |
| this->durability = (Durability::type)ecast88; |
| 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; |
| 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 _iter89; |
| for (_iter89 = this->authorizations.begin(); _iter89 != this->authorizations.end(); ++_iter89) |
| { |
| xfer += oprot->writeBinary((*_iter89)); |
| } |
| 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); |
| } |
| |
| const char* ActiveScan::ascii_fingerprint = "1B97541CB4E900A054266BBBEE61D004"; |
| const uint8_t ActiveScan::binary_fingerprint[16] = {0x1B,0x97,0x54,0x1C,0xB4,0xE9,0x00,0xA0,0x54,0x26,0x6B,0xBB,0xEE,0x61,0xD0,0x04}; |
| |
| uint32_t ActiveScan::read(::apache::thrift::protocol::TProtocol* iprot) { |
| |
| uint32_t xfer = 0; |
| std::string fname; |
| ::apache::thrift::protocol::TType ftype; |
| int16_t fid; |
| |
| xfer += iprot->readStructBegin(fname); |
| |
| 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 ecast90; |
| xfer += iprot->readI32(ecast90); |
| this->type = (ScanType::type)ecast90; |
| this->__isset.type = true; |
| } else { |
| xfer += iprot->skip(ftype); |
| } |
| break; |
| case 7: |
| if (ftype == ::apache::thrift::protocol::T_I32) { |
| int32_t ecast91; |
| xfer += iprot->readI32(ecast91); |
| this->state = (ScanState::type)ecast91; |
| 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 _size92; |
| ::apache::thrift::protocol::TType _etype95; |
| xfer += iprot->readListBegin(_etype95, _size92); |
| this->columns.resize(_size92); |
| uint32_t _i96; |
| for (_i96 = 0; _i96 < _size92; ++_i96) |
| { |
| xfer += this->columns[_i96].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 _size97; |
| ::apache::thrift::protocol::TType _etype100; |
| xfer += iprot->readListBegin(_etype100, _size97); |
| this->iterators.resize(_size97); |
| uint32_t _i101; |
| for (_i101 = 0; _i101 < _size97; ++_i101) |
| { |
| xfer += this->iterators[_i101].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 _size102; |
| ::apache::thrift::protocol::TType _etype105; |
| xfer += iprot->readListBegin(_etype105, _size102); |
| this->authorizations.resize(_size102); |
| uint32_t _i106; |
| for (_i106 = 0; _i106 < _size102; ++_i106) |
| { |
| xfer += iprot->readBinary(this->authorizations[_i106]); |
| } |
| 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; |
| 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 _iter107; |
| for (_iter107 = this->columns.begin(); _iter107 != this->columns.end(); ++_iter107) |
| { |
| xfer += (*_iter107).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 _iter108; |
| for (_iter108 = this->iterators.begin(); _iter108 != this->iterators.end(); ++_iter108) |
| { |
| xfer += (*_iter108).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 _iter109; |
| for (_iter109 = this->authorizations.begin(); _iter109 != this->authorizations.end(); ++_iter109) |
| { |
| xfer += oprot->writeBinary((*_iter109)); |
| } |
| 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); |
| } |
| |
| const char* ActiveCompaction::ascii_fingerprint = "2BB155CC901109464666B6C7E6A8C1A6"; |
| const uint8_t ActiveCompaction::binary_fingerprint[16] = {0x2B,0xB1,0x55,0xCC,0x90,0x11,0x09,0x46,0x46,0x66,0xB6,0xC7,0xE6,0xA8,0xC1,0xA6}; |
| |
| uint32_t ActiveCompaction::read(::apache::thrift::protocol::TProtocol* iprot) { |
| |
| uint32_t xfer = 0; |
| std::string fname; |
| ::apache::thrift::protocol::TType ftype; |
| int16_t fid; |
| |
| xfer += iprot->readStructBegin(fname); |
| |
| 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 _size110; |
| ::apache::thrift::protocol::TType _etype113; |
| xfer += iprot->readListBegin(_etype113, _size110); |
| this->inputFiles.resize(_size110); |
| uint32_t _i114; |
| for (_i114 = 0; _i114 < _size110; ++_i114) |
| { |
| xfer += iprot->readString(this->inputFiles[_i114]); |
| } |
| 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 ecast115; |
| xfer += iprot->readI32(ecast115); |
| this->type = (CompactionType::type)ecast115; |
| this->__isset.type = true; |
| } else { |
| xfer += iprot->skip(ftype); |
| } |
| break; |
| case 6: |
| if (ftype == ::apache::thrift::protocol::T_I32) { |
| int32_t ecast116; |
| xfer += iprot->readI32(ecast116); |
| this->reason = (CompactionReason::type)ecast116; |
| 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 _size117; |
| ::apache::thrift::protocol::TType _etype120; |
| xfer += iprot->readListBegin(_etype120, _size117); |
| this->iterators.resize(_size117); |
| uint32_t _i121; |
| for (_i121 = 0; _i121 < _size117; ++_i121) |
| { |
| xfer += this->iterators[_i121].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; |
| 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 _iter122; |
| for (_iter122 = this->inputFiles.begin(); _iter122 != this->inputFiles.end(); ++_iter122) |
| { |
| xfer += oprot->writeString((*_iter122)); |
| } |
| 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 _iter123; |
| for (_iter123 = this->iterators.begin(); _iter123 != this->iterators.end(); ++_iter123) |
| { |
| xfer += (*_iter123).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); |
| } |
| |
| const char* WriterOptions::ascii_fingerprint = "6640C55D2C0D4C8C2E7589456EA0C61A"; |
| const uint8_t WriterOptions::binary_fingerprint[16] = {0x66,0x40,0xC5,0x5D,0x2C,0x0D,0x4C,0x8C,0x2E,0x75,0x89,0x45,0x6E,0xA0,0xC6,0x1A}; |
| |
| uint32_t WriterOptions::read(::apache::thrift::protocol::TProtocol* iprot) { |
| |
| uint32_t xfer = 0; |
| std::string fname; |
| ::apache::thrift::protocol::TType ftype; |
| int16_t fid; |
| |
| xfer += iprot->readStructBegin(fname); |
| |
| 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 ecast124; |
| xfer += iprot->readI32(ecast124); |
| this->durability = (Durability::type)ecast124; |
| 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; |
| 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); |
| } |
| |
| const char* CompactionStrategyConfig::ascii_fingerprint = "F7C641917C22B35AE581CCD54910B00D"; |
| const uint8_t CompactionStrategyConfig::binary_fingerprint[16] = {0xF7,0xC6,0x41,0x91,0x7C,0x22,0xB3,0x5A,0xE5,0x81,0xCC,0xD5,0x49,0x10,0xB0,0x0D}; |
| |
| uint32_t CompactionStrategyConfig::read(::apache::thrift::protocol::TProtocol* iprot) { |
| |
| uint32_t xfer = 0; |
| std::string fname; |
| ::apache::thrift::protocol::TType ftype; |
| int16_t fid; |
| |
| xfer += iprot->readStructBegin(fname); |
| |
| 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 _size125; |
| ::apache::thrift::protocol::TType _ktype126; |
| ::apache::thrift::protocol::TType _vtype127; |
| xfer += iprot->readMapBegin(_ktype126, _vtype127, _size125); |
| uint32_t _i129; |
| for (_i129 = 0; _i129 < _size125; ++_i129) |
| { |
| std::string _key130; |
| xfer += iprot->readString(_key130); |
| std::string& _val131 = this->options[_key130]; |
| xfer += iprot->readString(_val131); |
| } |
| 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; |
| 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 _iter132; |
| for (_iter132 = this->options.begin(); _iter132 != this->options.end(); ++_iter132) |
| { |
| xfer += oprot->writeString(_iter132->first); |
| xfer += oprot->writeString(_iter132->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); |
| } |
| |
| const char* UnknownScanner::ascii_fingerprint = "EFB929595D312AC8F305D5A794CFEDA1"; |
| const uint8_t UnknownScanner::binary_fingerprint[16] = {0xEF,0xB9,0x29,0x59,0x5D,0x31,0x2A,0xC8,0xF3,0x05,0xD5,0xA7,0x94,0xCF,0xED,0xA1}; |
| |
| uint32_t UnknownScanner::read(::apache::thrift::protocol::TProtocol* iprot) { |
| |
| uint32_t xfer = 0; |
| std::string fname; |
| ::apache::thrift::protocol::TType ftype; |
| int16_t fid; |
| |
| xfer += iprot->readStructBegin(fname); |
| |
| 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; |
| 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); |
| } |
| |
| const char* UnknownWriter::ascii_fingerprint = "EFB929595D312AC8F305D5A794CFEDA1"; |
| const uint8_t UnknownWriter::binary_fingerprint[16] = {0xEF,0xB9,0x29,0x59,0x5D,0x31,0x2A,0xC8,0xF3,0x05,0xD5,0xA7,0x94,0xCF,0xED,0xA1}; |
| |
| uint32_t UnknownWriter::read(::apache::thrift::protocol::TProtocol* iprot) { |
| |
| uint32_t xfer = 0; |
| std::string fname; |
| ::apache::thrift::protocol::TType ftype; |
| int16_t fid; |
| |
| xfer += iprot->readStructBegin(fname); |
| |
| 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; |
| 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); |
| } |
| |
| const char* NoMoreEntriesException::ascii_fingerprint = "EFB929595D312AC8F305D5A794CFEDA1"; |
| const uint8_t NoMoreEntriesException::binary_fingerprint[16] = {0xEF,0xB9,0x29,0x59,0x5D,0x31,0x2A,0xC8,0xF3,0x05,0xD5,0xA7,0x94,0xCF,0xED,0xA1}; |
| |
| uint32_t NoMoreEntriesException::read(::apache::thrift::protocol::TProtocol* iprot) { |
| |
| uint32_t xfer = 0; |
| std::string fname; |
| ::apache::thrift::protocol::TType ftype; |
| int16_t fid; |
| |
| xfer += iprot->readStructBegin(fname); |
| |
| 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; |
| 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); |
| } |
| |
| const char* AccumuloException::ascii_fingerprint = "EFB929595D312AC8F305D5A794CFEDA1"; |
| const uint8_t AccumuloException::binary_fingerprint[16] = {0xEF,0xB9,0x29,0x59,0x5D,0x31,0x2A,0xC8,0xF3,0x05,0xD5,0xA7,0x94,0xCF,0xED,0xA1}; |
| |
| uint32_t AccumuloException::read(::apache::thrift::protocol::TProtocol* iprot) { |
| |
| uint32_t xfer = 0; |
| std::string fname; |
| ::apache::thrift::protocol::TType ftype; |
| int16_t fid; |
| |
| xfer += iprot->readStructBegin(fname); |
| |
| 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; |
| 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); |
| } |
| |
| const char* AccumuloSecurityException::ascii_fingerprint = "EFB929595D312AC8F305D5A794CFEDA1"; |
| const uint8_t AccumuloSecurityException::binary_fingerprint[16] = {0xEF,0xB9,0x29,0x59,0x5D,0x31,0x2A,0xC8,0xF3,0x05,0xD5,0xA7,0x94,0xCF,0xED,0xA1}; |
| |
| uint32_t AccumuloSecurityException::read(::apache::thrift::protocol::TProtocol* iprot) { |
| |
| uint32_t xfer = 0; |
| std::string fname; |
| ::apache::thrift::protocol::TType ftype; |
| int16_t fid; |
| |
| xfer += iprot->readStructBegin(fname); |
| |
| 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; |
| 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); |
| } |
| |
| const char* TableNotFoundException::ascii_fingerprint = "EFB929595D312AC8F305D5A794CFEDA1"; |
| const uint8_t TableNotFoundException::binary_fingerprint[16] = {0xEF,0xB9,0x29,0x59,0x5D,0x31,0x2A,0xC8,0xF3,0x05,0xD5,0xA7,0x94,0xCF,0xED,0xA1}; |
| |
| uint32_t TableNotFoundException::read(::apache::thrift::protocol::TProtocol* iprot) { |
| |
| uint32_t xfer = 0; |
| std::string fname; |
| ::apache::thrift::protocol::TType ftype; |
| int16_t fid; |
| |
| xfer += iprot->readStructBegin(fname); |
| |
| 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; |
| 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); |
| } |
| |
| const char* TableExistsException::ascii_fingerprint = "EFB929595D312AC8F305D5A794CFEDA1"; |
| const uint8_t TableExistsException::binary_fingerprint[16] = {0xEF,0xB9,0x29,0x59,0x5D,0x31,0x2A,0xC8,0xF3,0x05,0xD5,0xA7,0x94,0xCF,0xED,0xA1}; |
| |
| uint32_t TableExistsException::read(::apache::thrift::protocol::TProtocol* iprot) { |
| |
| uint32_t xfer = 0; |
| std::string fname; |
| ::apache::thrift::protocol::TType ftype; |
| int16_t fid; |
| |
| xfer += iprot->readStructBegin(fname); |
| |
| 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; |
| 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); |
| } |
| |
| const char* MutationsRejectedException::ascii_fingerprint = "EFB929595D312AC8F305D5A794CFEDA1"; |
| const uint8_t MutationsRejectedException::binary_fingerprint[16] = {0xEF,0xB9,0x29,0x59,0x5D,0x31,0x2A,0xC8,0xF3,0x05,0xD5,0xA7,0x94,0xCF,0xED,0xA1}; |
| |
| uint32_t MutationsRejectedException::read(::apache::thrift::protocol::TProtocol* iprot) { |
| |
| uint32_t xfer = 0; |
| std::string fname; |
| ::apache::thrift::protocol::TType ftype; |
| int16_t fid; |
| |
| xfer += iprot->readStructBegin(fname); |
| |
| 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; |
| 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); |
| } |
| |
| } // namespace |