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