~maria-captains/maria/5.5-cassandra-parallel
» Revision
3516
: storage/cassandra/gen-cpp-async/cassandra_types.cpp
« back to all changes in this revision
Viewing changes to storage/cassandra/gen-cpp-async/cassandra_types.cpp
- browse files at revision 3516
- compare with another revision
- compare with revision 3517
- download diff
- download tarball
- view history from revision 3516
- Committer: Sergey Petrunya
- Date: 2012-09-20 14:32:37 UTC
- Revision ID: psergey@askmonty.org-20120920143237-og4d9qh8uiojasmi
Casandra SE:
- Introduce asynchronous operations
- parallel INSERT operation.
- Introduce asynchronous operations
- parallel INSERT operation.
- files added:
- storage/cassandra/gen-cpp-async
- files modified:
- storage/cassandra/CMakeLists.txt
added
removed
storage/cassandra/gen-cpp-async/cassandra_types.cpp
1
/**
2
* Autogenerated by Thrift Compiler (0.9.0-dev)
3
*
4
* DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
5
* @generated
6
*/
7
#include "cassandra_types.h"
8
9
#include <algorithm>
10
11
namespace org { namespace apache { namespace cassandra {
12
13
int _kConsistencyLevelValues[] = {
14
ConsistencyLevel::ONE,
15
ConsistencyLevel::QUORUM,
16
ConsistencyLevel::LOCAL_QUORUM,
17
ConsistencyLevel::EACH_QUORUM,
18
ConsistencyLevel::ALL,
19
ConsistencyLevel::ANY,
20
ConsistencyLevel::TWO,
21
ConsistencyLevel::THREE
22
};
23
const char* _kConsistencyLevelNames[] = {
24
"ONE",
25
"QUORUM",
26
"LOCAL_QUORUM",
27
"EACH_QUORUM",
28
"ALL",
29
"ANY",
30
"TWO",
31
"THREE"
32
};
33
const std::map<int, const char*> _ConsistencyLevel_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(8, _kConsistencyLevelValues, _kConsistencyLevelNames), ::apache::thrift::TEnumIterator(-1, NULL, NULL));
34
35
int _kIndexOperatorValues[] = {
36
IndexOperator::EQ,
37
IndexOperator::GTE,
38
IndexOperator::GT,
39
IndexOperator::LTE,
40
IndexOperator::LT
41
};
42
const char* _kIndexOperatorNames[] = {
43
"EQ",
44
"GTE",
45
"GT",
46
"LTE",
47
"LT"
48
};
49
const std::map<int, const char*> _IndexOperator_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(5, _kIndexOperatorValues, _kIndexOperatorNames), ::apache::thrift::TEnumIterator(-1, NULL, NULL));
50
51
int _kIndexTypeValues[] = {
52
IndexType::KEYS,
53
IndexType::CUSTOM
54
};
55
const char* _kIndexTypeNames[] = {
56
"KEYS",
57
"CUSTOM"
58
};
59
const std::map<int, const char*> _IndexType_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(2, _kIndexTypeValues, _kIndexTypeNames), ::apache::thrift::TEnumIterator(-1, NULL, NULL));
60
61
int _kCompressionValues[] = {
62
Compression::GZIP,
63
Compression::NONE
64
};
65
const char* _kCompressionNames[] = {
66
"GZIP",
67
"NONE"
68
};
69
const std::map<int, const char*> _Compression_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(2, _kCompressionValues, _kCompressionNames), ::apache::thrift::TEnumIterator(-1, NULL, NULL));
70
71
int _kCqlResultTypeValues[] = {
72
CqlResultType::ROWS,
73
CqlResultType::VOID,
74
CqlResultType::INT
75
};
76
const char* _kCqlResultTypeNames[] = {
77
"ROWS",
78
"VOID",
79
"INT"
80
};
81
const std::map<int, const char*> _CqlResultType_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(3, _kCqlResultTypeValues, _kCqlResultTypeNames), ::apache::thrift::TEnumIterator(-1, NULL, NULL));
82
83
const char* Column::ascii_fingerprint = "3EE0E1C5C844001B62F08125068292CC";
84
const uint8_t Column::binary_fingerprint[16] = {0x3E,0xE0,0xE1,0xC5,0xC8,0x44,0x00,0x1B,0x62,0xF0,0x81,0x25,0x06,0x82,0x92,0xCC};
85
86
uint32_t Column::read(::apache::thrift::protocol::TProtocol* iprot) {
87
88
uint32_t xfer = 0;
89
std::string fname;
90
::apache::thrift::protocol::TType ftype;
91
int16_t fid;
92
93
xfer += iprot->readStructBegin(fname);
94
95
using ::apache::thrift::protocol::TProtocolException;
96
97
bool isset_name = false;
98
99
while (true)
100
{
101
xfer += iprot->readFieldBegin(fname, ftype, fid);
102
if (ftype == ::apache::thrift::protocol::T_STOP) {
103
break;
104
}
105
switch (fid)
106
{
107
case 1:
108
if (ftype == ::apache::thrift::protocol::T_STRING) {
109
xfer += iprot->readBinary(this->name);
110
isset_name = true;
111
} else {
112
xfer += iprot->skip(ftype);
113
}
114
break;
115
case 2:
116
if (ftype == ::apache::thrift::protocol::T_STRING) {
117
xfer += iprot->readBinary(this->value);
118
this->__isset.value = true;
119
} else {
120
xfer += iprot->skip(ftype);
121
}
122
break;
123
case 3:
124
if (ftype == ::apache::thrift::protocol::T_I64) {
125
xfer += iprot->readI64(this->timestamp);
126
this->__isset.timestamp = true;
127
} else {
128
xfer += iprot->skip(ftype);
129
}
130
break;
131
case 4:
132
if (ftype == ::apache::thrift::protocol::T_I32) {
133
xfer += iprot->readI32(this->ttl);
134
this->__isset.ttl = true;
135
} else {
136
xfer += iprot->skip(ftype);
137
}
138
break;
139
default:
140
xfer += iprot->skip(ftype);
141
break;
142
}
143
xfer += iprot->readFieldEnd();
144
}
145
146
xfer += iprot->readStructEnd();
147
148
if (!isset_name)
149
throw TProtocolException(TProtocolException::INVALID_DATA);
150
return xfer;
151
}
152
153
uint32_t Column::write(::apache::thrift::protocol::TProtocol* oprot) const {
154
uint32_t xfer = 0;
155
xfer += oprot->writeStructBegin("Column");
156
157
xfer += oprot->writeFieldBegin("name", ::apache::thrift::protocol::T_STRING, 1);
158
xfer += oprot->writeBinary(this->name);
159
xfer += oprot->writeFieldEnd();
160
161
if (this->__isset.value) {
162
xfer += oprot->writeFieldBegin("value", ::apache::thrift::protocol::T_STRING, 2);
163
xfer += oprot->writeBinary(this->value);
164
xfer += oprot->writeFieldEnd();
165
}
166
if (this->__isset.timestamp) {
167
xfer += oprot->writeFieldBegin("timestamp", ::apache::thrift::protocol::T_I64, 3);
168
xfer += oprot->writeI64(this->timestamp);
169
xfer += oprot->writeFieldEnd();
170
}
171
if (this->__isset.ttl) {
172
xfer += oprot->writeFieldBegin("ttl", ::apache::thrift::protocol::T_I32, 4);
173
xfer += oprot->writeI32(this->ttl);
174
xfer += oprot->writeFieldEnd();
175
}
176
xfer += oprot->writeFieldStop();
177
xfer += oprot->writeStructEnd();
178
return xfer;
179
}
180
181
void swap(Column &a, Column &b) {
182
using ::std::swap;
183
swap(a.name, b.name);
184
swap(a.value, b.value);
185
swap(a.timestamp, b.timestamp);
186
swap(a.ttl, b.ttl);
187
swap(a.__isset, b.__isset);
188
}
189
190
const char* SuperColumn::ascii_fingerprint = "470EFC558004E98D92D604898305C04E";
191
const uint8_t SuperColumn::binary_fingerprint[16] = {0x47,0x0E,0xFC,0x55,0x80,0x04,0xE9,0x8D,0x92,0xD6,0x04,0x89,0x83,0x05,0xC0,0x4E};
192
193
uint32_t SuperColumn::read(::apache::thrift::protocol::TProtocol* iprot) {
194
195
uint32_t xfer = 0;
196
std::string fname;
197
::apache::thrift::protocol::TType ftype;
198
int16_t fid;
199
200
xfer += iprot->readStructBegin(fname);
201
202
using ::apache::thrift::protocol::TProtocolException;
203
204
bool isset_name = false;
205
bool isset_columns = false;
206
207
while (true)
208
{
209
xfer += iprot->readFieldBegin(fname, ftype, fid);
210
if (ftype == ::apache::thrift::protocol::T_STOP) {
211
break;
212
}
213
switch (fid)
214
{
215
case 1:
216
if (ftype == ::apache::thrift::protocol::T_STRING) {
217
xfer += iprot->readBinary(this->name);
218
isset_name = true;
219
} else {
220
xfer += iprot->skip(ftype);
221
}
222
break;
223
case 2:
224
if (ftype == ::apache::thrift::protocol::T_LIST) {
225
{
226
this->columns.clear();
227
uint32_t _size0;
228
::apache::thrift::protocol::TType _etype3;
229
xfer += iprot->readListBegin(_etype3, _size0);
230
this->columns.resize(_size0);
231
uint32_t _i4;
232
for (_i4 = 0; _i4 < _size0; ++_i4)
233
{
234
xfer += this->columns[_i4].read(iprot);
235
}
236
xfer += iprot->readListEnd();
237
}
238
isset_columns = true;
239
} else {
240
xfer += iprot->skip(ftype);
241
}
242
break;
243
default:
244
xfer += iprot->skip(ftype);
245
break;
246
}
247
xfer += iprot->readFieldEnd();
248
}
249
250
xfer += iprot->readStructEnd();
251
252
if (!isset_name)
253
throw TProtocolException(TProtocolException::INVALID_DATA);
254
if (!isset_columns)
255
throw TProtocolException(TProtocolException::INVALID_DATA);
256
return xfer;
257
}
258
259
uint32_t SuperColumn::write(::apache::thrift::protocol::TProtocol* oprot) const {
260
uint32_t xfer = 0;
261
xfer += oprot->writeStructBegin("SuperColumn");
262
263
xfer += oprot->writeFieldBegin("name", ::apache::thrift::protocol::T_STRING, 1);
264
xfer += oprot->writeBinary(this->name);
265
xfer += oprot->writeFieldEnd();
266
267
xfer += oprot->writeFieldBegin("columns", ::apache::thrift::protocol::T_LIST, 2);
268
{
269
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->columns.size()));
270
std::vector<Column> ::const_iterator _iter5;
271
for (_iter5 = this->columns.begin(); _iter5 != this->columns.end(); ++_iter5)
272
{
273
xfer += (*_iter5).write(oprot);
274
}
275
xfer += oprot->writeListEnd();
276
}
277
xfer += oprot->writeFieldEnd();
278
279
xfer += oprot->writeFieldStop();
280
xfer += oprot->writeStructEnd();
281
return xfer;
282
}
283
284
void swap(SuperColumn &a, SuperColumn &b) {
285
using ::std::swap;
286
swap(a.name, b.name);
287
swap(a.columns, b.columns);
288
}
289
290
const char* CounterColumn::ascii_fingerprint = "1CCCF6FC31CFD1D61BBBB1BAF3590620";
291
const uint8_t CounterColumn::binary_fingerprint[16] = {0x1C,0xCC,0xF6,0xFC,0x31,0xCF,0xD1,0xD6,0x1B,0xBB,0xB1,0xBA,0xF3,0x59,0x06,0x20};
292
293
uint32_t CounterColumn::read(::apache::thrift::protocol::TProtocol* iprot) {
294
295
uint32_t xfer = 0;
296
std::string fname;
297
::apache::thrift::protocol::TType ftype;
298
int16_t fid;
299
300
xfer += iprot->readStructBegin(fname);
301
302
using ::apache::thrift::protocol::TProtocolException;
303
304
bool isset_name = false;
305
bool isset_value = false;
306
307
while (true)
308
{
309
xfer += iprot->readFieldBegin(fname, ftype, fid);
310
if (ftype == ::apache::thrift::protocol::T_STOP) {
311
break;
312
}
313
switch (fid)
314
{
315
case 1:
316
if (ftype == ::apache::thrift::protocol::T_STRING) {
317
xfer += iprot->readBinary(this->name);
318
isset_name = true;
319
} else {
320
xfer += iprot->skip(ftype);
321
}
322
break;
323
case 2:
324
if (ftype == ::apache::thrift::protocol::T_I64) {
325
xfer += iprot->readI64(this->value);
326
isset_value = true;
327
} else {
328
xfer += iprot->skip(ftype);
329
}
330
break;
331
default:
332
xfer += iprot->skip(ftype);
333
break;
334
}
335
xfer += iprot->readFieldEnd();
336
}
337
338
xfer += iprot->readStructEnd();
339
340
if (!isset_name)
341
throw TProtocolException(TProtocolException::INVALID_DATA);
342
if (!isset_value)
343
throw TProtocolException(TProtocolException::INVALID_DATA);
344
return xfer;
345
}
346
347
uint32_t CounterColumn::write(::apache::thrift::protocol::TProtocol* oprot) const {
348
uint32_t xfer = 0;
349
xfer += oprot->writeStructBegin("CounterColumn");
350
351
xfer += oprot->writeFieldBegin("name", ::apache::thrift::protocol::T_STRING, 1);
352
xfer += oprot->writeBinary(this->name);
353
xfer += oprot->writeFieldEnd();
354
355
xfer += oprot->writeFieldBegin("value", ::apache::thrift::protocol::T_I64, 2);
356
xfer += oprot->writeI64(this->value);
357
xfer += oprot->writeFieldEnd();
358
359
xfer += oprot->writeFieldStop();
360
xfer += oprot->writeStructEnd();
361
return xfer;
362
}
363
364
void swap(CounterColumn &a, CounterColumn &b) {
365
using ::std::swap;
366
swap(a.name, b.name);
367
swap(a.value, b.value);
368
}
369
370
const char* CounterSuperColumn::ascii_fingerprint = "CD4C8C4BF7753E46DE417CDE369343A4";
371
const uint8_t CounterSuperColumn::binary_fingerprint[16] = {0xCD,0x4C,0x8C,0x4B,0xF7,0x75,0x3E,0x46,0xDE,0x41,0x7C,0xDE,0x36,0x93,0x43,0xA4};
372
373
uint32_t CounterSuperColumn::read(::apache::thrift::protocol::TProtocol* iprot) {
374
375
uint32_t xfer = 0;
376
std::string fname;
377
::apache::thrift::protocol::TType ftype;
378
int16_t fid;
379
380
xfer += iprot->readStructBegin(fname);
381
382
using ::apache::thrift::protocol::TProtocolException;
383
384
bool isset_name = false;
385
bool isset_columns = false;
386
387
while (true)
388
{
389
xfer += iprot->readFieldBegin(fname, ftype, fid);
390
if (ftype == ::apache::thrift::protocol::T_STOP) {
391
break;
392
}
393
switch (fid)
394
{
395
case 1:
396
if (ftype == ::apache::thrift::protocol::T_STRING) {
397
xfer += iprot->readBinary(this->name);
398
isset_name = true;
399
} else {
400
xfer += iprot->skip(ftype);
401
}
402
break;
403
case 2:
404
if (ftype == ::apache::thrift::protocol::T_LIST) {
405
{
406
this->columns.clear();
407
uint32_t _size6;
408
::apache::thrift::protocol::TType _etype9;
409
xfer += iprot->readListBegin(_etype9, _size6);
410
this->columns.resize(_size6);
411
uint32_t _i10;
412
for (_i10 = 0; _i10 < _size6; ++_i10)
413
{
414
xfer += this->columns[_i10].read(iprot);
415
}
416
xfer += iprot->readListEnd();
417
}
418
isset_columns = true;
419
} else {
420
xfer += iprot->skip(ftype);
421
}
422
break;
423
default:
424
xfer += iprot->skip(ftype);
425
break;
426
}
427
xfer += iprot->readFieldEnd();
428
}
429
430
xfer += iprot->readStructEnd();
431
432
if (!isset_name)
433
throw TProtocolException(TProtocolException::INVALID_DATA);
434
if (!isset_columns)
435
throw TProtocolException(TProtocolException::INVALID_DATA);
436
return xfer;
437
}
438
439
uint32_t CounterSuperColumn::write(::apache::thrift::protocol::TProtocol* oprot) const {
440
uint32_t xfer = 0;
441
xfer += oprot->writeStructBegin("CounterSuperColumn");
442
443
xfer += oprot->writeFieldBegin("name", ::apache::thrift::protocol::T_STRING, 1);
444
xfer += oprot->writeBinary(this->name);
445
xfer += oprot->writeFieldEnd();
446
447
xfer += oprot->writeFieldBegin("columns", ::apache::thrift::protocol::T_LIST, 2);
448
{
449
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->columns.size()));
450
std::vector<CounterColumn> ::const_iterator _iter11;
451
for (_iter11 = this->columns.begin(); _iter11 != this->columns.end(); ++_iter11)
452
{
453
xfer += (*_iter11).write(oprot);
454
}
455
xfer += oprot->writeListEnd();
456
}
457
xfer += oprot->writeFieldEnd();
458
459
xfer += oprot->writeFieldStop();
460
xfer += oprot->writeStructEnd();
461
return xfer;
462
}
463
464
void swap(CounterSuperColumn &a, CounterSuperColumn &b) {
465
using ::std::swap;
466
swap(a.name, b.name);
467
swap(a.columns, b.columns);
468
}
469
470
const char* ColumnOrSuperColumn::ascii_fingerprint = "2B34AC9E80F1DAA3A2A63B1AB1841E61";
471
const uint8_t ColumnOrSuperColumn::binary_fingerprint[16] = {0x2B,0x34,0xAC,0x9E,0x80,0xF1,0xDA,0xA3,0xA2,0xA6,0x3B,0x1A,0xB1,0x84,0x1E,0x61};
472
473
uint32_t ColumnOrSuperColumn::read(::apache::thrift::protocol::TProtocol* iprot) {
474
475
uint32_t xfer = 0;
476
std::string fname;
477
::apache::thrift::protocol::TType ftype;
478
int16_t fid;
479
480
xfer += iprot->readStructBegin(fname);
481
482
using ::apache::thrift::protocol::TProtocolException;
483
484
485
while (true)
486
{
487
xfer += iprot->readFieldBegin(fname, ftype, fid);
488
if (ftype == ::apache::thrift::protocol::T_STOP) {
489
break;
490
}
491
switch (fid)
492
{
493
case 1:
494
if (ftype == ::apache::thrift::protocol::T_STRUCT) {
495
xfer += this->column.read(iprot);
496
this->__isset.column = true;
497
} else {
498
xfer += iprot->skip(ftype);
499
}
500
break;
501
case 2:
502
if (ftype == ::apache::thrift::protocol::T_STRUCT) {
503
xfer += this->super_column.read(iprot);
504
this->__isset.super_column = true;
505
} else {
506
xfer += iprot->skip(ftype);
507
}
508
break;
509
case 3:
510
if (ftype == ::apache::thrift::protocol::T_STRUCT) {
511
xfer += this->counter_column.read(iprot);
512
this->__isset.counter_column = true;
513
} else {
514
xfer += iprot->skip(ftype);
515
}
516
break;
517
case 4:
518
if (ftype == ::apache::thrift::protocol::T_STRUCT) {
519
xfer += this->counter_super_column.read(iprot);
520
this->__isset.counter_super_column = true;
521
} else {
522
xfer += iprot->skip(ftype);
523
}
524
break;
525
default:
526
xfer += iprot->skip(ftype);
527
break;
528
}
529
xfer += iprot->readFieldEnd();
530
}
531
532
xfer += iprot->readStructEnd();
533
534
return xfer;
535
}
536
537
uint32_t ColumnOrSuperColumn::write(::apache::thrift::protocol::TProtocol* oprot) const {
538
uint32_t xfer = 0;
539
xfer += oprot->writeStructBegin("ColumnOrSuperColumn");
540
541
if (this->__isset.column) {
542
xfer += oprot->writeFieldBegin("column", ::apache::thrift::protocol::T_STRUCT, 1);
543
xfer += this->column.write(oprot);
544
xfer += oprot->writeFieldEnd();
545
}
546
if (this->__isset.super_column) {
547
xfer += oprot->writeFieldBegin("super_column", ::apache::thrift::protocol::T_STRUCT, 2);
548
xfer += this->super_column.write(oprot);
549
xfer += oprot->writeFieldEnd();
550
}
551
if (this->__isset.counter_column) {
552
xfer += oprot->writeFieldBegin("counter_column", ::apache::thrift::protocol::T_STRUCT, 3);
553
xfer += this->counter_column.write(oprot);
554
xfer += oprot->writeFieldEnd();
555
}
556
if (this->__isset.counter_super_column) {
557
xfer += oprot->writeFieldBegin("counter_super_column", ::apache::thrift::protocol::T_STRUCT, 4);
558
xfer += this->counter_super_column.write(oprot);
559
xfer += oprot->writeFieldEnd();
560
}
561
xfer += oprot->writeFieldStop();
562
xfer += oprot->writeStructEnd();
563
return xfer;
564
}
565
566
void swap(ColumnOrSuperColumn &a, ColumnOrSuperColumn &b) {
567
using ::std::swap;
568
swap(a.column, b.column);
569
swap(a.super_column, b.super_column);
570
swap(a.counter_column, b.counter_column);
571
swap(a.counter_super_column, b.counter_super_column);
572
swap(a.__isset, b.__isset);
573
}
574
575
const char* NotFoundException::ascii_fingerprint = "99914B932BD37A50B983C5E7C90AE93B";
576
const uint8_t NotFoundException::binary_fingerprint[16] = {0x99,0x91,0x4B,0x93,0x2B,0xD3,0x7A,0x50,0xB9,0x83,0xC5,0xE7,0xC9,0x0A,0xE9,0x3B};
577
578
uint32_t NotFoundException::read(::apache::thrift::protocol::TProtocol* iprot) {
579
580
uint32_t xfer = 0;
581
std::string fname;
582
::apache::thrift::protocol::TType ftype;
583
int16_t fid;
584
585
xfer += iprot->readStructBegin(fname);
586
587
using ::apache::thrift::protocol::TProtocolException;
588
589
590
while (true)
591
{
592
xfer += iprot->readFieldBegin(fname, ftype, fid);
593
if (ftype == ::apache::thrift::protocol::T_STOP) {
594
break;
595
}
596
switch (fid)
597
{
598
default:
599
xfer += iprot->skip(ftype);
600
break;
601
}
602
xfer += iprot->readFieldEnd();
603
}
604
605
xfer += iprot->readStructEnd();
606
607
return xfer;
608
}
609
610
uint32_t NotFoundException::write(::apache::thrift::protocol::TProtocol* oprot) const {
611
uint32_t xfer = 0;
612
xfer += oprot->writeStructBegin("NotFoundException");
613
614
xfer += oprot->writeFieldStop();
615
xfer += oprot->writeStructEnd();
616
return xfer;
617
}
618
619
void swap(NotFoundException &a, NotFoundException &b) {
620
using ::std::swap;
621
(void) a;
622
(void) b;
623
}
624
625
const char* InvalidRequestException::ascii_fingerprint = "EFB929595D312AC8F305D5A794CFEDA1";
626
const uint8_t InvalidRequestException::binary_fingerprint[16] = {0xEF,0xB9,0x29,0x59,0x5D,0x31,0x2A,0xC8,0xF3,0x05,0xD5,0xA7,0x94,0xCF,0xED,0xA1};
627
628
uint32_t InvalidRequestException::read(::apache::thrift::protocol::TProtocol* iprot) {
629
630
uint32_t xfer = 0;
631
std::string fname;
632
::apache::thrift::protocol::TType ftype;
633
int16_t fid;
634
635
xfer += iprot->readStructBegin(fname);
636
637
using ::apache::thrift::protocol::TProtocolException;
638
639
bool isset_why = false;
640
641
while (true)
642
{
643
xfer += iprot->readFieldBegin(fname, ftype, fid);
644
if (ftype == ::apache::thrift::protocol::T_STOP) {
645
break;
646
}
647
switch (fid)
648
{
649
case 1:
650
if (ftype == ::apache::thrift::protocol::T_STRING) {
651
xfer += iprot->readString(this->why);
652
isset_why = true;
653
} else {
654
xfer += iprot->skip(ftype);
655
}
656
break;
657
default:
658
xfer += iprot->skip(ftype);
659
break;
660
}
661
xfer += iprot->readFieldEnd();
662
}
663
664
xfer += iprot->readStructEnd();
665
666
if (!isset_why)
667
throw TProtocolException(TProtocolException::INVALID_DATA);
668
return xfer;
669
}
670
671
uint32_t InvalidRequestException::write(::apache::thrift::protocol::TProtocol* oprot) const {
672
uint32_t xfer = 0;
673
xfer += oprot->writeStructBegin("InvalidRequestException");
674
675
xfer += oprot->writeFieldBegin("why", ::apache::thrift::protocol::T_STRING, 1);
676
xfer += oprot->writeString(this->why);
677
xfer += oprot->writeFieldEnd();
678
679
xfer += oprot->writeFieldStop();
680
xfer += oprot->writeStructEnd();
681
return xfer;
682
}
683
684
void swap(InvalidRequestException &a, InvalidRequestException &b) {
685
using ::std::swap;
686
swap(a.why, b.why);
687
}
688
689
const char* UnavailableException::ascii_fingerprint = "99914B932BD37A50B983C5E7C90AE93B";
690
const uint8_t UnavailableException::binary_fingerprint[16] = {0x99,0x91,0x4B,0x93,0x2B,0xD3,0x7A,0x50,0xB9,0x83,0xC5,0xE7,0xC9,0x0A,0xE9,0x3B};
691
692
uint32_t UnavailableException::read(::apache::thrift::protocol::TProtocol* iprot) {
693
694
uint32_t xfer = 0;
695
std::string fname;
696
::apache::thrift::protocol::TType ftype;
697
int16_t fid;
698
699
xfer += iprot->readStructBegin(fname);
700
701
using ::apache::thrift::protocol::TProtocolException;
702
703
704
while (true)
705
{
706
xfer += iprot->readFieldBegin(fname, ftype, fid);
707
if (ftype == ::apache::thrift::protocol::T_STOP) {
708
break;
709
}
710
switch (fid)
711
{
712
default:
713
xfer += iprot->skip(ftype);
714
break;
715
}
716
xfer += iprot->readFieldEnd();
717
}
718
719
xfer += iprot->readStructEnd();
720
721
return xfer;
722
}
723
724
uint32_t UnavailableException::write(::apache::thrift::protocol::TProtocol* oprot) const {
725
uint32_t xfer = 0;
726
xfer += oprot->writeStructBegin("UnavailableException");
727
728
xfer += oprot->writeFieldStop();
729
xfer += oprot->writeStructEnd();
730
return xfer;
731
}
732
733
void swap(UnavailableException &a, UnavailableException &b) {
734
using ::std::swap;
735
(void) a;
736
(void) b;
737
}
738
739
const char* TimedOutException::ascii_fingerprint = "99914B932BD37A50B983C5E7C90AE93B";
740
const uint8_t TimedOutException::binary_fingerprint[16] = {0x99,0x91,0x4B,0x93,0x2B,0xD3,0x7A,0x50,0xB9,0x83,0xC5,0xE7,0xC9,0x0A,0xE9,0x3B};
741
742
uint32_t TimedOutException::read(::apache::thrift::protocol::TProtocol* iprot) {
743
744
uint32_t xfer = 0;
745
std::string fname;
746
::apache::thrift::protocol::TType ftype;
747
int16_t fid;
748
749
xfer += iprot->readStructBegin(fname);
750
751
using ::apache::thrift::protocol::TProtocolException;
752
753
754
while (true)
755
{
756
xfer += iprot->readFieldBegin(fname, ftype, fid);
757
if (ftype == ::apache::thrift::protocol::T_STOP) {
758
break;
759
}
760
switch (fid)
761
{
762
default:
763
xfer += iprot->skip(ftype);
764
break;
765
}
766
xfer += iprot->readFieldEnd();
767
}
768
769
xfer += iprot->readStructEnd();
770
771
return xfer;
772
}
773
774
uint32_t TimedOutException::write(::apache::thrift::protocol::TProtocol* oprot) const {
775
uint32_t xfer = 0;
776
xfer += oprot->writeStructBegin("TimedOutException");
777
778
xfer += oprot->writeFieldStop();
779
xfer += oprot->writeStructEnd();
780
return xfer;
781
}
782
783
void swap(TimedOutException &a, TimedOutException &b) {
784
using ::std::swap;
785
(void) a;
786
(void) b;
787
}
788
789
const char* AuthenticationException::ascii_fingerprint = "EFB929595D312AC8F305D5A794CFEDA1";
790
const uint8_t AuthenticationException::binary_fingerprint[16] = {0xEF,0xB9,0x29,0x59,0x5D,0x31,0x2A,0xC8,0xF3,0x05,0xD5,0xA7,0x94,0xCF,0xED,0xA1};
791
792
uint32_t AuthenticationException::read(::apache::thrift::protocol::TProtocol* iprot) {
793
794
uint32_t xfer = 0;
795
std::string fname;
796
::apache::thrift::protocol::TType ftype;
797
int16_t fid;
798
799
xfer += iprot->readStructBegin(fname);
800
801
using ::apache::thrift::protocol::TProtocolException;
802
803
bool isset_why = false;
804
805
while (true)
806
{
807
xfer += iprot->readFieldBegin(fname, ftype, fid);
808
if (ftype == ::apache::thrift::protocol::T_STOP) {
809
break;
810
}
811
switch (fid)
812
{
813
case 1:
814
if (ftype == ::apache::thrift::protocol::T_STRING) {
815
xfer += iprot->readString(this->why);
816
isset_why = true;
817
} else {
818
xfer += iprot->skip(ftype);
819
}
820
break;
821
default:
822
xfer += iprot->skip(ftype);
823
break;
824
}
825
xfer += iprot->readFieldEnd();
826
}
827
828
xfer += iprot->readStructEnd();
829
830
if (!isset_why)
831
throw TProtocolException(TProtocolException::INVALID_DATA);
832
return xfer;
833
}
834
835
uint32_t AuthenticationException::write(::apache::thrift::protocol::TProtocol* oprot) const {
836
uint32_t xfer = 0;
837
xfer += oprot->writeStructBegin("AuthenticationException");
838
839
xfer += oprot->writeFieldBegin("why", ::apache::thrift::protocol::T_STRING, 1);
840
xfer += oprot->writeString(this->why);
841
xfer += oprot->writeFieldEnd();
842
843
xfer += oprot->writeFieldStop();
844
xfer += oprot->writeStructEnd();
845
return xfer;
846
}
847
848
void swap(AuthenticationException &a, AuthenticationException &b) {
849
using ::std::swap;
850
swap(a.why, b.why);
851
}
852
853
const char* AuthorizationException::ascii_fingerprint = "EFB929595D312AC8F305D5A794CFEDA1";
854
const uint8_t AuthorizationException::binary_fingerprint[16] = {0xEF,0xB9,0x29,0x59,0x5D,0x31,0x2A,0xC8,0xF3,0x05,0xD5,0xA7,0x94,0xCF,0xED,0xA1};
855
856
uint32_t AuthorizationException::read(::apache::thrift::protocol::TProtocol* iprot) {
857
858
uint32_t xfer = 0;
859
std::string fname;
860
::apache::thrift::protocol::TType ftype;
861
int16_t fid;
862
863
xfer += iprot->readStructBegin(fname);
864
865
using ::apache::thrift::protocol::TProtocolException;
866
867
bool isset_why = false;
868
869
while (true)
870
{
871
xfer += iprot->readFieldBegin(fname, ftype, fid);
872
if (ftype == ::apache::thrift::protocol::T_STOP) {
873
break;
874
}
875
switch (fid)
876
{
877
case 1:
878
if (ftype == ::apache::thrift::protocol::T_STRING) {
879
xfer += iprot->readString(this->why);
880
isset_why = true;
881
} else {
882
xfer += iprot->skip(ftype);
883
}
884
break;
885
default:
886
xfer += iprot->skip(ftype);
887
break;
888
}
889
xfer += iprot->readFieldEnd();
890
}
891
892
xfer += iprot->readStructEnd();
893
894
if (!isset_why)
895
throw TProtocolException(TProtocolException::INVALID_DATA);
896
return xfer;
897
}
898
899
uint32_t AuthorizationException::write(::apache::thrift::protocol::TProtocol* oprot) const {
900
uint32_t xfer = 0;
901
xfer += oprot->writeStructBegin("AuthorizationException");
902
903
xfer += oprot->writeFieldBegin("why", ::apache::thrift::protocol::T_STRING, 1);
904
xfer += oprot->writeString(this->why);
905
xfer += oprot->writeFieldEnd();
906
907
xfer += oprot->writeFieldStop();
908
xfer += oprot->writeStructEnd();
909
return xfer;
910
}
911
912
void swap(AuthorizationException &a, AuthorizationException &b) {
913
using ::std::swap;
914
swap(a.why, b.why);
915
}
916
917
const char* SchemaDisagreementException::ascii_fingerprint = "99914B932BD37A50B983C5E7C90AE93B";
918
const uint8_t SchemaDisagreementException::binary_fingerprint[16] = {0x99,0x91,0x4B,0x93,0x2B,0xD3,0x7A,0x50,0xB9,0x83,0xC5,0xE7,0xC9,0x0A,0xE9,0x3B};
919
920
uint32_t SchemaDisagreementException::read(::apache::thrift::protocol::TProtocol* iprot) {
921
922
uint32_t xfer = 0;
923
std::string fname;
924
::apache::thrift::protocol::TType ftype;
925
int16_t fid;
926
927
xfer += iprot->readStructBegin(fname);
928
929
using ::apache::thrift::protocol::TProtocolException;
930
931
932
while (true)
933
{
934
xfer += iprot->readFieldBegin(fname, ftype, fid);
935
if (ftype == ::apache::thrift::protocol::T_STOP) {
936
break;
937
}
938
switch (fid)
939
{
940
default:
941
xfer += iprot->skip(ftype);
942
break;
943
}
944
xfer += iprot->readFieldEnd();
945
}
946
947
xfer += iprot->readStructEnd();
948
949
return xfer;
950
}
951
952
uint32_t SchemaDisagreementException::write(::apache::thrift::protocol::TProtocol* oprot) const {
953
uint32_t xfer = 0;
954
xfer += oprot->writeStructBegin("SchemaDisagreementException");
955
956
xfer += oprot->writeFieldStop();
957
xfer += oprot->writeStructEnd();
958
return xfer;
959
}
960
961
void swap(SchemaDisagreementException &a, SchemaDisagreementException &b) {
962
using ::std::swap;
963
(void) a;
964
(void) b;
965
}
966
967
const char* ColumnParent::ascii_fingerprint = "0A13AE61181713A4100DFFB3EC293822";
968
const uint8_t ColumnParent::binary_fingerprint[16] = {0x0A,0x13,0xAE,0x61,0x18,0x17,0x13,0xA4,0x10,0x0D,0xFF,0xB3,0xEC,0x29,0x38,0x22};
969
970
uint32_t ColumnParent::read(::apache::thrift::protocol::TProtocol* iprot) {
971
972
uint32_t xfer = 0;
973
std::string fname;
974
::apache::thrift::protocol::TType ftype;
975
int16_t fid;
976
977
xfer += iprot->readStructBegin(fname);
978
979
using ::apache::thrift::protocol::TProtocolException;
980
981
bool isset_column_family = false;
982
983
while (true)
984
{
985
xfer += iprot->readFieldBegin(fname, ftype, fid);
986
if (ftype == ::apache::thrift::protocol::T_STOP) {
987
break;
988
}
989
switch (fid)
990
{
991
case 3:
992
if (ftype == ::apache::thrift::protocol::T_STRING) {
993
xfer += iprot->readString(this->column_family);
994
isset_column_family = true;
995
} else {
996
xfer += iprot->skip(ftype);
997
}
998
break;
999
case 4:
1000
if (ftype == ::apache::thrift::protocol::T_STRING) {
1001
xfer += iprot->readBinary(this->super_column);
1002
this->__isset.super_column = true;
1003
} else {
1004
xfer += iprot->skip(ftype);
1005
}
1006
break;
1007
default:
1008
xfer += iprot->skip(ftype);
1009
break;
1010
}
1011
xfer += iprot->readFieldEnd();
1012
}
1013
1014
xfer += iprot->readStructEnd();
1015
1016
if (!isset_column_family)
1017
throw TProtocolException(TProtocolException::INVALID_DATA);
1018
return xfer;
1019
}
1020
1021
uint32_t ColumnParent::write(::apache::thrift::protocol::TProtocol* oprot) const {
1022
uint32_t xfer = 0;
1023
xfer += oprot->writeStructBegin("ColumnParent");
1024
1025
xfer += oprot->writeFieldBegin("column_family", ::apache::thrift::protocol::T_STRING, 3);
1026
xfer += oprot->writeString(this->column_family);
1027
xfer += oprot->writeFieldEnd();
1028
1029
if (this->__isset.super_column) {
1030
xfer += oprot->writeFieldBegin("super_column", ::apache::thrift::protocol::T_STRING, 4);
1031
xfer += oprot->writeBinary(this->super_column);
1032
xfer += oprot->writeFieldEnd();
1033
}
1034
xfer += oprot->writeFieldStop();
1035
xfer += oprot->writeStructEnd();
1036
return xfer;
1037
}
1038
1039
void swap(ColumnParent &a, ColumnParent &b) {
1040
using ::std::swap;
1041
swap(a.column_family, b.column_family);
1042
swap(a.super_column, b.super_column);
1043
swap(a.__isset, b.__isset);
1044
}
1045
1046
const char* ColumnPath::ascii_fingerprint = "606212895BCF63C757913CF35AEB3462";
1047
const uint8_t ColumnPath::binary_fingerprint[16] = {0x60,0x62,0x12,0x89,0x5B,0xCF,0x63,0xC7,0x57,0x91,0x3C,0xF3,0x5A,0xEB,0x34,0x62};
1048
1049
uint32_t ColumnPath::read(::apache::thrift::protocol::TProtocol* iprot) {
1050
1051
uint32_t xfer = 0;
1052
std::string fname;
1053
::apache::thrift::protocol::TType ftype;
1054
int16_t fid;
1055
1056
xfer += iprot->readStructBegin(fname);
1057
1058
using ::apache::thrift::protocol::TProtocolException;
1059
1060
bool isset_column_family = false;
1061
1062
while (true)
1063
{
1064
xfer += iprot->readFieldBegin(fname, ftype, fid);
1065
if (ftype == ::apache::thrift::protocol::T_STOP) {
1066
break;
1067
}
1068
switch (fid)
1069
{
1070
case 3:
1071
if (ftype == ::apache::thrift::protocol::T_STRING) {
1072
xfer += iprot->readString(this->column_family);
1073
isset_column_family = true;
1074
} else {
1075
xfer += iprot->skip(ftype);
1076
}
1077
break;
1078
case 4:
1079
if (ftype == ::apache::thrift::protocol::T_STRING) {
1080
xfer += iprot->readBinary(this->super_column);
1081
this->__isset.super_column = true;
1082
} else {
1083
xfer += iprot->skip(ftype);
1084
}
1085
break;
1086
case 5:
1087
if (ftype == ::apache::thrift::protocol::T_STRING) {
1088
xfer += iprot->readBinary(this->column);
1089
this->__isset.column = true;
1090
} else {
1091
xfer += iprot->skip(ftype);
1092
}
1093
break;
1094
default:
1095
xfer += iprot->skip(ftype);
1096
break;
1097
}
1098
xfer += iprot->readFieldEnd();
1099
}
1100
1101
xfer += iprot->readStructEnd();
1102
1103
if (!isset_column_family)
1104
throw TProtocolException(TProtocolException::INVALID_DATA);
1105
return xfer;
1106
}
1107
1108
uint32_t ColumnPath::write(::apache::thrift::protocol::TProtocol* oprot) const {
1109
uint32_t xfer = 0;
1110
xfer += oprot->writeStructBegin("ColumnPath");
1111
1112
xfer += oprot->writeFieldBegin("column_family", ::apache::thrift::protocol::T_STRING, 3);
1113
xfer += oprot->writeString(this->column_family);
1114
xfer += oprot->writeFieldEnd();
1115
1116
if (this->__isset.super_column) {
1117
xfer += oprot->writeFieldBegin("super_column", ::apache::thrift::protocol::T_STRING, 4);
1118
xfer += oprot->writeBinary(this->super_column);
1119
xfer += oprot->writeFieldEnd();
1120
}
1121
if (this->__isset.column) {
1122
xfer += oprot->writeFieldBegin("column", ::apache::thrift::protocol::T_STRING, 5);
1123
xfer += oprot->writeBinary(this->column);
1124
xfer += oprot->writeFieldEnd();
1125
}
1126
xfer += oprot->writeFieldStop();
1127
xfer += oprot->writeStructEnd();
1128
return xfer;
1129
}
1130
1131
void swap(ColumnPath &a, ColumnPath &b) {
1132
using ::std::swap;
1133
swap(a.column_family, b.column_family);
1134
swap(a.super_column, b.super_column);
1135
swap(a.column, b.column);
1136
swap(a.__isset, b.__isset);
1137
}
1138
1139
const char* SliceRange::ascii_fingerprint = "184D24C9A0B8D4415E234DB649CAE740";
1140
const uint8_t SliceRange::binary_fingerprint[16] = {0x18,0x4D,0x24,0xC9,0xA0,0xB8,0xD4,0x41,0x5E,0x23,0x4D,0xB6,0x49,0xCA,0xE7,0x40};
1141
1142
uint32_t SliceRange::read(::apache::thrift::protocol::TProtocol* iprot) {
1143
1144
uint32_t xfer = 0;
1145
std::string fname;
1146
::apache::thrift::protocol::TType ftype;
1147
int16_t fid;
1148
1149
xfer += iprot->readStructBegin(fname);
1150
1151
using ::apache::thrift::protocol::TProtocolException;
1152
1153
bool isset_start = false;
1154
bool isset_finish = false;
1155
bool isset_reversed = false;
1156
bool isset_count = false;
1157
1158
while (true)
1159
{
1160
xfer += iprot->readFieldBegin(fname, ftype, fid);
1161
if (ftype == ::apache::thrift::protocol::T_STOP) {
1162
break;
1163
}
1164
switch (fid)
1165
{
1166
case 1:
1167
if (ftype == ::apache::thrift::protocol::T_STRING) {
1168
xfer += iprot->readBinary(this->start);
1169
isset_start = true;
1170
} else {
1171
xfer += iprot->skip(ftype);
1172
}
1173
break;
1174
case 2:
1175
if (ftype == ::apache::thrift::protocol::T_STRING) {
1176
xfer += iprot->readBinary(this->finish);
1177
isset_finish = true;
1178
} else {
1179
xfer += iprot->skip(ftype);
1180
}
1181
break;
1182
case 3:
1183
if (ftype == ::apache::thrift::protocol::T_BOOL) {
1184
xfer += iprot->readBool(this->reversed);
1185
isset_reversed = true;
1186
} else {
1187
xfer += iprot->skip(ftype);
1188
}
1189
break;
1190
case 4:
1191
if (ftype == ::apache::thrift::protocol::T_I32) {
1192
xfer += iprot->readI32(this->count);
1193
isset_count = true;
1194
} else {
1195
xfer += iprot->skip(ftype);
1196
}
1197
break;
1198
default:
1199
xfer += iprot->skip(ftype);
1200
break;
1201
}
1202
xfer += iprot->readFieldEnd();
1203
}
1204
1205
xfer += iprot->readStructEnd();
1206
1207
if (!isset_start)
1208
throw TProtocolException(TProtocolException::INVALID_DATA);
1209
if (!isset_finish)
1210
throw TProtocolException(TProtocolException::INVALID_DATA);
1211
if (!isset_reversed)
1212
throw TProtocolException(TProtocolException::INVALID_DATA);
1213
if (!isset_count)
1214
throw TProtocolException(TProtocolException::INVALID_DATA);
1215
return xfer;
1216
}
1217
1218
uint32_t SliceRange::write(::apache::thrift::protocol::TProtocol* oprot) const {
1219
uint32_t xfer = 0;
1220
xfer += oprot->writeStructBegin("SliceRange");
1221
1222
xfer += oprot->writeFieldBegin("start", ::apache::thrift::protocol::T_STRING, 1);
1223
xfer += oprot->writeBinary(this->start);
1224
xfer += oprot->writeFieldEnd();
1225
1226
xfer += oprot->writeFieldBegin("finish", ::apache::thrift::protocol::T_STRING, 2);
1227
xfer += oprot->writeBinary(this->finish);
1228
xfer += oprot->writeFieldEnd();
1229
1230
xfer += oprot->writeFieldBegin("reversed", ::apache::thrift::protocol::T_BOOL, 3);
1231
xfer += oprot->writeBool(this->reversed);
1232
xfer += oprot->writeFieldEnd();
1233
1234
xfer += oprot->writeFieldBegin("count", ::apache::thrift::protocol::T_I32, 4);
1235
xfer += oprot->writeI32(this->count);
1236
xfer += oprot->writeFieldEnd();
1237
1238
xfer += oprot->writeFieldStop();
1239
xfer += oprot->writeStructEnd();
1240
return xfer;
1241
}
1242
1243
void swap(SliceRange &a, SliceRange &b) {
1244
using ::std::swap;
1245
swap(a.start, b.start);
1246
swap(a.finish, b.finish);
1247
swap(a.reversed, b.reversed);
1248
swap(a.count, b.count);
1249
}
1250
1251
const char* SlicePredicate::ascii_fingerprint = "F59D1D81C17DFFAF09988BF1C9CE5E27";
1252
const uint8_t SlicePredicate::binary_fingerprint[16] = {0xF5,0x9D,0x1D,0x81,0xC1,0x7D,0xFF,0xAF,0x09,0x98,0x8B,0xF1,0xC9,0xCE,0x5E,0x27};
1253
1254
uint32_t SlicePredicate::read(::apache::thrift::protocol::TProtocol* iprot) {
1255
1256
uint32_t xfer = 0;
1257
std::string fname;
1258
::apache::thrift::protocol::TType ftype;
1259
int16_t fid;
1260
1261
xfer += iprot->readStructBegin(fname);
1262
1263
using ::apache::thrift::protocol::TProtocolException;
1264
1265
1266
while (true)
1267
{
1268
xfer += iprot->readFieldBegin(fname, ftype, fid);
1269
if (ftype == ::apache::thrift::protocol::T_STOP) {
1270
break;
1271
}
1272
switch (fid)
1273
{
1274
case 1:
1275
if (ftype == ::apache::thrift::protocol::T_LIST) {
1276
{
1277
this->column_names.clear();
1278
uint32_t _size12;
1279
::apache::thrift::protocol::TType _etype15;
1280
xfer += iprot->readListBegin(_etype15, _size12);
1281
this->column_names.resize(_size12);
1282
uint32_t _i16;
1283
for (_i16 = 0; _i16 < _size12; ++_i16)
1284
{
1285
xfer += iprot->readBinary(this->column_names[_i16]);
1286
}
1287
xfer += iprot->readListEnd();
1288
}
1289
this->__isset.column_names = true;
1290
} else {
1291
xfer += iprot->skip(ftype);
1292
}
1293
break;
1294
case 2:
1295
if (ftype == ::apache::thrift::protocol::T_STRUCT) {
1296
xfer += this->slice_range.read(iprot);
1297
this->__isset.slice_range = true;
1298
} else {
1299
xfer += iprot->skip(ftype);
1300
}
1301
break;
1302
default:
1303
xfer += iprot->skip(ftype);
1304
break;
1305
}
1306
xfer += iprot->readFieldEnd();
1307
}
1308
1309
xfer += iprot->readStructEnd();
1310
1311
return xfer;
1312
}
1313
1314
uint32_t SlicePredicate::write(::apache::thrift::protocol::TProtocol* oprot) const {
1315
uint32_t xfer = 0;
1316
xfer += oprot->writeStructBegin("SlicePredicate");
1317
1318
if (this->__isset.column_names) {
1319
xfer += oprot->writeFieldBegin("column_names", ::apache::thrift::protocol::T_LIST, 1);
1320
{
1321
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->column_names.size()));
1322
std::vector<std::string> ::const_iterator _iter17;
1323
for (_iter17 = this->column_names.begin(); _iter17 != this->column_names.end(); ++_iter17)
1324
{
1325
xfer += oprot->writeBinary((*_iter17));
1326
}
1327
xfer += oprot->writeListEnd();
1328
}
1329
xfer += oprot->writeFieldEnd();
1330
}
1331
if (this->__isset.slice_range) {
1332
xfer += oprot->writeFieldBegin("slice_range", ::apache::thrift::protocol::T_STRUCT, 2);
1333
xfer += this->slice_range.write(oprot);
1334
xfer += oprot->writeFieldEnd();
1335
}
1336
xfer += oprot->writeFieldStop();
1337
xfer += oprot->writeStructEnd();
1338
return xfer;
1339
}
1340
1341
void swap(SlicePredicate &a, SlicePredicate &b) {
1342
using ::std::swap;
1343
swap(a.column_names, b.column_names);
1344
swap(a.slice_range, b.slice_range);
1345
swap(a.__isset, b.__isset);
1346
}
1347
1348
const char* IndexExpression::ascii_fingerprint = "D9F4CFE2F293A8B1052FD3031DD2C847";
1349
const uint8_t IndexExpression::binary_fingerprint[16] = {0xD9,0xF4,0xCF,0xE2,0xF2,0x93,0xA8,0xB1,0x05,0x2F,0xD3,0x03,0x1D,0xD2,0xC8,0x47};
1350
1351
uint32_t IndexExpression::read(::apache::thrift::protocol::TProtocol* iprot) {
1352
1353
uint32_t xfer = 0;
1354
std::string fname;
1355
::apache::thrift::protocol::TType ftype;
1356
int16_t fid;
1357
1358
xfer += iprot->readStructBegin(fname);
1359
1360
using ::apache::thrift::protocol::TProtocolException;
1361
1362
bool isset_column_name = false;
1363
bool isset_op = false;
1364
bool isset_value = false;
1365
1366
while (true)
1367
{
1368
xfer += iprot->readFieldBegin(fname, ftype, fid);
1369
if (ftype == ::apache::thrift::protocol::T_STOP) {
1370
break;
1371
}
1372
switch (fid)
1373
{
1374
case 1:
1375
if (ftype == ::apache::thrift::protocol::T_STRING) {
1376
xfer += iprot->readBinary(this->column_name);
1377
isset_column_name = true;
1378
} else {
1379
xfer += iprot->skip(ftype);
1380
}
1381
break;
1382
case 2:
1383
if (ftype == ::apache::thrift::protocol::T_I32) {
1384
int32_t ecast18;
1385
xfer += iprot->readI32(ecast18);
1386
this->op = (IndexOperator::type)ecast18;
1387
isset_op = true;
1388
} else {
1389
xfer += iprot->skip(ftype);
1390
}
1391
break;
1392
case 3:
1393
if (ftype == ::apache::thrift::protocol::T_STRING) {
1394
xfer += iprot->readBinary(this->value);
1395
isset_value = true;
1396
} else {
1397
xfer += iprot->skip(ftype);
1398
}
1399
break;
1400
default:
1401
xfer += iprot->skip(ftype);
1402
break;
1403
}
1404
xfer += iprot->readFieldEnd();
1405
}
1406
1407
xfer += iprot->readStructEnd();
1408
1409
if (!isset_column_name)
1410
throw TProtocolException(TProtocolException::INVALID_DATA);
1411
if (!isset_op)
1412
throw TProtocolException(TProtocolException::INVALID_DATA);
1413
if (!isset_value)
1414
throw TProtocolException(TProtocolException::INVALID_DATA);
1415
return xfer;
1416
}
1417
1418
uint32_t IndexExpression::write(::apache::thrift::protocol::TProtocol* oprot) const {
1419
uint32_t xfer = 0;
1420
xfer += oprot->writeStructBegin("IndexExpression");
1421
1422
xfer += oprot->writeFieldBegin("column_name", ::apache::thrift::protocol::T_STRING, 1);
1423
xfer += oprot->writeBinary(this->column_name);
1424
xfer += oprot->writeFieldEnd();
1425
1426
xfer += oprot->writeFieldBegin("op", ::apache::thrift::protocol::T_I32, 2);
1427
xfer += oprot->writeI32((int32_t)this->op);
1428
xfer += oprot->writeFieldEnd();
1429
1430
xfer += oprot->writeFieldBegin("value", ::apache::thrift::protocol::T_STRING, 3);
1431
xfer += oprot->writeBinary(this->value);
1432
xfer += oprot->writeFieldEnd();
1433
1434
xfer += oprot->writeFieldStop();
1435
xfer += oprot->writeStructEnd();
1436
return xfer;
1437
}
1438
1439
void swap(IndexExpression &a, IndexExpression &b) {
1440
using ::std::swap;
1441
swap(a.column_name, b.column_name);
1442
swap(a.op, b.op);
1443
swap(a.value, b.value);
1444
}
1445
1446
const char* IndexClause::ascii_fingerprint = "9B551B9AB86120B0EEA9005C77FD3C1F";
1447
const uint8_t IndexClause::binary_fingerprint[16] = {0x9B,0x55,0x1B,0x9A,0xB8,0x61,0x20,0xB0,0xEE,0xA9,0x00,0x5C,0x77,0xFD,0x3C,0x1F};
1448
1449
uint32_t IndexClause::read(::apache::thrift::protocol::TProtocol* iprot) {
1450
1451
uint32_t xfer = 0;
1452
std::string fname;
1453
::apache::thrift::protocol::TType ftype;
1454
int16_t fid;
1455
1456
xfer += iprot->readStructBegin(fname);
1457
1458
using ::apache::thrift::protocol::TProtocolException;
1459
1460
bool isset_expressions = false;
1461
bool isset_start_key = false;
1462
bool isset_count = false;
1463
1464
while (true)
1465
{
1466
xfer += iprot->readFieldBegin(fname, ftype, fid);
1467
if (ftype == ::apache::thrift::protocol::T_STOP) {
1468
break;
1469
}
1470
switch (fid)
1471
{
1472
case 1:
1473
if (ftype == ::apache::thrift::protocol::T_LIST) {
1474
{
1475
this->expressions.clear();
1476
uint32_t _size19;
1477
::apache::thrift::protocol::TType _etype22;
1478
xfer += iprot->readListBegin(_etype22, _size19);
1479
this->expressions.resize(_size19);
1480
uint32_t _i23;
1481
for (_i23 = 0; _i23 < _size19; ++_i23)
1482
{
1483
xfer += this->expressions[_i23].read(iprot);
1484
}
1485
xfer += iprot->readListEnd();
1486
}
1487
isset_expressions = true;
1488
} else {
1489
xfer += iprot->skip(ftype);
1490
}
1491
break;
1492
case 2:
1493
if (ftype == ::apache::thrift::protocol::T_STRING) {
1494
xfer += iprot->readBinary(this->start_key);
1495
isset_start_key = true;
1496
} else {
1497
xfer += iprot->skip(ftype);
1498
}
1499
break;
1500
case 3:
1501
if (ftype == ::apache::thrift::protocol::T_I32) {
1502
xfer += iprot->readI32(this->count);
1503
isset_count = true;
1504
} else {
1505
xfer += iprot->skip(ftype);
1506
}
1507
break;
1508
default:
1509
xfer += iprot->skip(ftype);
1510
break;
1511
}
1512
xfer += iprot->readFieldEnd();
1513
}
1514
1515
xfer += iprot->readStructEnd();
1516
1517
if (!isset_expressions)
1518
throw TProtocolException(TProtocolException::INVALID_DATA);
1519
if (!isset_start_key)
1520
throw TProtocolException(TProtocolException::INVALID_DATA);
1521
if (!isset_count)
1522
throw TProtocolException(TProtocolException::INVALID_DATA);
1523
return xfer;
1524
}
1525
1526
uint32_t IndexClause::write(::apache::thrift::protocol::TProtocol* oprot) const {
1527
uint32_t xfer = 0;
1528
xfer += oprot->writeStructBegin("IndexClause");
1529
1530
xfer += oprot->writeFieldBegin("expressions", ::apache::thrift::protocol::T_LIST, 1);
1531
{
1532
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->expressions.size()));
1533
std::vector<IndexExpression> ::const_iterator _iter24;
1534
for (_iter24 = this->expressions.begin(); _iter24 != this->expressions.end(); ++_iter24)
1535
{
1536
xfer += (*_iter24).write(oprot);
1537
}
1538
xfer += oprot->writeListEnd();
1539
}
1540
xfer += oprot->writeFieldEnd();
1541
1542
xfer += oprot->writeFieldBegin("start_key", ::apache::thrift::protocol::T_STRING, 2);
1543
xfer += oprot->writeBinary(this->start_key);
1544
xfer += oprot->writeFieldEnd();
1545
1546
xfer += oprot->writeFieldBegin("count", ::apache::thrift::protocol::T_I32, 3);
1547
xfer += oprot->writeI32(this->count);
1548
xfer += oprot->writeFieldEnd();
1549
1550
xfer += oprot->writeFieldStop();
1551
xfer += oprot->writeStructEnd();
1552
return xfer;
1553
}
1554
1555
void swap(IndexClause &a, IndexClause &b) {
1556
using ::std::swap;
1557
swap(a.expressions, b.expressions);
1558
swap(a.start_key, b.start_key);
1559
swap(a.count, b.count);
1560
}
1561
1562
const char* KeyRange::ascii_fingerprint = "A6EC82FA0980B91C7C8EB013C61CA1B0";
1563
const uint8_t KeyRange::binary_fingerprint[16] = {0xA6,0xEC,0x82,0xFA,0x09,0x80,0xB9,0x1C,0x7C,0x8E,0xB0,0x13,0xC6,0x1C,0xA1,0xB0};
1564
1565
uint32_t KeyRange::read(::apache::thrift::protocol::TProtocol* iprot) {
1566
1567
uint32_t xfer = 0;
1568
std::string fname;
1569
::apache::thrift::protocol::TType ftype;
1570
int16_t fid;
1571
1572
xfer += iprot->readStructBegin(fname);
1573
1574
using ::apache::thrift::protocol::TProtocolException;
1575
1576
bool isset_count = false;
1577
1578
while (true)
1579
{
1580
xfer += iprot->readFieldBegin(fname, ftype, fid);
1581
if (ftype == ::apache::thrift::protocol::T_STOP) {
1582
break;
1583
}
1584
switch (fid)
1585
{
1586
case 1:
1587
if (ftype == ::apache::thrift::protocol::T_STRING) {
1588
xfer += iprot->readBinary(this->start_key);
1589
this->__isset.start_key = true;
1590
} else {
1591
xfer += iprot->skip(ftype);
1592
}
1593
break;
1594
case 2:
1595
if (ftype == ::apache::thrift::protocol::T_STRING) {
1596
xfer += iprot->readBinary(this->end_key);
1597
this->__isset.end_key = true;
1598
} else {
1599
xfer += iprot->skip(ftype);
1600
}
1601
break;
1602
case 3:
1603
if (ftype == ::apache::thrift::protocol::T_STRING) {
1604
xfer += iprot->readString(this->start_token);
1605
this->__isset.start_token = true;
1606
} else {
1607
xfer += iprot->skip(ftype);
1608
}
1609
break;
1610
case 4:
1611
if (ftype == ::apache::thrift::protocol::T_STRING) {
1612
xfer += iprot->readString(this->end_token);
1613
this->__isset.end_token = true;
1614
} else {
1615
xfer += iprot->skip(ftype);
1616
}
1617
break;
1618
case 6:
1619
if (ftype == ::apache::thrift::protocol::T_LIST) {
1620
{
1621
this->row_filter.clear();
1622
uint32_t _size25;
1623
::apache::thrift::protocol::TType _etype28;
1624
xfer += iprot->readListBegin(_etype28, _size25);
1625
this->row_filter.resize(_size25);
1626
uint32_t _i29;
1627
for (_i29 = 0; _i29 < _size25; ++_i29)
1628
{
1629
xfer += this->row_filter[_i29].read(iprot);
1630
}
1631
xfer += iprot->readListEnd();
1632
}
1633
this->__isset.row_filter = true;
1634
} else {
1635
xfer += iprot->skip(ftype);
1636
}
1637
break;
1638
case 5:
1639
if (ftype == ::apache::thrift::protocol::T_I32) {
1640
xfer += iprot->readI32(this->count);
1641
isset_count = true;
1642
} else {
1643
xfer += iprot->skip(ftype);
1644
}
1645
break;
1646
default:
1647
xfer += iprot->skip(ftype);
1648
break;
1649
}
1650
xfer += iprot->readFieldEnd();
1651
}
1652
1653
xfer += iprot->readStructEnd();
1654
1655
if (!isset_count)
1656
throw TProtocolException(TProtocolException::INVALID_DATA);
1657
return xfer;
1658
}
1659
1660
uint32_t KeyRange::write(::apache::thrift::protocol::TProtocol* oprot) const {
1661
uint32_t xfer = 0;
1662
xfer += oprot->writeStructBegin("KeyRange");
1663
1664
if (this->__isset.start_key) {
1665
xfer += oprot->writeFieldBegin("start_key", ::apache::thrift::protocol::T_STRING, 1);
1666
xfer += oprot->writeBinary(this->start_key);
1667
xfer += oprot->writeFieldEnd();
1668
}
1669
if (this->__isset.end_key) {
1670
xfer += oprot->writeFieldBegin("end_key", ::apache::thrift::protocol::T_STRING, 2);
1671
xfer += oprot->writeBinary(this->end_key);
1672
xfer += oprot->writeFieldEnd();
1673
}
1674
if (this->__isset.start_token) {
1675
xfer += oprot->writeFieldBegin("start_token", ::apache::thrift::protocol::T_STRING, 3);
1676
xfer += oprot->writeString(this->start_token);
1677
xfer += oprot->writeFieldEnd();
1678
}
1679
if (this->__isset.end_token) {
1680
xfer += oprot->writeFieldBegin("end_token", ::apache::thrift::protocol::T_STRING, 4);
1681
xfer += oprot->writeString(this->end_token);
1682
xfer += oprot->writeFieldEnd();
1683
}
1684
xfer += oprot->writeFieldBegin("count", ::apache::thrift::protocol::T_I32, 5);
1685
xfer += oprot->writeI32(this->count);
1686
xfer += oprot->writeFieldEnd();
1687
1688
if (this->__isset.row_filter) {
1689
xfer += oprot->writeFieldBegin("row_filter", ::apache::thrift::protocol::T_LIST, 6);
1690
{
1691
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->row_filter.size()));
1692
std::vector<IndexExpression> ::const_iterator _iter30;
1693
for (_iter30 = this->row_filter.begin(); _iter30 != this->row_filter.end(); ++_iter30)
1694
{
1695
xfer += (*_iter30).write(oprot);
1696
}
1697
xfer += oprot->writeListEnd();
1698
}
1699
xfer += oprot->writeFieldEnd();
1700
}
1701
xfer += oprot->writeFieldStop();
1702
xfer += oprot->writeStructEnd();
1703
return xfer;
1704
}
1705
1706
void swap(KeyRange &a, KeyRange &b) {
1707
using ::std::swap;
1708
swap(a.start_key, b.start_key);
1709
swap(a.end_key, b.end_key);
1710
swap(a.start_token, b.start_token);
1711
swap(a.end_token, b.end_token);
1712
swap(a.row_filter, b.row_filter);
1713
swap(a.count, b.count);
1714
swap(a.__isset, b.__isset);
1715
}
1716
1717
const char* KeySlice::ascii_fingerprint = "D1568675B0C135C909E3169B72A4DA3D";
1718
const uint8_t KeySlice::binary_fingerprint[16] = {0xD1,0x56,0x86,0x75,0xB0,0xC1,0x35,0xC9,0x09,0xE3,0x16,0x9B,0x72,0xA4,0xDA,0x3D};
1719
1720
uint32_t KeySlice::read(::apache::thrift::protocol::TProtocol* iprot) {
1721
1722
uint32_t xfer = 0;
1723
std::string fname;
1724
::apache::thrift::protocol::TType ftype;
1725
int16_t fid;
1726
1727
xfer += iprot->readStructBegin(fname);
1728
1729
using ::apache::thrift::protocol::TProtocolException;
1730
1731
bool isset_key = false;
1732
bool isset_columns = false;
1733
1734
while (true)
1735
{
1736
xfer += iprot->readFieldBegin(fname, ftype, fid);
1737
if (ftype == ::apache::thrift::protocol::T_STOP) {
1738
break;
1739
}
1740
switch (fid)
1741
{
1742
case 1:
1743
if (ftype == ::apache::thrift::protocol::T_STRING) {
1744
xfer += iprot->readBinary(this->key);
1745
isset_key = true;
1746
} else {
1747
xfer += iprot->skip(ftype);
1748
}
1749
break;
1750
case 2:
1751
if (ftype == ::apache::thrift::protocol::T_LIST) {
1752
{
1753
this->columns.clear();
1754
uint32_t _size31;
1755
::apache::thrift::protocol::TType _etype34;
1756
xfer += iprot->readListBegin(_etype34, _size31);
1757
this->columns.resize(_size31);
1758
uint32_t _i35;
1759
for (_i35 = 0; _i35 < _size31; ++_i35)
1760
{
1761
xfer += this->columns[_i35].read(iprot);
1762
}
1763
xfer += iprot->readListEnd();
1764
}
1765
isset_columns = true;
1766
} else {
1767
xfer += iprot->skip(ftype);
1768
}
1769
break;
1770
default:
1771
xfer += iprot->skip(ftype);
1772
break;
1773
}
1774
xfer += iprot->readFieldEnd();
1775
}
1776
1777
xfer += iprot->readStructEnd();
1778
1779
if (!isset_key)
1780
throw TProtocolException(TProtocolException::INVALID_DATA);
1781
if (!isset_columns)
1782
throw TProtocolException(TProtocolException::INVALID_DATA);
1783
return xfer;
1784
}
1785
1786
uint32_t KeySlice::write(::apache::thrift::protocol::TProtocol* oprot) const {
1787
uint32_t xfer = 0;
1788
xfer += oprot->writeStructBegin("KeySlice");
1789
1790
xfer += oprot->writeFieldBegin("key", ::apache::thrift::protocol::T_STRING, 1);
1791
xfer += oprot->writeBinary(this->key);
1792
xfer += oprot->writeFieldEnd();
1793
1794
xfer += oprot->writeFieldBegin("columns", ::apache::thrift::protocol::T_LIST, 2);
1795
{
1796
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->columns.size()));
1797
std::vector<ColumnOrSuperColumn> ::const_iterator _iter36;
1798
for (_iter36 = this->columns.begin(); _iter36 != this->columns.end(); ++_iter36)
1799
{
1800
xfer += (*_iter36).write(oprot);
1801
}
1802
xfer += oprot->writeListEnd();
1803
}
1804
xfer += oprot->writeFieldEnd();
1805
1806
xfer += oprot->writeFieldStop();
1807
xfer += oprot->writeStructEnd();
1808
return xfer;
1809
}
1810
1811
void swap(KeySlice &a, KeySlice &b) {
1812
using ::std::swap;
1813
swap(a.key, b.key);
1814
swap(a.columns, b.columns);
1815
}
1816
1817
const char* KeyCount::ascii_fingerprint = "EEBC915CE44901401D881E6091423036";
1818
const uint8_t KeyCount::binary_fingerprint[16] = {0xEE,0xBC,0x91,0x5C,0xE4,0x49,0x01,0x40,0x1D,0x88,0x1E,0x60,0x91,0x42,0x30,0x36};
1819
1820
uint32_t KeyCount::read(::apache::thrift::protocol::TProtocol* iprot) {
1821
1822
uint32_t xfer = 0;
1823
std::string fname;
1824
::apache::thrift::protocol::TType ftype;
1825
int16_t fid;
1826
1827
xfer += iprot->readStructBegin(fname);
1828
1829
using ::apache::thrift::protocol::TProtocolException;
1830
1831
bool isset_key = false;
1832
bool isset_count = false;
1833
1834
while (true)
1835
{
1836
xfer += iprot->readFieldBegin(fname, ftype, fid);
1837
if (ftype == ::apache::thrift::protocol::T_STOP) {
1838
break;
1839
}
1840
switch (fid)
1841
{
1842
case 1:
1843
if (ftype == ::apache::thrift::protocol::T_STRING) {
1844
xfer += iprot->readBinary(this->key);
1845
isset_key = true;
1846
} else {
1847
xfer += iprot->skip(ftype);
1848
}
1849
break;
1850
case 2:
1851
if (ftype == ::apache::thrift::protocol::T_I32) {
1852
xfer += iprot->readI32(this->count);
1853
isset_count = true;
1854
} else {
1855
xfer += iprot->skip(ftype);
1856
}
1857
break;
1858
default:
1859
xfer += iprot->skip(ftype);
1860
break;
1861
}
1862
xfer += iprot->readFieldEnd();
1863
}
1864
1865
xfer += iprot->readStructEnd();
1866
1867
if (!isset_key)
1868
throw TProtocolException(TProtocolException::INVALID_DATA);
1869
if (!isset_count)
1870
throw TProtocolException(TProtocolException::INVALID_DATA);
1871
return xfer;
1872
}
1873
1874
uint32_t KeyCount::write(::apache::thrift::protocol::TProtocol* oprot) const {
1875
uint32_t xfer = 0;
1876
xfer += oprot->writeStructBegin("KeyCount");
1877
1878
xfer += oprot->writeFieldBegin("key", ::apache::thrift::protocol::T_STRING, 1);
1879
xfer += oprot->writeBinary(this->key);
1880
xfer += oprot->writeFieldEnd();
1881
1882
xfer += oprot->writeFieldBegin("count", ::apache::thrift::protocol::T_I32, 2);
1883
xfer += oprot->writeI32(this->count);
1884
xfer += oprot->writeFieldEnd();
1885
1886
xfer += oprot->writeFieldStop();
1887
xfer += oprot->writeStructEnd();
1888
return xfer;
1889
}
1890
1891
void swap(KeyCount &a, KeyCount &b) {
1892
using ::std::swap;
1893
swap(a.key, b.key);
1894
swap(a.count, b.count);
1895
}
1896
1897
const char* Deletion::ascii_fingerprint = "40F33ECF1C932CA77C2414C4E6C60CBE";
1898
const uint8_t Deletion::binary_fingerprint[16] = {0x40,0xF3,0x3E,0xCF,0x1C,0x93,0x2C,0xA7,0x7C,0x24,0x14,0xC4,0xE6,0xC6,0x0C,0xBE};
1899
1900
uint32_t Deletion::read(::apache::thrift::protocol::TProtocol* iprot) {
1901
1902
uint32_t xfer = 0;
1903
std::string fname;
1904
::apache::thrift::protocol::TType ftype;
1905
int16_t fid;
1906
1907
xfer += iprot->readStructBegin(fname);
1908
1909
using ::apache::thrift::protocol::TProtocolException;
1910
1911
1912
while (true)
1913
{
1914
xfer += iprot->readFieldBegin(fname, ftype, fid);
1915
if (ftype == ::apache::thrift::protocol::T_STOP) {
1916
break;
1917
}
1918
switch (fid)
1919
{
1920
case 1:
1921
if (ftype == ::apache::thrift::protocol::T_I64) {
1922
xfer += iprot->readI64(this->timestamp);
1923
this->__isset.timestamp = true;
1924
} else {
1925
xfer += iprot->skip(ftype);
1926
}
1927
break;
1928
case 2:
1929
if (ftype == ::apache::thrift::protocol::T_STRING) {
1930
xfer += iprot->readBinary(this->super_column);
1931
this->__isset.super_column = true;
1932
} else {
1933
xfer += iprot->skip(ftype);
1934
}
1935
break;
1936
case 3:
1937
if (ftype == ::apache::thrift::protocol::T_STRUCT) {
1938
xfer += this->predicate.read(iprot);
1939
this->__isset.predicate = true;
1940
} else {
1941
xfer += iprot->skip(ftype);
1942
}
1943
break;
1944
default:
1945
xfer += iprot->skip(ftype);
1946
break;
1947
}
1948
xfer += iprot->readFieldEnd();
1949
}
1950
1951
xfer += iprot->readStructEnd();
1952
1953
return xfer;
1954
}
1955
1956
uint32_t Deletion::write(::apache::thrift::protocol::TProtocol* oprot) const {
1957
uint32_t xfer = 0;
1958
xfer += oprot->writeStructBegin("Deletion");
1959
1960
if (this->__isset.timestamp) {
1961
xfer += oprot->writeFieldBegin("timestamp", ::apache::thrift::protocol::T_I64, 1);
1962
xfer += oprot->writeI64(this->timestamp);
1963
xfer += oprot->writeFieldEnd();
1964
}
1965
if (this->__isset.super_column) {
1966
xfer += oprot->writeFieldBegin("super_column", ::apache::thrift::protocol::T_STRING, 2);
1967
xfer += oprot->writeBinary(this->super_column);
1968
xfer += oprot->writeFieldEnd();
1969
}
1970
if (this->__isset.predicate) {
1971
xfer += oprot->writeFieldBegin("predicate", ::apache::thrift::protocol::T_STRUCT, 3);
1972
xfer += this->predicate.write(oprot);
1973
xfer += oprot->writeFieldEnd();
1974
}
1975
xfer += oprot->writeFieldStop();
1976
xfer += oprot->writeStructEnd();
1977
return xfer;
1978
}
1979
1980
void swap(Deletion &a, Deletion &b) {
1981
using ::std::swap;
1982
swap(a.timestamp, b.timestamp);
1983
swap(a.super_column, b.super_column);
1984
swap(a.predicate, b.predicate);
1985
swap(a.__isset, b.__isset);
1986
}
1987
1988
const char* Mutation::ascii_fingerprint = "E8B65DF3979C6868F80DF81F8E769E63";
1989
const uint8_t Mutation::binary_fingerprint[16] = {0xE8,0xB6,0x5D,0xF3,0x97,0x9C,0x68,0x68,0xF8,0x0D,0xF8,0x1F,0x8E,0x76,0x9E,0x63};
1990
1991
uint32_t Mutation::read(::apache::thrift::protocol::TProtocol* iprot) {
1992
1993
uint32_t xfer = 0;
1994
std::string fname;
1995
::apache::thrift::protocol::TType ftype;
1996
int16_t fid;
1997
1998
xfer += iprot->readStructBegin(fname);
1999
2000
using ::apache::thrift::protocol::TProtocolException;
2001
2002
2003
while (true)
2004
{
2005
xfer += iprot->readFieldBegin(fname, ftype, fid);
2006
if (ftype == ::apache::thrift::protocol::T_STOP) {
2007
break;
2008
}
2009
switch (fid)
2010
{
2011
case 1:
2012
if (ftype == ::apache::thrift::protocol::T_STRUCT) {
2013
xfer += this->column_or_supercolumn.read(iprot);
2014
this->__isset.column_or_supercolumn = true;
2015
} else {
2016
xfer += iprot->skip(ftype);
2017
}
2018
break;
2019
case 2:
2020
if (ftype == ::apache::thrift::protocol::T_STRUCT) {
2021
xfer += this->deletion.read(iprot);
2022
this->__isset.deletion = true;
2023
} else {
2024
xfer += iprot->skip(ftype);
2025
}
2026
break;
2027
default:
2028
xfer += iprot->skip(ftype);
2029
break;
2030
}
2031
xfer += iprot->readFieldEnd();
2032
}
2033
2034
xfer += iprot->readStructEnd();
2035
2036
return xfer;
2037
}
2038
2039
uint32_t Mutation::write(::apache::thrift::protocol::TProtocol* oprot) const {
2040
uint32_t xfer = 0;
2041
xfer += oprot->writeStructBegin("Mutation");
2042
2043
if (this->__isset.column_or_supercolumn) {
2044
xfer += oprot->writeFieldBegin("column_or_supercolumn", ::apache::thrift::protocol::T_STRUCT, 1);
2045
xfer += this->column_or_supercolumn.write(oprot);
2046
xfer += oprot->writeFieldEnd();
2047
}
2048
if (this->__isset.deletion) {
2049
xfer += oprot->writeFieldBegin("deletion", ::apache::thrift::protocol::T_STRUCT, 2);
2050
xfer += this->deletion.write(oprot);
2051
xfer += oprot->writeFieldEnd();
2052
}
2053
xfer += oprot->writeFieldStop();
2054
xfer += oprot->writeStructEnd();
2055
return xfer;
2056
}
2057
2058
void swap(Mutation &a, Mutation &b) {
2059
using ::std::swap;
2060
swap(a.column_or_supercolumn, b.column_or_supercolumn);
2061
swap(a.deletion, b.deletion);
2062
swap(a.__isset, b.__isset);
2063
}
2064
2065
const char* EndpointDetails::ascii_fingerprint = "F4A50F0EC638C7F66026F9B6678FD89B";
2066
const uint8_t EndpointDetails::binary_fingerprint[16] = {0xF4,0xA5,0x0F,0x0E,0xC6,0x38,0xC7,0xF6,0x60,0x26,0xF9,0xB6,0x67,0x8F,0xD8,0x9B};
2067
2068
uint32_t EndpointDetails::read(::apache::thrift::protocol::TProtocol* iprot) {
2069
2070
uint32_t xfer = 0;
2071
std::string fname;
2072
::apache::thrift::protocol::TType ftype;
2073
int16_t fid;
2074
2075
xfer += iprot->readStructBegin(fname);
2076
2077
using ::apache::thrift::protocol::TProtocolException;
2078
2079
2080
while (true)
2081
{
2082
xfer += iprot->readFieldBegin(fname, ftype, fid);
2083
if (ftype == ::apache::thrift::protocol::T_STOP) {
2084
break;
2085
}
2086
switch (fid)
2087
{
2088
case 1:
2089
if (ftype == ::apache::thrift::protocol::T_STRING) {
2090
xfer += iprot->readString(this->host);
2091
this->__isset.host = true;
2092
} else {
2093
xfer += iprot->skip(ftype);
2094
}
2095
break;
2096
case 2:
2097
if (ftype == ::apache::thrift::protocol::T_STRING) {
2098
xfer += iprot->readString(this->datacenter);
2099
this->__isset.datacenter = true;
2100
} else {
2101
xfer += iprot->skip(ftype);
2102
}
2103
break;
2104
case 3:
2105
if (ftype == ::apache::thrift::protocol::T_STRING) {
2106
xfer += iprot->readString(this->rack);
2107
this->__isset.rack = true;
2108
} else {
2109
xfer += iprot->skip(ftype);
2110
}
2111
break;
2112
default:
2113
xfer += iprot->skip(ftype);
2114
break;
2115
}
2116
xfer += iprot->readFieldEnd();
2117
}
2118
2119
xfer += iprot->readStructEnd();
2120
2121
return xfer;
2122
}
2123
2124
uint32_t EndpointDetails::write(::apache::thrift::protocol::TProtocol* oprot) const {
2125
uint32_t xfer = 0;
2126
xfer += oprot->writeStructBegin("EndpointDetails");
2127
2128
xfer += oprot->writeFieldBegin("host", ::apache::thrift::protocol::T_STRING, 1);
2129
xfer += oprot->writeString(this->host);
2130
xfer += oprot->writeFieldEnd();
2131
2132
xfer += oprot->writeFieldBegin("datacenter", ::apache::thrift::protocol::T_STRING, 2);
2133
xfer += oprot->writeString(this->datacenter);
2134
xfer += oprot->writeFieldEnd();
2135
2136
if (this->__isset.rack) {
2137
xfer += oprot->writeFieldBegin("rack", ::apache::thrift::protocol::T_STRING, 3);
2138
xfer += oprot->writeString(this->rack);
2139
xfer += oprot->writeFieldEnd();
2140
}
2141
xfer += oprot->writeFieldStop();
2142
xfer += oprot->writeStructEnd();
2143
return xfer;
2144
}
2145
2146
void swap(EndpointDetails &a, EndpointDetails &b) {
2147
using ::std::swap;
2148
swap(a.host, b.host);
2149
swap(a.datacenter, b.datacenter);
2150
swap(a.rack, b.rack);
2151
swap(a.__isset, b.__isset);
2152
}
2153
2154
const char* TokenRange::ascii_fingerprint = "832268DC4CD6B17EE8881FC57EA04679";
2155
const uint8_t TokenRange::binary_fingerprint[16] = {0x83,0x22,0x68,0xDC,0x4C,0xD6,0xB1,0x7E,0xE8,0x88,0x1F,0xC5,0x7E,0xA0,0x46,0x79};
2156
2157
uint32_t TokenRange::read(::apache::thrift::protocol::TProtocol* iprot) {
2158
2159
uint32_t xfer = 0;
2160
std::string fname;
2161
::apache::thrift::protocol::TType ftype;
2162
int16_t fid;
2163
2164
xfer += iprot->readStructBegin(fname);
2165
2166
using ::apache::thrift::protocol::TProtocolException;
2167
2168
bool isset_start_token = false;
2169
bool isset_end_token = false;
2170
bool isset_endpoints = false;
2171
2172
while (true)
2173
{
2174
xfer += iprot->readFieldBegin(fname, ftype, fid);
2175
if (ftype == ::apache::thrift::protocol::T_STOP) {
2176
break;
2177
}
2178
switch (fid)
2179
{
2180
case 1:
2181
if (ftype == ::apache::thrift::protocol::T_STRING) {
2182
xfer += iprot->readString(this->start_token);
2183
isset_start_token = true;
2184
} else {
2185
xfer += iprot->skip(ftype);
2186
}
2187
break;
2188
case 2:
2189
if (ftype == ::apache::thrift::protocol::T_STRING) {
2190
xfer += iprot->readString(this->end_token);
2191
isset_end_token = true;
2192
} else {
2193
xfer += iprot->skip(ftype);
2194
}
2195
break;
2196
case 3:
2197
if (ftype == ::apache::thrift::protocol::T_LIST) {
2198
{
2199
this->endpoints.clear();
2200
uint32_t _size37;
2201
::apache::thrift::protocol::TType _etype40;
2202
xfer += iprot->readListBegin(_etype40, _size37);
2203
this->endpoints.resize(_size37);
2204
uint32_t _i41;
2205
for (_i41 = 0; _i41 < _size37; ++_i41)
2206
{
2207
xfer += iprot->readString(this->endpoints[_i41]);
2208
}
2209
xfer += iprot->readListEnd();
2210
}
2211
isset_endpoints = true;
2212
} else {
2213
xfer += iprot->skip(ftype);
2214
}
2215
break;
2216
case 4:
2217
if (ftype == ::apache::thrift::protocol::T_LIST) {
2218
{
2219
this->rpc_endpoints.clear();
2220
uint32_t _size42;
2221
::apache::thrift::protocol::TType _etype45;
2222
xfer += iprot->readListBegin(_etype45, _size42);
2223
this->rpc_endpoints.resize(_size42);
2224
uint32_t _i46;
2225
for (_i46 = 0; _i46 < _size42; ++_i46)
2226
{
2227
xfer += iprot->readString(this->rpc_endpoints[_i46]);
2228
}
2229
xfer += iprot->readListEnd();
2230
}
2231
this->__isset.rpc_endpoints = true;
2232
} else {
2233
xfer += iprot->skip(ftype);
2234
}
2235
break;
2236
case 5:
2237
if (ftype == ::apache::thrift::protocol::T_LIST) {
2238
{
2239
this->endpoint_details.clear();
2240
uint32_t _size47;
2241
::apache::thrift::protocol::TType _etype50;
2242
xfer += iprot->readListBegin(_etype50, _size47);
2243
this->endpoint_details.resize(_size47);
2244
uint32_t _i51;
2245
for (_i51 = 0; _i51 < _size47; ++_i51)
2246
{
2247
xfer += this->endpoint_details[_i51].read(iprot);
2248
}
2249
xfer += iprot->readListEnd();
2250
}
2251
this->__isset.endpoint_details = true;
2252
} else {
2253
xfer += iprot->skip(ftype);
2254
}
2255
break;
2256
default:
2257
xfer += iprot->skip(ftype);
2258
break;
2259
}
2260
xfer += iprot->readFieldEnd();
2261
}
2262
2263
xfer += iprot->readStructEnd();
2264
2265
if (!isset_start_token)
2266
throw TProtocolException(TProtocolException::INVALID_DATA);
2267
if (!isset_end_token)
2268
throw TProtocolException(TProtocolException::INVALID_DATA);
2269
if (!isset_endpoints)
2270
throw TProtocolException(TProtocolException::INVALID_DATA);
2271
return xfer;
2272
}
2273
2274
uint32_t TokenRange::write(::apache::thrift::protocol::TProtocol* oprot) const {
2275
uint32_t xfer = 0;
2276
xfer += oprot->writeStructBegin("TokenRange");
2277
2278
xfer += oprot->writeFieldBegin("start_token", ::apache::thrift::protocol::T_STRING, 1);
2279
xfer += oprot->writeString(this->start_token);
2280
xfer += oprot->writeFieldEnd();
2281
2282
xfer += oprot->writeFieldBegin("end_token", ::apache::thrift::protocol::T_STRING, 2);
2283
xfer += oprot->writeString(this->end_token);
2284
xfer += oprot->writeFieldEnd();
2285
2286
xfer += oprot->writeFieldBegin("endpoints", ::apache::thrift::protocol::T_LIST, 3);
2287
{
2288
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->endpoints.size()));
2289
std::vector<std::string> ::const_iterator _iter52;
2290
for (_iter52 = this->endpoints.begin(); _iter52 != this->endpoints.end(); ++_iter52)
2291
{
2292
xfer += oprot->writeString((*_iter52));
2293
}
2294
xfer += oprot->writeListEnd();
2295
}
2296
xfer += oprot->writeFieldEnd();
2297
2298
if (this->__isset.rpc_endpoints) {
2299
xfer += oprot->writeFieldBegin("rpc_endpoints", ::apache::thrift::protocol::T_LIST, 4);
2300
{
2301
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->rpc_endpoints.size()));
2302
std::vector<std::string> ::const_iterator _iter53;
2303
for (_iter53 = this->rpc_endpoints.begin(); _iter53 != this->rpc_endpoints.end(); ++_iter53)
2304
{
2305
xfer += oprot->writeString((*_iter53));
2306
}
2307
xfer += oprot->writeListEnd();
2308
}
2309
xfer += oprot->writeFieldEnd();
2310
}
2311
if (this->__isset.endpoint_details) {
2312
xfer += oprot->writeFieldBegin("endpoint_details", ::apache::thrift::protocol::T_LIST, 5);
2313
{
2314
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->endpoint_details.size()));
2315
std::vector<EndpointDetails> ::const_iterator _iter54;
2316
for (_iter54 = this->endpoint_details.begin(); _iter54 != this->endpoint_details.end(); ++_iter54)
2317
{
2318
xfer += (*_iter54).write(oprot);
2319
}
2320
xfer += oprot->writeListEnd();
2321
}
2322
xfer += oprot->writeFieldEnd();
2323
}
2324
xfer += oprot->writeFieldStop();
2325
xfer += oprot->writeStructEnd();
2326
return xfer;
2327
}
2328
2329
void swap(TokenRange &a, TokenRange &b) {
2330
using ::std::swap;
2331
swap(a.start_token, b.start_token);
2332
swap(a.end_token, b.end_token);
2333
swap(a.endpoints, b.endpoints);
2334
swap(a.rpc_endpoints, b.rpc_endpoints);
2335
swap(a.endpoint_details, b.endpoint_details);
2336
swap(a.__isset, b.__isset);
2337
}
2338
2339
const char* AuthenticationRequest::ascii_fingerprint = "5EA2D527ECA3BA20C77AFC023EE8C05F";
2340
const uint8_t AuthenticationRequest::binary_fingerprint[16] = {0x5E,0xA2,0xD5,0x27,0xEC,0xA3,0xBA,0x20,0xC7,0x7A,0xFC,0x02,0x3E,0xE8,0xC0,0x5F};
2341
2342
uint32_t AuthenticationRequest::read(::apache::thrift::protocol::TProtocol* iprot) {
2343
2344
uint32_t xfer = 0;
2345
std::string fname;
2346
::apache::thrift::protocol::TType ftype;
2347
int16_t fid;
2348
2349
xfer += iprot->readStructBegin(fname);
2350
2351
using ::apache::thrift::protocol::TProtocolException;
2352
2353
bool isset_credentials = false;
2354
2355
while (true)
2356
{
2357
xfer += iprot->readFieldBegin(fname, ftype, fid);
2358
if (ftype == ::apache::thrift::protocol::T_STOP) {
2359
break;
2360
}
2361
switch (fid)
2362
{
2363
case 1:
2364
if (ftype == ::apache::thrift::protocol::T_MAP) {
2365
{
2366
this->credentials.clear();
2367
uint32_t _size55;
2368
::apache::thrift::protocol::TType _ktype56;
2369
::apache::thrift::protocol::TType _vtype57;
2370
xfer += iprot->readMapBegin(_ktype56, _vtype57, _size55);
2371
uint32_t _i59;
2372
for (_i59 = 0; _i59 < _size55; ++_i59)
2373
{
2374
std::string _key60;
2375
xfer += iprot->readString(_key60);
2376
std::string& _val61 = this->credentials[_key60];
2377
xfer += iprot->readString(_val61);
2378
}
2379
xfer += iprot->readMapEnd();
2380
}
2381
isset_credentials = true;
2382
} else {
2383
xfer += iprot->skip(ftype);
2384
}
2385
break;
2386
default:
2387
xfer += iprot->skip(ftype);
2388
break;
2389
}
2390
xfer += iprot->readFieldEnd();
2391
}
2392
2393
xfer += iprot->readStructEnd();
2394
2395
if (!isset_credentials)
2396
throw TProtocolException(TProtocolException::INVALID_DATA);
2397
return xfer;
2398
}
2399
2400
uint32_t AuthenticationRequest::write(::apache::thrift::protocol::TProtocol* oprot) const {
2401
uint32_t xfer = 0;
2402
xfer += oprot->writeStructBegin("AuthenticationRequest");
2403
2404
xfer += oprot->writeFieldBegin("credentials", ::apache::thrift::protocol::T_MAP, 1);
2405
{
2406
xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->credentials.size()));
2407
std::map<std::string, std::string> ::const_iterator _iter62;
2408
for (_iter62 = this->credentials.begin(); _iter62 != this->credentials.end(); ++_iter62)
2409
{
2410
xfer += oprot->writeString(_iter62->first);
2411
xfer += oprot->writeString(_iter62->second);
2412
}
2413
xfer += oprot->writeMapEnd();
2414
}
2415
xfer += oprot->writeFieldEnd();
2416
2417
xfer += oprot->writeFieldStop();
2418
xfer += oprot->writeStructEnd();
2419
return xfer;
2420
}
2421
2422
void swap(AuthenticationRequest &a, AuthenticationRequest &b) {
2423
using ::std::swap;
2424
swap(a.credentials, b.credentials);
2425
}
2426
2427
const char* ColumnDef::ascii_fingerprint = "0D89CE83D7EDAD079AC3213ED1DCAA58";
2428
const uint8_t ColumnDef::binary_fingerprint[16] = {0x0D,0x89,0xCE,0x83,0xD7,0xED,0xAD,0x07,0x9A,0xC3,0x21,0x3E,0xD1,0xDC,0xAA,0x58};
2429
2430
uint32_t ColumnDef::read(::apache::thrift::protocol::TProtocol* iprot) {
2431
2432
uint32_t xfer = 0;
2433
std::string fname;
2434
::apache::thrift::protocol::TType ftype;
2435
int16_t fid;
2436
2437
xfer += iprot->readStructBegin(fname);
2438
2439
using ::apache::thrift::protocol::TProtocolException;
2440
2441
bool isset_name = false;
2442
bool isset_validation_class = false;
2443
2444
while (true)
2445
{
2446
xfer += iprot->readFieldBegin(fname, ftype, fid);
2447
if (ftype == ::apache::thrift::protocol::T_STOP) {
2448
break;
2449
}
2450
switch (fid)
2451
{
2452
case 1:
2453
if (ftype == ::apache::thrift::protocol::T_STRING) {
2454
xfer += iprot->readBinary(this->name);
2455
isset_name = true;
2456
} else {
2457
xfer += iprot->skip(ftype);
2458
}
2459
break;
2460
case 2:
2461
if (ftype == ::apache::thrift::protocol::T_STRING) {
2462
xfer += iprot->readString(this->validation_class);
2463
isset_validation_class = true;
2464
} else {
2465
xfer += iprot->skip(ftype);
2466
}
2467
break;
2468
case 3:
2469
if (ftype == ::apache::thrift::protocol::T_I32) {
2470
int32_t ecast63;
2471
xfer += iprot->readI32(ecast63);
2472
this->index_type = (IndexType::type)ecast63;
2473
this->__isset.index_type = true;
2474
} else {
2475
xfer += iprot->skip(ftype);
2476
}
2477
break;
2478
case 4:
2479
if (ftype == ::apache::thrift::protocol::T_STRING) {
2480
xfer += iprot->readString(this->index_name);
2481
this->__isset.index_name = true;
2482
} else {
2483
xfer += iprot->skip(ftype);
2484
}
2485
break;
2486
case 5:
2487
if (ftype == ::apache::thrift::protocol::T_MAP) {
2488
{
2489
this->index_options.clear();
2490
uint32_t _size64;
2491
::apache::thrift::protocol::TType _ktype65;
2492
::apache::thrift::protocol::TType _vtype66;
2493
xfer += iprot->readMapBegin(_ktype65, _vtype66, _size64);
2494
uint32_t _i68;
2495
for (_i68 = 0; _i68 < _size64; ++_i68)
2496
{
2497
std::string _key69;
2498
xfer += iprot->readString(_key69);
2499
std::string& _val70 = this->index_options[_key69];
2500
xfer += iprot->readString(_val70);
2501
}
2502
xfer += iprot->readMapEnd();
2503
}
2504
this->__isset.index_options = true;
2505
} else {
2506
xfer += iprot->skip(ftype);
2507
}
2508
break;
2509
default:
2510
xfer += iprot->skip(ftype);
2511
break;
2512
}
2513
xfer += iprot->readFieldEnd();
2514
}
2515
2516
xfer += iprot->readStructEnd();
2517
2518
if (!isset_name)
2519
throw TProtocolException(TProtocolException::INVALID_DATA);
2520
if (!isset_validation_class)
2521
throw TProtocolException(TProtocolException::INVALID_DATA);
2522
return xfer;
2523
}
2524
2525
uint32_t ColumnDef::write(::apache::thrift::protocol::TProtocol* oprot) const {
2526
uint32_t xfer = 0;
2527
xfer += oprot->writeStructBegin("ColumnDef");
2528
2529
xfer += oprot->writeFieldBegin("name", ::apache::thrift::protocol::T_STRING, 1);
2530
xfer += oprot->writeBinary(this->name);
2531
xfer += oprot->writeFieldEnd();
2532
2533
xfer += oprot->writeFieldBegin("validation_class", ::apache::thrift::protocol::T_STRING, 2);
2534
xfer += oprot->writeString(this->validation_class);
2535
xfer += oprot->writeFieldEnd();
2536
2537
if (this->__isset.index_type) {
2538
xfer += oprot->writeFieldBegin("index_type", ::apache::thrift::protocol::T_I32, 3);
2539
xfer += oprot->writeI32((int32_t)this->index_type);
2540
xfer += oprot->writeFieldEnd();
2541
}
2542
if (this->__isset.index_name) {
2543
xfer += oprot->writeFieldBegin("index_name", ::apache::thrift::protocol::T_STRING, 4);
2544
xfer += oprot->writeString(this->index_name);
2545
xfer += oprot->writeFieldEnd();
2546
}
2547
if (this->__isset.index_options) {
2548
xfer += oprot->writeFieldBegin("index_options", ::apache::thrift::protocol::T_MAP, 5);
2549
{
2550
xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->index_options.size()));
2551
std::map<std::string, std::string> ::const_iterator _iter71;
2552
for (_iter71 = this->index_options.begin(); _iter71 != this->index_options.end(); ++_iter71)
2553
{
2554
xfer += oprot->writeString(_iter71->first);
2555
xfer += oprot->writeString(_iter71->second);
2556
}
2557
xfer += oprot->writeMapEnd();
2558
}
2559
xfer += oprot->writeFieldEnd();
2560
}
2561
xfer += oprot->writeFieldStop();
2562
xfer += oprot->writeStructEnd();
2563
return xfer;
2564
}
2565
2566
void swap(ColumnDef &a, ColumnDef &b) {
2567
using ::std::swap;
2568
swap(a.name, b.name);
2569
swap(a.validation_class, b.validation_class);
2570
swap(a.index_type, b.index_type);
2571
swap(a.index_name, b.index_name);
2572
swap(a.index_options, b.index_options);
2573
swap(a.__isset, b.__isset);
2574
}
2575
2576
const char* CfDef::ascii_fingerprint = "231A260521B5DD99EFBCCBDD8768CA7D";
2577
const uint8_t CfDef::binary_fingerprint[16] = {0x23,0x1A,0x26,0x05,0x21,0xB5,0xDD,0x99,0xEF,0xBC,0xCB,0xDD,0x87,0x68,0xCA,0x7D};
2578
2579
uint32_t CfDef::read(::apache::thrift::protocol::TProtocol* iprot) {
2580
2581
uint32_t xfer = 0;
2582
std::string fname;
2583
::apache::thrift::protocol::TType ftype;
2584
int16_t fid;
2585
2586
xfer += iprot->readStructBegin(fname);
2587
2588
using ::apache::thrift::protocol::TProtocolException;
2589
2590
bool isset_keyspace = false;
2591
bool isset_name = false;
2592
2593
while (true)
2594
{
2595
xfer += iprot->readFieldBegin(fname, ftype, fid);
2596
if (ftype == ::apache::thrift::protocol::T_STOP) {
2597
break;
2598
}
2599
switch (fid)
2600
{
2601
case 1:
2602
if (ftype == ::apache::thrift::protocol::T_STRING) {
2603
xfer += iprot->readString(this->keyspace);
2604
isset_keyspace = true;
2605
} else {
2606
xfer += iprot->skip(ftype);
2607
}
2608
break;
2609
case 2:
2610
if (ftype == ::apache::thrift::protocol::T_STRING) {
2611
xfer += iprot->readString(this->name);
2612
isset_name = true;
2613
} else {
2614
xfer += iprot->skip(ftype);
2615
}
2616
break;
2617
case 3:
2618
if (ftype == ::apache::thrift::protocol::T_STRING) {
2619
xfer += iprot->readString(this->column_type);
2620
this->__isset.column_type = true;
2621
} else {
2622
xfer += iprot->skip(ftype);
2623
}
2624
break;
2625
case 5:
2626
if (ftype == ::apache::thrift::protocol::T_STRING) {
2627
xfer += iprot->readString(this->comparator_type);
2628
this->__isset.comparator_type = true;
2629
} else {
2630
xfer += iprot->skip(ftype);
2631
}
2632
break;
2633
case 6:
2634
if (ftype == ::apache::thrift::protocol::T_STRING) {
2635
xfer += iprot->readString(this->subcomparator_type);
2636
this->__isset.subcomparator_type = true;
2637
} else {
2638
xfer += iprot->skip(ftype);
2639
}
2640
break;
2641
case 8:
2642
if (ftype == ::apache::thrift::protocol::T_STRING) {
2643
xfer += iprot->readString(this->comment);
2644
this->__isset.comment = true;
2645
} else {
2646
xfer += iprot->skip(ftype);
2647
}
2648
break;
2649
case 12:
2650
if (ftype == ::apache::thrift::protocol::T_DOUBLE) {
2651
xfer += iprot->readDouble(this->read_repair_chance);
2652
this->__isset.read_repair_chance = true;
2653
} else {
2654
xfer += iprot->skip(ftype);
2655
}
2656
break;
2657
case 13:
2658
if (ftype == ::apache::thrift::protocol::T_LIST) {
2659
{
2660
this->column_metadata.clear();
2661
uint32_t _size72;
2662
::apache::thrift::protocol::TType _etype75;
2663
xfer += iprot->readListBegin(_etype75, _size72);
2664
this->column_metadata.resize(_size72);
2665
uint32_t _i76;
2666
for (_i76 = 0; _i76 < _size72; ++_i76)
2667
{
2668
xfer += this->column_metadata[_i76].read(iprot);
2669
}
2670
xfer += iprot->readListEnd();
2671
}
2672
this->__isset.column_metadata = true;
2673
} else {
2674
xfer += iprot->skip(ftype);
2675
}
2676
break;
2677
case 14:
2678
if (ftype == ::apache::thrift::protocol::T_I32) {
2679
xfer += iprot->readI32(this->gc_grace_seconds);
2680
this->__isset.gc_grace_seconds = true;
2681
} else {
2682
xfer += iprot->skip(ftype);
2683
}
2684
break;
2685
case 15:
2686
if (ftype == ::apache::thrift::protocol::T_STRING) {
2687
xfer += iprot->readString(this->default_validation_class);
2688
this->__isset.default_validation_class = true;
2689
} else {
2690
xfer += iprot->skip(ftype);
2691
}
2692
break;
2693
case 16:
2694
if (ftype == ::apache::thrift::protocol::T_I32) {
2695
xfer += iprot->readI32(this->id);
2696
this->__isset.id = true;
2697
} else {
2698
xfer += iprot->skip(ftype);
2699
}
2700
break;
2701
case 17:
2702
if (ftype == ::apache::thrift::protocol::T_I32) {
2703
xfer += iprot->readI32(this->min_compaction_threshold);
2704
this->__isset.min_compaction_threshold = true;
2705
} else {
2706
xfer += iprot->skip(ftype);
2707
}
2708
break;
2709
case 18:
2710
if (ftype == ::apache::thrift::protocol::T_I32) {
2711
xfer += iprot->readI32(this->max_compaction_threshold);
2712
this->__isset.max_compaction_threshold = true;
2713
} else {
2714
xfer += iprot->skip(ftype);
2715
}
2716
break;
2717
case 24:
2718
if (ftype == ::apache::thrift::protocol::T_BOOL) {
2719
xfer += iprot->readBool(this->replicate_on_write);
2720
this->__isset.replicate_on_write = true;
2721
} else {
2722
xfer += iprot->skip(ftype);
2723
}
2724
break;
2725
case 26:
2726
if (ftype == ::apache::thrift::protocol::T_STRING) {
2727
xfer += iprot->readString(this->key_validation_class);
2728
this->__isset.key_validation_class = true;
2729
} else {
2730
xfer += iprot->skip(ftype);
2731
}
2732
break;
2733
case 28:
2734
if (ftype == ::apache::thrift::protocol::T_STRING) {
2735
xfer += iprot->readBinary(this->key_alias);
2736
this->__isset.key_alias = true;
2737
} else {
2738
xfer += iprot->skip(ftype);
2739
}
2740
break;
2741
case 29:
2742
if (ftype == ::apache::thrift::protocol::T_STRING) {
2743
xfer += iprot->readString(this->compaction_strategy);
2744
this->__isset.compaction_strategy = true;
2745
} else {
2746
xfer += iprot->skip(ftype);
2747
}
2748
break;
2749
case 30:
2750
if (ftype == ::apache::thrift::protocol::T_MAP) {
2751
{
2752
this->compaction_strategy_options.clear();
2753
uint32_t _size77;
2754
::apache::thrift::protocol::TType _ktype78;
2755
::apache::thrift::protocol::TType _vtype79;
2756
xfer += iprot->readMapBegin(_ktype78, _vtype79, _size77);
2757
uint32_t _i81;
2758
for (_i81 = 0; _i81 < _size77; ++_i81)
2759
{
2760
std::string _key82;
2761
xfer += iprot->readString(_key82);
2762
std::string& _val83 = this->compaction_strategy_options[_key82];
2763
xfer += iprot->readString(_val83);
2764
}
2765
xfer += iprot->readMapEnd();
2766
}
2767
this->__isset.compaction_strategy_options = true;
2768
} else {
2769
xfer += iprot->skip(ftype);
2770
}
2771
break;
2772
case 32:
2773
if (ftype == ::apache::thrift::protocol::T_MAP) {
2774
{
2775
this->compression_options.clear();
2776
uint32_t _size84;
2777
::apache::thrift::protocol::TType _ktype85;
2778
::apache::thrift::protocol::TType _vtype86;
2779
xfer += iprot->readMapBegin(_ktype85, _vtype86, _size84);
2780
uint32_t _i88;
2781
for (_i88 = 0; _i88 < _size84; ++_i88)
2782
{
2783
std::string _key89;
2784
xfer += iprot->readString(_key89);
2785
std::string& _val90 = this->compression_options[_key89];
2786
xfer += iprot->readString(_val90);
2787
}
2788
xfer += iprot->readMapEnd();
2789
}
2790
this->__isset.compression_options = true;
2791
} else {
2792
xfer += iprot->skip(ftype);
2793
}
2794
break;
2795
case 33:
2796
if (ftype == ::apache::thrift::protocol::T_DOUBLE) {
2797
xfer += iprot->readDouble(this->bloom_filter_fp_chance);
2798
this->__isset.bloom_filter_fp_chance = true;
2799
} else {
2800
xfer += iprot->skip(ftype);
2801
}
2802
break;
2803
case 34:
2804
if (ftype == ::apache::thrift::protocol::T_STRING) {
2805
xfer += iprot->readString(this->caching);
2806
this->__isset.caching = true;
2807
} else {
2808
xfer += iprot->skip(ftype);
2809
}
2810
break;
2811
case 37:
2812
if (ftype == ::apache::thrift::protocol::T_DOUBLE) {
2813
xfer += iprot->readDouble(this->dclocal_read_repair_chance);
2814
this->__isset.dclocal_read_repair_chance = true;
2815
} else {
2816
xfer += iprot->skip(ftype);
2817
}
2818
break;
2819
case 9:
2820
if (ftype == ::apache::thrift::protocol::T_DOUBLE) {
2821
xfer += iprot->readDouble(this->row_cache_size);
2822
this->__isset.row_cache_size = true;
2823
} else {
2824
xfer += iprot->skip(ftype);
2825
}
2826
break;
2827
case 11:
2828
if (ftype == ::apache::thrift::protocol::T_DOUBLE) {
2829
xfer += iprot->readDouble(this->key_cache_size);
2830
this->__isset.key_cache_size = true;
2831
} else {
2832
xfer += iprot->skip(ftype);
2833
}
2834
break;
2835
case 19:
2836
if (ftype == ::apache::thrift::protocol::T_I32) {
2837
xfer += iprot->readI32(this->row_cache_save_period_in_seconds);
2838
this->__isset.row_cache_save_period_in_seconds = true;
2839
} else {
2840
xfer += iprot->skip(ftype);
2841
}
2842
break;
2843
case 20:
2844
if (ftype == ::apache::thrift::protocol::T_I32) {
2845
xfer += iprot->readI32(this->key_cache_save_period_in_seconds);
2846
this->__isset.key_cache_save_period_in_seconds = true;
2847
} else {
2848
xfer += iprot->skip(ftype);
2849
}
2850
break;
2851
case 21:
2852
if (ftype == ::apache::thrift::protocol::T_I32) {
2853
xfer += iprot->readI32(this->memtable_flush_after_mins);
2854
this->__isset.memtable_flush_after_mins = true;
2855
} else {
2856
xfer += iprot->skip(ftype);
2857
}
2858
break;
2859
case 22:
2860
if (ftype == ::apache::thrift::protocol::T_I32) {
2861
xfer += iprot->readI32(this->memtable_throughput_in_mb);
2862
this->__isset.memtable_throughput_in_mb = true;
2863
} else {
2864
xfer += iprot->skip(ftype);
2865
}
2866
break;
2867
case 23:
2868
if (ftype == ::apache::thrift::protocol::T_DOUBLE) {
2869
xfer += iprot->readDouble(this->memtable_operations_in_millions);
2870
this->__isset.memtable_operations_in_millions = true;
2871
} else {
2872
xfer += iprot->skip(ftype);
2873
}
2874
break;
2875
case 25:
2876
if (ftype == ::apache::thrift::protocol::T_DOUBLE) {
2877
xfer += iprot->readDouble(this->merge_shards_chance);
2878
this->__isset.merge_shards_chance = true;
2879
} else {
2880
xfer += iprot->skip(ftype);
2881
}
2882
break;
2883
case 27:
2884
if (ftype == ::apache::thrift::protocol::T_STRING) {
2885
xfer += iprot->readString(this->row_cache_provider);
2886
this->__isset.row_cache_provider = true;
2887
} else {
2888
xfer += iprot->skip(ftype);
2889
}
2890
break;
2891
case 31:
2892
if (ftype == ::apache::thrift::protocol::T_I32) {
2893
xfer += iprot->readI32(this->row_cache_keys_to_save);
2894
this->__isset.row_cache_keys_to_save = true;
2895
} else {
2896
xfer += iprot->skip(ftype);
2897
}
2898
break;
2899
default:
2900
xfer += iprot->skip(ftype);
2901
break;
2902
}
2903
xfer += iprot->readFieldEnd();
2904
}
2905
2906
xfer += iprot->readStructEnd();
2907
2908
if (!isset_keyspace)
2909
throw TProtocolException(TProtocolException::INVALID_DATA);
2910
if (!isset_name)
2911
throw TProtocolException(TProtocolException::INVALID_DATA);
2912
return xfer;
2913
}
2914
2915
uint32_t CfDef::write(::apache::thrift::protocol::TProtocol* oprot) const {
2916
uint32_t xfer = 0;
2917
xfer += oprot->writeStructBegin("CfDef");
2918
2919
xfer += oprot->writeFieldBegin("keyspace", ::apache::thrift::protocol::T_STRING, 1);
2920
xfer += oprot->writeString(this->keyspace);
2921
xfer += oprot->writeFieldEnd();
2922
2923
xfer += oprot->writeFieldBegin("name", ::apache::thrift::protocol::T_STRING, 2);
2924
xfer += oprot->writeString(this->name);
2925
xfer += oprot->writeFieldEnd();
2926
2927
if (this->__isset.column_type) {
2928
xfer += oprot->writeFieldBegin("column_type", ::apache::thrift::protocol::T_STRING, 3);
2929
xfer += oprot->writeString(this->column_type);
2930
xfer += oprot->writeFieldEnd();
2931
}
2932
if (this->__isset.comparator_type) {
2933
xfer += oprot->writeFieldBegin("comparator_type", ::apache::thrift::protocol::T_STRING, 5);
2934
xfer += oprot->writeString(this->comparator_type);
2935
xfer += oprot->writeFieldEnd();
2936
}
2937
if (this->__isset.subcomparator_type) {
2938
xfer += oprot->writeFieldBegin("subcomparator_type", ::apache::thrift::protocol::T_STRING, 6);
2939
xfer += oprot->writeString(this->subcomparator_type);
2940
xfer += oprot->writeFieldEnd();
2941
}
2942
if (this->__isset.comment) {
2943
xfer += oprot->writeFieldBegin("comment", ::apache::thrift::protocol::T_STRING, 8);
2944
xfer += oprot->writeString(this->comment);
2945
xfer += oprot->writeFieldEnd();
2946
}
2947
if (this->__isset.row_cache_size) {
2948
xfer += oprot->writeFieldBegin("row_cache_size", ::apache::thrift::protocol::T_DOUBLE, 9);
2949
xfer += oprot->writeDouble(this->row_cache_size);
2950
xfer += oprot->writeFieldEnd();
2951
}
2952
if (this->__isset.key_cache_size) {
2953
xfer += oprot->writeFieldBegin("key_cache_size", ::apache::thrift::protocol::T_DOUBLE, 11);
2954
xfer += oprot->writeDouble(this->key_cache_size);
2955
xfer += oprot->writeFieldEnd();
2956
}
2957
if (this->__isset.read_repair_chance) {
2958
xfer += oprot->writeFieldBegin("read_repair_chance", ::apache::thrift::protocol::T_DOUBLE, 12);
2959
xfer += oprot->writeDouble(this->read_repair_chance);
2960
xfer += oprot->writeFieldEnd();
2961
}
2962
if (this->__isset.column_metadata) {
2963
xfer += oprot->writeFieldBegin("column_metadata", ::apache::thrift::protocol::T_LIST, 13);
2964
{
2965
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->column_metadata.size()));
2966
std::vector<ColumnDef> ::const_iterator _iter91;
2967
for (_iter91 = this->column_metadata.begin(); _iter91 != this->column_metadata.end(); ++_iter91)
2968
{
2969
xfer += (*_iter91).write(oprot);
2970
}
2971
xfer += oprot->writeListEnd();
2972
}
2973
xfer += oprot->writeFieldEnd();
2974
}
2975
if (this->__isset.gc_grace_seconds) {
2976
xfer += oprot->writeFieldBegin("gc_grace_seconds", ::apache::thrift::protocol::T_I32, 14);
2977
xfer += oprot->writeI32(this->gc_grace_seconds);
2978
xfer += oprot->writeFieldEnd();
2979
}
2980
if (this->__isset.default_validation_class) {
2981
xfer += oprot->writeFieldBegin("default_validation_class", ::apache::thrift::protocol::T_STRING, 15);
2982
xfer += oprot->writeString(this->default_validation_class);
2983
xfer += oprot->writeFieldEnd();
2984
}
2985
if (this->__isset.id) {
2986
xfer += oprot->writeFieldBegin("id", ::apache::thrift::protocol::T_I32, 16);
2987
xfer += oprot->writeI32(this->id);
2988
xfer += oprot->writeFieldEnd();
2989
}
2990
if (this->__isset.min_compaction_threshold) {
2991
xfer += oprot->writeFieldBegin("min_compaction_threshold", ::apache::thrift::protocol::T_I32, 17);
2992
xfer += oprot->writeI32(this->min_compaction_threshold);
2993
xfer += oprot->writeFieldEnd();
2994
}
2995
if (this->__isset.max_compaction_threshold) {
2996
xfer += oprot->writeFieldBegin("max_compaction_threshold", ::apache::thrift::protocol::T_I32, 18);
2997
xfer += oprot->writeI32(this->max_compaction_threshold);
2998
xfer += oprot->writeFieldEnd();
2999
}
3000
if (this->__isset.row_cache_save_period_in_seconds) {
3001
xfer += oprot->writeFieldBegin("row_cache_save_period_in_seconds", ::apache::thrift::protocol::T_I32, 19);
3002
xfer += oprot->writeI32(this->row_cache_save_period_in_seconds);
3003
xfer += oprot->writeFieldEnd();
3004
}
3005
if (this->__isset.key_cache_save_period_in_seconds) {
3006
xfer += oprot->writeFieldBegin("key_cache_save_period_in_seconds", ::apache::thrift::protocol::T_I32, 20);
3007
xfer += oprot->writeI32(this->key_cache_save_period_in_seconds);
3008
xfer += oprot->writeFieldEnd();
3009
}
3010
if (this->__isset.memtable_flush_after_mins) {
3011
xfer += oprot->writeFieldBegin("memtable_flush_after_mins", ::apache::thrift::protocol::T_I32, 21);
3012
xfer += oprot->writeI32(this->memtable_flush_after_mins);
3013
xfer += oprot->writeFieldEnd();
3014
}
3015
if (this->__isset.memtable_throughput_in_mb) {
3016
xfer += oprot->writeFieldBegin("memtable_throughput_in_mb", ::apache::thrift::protocol::T_I32, 22);
3017
xfer += oprot->writeI32(this->memtable_throughput_in_mb);
3018
xfer += oprot->writeFieldEnd();
3019
}
3020
if (this->__isset.memtable_operations_in_millions) {
3021
xfer += oprot->writeFieldBegin("memtable_operations_in_millions", ::apache::thrift::protocol::T_DOUBLE, 23);
3022
xfer += oprot->writeDouble(this->memtable_operations_in_millions);
3023
xfer += oprot->writeFieldEnd();
3024
}
3025
if (this->__isset.replicate_on_write) {
3026
xfer += oprot->writeFieldBegin("replicate_on_write", ::apache::thrift::protocol::T_BOOL, 24);
3027
xfer += oprot->writeBool(this->replicate_on_write);
3028
xfer += oprot->writeFieldEnd();
3029
}
3030
if (this->__isset.merge_shards_chance) {
3031
xfer += oprot->writeFieldBegin("merge_shards_chance", ::apache::thrift::protocol::T_DOUBLE, 25);
3032
xfer += oprot->writeDouble(this->merge_shards_chance);
3033
xfer += oprot->writeFieldEnd();
3034
}
3035
if (this->__isset.key_validation_class) {
3036
xfer += oprot->writeFieldBegin("key_validation_class", ::apache::thrift::protocol::T_STRING, 26);
3037
xfer += oprot->writeString(this->key_validation_class);
3038
xfer += oprot->writeFieldEnd();
3039
}
3040
if (this->__isset.row_cache_provider) {
3041
xfer += oprot->writeFieldBegin("row_cache_provider", ::apache::thrift::protocol::T_STRING, 27);
3042
xfer += oprot->writeString(this->row_cache_provider);
3043
xfer += oprot->writeFieldEnd();
3044
}
3045
if (this->__isset.key_alias) {
3046
xfer += oprot->writeFieldBegin("key_alias", ::apache::thrift::protocol::T_STRING, 28);
3047
xfer += oprot->writeBinary(this->key_alias);
3048
xfer += oprot->writeFieldEnd();
3049
}
3050
if (this->__isset.compaction_strategy) {
3051
xfer += oprot->writeFieldBegin("compaction_strategy", ::apache::thrift::protocol::T_STRING, 29);
3052
xfer += oprot->writeString(this->compaction_strategy);
3053
xfer += oprot->writeFieldEnd();
3054
}
3055
if (this->__isset.compaction_strategy_options) {
3056
xfer += oprot->writeFieldBegin("compaction_strategy_options", ::apache::thrift::protocol::T_MAP, 30);
3057
{
3058
xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->compaction_strategy_options.size()));
3059
std::map<std::string, std::string> ::const_iterator _iter92;
3060
for (_iter92 = this->compaction_strategy_options.begin(); _iter92 != this->compaction_strategy_options.end(); ++_iter92)
3061
{
3062
xfer += oprot->writeString(_iter92->first);
3063
xfer += oprot->writeString(_iter92->second);
3064
}
3065
xfer += oprot->writeMapEnd();
3066
}
3067
xfer += oprot->writeFieldEnd();
3068
}
3069
if (this->__isset.row_cache_keys_to_save) {
3070
xfer += oprot->writeFieldBegin("row_cache_keys_to_save", ::apache::thrift::protocol::T_I32, 31);
3071
xfer += oprot->writeI32(this->row_cache_keys_to_save);
3072
xfer += oprot->writeFieldEnd();
3073
}
3074
if (this->__isset.compression_options) {
3075
xfer += oprot->writeFieldBegin("compression_options", ::apache::thrift::protocol::T_MAP, 32);
3076
{
3077
xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->compression_options.size()));
3078
std::map<std::string, std::string> ::const_iterator _iter93;
3079
for (_iter93 = this->compression_options.begin(); _iter93 != this->compression_options.end(); ++_iter93)
3080
{
3081
xfer += oprot->writeString(_iter93->first);
3082
xfer += oprot->writeString(_iter93->second);
3083
}
3084
xfer += oprot->writeMapEnd();
3085
}
3086
xfer += oprot->writeFieldEnd();
3087
}
3088
if (this->__isset.bloom_filter_fp_chance) {
3089
xfer += oprot->writeFieldBegin("bloom_filter_fp_chance", ::apache::thrift::protocol::T_DOUBLE, 33);
3090
xfer += oprot->writeDouble(this->bloom_filter_fp_chance);
3091
xfer += oprot->writeFieldEnd();
3092
}
3093
if (this->__isset.caching) {
3094
xfer += oprot->writeFieldBegin("caching", ::apache::thrift::protocol::T_STRING, 34);
3095
xfer += oprot->writeString(this->caching);
3096
xfer += oprot->writeFieldEnd();
3097
}
3098
if (this->__isset.dclocal_read_repair_chance) {
3099
xfer += oprot->writeFieldBegin("dclocal_read_repair_chance", ::apache::thrift::protocol::T_DOUBLE, 37);
3100
xfer += oprot->writeDouble(this->dclocal_read_repair_chance);
3101
xfer += oprot->writeFieldEnd();
3102
}
3103
xfer += oprot->writeFieldStop();
3104
xfer += oprot->writeStructEnd();
3105
return xfer;
3106
}
3107
3108
void swap(CfDef &a, CfDef &b) {
3109
using ::std::swap;
3110
swap(a.keyspace, b.keyspace);
3111
swap(a.name, b.name);
3112
swap(a.column_type, b.column_type);
3113
swap(a.comparator_type, b.comparator_type);
3114
swap(a.subcomparator_type, b.subcomparator_type);
3115
swap(a.comment, b.comment);
3116
swap(a.read_repair_chance, b.read_repair_chance);
3117
swap(a.column_metadata, b.column_metadata);
3118
swap(a.gc_grace_seconds, b.gc_grace_seconds);
3119
swap(a.default_validation_class, b.default_validation_class);
3120
swap(a.id, b.id);
3121
swap(a.min_compaction_threshold, b.min_compaction_threshold);
3122
swap(a.max_compaction_threshold, b.max_compaction_threshold);
3123
swap(a.replicate_on_write, b.replicate_on_write);
3124
swap(a.key_validation_class, b.key_validation_class);
3125
swap(a.key_alias, b.key_alias);
3126
swap(a.compaction_strategy, b.compaction_strategy);
3127
swap(a.compaction_strategy_options, b.compaction_strategy_options);
3128
swap(a.compression_options, b.compression_options);
3129
swap(a.bloom_filter_fp_chance, b.bloom_filter_fp_chance);
3130
swap(a.caching, b.caching);
3131
swap(a.dclocal_read_repair_chance, b.dclocal_read_repair_chance);
3132
swap(a.row_cache_size, b.row_cache_size);
3133
swap(a.key_cache_size, b.key_cache_size);
3134
swap(a.row_cache_save_period_in_seconds, b.row_cache_save_period_in_seconds);
3135
swap(a.key_cache_save_period_in_seconds, b.key_cache_save_period_in_seconds);
3136
swap(a.memtable_flush_after_mins, b.memtable_flush_after_mins);
3137
swap(a.memtable_throughput_in_mb, b.memtable_throughput_in_mb);
3138
swap(a.memtable_operations_in_millions, b.memtable_operations_in_millions);
3139
swap(a.merge_shards_chance, b.merge_shards_chance);
3140
swap(a.row_cache_provider, b.row_cache_provider);
3141
swap(a.row_cache_keys_to_save, b.row_cache_keys_to_save);
3142
swap(a.__isset, b.__isset);
3143
}
3144
3145
const char* KsDef::ascii_fingerprint = "0767851B6476EB3777A21E59E912E11A";
3146
const uint8_t KsDef::binary_fingerprint[16] = {0x07,0x67,0x85,0x1B,0x64,0x76,0xEB,0x37,0x77,0xA2,0x1E,0x59,0xE9,0x12,0xE1,0x1A};
3147
3148
uint32_t KsDef::read(::apache::thrift::protocol::TProtocol* iprot) {
3149
3150
uint32_t xfer = 0;
3151
std::string fname;
3152
::apache::thrift::protocol::TType ftype;
3153
int16_t fid;
3154
3155
xfer += iprot->readStructBegin(fname);
3156
3157
using ::apache::thrift::protocol::TProtocolException;
3158
3159
bool isset_name = false;
3160
bool isset_strategy_class = false;
3161
bool isset_cf_defs = false;
3162
3163
while (true)
3164
{
3165
xfer += iprot->readFieldBegin(fname, ftype, fid);
3166
if (ftype == ::apache::thrift::protocol::T_STOP) {
3167
break;
3168
}
3169
switch (fid)
3170
{
3171
case 1:
3172
if (ftype == ::apache::thrift::protocol::T_STRING) {
3173
xfer += iprot->readString(this->name);
3174
isset_name = true;
3175
} else {
3176
xfer += iprot->skip(ftype);
3177
}
3178
break;
3179
case 2:
3180
if (ftype == ::apache::thrift::protocol::T_STRING) {
3181
xfer += iprot->readString(this->strategy_class);
3182
isset_strategy_class = true;
3183
} else {
3184
xfer += iprot->skip(ftype);
3185
}
3186
break;
3187
case 3:
3188
if (ftype == ::apache::thrift::protocol::T_MAP) {
3189
{
3190
this->strategy_options.clear();
3191
uint32_t _size94;
3192
::apache::thrift::protocol::TType _ktype95;
3193
::apache::thrift::protocol::TType _vtype96;
3194
xfer += iprot->readMapBegin(_ktype95, _vtype96, _size94);
3195
uint32_t _i98;
3196
for (_i98 = 0; _i98 < _size94; ++_i98)
3197
{
3198
std::string _key99;
3199
xfer += iprot->readString(_key99);
3200
std::string& _val100 = this->strategy_options[_key99];
3201
xfer += iprot->readString(_val100);
3202
}
3203
xfer += iprot->readMapEnd();
3204
}
3205
this->__isset.strategy_options = true;
3206
} else {
3207
xfer += iprot->skip(ftype);
3208
}
3209
break;
3210
case 4:
3211
if (ftype == ::apache::thrift::protocol::T_I32) {
3212
xfer += iprot->readI32(this->replication_factor);
3213
this->__isset.replication_factor = true;
3214
} else {
3215
xfer += iprot->skip(ftype);
3216
}
3217
break;
3218
case 5:
3219
if (ftype == ::apache::thrift::protocol::T_LIST) {
3220
{
3221
this->cf_defs.clear();
3222
uint32_t _size101;
3223
::apache::thrift::protocol::TType _etype104;
3224
xfer += iprot->readListBegin(_etype104, _size101);
3225
this->cf_defs.resize(_size101);
3226
uint32_t _i105;
3227
for (_i105 = 0; _i105 < _size101; ++_i105)
3228
{
3229
xfer += this->cf_defs[_i105].read(iprot);
3230
}
3231
xfer += iprot->readListEnd();
3232
}
3233
isset_cf_defs = true;
3234
} else {
3235
xfer += iprot->skip(ftype);
3236
}
3237
break;
3238
case 6:
3239
if (ftype == ::apache::thrift::protocol::T_BOOL) {
3240
xfer += iprot->readBool(this->durable_writes);
3241
this->__isset.durable_writes = true;
3242
} else {
3243
xfer += iprot->skip(ftype);
3244
}
3245
break;
3246
default:
3247
xfer += iprot->skip(ftype);
3248
break;
3249
}
3250
xfer += iprot->readFieldEnd();
3251
}
3252
3253
xfer += iprot->readStructEnd();
3254
3255
if (!isset_name)
3256
throw TProtocolException(TProtocolException::INVALID_DATA);
3257
if (!isset_strategy_class)
3258
throw TProtocolException(TProtocolException::INVALID_DATA);
3259
if (!isset_cf_defs)
3260
throw TProtocolException(TProtocolException::INVALID_DATA);
3261
return xfer;
3262
}
3263
3264
uint32_t KsDef::write(::apache::thrift::protocol::TProtocol* oprot) const {
3265
uint32_t xfer = 0;
3266
xfer += oprot->writeStructBegin("KsDef");
3267
3268
xfer += oprot->writeFieldBegin("name", ::apache::thrift::protocol::T_STRING, 1);
3269
xfer += oprot->writeString(this->name);
3270
xfer += oprot->writeFieldEnd();
3271
3272
xfer += oprot->writeFieldBegin("strategy_class", ::apache::thrift::protocol::T_STRING, 2);
3273
xfer += oprot->writeString(this->strategy_class);
3274
xfer += oprot->writeFieldEnd();
3275
3276
if (this->__isset.strategy_options) {
3277
xfer += oprot->writeFieldBegin("strategy_options", ::apache::thrift::protocol::T_MAP, 3);
3278
{
3279
xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->strategy_options.size()));
3280
std::map<std::string, std::string> ::const_iterator _iter106;
3281
for (_iter106 = this->strategy_options.begin(); _iter106 != this->strategy_options.end(); ++_iter106)
3282
{
3283
xfer += oprot->writeString(_iter106->first);
3284
xfer += oprot->writeString(_iter106->second);
3285
}
3286
xfer += oprot->writeMapEnd();
3287
}
3288
xfer += oprot->writeFieldEnd();
3289
}
3290
if (this->__isset.replication_factor) {
3291
xfer += oprot->writeFieldBegin("replication_factor", ::apache::thrift::protocol::T_I32, 4);
3292
xfer += oprot->writeI32(this->replication_factor);
3293
xfer += oprot->writeFieldEnd();
3294
}
3295
xfer += oprot->writeFieldBegin("cf_defs", ::apache::thrift::protocol::T_LIST, 5);
3296
{
3297
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->cf_defs.size()));
3298
std::vector<CfDef> ::const_iterator _iter107;
3299
for (_iter107 = this->cf_defs.begin(); _iter107 != this->cf_defs.end(); ++_iter107)
3300
{
3301
xfer += (*_iter107).write(oprot);
3302
}
3303
xfer += oprot->writeListEnd();
3304
}
3305
xfer += oprot->writeFieldEnd();
3306
3307
if (this->__isset.durable_writes) {
3308
xfer += oprot->writeFieldBegin("durable_writes", ::apache::thrift::protocol::T_BOOL, 6);
3309
xfer += oprot->writeBool(this->durable_writes);
3310
xfer += oprot->writeFieldEnd();
3311
}
3312
xfer += oprot->writeFieldStop();
3313
xfer += oprot->writeStructEnd();
3314
return xfer;
3315
}
3316
3317
void swap(KsDef &a, KsDef &b) {
3318
using ::std::swap;
3319
swap(a.name, b.name);
3320
swap(a.strategy_class, b.strategy_class);
3321
swap(a.strategy_options, b.strategy_options);
3322
swap(a.replication_factor, b.replication_factor);
3323
swap(a.cf_defs, b.cf_defs);
3324
swap(a.durable_writes, b.durable_writes);
3325
swap(a.__isset, b.__isset);
3326
}
3327
3328
const char* CqlRow::ascii_fingerprint = "470EFC558004E98D92D604898305C04E";
3329
const uint8_t CqlRow::binary_fingerprint[16] = {0x47,0x0E,0xFC,0x55,0x80,0x04,0xE9,0x8D,0x92,0xD6,0x04,0x89,0x83,0x05,0xC0,0x4E};
3330
3331
uint32_t CqlRow::read(::apache::thrift::protocol::TProtocol* iprot) {
3332
3333
uint32_t xfer = 0;
3334
std::string fname;
3335
::apache::thrift::protocol::TType ftype;
3336
int16_t fid;
3337
3338
xfer += iprot->readStructBegin(fname);
3339
3340
using ::apache::thrift::protocol::TProtocolException;
3341
3342
bool isset_key = false;
3343
bool isset_columns = false;
3344
3345
while (true)
3346
{
3347
xfer += iprot->readFieldBegin(fname, ftype, fid);
3348
if (ftype == ::apache::thrift::protocol::T_STOP) {
3349
break;
3350
}
3351
switch (fid)
3352
{
3353
case 1:
3354
if (ftype == ::apache::thrift::protocol::T_STRING) {
3355
xfer += iprot->readBinary(this->key);
3356
isset_key = true;
3357
} else {
3358
xfer += iprot->skip(ftype);
3359
}
3360
break;
3361
case 2:
3362
if (ftype == ::apache::thrift::protocol::T_LIST) {
3363
{
3364
this->columns.clear();
3365
uint32_t _size108;
3366
::apache::thrift::protocol::TType _etype111;
3367
xfer += iprot->readListBegin(_etype111, _size108);
3368
this->columns.resize(_size108);
3369
uint32_t _i112;
3370
for (_i112 = 0; _i112 < _size108; ++_i112)
3371
{
3372
xfer += this->columns[_i112].read(iprot);
3373
}
3374
xfer += iprot->readListEnd();
3375
}
3376
isset_columns = true;
3377
} else {
3378
xfer += iprot->skip(ftype);
3379
}
3380
break;
3381
default:
3382
xfer += iprot->skip(ftype);
3383
break;
3384
}
3385
xfer += iprot->readFieldEnd();
3386
}
3387
3388
xfer += iprot->readStructEnd();
3389
3390
if (!isset_key)
3391
throw TProtocolException(TProtocolException::INVALID_DATA);
3392
if (!isset_columns)
3393
throw TProtocolException(TProtocolException::INVALID_DATA);
3394
return xfer;
3395
}
3396
3397
uint32_t CqlRow::write(::apache::thrift::protocol::TProtocol* oprot) const {
3398
uint32_t xfer = 0;
3399
xfer += oprot->writeStructBegin("CqlRow");
3400
3401
xfer += oprot->writeFieldBegin("key", ::apache::thrift::protocol::T_STRING, 1);
3402
xfer += oprot->writeBinary(this->key);
3403
xfer += oprot->writeFieldEnd();
3404
3405
xfer += oprot->writeFieldBegin("columns", ::apache::thrift::protocol::T_LIST, 2);
3406
{
3407
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->columns.size()));
3408
std::vector<Column> ::const_iterator _iter113;
3409
for (_iter113 = this->columns.begin(); _iter113 != this->columns.end(); ++_iter113)
3410
{
3411
xfer += (*_iter113).write(oprot);
3412
}
3413
xfer += oprot->writeListEnd();
3414
}
3415
xfer += oprot->writeFieldEnd();
3416
3417
xfer += oprot->writeFieldStop();
3418
xfer += oprot->writeStructEnd();
3419
return xfer;
3420
}
3421
3422
void swap(CqlRow &a, CqlRow &b) {
3423
using ::std::swap;
3424
swap(a.key, b.key);
3425
swap(a.columns, b.columns);
3426
}
3427
3428
const char* CqlMetadata::ascii_fingerprint = "B7C5A4AA9652C744A48EBC1C12D531E7";
3429
const uint8_t CqlMetadata::binary_fingerprint[16] = {0xB7,0xC5,0xA4,0xAA,0x96,0x52,0xC7,0x44,0xA4,0x8E,0xBC,0x1C,0x12,0xD5,0x31,0xE7};
3430
3431
uint32_t CqlMetadata::read(::apache::thrift::protocol::TProtocol* iprot) {
3432
3433
uint32_t xfer = 0;
3434
std::string fname;
3435
::apache::thrift::protocol::TType ftype;
3436
int16_t fid;
3437
3438
xfer += iprot->readStructBegin(fname);
3439
3440
using ::apache::thrift::protocol::TProtocolException;
3441
3442
bool isset_name_types = false;
3443
bool isset_value_types = false;
3444
bool isset_default_name_type = false;
3445
bool isset_default_value_type = false;
3446
3447
while (true)
3448
{
3449
xfer += iprot->readFieldBegin(fname, ftype, fid);
3450
if (ftype == ::apache::thrift::protocol::T_STOP) {
3451
break;
3452
}
3453
switch (fid)
3454
{
3455
case 1:
3456
if (ftype == ::apache::thrift::protocol::T_MAP) {
3457
{
3458
this->name_types.clear();
3459
uint32_t _size114;
3460
::apache::thrift::protocol::TType _ktype115;
3461
::apache::thrift::protocol::TType _vtype116;
3462
xfer += iprot->readMapBegin(_ktype115, _vtype116, _size114);
3463
uint32_t _i118;
3464
for (_i118 = 0; _i118 < _size114; ++_i118)
3465
{
3466
std::string _key119;
3467
xfer += iprot->readBinary(_key119);
3468
std::string& _val120 = this->name_types[_key119];
3469
xfer += iprot->readString(_val120);
3470
}
3471
xfer += iprot->readMapEnd();
3472
}
3473
isset_name_types = true;
3474
} else {
3475
xfer += iprot->skip(ftype);
3476
}
3477
break;
3478
case 2:
3479
if (ftype == ::apache::thrift::protocol::T_MAP) {
3480
{
3481
this->value_types.clear();
3482
uint32_t _size121;
3483
::apache::thrift::protocol::TType _ktype122;
3484
::apache::thrift::protocol::TType _vtype123;
3485
xfer += iprot->readMapBegin(_ktype122, _vtype123, _size121);
3486
uint32_t _i125;
3487
for (_i125 = 0; _i125 < _size121; ++_i125)
3488
{
3489
std::string _key126;
3490
xfer += iprot->readBinary(_key126);
3491
std::string& _val127 = this->value_types[_key126];
3492
xfer += iprot->readString(_val127);
3493
}
3494
xfer += iprot->readMapEnd();
3495
}
3496
isset_value_types = true;
3497
} else {
3498
xfer += iprot->skip(ftype);
3499
}
3500
break;
3501
case 3:
3502
if (ftype == ::apache::thrift::protocol::T_STRING) {
3503
xfer += iprot->readString(this->default_name_type);
3504
isset_default_name_type = true;
3505
} else {
3506
xfer += iprot->skip(ftype);
3507
}
3508
break;
3509
case 4:
3510
if (ftype == ::apache::thrift::protocol::T_STRING) {
3511
xfer += iprot->readString(this->default_value_type);
3512
isset_default_value_type = true;
3513
} else {
3514
xfer += iprot->skip(ftype);
3515
}
3516
break;
3517
default:
3518
xfer += iprot->skip(ftype);
3519
break;
3520
}
3521
xfer += iprot->readFieldEnd();
3522
}
3523
3524
xfer += iprot->readStructEnd();
3525
3526
if (!isset_name_types)
3527
throw TProtocolException(TProtocolException::INVALID_DATA);
3528
if (!isset_value_types)
3529
throw TProtocolException(TProtocolException::INVALID_DATA);
3530
if (!isset_default_name_type)
3531
throw TProtocolException(TProtocolException::INVALID_DATA);
3532
if (!isset_default_value_type)
3533
throw TProtocolException(TProtocolException::INVALID_DATA);
3534
return xfer;
3535
}
3536
3537
uint32_t CqlMetadata::write(::apache::thrift::protocol::TProtocol* oprot) const {
3538
uint32_t xfer = 0;
3539
xfer += oprot->writeStructBegin("CqlMetadata");
3540
3541
xfer += oprot->writeFieldBegin("name_types", ::apache::thrift::protocol::T_MAP, 1);
3542
{
3543
xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->name_types.size()));
3544
std::map<std::string, std::string> ::const_iterator _iter128;
3545
for (_iter128 = this->name_types.begin(); _iter128 != this->name_types.end(); ++_iter128)
3546
{
3547
xfer += oprot->writeBinary(_iter128->first);
3548
xfer += oprot->writeString(_iter128->second);
3549
}
3550
xfer += oprot->writeMapEnd();
3551
}
3552
xfer += oprot->writeFieldEnd();
3553
3554
xfer += oprot->writeFieldBegin("value_types", ::apache::thrift::protocol::T_MAP, 2);
3555
{
3556
xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->value_types.size()));
3557
std::map<std::string, std::string> ::const_iterator _iter129;
3558
for (_iter129 = this->value_types.begin(); _iter129 != this->value_types.end(); ++_iter129)
3559
{
3560
xfer += oprot->writeBinary(_iter129->first);
3561
xfer += oprot->writeString(_iter129->second);
3562
}
3563
xfer += oprot->writeMapEnd();
3564
}
3565
xfer += oprot->writeFieldEnd();
3566
3567
xfer += oprot->writeFieldBegin("default_name_type", ::apache::thrift::protocol::T_STRING, 3);
3568
xfer += oprot->writeString(this->default_name_type);
3569
xfer += oprot->writeFieldEnd();
3570
3571
xfer += oprot->writeFieldBegin("default_value_type", ::apache::thrift::protocol::T_STRING, 4);
3572
xfer += oprot->writeString(this->default_value_type);
3573
xfer += oprot->writeFieldEnd();
3574
3575
xfer += oprot->writeFieldStop();
3576
xfer += oprot->writeStructEnd();
3577
return xfer;
3578
}
3579
3580
void swap(CqlMetadata &a, CqlMetadata &b) {
3581
using ::std::swap;
3582
swap(a.name_types, b.name_types);
3583
swap(a.value_types, b.value_types);
3584
swap(a.default_name_type, b.default_name_type);
3585
swap(a.default_value_type, b.default_value_type);
3586
}
3587
3588
const char* CqlResult::ascii_fingerprint = "521B9CE5AF77539F7267F6952B609E81";
3589
const uint8_t CqlResult::binary_fingerprint[16] = {0x52,0x1B,0x9C,0xE5,0xAF,0x77,0x53,0x9F,0x72,0x67,0xF6,0x95,0x2B,0x60,0x9E,0x81};
3590
3591
uint32_t CqlResult::read(::apache::thrift::protocol::TProtocol* iprot) {
3592
3593
uint32_t xfer = 0;
3594
std::string fname;
3595
::apache::thrift::protocol::TType ftype;
3596
int16_t fid;
3597
3598
xfer += iprot->readStructBegin(fname);
3599
3600
using ::apache::thrift::protocol::TProtocolException;
3601
3602
bool isset_type = false;
3603
3604
while (true)
3605
{
3606
xfer += iprot->readFieldBegin(fname, ftype, fid);
3607
if (ftype == ::apache::thrift::protocol::T_STOP) {
3608
break;
3609
}
3610
switch (fid)
3611
{
3612
case 1:
3613
if (ftype == ::apache::thrift::protocol::T_I32) {
3614
int32_t ecast130;
3615
xfer += iprot->readI32(ecast130);
3616
this->type = (CqlResultType::type)ecast130;
3617
isset_type = true;
3618
} else {
3619
xfer += iprot->skip(ftype);
3620
}
3621
break;
3622
case 2:
3623
if (ftype == ::apache::thrift::protocol::T_LIST) {
3624
{
3625
this->rows.clear();
3626
uint32_t _size131;
3627
::apache::thrift::protocol::TType _etype134;
3628
xfer += iprot->readListBegin(_etype134, _size131);
3629
this->rows.resize(_size131);
3630
uint32_t _i135;
3631
for (_i135 = 0; _i135 < _size131; ++_i135)
3632
{
3633
xfer += this->rows[_i135].read(iprot);
3634
}
3635
xfer += iprot->readListEnd();
3636
}
3637
this->__isset.rows = true;
3638
} else {
3639
xfer += iprot->skip(ftype);
3640
}
3641
break;
3642
case 3:
3643
if (ftype == ::apache::thrift::protocol::T_I32) {
3644
xfer += iprot->readI32(this->num);
3645
this->__isset.num = true;
3646
} else {
3647
xfer += iprot->skip(ftype);
3648
}
3649
break;
3650
case 4:
3651
if (ftype == ::apache::thrift::protocol::T_STRUCT) {
3652
xfer += this->schema.read(iprot);
3653
this->__isset.schema = true;
3654
} else {
3655
xfer += iprot->skip(ftype);
3656
}
3657
break;
3658
default:
3659
xfer += iprot->skip(ftype);
3660
break;
3661
}
3662
xfer += iprot->readFieldEnd();
3663
}
3664
3665
xfer += iprot->readStructEnd();
3666
3667
if (!isset_type)
3668
throw TProtocolException(TProtocolException::INVALID_DATA);
3669
return xfer;
3670
}
3671
3672
uint32_t CqlResult::write(::apache::thrift::protocol::TProtocol* oprot) const {
3673
uint32_t xfer = 0;
3674
xfer += oprot->writeStructBegin("CqlResult");
3675
3676
xfer += oprot->writeFieldBegin("type", ::apache::thrift::protocol::T_I32, 1);
3677
xfer += oprot->writeI32((int32_t)this->type);
3678
xfer += oprot->writeFieldEnd();
3679
3680
if (this->__isset.rows) {
3681
xfer += oprot->writeFieldBegin("rows", ::apache::thrift::protocol::T_LIST, 2);
3682
{
3683
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->rows.size()));
3684
std::vector<CqlRow> ::const_iterator _iter136;
3685
for (_iter136 = this->rows.begin(); _iter136 != this->rows.end(); ++_iter136)
3686
{
3687
xfer += (*_iter136).write(oprot);
3688
}
3689
xfer += oprot->writeListEnd();
3690
}
3691
xfer += oprot->writeFieldEnd();
3692
}
3693
if (this->__isset.num) {
3694
xfer += oprot->writeFieldBegin("num", ::apache::thrift::protocol::T_I32, 3);
3695
xfer += oprot->writeI32(this->num);
3696
xfer += oprot->writeFieldEnd();
3697
}
3698
if (this->__isset.schema) {
3699
xfer += oprot->writeFieldBegin("schema", ::apache::thrift::protocol::T_STRUCT, 4);
3700
xfer += this->schema.write(oprot);
3701
xfer += oprot->writeFieldEnd();
3702
}
3703
xfer += oprot->writeFieldStop();
3704
xfer += oprot->writeStructEnd();
3705
return xfer;
3706
}
3707
3708
void swap(CqlResult &a, CqlResult &b) {
3709
using ::std::swap;
3710
swap(a.type, b.type);
3711
swap(a.rows, b.rows);
3712
swap(a.num, b.num);
3713
swap(a.schema, b.schema);
3714
swap(a.__isset, b.__isset);
3715
}
3716
3717
const char* CqlPreparedResult::ascii_fingerprint = "7E1663EC688DFDC28722BF36F9F64E6F";
3718
const uint8_t CqlPreparedResult::binary_fingerprint[16] = {0x7E,0x16,0x63,0xEC,0x68,0x8D,0xFD,0xC2,0x87,0x22,0xBF,0x36,0xF9,0xF6,0x4E,0x6F};
3719
3720
uint32_t CqlPreparedResult::read(::apache::thrift::protocol::TProtocol* iprot) {
3721
3722
uint32_t xfer = 0;
3723
std::string fname;
3724
::apache::thrift::protocol::TType ftype;
3725
int16_t fid;
3726
3727
xfer += iprot->readStructBegin(fname);
3728
3729
using ::apache::thrift::protocol::TProtocolException;
3730
3731
bool isset_itemId = false;
3732
bool isset_count = false;
3733
3734
while (true)
3735
{
3736
xfer += iprot->readFieldBegin(fname, ftype, fid);
3737
if (ftype == ::apache::thrift::protocol::T_STOP) {
3738
break;
3739
}
3740
switch (fid)
3741
{
3742
case 1:
3743
if (ftype == ::apache::thrift::protocol::T_I32) {
3744
xfer += iprot->readI32(this->itemId);
3745
isset_itemId = true;
3746
} else {
3747
xfer += iprot->skip(ftype);
3748
}
3749
break;
3750
case 2:
3751
if (ftype == ::apache::thrift::protocol::T_I32) {
3752
xfer += iprot->readI32(this->count);
3753
isset_count = true;
3754
} else {
3755
xfer += iprot->skip(ftype);
3756
}
3757
break;
3758
case 3:
3759
if (ftype == ::apache::thrift::protocol::T_LIST) {
3760
{
3761
this->variable_types.clear();
3762
uint32_t _size137;
3763
::apache::thrift::protocol::TType _etype140;
3764
xfer += iprot->readListBegin(_etype140, _size137);
3765
this->variable_types.resize(_size137);
3766
uint32_t _i141;
3767
for (_i141 = 0; _i141 < _size137; ++_i141)
3768
{
3769
xfer += iprot->readString(this->variable_types[_i141]);
3770
}
3771
xfer += iprot->readListEnd();
3772
}
3773
this->__isset.variable_types = true;
3774
} else {
3775
xfer += iprot->skip(ftype);
3776
}
3777
break;
3778
case 4:
3779
if (ftype == ::apache::thrift::protocol::T_LIST) {
3780
{
3781
this->variable_names.clear();
3782
uint32_t _size142;
3783
::apache::thrift::protocol::TType _etype145;
3784
xfer += iprot->readListBegin(_etype145, _size142);
3785
this->variable_names.resize(_size142);
3786
uint32_t _i146;
3787
for (_i146 = 0; _i146 < _size142; ++_i146)
3788
{
3789
xfer += iprot->readString(this->variable_names[_i146]);
3790
}
3791
xfer += iprot->readListEnd();
3792
}
3793
this->__isset.variable_names = true;
3794
} else {
3795
xfer += iprot->skip(ftype);
3796
}
3797
break;
3798
default:
3799
xfer += iprot->skip(ftype);
3800
break;
3801
}
3802
xfer += iprot->readFieldEnd();
3803
}
3804
3805
xfer += iprot->readStructEnd();
3806
3807
if (!isset_itemId)
3808
throw TProtocolException(TProtocolException::INVALID_DATA);
3809
if (!isset_count)
3810
throw TProtocolException(TProtocolException::INVALID_DATA);
3811
return xfer;
3812
}
3813
3814
uint32_t CqlPreparedResult::write(::apache::thrift::protocol::TProtocol* oprot) const {
3815
uint32_t xfer = 0;
3816
xfer += oprot->writeStructBegin("CqlPreparedResult");
3817
3818
xfer += oprot->writeFieldBegin("itemId", ::apache::thrift::protocol::T_I32, 1);
3819
xfer += oprot->writeI32(this->itemId);
3820
xfer += oprot->writeFieldEnd();
3821
3822
xfer += oprot->writeFieldBegin("count", ::apache::thrift::protocol::T_I32, 2);
3823
xfer += oprot->writeI32(this->count);
3824
xfer += oprot->writeFieldEnd();
3825
3826
if (this->__isset.variable_types) {
3827
xfer += oprot->writeFieldBegin("variable_types", ::apache::thrift::protocol::T_LIST, 3);
3828
{
3829
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->variable_types.size()));
3830
std::vector<std::string> ::const_iterator _iter147;
3831
for (_iter147 = this->variable_types.begin(); _iter147 != this->variable_types.end(); ++_iter147)
3832
{
3833
xfer += oprot->writeString((*_iter147));
3834
}
3835
xfer += oprot->writeListEnd();
3836
}
3837
xfer += oprot->writeFieldEnd();
3838
}
3839
if (this->__isset.variable_names) {
3840
xfer += oprot->writeFieldBegin("variable_names", ::apache::thrift::protocol::T_LIST, 4);
3841
{
3842
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->variable_names.size()));
3843
std::vector<std::string> ::const_iterator _iter148;
3844
for (_iter148 = this->variable_names.begin(); _iter148 != this->variable_names.end(); ++_iter148)
3845
{
3846
xfer += oprot->writeString((*_iter148));
3847
}
3848
xfer += oprot->writeListEnd();
3849
}
3850
xfer += oprot->writeFieldEnd();
3851
}
3852
xfer += oprot->writeFieldStop();
3853
xfer += oprot->writeStructEnd();
3854
return xfer;
3855
}
3856
3857
void swap(CqlPreparedResult &a, CqlPreparedResult &b) {
3858
using ::std::swap;
3859
swap(a.itemId, b.itemId);
3860
swap(a.count, b.count);
3861
swap(a.variable_types, b.variable_types);
3862
swap(a.variable_names, b.variable_names);
3863
swap(a.__isset, b.__isset);
3864
}
3865
3866
}}} // namespace
Loggerhead is a web-based interface for Breezy
Version: 2.0.1