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