?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
HBASE-26921 Rewrite the counting cells part in TestMultiVersions (#4316)
[hbase.git] / hbase-examples / src / main / cpp / gen-cpp / Hbase.cpp
blob936fe5842d50ea00221bd038f2a06b9c53f8c72d
1 /**
2 * Autogenerated by Thrift Compiler (0.9.0)
3 *
4 * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
5 * @generated
6 */
7 #include "Hbase.h"
8
9 namespace apache { namespace hadoop { namespace hbase { namespace thrift {
10
11 uint32_t Hbase_enableTable_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
23 while (true)
24 {
25 xfer += iprot->readFieldBegin(fname, ftype, fid);
26 if (ftype == ::apache::thrift::protocol::T_STOP) {
27 break;
28 }
29 switch (fid)
30 {
31 case 1:
32 if (ftype == ::apache::thrift::protocol::T_STRING) {
33 xfer += iprot->readBinary(this->tableName);
34 this->__isset.tableName = true;
35 } else {
36 xfer += iprot->skip(ftype);
37 }
38 break;
39 default:
40 xfer += iprot->skip(ftype);
41 break;
42 }
43 xfer += iprot->readFieldEnd();
44 }
45
46 xfer += iprot->readStructEnd();
47
48 return xfer;
49 }
50
51 uint32_t Hbase_enableTable_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
52 uint32_t xfer = 0;
53 xfer += oprot->writeStructBegin("Hbase_enableTable_args");
54
55 xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
56 xfer += oprot->writeBinary(this->tableName);
57 xfer += oprot->writeFieldEnd();
58
59 xfer += oprot->writeFieldStop();
60 xfer += oprot->writeStructEnd();
61 return xfer;
62 }
63
64 uint32_t Hbase_enableTable_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
65 uint32_t xfer = 0;
66 xfer += oprot->writeStructBegin("Hbase_enableTable_pargs");
67
68 xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
69 xfer += oprot->writeBinary((*(this->tableName)));
70 xfer += oprot->writeFieldEnd();
71
72 xfer += oprot->writeFieldStop();
73 xfer += oprot->writeStructEnd();
74 return xfer;
75 }
76
77 uint32_t Hbase_enableTable_result::read(::apache::thrift::protocol::TProtocol* iprot) {
78
79 uint32_t xfer = 0;
80 std::string fname;
81 ::apache::thrift::protocol::TType ftype;
82 int16_t fid;
83
84 xfer += iprot->readStructBegin(fname);
85
86 using ::apache::thrift::protocol::TProtocolException;
87
88
89 while (true)
90 {
91 xfer += iprot->readFieldBegin(fname, ftype, fid);
92 if (ftype == ::apache::thrift::protocol::T_STOP) {
93 break;
94 }
95 switch (fid)
96 {
97 case 1:
98 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
99 xfer += this->io.read(iprot);
100 this->__isset.io = true;
101 } else {
102 xfer += iprot->skip(ftype);
103 }
104 break;
105 default:
106 xfer += iprot->skip(ftype);
107 break;
108 }
109 xfer += iprot->readFieldEnd();
110 }
111
112 xfer += iprot->readStructEnd();
113
114 return xfer;
115 }
116
117 uint32_t Hbase_enableTable_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
118
119 uint32_t xfer = 0;
120
121 xfer += oprot->writeStructBegin("Hbase_enableTable_result");
122
123 if (this->__isset.io) {
124 xfer += oprot->writeFieldBegin("io", ::apache::thrift::protocol::T_STRUCT, 1);
125 xfer += this->io.write(oprot);
126 xfer += oprot->writeFieldEnd();
127 }
128 xfer += oprot->writeFieldStop();
129 xfer += oprot->writeStructEnd();
130 return xfer;
131 }
132
133 uint32_t Hbase_enableTable_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
134
135 uint32_t xfer = 0;
136 std::string fname;
137 ::apache::thrift::protocol::TType ftype;
138 int16_t fid;
139
140 xfer += iprot->readStructBegin(fname);
141
142 using ::apache::thrift::protocol::TProtocolException;
143
144
145 while (true)
146 {
147 xfer += iprot->readFieldBegin(fname, ftype, fid);
148 if (ftype == ::apache::thrift::protocol::T_STOP) {
149 break;
150 }
151 switch (fid)
152 {
153 case 1:
154 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
155 xfer += this->io.read(iprot);
156 this->__isset.io = true;
157 } else {
158 xfer += iprot->skip(ftype);
159 }
160 break;
161 default:
162 xfer += iprot->skip(ftype);
163 break;
164 }
165 xfer += iprot->readFieldEnd();
166 }
167
168 xfer += iprot->readStructEnd();
169
170 return xfer;
171 }
172
173 uint32_t Hbase_disableTable_args::read(::apache::thrift::protocol::TProtocol* iprot) {
174
175 uint32_t xfer = 0;
176 std::string fname;
177 ::apache::thrift::protocol::TType ftype;
178 int16_t fid;
179
180 xfer += iprot->readStructBegin(fname);
181
182 using ::apache::thrift::protocol::TProtocolException;
183
184
185 while (true)
186 {
187 xfer += iprot->readFieldBegin(fname, ftype, fid);
188 if (ftype == ::apache::thrift::protocol::T_STOP) {
189 break;
190 }
191 switch (fid)
192 {
193 case 1:
194 if (ftype == ::apache::thrift::protocol::T_STRING) {
195 xfer += iprot->readBinary(this->tableName);
196 this->__isset.tableName = true;
197 } else {
198 xfer += iprot->skip(ftype);
199 }
200 break;
201 default:
202 xfer += iprot->skip(ftype);
203 break;
204 }
205 xfer += iprot->readFieldEnd();
206 }
207
208 xfer += iprot->readStructEnd();
209
210 return xfer;
211 }
212
213 uint32_t Hbase_disableTable_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
214 uint32_t xfer = 0;
215 xfer += oprot->writeStructBegin("Hbase_disableTable_args");
216
217 xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
218 xfer += oprot->writeBinary(this->tableName);
219 xfer += oprot->writeFieldEnd();
220
221 xfer += oprot->writeFieldStop();
222 xfer += oprot->writeStructEnd();
223 return xfer;
224 }
225
226 uint32_t Hbase_disableTable_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
227 uint32_t xfer = 0;
228 xfer += oprot->writeStructBegin("Hbase_disableTable_pargs");
229
230 xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
231 xfer += oprot->writeBinary((*(this->tableName)));
232 xfer += oprot->writeFieldEnd();
233
234 xfer += oprot->writeFieldStop();
235 xfer += oprot->writeStructEnd();
236 return xfer;
237 }
238
239 uint32_t Hbase_disableTable_result::read(::apache::thrift::protocol::TProtocol* iprot) {
240
241 uint32_t xfer = 0;
242 std::string fname;
243 ::apache::thrift::protocol::TType ftype;
244 int16_t fid;
245
246 xfer += iprot->readStructBegin(fname);
247
248 using ::apache::thrift::protocol::TProtocolException;
249
250
251 while (true)
252 {
253 xfer += iprot->readFieldBegin(fname, ftype, fid);
254 if (ftype == ::apache::thrift::protocol::T_STOP) {
255 break;
256 }
257 switch (fid)
258 {
259 case 1:
260 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
261 xfer += this->io.read(iprot);
262 this->__isset.io = true;
263 } else {
264 xfer += iprot->skip(ftype);
265 }
266 break;
267 default:
268 xfer += iprot->skip(ftype);
269 break;
270 }
271 xfer += iprot->readFieldEnd();
272 }
273
274 xfer += iprot->readStructEnd();
275
276 return xfer;
277 }
278
279 uint32_t Hbase_disableTable_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
280
281 uint32_t xfer = 0;
282
283 xfer += oprot->writeStructBegin("Hbase_disableTable_result");
284
285 if (this->__isset.io) {
286 xfer += oprot->writeFieldBegin("io", ::apache::thrift::protocol::T_STRUCT, 1);
287 xfer += this->io.write(oprot);
288 xfer += oprot->writeFieldEnd();
289 }
290 xfer += oprot->writeFieldStop();
291 xfer += oprot->writeStructEnd();
292 return xfer;
293 }
294
295 uint32_t Hbase_disableTable_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
296
297 uint32_t xfer = 0;
298 std::string fname;
299 ::apache::thrift::protocol::TType ftype;
300 int16_t fid;
301
302 xfer += iprot->readStructBegin(fname);
303
304 using ::apache::thrift::protocol::TProtocolException;
305
306
307 while (true)
308 {
309 xfer += iprot->readFieldBegin(fname, ftype, fid);
310 if (ftype == ::apache::thrift::protocol::T_STOP) {
311 break;
312 }
313 switch (fid)
314 {
315 case 1:
316 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
317 xfer += this->io.read(iprot);
318 this->__isset.io = true;
319 } else {
320 xfer += iprot->skip(ftype);
321 }
322 break;
323 default:
324 xfer += iprot->skip(ftype);
325 break;
326 }
327 xfer += iprot->readFieldEnd();
328 }
329
330 xfer += iprot->readStructEnd();
331
332 return xfer;
333 }
334
335 uint32_t Hbase_isTableEnabled_args::read(::apache::thrift::protocol::TProtocol* iprot) {
336
337 uint32_t xfer = 0;
338 std::string fname;
339 ::apache::thrift::protocol::TType ftype;
340 int16_t fid;
341
342 xfer += iprot->readStructBegin(fname);
343
344 using ::apache::thrift::protocol::TProtocolException;
345
346
347 while (true)
348 {
349 xfer += iprot->readFieldBegin(fname, ftype, fid);
350 if (ftype == ::apache::thrift::protocol::T_STOP) {
351 break;
352 }
353 switch (fid)
354 {
355 case 1:
356 if (ftype == ::apache::thrift::protocol::T_STRING) {
357 xfer += iprot->readBinary(this->tableName);
358 this->__isset.tableName = true;
359 } else {
360 xfer += iprot->skip(ftype);
361 }
362 break;
363 default:
364 xfer += iprot->skip(ftype);
365 break;
366 }
367 xfer += iprot->readFieldEnd();
368 }
369
370 xfer += iprot->readStructEnd();
371
372 return xfer;
373 }
374
375 uint32_t Hbase_isTableEnabled_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
376 uint32_t xfer = 0;
377 xfer += oprot->writeStructBegin("Hbase_isTableEnabled_args");
378
379 xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
380 xfer += oprot->writeBinary(this->tableName);
381 xfer += oprot->writeFieldEnd();
382
383 xfer += oprot->writeFieldStop();
384 xfer += oprot->writeStructEnd();
385 return xfer;
386 }
387
388 uint32_t Hbase_isTableEnabled_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
389 uint32_t xfer = 0;
390 xfer += oprot->writeStructBegin("Hbase_isTableEnabled_pargs");
391
392 xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
393 xfer += oprot->writeBinary((*(this->tableName)));
394 xfer += oprot->writeFieldEnd();
395
396 xfer += oprot->writeFieldStop();
397 xfer += oprot->writeStructEnd();
398 return xfer;
399 }
400
401 uint32_t Hbase_isTableEnabled_result::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
413 while (true)
414 {
415 xfer += iprot->readFieldBegin(fname, ftype, fid);
416 if (ftype == ::apache::thrift::protocol::T_STOP) {
417 break;
418 }
419 switch (fid)
420 {
421 case 0:
422 if (ftype == ::apache::thrift::protocol::T_BOOL) {
423 xfer += iprot->readBool(this->success);
424 this->__isset.success = true;
425 } else {
426 xfer += iprot->skip(ftype);
427 }
428 break;
429 case 1:
430 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
431 xfer += this->io.read(iprot);
432 this->__isset.io = true;
433 } else {
434 xfer += iprot->skip(ftype);
435 }
436 break;
437 default:
438 xfer += iprot->skip(ftype);
439 break;
440 }
441 xfer += iprot->readFieldEnd();
442 }
443
444 xfer += iprot->readStructEnd();
445
446 return xfer;
447 }
448
449 uint32_t Hbase_isTableEnabled_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
450
451 uint32_t xfer = 0;
452
453 xfer += oprot->writeStructBegin("Hbase_isTableEnabled_result");
454
455 if (this->__isset.success) {
456 xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_BOOL, 0);
457 xfer += oprot->writeBool(this->success);
458 xfer += oprot->writeFieldEnd();
459 } else if (this->__isset.io) {
460 xfer += oprot->writeFieldBegin("io", ::apache::thrift::protocol::T_STRUCT, 1);
461 xfer += this->io.write(oprot);
462 xfer += oprot->writeFieldEnd();
463 }
464 xfer += oprot->writeFieldStop();
465 xfer += oprot->writeStructEnd();
466 return xfer;
467 }
468
469 uint32_t Hbase_isTableEnabled_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
470
471 uint32_t xfer = 0;
472 std::string fname;
473 ::apache::thrift::protocol::TType ftype;
474 int16_t fid;
475
476 xfer += iprot->readStructBegin(fname);
477
478 using ::apache::thrift::protocol::TProtocolException;
479
480
481 while (true)
482 {
483 xfer += iprot->readFieldBegin(fname, ftype, fid);
484 if (ftype == ::apache::thrift::protocol::T_STOP) {
485 break;
486 }
487 switch (fid)
488 {
489 case 0:
490 if (ftype == ::apache::thrift::protocol::T_BOOL) {
491 xfer += iprot->readBool((*(this->success)));
492 this->__isset.success = true;
493 } else {
494 xfer += iprot->skip(ftype);
495 }
496 break;
497 case 1:
498 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
499 xfer += this->io.read(iprot);
500 this->__isset.io = true;
501 } else {
502 xfer += iprot->skip(ftype);
503 }
504 break;
505 default:
506 xfer += iprot->skip(ftype);
507 break;
508 }
509 xfer += iprot->readFieldEnd();
510 }
511
512 xfer += iprot->readStructEnd();
513
514 return xfer;
515 }
516
517 uint32_t Hbase_compact_args::read(::apache::thrift::protocol::TProtocol* iprot) {
518
519 uint32_t xfer = 0;
520 std::string fname;
521 ::apache::thrift::protocol::TType ftype;
522 int16_t fid;
523
524 xfer += iprot->readStructBegin(fname);
525
526 using ::apache::thrift::protocol::TProtocolException;
527
528
529 while (true)
530 {
531 xfer += iprot->readFieldBegin(fname, ftype, fid);
532 if (ftype == ::apache::thrift::protocol::T_STOP) {
533 break;
534 }
535 switch (fid)
536 {
537 case 1:
538 if (ftype == ::apache::thrift::protocol::T_STRING) {
539 xfer += iprot->readBinary(this->tableNameOrRegionName);
540 this->__isset.tableNameOrRegionName = true;
541 } else {
542 xfer += iprot->skip(ftype);
543 }
544 break;
545 default:
546 xfer += iprot->skip(ftype);
547 break;
548 }
549 xfer += iprot->readFieldEnd();
550 }
551
552 xfer += iprot->readStructEnd();
553
554 return xfer;
555 }
556
557 uint32_t Hbase_compact_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
558 uint32_t xfer = 0;
559 xfer += oprot->writeStructBegin("Hbase_compact_args");
560
561 xfer += oprot->writeFieldBegin("tableNameOrRegionName", ::apache::thrift::protocol::T_STRING, 1);
562 xfer += oprot->writeBinary(this->tableNameOrRegionName);
563 xfer += oprot->writeFieldEnd();
564
565 xfer += oprot->writeFieldStop();
566 xfer += oprot->writeStructEnd();
567 return xfer;
568 }
569
570 uint32_t Hbase_compact_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
571 uint32_t xfer = 0;
572 xfer += oprot->writeStructBegin("Hbase_compact_pargs");
573
574 xfer += oprot->writeFieldBegin("tableNameOrRegionName", ::apache::thrift::protocol::T_STRING, 1);
575 xfer += oprot->writeBinary((*(this->tableNameOrRegionName)));
576 xfer += oprot->writeFieldEnd();
577
578 xfer += oprot->writeFieldStop();
579 xfer += oprot->writeStructEnd();
580 return xfer;
581 }
582
583 uint32_t Hbase_compact_result::read(::apache::thrift::protocol::TProtocol* iprot) {
584
585 uint32_t xfer = 0;
586 std::string fname;
587 ::apache::thrift::protocol::TType ftype;
588 int16_t fid;
589
590 xfer += iprot->readStructBegin(fname);
591
592 using ::apache::thrift::protocol::TProtocolException;
593
594
595 while (true)
596 {
597 xfer += iprot->readFieldBegin(fname, ftype, fid);
598 if (ftype == ::apache::thrift::protocol::T_STOP) {
599 break;
600 }
601 switch (fid)
602 {
603 case 1:
604 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
605 xfer += this->io.read(iprot);
606 this->__isset.io = true;
607 } else {
608 xfer += iprot->skip(ftype);
609 }
610 break;
611 default:
612 xfer += iprot->skip(ftype);
613 break;
614 }
615 xfer += iprot->readFieldEnd();
616 }
617
618 xfer += iprot->readStructEnd();
619
620 return xfer;
621 }
622
623 uint32_t Hbase_compact_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
624
625 uint32_t xfer = 0;
626
627 xfer += oprot->writeStructBegin("Hbase_compact_result");
628
629 if (this->__isset.io) {
630 xfer += oprot->writeFieldBegin("io", ::apache::thrift::protocol::T_STRUCT, 1);
631 xfer += this->io.write(oprot);
632 xfer += oprot->writeFieldEnd();
633 }
634 xfer += oprot->writeFieldStop();
635 xfer += oprot->writeStructEnd();
636 return xfer;
637 }
638
639 uint32_t Hbase_compact_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
640
641 uint32_t xfer = 0;
642 std::string fname;
643 ::apache::thrift::protocol::TType ftype;
644 int16_t fid;
645
646 xfer += iprot->readStructBegin(fname);
647
648 using ::apache::thrift::protocol::TProtocolException;
649
650
651 while (true)
652 {
653 xfer += iprot->readFieldBegin(fname, ftype, fid);
654 if (ftype == ::apache::thrift::protocol::T_STOP) {
655 break;
656 }
657 switch (fid)
658 {
659 case 1:
660 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
661 xfer += this->io.read(iprot);
662 this->__isset.io = true;
663 } else {
664 xfer += iprot->skip(ftype);
665 }
666 break;
667 default:
668 xfer += iprot->skip(ftype);
669 break;
670 }
671 xfer += iprot->readFieldEnd();
672 }
673
674 xfer += iprot->readStructEnd();
675
676 return xfer;
677 }
678
679 uint32_t Hbase_majorCompact_args::read(::apache::thrift::protocol::TProtocol* iprot) {
680
681 uint32_t xfer = 0;
682 std::string fname;
683 ::apache::thrift::protocol::TType ftype;
684 int16_t fid;
685
686 xfer += iprot->readStructBegin(fname);
687
688 using ::apache::thrift::protocol::TProtocolException;
689
690
691 while (true)
692 {
693 xfer += iprot->readFieldBegin(fname, ftype, fid);
694 if (ftype == ::apache::thrift::protocol::T_STOP) {
695 break;
696 }
697 switch (fid)
698 {
699 case 1:
700 if (ftype == ::apache::thrift::protocol::T_STRING) {
701 xfer += iprot->readBinary(this->tableNameOrRegionName);
702 this->__isset.tableNameOrRegionName = true;
703 } else {
704 xfer += iprot->skip(ftype);
705 }
706 break;
707 default:
708 xfer += iprot->skip(ftype);
709 break;
710 }
711 xfer += iprot->readFieldEnd();
712 }
713
714 xfer += iprot->readStructEnd();
715
716 return xfer;
717 }
718
719 uint32_t Hbase_majorCompact_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
720 uint32_t xfer = 0;
721 xfer += oprot->writeStructBegin("Hbase_majorCompact_args");
722
723 xfer += oprot->writeFieldBegin("tableNameOrRegionName", ::apache::thrift::protocol::T_STRING, 1);
724 xfer += oprot->writeBinary(this->tableNameOrRegionName);
725 xfer += oprot->writeFieldEnd();
726
727 xfer += oprot->writeFieldStop();
728 xfer += oprot->writeStructEnd();
729 return xfer;
730 }
731
732 uint32_t Hbase_majorCompact_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
733 uint32_t xfer = 0;
734 xfer += oprot->writeStructBegin("Hbase_majorCompact_pargs");
735
736 xfer += oprot->writeFieldBegin("tableNameOrRegionName", ::apache::thrift::protocol::T_STRING, 1);
737 xfer += oprot->writeBinary((*(this->tableNameOrRegionName)));
738 xfer += oprot->writeFieldEnd();
739
740 xfer += oprot->writeFieldStop();
741 xfer += oprot->writeStructEnd();
742 return xfer;
743 }
744
745 uint32_t Hbase_majorCompact_result::read(::apache::thrift::protocol::TProtocol* iprot) {
746
747 uint32_t xfer = 0;
748 std::string fname;
749 ::apache::thrift::protocol::TType ftype;
750 int16_t fid;
751
752 xfer += iprot->readStructBegin(fname);
753
754 using ::apache::thrift::protocol::TProtocolException;
755
756
757 while (true)
758 {
759 xfer += iprot->readFieldBegin(fname, ftype, fid);
760 if (ftype == ::apache::thrift::protocol::T_STOP) {
761 break;
762 }
763 switch (fid)
764 {
765 case 1:
766 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
767 xfer += this->io.read(iprot);
768 this->__isset.io = true;
769 } else {
770 xfer += iprot->skip(ftype);
771 }
772 break;
773 default:
774 xfer += iprot->skip(ftype);
775 break;
776 }
777 xfer += iprot->readFieldEnd();
778 }
779
780 xfer += iprot->readStructEnd();
781
782 return xfer;
783 }
784
785 uint32_t Hbase_majorCompact_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
786
787 uint32_t xfer = 0;
788
789 xfer += oprot->writeStructBegin("Hbase_majorCompact_result");
790
791 if (this->__isset.io) {
792 xfer += oprot->writeFieldBegin("io", ::apache::thrift::protocol::T_STRUCT, 1);
793 xfer += this->io.write(oprot);
794 xfer += oprot->writeFieldEnd();
795 }
796 xfer += oprot->writeFieldStop();
797 xfer += oprot->writeStructEnd();
798 return xfer;
799 }
800
801 uint32_t Hbase_majorCompact_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
802
803 uint32_t xfer = 0;
804 std::string fname;
805 ::apache::thrift::protocol::TType ftype;
806 int16_t fid;
807
808 xfer += iprot->readStructBegin(fname);
809
810 using ::apache::thrift::protocol::TProtocolException;
811
812
813 while (true)
814 {
815 xfer += iprot->readFieldBegin(fname, ftype, fid);
816 if (ftype == ::apache::thrift::protocol::T_STOP) {
817 break;
818 }
819 switch (fid)
820 {
821 case 1:
822 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
823 xfer += this->io.read(iprot);
824 this->__isset.io = true;
825 } else {
826 xfer += iprot->skip(ftype);
827 }
828 break;
829 default:
830 xfer += iprot->skip(ftype);
831 break;
832 }
833 xfer += iprot->readFieldEnd();
834 }
835
836 xfer += iprot->readStructEnd();
837
838 return xfer;
839 }
840
841 uint32_t Hbase_getTableNames_args::read(::apache::thrift::protocol::TProtocol* iprot) {
842
843 uint32_t xfer = 0;
844 std::string fname;
845 ::apache::thrift::protocol::TType ftype;
846 int16_t fid;
847
848 xfer += iprot->readStructBegin(fname);
849
850 using ::apache::thrift::protocol::TProtocolException;
851
852
853 while (true)
854 {
855 xfer += iprot->readFieldBegin(fname, ftype, fid);
856 if (ftype == ::apache::thrift::protocol::T_STOP) {
857 break;
858 }
859 xfer += iprot->skip(ftype);
860 xfer += iprot->readFieldEnd();
861 }
862
863 xfer += iprot->readStructEnd();
864
865 return xfer;
866 }
867
868 uint32_t Hbase_getTableNames_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
869 uint32_t xfer = 0;
870 xfer += oprot->writeStructBegin("Hbase_getTableNames_args");
871
872 xfer += oprot->writeFieldStop();
873 xfer += oprot->writeStructEnd();
874 return xfer;
875 }
876
877 uint32_t Hbase_getTableNames_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
878 uint32_t xfer = 0;
879 xfer += oprot->writeStructBegin("Hbase_getTableNames_pargs");
880
881 xfer += oprot->writeFieldStop();
882 xfer += oprot->writeStructEnd();
883 return xfer;
884 }
885
886 uint32_t Hbase_getTableNames_result::read(::apache::thrift::protocol::TProtocol* iprot) {
887
888 uint32_t xfer = 0;
889 std::string fname;
890 ::apache::thrift::protocol::TType ftype;
891 int16_t fid;
892
893 xfer += iprot->readStructBegin(fname);
894
895 using ::apache::thrift::protocol::TProtocolException;
896
897
898 while (true)
899 {
900 xfer += iprot->readFieldBegin(fname, ftype, fid);
901 if (ftype == ::apache::thrift::protocol::T_STOP) {
902 break;
903 }
904 switch (fid)
905 {
906 case 0:
907 if (ftype == ::apache::thrift::protocol::T_LIST) {
908 {
909 this->success.clear();
910 uint32_t _size20;
911 ::apache::thrift::protocol::TType _etype23;
912 xfer += iprot->readListBegin(_etype23, _size20);
913 this->success.resize(_size20);
914 uint32_t _i24;
915 for (_i24 = 0; _i24 < _size20; ++_i24)
916 {
917 xfer += iprot->readBinary(this->success[_i24]);
918 }
919 xfer += iprot->readListEnd();
920 }
921 this->__isset.success = true;
922 } else {
923 xfer += iprot->skip(ftype);
924 }
925 break;
926 case 1:
927 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
928 xfer += this->io.read(iprot);
929 this->__isset.io = true;
930 } else {
931 xfer += iprot->skip(ftype);
932 }
933 break;
934 default:
935 xfer += iprot->skip(ftype);
936 break;
937 }
938 xfer += iprot->readFieldEnd();
939 }
940
941 xfer += iprot->readStructEnd();
942
943 return xfer;
944 }
945
946 uint32_t Hbase_getTableNames_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
947
948 uint32_t xfer = 0;
949
950 xfer += oprot->writeStructBegin("Hbase_getTableNames_result");
951
952 if (this->__isset.success) {
953 xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0);
954 {
955 xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->success.size()));
956 std::vector<Text> ::const_iterator _iter25;
957 for (_iter25 = this->success.begin(); _iter25 != this->success.end(); ++_iter25)
958 {
959 xfer += oprot->writeBinary((*_iter25));
960 }
961 xfer += oprot->writeListEnd();
962 }
963 xfer += oprot->writeFieldEnd();
964 } else if (this->__isset.io) {
965 xfer += oprot->writeFieldBegin("io", ::apache::thrift::protocol::T_STRUCT, 1);
966 xfer += this->io.write(oprot);
967 xfer += oprot->writeFieldEnd();
968 }
969 xfer += oprot->writeFieldStop();
970 xfer += oprot->writeStructEnd();
971 return xfer;
972 }
973
974 uint32_t Hbase_getTableNames_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
975
976 uint32_t xfer = 0;
977 std::string fname;
978 ::apache::thrift::protocol::TType ftype;
979 int16_t fid;
980
981 xfer += iprot->readStructBegin(fname);
982
983 using ::apache::thrift::protocol::TProtocolException;
984
985
986 while (true)
987 {
988 xfer += iprot->readFieldBegin(fname, ftype, fid);
989 if (ftype == ::apache::thrift::protocol::T_STOP) {
990 break;
991 }
992 switch (fid)
993 {
994 case 0:
995 if (ftype == ::apache::thrift::protocol::T_LIST) {
996 {
997 (*(this->success)).clear();
998 uint32_t _size26;
999 ::apache::thrift::protocol::TType _etype29;
1000 xfer += iprot->readListBegin(_etype29, _size26);
1001 (*(this->success)).resize(_size26);
1002 uint32_t _i30;
1003 for (_i30 = 0; _i30 < _size26; ++_i30)
1004 {
1005 xfer += iprot->readBinary((*(this->success))[_i30]);
1006 }
1007 xfer += iprot->readListEnd();
1008 }
1009 this->__isset.success = true;
1010 } else {
1011 xfer += iprot->skip(ftype);
1012 }
1013 break;
1014 case 1:
1015 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
1016 xfer += this->io.read(iprot);
1017 this->__isset.io = true;
1018 } else {
1019 xfer += iprot->skip(ftype);
1020 }
1021 break;
1022 default:
1023 xfer += iprot->skip(ftype);
1024 break;
1025 }
1026 xfer += iprot->readFieldEnd();
1027 }
1028
1029 xfer += iprot->readStructEnd();
1030
1031 return xfer;
1032 }
1033
1034 uint32_t Hbase_getColumnDescriptors_args::read(::apache::thrift::protocol::TProtocol* iprot) {
1035
1036 uint32_t xfer = 0;
1037 std::string fname;
1038 ::apache::thrift::protocol::TType ftype;
1039 int16_t fid;
1040
1041 xfer += iprot->readStructBegin(fname);
1042
1043 using ::apache::thrift::protocol::TProtocolException;
1044
1045
1046 while (true)
1047 {
1048 xfer += iprot->readFieldBegin(fname, ftype, fid);
1049 if (ftype == ::apache::thrift::protocol::T_STOP) {
1050 break;
1051 }
1052 switch (fid)
1053 {
1054 case 1:
1055 if (ftype == ::apache::thrift::protocol::T_STRING) {
1056 xfer += iprot->readBinary(this->tableName);
1057 this->__isset.tableName = true;
1058 } else {
1059 xfer += iprot->skip(ftype);
1060 }
1061 break;
1062 default:
1063 xfer += iprot->skip(ftype);
1064 break;
1065 }
1066 xfer += iprot->readFieldEnd();
1067 }
1068
1069 xfer += iprot->readStructEnd();
1070
1071 return xfer;
1072 }
1073
1074 uint32_t Hbase_getColumnDescriptors_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
1075 uint32_t xfer = 0;
1076 xfer += oprot->writeStructBegin("Hbase_getColumnDescriptors_args");
1077
1078 xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
1079 xfer += oprot->writeBinary(this->tableName);
1080 xfer += oprot->writeFieldEnd();
1081
1082 xfer += oprot->writeFieldStop();
1083 xfer += oprot->writeStructEnd();
1084 return xfer;
1085 }
1086
1087 uint32_t Hbase_getColumnDescriptors_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
1088 uint32_t xfer = 0;
1089 xfer += oprot->writeStructBegin("Hbase_getColumnDescriptors_pargs");
1090
1091 xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
1092 xfer += oprot->writeBinary((*(this->tableName)));
1093 xfer += oprot->writeFieldEnd();
1094
1095 xfer += oprot->writeFieldStop();
1096 xfer += oprot->writeStructEnd();
1097 return xfer;
1098 }
1099
1100 uint32_t Hbase_getColumnDescriptors_result::read(::apache::thrift::protocol::TProtocol* iprot) {
1101
1102 uint32_t xfer = 0;
1103 std::string fname;
1104 ::apache::thrift::protocol::TType ftype;
1105 int16_t fid;
1106
1107 xfer += iprot->readStructBegin(fname);
1108
1109 using ::apache::thrift::protocol::TProtocolException;
1110
1111
1112 while (true)
1113 {
1114 xfer += iprot->readFieldBegin(fname, ftype, fid);
1115 if (ftype == ::apache::thrift::protocol::T_STOP) {
1116 break;
1117 }
1118 switch (fid)
1119 {
1120 case 0:
1121 if (ftype == ::apache::thrift::protocol::T_MAP) {
1122 {
1123 this->success.clear();
1124 uint32_t _size31;
1125 ::apache::thrift::protocol::TType _ktype32;
1126 ::apache::thrift::protocol::TType _vtype33;
1127 xfer += iprot->readMapBegin(_ktype32, _vtype33, _size31);
1128 uint32_t _i35;
1129 for (_i35 = 0; _i35 < _size31; ++_i35)
1130 {
1131 Text _key36;
1132 xfer += iprot->readBinary(_key36);
1133 ColumnDescriptor& _val37 = this->success[_key36];
1134 xfer += _val37.read(iprot);
1135 }
1136 xfer += iprot->readMapEnd();
1137 }
1138 this->__isset.success = true;
1139 } else {
1140 xfer += iprot->skip(ftype);
1141 }
1142 break;
1143 case 1:
1144 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
1145 xfer += this->io.read(iprot);
1146 this->__isset.io = true;
1147 } else {
1148 xfer += iprot->skip(ftype);
1149 }
1150 break;
1151 default:
1152 xfer += iprot->skip(ftype);
1153 break;
1154 }
1155 xfer += iprot->readFieldEnd();
1156 }
1157
1158 xfer += iprot->readStructEnd();
1159
1160 return xfer;
1161 }
1162
1163 uint32_t Hbase_getColumnDescriptors_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
1164
1165 uint32_t xfer = 0;
1166
1167 xfer += oprot->writeStructBegin("Hbase_getColumnDescriptors_result");
1168
1169 if (this->__isset.success) {
1170 xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_MAP, 0);
1171 {
1172 xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->success.size()));
1173 std::map<Text, ColumnDescriptor> ::const_iterator _iter38;
1174 for (_iter38 = this->success.begin(); _iter38 != this->success.end(); ++_iter38)
1175 {
1176 xfer += oprot->writeBinary(_iter38->first);
1177 xfer += _iter38->second.write(oprot);
1178 }
1179 xfer += oprot->writeMapEnd();
1180 }
1181 xfer += oprot->writeFieldEnd();
1182 } else if (this->__isset.io) {
1183 xfer += oprot->writeFieldBegin("io", ::apache::thrift::protocol::T_STRUCT, 1);
1184 xfer += this->io.write(oprot);
1185 xfer += oprot->writeFieldEnd();
1186 }
1187 xfer += oprot->writeFieldStop();
1188 xfer += oprot->writeStructEnd();
1189 return xfer;
1190 }
1191
1192 uint32_t Hbase_getColumnDescriptors_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
1193
1194 uint32_t xfer = 0;
1195 std::string fname;
1196 ::apache::thrift::protocol::TType ftype;
1197 int16_t fid;
1198
1199 xfer += iprot->readStructBegin(fname);
1200
1201 using ::apache::thrift::protocol::TProtocolException;
1202
1203
1204 while (true)
1205 {
1206 xfer += iprot->readFieldBegin(fname, ftype, fid);
1207 if (ftype == ::apache::thrift::protocol::T_STOP) {
1208 break;
1209 }
1210 switch (fid)
1211 {
1212 case 0:
1213 if (ftype == ::apache::thrift::protocol::T_MAP) {
1214 {
1215 (*(this->success)).clear();
1216 uint32_t _size39;
1217 ::apache::thrift::protocol::TType _ktype40;
1218 ::apache::thrift::protocol::TType _vtype41;
1219 xfer += iprot->readMapBegin(_ktype40, _vtype41, _size39);
1220 uint32_t _i43;
1221 for (_i43 = 0; _i43 < _size39; ++_i43)
1222 {
1223 Text _key44;
1224 xfer += iprot->readBinary(_key44);
1225 ColumnDescriptor& _val45 = (*(this->success))[_key44];
1226 xfer += _val45.read(iprot);
1227 }
1228 xfer += iprot->readMapEnd();
1229 }
1230 this->__isset.success = true;
1231 } else {
1232 xfer += iprot->skip(ftype);
1233 }
1234 break;
1235 case 1:
1236 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
1237 xfer += this->io.read(iprot);
1238 this->__isset.io = true;
1239 } else {
1240 xfer += iprot->skip(ftype);
1241 }
1242 break;
1243 default:
1244 xfer += iprot->skip(ftype);
1245 break;
1246 }
1247 xfer += iprot->readFieldEnd();
1248 }
1249
1250 xfer += iprot->readStructEnd();
1251
1252 return xfer;
1253 }
1254
1255 uint32_t Hbase_getTableRegions_args::read(::apache::thrift::protocol::TProtocol* iprot) {
1256
1257 uint32_t xfer = 0;
1258 std::string fname;
1259 ::apache::thrift::protocol::TType ftype;
1260 int16_t fid;
1261
1262 xfer += iprot->readStructBegin(fname);
1263
1264 using ::apache::thrift::protocol::TProtocolException;
1265
1266
1267 while (true)
1268 {
1269 xfer += iprot->readFieldBegin(fname, ftype, fid);
1270 if (ftype == ::apache::thrift::protocol::T_STOP) {
1271 break;
1272 }
1273 switch (fid)
1274 {
1275 case 1:
1276 if (ftype == ::apache::thrift::protocol::T_STRING) {
1277 xfer += iprot->readBinary(this->tableName);
1278 this->__isset.tableName = true;
1279 } else {
1280 xfer += iprot->skip(ftype);
1281 }
1282 break;
1283 default:
1284 xfer += iprot->skip(ftype);
1285 break;
1286 }
1287 xfer += iprot->readFieldEnd();
1288 }
1289
1290 xfer += iprot->readStructEnd();
1291
1292 return xfer;
1293 }
1294
1295 uint32_t Hbase_getTableRegions_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
1296 uint32_t xfer = 0;
1297 xfer += oprot->writeStructBegin("Hbase_getTableRegions_args");
1298
1299 xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
1300 xfer += oprot->writeBinary(this->tableName);
1301 xfer += oprot->writeFieldEnd();
1302
1303 xfer += oprot->writeFieldStop();
1304 xfer += oprot->writeStructEnd();
1305 return xfer;
1306 }
1307
1308 uint32_t Hbase_getTableRegions_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
1309 uint32_t xfer = 0;
1310 xfer += oprot->writeStructBegin("Hbase_getTableRegions_pargs");
1311
1312 xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
1313 xfer += oprot->writeBinary((*(this->tableName)));
1314 xfer += oprot->writeFieldEnd();
1315
1316 xfer += oprot->writeFieldStop();
1317 xfer += oprot->writeStructEnd();
1318 return xfer;
1319 }
1320
1321 uint32_t Hbase_getTableRegions_result::read(::apache::thrift::protocol::TProtocol* iprot) {
1322
1323 uint32_t xfer = 0;
1324 std::string fname;
1325 ::apache::thrift::protocol::TType ftype;
1326 int16_t fid;
1327
1328 xfer += iprot->readStructBegin(fname);
1329
1330 using ::apache::thrift::protocol::TProtocolException;
1331
1332
1333 while (true)
1334 {
1335 xfer += iprot->readFieldBegin(fname, ftype, fid);
1336 if (ftype == ::apache::thrift::protocol::T_STOP) {
1337 break;
1338 }
1339 switch (fid)
1340 {
1341 case 0:
1342 if (ftype == ::apache::thrift::protocol::T_LIST) {
1343 {
1344 this->success.clear();
1345 uint32_t _size46;
1346 ::apache::thrift::protocol::TType _etype49;
1347 xfer += iprot->readListBegin(_etype49, _size46);
1348 this->success.resize(_size46);
1349 uint32_t _i50;
1350 for (_i50 = 0; _i50 < _size46; ++_i50)
1351 {
1352 xfer += this->success[_i50].read(iprot);
1353 }
1354 xfer += iprot->readListEnd();
1355 }
1356 this->__isset.success = true;
1357 } else {
1358 xfer += iprot->skip(ftype);
1359 }
1360 break;
1361 case 1:
1362 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
1363 xfer += this->io.read(iprot);
1364 this->__isset.io = true;
1365 } else {
1366 xfer += iprot->skip(ftype);
1367 }
1368 break;
1369 default:
1370 xfer += iprot->skip(ftype);
1371 break;
1372 }
1373 xfer += iprot->readFieldEnd();
1374 }
1375
1376 xfer += iprot->readStructEnd();
1377
1378 return xfer;
1379 }
1380
1381 uint32_t Hbase_getTableRegions_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
1382
1383 uint32_t xfer = 0;
1384
1385 xfer += oprot->writeStructBegin("Hbase_getTableRegions_result");
1386
1387 if (this->__isset.success) {
1388 xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0);
1389 {
1390 xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->success.size()));
1391 std::vector<TRegionInfo> ::const_iterator _iter51;
1392 for (_iter51 = this->success.begin(); _iter51 != this->success.end(); ++_iter51)
1393 {
1394 xfer += (*_iter51).write(oprot);
1395 }
1396 xfer += oprot->writeListEnd();
1397 }
1398 xfer += oprot->writeFieldEnd();
1399 } else if (this->__isset.io) {
1400 xfer += oprot->writeFieldBegin("io", ::apache::thrift::protocol::T_STRUCT, 1);
1401 xfer += this->io.write(oprot);
1402 xfer += oprot->writeFieldEnd();
1403 }
1404 xfer += oprot->writeFieldStop();
1405 xfer += oprot->writeStructEnd();
1406 return xfer;
1407 }
1408
1409 uint32_t Hbase_getTableRegions_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
1410
1411 uint32_t xfer = 0;
1412 std::string fname;
1413 ::apache::thrift::protocol::TType ftype;
1414 int16_t fid;
1415
1416 xfer += iprot->readStructBegin(fname);
1417
1418 using ::apache::thrift::protocol::TProtocolException;
1419
1420
1421 while (true)
1422 {
1423 xfer += iprot->readFieldBegin(fname, ftype, fid);
1424 if (ftype == ::apache::thrift::protocol::T_STOP) {
1425 break;
1426 }
1427 switch (fid)
1428 {
1429 case 0:
1430 if (ftype == ::apache::thrift::protocol::T_LIST) {
1431 {
1432 (*(this->success)).clear();
1433 uint32_t _size52;
1434 ::apache::thrift::protocol::TType _etype55;
1435 xfer += iprot->readListBegin(_etype55, _size52);
1436 (*(this->success)).resize(_size52);
1437 uint32_t _i56;
1438 for (_i56 = 0; _i56 < _size52; ++_i56)
1439 {
1440 xfer += (*(this->success))[_i56].read(iprot);
1441 }
1442 xfer += iprot->readListEnd();
1443 }
1444 this->__isset.success = true;
1445 } else {
1446 xfer += iprot->skip(ftype);
1447 }
1448 break;
1449 case 1:
1450 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
1451 xfer += this->io.read(iprot);
1452 this->__isset.io = true;
1453 } else {
1454 xfer += iprot->skip(ftype);
1455 }
1456 break;
1457 default:
1458 xfer += iprot->skip(ftype);
1459 break;
1460 }
1461 xfer += iprot->readFieldEnd();
1462 }
1463
1464 xfer += iprot->readStructEnd();
1465
1466 return xfer;
1467 }
1468
1469 uint32_t Hbase_createTable_args::read(::apache::thrift::protocol::TProtocol* iprot) {
1470
1471 uint32_t xfer = 0;
1472 std::string fname;
1473 ::apache::thrift::protocol::TType ftype;
1474 int16_t fid;
1475
1476 xfer += iprot->readStructBegin(fname);
1477
1478 using ::apache::thrift::protocol::TProtocolException;
1479
1480
1481 while (true)
1482 {
1483 xfer += iprot->readFieldBegin(fname, ftype, fid);
1484 if (ftype == ::apache::thrift::protocol::T_STOP) {
1485 break;
1486 }
1487 switch (fid)
1488 {
1489 case 1:
1490 if (ftype == ::apache::thrift::protocol::T_STRING) {
1491 xfer += iprot->readBinary(this->tableName);
1492 this->__isset.tableName = true;
1493 } else {
1494 xfer += iprot->skip(ftype);
1495 }
1496 break;
1497 case 2:
1498 if (ftype == ::apache::thrift::protocol::T_LIST) {
1499 {
1500 this->columnFamilies.clear();
1501 uint32_t _size57;
1502 ::apache::thrift::protocol::TType _etype60;
1503 xfer += iprot->readListBegin(_etype60, _size57);
1504 this->columnFamilies.resize(_size57);
1505 uint32_t _i61;
1506 for (_i61 = 0; _i61 < _size57; ++_i61)
1507 {
1508 xfer += this->columnFamilies[_i61].read(iprot);
1509 }
1510 xfer += iprot->readListEnd();
1511 }
1512 this->__isset.columnFamilies = true;
1513 } else {
1514 xfer += iprot->skip(ftype);
1515 }
1516 break;
1517 default:
1518 xfer += iprot->skip(ftype);
1519 break;
1520 }
1521 xfer += iprot->readFieldEnd();
1522 }
1523
1524 xfer += iprot->readStructEnd();
1525
1526 return xfer;
1527 }
1528
1529 uint32_t Hbase_createTable_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
1530 uint32_t xfer = 0;
1531 xfer += oprot->writeStructBegin("Hbase_createTable_args");
1532
1533 xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
1534 xfer += oprot->writeBinary(this->tableName);
1535 xfer += oprot->writeFieldEnd();
1536
1537 xfer += oprot->writeFieldBegin("columnFamilies", ::apache::thrift::protocol::T_LIST, 2);
1538 {
1539 xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->columnFamilies.size()));
1540 std::vector<ColumnDescriptor> ::const_iterator _iter62;
1541 for (_iter62 = this->columnFamilies.begin(); _iter62 != this->columnFamilies.end(); ++_iter62)
1542 {
1543 xfer += (*_iter62).write(oprot);
1544 }
1545 xfer += oprot->writeListEnd();
1546 }
1547 xfer += oprot->writeFieldEnd();
1548
1549 xfer += oprot->writeFieldStop();
1550 xfer += oprot->writeStructEnd();
1551 return xfer;
1552 }
1553
1554 uint32_t Hbase_createTable_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
1555 uint32_t xfer = 0;
1556 xfer += oprot->writeStructBegin("Hbase_createTable_pargs");
1557
1558 xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
1559 xfer += oprot->writeBinary((*(this->tableName)));
1560 xfer += oprot->writeFieldEnd();
1561
1562 xfer += oprot->writeFieldBegin("columnFamilies", ::apache::thrift::protocol::T_LIST, 2);
1563 {
1564 xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>((*(this->columnFamilies)).size()));
1565 std::vector<ColumnDescriptor> ::const_iterator _iter63;
1566 for (_iter63 = (*(this->columnFamilies)).begin(); _iter63 != (*(this->columnFamilies)).end(); ++_iter63)
1567 {
1568 xfer += (*_iter63).write(oprot);
1569 }
1570 xfer += oprot->writeListEnd();
1571 }
1572 xfer += oprot->writeFieldEnd();
1573
1574 xfer += oprot->writeFieldStop();
1575 xfer += oprot->writeStructEnd();
1576 return xfer;
1577 }
1578
1579 uint32_t Hbase_createTable_result::read(::apache::thrift::protocol::TProtocol* iprot) {
1580
1581 uint32_t xfer = 0;
1582 std::string fname;
1583 ::apache::thrift::protocol::TType ftype;
1584 int16_t fid;
1585
1586 xfer += iprot->readStructBegin(fname);
1587
1588 using ::apache::thrift::protocol::TProtocolException;
1589
1590
1591 while (true)
1592 {
1593 xfer += iprot->readFieldBegin(fname, ftype, fid);
1594 if (ftype == ::apache::thrift::protocol::T_STOP) {
1595 break;
1596 }
1597 switch (fid)
1598 {
1599 case 1:
1600 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
1601 xfer += this->io.read(iprot);
1602 this->__isset.io = true;
1603 } else {
1604 xfer += iprot->skip(ftype);
1605 }
1606 break;
1607 case 2:
1608 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
1609 xfer += this->ia.read(iprot);
1610 this->__isset.ia = true;
1611 } else {
1612 xfer += iprot->skip(ftype);
1613 }
1614 break;
1615 case 3:
1616 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
1617 xfer += this->exist.read(iprot);
1618 this->__isset.exist = true;
1619 } else {
1620 xfer += iprot->skip(ftype);
1621 }
1622 break;
1623 default:
1624 xfer += iprot->skip(ftype);
1625 break;
1626 }
1627 xfer += iprot->readFieldEnd();
1628 }
1629
1630 xfer += iprot->readStructEnd();
1631
1632 return xfer;
1633 }
1634
1635 uint32_t Hbase_createTable_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
1636
1637 uint32_t xfer = 0;
1638
1639 xfer += oprot->writeStructBegin("Hbase_createTable_result");
1640
1641 if (this->__isset.io) {
1642 xfer += oprot->writeFieldBegin("io", ::apache::thrift::protocol::T_STRUCT, 1);
1643 xfer += this->io.write(oprot);
1644 xfer += oprot->writeFieldEnd();
1645 } else if (this->__isset.ia) {
1646 xfer += oprot->writeFieldBegin("ia", ::apache::thrift::protocol::T_STRUCT, 2);
1647 xfer += this->ia.write(oprot);
1648 xfer += oprot->writeFieldEnd();
1649 } else if (this->__isset.exist) {
1650 xfer += oprot->writeFieldBegin("exist", ::apache::thrift::protocol::T_STRUCT, 3);
1651 xfer += this->exist.write(oprot);
1652 xfer += oprot->writeFieldEnd();
1653 }
1654 xfer += oprot->writeFieldStop();
1655 xfer += oprot->writeStructEnd();
1656 return xfer;
1657 }
1658
1659 uint32_t Hbase_createTable_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
1660
1661 uint32_t xfer = 0;
1662 std::string fname;
1663 ::apache::thrift::protocol::TType ftype;
1664 int16_t fid;
1665
1666 xfer += iprot->readStructBegin(fname);
1667
1668 using ::apache::thrift::protocol::TProtocolException;
1669
1670
1671 while (true)
1672 {
1673 xfer += iprot->readFieldBegin(fname, ftype, fid);
1674 if (ftype == ::apache::thrift::protocol::T_STOP) {
1675 break;
1676 }
1677 switch (fid)
1678 {
1679 case 1:
1680 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
1681 xfer += this->io.read(iprot);
1682 this->__isset.io = true;
1683 } else {
1684 xfer += iprot->skip(ftype);
1685 }
1686 break;
1687 case 2:
1688 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
1689 xfer += this->ia.read(iprot);
1690 this->__isset.ia = true;
1691 } else {
1692 xfer += iprot->skip(ftype);
1693 }
1694 break;
1695 case 3:
1696 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
1697 xfer += this->exist.read(iprot);
1698 this->__isset.exist = true;
1699 } else {
1700 xfer += iprot->skip(ftype);
1701 }
1702 break;
1703 default:
1704 xfer += iprot->skip(ftype);
1705 break;
1706 }
1707 xfer += iprot->readFieldEnd();
1708 }
1709
1710 xfer += iprot->readStructEnd();
1711
1712 return xfer;
1713 }
1714
1715 uint32_t Hbase_deleteTable_args::read(::apache::thrift::protocol::TProtocol* iprot) {
1716
1717 uint32_t xfer = 0;
1718 std::string fname;
1719 ::apache::thrift::protocol::TType ftype;
1720 int16_t fid;
1721
1722 xfer += iprot->readStructBegin(fname);
1723
1724 using ::apache::thrift::protocol::TProtocolException;
1725
1726
1727 while (true)
1728 {
1729 xfer += iprot->readFieldBegin(fname, ftype, fid);
1730 if (ftype == ::apache::thrift::protocol::T_STOP) {
1731 break;
1732 }
1733 switch (fid)
1734 {
1735 case 1:
1736 if (ftype == ::apache::thrift::protocol::T_STRING) {
1737 xfer += iprot->readBinary(this->tableName);
1738 this->__isset.tableName = true;
1739 } else {
1740 xfer += iprot->skip(ftype);
1741 }
1742 break;
1743 default:
1744 xfer += iprot->skip(ftype);
1745 break;
1746 }
1747 xfer += iprot->readFieldEnd();
1748 }
1749
1750 xfer += iprot->readStructEnd();
1751
1752 return xfer;
1753 }
1754
1755 uint32_t Hbase_deleteTable_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
1756 uint32_t xfer = 0;
1757 xfer += oprot->writeStructBegin("Hbase_deleteTable_args");
1758
1759 xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
1760 xfer += oprot->writeBinary(this->tableName);
1761 xfer += oprot->writeFieldEnd();
1762
1763 xfer += oprot->writeFieldStop();
1764 xfer += oprot->writeStructEnd();
1765 return xfer;
1766 }
1767
1768 uint32_t Hbase_deleteTable_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
1769 uint32_t xfer = 0;
1770 xfer += oprot->writeStructBegin("Hbase_deleteTable_pargs");
1771
1772 xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
1773 xfer += oprot->writeBinary((*(this->tableName)));
1774 xfer += oprot->writeFieldEnd();
1775
1776 xfer += oprot->writeFieldStop();
1777 xfer += oprot->writeStructEnd();
1778 return xfer;
1779 }
1780
1781 uint32_t Hbase_deleteTable_result::read(::apache::thrift::protocol::TProtocol* iprot) {
1782
1783 uint32_t xfer = 0;
1784 std::string fname;
1785 ::apache::thrift::protocol::TType ftype;
1786 int16_t fid;
1787
1788 xfer += iprot->readStructBegin(fname);
1789
1790 using ::apache::thrift::protocol::TProtocolException;
1791
1792
1793 while (true)
1794 {
1795 xfer += iprot->readFieldBegin(fname, ftype, fid);
1796 if (ftype == ::apache::thrift::protocol::T_STOP) {
1797 break;
1798 }
1799 switch (fid)
1800 {
1801 case 1:
1802 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
1803 xfer += this->io.read(iprot);
1804 this->__isset.io = true;
1805 } else {
1806 xfer += iprot->skip(ftype);
1807 }
1808 break;
1809 default:
1810 xfer += iprot->skip(ftype);
1811 break;
1812 }
1813 xfer += iprot->readFieldEnd();
1814 }
1815
1816 xfer += iprot->readStructEnd();
1817
1818 return xfer;
1819 }
1820
1821 uint32_t Hbase_deleteTable_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
1822
1823 uint32_t xfer = 0;
1824
1825 xfer += oprot->writeStructBegin("Hbase_deleteTable_result");
1826
1827 if (this->__isset.io) {
1828 xfer += oprot->writeFieldBegin("io", ::apache::thrift::protocol::T_STRUCT, 1);
1829 xfer += this->io.write(oprot);
1830 xfer += oprot->writeFieldEnd();
1831 }
1832 xfer += oprot->writeFieldStop();
1833 xfer += oprot->writeStructEnd();
1834 return xfer;
1835 }
1836
1837 uint32_t Hbase_deleteTable_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
1838
1839 uint32_t xfer = 0;
1840 std::string fname;
1841 ::apache::thrift::protocol::TType ftype;
1842 int16_t fid;
1843
1844 xfer += iprot->readStructBegin(fname);
1845
1846 using ::apache::thrift::protocol::TProtocolException;
1847
1848
1849 while (true)
1850 {
1851 xfer += iprot->readFieldBegin(fname, ftype, fid);
1852 if (ftype == ::apache::thrift::protocol::T_STOP) {
1853 break;
1854 }
1855 switch (fid)
1856 {
1857 case 1:
1858 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
1859 xfer += this->io.read(iprot);
1860 this->__isset.io = true;
1861 } else {
1862 xfer += iprot->skip(ftype);
1863 }
1864 break;
1865 default:
1866 xfer += iprot->skip(ftype);
1867 break;
1868 }
1869 xfer += iprot->readFieldEnd();
1870 }
1871
1872 xfer += iprot->readStructEnd();
1873
1874 return xfer;
1875 }
1876
1877 uint32_t Hbase_get_args::read(::apache::thrift::protocol::TProtocol* iprot) {
1878
1879 uint32_t xfer = 0;
1880 std::string fname;
1881 ::apache::thrift::protocol::TType ftype;
1882 int16_t fid;
1883
1884 xfer += iprot->readStructBegin(fname);
1885
1886 using ::apache::thrift::protocol::TProtocolException;
1887
1888
1889 while (true)
1890 {
1891 xfer += iprot->readFieldBegin(fname, ftype, fid);
1892 if (ftype == ::apache::thrift::protocol::T_STOP) {
1893 break;
1894 }
1895 switch (fid)
1896 {
1897 case 1:
1898 if (ftype == ::apache::thrift::protocol::T_STRING) {
1899 xfer += iprot->readBinary(this->tableName);
1900 this->__isset.tableName = true;
1901 } else {
1902 xfer += iprot->skip(ftype);
1903 }
1904 break;
1905 case 2:
1906 if (ftype == ::apache::thrift::protocol::T_STRING) {
1907 xfer += iprot->readBinary(this->row);
1908 this->__isset.row = true;
1909 } else {
1910 xfer += iprot->skip(ftype);
1911 }
1912 break;
1913 case 3:
1914 if (ftype == ::apache::thrift::protocol::T_STRING) {
1915 xfer += iprot->readBinary(this->column);
1916 this->__isset.column = true;
1917 } else {
1918 xfer += iprot->skip(ftype);
1919 }
1920 break;
1921 case 4:
1922 if (ftype == ::apache::thrift::protocol::T_MAP) {
1923 {
1924 this->attributes.clear();
1925 uint32_t _size64;
1926 ::apache::thrift::protocol::TType _ktype65;
1927 ::apache::thrift::protocol::TType _vtype66;
1928 xfer += iprot->readMapBegin(_ktype65, _vtype66, _size64);
1929 uint32_t _i68;
1930 for (_i68 = 0; _i68 < _size64; ++_i68)
1931 {
1932 Text _key69;
1933 xfer += iprot->readBinary(_key69);
1934 Text& _val70 = this->attributes[_key69];
1935 xfer += iprot->readBinary(_val70);
1936 }
1937 xfer += iprot->readMapEnd();
1938 }
1939 this->__isset.attributes = true;
1940 } else {
1941 xfer += iprot->skip(ftype);
1942 }
1943 break;
1944 default:
1945 xfer += iprot->skip(ftype);
1946 break;
1947 }
1948 xfer += iprot->readFieldEnd();
1949 }
1950
1951 xfer += iprot->readStructEnd();
1952
1953 return xfer;
1954 }
1955
1956 uint32_t Hbase_get_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
1957 uint32_t xfer = 0;
1958 xfer += oprot->writeStructBegin("Hbase_get_args");
1959
1960 xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
1961 xfer += oprot->writeBinary(this->tableName);
1962 xfer += oprot->writeFieldEnd();
1963
1964 xfer += oprot->writeFieldBegin("row", ::apache::thrift::protocol::T_STRING, 2);
1965 xfer += oprot->writeBinary(this->row);
1966 xfer += oprot->writeFieldEnd();
1967
1968 xfer += oprot->writeFieldBegin("column", ::apache::thrift::protocol::T_STRING, 3);
1969 xfer += oprot->writeBinary(this->column);
1970 xfer += oprot->writeFieldEnd();
1971
1972 xfer += oprot->writeFieldBegin("attributes", ::apache::thrift::protocol::T_MAP, 4);
1973 {
1974 xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->attributes.size()));
1975 std::map<Text, Text> ::const_iterator _iter71;
1976 for (_iter71 = this->attributes.begin(); _iter71 != this->attributes.end(); ++_iter71)
1977 {
1978 xfer += oprot->writeBinary(_iter71->first);
1979 xfer += oprot->writeBinary(_iter71->second);
1980 }
1981 xfer += oprot->writeMapEnd();
1982 }
1983 xfer += oprot->writeFieldEnd();
1984
1985 xfer += oprot->writeFieldStop();
1986 xfer += oprot->writeStructEnd();
1987 return xfer;
1988 }
1989
1990 uint32_t Hbase_get_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
1991 uint32_t xfer = 0;
1992 xfer += oprot->writeStructBegin("Hbase_get_pargs");
1993
1994 xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
1995 xfer += oprot->writeBinary((*(this->tableName)));
1996 xfer += oprot->writeFieldEnd();
1997
1998 xfer += oprot->writeFieldBegin("row", ::apache::thrift::protocol::T_STRING, 2);
1999 xfer += oprot->writeBinary((*(this->row)));
2000 xfer += oprot->writeFieldEnd();
2001
2002 xfer += oprot->writeFieldBegin("column", ::apache::thrift::protocol::T_STRING, 3);
2003 xfer += oprot->writeBinary((*(this->column)));
2004 xfer += oprot->writeFieldEnd();
2005
2006 xfer += oprot->writeFieldBegin("attributes", ::apache::thrift::protocol::T_MAP, 4);
2007 {
2008 xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->attributes)).size()));
2009 std::map<Text, Text> ::const_iterator _iter72;
2010 for (_iter72 = (*(this->attributes)).begin(); _iter72 != (*(this->attributes)).end(); ++_iter72)
2011 {
2012 xfer += oprot->writeBinary(_iter72->first);
2013 xfer += oprot->writeBinary(_iter72->second);
2014 }
2015 xfer += oprot->writeMapEnd();
2016 }
2017 xfer += oprot->writeFieldEnd();
2018
2019 xfer += oprot->writeFieldStop();
2020 xfer += oprot->writeStructEnd();
2021 return xfer;
2022 }
2023
2024 uint32_t Hbase_get_result::read(::apache::thrift::protocol::TProtocol* iprot) {
2025
2026 uint32_t xfer = 0;
2027 std::string fname;
2028 ::apache::thrift::protocol::TType ftype;
2029 int16_t fid;
2030
2031 xfer += iprot->readStructBegin(fname);
2032
2033 using ::apache::thrift::protocol::TProtocolException;
2034
2035
2036 while (true)
2037 {
2038 xfer += iprot->readFieldBegin(fname, ftype, fid);
2039 if (ftype == ::apache::thrift::protocol::T_STOP) {
2040 break;
2041 }
2042 switch (fid)
2043 {
2044 case 0:
2045 if (ftype == ::apache::thrift::protocol::T_LIST) {
2046 {
2047 this->success.clear();
2048 uint32_t _size73;
2049 ::apache::thrift::protocol::TType _etype76;
2050 xfer += iprot->readListBegin(_etype76, _size73);
2051 this->success.resize(_size73);
2052 uint32_t _i77;
2053 for (_i77 = 0; _i77 < _size73; ++_i77)
2054 {
2055 xfer += this->success[_i77].read(iprot);
2056 }
2057 xfer += iprot->readListEnd();
2058 }
2059 this->__isset.success = true;
2060 } else {
2061 xfer += iprot->skip(ftype);
2062 }
2063 break;
2064 case 1:
2065 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
2066 xfer += this->io.read(iprot);
2067 this->__isset.io = true;
2068 } else {
2069 xfer += iprot->skip(ftype);
2070 }
2071 break;
2072 default:
2073 xfer += iprot->skip(ftype);
2074 break;
2075 }
2076 xfer += iprot->readFieldEnd();
2077 }
2078
2079 xfer += iprot->readStructEnd();
2080
2081 return xfer;
2082 }
2083
2084 uint32_t Hbase_get_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
2085
2086 uint32_t xfer = 0;
2087
2088 xfer += oprot->writeStructBegin("Hbase_get_result");
2089
2090 if (this->__isset.success) {
2091 xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0);
2092 {
2093 xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->success.size()));
2094 std::vector<TCell> ::const_iterator _iter78;
2095 for (_iter78 = this->success.begin(); _iter78 != this->success.end(); ++_iter78)
2096 {
2097 xfer += (*_iter78).write(oprot);
2098 }
2099 xfer += oprot->writeListEnd();
2100 }
2101 xfer += oprot->writeFieldEnd();
2102 } else if (this->__isset.io) {
2103 xfer += oprot->writeFieldBegin("io", ::apache::thrift::protocol::T_STRUCT, 1);
2104 xfer += this->io.write(oprot);
2105 xfer += oprot->writeFieldEnd();
2106 }
2107 xfer += oprot->writeFieldStop();
2108 xfer += oprot->writeStructEnd();
2109 return xfer;
2110 }
2111
2112 uint32_t Hbase_get_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
2113
2114 uint32_t xfer = 0;
2115 std::string fname;
2116 ::apache::thrift::protocol::TType ftype;
2117 int16_t fid;
2118
2119 xfer += iprot->readStructBegin(fname);
2120
2121 using ::apache::thrift::protocol::TProtocolException;
2122
2123
2124 while (true)
2125 {
2126 xfer += iprot->readFieldBegin(fname, ftype, fid);
2127 if (ftype == ::apache::thrift::protocol::T_STOP) {
2128 break;
2129 }
2130 switch (fid)
2131 {
2132 case 0:
2133 if (ftype == ::apache::thrift::protocol::T_LIST) {
2134 {
2135 (*(this->success)).clear();
2136 uint32_t _size79;
2137 ::apache::thrift::protocol::TType _etype82;
2138 xfer += iprot->readListBegin(_etype82, _size79);
2139 (*(this->success)).resize(_size79);
2140 uint32_t _i83;
2141 for (_i83 = 0; _i83 < _size79; ++_i83)
2142 {
2143 xfer += (*(this->success))[_i83].read(iprot);
2144 }
2145 xfer += iprot->readListEnd();
2146 }
2147 this->__isset.success = true;
2148 } else {
2149 xfer += iprot->skip(ftype);
2150 }
2151 break;
2152 case 1:
2153 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
2154 xfer += this->io.read(iprot);
2155 this->__isset.io = true;
2156 } else {
2157 xfer += iprot->skip(ftype);
2158 }
2159 break;
2160 default:
2161 xfer += iprot->skip(ftype);
2162 break;
2163 }
2164 xfer += iprot->readFieldEnd();
2165 }
2166
2167 xfer += iprot->readStructEnd();
2168
2169 return xfer;
2170 }
2171
2172 uint32_t Hbase_getVer_args::read(::apache::thrift::protocol::TProtocol* iprot) {
2173
2174 uint32_t xfer = 0;
2175 std::string fname;
2176 ::apache::thrift::protocol::TType ftype;
2177 int16_t fid;
2178
2179 xfer += iprot->readStructBegin(fname);
2180
2181 using ::apache::thrift::protocol::TProtocolException;
2182
2183
2184 while (true)
2185 {
2186 xfer += iprot->readFieldBegin(fname, ftype, fid);
2187 if (ftype == ::apache::thrift::protocol::T_STOP) {
2188 break;
2189 }
2190 switch (fid)
2191 {
2192 case 1:
2193 if (ftype == ::apache::thrift::protocol::T_STRING) {
2194 xfer += iprot->readBinary(this->tableName);
2195 this->__isset.tableName = true;
2196 } else {
2197 xfer += iprot->skip(ftype);
2198 }
2199 break;
2200 case 2:
2201 if (ftype == ::apache::thrift::protocol::T_STRING) {
2202 xfer += iprot->readBinary(this->row);
2203 this->__isset.row = true;
2204 } else {
2205 xfer += iprot->skip(ftype);
2206 }
2207 break;
2208 case 3:
2209 if (ftype == ::apache::thrift::protocol::T_STRING) {
2210 xfer += iprot->readBinary(this->column);
2211 this->__isset.column = true;
2212 } else {
2213 xfer += iprot->skip(ftype);
2214 }
2215 break;
2216 case 4:
2217 if (ftype == ::apache::thrift::protocol::T_I32) {
2218 xfer += iprot->readI32(this->numVersions);
2219 this->__isset.numVersions = true;
2220 } else {
2221 xfer += iprot->skip(ftype);
2222 }
2223 break;
2224 case 5:
2225 if (ftype == ::apache::thrift::protocol::T_MAP) {
2226 {
2227 this->attributes.clear();
2228 uint32_t _size84;
2229 ::apache::thrift::protocol::TType _ktype85;
2230 ::apache::thrift::protocol::TType _vtype86;
2231 xfer += iprot->readMapBegin(_ktype85, _vtype86, _size84);
2232 uint32_t _i88;
2233 for (_i88 = 0; _i88 < _size84; ++_i88)
2234 {
2235 Text _key89;
2236 xfer += iprot->readBinary(_key89);
2237 Text& _val90 = this->attributes[_key89];
2238 xfer += iprot->readBinary(_val90);
2239 }
2240 xfer += iprot->readMapEnd();
2241 }
2242 this->__isset.attributes = true;
2243 } else {
2244 xfer += iprot->skip(ftype);
2245 }
2246 break;
2247 default:
2248 xfer += iprot->skip(ftype);
2249 break;
2250 }
2251 xfer += iprot->readFieldEnd();
2252 }
2253
2254 xfer += iprot->readStructEnd();
2255
2256 return xfer;
2257 }
2258
2259 uint32_t Hbase_getVer_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
2260 uint32_t xfer = 0;
2261 xfer += oprot->writeStructBegin("Hbase_getVer_args");
2262
2263 xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
2264 xfer += oprot->writeBinary(this->tableName);
2265 xfer += oprot->writeFieldEnd();
2266
2267 xfer += oprot->writeFieldBegin("row", ::apache::thrift::protocol::T_STRING, 2);
2268 xfer += oprot->writeBinary(this->row);
2269 xfer += oprot->writeFieldEnd();
2270
2271 xfer += oprot->writeFieldBegin("column", ::apache::thrift::protocol::T_STRING, 3);
2272 xfer += oprot->writeBinary(this->column);
2273 xfer += oprot->writeFieldEnd();
2274
2275 xfer += oprot->writeFieldBegin("numVersions", ::apache::thrift::protocol::T_I32, 4);
2276 xfer += oprot->writeI32(this->numVersions);
2277 xfer += oprot->writeFieldEnd();
2278
2279 xfer += oprot->writeFieldBegin("attributes", ::apache::thrift::protocol::T_MAP, 5);
2280 {
2281 xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->attributes.size()));
2282 std::map<Text, Text> ::const_iterator _iter91;
2283 for (_iter91 = this->attributes.begin(); _iter91 != this->attributes.end(); ++_iter91)
2284 {
2285 xfer += oprot->writeBinary(_iter91->first);
2286 xfer += oprot->writeBinary(_iter91->second);
2287 }
2288 xfer += oprot->writeMapEnd();
2289 }
2290 xfer += oprot->writeFieldEnd();
2291
2292 xfer += oprot->writeFieldStop();
2293 xfer += oprot->writeStructEnd();
2294 return xfer;
2295 }
2296
2297 uint32_t Hbase_getVer_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
2298 uint32_t xfer = 0;
2299 xfer += oprot->writeStructBegin("Hbase_getVer_pargs");
2300
2301 xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
2302 xfer += oprot->writeBinary((*(this->tableName)));
2303 xfer += oprot->writeFieldEnd();
2304
2305 xfer += oprot->writeFieldBegin("row", ::apache::thrift::protocol::T_STRING, 2);
2306 xfer += oprot->writeBinary((*(this->row)));
2307 xfer += oprot->writeFieldEnd();
2308
2309 xfer += oprot->writeFieldBegin("column", ::apache::thrift::protocol::T_STRING, 3);
2310 xfer += oprot->writeBinary((*(this->column)));
2311 xfer += oprot->writeFieldEnd();
2312
2313 xfer += oprot->writeFieldBegin("numVersions", ::apache::thrift::protocol::T_I32, 4);
2314 xfer += oprot->writeI32((*(this->numVersions)));
2315 xfer += oprot->writeFieldEnd();
2316
2317 xfer += oprot->writeFieldBegin("attributes", ::apache::thrift::protocol::T_MAP, 5);
2318 {
2319 xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->attributes)).size()));
2320 std::map<Text, Text> ::const_iterator _iter92;
2321 for (_iter92 = (*(this->attributes)).begin(); _iter92 != (*(this->attributes)).end(); ++_iter92)
2322 {
2323 xfer += oprot->writeBinary(_iter92->first);
2324 xfer += oprot->writeBinary(_iter92->second);
2325 }
2326 xfer += oprot->writeMapEnd();
2327 }
2328 xfer += oprot->writeFieldEnd();
2329
2330 xfer += oprot->writeFieldStop();
2331 xfer += oprot->writeStructEnd();
2332 return xfer;
2333 }
2334
2335 uint32_t Hbase_getVer_result::read(::apache::thrift::protocol::TProtocol* iprot) {
2336
2337 uint32_t xfer = 0;
2338 std::string fname;
2339 ::apache::thrift::protocol::TType ftype;
2340 int16_t fid;
2341
2342 xfer += iprot->readStructBegin(fname);
2343
2344 using ::apache::thrift::protocol::TProtocolException;
2345
2346
2347 while (true)
2348 {
2349 xfer += iprot->readFieldBegin(fname, ftype, fid);
2350 if (ftype == ::apache::thrift::protocol::T_STOP) {
2351 break;
2352 }
2353 switch (fid)
2354 {
2355 case 0:
2356 if (ftype == ::apache::thrift::protocol::T_LIST) {
2357 {
2358 this->success.clear();
2359 uint32_t _size93;
2360 ::apache::thrift::protocol::TType _etype96;
2361 xfer += iprot->readListBegin(_etype96, _size93);
2362 this->success.resize(_size93);
2363 uint32_t _i97;
2364 for (_i97 = 0; _i97 < _size93; ++_i97)
2365 {
2366 xfer += this->success[_i97].read(iprot);
2367 }
2368 xfer += iprot->readListEnd();
2369 }
2370 this->__isset.success = true;
2371 } else {
2372 xfer += iprot->skip(ftype);
2373 }
2374 break;
2375 case 1:
2376 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
2377 xfer += this->io.read(iprot);
2378 this->__isset.io = true;
2379 } else {
2380 xfer += iprot->skip(ftype);
2381 }
2382 break;
2383 default:
2384 xfer += iprot->skip(ftype);
2385 break;
2386 }
2387 xfer += iprot->readFieldEnd();
2388 }
2389
2390 xfer += iprot->readStructEnd();
2391
2392 return xfer;
2393 }
2394
2395 uint32_t Hbase_getVer_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
2396
2397 uint32_t xfer = 0;
2398
2399 xfer += oprot->writeStructBegin("Hbase_getVer_result");
2400
2401 if (this->__isset.success) {
2402 xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0);
2403 {
2404 xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->success.size()));
2405 std::vector<TCell> ::const_iterator _iter98;
2406 for (_iter98 = this->success.begin(); _iter98 != this->success.end(); ++_iter98)
2407 {
2408 xfer += (*_iter98).write(oprot);
2409 }
2410 xfer += oprot->writeListEnd();
2411 }
2412 xfer += oprot->writeFieldEnd();
2413 } else if (this->__isset.io) {
2414 xfer += oprot->writeFieldBegin("io", ::apache::thrift::protocol::T_STRUCT, 1);
2415 xfer += this->io.write(oprot);
2416 xfer += oprot->writeFieldEnd();
2417 }
2418 xfer += oprot->writeFieldStop();
2419 xfer += oprot->writeStructEnd();
2420 return xfer;
2421 }
2422
2423 uint32_t Hbase_getVer_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
2424
2425 uint32_t xfer = 0;
2426 std::string fname;
2427 ::apache::thrift::protocol::TType ftype;
2428 int16_t fid;
2429
2430 xfer += iprot->readStructBegin(fname);
2431
2432 using ::apache::thrift::protocol::TProtocolException;
2433
2434
2435 while (true)
2436 {
2437 xfer += iprot->readFieldBegin(fname, ftype, fid);
2438 if (ftype == ::apache::thrift::protocol::T_STOP) {
2439 break;
2440 }
2441 switch (fid)
2442 {
2443 case 0:
2444 if (ftype == ::apache::thrift::protocol::T_LIST) {
2445 {
2446 (*(this->success)).clear();
2447 uint32_t _size99;
2448 ::apache::thrift::protocol::TType _etype102;
2449 xfer += iprot->readListBegin(_etype102, _size99);
2450 (*(this->success)).resize(_size99);
2451 uint32_t _i103;
2452 for (_i103 = 0; _i103 < _size99; ++_i103)
2453 {
2454 xfer += (*(this->success))[_i103].read(iprot);
2455 }
2456 xfer += iprot->readListEnd();
2457 }
2458 this->__isset.success = true;
2459 } else {
2460 xfer += iprot->skip(ftype);
2461 }
2462 break;
2463 case 1:
2464 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
2465 xfer += this->io.read(iprot);
2466 this->__isset.io = true;
2467 } else {
2468 xfer += iprot->skip(ftype);
2469 }
2470 break;
2471 default:
2472 xfer += iprot->skip(ftype);
2473 break;
2474 }
2475 xfer += iprot->readFieldEnd();
2476 }
2477
2478 xfer += iprot->readStructEnd();
2479
2480 return xfer;
2481 }
2482
2483 uint32_t Hbase_getVerTs_args::read(::apache::thrift::protocol::TProtocol* iprot) {
2484
2485 uint32_t xfer = 0;
2486 std::string fname;
2487 ::apache::thrift::protocol::TType ftype;
2488 int16_t fid;
2489
2490 xfer += iprot->readStructBegin(fname);
2491
2492 using ::apache::thrift::protocol::TProtocolException;
2493
2494
2495 while (true)
2496 {
2497 xfer += iprot->readFieldBegin(fname, ftype, fid);
2498 if (ftype == ::apache::thrift::protocol::T_STOP) {
2499 break;
2500 }
2501 switch (fid)
2502 {
2503 case 1:
2504 if (ftype == ::apache::thrift::protocol::T_STRING) {
2505 xfer += iprot->readBinary(this->tableName);
2506 this->__isset.tableName = true;
2507 } else {
2508 xfer += iprot->skip(ftype);
2509 }
2510 break;
2511 case 2:
2512 if (ftype == ::apache::thrift::protocol::T_STRING) {
2513 xfer += iprot->readBinary(this->row);
2514 this->__isset.row = true;
2515 } else {
2516 xfer += iprot->skip(ftype);
2517 }
2518 break;
2519 case 3:
2520 if (ftype == ::apache::thrift::protocol::T_STRING) {
2521 xfer += iprot->readBinary(this->column);
2522 this->__isset.column = true;
2523 } else {
2524 xfer += iprot->skip(ftype);
2525 }
2526 break;
2527 case 4:
2528 if (ftype == ::apache::thrift::protocol::T_I64) {
2529 xfer += iprot->readI64(this->timestamp);
2530 this->__isset.timestamp = true;
2531 } else {
2532 xfer += iprot->skip(ftype);
2533 }
2534 break;
2535 case 5:
2536 if (ftype == ::apache::thrift::protocol::T_I32) {
2537 xfer += iprot->readI32(this->numVersions);
2538 this->__isset.numVersions = true;
2539 } else {
2540 xfer += iprot->skip(ftype);
2541 }
2542 break;
2543 case 6:
2544 if (ftype == ::apache::thrift::protocol::T_MAP) {
2545 {
2546 this->attributes.clear();
2547 uint32_t _size104;
2548 ::apache::thrift::protocol::TType _ktype105;
2549 ::apache::thrift::protocol::TType _vtype106;
2550 xfer += iprot->readMapBegin(_ktype105, _vtype106, _size104);
2551 uint32_t _i108;
2552 for (_i108 = 0; _i108 < _size104; ++_i108)
2553 {
2554 Text _key109;
2555 xfer += iprot->readBinary(_key109);
2556 Text& _val110 = this->attributes[_key109];
2557 xfer += iprot->readBinary(_val110);
2558 }
2559 xfer += iprot->readMapEnd();
2560 }
2561 this->__isset.attributes = true;
2562 } else {
2563 xfer += iprot->skip(ftype);
2564 }
2565 break;
2566 default:
2567 xfer += iprot->skip(ftype);
2568 break;
2569 }
2570 xfer += iprot->readFieldEnd();
2571 }
2572
2573 xfer += iprot->readStructEnd();
2574
2575 return xfer;
2576 }
2577
2578 uint32_t Hbase_getVerTs_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
2579 uint32_t xfer = 0;
2580 xfer += oprot->writeStructBegin("Hbase_getVerTs_args");
2581
2582 xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
2583 xfer += oprot->writeBinary(this->tableName);
2584 xfer += oprot->writeFieldEnd();
2585
2586 xfer += oprot->writeFieldBegin("row", ::apache::thrift::protocol::T_STRING, 2);
2587 xfer += oprot->writeBinary(this->row);
2588 xfer += oprot->writeFieldEnd();
2589
2590 xfer += oprot->writeFieldBegin("column", ::apache::thrift::protocol::T_STRING, 3);
2591 xfer += oprot->writeBinary(this->column);
2592 xfer += oprot->writeFieldEnd();
2593
2594 xfer += oprot->writeFieldBegin("timestamp", ::apache::thrift::protocol::T_I64, 4);
2595 xfer += oprot->writeI64(this->timestamp);
2596 xfer += oprot->writeFieldEnd();
2597
2598 xfer += oprot->writeFieldBegin("numVersions", ::apache::thrift::protocol::T_I32, 5);
2599 xfer += oprot->writeI32(this->numVersions);
2600 xfer += oprot->writeFieldEnd();
2601
2602 xfer += oprot->writeFieldBegin("attributes", ::apache::thrift::protocol::T_MAP, 6);
2603 {
2604 xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->attributes.size()));
2605 std::map<Text, Text> ::const_iterator _iter111;
2606 for (_iter111 = this->attributes.begin(); _iter111 != this->attributes.end(); ++_iter111)
2607 {
2608 xfer += oprot->writeBinary(_iter111->first);
2609 xfer += oprot->writeBinary(_iter111->second);
2610 }
2611 xfer += oprot->writeMapEnd();
2612 }
2613 xfer += oprot->writeFieldEnd();
2614
2615 xfer += oprot->writeFieldStop();
2616 xfer += oprot->writeStructEnd();
2617 return xfer;
2618 }
2619
2620 uint32_t Hbase_getVerTs_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
2621 uint32_t xfer = 0;
2622 xfer += oprot->writeStructBegin("Hbase_getVerTs_pargs");
2623
2624 xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
2625 xfer += oprot->writeBinary((*(this->tableName)));
2626 xfer += oprot->writeFieldEnd();
2627
2628 xfer += oprot->writeFieldBegin("row", ::apache::thrift::protocol::T_STRING, 2);
2629 xfer += oprot->writeBinary((*(this->row)));
2630 xfer += oprot->writeFieldEnd();
2631
2632 xfer += oprot->writeFieldBegin("column", ::apache::thrift::protocol::T_STRING, 3);
2633 xfer += oprot->writeBinary((*(this->column)));
2634 xfer += oprot->writeFieldEnd();
2635
2636 xfer += oprot->writeFieldBegin("timestamp", ::apache::thrift::protocol::T_I64, 4);
2637 xfer += oprot->writeI64((*(this->timestamp)));
2638 xfer += oprot->writeFieldEnd();
2639
2640 xfer += oprot->writeFieldBegin("numVersions", ::apache::thrift::protocol::T_I32, 5);
2641 xfer += oprot->writeI32((*(this->numVersions)));
2642 xfer += oprot->writeFieldEnd();
2643
2644 xfer += oprot->writeFieldBegin("attributes", ::apache::thrift::protocol::T_MAP, 6);
2645 {
2646 xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->attributes)).size()));
2647 std::map<Text, Text> ::const_iterator _iter112;
2648 for (_iter112 = (*(this->attributes)).begin(); _iter112 != (*(this->attributes)).end(); ++_iter112)
2649 {
2650 xfer += oprot->writeBinary(_iter112->first);
2651 xfer += oprot->writeBinary(_iter112->second);
2652 }
2653 xfer += oprot->writeMapEnd();
2654 }
2655 xfer += oprot->writeFieldEnd();
2656
2657 xfer += oprot->writeFieldStop();
2658 xfer += oprot->writeStructEnd();
2659 return xfer;
2660 }
2661
2662 uint32_t Hbase_getVerTs_result::read(::apache::thrift::protocol::TProtocol* iprot) {
2663
2664 uint32_t xfer = 0;
2665 std::string fname;
2666 ::apache::thrift::protocol::TType ftype;
2667 int16_t fid;
2668
2669 xfer += iprot->readStructBegin(fname);
2670
2671 using ::apache::thrift::protocol::TProtocolException;
2672
2673
2674 while (true)
2675 {
2676 xfer += iprot->readFieldBegin(fname, ftype, fid);
2677 if (ftype == ::apache::thrift::protocol::T_STOP) {
2678 break;
2679 }
2680 switch (fid)
2681 {
2682 case 0:
2683 if (ftype == ::apache::thrift::protocol::T_LIST) {
2684 {
2685 this->success.clear();
2686 uint32_t _size113;
2687 ::apache::thrift::protocol::TType _etype116;
2688 xfer += iprot->readListBegin(_etype116, _size113);
2689 this->success.resize(_size113);
2690 uint32_t _i117;
2691 for (_i117 = 0; _i117 < _size113; ++_i117)
2692 {
2693 xfer += this->success[_i117].read(iprot);
2694 }
2695 xfer += iprot->readListEnd();
2696 }
2697 this->__isset.success = true;
2698 } else {
2699 xfer += iprot->skip(ftype);
2700 }
2701 break;
2702 case 1:
2703 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
2704 xfer += this->io.read(iprot);
2705 this->__isset.io = true;
2706 } else {
2707 xfer += iprot->skip(ftype);
2708 }
2709 break;
2710 default:
2711 xfer += iprot->skip(ftype);
2712 break;
2713 }
2714 xfer += iprot->readFieldEnd();
2715 }
2716
2717 xfer += iprot->readStructEnd();
2718
2719 return xfer;
2720 }
2721
2722 uint32_t Hbase_getVerTs_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
2723
2724 uint32_t xfer = 0;
2725
2726 xfer += oprot->writeStructBegin("Hbase_getVerTs_result");
2727
2728 if (this->__isset.success) {
2729 xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0);
2730 {
2731 xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->success.size()));
2732 std::vector<TCell> ::const_iterator _iter118;
2733 for (_iter118 = this->success.begin(); _iter118 != this->success.end(); ++_iter118)
2734 {
2735 xfer += (*_iter118).write(oprot);
2736 }
2737 xfer += oprot->writeListEnd();
2738 }
2739 xfer += oprot->writeFieldEnd();
2740 } else if (this->__isset.io) {
2741 xfer += oprot->writeFieldBegin("io", ::apache::thrift::protocol::T_STRUCT, 1);
2742 xfer += this->io.write(oprot);
2743 xfer += oprot->writeFieldEnd();
2744 }
2745 xfer += oprot->writeFieldStop();
2746 xfer += oprot->writeStructEnd();
2747 return xfer;
2748 }
2749
2750 uint32_t Hbase_getVerTs_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
2751
2752 uint32_t xfer = 0;
2753 std::string fname;
2754 ::apache::thrift::protocol::TType ftype;
2755 int16_t fid;
2756
2757 xfer += iprot->readStructBegin(fname);
2758
2759 using ::apache::thrift::protocol::TProtocolException;
2760
2761
2762 while (true)
2763 {
2764 xfer += iprot->readFieldBegin(fname, ftype, fid);
2765 if (ftype == ::apache::thrift::protocol::T_STOP) {
2766 break;
2767 }
2768 switch (fid)
2769 {
2770 case 0:
2771 if (ftype == ::apache::thrift::protocol::T_LIST) {
2772 {
2773 (*(this->success)).clear();
2774 uint32_t _size119;
2775 ::apache::thrift::protocol::TType _etype122;
2776 xfer += iprot->readListBegin(_etype122, _size119);
2777 (*(this->success)).resize(_size119);
2778 uint32_t _i123;
2779 for (_i123 = 0; _i123 < _size119; ++_i123)
2780 {
2781 xfer += (*(this->success))[_i123].read(iprot);
2782 }
2783 xfer += iprot->readListEnd();
2784 }
2785 this->__isset.success = true;
2786 } else {
2787 xfer += iprot->skip(ftype);
2788 }
2789 break;
2790 case 1:
2791 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
2792 xfer += this->io.read(iprot);
2793 this->__isset.io = true;
2794 } else {
2795 xfer += iprot->skip(ftype);
2796 }
2797 break;
2798 default:
2799 xfer += iprot->skip(ftype);
2800 break;
2801 }
2802 xfer += iprot->readFieldEnd();
2803 }
2804
2805 xfer += iprot->readStructEnd();
2806
2807 return xfer;
2808 }
2809
2810 uint32_t Hbase_getRow_args::read(::apache::thrift::protocol::TProtocol* iprot) {
2811
2812 uint32_t xfer = 0;
2813 std::string fname;
2814 ::apache::thrift::protocol::TType ftype;
2815 int16_t fid;
2816
2817 xfer += iprot->readStructBegin(fname);
2818
2819 using ::apache::thrift::protocol::TProtocolException;
2820
2821
2822 while (true)
2823 {
2824 xfer += iprot->readFieldBegin(fname, ftype, fid);
2825 if (ftype == ::apache::thrift::protocol::T_STOP) {
2826 break;
2827 }
2828 switch (fid)
2829 {
2830 case 1:
2831 if (ftype == ::apache::thrift::protocol::T_STRING) {
2832 xfer += iprot->readBinary(this->tableName);
2833 this->__isset.tableName = true;
2834 } else {
2835 xfer += iprot->skip(ftype);
2836 }
2837 break;
2838 case 2:
2839 if (ftype == ::apache::thrift::protocol::T_STRING) {
2840 xfer += iprot->readBinary(this->row);
2841 this->__isset.row = true;
2842 } else {
2843 xfer += iprot->skip(ftype);
2844 }
2845 break;
2846 case 3:
2847 if (ftype == ::apache::thrift::protocol::T_MAP) {
2848 {
2849 this->attributes.clear();
2850 uint32_t _size124;
2851 ::apache::thrift::protocol::TType _ktype125;
2852 ::apache::thrift::protocol::TType _vtype126;
2853 xfer += iprot->readMapBegin(_ktype125, _vtype126, _size124);
2854 uint32_t _i128;
2855 for (_i128 = 0; _i128 < _size124; ++_i128)
2856 {
2857 Text _key129;
2858 xfer += iprot->readBinary(_key129);
2859 Text& _val130 = this->attributes[_key129];
2860 xfer += iprot->readBinary(_val130);
2861 }
2862 xfer += iprot->readMapEnd();
2863 }
2864 this->__isset.attributes = true;
2865 } else {
2866 xfer += iprot->skip(ftype);
2867 }
2868 break;
2869 default:
2870 xfer += iprot->skip(ftype);
2871 break;
2872 }
2873 xfer += iprot->readFieldEnd();
2874 }
2875
2876 xfer += iprot->readStructEnd();
2877
2878 return xfer;
2879 }
2880
2881 uint32_t Hbase_getRow_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
2882 uint32_t xfer = 0;
2883 xfer += oprot->writeStructBegin("Hbase_getRow_args");
2884
2885 xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
2886 xfer += oprot->writeBinary(this->tableName);
2887 xfer += oprot->writeFieldEnd();
2888
2889 xfer += oprot->writeFieldBegin("row", ::apache::thrift::protocol::T_STRING, 2);
2890 xfer += oprot->writeBinary(this->row);
2891 xfer += oprot->writeFieldEnd();
2892
2893 xfer += oprot->writeFieldBegin("attributes", ::apache::thrift::protocol::T_MAP, 3);
2894 {
2895 xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->attributes.size()));
2896 std::map<Text, Text> ::const_iterator _iter131;
2897 for (_iter131 = this->attributes.begin(); _iter131 != this->attributes.end(); ++_iter131)
2898 {
2899 xfer += oprot->writeBinary(_iter131->first);
2900 xfer += oprot->writeBinary(_iter131->second);
2901 }
2902 xfer += oprot->writeMapEnd();
2903 }
2904 xfer += oprot->writeFieldEnd();
2905
2906 xfer += oprot->writeFieldStop();
2907 xfer += oprot->writeStructEnd();
2908 return xfer;
2909 }
2910
2911 uint32_t Hbase_getRow_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
2912 uint32_t xfer = 0;
2913 xfer += oprot->writeStructBegin("Hbase_getRow_pargs");
2914
2915 xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
2916 xfer += oprot->writeBinary((*(this->tableName)));
2917 xfer += oprot->writeFieldEnd();
2918
2919 xfer += oprot->writeFieldBegin("row", ::apache::thrift::protocol::T_STRING, 2);
2920 xfer += oprot->writeBinary((*(this->row)));
2921 xfer += oprot->writeFieldEnd();
2922
2923 xfer += oprot->writeFieldBegin("attributes", ::apache::thrift::protocol::T_MAP, 3);
2924 {
2925 xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->attributes)).size()));
2926 std::map<Text, Text> ::const_iterator _iter132;
2927 for (_iter132 = (*(this->attributes)).begin(); _iter132 != (*(this->attributes)).end(); ++_iter132)
2928 {
2929 xfer += oprot->writeBinary(_iter132->first);
2930 xfer += oprot->writeBinary(_iter132->second);
2931 }
2932 xfer += oprot->writeMapEnd();
2933 }
2934 xfer += oprot->writeFieldEnd();
2935
2936 xfer += oprot->writeFieldStop();
2937 xfer += oprot->writeStructEnd();
2938 return xfer;
2939 }
2940
2941 uint32_t Hbase_getRow_result::read(::apache::thrift::protocol::TProtocol* iprot) {
2942
2943 uint32_t xfer = 0;
2944 std::string fname;
2945 ::apache::thrift::protocol::TType ftype;
2946 int16_t fid;
2947
2948 xfer += iprot->readStructBegin(fname);
2949
2950 using ::apache::thrift::protocol::TProtocolException;
2951
2952
2953 while (true)
2954 {
2955 xfer += iprot->readFieldBegin(fname, ftype, fid);
2956 if (ftype == ::apache::thrift::protocol::T_STOP) {
2957 break;
2958 }
2959 switch (fid)
2960 {
2961 case 0:
2962 if (ftype == ::apache::thrift::protocol::T_LIST) {
2963 {
2964 this->success.clear();
2965 uint32_t _size133;
2966 ::apache::thrift::protocol::TType _etype136;
2967 xfer += iprot->readListBegin(_etype136, _size133);
2968 this->success.resize(_size133);
2969 uint32_t _i137;
2970 for (_i137 = 0; _i137 < _size133; ++_i137)
2971 {
2972 xfer += this->success[_i137].read(iprot);
2973 }
2974 xfer += iprot->readListEnd();
2975 }
2976 this->__isset.success = true;
2977 } else {
2978 xfer += iprot->skip(ftype);
2979 }
2980 break;
2981 case 1:
2982 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
2983 xfer += this->io.read(iprot);
2984 this->__isset.io = true;
2985 } else {
2986 xfer += iprot->skip(ftype);
2987 }
2988 break;
2989 default:
2990 xfer += iprot->skip(ftype);
2991 break;
2992 }
2993 xfer += iprot->readFieldEnd();
2994 }
2995
2996 xfer += iprot->readStructEnd();
2997
2998 return xfer;
2999 }
3000
3001 uint32_t Hbase_getRow_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
3002
3003 uint32_t xfer = 0;
3004
3005 xfer += oprot->writeStructBegin("Hbase_getRow_result");
3006
3007 if (this->__isset.success) {
3008 xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0);
3009 {
3010 xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->success.size()));
3011 std::vector<TRowResult> ::const_iterator _iter138;
3012 for (_iter138 = this->success.begin(); _iter138 != this->success.end(); ++_iter138)
3013 {
3014 xfer += (*_iter138).write(oprot);
3015 }
3016 xfer += oprot->writeListEnd();
3017 }
3018 xfer += oprot->writeFieldEnd();
3019 } else if (this->__isset.io) {
3020 xfer += oprot->writeFieldBegin("io", ::apache::thrift::protocol::T_STRUCT, 1);
3021 xfer += this->io.write(oprot);
3022 xfer += oprot->writeFieldEnd();
3023 }
3024 xfer += oprot->writeFieldStop();
3025 xfer += oprot->writeStructEnd();
3026 return xfer;
3027 }
3028
3029 uint32_t Hbase_getRow_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
3030
3031 uint32_t xfer = 0;
3032 std::string fname;
3033 ::apache::thrift::protocol::TType ftype;
3034 int16_t fid;
3035
3036 xfer += iprot->readStructBegin(fname);
3037
3038 using ::apache::thrift::protocol::TProtocolException;
3039
3040
3041 while (true)
3042 {
3043 xfer += iprot->readFieldBegin(fname, ftype, fid);
3044 if (ftype == ::apache::thrift::protocol::T_STOP) {
3045 break;
3046 }
3047 switch (fid)
3048 {
3049 case 0:
3050 if (ftype == ::apache::thrift::protocol::T_LIST) {
3051 {
3052 (*(this->success)).clear();
3053 uint32_t _size139;
3054 ::apache::thrift::protocol::TType _etype142;
3055 xfer += iprot->readListBegin(_etype142, _size139);
3056 (*(this->success)).resize(_size139);
3057 uint32_t _i143;
3058 for (_i143 = 0; _i143 < _size139; ++_i143)
3059 {
3060 xfer += (*(this->success))[_i143].read(iprot);
3061 }
3062 xfer += iprot->readListEnd();
3063 }
3064 this->__isset.success = true;
3065 } else {
3066 xfer += iprot->skip(ftype);
3067 }
3068 break;
3069 case 1:
3070 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
3071 xfer += this->io.read(iprot);
3072 this->__isset.io = true;
3073 } else {
3074 xfer += iprot->skip(ftype);
3075 }
3076 break;
3077 default:
3078 xfer += iprot->skip(ftype);
3079 break;
3080 }
3081 xfer += iprot->readFieldEnd();
3082 }
3083
3084 xfer += iprot->readStructEnd();
3085
3086 return xfer;
3087 }
3088
3089 uint32_t Hbase_getRowWithColumns_args::read(::apache::thrift::protocol::TProtocol* iprot) {
3090
3091 uint32_t xfer = 0;
3092 std::string fname;
3093 ::apache::thrift::protocol::TType ftype;
3094 int16_t fid;
3095
3096 xfer += iprot->readStructBegin(fname);
3097
3098 using ::apache::thrift::protocol::TProtocolException;
3099
3100
3101 while (true)
3102 {
3103 xfer += iprot->readFieldBegin(fname, ftype, fid);
3104 if (ftype == ::apache::thrift::protocol::T_STOP) {
3105 break;
3106 }
3107 switch (fid)
3108 {
3109 case 1:
3110 if (ftype == ::apache::thrift::protocol::T_STRING) {
3111 xfer += iprot->readBinary(this->tableName);
3112 this->__isset.tableName = true;
3113 } else {
3114 xfer += iprot->skip(ftype);
3115 }
3116 break;
3117 case 2:
3118 if (ftype == ::apache::thrift::protocol::T_STRING) {
3119 xfer += iprot->readBinary(this->row);
3120 this->__isset.row = true;
3121 } else {
3122 xfer += iprot->skip(ftype);
3123 }
3124 break;
3125 case 3:
3126 if (ftype == ::apache::thrift::protocol::T_LIST) {
3127 {
3128 this->columns.clear();
3129 uint32_t _size144;
3130 ::apache::thrift::protocol::TType _etype147;
3131 xfer += iprot->readListBegin(_etype147, _size144);
3132 this->columns.resize(_size144);
3133 uint32_t _i148;
3134 for (_i148 = 0; _i148 < _size144; ++_i148)
3135 {
3136 xfer += iprot->readBinary(this->columns[_i148]);
3137 }
3138 xfer += iprot->readListEnd();
3139 }
3140 this->__isset.columns = true;
3141 } else {
3142 xfer += iprot->skip(ftype);
3143 }
3144 break;
3145 case 4:
3146 if (ftype == ::apache::thrift::protocol::T_MAP) {
3147 {
3148 this->attributes.clear();
3149 uint32_t _size149;
3150 ::apache::thrift::protocol::TType _ktype150;
3151 ::apache::thrift::protocol::TType _vtype151;
3152 xfer += iprot->readMapBegin(_ktype150, _vtype151, _size149);
3153 uint32_t _i153;
3154 for (_i153 = 0; _i153 < _size149; ++_i153)
3155 {
3156 Text _key154;
3157 xfer += iprot->readBinary(_key154);
3158 Text& _val155 = this->attributes[_key154];
3159 xfer += iprot->readBinary(_val155);
3160 }
3161 xfer += iprot->readMapEnd();
3162 }
3163 this->__isset.attributes = true;
3164 } else {
3165 xfer += iprot->skip(ftype);
3166 }
3167 break;
3168 default:
3169 xfer += iprot->skip(ftype);
3170 break;
3171 }
3172 xfer += iprot->readFieldEnd();
3173 }
3174
3175 xfer += iprot->readStructEnd();
3176
3177 return xfer;
3178 }
3179
3180 uint32_t Hbase_getRowWithColumns_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
3181 uint32_t xfer = 0;
3182 xfer += oprot->writeStructBegin("Hbase_getRowWithColumns_args");
3183
3184 xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
3185 xfer += oprot->writeBinary(this->tableName);
3186 xfer += oprot->writeFieldEnd();
3187
3188 xfer += oprot->writeFieldBegin("row", ::apache::thrift::protocol::T_STRING, 2);
3189 xfer += oprot->writeBinary(this->row);
3190 xfer += oprot->writeFieldEnd();
3191
3192 xfer += oprot->writeFieldBegin("columns", ::apache::thrift::protocol::T_LIST, 3);
3193 {
3194 xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->columns.size()));
3195 std::vector<Text> ::const_iterator _iter156;
3196 for (_iter156 = this->columns.begin(); _iter156 != this->columns.end(); ++_iter156)
3197 {
3198 xfer += oprot->writeBinary((*_iter156));
3199 }
3200 xfer += oprot->writeListEnd();
3201 }
3202 xfer += oprot->writeFieldEnd();
3203
3204 xfer += oprot->writeFieldBegin("attributes", ::apache::thrift::protocol::T_MAP, 4);
3205 {
3206 xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->attributes.size()));
3207 std::map<Text, Text> ::const_iterator _iter157;
3208 for (_iter157 = this->attributes.begin(); _iter157 != this->attributes.end(); ++_iter157)
3209 {
3210 xfer += oprot->writeBinary(_iter157->first);
3211 xfer += oprot->writeBinary(_iter157->second);
3212 }
3213 xfer += oprot->writeMapEnd();
3214 }
3215 xfer += oprot->writeFieldEnd();
3216
3217 xfer += oprot->writeFieldStop();
3218 xfer += oprot->writeStructEnd();
3219 return xfer;
3220 }
3221
3222 uint32_t Hbase_getRowWithColumns_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
3223 uint32_t xfer = 0;
3224 xfer += oprot->writeStructBegin("Hbase_getRowWithColumns_pargs");
3225
3226 xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
3227 xfer += oprot->writeBinary((*(this->tableName)));
3228 xfer += oprot->writeFieldEnd();
3229
3230 xfer += oprot->writeFieldBegin("row", ::apache::thrift::protocol::T_STRING, 2);
3231 xfer += oprot->writeBinary((*(this->row)));
3232 xfer += oprot->writeFieldEnd();
3233
3234 xfer += oprot->writeFieldBegin("columns", ::apache::thrift::protocol::T_LIST, 3);
3235 {
3236 xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->columns)).size()));
3237 std::vector<Text> ::const_iterator _iter158;
3238 for (_iter158 = (*(this->columns)).begin(); _iter158 != (*(this->columns)).end(); ++_iter158)
3239 {
3240 xfer += oprot->writeBinary((*_iter158));
3241 }
3242 xfer += oprot->writeListEnd();
3243 }
3244 xfer += oprot->writeFieldEnd();
3245
3246 xfer += oprot->writeFieldBegin("attributes", ::apache::thrift::protocol::T_MAP, 4);
3247 {
3248 xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->attributes)).size()));
3249 std::map<Text, Text> ::const_iterator _iter159;
3250 for (_iter159 = (*(this->attributes)).begin(); _iter159 != (*(this->attributes)).end(); ++_iter159)
3251 {
3252 xfer += oprot->writeBinary(_iter159->first);
3253 xfer += oprot->writeBinary(_iter159->second);
3254 }
3255 xfer += oprot->writeMapEnd();
3256 }
3257 xfer += oprot->writeFieldEnd();
3258
3259 xfer += oprot->writeFieldStop();
3260 xfer += oprot->writeStructEnd();
3261 return xfer;
3262 }
3263
3264 uint32_t Hbase_getRowWithColumns_result::read(::apache::thrift::protocol::TProtocol* iprot) {
3265
3266 uint32_t xfer = 0;
3267 std::string fname;
3268 ::apache::thrift::protocol::TType ftype;
3269 int16_t fid;
3270
3271 xfer += iprot->readStructBegin(fname);
3272
3273 using ::apache::thrift::protocol::TProtocolException;
3274
3275
3276 while (true)
3277 {
3278 xfer += iprot->readFieldBegin(fname, ftype, fid);
3279 if (ftype == ::apache::thrift::protocol::T_STOP) {
3280 break;
3281 }
3282 switch (fid)
3283 {
3284 case 0:
3285 if (ftype == ::apache::thrift::protocol::T_LIST) {
3286 {
3287 this->success.clear();
3288 uint32_t _size160;
3289 ::apache::thrift::protocol::TType _etype163;
3290 xfer += iprot->readListBegin(_etype163, _size160);
3291 this->success.resize(_size160);
3292 uint32_t _i164;
3293 for (_i164 = 0; _i164 < _size160; ++_i164)
3294 {
3295 xfer += this->success[_i164].read(iprot);
3296 }
3297 xfer += iprot->readListEnd();
3298 }
3299 this->__isset.success = true;
3300 } else {
3301 xfer += iprot->skip(ftype);
3302 }
3303 break;
3304 case 1:
3305 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
3306 xfer += this->io.read(iprot);
3307 this->__isset.io = true;
3308 } else {
3309 xfer += iprot->skip(ftype);
3310 }
3311 break;
3312 default:
3313 xfer += iprot->skip(ftype);
3314 break;
3315 }
3316 xfer += iprot->readFieldEnd();
3317 }
3318
3319 xfer += iprot->readStructEnd();
3320
3321 return xfer;
3322 }
3323
3324 uint32_t Hbase_getRowWithColumns_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
3325
3326 uint32_t xfer = 0;
3327
3328 xfer += oprot->writeStructBegin("Hbase_getRowWithColumns_result");
3329
3330 if (this->__isset.success) {
3331 xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0);
3332 {
3333 xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->success.size()));
3334 std::vector<TRowResult> ::const_iterator _iter165;
3335 for (_iter165 = this->success.begin(); _iter165 != this->success.end(); ++_iter165)
3336 {
3337 xfer += (*_iter165).write(oprot);
3338 }
3339 xfer += oprot->writeListEnd();
3340 }
3341 xfer += oprot->writeFieldEnd();
3342 } else if (this->__isset.io) {
3343 xfer += oprot->writeFieldBegin("io", ::apache::thrift::protocol::T_STRUCT, 1);
3344 xfer += this->io.write(oprot);
3345 xfer += oprot->writeFieldEnd();
3346 }
3347 xfer += oprot->writeFieldStop();
3348 xfer += oprot->writeStructEnd();
3349 return xfer;
3350 }
3351
3352 uint32_t Hbase_getRowWithColumns_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
3353
3354 uint32_t xfer = 0;
3355 std::string fname;
3356 ::apache::thrift::protocol::TType ftype;
3357 int16_t fid;
3358
3359 xfer += iprot->readStructBegin(fname);
3360
3361 using ::apache::thrift::protocol::TProtocolException;
3362
3363
3364 while (true)
3365 {
3366 xfer += iprot->readFieldBegin(fname, ftype, fid);
3367 if (ftype == ::apache::thrift::protocol::T_STOP) {
3368 break;
3369 }
3370 switch (fid)
3371 {
3372 case 0:
3373 if (ftype == ::apache::thrift::protocol::T_LIST) {
3374 {
3375 (*(this->success)).clear();
3376 uint32_t _size166;
3377 ::apache::thrift::protocol::TType _etype169;
3378 xfer += iprot->readListBegin(_etype169, _size166);
3379 (*(this->success)).resize(_size166);
3380 uint32_t _i170;
3381 for (_i170 = 0; _i170 < _size166; ++_i170)
3382 {
3383 xfer += (*(this->success))[_i170].read(iprot);
3384 }
3385 xfer += iprot->readListEnd();
3386 }
3387 this->__isset.success = true;
3388 } else {
3389 xfer += iprot->skip(ftype);
3390 }
3391 break;
3392 case 1:
3393 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
3394 xfer += this->io.read(iprot);
3395 this->__isset.io = 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 Hbase_getRowTs_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
3424 while (true)
3425 {
3426 xfer += iprot->readFieldBegin(fname, ftype, fid);
3427 if (ftype == ::apache::thrift::protocol::T_STOP) {
3428 break;
3429 }
3430 switch (fid)
3431 {
3432 case 1:
3433 if (ftype == ::apache::thrift::protocol::T_STRING) {
3434 xfer += iprot->readBinary(this->tableName);
3435 this->__isset.tableName = true;
3436 } else {
3437 xfer += iprot->skip(ftype);
3438 }
3439 break;
3440 case 2:
3441 if (ftype == ::apache::thrift::protocol::T_STRING) {
3442 xfer += iprot->readBinary(this->row);
3443 this->__isset.row = true;
3444 } else {
3445 xfer += iprot->skip(ftype);
3446 }
3447 break;
3448 case 3:
3449 if (ftype == ::apache::thrift::protocol::T_I64) {
3450 xfer += iprot->readI64(this->timestamp);
3451 this->__isset.timestamp = true;
3452 } else {
3453 xfer += iprot->skip(ftype);
3454 }
3455 break;
3456 case 4:
3457 if (ftype == ::apache::thrift::protocol::T_MAP) {
3458 {
3459 this->attributes.clear();
3460 uint32_t _size171;
3461 ::apache::thrift::protocol::TType _ktype172;
3462 ::apache::thrift::protocol::TType _vtype173;
3463 xfer += iprot->readMapBegin(_ktype172, _vtype173, _size171);
3464 uint32_t _i175;
3465 for (_i175 = 0; _i175 < _size171; ++_i175)
3466 {
3467 Text _key176;
3468 xfer += iprot->readBinary(_key176);
3469 Text& _val177 = this->attributes[_key176];
3470 xfer += iprot->readBinary(_val177);
3471 }
3472 xfer += iprot->readMapEnd();
3473 }
3474 this->__isset.attributes = true;
3475 } else {
3476 xfer += iprot->skip(ftype);
3477 }
3478 break;
3479 default:
3480 xfer += iprot->skip(ftype);
3481 break;
3482 }
3483 xfer += iprot->readFieldEnd();
3484 }
3485
3486 xfer += iprot->readStructEnd();
3487
3488 return xfer;
3489 }
3490
3491 uint32_t Hbase_getRowTs_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
3492 uint32_t xfer = 0;
3493 xfer += oprot->writeStructBegin("Hbase_getRowTs_args");
3494
3495 xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
3496 xfer += oprot->writeBinary(this->tableName);
3497 xfer += oprot->writeFieldEnd();
3498
3499 xfer += oprot->writeFieldBegin("row", ::apache::thrift::protocol::T_STRING, 2);
3500 xfer += oprot->writeBinary(this->row);
3501 xfer += oprot->writeFieldEnd();
3502
3503 xfer += oprot->writeFieldBegin("timestamp", ::apache::thrift::protocol::T_I64, 3);
3504 xfer += oprot->writeI64(this->timestamp);
3505 xfer += oprot->writeFieldEnd();
3506
3507 xfer += oprot->writeFieldBegin("attributes", ::apache::thrift::protocol::T_MAP, 4);
3508 {
3509 xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->attributes.size()));
3510 std::map<Text, Text> ::const_iterator _iter178;
3511 for (_iter178 = this->attributes.begin(); _iter178 != this->attributes.end(); ++_iter178)
3512 {
3513 xfer += oprot->writeBinary(_iter178->first);
3514 xfer += oprot->writeBinary(_iter178->second);
3515 }
3516 xfer += oprot->writeMapEnd();
3517 }
3518 xfer += oprot->writeFieldEnd();
3519
3520 xfer += oprot->writeFieldStop();
3521 xfer += oprot->writeStructEnd();
3522 return xfer;
3523 }
3524
3525 uint32_t Hbase_getRowTs_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
3526 uint32_t xfer = 0;
3527 xfer += oprot->writeStructBegin("Hbase_getRowTs_pargs");
3528
3529 xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
3530 xfer += oprot->writeBinary((*(this->tableName)));
3531 xfer += oprot->writeFieldEnd();
3532
3533 xfer += oprot->writeFieldBegin("row", ::apache::thrift::protocol::T_STRING, 2);
3534 xfer += oprot->writeBinary((*(this->row)));
3535 xfer += oprot->writeFieldEnd();
3536
3537 xfer += oprot->writeFieldBegin("timestamp", ::apache::thrift::protocol::T_I64, 3);
3538 xfer += oprot->writeI64((*(this->timestamp)));
3539 xfer += oprot->writeFieldEnd();
3540
3541 xfer += oprot->writeFieldBegin("attributes", ::apache::thrift::protocol::T_MAP, 4);
3542 {
3543 xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->attributes)).size()));
3544 std::map<Text, Text> ::const_iterator _iter179;
3545 for (_iter179 = (*(this->attributes)).begin(); _iter179 != (*(this->attributes)).end(); ++_iter179)
3546 {
3547 xfer += oprot->writeBinary(_iter179->first);
3548 xfer += oprot->writeBinary(_iter179->second);
3549 }
3550 xfer += oprot->writeMapEnd();
3551 }
3552 xfer += oprot->writeFieldEnd();
3553
3554 xfer += oprot->writeFieldStop();
3555 xfer += oprot->writeStructEnd();
3556 return xfer;
3557 }
3558
3559 uint32_t Hbase_getRowTs_result::read(::apache::thrift::protocol::TProtocol* iprot) {
3560
3561 uint32_t xfer = 0;
3562 std::string fname;
3563 ::apache::thrift::protocol::TType ftype;
3564 int16_t fid;
3565
3566 xfer += iprot->readStructBegin(fname);
3567
3568 using ::apache::thrift::protocol::TProtocolException;
3569
3570
3571 while (true)
3572 {
3573 xfer += iprot->readFieldBegin(fname, ftype, fid);
3574 if (ftype == ::apache::thrift::protocol::T_STOP) {
3575 break;
3576 }
3577 switch (fid)
3578 {
3579 case 0:
3580 if (ftype == ::apache::thrift::protocol::T_LIST) {
3581 {
3582 this->success.clear();
3583 uint32_t _size180;
3584 ::apache::thrift::protocol::TType _etype183;
3585 xfer += iprot->readListBegin(_etype183, _size180);
3586 this->success.resize(_size180);
3587 uint32_t _i184;
3588 for (_i184 = 0; _i184 < _size180; ++_i184)
3589 {
3590 xfer += this->success[_i184].read(iprot);
3591 }
3592 xfer += iprot->readListEnd();
3593 }
3594 this->__isset.success = true;
3595 } else {
3596 xfer += iprot->skip(ftype);
3597 }
3598 break;
3599 case 1:
3600 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
3601 xfer += this->io.read(iprot);
3602 this->__isset.io = true;
3603 } else {
3604 xfer += iprot->skip(ftype);
3605 }
3606 break;
3607 default:
3608 xfer += iprot->skip(ftype);
3609 break;
3610 }
3611 xfer += iprot->readFieldEnd();
3612 }
3613
3614 xfer += iprot->readStructEnd();
3615
3616 return xfer;
3617 }
3618
3619 uint32_t Hbase_getRowTs_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
3620
3621 uint32_t xfer = 0;
3622
3623 xfer += oprot->writeStructBegin("Hbase_getRowTs_result");
3624
3625 if (this->__isset.success) {
3626 xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0);
3627 {
3628 xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->success.size()));
3629 std::vector<TRowResult> ::const_iterator _iter185;
3630 for (_iter185 = this->success.begin(); _iter185 != this->success.end(); ++_iter185)
3631 {
3632 xfer += (*_iter185).write(oprot);
3633 }
3634 xfer += oprot->writeListEnd();
3635 }
3636 xfer += oprot->writeFieldEnd();
3637 } else if (this->__isset.io) {
3638 xfer += oprot->writeFieldBegin("io", ::apache::thrift::protocol::T_STRUCT, 1);
3639 xfer += this->io.write(oprot);
3640 xfer += oprot->writeFieldEnd();
3641 }
3642 xfer += oprot->writeFieldStop();
3643 xfer += oprot->writeStructEnd();
3644 return xfer;
3645 }
3646
3647 uint32_t Hbase_getRowTs_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
3648
3649 uint32_t xfer = 0;
3650 std::string fname;
3651 ::apache::thrift::protocol::TType ftype;
3652 int16_t fid;
3653
3654 xfer += iprot->readStructBegin(fname);
3655
3656 using ::apache::thrift::protocol::TProtocolException;
3657
3658
3659 while (true)
3660 {
3661 xfer += iprot->readFieldBegin(fname, ftype, fid);
3662 if (ftype == ::apache::thrift::protocol::T_STOP) {
3663 break;
3664 }
3665 switch (fid)
3666 {
3667 case 0:
3668 if (ftype == ::apache::thrift::protocol::T_LIST) {
3669 {
3670 (*(this->success)).clear();
3671 uint32_t _size186;
3672 ::apache::thrift::protocol::TType _etype189;
3673 xfer += iprot->readListBegin(_etype189, _size186);
3674 (*(this->success)).resize(_size186);
3675 uint32_t _i190;
3676 for (_i190 = 0; _i190 < _size186; ++_i190)
3677 {
3678 xfer += (*(this->success))[_i190].read(iprot);
3679 }
3680 xfer += iprot->readListEnd();
3681 }
3682 this->__isset.success = true;
3683 } else {
3684 xfer += iprot->skip(ftype);
3685 }
3686 break;
3687 case 1:
3688 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
3689 xfer += this->io.read(iprot);
3690 this->__isset.io = true;
3691 } else {
3692 xfer += iprot->skip(ftype);
3693 }
3694 break;
3695 default:
3696 xfer += iprot->skip(ftype);
3697 break;
3698 }
3699 xfer += iprot->readFieldEnd();
3700 }
3701
3702 xfer += iprot->readStructEnd();
3703
3704 return xfer;
3705 }
3706
3707 uint32_t Hbase_getRowWithColumnsTs_args::read(::apache::thrift::protocol::TProtocol* iprot) {
3708
3709 uint32_t xfer = 0;
3710 std::string fname;
3711 ::apache::thrift::protocol::TType ftype;
3712 int16_t fid;
3713
3714 xfer += iprot->readStructBegin(fname);
3715
3716 using ::apache::thrift::protocol::TProtocolException;
3717
3718
3719 while (true)
3720 {
3721 xfer += iprot->readFieldBegin(fname, ftype, fid);
3722 if (ftype == ::apache::thrift::protocol::T_STOP) {
3723 break;
3724 }
3725 switch (fid)
3726 {
3727 case 1:
3728 if (ftype == ::apache::thrift::protocol::T_STRING) {
3729 xfer += iprot->readBinary(this->tableName);
3730 this->__isset.tableName = true;
3731 } else {
3732 xfer += iprot->skip(ftype);
3733 }
3734 break;
3735 case 2:
3736 if (ftype == ::apache::thrift::protocol::T_STRING) {
3737 xfer += iprot->readBinary(this->row);
3738 this->__isset.row = true;
3739 } else {
3740 xfer += iprot->skip(ftype);
3741 }
3742 break;
3743 case 3:
3744 if (ftype == ::apache::thrift::protocol::T_LIST) {
3745 {
3746 this->columns.clear();
3747 uint32_t _size191;
3748 ::apache::thrift::protocol::TType _etype194;
3749 xfer += iprot->readListBegin(_etype194, _size191);
3750 this->columns.resize(_size191);
3751 uint32_t _i195;
3752 for (_i195 = 0; _i195 < _size191; ++_i195)
3753 {
3754 xfer += iprot->readBinary(this->columns[_i195]);
3755 }
3756 xfer += iprot->readListEnd();
3757 }
3758 this->__isset.columns = true;
3759 } else {
3760 xfer += iprot->skip(ftype);
3761 }
3762 break;
3763 case 4:
3764 if (ftype == ::apache::thrift::protocol::T_I64) {
3765 xfer += iprot->readI64(this->timestamp);
3766 this->__isset.timestamp = true;
3767 } else {
3768 xfer += iprot->skip(ftype);
3769 }
3770 break;
3771 case 5:
3772 if (ftype == ::apache::thrift::protocol::T_MAP) {
3773 {
3774 this->attributes.clear();
3775 uint32_t _size196;
3776 ::apache::thrift::protocol::TType _ktype197;
3777 ::apache::thrift::protocol::TType _vtype198;
3778 xfer += iprot->readMapBegin(_ktype197, _vtype198, _size196);
3779 uint32_t _i200;
3780 for (_i200 = 0; _i200 < _size196; ++_i200)
3781 {
3782 Text _key201;
3783 xfer += iprot->readBinary(_key201);
3784 Text& _val202 = this->attributes[_key201];
3785 xfer += iprot->readBinary(_val202);
3786 }
3787 xfer += iprot->readMapEnd();
3788 }
3789 this->__isset.attributes = true;
3790 } else {
3791 xfer += iprot->skip(ftype);
3792 }
3793 break;
3794 default:
3795 xfer += iprot->skip(ftype);
3796 break;
3797 }
3798 xfer += iprot->readFieldEnd();
3799 }
3800
3801 xfer += iprot->readStructEnd();
3802
3803 return xfer;
3804 }
3805
3806 uint32_t Hbase_getRowWithColumnsTs_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
3807 uint32_t xfer = 0;
3808 xfer += oprot->writeStructBegin("Hbase_getRowWithColumnsTs_args");
3809
3810 xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
3811 xfer += oprot->writeBinary(this->tableName);
3812 xfer += oprot->writeFieldEnd();
3813
3814 xfer += oprot->writeFieldBegin("row", ::apache::thrift::protocol::T_STRING, 2);
3815 xfer += oprot->writeBinary(this->row);
3816 xfer += oprot->writeFieldEnd();
3817
3818 xfer += oprot->writeFieldBegin("columns", ::apache::thrift::protocol::T_LIST, 3);
3819 {
3820 xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->columns.size()));
3821 std::vector<Text> ::const_iterator _iter203;
3822 for (_iter203 = this->columns.begin(); _iter203 != this->columns.end(); ++_iter203)
3823 {
3824 xfer += oprot->writeBinary((*_iter203));
3825 }
3826 xfer += oprot->writeListEnd();
3827 }
3828 xfer += oprot->writeFieldEnd();
3829
3830 xfer += oprot->writeFieldBegin("timestamp", ::apache::thrift::protocol::T_I64, 4);
3831 xfer += oprot->writeI64(this->timestamp);
3832 xfer += oprot->writeFieldEnd();
3833
3834 xfer += oprot->writeFieldBegin("attributes", ::apache::thrift::protocol::T_MAP, 5);
3835 {
3836 xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->attributes.size()));
3837 std::map<Text, Text> ::const_iterator _iter204;
3838 for (_iter204 = this->attributes.begin(); _iter204 != this->attributes.end(); ++_iter204)
3839 {
3840 xfer += oprot->writeBinary(_iter204->first);
3841 xfer += oprot->writeBinary(_iter204->second);
3842 }
3843 xfer += oprot->writeMapEnd();
3844 }
3845 xfer += oprot->writeFieldEnd();
3846
3847 xfer += oprot->writeFieldStop();
3848 xfer += oprot->writeStructEnd();
3849 return xfer;
3850 }
3851
3852 uint32_t Hbase_getRowWithColumnsTs_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
3853 uint32_t xfer = 0;
3854 xfer += oprot->writeStructBegin("Hbase_getRowWithColumnsTs_pargs");
3855
3856 xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
3857 xfer += oprot->writeBinary((*(this->tableName)));
3858 xfer += oprot->writeFieldEnd();
3859
3860 xfer += oprot->writeFieldBegin("row", ::apache::thrift::protocol::T_STRING, 2);
3861 xfer += oprot->writeBinary((*(this->row)));
3862 xfer += oprot->writeFieldEnd();
3863
3864 xfer += oprot->writeFieldBegin("columns", ::apache::thrift::protocol::T_LIST, 3);
3865 {
3866 xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->columns)).size()));
3867 std::vector<Text> ::const_iterator _iter205;
3868 for (_iter205 = (*(this->columns)).begin(); _iter205 != (*(this->columns)).end(); ++_iter205)
3869 {
3870 xfer += oprot->writeBinary((*_iter205));
3871 }
3872 xfer += oprot->writeListEnd();
3873 }
3874 xfer += oprot->writeFieldEnd();
3875
3876 xfer += oprot->writeFieldBegin("timestamp", ::apache::thrift::protocol::T_I64, 4);
3877 xfer += oprot->writeI64((*(this->timestamp)));
3878 xfer += oprot->writeFieldEnd();
3879
3880 xfer += oprot->writeFieldBegin("attributes", ::apache::thrift::protocol::T_MAP, 5);
3881 {
3882 xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->attributes)).size()));
3883 std::map<Text, Text> ::const_iterator _iter206;
3884 for (_iter206 = (*(this->attributes)).begin(); _iter206 != (*(this->attributes)).end(); ++_iter206)
3885 {
3886 xfer += oprot->writeBinary(_iter206->first);
3887 xfer += oprot->writeBinary(_iter206->second);
3888 }
3889 xfer += oprot->writeMapEnd();
3890 }
3891 xfer += oprot->writeFieldEnd();
3892
3893 xfer += oprot->writeFieldStop();
3894 xfer += oprot->writeStructEnd();
3895 return xfer;
3896 }
3897
3898 uint32_t Hbase_getRowWithColumnsTs_result::read(::apache::thrift::protocol::TProtocol* iprot) {
3899
3900 uint32_t xfer = 0;
3901 std::string fname;
3902 ::apache::thrift::protocol::TType ftype;
3903 int16_t fid;
3904
3905 xfer += iprot->readStructBegin(fname);
3906
3907 using ::apache::thrift::protocol::TProtocolException;
3908
3909
3910 while (true)
3911 {
3912 xfer += iprot->readFieldBegin(fname, ftype, fid);
3913 if (ftype == ::apache::thrift::protocol::T_STOP) {
3914 break;
3915 }
3916 switch (fid)
3917 {
3918 case 0:
3919 if (ftype == ::apache::thrift::protocol::T_LIST) {
3920 {
3921 this->success.clear();
3922 uint32_t _size207;
3923 ::apache::thrift::protocol::TType _etype210;
3924 xfer += iprot->readListBegin(_etype210, _size207);
3925 this->success.resize(_size207);
3926 uint32_t _i211;
3927 for (_i211 = 0; _i211 < _size207; ++_i211)
3928 {
3929 xfer += this->success[_i211].read(iprot);
3930 }
3931 xfer += iprot->readListEnd();
3932 }
3933 this->__isset.success = true;
3934 } else {
3935 xfer += iprot->skip(ftype);
3936 }
3937 break;
3938 case 1:
3939 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
3940 xfer += this->io.read(iprot);
3941 this->__isset.io = true;
3942 } else {
3943 xfer += iprot->skip(ftype);
3944 }
3945 break;
3946 default:
3947 xfer += iprot->skip(ftype);
3948 break;
3949 }
3950 xfer += iprot->readFieldEnd();
3951 }
3952
3953 xfer += iprot->readStructEnd();
3954
3955 return xfer;
3956 }
3957
3958 uint32_t Hbase_getRowWithColumnsTs_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
3959
3960 uint32_t xfer = 0;
3961
3962 xfer += oprot->writeStructBegin("Hbase_getRowWithColumnsTs_result");
3963
3964 if (this->__isset.success) {
3965 xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0);
3966 {
3967 xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->success.size()));
3968 std::vector<TRowResult> ::const_iterator _iter212;
3969 for (_iter212 = this->success.begin(); _iter212 != this->success.end(); ++_iter212)
3970 {
3971 xfer += (*_iter212).write(oprot);
3972 }
3973 xfer += oprot->writeListEnd();
3974 }
3975 xfer += oprot->writeFieldEnd();
3976 } else if (this->__isset.io) {
3977 xfer += oprot->writeFieldBegin("io", ::apache::thrift::protocol::T_STRUCT, 1);
3978 xfer += this->io.write(oprot);
3979 xfer += oprot->writeFieldEnd();
3980 }
3981 xfer += oprot->writeFieldStop();
3982 xfer += oprot->writeStructEnd();
3983 return xfer;
3984 }
3985
3986 uint32_t Hbase_getRowWithColumnsTs_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
3987
3988 uint32_t xfer = 0;
3989 std::string fname;
3990 ::apache::thrift::protocol::TType ftype;
3991 int16_t fid;
3992
3993 xfer += iprot->readStructBegin(fname);
3994
3995 using ::apache::thrift::protocol::TProtocolException;
3996
3997
3998 while (true)
3999 {
4000 xfer += iprot->readFieldBegin(fname, ftype, fid);
4001 if (ftype == ::apache::thrift::protocol::T_STOP) {
4002 break;
4003 }
4004 switch (fid)
4005 {
4006 case 0:
4007 if (ftype == ::apache::thrift::protocol::T_LIST) {
4008 {
4009 (*(this->success)).clear();
4010 uint32_t _size213;
4011 ::apache::thrift::protocol::TType _etype216;
4012 xfer += iprot->readListBegin(_etype216, _size213);
4013 (*(this->success)).resize(_size213);
4014 uint32_t _i217;
4015 for (_i217 = 0; _i217 < _size213; ++_i217)
4016 {
4017 xfer += (*(this->success))[_i217].read(iprot);
4018 }
4019 xfer += iprot->readListEnd();
4020 }
4021 this->__isset.success = true;
4022 } else {
4023 xfer += iprot->skip(ftype);
4024 }
4025 break;
4026 case 1:
4027 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
4028 xfer += this->io.read(iprot);
4029 this->__isset.io = true;
4030 } else {
4031 xfer += iprot->skip(ftype);
4032 }
4033 break;
4034 default:
4035 xfer += iprot->skip(ftype);
4036 break;
4037 }
4038 xfer += iprot->readFieldEnd();
4039 }
4040
4041 xfer += iprot->readStructEnd();
4042
4043 return xfer;
4044 }
4045
4046 uint32_t Hbase_getRows_args::read(::apache::thrift::protocol::TProtocol* iprot) {
4047
4048 uint32_t xfer = 0;
4049 std::string fname;
4050 ::apache::thrift::protocol::TType ftype;
4051 int16_t fid;
4052
4053 xfer += iprot->readStructBegin(fname);
4054
4055 using ::apache::thrift::protocol::TProtocolException;
4056
4057
4058 while (true)
4059 {
4060 xfer += iprot->readFieldBegin(fname, ftype, fid);
4061 if (ftype == ::apache::thrift::protocol::T_STOP) {
4062 break;
4063 }
4064 switch (fid)
4065 {
4066 case 1:
4067 if (ftype == ::apache::thrift::protocol::T_STRING) {
4068 xfer += iprot->readBinary(this->tableName);
4069 this->__isset.tableName = true;
4070 } else {
4071 xfer += iprot->skip(ftype);
4072 }
4073 break;
4074 case 2:
4075 if (ftype == ::apache::thrift::protocol::T_LIST) {
4076 {
4077 this->rows.clear();
4078 uint32_t _size218;
4079 ::apache::thrift::protocol::TType _etype221;
4080 xfer += iprot->readListBegin(_etype221, _size218);
4081 this->rows.resize(_size218);
4082 uint32_t _i222;
4083 for (_i222 = 0; _i222 < _size218; ++_i222)
4084 {
4085 xfer += iprot->readBinary(this->rows[_i222]);
4086 }
4087 xfer += iprot->readListEnd();
4088 }
4089 this->__isset.rows = true;
4090 } else {
4091 xfer += iprot->skip(ftype);
4092 }
4093 break;
4094 case 3:
4095 if (ftype == ::apache::thrift::protocol::T_MAP) {
4096 {
4097 this->attributes.clear();
4098 uint32_t _size223;
4099 ::apache::thrift::protocol::TType _ktype224;
4100 ::apache::thrift::protocol::TType _vtype225;
4101 xfer += iprot->readMapBegin(_ktype224, _vtype225, _size223);
4102 uint32_t _i227;
4103 for (_i227 = 0; _i227 < _size223; ++_i227)
4104 {
4105 Text _key228;
4106 xfer += iprot->readBinary(_key228);
4107 Text& _val229 = this->attributes[_key228];
4108 xfer += iprot->readBinary(_val229);
4109 }
4110 xfer += iprot->readMapEnd();
4111 }
4112 this->__isset.attributes = true;
4113 } else {
4114 xfer += iprot->skip(ftype);
4115 }
4116 break;
4117 default:
4118 xfer += iprot->skip(ftype);
4119 break;
4120 }
4121 xfer += iprot->readFieldEnd();
4122 }
4123
4124 xfer += iprot->readStructEnd();
4125
4126 return xfer;
4127 }
4128
4129 uint32_t Hbase_getRows_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
4130 uint32_t xfer = 0;
4131 xfer += oprot->writeStructBegin("Hbase_getRows_args");
4132
4133 xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
4134 xfer += oprot->writeBinary(this->tableName);
4135 xfer += oprot->writeFieldEnd();
4136
4137 xfer += oprot->writeFieldBegin("rows", ::apache::thrift::protocol::T_LIST, 2);
4138 {
4139 xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->rows.size()));
4140 std::vector<Text> ::const_iterator _iter230;
4141 for (_iter230 = this->rows.begin(); _iter230 != this->rows.end(); ++_iter230)
4142 {
4143 xfer += oprot->writeBinary((*_iter230));
4144 }
4145 xfer += oprot->writeListEnd();
4146 }
4147 xfer += oprot->writeFieldEnd();
4148
4149 xfer += oprot->writeFieldBegin("attributes", ::apache::thrift::protocol::T_MAP, 3);
4150 {
4151 xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->attributes.size()));
4152 std::map<Text, Text> ::const_iterator _iter231;
4153 for (_iter231 = this->attributes.begin(); _iter231 != this->attributes.end(); ++_iter231)
4154 {
4155 xfer += oprot->writeBinary(_iter231->first);
4156 xfer += oprot->writeBinary(_iter231->second);
4157 }
4158 xfer += oprot->writeMapEnd();
4159 }
4160 xfer += oprot->writeFieldEnd();
4161
4162 xfer += oprot->writeFieldStop();
4163 xfer += oprot->writeStructEnd();
4164 return xfer;
4165 }
4166
4167 uint32_t Hbase_getRows_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
4168 uint32_t xfer = 0;
4169 xfer += oprot->writeStructBegin("Hbase_getRows_pargs");
4170
4171 xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
4172 xfer += oprot->writeBinary((*(this->tableName)));
4173 xfer += oprot->writeFieldEnd();
4174
4175 xfer += oprot->writeFieldBegin("rows", ::apache::thrift::protocol::T_LIST, 2);
4176 {
4177 xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->rows)).size()));
4178 std::vector<Text> ::const_iterator _iter232;
4179 for (_iter232 = (*(this->rows)).begin(); _iter232 != (*(this->rows)).end(); ++_iter232)
4180 {
4181 xfer += oprot->writeBinary((*_iter232));
4182 }
4183 xfer += oprot->writeListEnd();
4184 }
4185 xfer += oprot->writeFieldEnd();
4186
4187 xfer += oprot->writeFieldBegin("attributes", ::apache::thrift::protocol::T_MAP, 3);
4188 {
4189 xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->attributes)).size()));
4190 std::map<Text, Text> ::const_iterator _iter233;
4191 for (_iter233 = (*(this->attributes)).begin(); _iter233 != (*(this->attributes)).end(); ++_iter233)
4192 {
4193 xfer += oprot->writeBinary(_iter233->first);
4194 xfer += oprot->writeBinary(_iter233->second);
4195 }
4196 xfer += oprot->writeMapEnd();
4197 }
4198 xfer += oprot->writeFieldEnd();
4199
4200 xfer += oprot->writeFieldStop();
4201 xfer += oprot->writeStructEnd();
4202 return xfer;
4203 }
4204
4205 uint32_t Hbase_getRows_result::read(::apache::thrift::protocol::TProtocol* iprot) {
4206
4207 uint32_t xfer = 0;
4208 std::string fname;
4209 ::apache::thrift::protocol::TType ftype;
4210 int16_t fid;
4211
4212 xfer += iprot->readStructBegin(fname);
4213
4214 using ::apache::thrift::protocol::TProtocolException;
4215
4216
4217 while (true)
4218 {
4219 xfer += iprot->readFieldBegin(fname, ftype, fid);
4220 if (ftype == ::apache::thrift::protocol::T_STOP) {
4221 break;
4222 }
4223 switch (fid)
4224 {
4225 case 0:
4226 if (ftype == ::apache::thrift::protocol::T_LIST) {
4227 {
4228 this->success.clear();
4229 uint32_t _size234;
4230 ::apache::thrift::protocol::TType _etype237;
4231 xfer += iprot->readListBegin(_etype237, _size234);
4232 this->success.resize(_size234);
4233 uint32_t _i238;
4234 for (_i238 = 0; _i238 < _size234; ++_i238)
4235 {
4236 xfer += this->success[_i238].read(iprot);
4237 }
4238 xfer += iprot->readListEnd();
4239 }
4240 this->__isset.success = true;
4241 } else {
4242 xfer += iprot->skip(ftype);
4243 }
4244 break;
4245 case 1:
4246 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
4247 xfer += this->io.read(iprot);
4248 this->__isset.io = true;
4249 } else {
4250 xfer += iprot->skip(ftype);
4251 }
4252 break;
4253 default:
4254 xfer += iprot->skip(ftype);
4255 break;
4256 }
4257 xfer += iprot->readFieldEnd();
4258 }
4259
4260 xfer += iprot->readStructEnd();
4261
4262 return xfer;
4263 }
4264
4265 uint32_t Hbase_getRows_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
4266
4267 uint32_t xfer = 0;
4268
4269 xfer += oprot->writeStructBegin("Hbase_getRows_result");
4270
4271 if (this->__isset.success) {
4272 xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0);
4273 {
4274 xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->success.size()));
4275 std::vector<TRowResult> ::const_iterator _iter239;
4276 for (_iter239 = this->success.begin(); _iter239 != this->success.end(); ++_iter239)
4277 {
4278 xfer += (*_iter239).write(oprot);
4279 }
4280 xfer += oprot->writeListEnd();
4281 }
4282 xfer += oprot->writeFieldEnd();
4283 } else if (this->__isset.io) {
4284 xfer += oprot->writeFieldBegin("io", ::apache::thrift::protocol::T_STRUCT, 1);
4285 xfer += this->io.write(oprot);
4286 xfer += oprot->writeFieldEnd();
4287 }
4288 xfer += oprot->writeFieldStop();
4289 xfer += oprot->writeStructEnd();
4290 return xfer;
4291 }
4292
4293 uint32_t Hbase_getRows_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
4294
4295 uint32_t xfer = 0;
4296 std::string fname;
4297 ::apache::thrift::protocol::TType ftype;
4298 int16_t fid;
4299
4300 xfer += iprot->readStructBegin(fname);
4301
4302 using ::apache::thrift::protocol::TProtocolException;
4303
4304
4305 while (true)
4306 {
4307 xfer += iprot->readFieldBegin(fname, ftype, fid);
4308 if (ftype == ::apache::thrift::protocol::T_STOP) {
4309 break;
4310 }
4311 switch (fid)
4312 {
4313 case 0:
4314 if (ftype == ::apache::thrift::protocol::T_LIST) {
4315 {
4316 (*(this->success)).clear();
4317 uint32_t _size240;
4318 ::apache::thrift::protocol::TType _etype243;
4319 xfer += iprot->readListBegin(_etype243, _size240);
4320 (*(this->success)).resize(_size240);
4321 uint32_t _i244;
4322 for (_i244 = 0; _i244 < _size240; ++_i244)
4323 {
4324 xfer += (*(this->success))[_i244].read(iprot);
4325 }
4326 xfer += iprot->readListEnd();
4327 }
4328 this->__isset.success = true;
4329 } else {
4330 xfer += iprot->skip(ftype);
4331 }
4332 break;
4333 case 1:
4334 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
4335 xfer += this->io.read(iprot);
4336 this->__isset.io = true;
4337 } else {
4338 xfer += iprot->skip(ftype);
4339 }
4340 break;
4341 default:
4342 xfer += iprot->skip(ftype);
4343 break;
4344 }
4345 xfer += iprot->readFieldEnd();
4346 }
4347
4348 xfer += iprot->readStructEnd();
4349
4350 return xfer;
4351 }
4352
4353 uint32_t Hbase_getRowsWithColumns_args::read(::apache::thrift::protocol::TProtocol* iprot) {
4354
4355 uint32_t xfer = 0;
4356 std::string fname;
4357 ::apache::thrift::protocol::TType ftype;
4358 int16_t fid;
4359
4360 xfer += iprot->readStructBegin(fname);
4361
4362 using ::apache::thrift::protocol::TProtocolException;
4363
4364
4365 while (true)
4366 {
4367 xfer += iprot->readFieldBegin(fname, ftype, fid);
4368 if (ftype == ::apache::thrift::protocol::T_STOP) {
4369 break;
4370 }
4371 switch (fid)
4372 {
4373 case 1:
4374 if (ftype == ::apache::thrift::protocol::T_STRING) {
4375 xfer += iprot->readBinary(this->tableName);
4376 this->__isset.tableName = true;
4377 } else {
4378 xfer += iprot->skip(ftype);
4379 }
4380 break;
4381 case 2:
4382 if (ftype == ::apache::thrift::protocol::T_LIST) {
4383 {
4384 this->rows.clear();
4385 uint32_t _size245;
4386 ::apache::thrift::protocol::TType _etype248;
4387 xfer += iprot->readListBegin(_etype248, _size245);
4388 this->rows.resize(_size245);
4389 uint32_t _i249;
4390 for (_i249 = 0; _i249 < _size245; ++_i249)
4391 {
4392 xfer += iprot->readBinary(this->rows[_i249]);
4393 }
4394 xfer += iprot->readListEnd();
4395 }
4396 this->__isset.rows = true;
4397 } else {
4398 xfer += iprot->skip(ftype);
4399 }
4400 break;
4401 case 3:
4402 if (ftype == ::apache::thrift::protocol::T_LIST) {
4403 {
4404 this->columns.clear();
4405 uint32_t _size250;
4406 ::apache::thrift::protocol::TType _etype253;
4407 xfer += iprot->readListBegin(_etype253, _size250);
4408 this->columns.resize(_size250);
4409 uint32_t _i254;
4410 for (_i254 = 0; _i254 < _size250; ++_i254)
4411 {
4412 xfer += iprot->readBinary(this->columns[_i254]);
4413 }
4414 xfer += iprot->readListEnd();
4415 }
4416 this->__isset.columns = true;
4417 } else {
4418 xfer += iprot->skip(ftype);
4419 }
4420 break;
4421 case 4:
4422 if (ftype == ::apache::thrift::protocol::T_MAP) {
4423 {
4424 this->attributes.clear();
4425 uint32_t _size255;
4426 ::apache::thrift::protocol::TType _ktype256;
4427 ::apache::thrift::protocol::TType _vtype257;
4428 xfer += iprot->readMapBegin(_ktype256, _vtype257, _size255);
4429 uint32_t _i259;
4430 for (_i259 = 0; _i259 < _size255; ++_i259)
4431 {
4432 Text _key260;
4433 xfer += iprot->readBinary(_key260);
4434 Text& _val261 = this->attributes[_key260];
4435 xfer += iprot->readBinary(_val261);
4436 }
4437 xfer += iprot->readMapEnd();
4438 }
4439 this->__isset.attributes = true;
4440 } else {
4441 xfer += iprot->skip(ftype);
4442 }
4443 break;
4444 default:
4445 xfer += iprot->skip(ftype);
4446 break;
4447 }
4448 xfer += iprot->readFieldEnd();
4449 }
4450
4451 xfer += iprot->readStructEnd();
4452
4453 return xfer;
4454 }
4455
4456 uint32_t Hbase_getRowsWithColumns_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
4457 uint32_t xfer = 0;
4458 xfer += oprot->writeStructBegin("Hbase_getRowsWithColumns_args");
4459
4460 xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
4461 xfer += oprot->writeBinary(this->tableName);
4462 xfer += oprot->writeFieldEnd();
4463
4464 xfer += oprot->writeFieldBegin("rows", ::apache::thrift::protocol::T_LIST, 2);
4465 {
4466 xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->rows.size()));
4467 std::vector<Text> ::const_iterator _iter262;
4468 for (_iter262 = this->rows.begin(); _iter262 != this->rows.end(); ++_iter262)
4469 {
4470 xfer += oprot->writeBinary((*_iter262));
4471 }
4472 xfer += oprot->writeListEnd();
4473 }
4474 xfer += oprot->writeFieldEnd();
4475
4476 xfer += oprot->writeFieldBegin("columns", ::apache::thrift::protocol::T_LIST, 3);
4477 {
4478 xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->columns.size()));
4479 std::vector<Text> ::const_iterator _iter263;
4480 for (_iter263 = this->columns.begin(); _iter263 != this->columns.end(); ++_iter263)
4481 {
4482 xfer += oprot->writeBinary((*_iter263));
4483 }
4484 xfer += oprot->writeListEnd();
4485 }
4486 xfer += oprot->writeFieldEnd();
4487
4488 xfer += oprot->writeFieldBegin("attributes", ::apache::thrift::protocol::T_MAP, 4);
4489 {
4490 xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->attributes.size()));
4491 std::map<Text, Text> ::const_iterator _iter264;
4492 for (_iter264 = this->attributes.begin(); _iter264 != this->attributes.end(); ++_iter264)
4493 {
4494 xfer += oprot->writeBinary(_iter264->first);
4495 xfer += oprot->writeBinary(_iter264->second);
4496 }
4497 xfer += oprot->writeMapEnd();
4498 }
4499 xfer += oprot->writeFieldEnd();
4500
4501 xfer += oprot->writeFieldStop();
4502 xfer += oprot->writeStructEnd();
4503 return xfer;
4504 }
4505
4506 uint32_t Hbase_getRowsWithColumns_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
4507 uint32_t xfer = 0;
4508 xfer += oprot->writeStructBegin("Hbase_getRowsWithColumns_pargs");
4509
4510 xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
4511 xfer += oprot->writeBinary((*(this->tableName)));
4512 xfer += oprot->writeFieldEnd();
4513
4514 xfer += oprot->writeFieldBegin("rows", ::apache::thrift::protocol::T_LIST, 2);
4515 {
4516 xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->rows)).size()));
4517 std::vector<Text> ::const_iterator _iter265;
4518 for (_iter265 = (*(this->rows)).begin(); _iter265 != (*(this->rows)).end(); ++_iter265)
4519 {
4520 xfer += oprot->writeBinary((*_iter265));
4521 }
4522 xfer += oprot->writeListEnd();
4523 }
4524 xfer += oprot->writeFieldEnd();
4525
4526 xfer += oprot->writeFieldBegin("columns", ::apache::thrift::protocol::T_LIST, 3);
4527 {
4528 xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->columns)).size()));
4529 std::vector<Text> ::const_iterator _iter266;
4530 for (_iter266 = (*(this->columns)).begin(); _iter266 != (*(this->columns)).end(); ++_iter266)
4531 {
4532 xfer += oprot->writeBinary((*_iter266));
4533 }
4534 xfer += oprot->writeListEnd();
4535 }
4536 xfer += oprot->writeFieldEnd();
4537
4538 xfer += oprot->writeFieldBegin("attributes", ::apache::thrift::protocol::T_MAP, 4);
4539 {
4540 xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->attributes)).size()));
4541 std::map<Text, Text> ::const_iterator _iter267;
4542 for (_iter267 = (*(this->attributes)).begin(); _iter267 != (*(this->attributes)).end(); ++_iter267)
4543 {
4544 xfer += oprot->writeBinary(_iter267->first);
4545 xfer += oprot->writeBinary(_iter267->second);
4546 }
4547 xfer += oprot->writeMapEnd();
4548 }
4549 xfer += oprot->writeFieldEnd();
4550
4551 xfer += oprot->writeFieldStop();
4552 xfer += oprot->writeStructEnd();
4553 return xfer;
4554 }
4555
4556 uint32_t Hbase_getRowsWithColumns_result::read(::apache::thrift::protocol::TProtocol* iprot) {
4557
4558 uint32_t xfer = 0;
4559 std::string fname;
4560 ::apache::thrift::protocol::TType ftype;
4561 int16_t fid;
4562
4563 xfer += iprot->readStructBegin(fname);
4564
4565 using ::apache::thrift::protocol::TProtocolException;
4566
4567
4568 while (true)
4569 {
4570 xfer += iprot->readFieldBegin(fname, ftype, fid);
4571 if (ftype == ::apache::thrift::protocol::T_STOP) {
4572 break;
4573 }
4574 switch (fid)
4575 {
4576 case 0:
4577 if (ftype == ::apache::thrift::protocol::T_LIST) {
4578 {
4579 this->success.clear();
4580 uint32_t _size268;
4581 ::apache::thrift::protocol::TType _etype271;
4582 xfer += iprot->readListBegin(_etype271, _size268);
4583 this->success.resize(_size268);
4584 uint32_t _i272;
4585 for (_i272 = 0; _i272 < _size268; ++_i272)
4586 {
4587 xfer += this->success[_i272].read(iprot);
4588 }
4589 xfer += iprot->readListEnd();
4590 }
4591 this->__isset.success = true;
4592 } else {
4593 xfer += iprot->skip(ftype);
4594 }
4595 break;
4596 case 1:
4597 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
4598 xfer += this->io.read(iprot);
4599 this->__isset.io = true;
4600 } else {
4601 xfer += iprot->skip(ftype);
4602 }
4603 break;
4604 default:
4605 xfer += iprot->skip(ftype);
4606 break;
4607 }
4608 xfer += iprot->readFieldEnd();
4609 }
4610
4611 xfer += iprot->readStructEnd();
4612
4613 return xfer;
4614 }
4615
4616 uint32_t Hbase_getRowsWithColumns_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
4617
4618 uint32_t xfer = 0;
4619
4620 xfer += oprot->writeStructBegin("Hbase_getRowsWithColumns_result");
4621
4622 if (this->__isset.success) {
4623 xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0);
4624 {
4625 xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->success.size()));
4626 std::vector<TRowResult> ::const_iterator _iter273;
4627 for (_iter273 = this->success.begin(); _iter273 != this->success.end(); ++_iter273)
4628 {
4629 xfer += (*_iter273).write(oprot);
4630 }
4631 xfer += oprot->writeListEnd();
4632 }
4633 xfer += oprot->writeFieldEnd();
4634 } else if (this->__isset.io) {
4635 xfer += oprot->writeFieldBegin("io", ::apache::thrift::protocol::T_STRUCT, 1);
4636 xfer += this->io.write(oprot);
4637 xfer += oprot->writeFieldEnd();
4638 }
4639 xfer += oprot->writeFieldStop();
4640 xfer += oprot->writeStructEnd();
4641 return xfer;
4642 }
4643
4644 uint32_t Hbase_getRowsWithColumns_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
4645
4646 uint32_t xfer = 0;
4647 std::string fname;
4648 ::apache::thrift::protocol::TType ftype;
4649 int16_t fid;
4650
4651 xfer += iprot->readStructBegin(fname);
4652
4653 using ::apache::thrift::protocol::TProtocolException;
4654
4655
4656 while (true)
4657 {
4658 xfer += iprot->readFieldBegin(fname, ftype, fid);
4659 if (ftype == ::apache::thrift::protocol::T_STOP) {
4660 break;
4661 }
4662 switch (fid)
4663 {
4664 case 0:
4665 if (ftype == ::apache::thrift::protocol::T_LIST) {
4666 {
4667 (*(this->success)).clear();
4668 uint32_t _size274;
4669 ::apache::thrift::protocol::TType _etype277;
4670 xfer += iprot->readListBegin(_etype277, _size274);
4671 (*(this->success)).resize(_size274);
4672 uint32_t _i278;
4673 for (_i278 = 0; _i278 < _size274; ++_i278)
4674 {
4675 xfer += (*(this->success))[_i278].read(iprot);
4676 }
4677 xfer += iprot->readListEnd();
4678 }
4679 this->__isset.success = true;
4680 } else {
4681 xfer += iprot->skip(ftype);
4682 }
4683 break;
4684 case 1:
4685 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
4686 xfer += this->io.read(iprot);
4687 this->__isset.io = true;
4688 } else {
4689 xfer += iprot->skip(ftype);
4690 }
4691 break;
4692 default:
4693 xfer += iprot->skip(ftype);
4694 break;
4695 }
4696 xfer += iprot->readFieldEnd();
4697 }
4698
4699 xfer += iprot->readStructEnd();
4700
4701 return xfer;
4702 }
4703
4704 uint32_t Hbase_getRowsTs_args::read(::apache::thrift::protocol::TProtocol* iprot) {
4705
4706 uint32_t xfer = 0;
4707 std::string fname;
4708 ::apache::thrift::protocol::TType ftype;
4709 int16_t fid;
4710
4711 xfer += iprot->readStructBegin(fname);
4712
4713 using ::apache::thrift::protocol::TProtocolException;
4714
4715
4716 while (true)
4717 {
4718 xfer += iprot->readFieldBegin(fname, ftype, fid);
4719 if (ftype == ::apache::thrift::protocol::T_STOP) {
4720 break;
4721 }
4722 switch (fid)
4723 {
4724 case 1:
4725 if (ftype == ::apache::thrift::protocol::T_STRING) {
4726 xfer += iprot->readBinary(this->tableName);
4727 this->__isset.tableName = true;
4728 } else {
4729 xfer += iprot->skip(ftype);
4730 }
4731 break;
4732 case 2:
4733 if (ftype == ::apache::thrift::protocol::T_LIST) {
4734 {
4735 this->rows.clear();
4736 uint32_t _size279;
4737 ::apache::thrift::protocol::TType _etype282;
4738 xfer += iprot->readListBegin(_etype282, _size279);
4739 this->rows.resize(_size279);
4740 uint32_t _i283;
4741 for (_i283 = 0; _i283 < _size279; ++_i283)
4742 {
4743 xfer += iprot->readBinary(this->rows[_i283]);
4744 }
4745 xfer += iprot->readListEnd();
4746 }
4747 this->__isset.rows = true;
4748 } else {
4749 xfer += iprot->skip(ftype);
4750 }
4751 break;
4752 case 3:
4753 if (ftype == ::apache::thrift::protocol::T_I64) {
4754 xfer += iprot->readI64(this->timestamp);
4755 this->__isset.timestamp = true;
4756 } else {
4757 xfer += iprot->skip(ftype);
4758 }
4759 break;
4760 case 4:
4761 if (ftype == ::apache::thrift::protocol::T_MAP) {
4762 {
4763 this->attributes.clear();
4764 uint32_t _size284;
4765 ::apache::thrift::protocol::TType _ktype285;
4766 ::apache::thrift::protocol::TType _vtype286;
4767 xfer += iprot->readMapBegin(_ktype285, _vtype286, _size284);
4768 uint32_t _i288;
4769 for (_i288 = 0; _i288 < _size284; ++_i288)
4770 {
4771 Text _key289;
4772 xfer += iprot->readBinary(_key289);
4773 Text& _val290 = this->attributes[_key289];
4774 xfer += iprot->readBinary(_val290);
4775 }
4776 xfer += iprot->readMapEnd();
4777 }
4778 this->__isset.attributes = true;
4779 } else {
4780 xfer += iprot->skip(ftype);
4781 }
4782 break;
4783 default:
4784 xfer += iprot->skip(ftype);
4785 break;
4786 }
4787 xfer += iprot->readFieldEnd();
4788 }
4789
4790 xfer += iprot->readStructEnd();
4791
4792 return xfer;
4793 }
4794
4795 uint32_t Hbase_getRowsTs_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
4796 uint32_t xfer = 0;
4797 xfer += oprot->writeStructBegin("Hbase_getRowsTs_args");
4798
4799 xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
4800 xfer += oprot->writeBinary(this->tableName);
4801 xfer += oprot->writeFieldEnd();
4802
4803 xfer += oprot->writeFieldBegin("rows", ::apache::thrift::protocol::T_LIST, 2);
4804 {
4805 xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->rows.size()));
4806 std::vector<Text> ::const_iterator _iter291;
4807 for (_iter291 = this->rows.begin(); _iter291 != this->rows.end(); ++_iter291)
4808 {
4809 xfer += oprot->writeBinary((*_iter291));
4810 }
4811 xfer += oprot->writeListEnd();
4812 }
4813 xfer += oprot->writeFieldEnd();
4814
4815 xfer += oprot->writeFieldBegin("timestamp", ::apache::thrift::protocol::T_I64, 3);
4816 xfer += oprot->writeI64(this->timestamp);
4817 xfer += oprot->writeFieldEnd();
4818
4819 xfer += oprot->writeFieldBegin("attributes", ::apache::thrift::protocol::T_MAP, 4);
4820 {
4821 xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->attributes.size()));
4822 std::map<Text, Text> ::const_iterator _iter292;
4823 for (_iter292 = this->attributes.begin(); _iter292 != this->attributes.end(); ++_iter292)
4824 {
4825 xfer += oprot->writeBinary(_iter292->first);
4826 xfer += oprot->writeBinary(_iter292->second);
4827 }
4828 xfer += oprot->writeMapEnd();
4829 }
4830 xfer += oprot->writeFieldEnd();
4831
4832 xfer += oprot->writeFieldStop();
4833 xfer += oprot->writeStructEnd();
4834 return xfer;
4835 }
4836
4837 uint32_t Hbase_getRowsTs_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
4838 uint32_t xfer = 0;
4839 xfer += oprot->writeStructBegin("Hbase_getRowsTs_pargs");
4840
4841 xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
4842 xfer += oprot->writeBinary((*(this->tableName)));
4843 xfer += oprot->writeFieldEnd();
4844
4845 xfer += oprot->writeFieldBegin("rows", ::apache::thrift::protocol::T_LIST, 2);
4846 {
4847 xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->rows)).size()));
4848 std::vector<Text> ::const_iterator _iter293;
4849 for (_iter293 = (*(this->rows)).begin(); _iter293 != (*(this->rows)).end(); ++_iter293)
4850 {
4851 xfer += oprot->writeBinary((*_iter293));
4852 }
4853 xfer += oprot->writeListEnd();
4854 }
4855 xfer += oprot->writeFieldEnd();
4856
4857 xfer += oprot->writeFieldBegin("timestamp", ::apache::thrift::protocol::T_I64, 3);
4858 xfer += oprot->writeI64((*(this->timestamp)));
4859 xfer += oprot->writeFieldEnd();
4860
4861 xfer += oprot->writeFieldBegin("attributes", ::apache::thrift::protocol::T_MAP, 4);
4862 {
4863 xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->attributes)).size()));
4864 std::map<Text, Text> ::const_iterator _iter294;
4865 for (_iter294 = (*(this->attributes)).begin(); _iter294 != (*(this->attributes)).end(); ++_iter294)
4866 {
4867 xfer += oprot->writeBinary(_iter294->first);
4868 xfer += oprot->writeBinary(_iter294->second);
4869 }
4870 xfer += oprot->writeMapEnd();
4871 }
4872 xfer += oprot->writeFieldEnd();
4873
4874 xfer += oprot->writeFieldStop();
4875 xfer += oprot->writeStructEnd();
4876 return xfer;
4877 }
4878
4879 uint32_t Hbase_getRowsTs_result::read(::apache::thrift::protocol::TProtocol* iprot) {
4880
4881 uint32_t xfer = 0;
4882 std::string fname;
4883 ::apache::thrift::protocol::TType ftype;
4884 int16_t fid;
4885
4886 xfer += iprot->readStructBegin(fname);
4887
4888 using ::apache::thrift::protocol::TProtocolException;
4889
4890
4891 while (true)
4892 {
4893 xfer += iprot->readFieldBegin(fname, ftype, fid);
4894 if (ftype == ::apache::thrift::protocol::T_STOP) {
4895 break;
4896 }
4897 switch (fid)
4898 {
4899 case 0:
4900 if (ftype == ::apache::thrift::protocol::T_LIST) {
4901 {
4902 this->success.clear();
4903 uint32_t _size295;
4904 ::apache::thrift::protocol::TType _etype298;
4905 xfer += iprot->readListBegin(_etype298, _size295);
4906 this->success.resize(_size295);
4907 uint32_t _i299;
4908 for (_i299 = 0; _i299 < _size295; ++_i299)
4909 {
4910 xfer += this->success[_i299].read(iprot);
4911 }
4912 xfer += iprot->readListEnd();
4913 }
4914 this->__isset.success = true;
4915 } else {
4916 xfer += iprot->skip(ftype);
4917 }
4918 break;
4919 case 1:
4920 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
4921 xfer += this->io.read(iprot);
4922 this->__isset.io = true;
4923 } else {
4924 xfer += iprot->skip(ftype);
4925 }
4926 break;
4927 default:
4928 xfer += iprot->skip(ftype);
4929 break;
4930 }
4931 xfer += iprot->readFieldEnd();
4932 }
4933
4934 xfer += iprot->readStructEnd();
4935
4936 return xfer;
4937 }
4938
4939 uint32_t Hbase_getRowsTs_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
4940
4941 uint32_t xfer = 0;
4942
4943 xfer += oprot->writeStructBegin("Hbase_getRowsTs_result");
4944
4945 if (this->__isset.success) {
4946 xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0);
4947 {
4948 xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->success.size()));
4949 std::vector<TRowResult> ::const_iterator _iter300;
4950 for (_iter300 = this->success.begin(); _iter300 != this->success.end(); ++_iter300)
4951 {
4952 xfer += (*_iter300).write(oprot);
4953 }
4954 xfer += oprot->writeListEnd();
4955 }
4956 xfer += oprot->writeFieldEnd();
4957 } else if (this->__isset.io) {
4958 xfer += oprot->writeFieldBegin("io", ::apache::thrift::protocol::T_STRUCT, 1);
4959 xfer += this->io.write(oprot);
4960 xfer += oprot->writeFieldEnd();
4961 }
4962 xfer += oprot->writeFieldStop();
4963 xfer += oprot->writeStructEnd();
4964 return xfer;
4965 }
4966
4967 uint32_t Hbase_getRowsTs_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
4968
4969 uint32_t xfer = 0;
4970 std::string fname;
4971 ::apache::thrift::protocol::TType ftype;
4972 int16_t fid;
4973
4974 xfer += iprot->readStructBegin(fname);
4975
4976 using ::apache::thrift::protocol::TProtocolException;
4977
4978
4979 while (true)
4980 {
4981 xfer += iprot->readFieldBegin(fname, ftype, fid);
4982 if (ftype == ::apache::thrift::protocol::T_STOP) {
4983 break;
4984 }
4985 switch (fid)
4986 {
4987 case 0:
4988 if (ftype == ::apache::thrift::protocol::T_LIST) {
4989 {
4990 (*(this->success)).clear();
4991 uint32_t _size301;
4992 ::apache::thrift::protocol::TType _etype304;
4993 xfer += iprot->readListBegin(_etype304, _size301);
4994 (*(this->success)).resize(_size301);
4995 uint32_t _i305;
4996 for (_i305 = 0; _i305 < _size301; ++_i305)
4997 {
4998 xfer += (*(this->success))[_i305].read(iprot);
4999 }
5000 xfer += iprot->readListEnd();
5001 }
5002 this->__isset.success = true;
5003 } else {
5004 xfer += iprot->skip(ftype);
5005 }
5006 break;
5007 case 1:
5008 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
5009 xfer += this->io.read(iprot);
5010 this->__isset.io = true;
5011 } else {
5012 xfer += iprot->skip(ftype);
5013 }
5014 break;
5015 default:
5016 xfer += iprot->skip(ftype);
5017 break;
5018 }
5019 xfer += iprot->readFieldEnd();
5020 }
5021
5022 xfer += iprot->readStructEnd();
5023
5024 return xfer;
5025 }
5026
5027 uint32_t Hbase_getRowsWithColumnsTs_args::read(::apache::thrift::protocol::TProtocol* iprot) {
5028
5029 uint32_t xfer = 0;
5030 std::string fname;
5031 ::apache::thrift::protocol::TType ftype;
5032 int16_t fid;
5033
5034 xfer += iprot->readStructBegin(fname);
5035
5036 using ::apache::thrift::protocol::TProtocolException;
5037
5038
5039 while (true)
5040 {
5041 xfer += iprot->readFieldBegin(fname, ftype, fid);
5042 if (ftype == ::apache::thrift::protocol::T_STOP) {
5043 break;
5044 }
5045 switch (fid)
5046 {
5047 case 1:
5048 if (ftype == ::apache::thrift::protocol::T_STRING) {
5049 xfer += iprot->readBinary(this->tableName);
5050 this->__isset.tableName = true;
5051 } else {
5052 xfer += iprot->skip(ftype);
5053 }
5054 break;
5055 case 2:
5056 if (ftype == ::apache::thrift::protocol::T_LIST) {
5057 {
5058 this->rows.clear();
5059 uint32_t _size306;
5060 ::apache::thrift::protocol::TType _etype309;
5061 xfer += iprot->readListBegin(_etype309, _size306);
5062 this->rows.resize(_size306);
5063 uint32_t _i310;
5064 for (_i310 = 0; _i310 < _size306; ++_i310)
5065 {
5066 xfer += iprot->readBinary(this->rows[_i310]);
5067 }
5068 xfer += iprot->readListEnd();
5069 }
5070 this->__isset.rows = true;
5071 } else {
5072 xfer += iprot->skip(ftype);
5073 }
5074 break;
5075 case 3:
5076 if (ftype == ::apache::thrift::protocol::T_LIST) {
5077 {
5078 this->columns.clear();
5079 uint32_t _size311;
5080 ::apache::thrift::protocol::TType _etype314;
5081 xfer += iprot->readListBegin(_etype314, _size311);
5082 this->columns.resize(_size311);
5083 uint32_t _i315;
5084 for (_i315 = 0; _i315 < _size311; ++_i315)
5085 {
5086 xfer += iprot->readBinary(this->columns[_i315]);
5087 }
5088 xfer += iprot->readListEnd();
5089 }
5090 this->__isset.columns = true;
5091 } else {
5092 xfer += iprot->skip(ftype);
5093 }
5094 break;
5095 case 4:
5096 if (ftype == ::apache::thrift::protocol::T_I64) {
5097 xfer += iprot->readI64(this->timestamp);
5098 this->__isset.timestamp = true;
5099 } else {
5100 xfer += iprot->skip(ftype);
5101 }
5102 break;
5103 case 5:
5104 if (ftype == ::apache::thrift::protocol::T_MAP) {
5105 {
5106 this->attributes.clear();
5107 uint32_t _size316;
5108 ::apache::thrift::protocol::TType _ktype317;
5109 ::apache::thrift::protocol::TType _vtype318;
5110 xfer += iprot->readMapBegin(_ktype317, _vtype318, _size316);
5111 uint32_t _i320;
5112 for (_i320 = 0; _i320 < _size316; ++_i320)
5113 {
5114 Text _key321;
5115 xfer += iprot->readBinary(_key321);
5116 Text& _val322 = this->attributes[_key321];
5117 xfer += iprot->readBinary(_val322);
5118 }
5119 xfer += iprot->readMapEnd();
5120 }
5121 this->__isset.attributes = true;
5122 } else {
5123 xfer += iprot->skip(ftype);
5124 }
5125 break;
5126 default:
5127 xfer += iprot->skip(ftype);
5128 break;
5129 }
5130 xfer += iprot->readFieldEnd();
5131 }
5132
5133 xfer += iprot->readStructEnd();
5134
5135 return xfer;
5136 }
5137
5138 uint32_t Hbase_getRowsWithColumnsTs_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
5139 uint32_t xfer = 0;
5140 xfer += oprot->writeStructBegin("Hbase_getRowsWithColumnsTs_args");
5141
5142 xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
5143 xfer += oprot->writeBinary(this->tableName);
5144 xfer += oprot->writeFieldEnd();
5145
5146 xfer += oprot->writeFieldBegin("rows", ::apache::thrift::protocol::T_LIST, 2);
5147 {
5148 xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->rows.size()));
5149 std::vector<Text> ::const_iterator _iter323;
5150 for (_iter323 = this->rows.begin(); _iter323 != this->rows.end(); ++_iter323)
5151 {
5152 xfer += oprot->writeBinary((*_iter323));
5153 }
5154 xfer += oprot->writeListEnd();
5155 }
5156 xfer += oprot->writeFieldEnd();
5157
5158 xfer += oprot->writeFieldBegin("columns", ::apache::thrift::protocol::T_LIST, 3);
5159 {
5160 xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->columns.size()));
5161 std::vector<Text> ::const_iterator _iter324;
5162 for (_iter324 = this->columns.begin(); _iter324 != this->columns.end(); ++_iter324)
5163 {
5164 xfer += oprot->writeBinary((*_iter324));
5165 }
5166 xfer += oprot->writeListEnd();
5167 }
5168 xfer += oprot->writeFieldEnd();
5169
5170 xfer += oprot->writeFieldBegin("timestamp", ::apache::thrift::protocol::T_I64, 4);
5171 xfer += oprot->writeI64(this->timestamp);
5172 xfer += oprot->writeFieldEnd();
5173
5174 xfer += oprot->writeFieldBegin("attributes", ::apache::thrift::protocol::T_MAP, 5);
5175 {
5176 xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->attributes.size()));
5177 std::map<Text, Text> ::const_iterator _iter325;
5178 for (_iter325 = this->attributes.begin(); _iter325 != this->attributes.end(); ++_iter325)
5179 {
5180 xfer += oprot->writeBinary(_iter325->first);
5181 xfer += oprot->writeBinary(_iter325->second);
5182 }
5183 xfer += oprot->writeMapEnd();
5184 }
5185 xfer += oprot->writeFieldEnd();
5186
5187 xfer += oprot->writeFieldStop();
5188 xfer += oprot->writeStructEnd();
5189 return xfer;
5190 }
5191
5192 uint32_t Hbase_getRowsWithColumnsTs_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
5193 uint32_t xfer = 0;
5194 xfer += oprot->writeStructBegin("Hbase_getRowsWithColumnsTs_pargs");
5195
5196 xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
5197 xfer += oprot->writeBinary((*(this->tableName)));
5198 xfer += oprot->writeFieldEnd();
5199
5200 xfer += oprot->writeFieldBegin("rows", ::apache::thrift::protocol::T_LIST, 2);
5201 {
5202 xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->rows)).size()));
5203 std::vector<Text> ::const_iterator _iter326;
5204 for (_iter326 = (*(this->rows)).begin(); _iter326 != (*(this->rows)).end(); ++_iter326)
5205 {
5206 xfer += oprot->writeBinary((*_iter326));
5207 }
5208 xfer += oprot->writeListEnd();
5209 }
5210 xfer += oprot->writeFieldEnd();
5211
5212 xfer += oprot->writeFieldBegin("columns", ::apache::thrift::protocol::T_LIST, 3);
5213 {
5214 xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->columns)).size()));
5215 std::vector<Text> ::const_iterator _iter327;
5216 for (_iter327 = (*(this->columns)).begin(); _iter327 != (*(this->columns)).end(); ++_iter327)
5217 {
5218 xfer += oprot->writeBinary((*_iter327));
5219 }
5220 xfer += oprot->writeListEnd();
5221 }
5222 xfer += oprot->writeFieldEnd();
5223
5224 xfer += oprot->writeFieldBegin("timestamp", ::apache::thrift::protocol::T_I64, 4);
5225 xfer += oprot->writeI64((*(this->timestamp)));
5226 xfer += oprot->writeFieldEnd();
5227
5228 xfer += oprot->writeFieldBegin("attributes", ::apache::thrift::protocol::T_MAP, 5);
5229 {
5230 xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->attributes)).size()));
5231 std::map<Text, Text> ::const_iterator _iter328;
5232 for (_iter328 = (*(this->attributes)).begin(); _iter328 != (*(this->attributes)).end(); ++_iter328)
5233 {
5234 xfer += oprot->writeBinary(_iter328->first);
5235 xfer += oprot->writeBinary(_iter328->second);
5236 }
5237 xfer += oprot->writeMapEnd();
5238 }
5239 xfer += oprot->writeFieldEnd();
5240
5241 xfer += oprot->writeFieldStop();
5242 xfer += oprot->writeStructEnd();
5243 return xfer;
5244 }
5245
5246 uint32_t Hbase_getRowsWithColumnsTs_result::read(::apache::thrift::protocol::TProtocol* iprot) {
5247
5248 uint32_t xfer = 0;
5249 std::string fname;
5250 ::apache::thrift::protocol::TType ftype;
5251 int16_t fid;
5252
5253 xfer += iprot->readStructBegin(fname);
5254
5255 using ::apache::thrift::protocol::TProtocolException;
5256
5257
5258 while (true)
5259 {
5260 xfer += iprot->readFieldBegin(fname, ftype, fid);
5261 if (ftype == ::apache::thrift::protocol::T_STOP) {
5262 break;
5263 }
5264 switch (fid)
5265 {
5266 case 0:
5267 if (ftype == ::apache::thrift::protocol::T_LIST) {
5268 {
5269 this->success.clear();
5270 uint32_t _size329;
5271 ::apache::thrift::protocol::TType _etype332;
5272 xfer += iprot->readListBegin(_etype332, _size329);
5273 this->success.resize(_size329);
5274 uint32_t _i333;
5275 for (_i333 = 0; _i333 < _size329; ++_i333)
5276 {
5277 xfer += this->success[_i333].read(iprot);
5278 }
5279 xfer += iprot->readListEnd();
5280 }
5281 this->__isset.success = true;
5282 } else {
5283 xfer += iprot->skip(ftype);
5284 }
5285 break;
5286 case 1:
5287 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
5288 xfer += this->io.read(iprot);
5289 this->__isset.io = true;
5290 } else {
5291 xfer += iprot->skip(ftype);
5292 }
5293 break;
5294 default:
5295 xfer += iprot->skip(ftype);
5296 break;
5297 }
5298 xfer += iprot->readFieldEnd();
5299 }
5300
5301 xfer += iprot->readStructEnd();
5302
5303 return xfer;
5304 }
5305
5306 uint32_t Hbase_getRowsWithColumnsTs_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
5307
5308 uint32_t xfer = 0;
5309
5310 xfer += oprot->writeStructBegin("Hbase_getRowsWithColumnsTs_result");
5311
5312 if (this->__isset.success) {
5313 xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0);
5314 {
5315 xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->success.size()));
5316 std::vector<TRowResult> ::const_iterator _iter334;
5317 for (_iter334 = this->success.begin(); _iter334 != this->success.end(); ++_iter334)
5318 {
5319 xfer += (*_iter334).write(oprot);
5320 }
5321 xfer += oprot->writeListEnd();
5322 }
5323 xfer += oprot->writeFieldEnd();
5324 } else if (this->__isset.io) {
5325 xfer += oprot->writeFieldBegin("io", ::apache::thrift::protocol::T_STRUCT, 1);
5326 xfer += this->io.write(oprot);
5327 xfer += oprot->writeFieldEnd();
5328 }
5329 xfer += oprot->writeFieldStop();
5330 xfer += oprot->writeStructEnd();
5331 return xfer;
5332 }
5333
5334 uint32_t Hbase_getRowsWithColumnsTs_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
5335
5336 uint32_t xfer = 0;
5337 std::string fname;
5338 ::apache::thrift::protocol::TType ftype;
5339 int16_t fid;
5340
5341 xfer += iprot->readStructBegin(fname);
5342
5343 using ::apache::thrift::protocol::TProtocolException;
5344
5345
5346 while (true)
5347 {
5348 xfer += iprot->readFieldBegin(fname, ftype, fid);
5349 if (ftype == ::apache::thrift::protocol::T_STOP) {
5350 break;
5351 }
5352 switch (fid)
5353 {
5354 case 0:
5355 if (ftype == ::apache::thrift::protocol::T_LIST) {
5356 {
5357 (*(this->success)).clear();
5358 uint32_t _size335;
5359 ::apache::thrift::protocol::TType _etype338;
5360 xfer += iprot->readListBegin(_etype338, _size335);
5361 (*(this->success)).resize(_size335);
5362 uint32_t _i339;
5363 for (_i339 = 0; _i339 < _size335; ++_i339)
5364 {
5365 xfer += (*(this->success))[_i339].read(iprot);
5366 }
5367 xfer += iprot->readListEnd();
5368 }
5369 this->__isset.success = true;
5370 } else {
5371 xfer += iprot->skip(ftype);
5372 }
5373 break;
5374 case 1:
5375 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
5376 xfer += this->io.read(iprot);
5377 this->__isset.io = true;
5378 } else {
5379 xfer += iprot->skip(ftype);
5380 }
5381 break;
5382 default:
5383 xfer += iprot->skip(ftype);
5384 break;
5385 }
5386 xfer += iprot->readFieldEnd();
5387 }
5388
5389 xfer += iprot->readStructEnd();
5390
5391 return xfer;
5392 }
5393
5394 uint32_t Hbase_mutateRow_args::read(::apache::thrift::protocol::TProtocol* iprot) {
5395
5396 uint32_t xfer = 0;
5397 std::string fname;
5398 ::apache::thrift::protocol::TType ftype;
5399 int16_t fid;
5400
5401 xfer += iprot->readStructBegin(fname);
5402
5403 using ::apache::thrift::protocol::TProtocolException;
5404
5405
5406 while (true)
5407 {
5408 xfer += iprot->readFieldBegin(fname, ftype, fid);
5409 if (ftype == ::apache::thrift::protocol::T_STOP) {
5410 break;
5411 }
5412 switch (fid)
5413 {
5414 case 1:
5415 if (ftype == ::apache::thrift::protocol::T_STRING) {
5416 xfer += iprot->readBinary(this->tableName);
5417 this->__isset.tableName = true;
5418 } else {
5419 xfer += iprot->skip(ftype);
5420 }
5421 break;
5422 case 2:
5423 if (ftype == ::apache::thrift::protocol::T_STRING) {
5424 xfer += iprot->readBinary(this->row);
5425 this->__isset.row = true;
5426 } else {
5427 xfer += iprot->skip(ftype);
5428 }
5429 break;
5430 case 3:
5431 if (ftype == ::apache::thrift::protocol::T_LIST) {
5432 {
5433 this->mutations.clear();
5434 uint32_t _size340;
5435 ::apache::thrift::protocol::TType _etype343;
5436 xfer += iprot->readListBegin(_etype343, _size340);
5437 this->mutations.resize(_size340);
5438 uint32_t _i344;
5439 for (_i344 = 0; _i344 < _size340; ++_i344)
5440 {
5441 xfer += this->mutations[_i344].read(iprot);
5442 }
5443 xfer += iprot->readListEnd();
5444 }
5445 this->__isset.mutations = true;
5446 } else {
5447 xfer += iprot->skip(ftype);
5448 }
5449 break;
5450 case 4:
5451 if (ftype == ::apache::thrift::protocol::T_MAP) {
5452 {
5453 this->attributes.clear();
5454 uint32_t _size345;
5455 ::apache::thrift::protocol::TType _ktype346;
5456 ::apache::thrift::protocol::TType _vtype347;
5457 xfer += iprot->readMapBegin(_ktype346, _vtype347, _size345);
5458 uint32_t _i349;
5459 for (_i349 = 0; _i349 < _size345; ++_i349)
5460 {
5461 Text _key350;
5462 xfer += iprot->readBinary(_key350);
5463 Text& _val351 = this->attributes[_key350];
5464 xfer += iprot->readBinary(_val351);
5465 }
5466 xfer += iprot->readMapEnd();
5467 }
5468 this->__isset.attributes = true;
5469 } else {
5470 xfer += iprot->skip(ftype);
5471 }
5472 break;
5473 default:
5474 xfer += iprot->skip(ftype);
5475 break;
5476 }
5477 xfer += iprot->readFieldEnd();
5478 }
5479
5480 xfer += iprot->readStructEnd();
5481
5482 return xfer;
5483 }
5484
5485 uint32_t Hbase_mutateRow_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
5486 uint32_t xfer = 0;
5487 xfer += oprot->writeStructBegin("Hbase_mutateRow_args");
5488
5489 xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
5490 xfer += oprot->writeBinary(this->tableName);
5491 xfer += oprot->writeFieldEnd();
5492
5493 xfer += oprot->writeFieldBegin("row", ::apache::thrift::protocol::T_STRING, 2);
5494 xfer += oprot->writeBinary(this->row);
5495 xfer += oprot->writeFieldEnd();
5496
5497 xfer += oprot->writeFieldBegin("mutations", ::apache::thrift::protocol::T_LIST, 3);
5498 {
5499 xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->mutations.size()));
5500 std::vector<Mutation> ::const_iterator _iter352;
5501 for (_iter352 = this->mutations.begin(); _iter352 != this->mutations.end(); ++_iter352)
5502 {
5503 xfer += (*_iter352).write(oprot);
5504 }
5505 xfer += oprot->writeListEnd();
5506 }
5507 xfer += oprot->writeFieldEnd();
5508
5509 xfer += oprot->writeFieldBegin("attributes", ::apache::thrift::protocol::T_MAP, 4);
5510 {
5511 xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->attributes.size()));
5512 std::map<Text, Text> ::const_iterator _iter353;
5513 for (_iter353 = this->attributes.begin(); _iter353 != this->attributes.end(); ++_iter353)
5514 {
5515 xfer += oprot->writeBinary(_iter353->first);
5516 xfer += oprot->writeBinary(_iter353->second);
5517 }
5518 xfer += oprot->writeMapEnd();
5519 }
5520 xfer += oprot->writeFieldEnd();
5521
5522 xfer += oprot->writeFieldStop();
5523 xfer += oprot->writeStructEnd();
5524 return xfer;
5525 }
5526
5527 uint32_t Hbase_mutateRow_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
5528 uint32_t xfer = 0;
5529 xfer += oprot->writeStructBegin("Hbase_mutateRow_pargs");
5530
5531 xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
5532 xfer += oprot->writeBinary((*(this->tableName)));
5533 xfer += oprot->writeFieldEnd();
5534
5535 xfer += oprot->writeFieldBegin("row", ::apache::thrift::protocol::T_STRING, 2);
5536 xfer += oprot->writeBinary((*(this->row)));
5537 xfer += oprot->writeFieldEnd();
5538
5539 xfer += oprot->writeFieldBegin("mutations", ::apache::thrift::protocol::T_LIST, 3);
5540 {
5541 xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>((*(this->mutations)).size()));
5542 std::vector<Mutation> ::const_iterator _iter354;
5543 for (_iter354 = (*(this->mutations)).begin(); _iter354 != (*(this->mutations)).end(); ++_iter354)
5544 {
5545 xfer += (*_iter354).write(oprot);
5546 }
5547 xfer += oprot->writeListEnd();
5548 }
5549 xfer += oprot->writeFieldEnd();
5550
5551 xfer += oprot->writeFieldBegin("attributes", ::apache::thrift::protocol::T_MAP, 4);
5552 {
5553 xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->attributes)).size()));
5554 std::map<Text, Text> ::const_iterator _iter355;
5555 for (_iter355 = (*(this->attributes)).begin(); _iter355 != (*(this->attributes)).end(); ++_iter355)
5556 {
5557 xfer += oprot->writeBinary(_iter355->first);
5558 xfer += oprot->writeBinary(_iter355->second);
5559 }
5560 xfer += oprot->writeMapEnd();
5561 }
5562 xfer += oprot->writeFieldEnd();
5563
5564 xfer += oprot->writeFieldStop();
5565 xfer += oprot->writeStructEnd();
5566 return xfer;
5567 }
5568
5569 uint32_t Hbase_mutateRow_result::read(::apache::thrift::protocol::TProtocol* iprot) {
5570
5571 uint32_t xfer = 0;
5572 std::string fname;
5573 ::apache::thrift::protocol::TType ftype;
5574 int16_t fid;
5575
5576 xfer += iprot->readStructBegin(fname);
5577
5578 using ::apache::thrift::protocol::TProtocolException;
5579
5580
5581 while (true)
5582 {
5583 xfer += iprot->readFieldBegin(fname, ftype, fid);
5584 if (ftype == ::apache::thrift::protocol::T_STOP) {
5585 break;
5586 }
5587 switch (fid)
5588 {
5589 case 1:
5590 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
5591 xfer += this->io.read(iprot);
5592 this->__isset.io = true;
5593 } else {
5594 xfer += iprot->skip(ftype);
5595 }
5596 break;
5597 case 2:
5598 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
5599 xfer += this->ia.read(iprot);
5600 this->__isset.ia = true;
5601 } else {
5602 xfer += iprot->skip(ftype);
5603 }
5604 break;
5605 default:
5606 xfer += iprot->skip(ftype);
5607 break;
5608 }
5609 xfer += iprot->readFieldEnd();
5610 }
5611
5612 xfer += iprot->readStructEnd();
5613
5614 return xfer;
5615 }
5616
5617 uint32_t Hbase_mutateRow_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
5618
5619 uint32_t xfer = 0;
5620
5621 xfer += oprot->writeStructBegin("Hbase_mutateRow_result");
5622
5623 if (this->__isset.io) {
5624 xfer += oprot->writeFieldBegin("io", ::apache::thrift::protocol::T_STRUCT, 1);
5625 xfer += this->io.write(oprot);
5626 xfer += oprot->writeFieldEnd();
5627 } else if (this->__isset.ia) {
5628 xfer += oprot->writeFieldBegin("ia", ::apache::thrift::protocol::T_STRUCT, 2);
5629 xfer += this->ia.write(oprot);
5630 xfer += oprot->writeFieldEnd();
5631 }
5632 xfer += oprot->writeFieldStop();
5633 xfer += oprot->writeStructEnd();
5634 return xfer;
5635 }
5636
5637 uint32_t Hbase_mutateRow_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
5638
5639 uint32_t xfer = 0;
5640 std::string fname;
5641 ::apache::thrift::protocol::TType ftype;
5642 int16_t fid;
5643
5644 xfer += iprot->readStructBegin(fname);
5645
5646 using ::apache::thrift::protocol::TProtocolException;
5647
5648
5649 while (true)
5650 {
5651 xfer += iprot->readFieldBegin(fname, ftype, fid);
5652 if (ftype == ::apache::thrift::protocol::T_STOP) {
5653 break;
5654 }
5655 switch (fid)
5656 {
5657 case 1:
5658 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
5659 xfer += this->io.read(iprot);
5660 this->__isset.io = true;
5661 } else {
5662 xfer += iprot->skip(ftype);
5663 }
5664 break;
5665 case 2:
5666 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
5667 xfer += this->ia.read(iprot);
5668 this->__isset.ia = true;
5669 } else {
5670 xfer += iprot->skip(ftype);
5671 }
5672 break;
5673 default:
5674 xfer += iprot->skip(ftype);
5675 break;
5676 }
5677 xfer += iprot->readFieldEnd();
5678 }
5679
5680 xfer += iprot->readStructEnd();
5681
5682 return xfer;
5683 }
5684
5685 uint32_t Hbase_mutateRowTs_args::read(::apache::thrift::protocol::TProtocol* iprot) {
5686
5687 uint32_t xfer = 0;
5688 std::string fname;
5689 ::apache::thrift::protocol::TType ftype;
5690 int16_t fid;
5691
5692 xfer += iprot->readStructBegin(fname);
5693
5694 using ::apache::thrift::protocol::TProtocolException;
5695
5696
5697 while (true)
5698 {
5699 xfer += iprot->readFieldBegin(fname, ftype, fid);
5700 if (ftype == ::apache::thrift::protocol::T_STOP) {
5701 break;
5702 }
5703 switch (fid)
5704 {
5705 case 1:
5706 if (ftype == ::apache::thrift::protocol::T_STRING) {
5707 xfer += iprot->readBinary(this->tableName);
5708 this->__isset.tableName = true;
5709 } else {
5710 xfer += iprot->skip(ftype);
5711 }
5712 break;
5713 case 2:
5714 if (ftype == ::apache::thrift::protocol::T_STRING) {
5715 xfer += iprot->readBinary(this->row);
5716 this->__isset.row = true;
5717 } else {
5718 xfer += iprot->skip(ftype);
5719 }
5720 break;
5721 case 3:
5722 if (ftype == ::apache::thrift::protocol::T_LIST) {
5723 {
5724 this->mutations.clear();
5725 uint32_t _size356;
5726 ::apache::thrift::protocol::TType _etype359;
5727 xfer += iprot->readListBegin(_etype359, _size356);
5728 this->mutations.resize(_size356);
5729 uint32_t _i360;
5730 for (_i360 = 0; _i360 < _size356; ++_i360)
5731 {
5732 xfer += this->mutations[_i360].read(iprot);
5733 }
5734 xfer += iprot->readListEnd();
5735 }
5736 this->__isset.mutations = true;
5737 } else {
5738 xfer += iprot->skip(ftype);
5739 }
5740 break;
5741 case 4:
5742 if (ftype == ::apache::thrift::protocol::T_I64) {
5743 xfer += iprot->readI64(this->timestamp);
5744 this->__isset.timestamp = true;
5745 } else {
5746 xfer += iprot->skip(ftype);
5747 }
5748 break;
5749 case 5:
5750 if (ftype == ::apache::thrift::protocol::T_MAP) {
5751 {
5752 this->attributes.clear();
5753 uint32_t _size361;
5754 ::apache::thrift::protocol::TType _ktype362;
5755 ::apache::thrift::protocol::TType _vtype363;
5756 xfer += iprot->readMapBegin(_ktype362, _vtype363, _size361);
5757 uint32_t _i365;
5758 for (_i365 = 0; _i365 < _size361; ++_i365)
5759 {
5760 Text _key366;
5761 xfer += iprot->readBinary(_key366);
5762 Text& _val367 = this->attributes[_key366];
5763 xfer += iprot->readBinary(_val367);
5764 }
5765 xfer += iprot->readMapEnd();
5766 }
5767 this->__isset.attributes = true;
5768 } else {
5769 xfer += iprot->skip(ftype);
5770 }
5771 break;
5772 default:
5773 xfer += iprot->skip(ftype);
5774 break;
5775 }
5776 xfer += iprot->readFieldEnd();
5777 }
5778
5779 xfer += iprot->readStructEnd();
5780
5781 return xfer;
5782 }
5783
5784 uint32_t Hbase_mutateRowTs_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
5785 uint32_t xfer = 0;
5786 xfer += oprot->writeStructBegin("Hbase_mutateRowTs_args");
5787
5788 xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
5789 xfer += oprot->writeBinary(this->tableName);
5790 xfer += oprot->writeFieldEnd();
5791
5792 xfer += oprot->writeFieldBegin("row", ::apache::thrift::protocol::T_STRING, 2);
5793 xfer += oprot->writeBinary(this->row);
5794 xfer += oprot->writeFieldEnd();
5795
5796 xfer += oprot->writeFieldBegin("mutations", ::apache::thrift::protocol::T_LIST, 3);
5797 {
5798 xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->mutations.size()));
5799 std::vector<Mutation> ::const_iterator _iter368;
5800 for (_iter368 = this->mutations.begin(); _iter368 != this->mutations.end(); ++_iter368)
5801 {
5802 xfer += (*_iter368).write(oprot);
5803 }
5804 xfer += oprot->writeListEnd();
5805 }
5806 xfer += oprot->writeFieldEnd();
5807
5808 xfer += oprot->writeFieldBegin("timestamp", ::apache::thrift::protocol::T_I64, 4);
5809 xfer += oprot->writeI64(this->timestamp);
5810 xfer += oprot->writeFieldEnd();
5811
5812 xfer += oprot->writeFieldBegin("attributes", ::apache::thrift::protocol::T_MAP, 5);
5813 {
5814 xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->attributes.size()));
5815 std::map<Text, Text> ::const_iterator _iter369;
5816 for (_iter369 = this->attributes.begin(); _iter369 != this->attributes.end(); ++_iter369)
5817 {
5818 xfer += oprot->writeBinary(_iter369->first);
5819 xfer += oprot->writeBinary(_iter369->second);
5820 }
5821 xfer += oprot->writeMapEnd();
5822 }
5823 xfer += oprot->writeFieldEnd();
5824
5825 xfer += oprot->writeFieldStop();
5826 xfer += oprot->writeStructEnd();
5827 return xfer;
5828 }
5829
5830 uint32_t Hbase_mutateRowTs_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
5831 uint32_t xfer = 0;
5832 xfer += oprot->writeStructBegin("Hbase_mutateRowTs_pargs");
5833
5834 xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
5835 xfer += oprot->writeBinary((*(this->tableName)));
5836 xfer += oprot->writeFieldEnd();
5837
5838 xfer += oprot->writeFieldBegin("row", ::apache::thrift::protocol::T_STRING, 2);
5839 xfer += oprot->writeBinary((*(this->row)));
5840 xfer += oprot->writeFieldEnd();
5841
5842 xfer += oprot->writeFieldBegin("mutations", ::apache::thrift::protocol::T_LIST, 3);
5843 {
5844 xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>((*(this->mutations)).size()));
5845 std::vector<Mutation> ::const_iterator _iter370;
5846 for (_iter370 = (*(this->mutations)).begin(); _iter370 != (*(this->mutations)).end(); ++_iter370)
5847 {
5848 xfer += (*_iter370).write(oprot);
5849 }
5850 xfer += oprot->writeListEnd();
5851 }
5852 xfer += oprot->writeFieldEnd();
5853
5854 xfer += oprot->writeFieldBegin("timestamp", ::apache::thrift::protocol::T_I64, 4);
5855 xfer += oprot->writeI64((*(this->timestamp)));
5856 xfer += oprot->writeFieldEnd();
5857
5858 xfer += oprot->writeFieldBegin("attributes", ::apache::thrift::protocol::T_MAP, 5);
5859 {
5860 xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->attributes)).size()));
5861 std::map<Text, Text> ::const_iterator _iter371;
5862 for (_iter371 = (*(this->attributes)).begin(); _iter371 != (*(this->attributes)).end(); ++_iter371)
5863 {
5864 xfer += oprot->writeBinary(_iter371->first);
5865 xfer += oprot->writeBinary(_iter371->second);
5866 }
5867 xfer += oprot->writeMapEnd();
5868 }
5869 xfer += oprot->writeFieldEnd();
5870
5871 xfer += oprot->writeFieldStop();
5872 xfer += oprot->writeStructEnd();
5873 return xfer;
5874 }
5875
5876 uint32_t Hbase_mutateRowTs_result::read(::apache::thrift::protocol::TProtocol* iprot) {
5877
5878 uint32_t xfer = 0;
5879 std::string fname;
5880 ::apache::thrift::protocol::TType ftype;
5881 int16_t fid;
5882
5883 xfer += iprot->readStructBegin(fname);
5884
5885 using ::apache::thrift::protocol::TProtocolException;
5886
5887
5888 while (true)
5889 {
5890 xfer += iprot->readFieldBegin(fname, ftype, fid);
5891 if (ftype == ::apache::thrift::protocol::T_STOP) {
5892 break;
5893 }
5894 switch (fid)
5895 {
5896 case 1:
5897 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
5898 xfer += this->io.read(iprot);
5899 this->__isset.io = true;
5900 } else {
5901 xfer += iprot->skip(ftype);
5902 }
5903 break;
5904 case 2:
5905 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
5906 xfer += this->ia.read(iprot);
5907 this->__isset.ia = true;
5908 } else {
5909 xfer += iprot->skip(ftype);
5910 }
5911 break;
5912 default:
5913 xfer += iprot->skip(ftype);
5914 break;
5915 }
5916 xfer += iprot->readFieldEnd();
5917 }
5918
5919 xfer += iprot->readStructEnd();
5920
5921 return xfer;
5922 }
5923
5924 uint32_t Hbase_mutateRowTs_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
5925
5926 uint32_t xfer = 0;
5927
5928 xfer += oprot->writeStructBegin("Hbase_mutateRowTs_result");
5929
5930 if (this->__isset.io) {
5931 xfer += oprot->writeFieldBegin("io", ::apache::thrift::protocol::T_STRUCT, 1);
5932 xfer += this->io.write(oprot);
5933 xfer += oprot->writeFieldEnd();
5934 } else if (this->__isset.ia) {
5935 xfer += oprot->writeFieldBegin("ia", ::apache::thrift::protocol::T_STRUCT, 2);
5936 xfer += this->ia.write(oprot);
5937 xfer += oprot->writeFieldEnd();
5938 }
5939 xfer += oprot->writeFieldStop();
5940 xfer += oprot->writeStructEnd();
5941 return xfer;
5942 }
5943
5944 uint32_t Hbase_mutateRowTs_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
5945
5946 uint32_t xfer = 0;
5947 std::string fname;
5948 ::apache::thrift::protocol::TType ftype;
5949 int16_t fid;
5950
5951 xfer += iprot->readStructBegin(fname);
5952
5953 using ::apache::thrift::protocol::TProtocolException;
5954
5955
5956 while (true)
5957 {
5958 xfer += iprot->readFieldBegin(fname, ftype, fid);
5959 if (ftype == ::apache::thrift::protocol::T_STOP) {
5960 break;
5961 }
5962 switch (fid)
5963 {
5964 case 1:
5965 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
5966 xfer += this->io.read(iprot);
5967 this->__isset.io = true;
5968 } else {
5969 xfer += iprot->skip(ftype);
5970 }
5971 break;
5972 case 2:
5973 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
5974 xfer += this->ia.read(iprot);
5975 this->__isset.ia = true;
5976 } else {
5977 xfer += iprot->skip(ftype);
5978 }
5979 break;
5980 default:
5981 xfer += iprot->skip(ftype);
5982 break;
5983 }
5984 xfer += iprot->readFieldEnd();
5985 }
5986
5987 xfer += iprot->readStructEnd();
5988
5989 return xfer;
5990 }
5991
5992 uint32_t Hbase_mutateRows_args::read(::apache::thrift::protocol::TProtocol* iprot) {
5993
5994 uint32_t xfer = 0;
5995 std::string fname;
5996 ::apache::thrift::protocol::TType ftype;
5997 int16_t fid;
5998
5999 xfer += iprot->readStructBegin(fname);
6000
6001 using ::apache::thrift::protocol::TProtocolException;
6002
6003
6004 while (true)
6005 {
6006 xfer += iprot->readFieldBegin(fname, ftype, fid);
6007 if (ftype == ::apache::thrift::protocol::T_STOP) {
6008 break;
6009 }
6010 switch (fid)
6011 {
6012 case 1:
6013 if (ftype == ::apache::thrift::protocol::T_STRING) {
6014 xfer += iprot->readBinary(this->tableName);
6015 this->__isset.tableName = true;
6016 } else {
6017 xfer += iprot->skip(ftype);
6018 }
6019 break;
6020 case 2:
6021 if (ftype == ::apache::thrift::protocol::T_LIST) {
6022 {
6023 this->rowBatches.clear();
6024 uint32_t _size372;
6025 ::apache::thrift::protocol::TType _etype375;
6026 xfer += iprot->readListBegin(_etype375, _size372);
6027 this->rowBatches.resize(_size372);
6028 uint32_t _i376;
6029 for (_i376 = 0; _i376 < _size372; ++_i376)
6030 {
6031 xfer += this->rowBatches[_i376].read(iprot);
6032 }
6033 xfer += iprot->readListEnd();
6034 }
6035 this->__isset.rowBatches = true;
6036 } else {
6037 xfer += iprot->skip(ftype);
6038 }
6039 break;
6040 case 3:
6041 if (ftype == ::apache::thrift::protocol::T_MAP) {
6042 {
6043 this->attributes.clear();
6044 uint32_t _size377;
6045 ::apache::thrift::protocol::TType _ktype378;
6046 ::apache::thrift::protocol::TType _vtype379;
6047 xfer += iprot->readMapBegin(_ktype378, _vtype379, _size377);
6048 uint32_t _i381;
6049 for (_i381 = 0; _i381 < _size377; ++_i381)
6050 {
6051 Text _key382;
6052 xfer += iprot->readBinary(_key382);
6053 Text& _val383 = this->attributes[_key382];
6054 xfer += iprot->readBinary(_val383);
6055 }
6056 xfer += iprot->readMapEnd();
6057 }
6058 this->__isset.attributes = true;
6059 } else {
6060 xfer += iprot->skip(ftype);
6061 }
6062 break;
6063 default:
6064 xfer += iprot->skip(ftype);
6065 break;
6066 }
6067 xfer += iprot->readFieldEnd();
6068 }
6069
6070 xfer += iprot->readStructEnd();
6071
6072 return xfer;
6073 }
6074
6075 uint32_t Hbase_mutateRows_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
6076 uint32_t xfer = 0;
6077 xfer += oprot->writeStructBegin("Hbase_mutateRows_args");
6078
6079 xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
6080 xfer += oprot->writeBinary(this->tableName);
6081 xfer += oprot->writeFieldEnd();
6082
6083 xfer += oprot->writeFieldBegin("rowBatches", ::apache::thrift::protocol::T_LIST, 2);
6084 {
6085 xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->rowBatches.size()));
6086 std::vector<BatchMutation> ::const_iterator _iter384;
6087 for (_iter384 = this->rowBatches.begin(); _iter384 != this->rowBatches.end(); ++_iter384)
6088 {
6089 xfer += (*_iter384).write(oprot);
6090 }
6091 xfer += oprot->writeListEnd();
6092 }
6093 xfer += oprot->writeFieldEnd();
6094
6095 xfer += oprot->writeFieldBegin("attributes", ::apache::thrift::protocol::T_MAP, 3);
6096 {
6097 xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->attributes.size()));
6098 std::map<Text, Text> ::const_iterator _iter385;
6099 for (_iter385 = this->attributes.begin(); _iter385 != this->attributes.end(); ++_iter385)
6100 {
6101 xfer += oprot->writeBinary(_iter385->first);
6102 xfer += oprot->writeBinary(_iter385->second);
6103 }
6104 xfer += oprot->writeMapEnd();
6105 }
6106 xfer += oprot->writeFieldEnd();
6107
6108 xfer += oprot->writeFieldStop();
6109 xfer += oprot->writeStructEnd();
6110 return xfer;
6111 }
6112
6113 uint32_t Hbase_mutateRows_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
6114 uint32_t xfer = 0;
6115 xfer += oprot->writeStructBegin("Hbase_mutateRows_pargs");
6116
6117 xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
6118 xfer += oprot->writeBinary((*(this->tableName)));
6119 xfer += oprot->writeFieldEnd();
6120
6121 xfer += oprot->writeFieldBegin("rowBatches", ::apache::thrift::protocol::T_LIST, 2);
6122 {
6123 xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>((*(this->rowBatches)).size()));
6124 std::vector<BatchMutation> ::const_iterator _iter386;
6125 for (_iter386 = (*(this->rowBatches)).begin(); _iter386 != (*(this->rowBatches)).end(); ++_iter386)
6126 {
6127 xfer += (*_iter386).write(oprot);
6128 }
6129 xfer += oprot->writeListEnd();
6130 }
6131 xfer += oprot->writeFieldEnd();
6132
6133 xfer += oprot->writeFieldBegin("attributes", ::apache::thrift::protocol::T_MAP, 3);
6134 {
6135 xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->attributes)).size()));
6136 std::map<Text, Text> ::const_iterator _iter387;
6137 for (_iter387 = (*(this->attributes)).begin(); _iter387 != (*(this->attributes)).end(); ++_iter387)
6138 {
6139 xfer += oprot->writeBinary(_iter387->first);
6140 xfer += oprot->writeBinary(_iter387->second);
6141 }
6142 xfer += oprot->writeMapEnd();
6143 }
6144 xfer += oprot->writeFieldEnd();
6145
6146 xfer += oprot->writeFieldStop();
6147 xfer += oprot->writeStructEnd();
6148 return xfer;
6149 }
6150
6151 uint32_t Hbase_mutateRows_result::read(::apache::thrift::protocol::TProtocol* iprot) {
6152
6153 uint32_t xfer = 0;
6154 std::string fname;
6155 ::apache::thrift::protocol::TType ftype;
6156 int16_t fid;
6157
6158 xfer += iprot->readStructBegin(fname);
6159
6160 using ::apache::thrift::protocol::TProtocolException;
6161
6162
6163 while (true)
6164 {
6165 xfer += iprot->readFieldBegin(fname, ftype, fid);
6166 if (ftype == ::apache::thrift::protocol::T_STOP) {
6167 break;
6168 }
6169 switch (fid)
6170 {
6171 case 1:
6172 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
6173 xfer += this->io.read(iprot);
6174 this->__isset.io = true;
6175 } else {
6176 xfer += iprot->skip(ftype);
6177 }
6178 break;
6179 case 2:
6180 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
6181 xfer += this->ia.read(iprot);
6182 this->__isset.ia = true;
6183 } else {
6184 xfer += iprot->skip(ftype);
6185 }
6186 break;
6187 default:
6188 xfer += iprot->skip(ftype);
6189 break;
6190 }
6191 xfer += iprot->readFieldEnd();
6192 }
6193
6194 xfer += iprot->readStructEnd();
6195
6196 return xfer;
6197 }
6198
6199 uint32_t Hbase_mutateRows_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
6200
6201 uint32_t xfer = 0;
6202
6203 xfer += oprot->writeStructBegin("Hbase_mutateRows_result");
6204
6205 if (this->__isset.io) {
6206 xfer += oprot->writeFieldBegin("io", ::apache::thrift::protocol::T_STRUCT, 1);
6207 xfer += this->io.write(oprot);
6208 xfer += oprot->writeFieldEnd();
6209 } else if (this->__isset.ia) {
6210 xfer += oprot->writeFieldBegin("ia", ::apache::thrift::protocol::T_STRUCT, 2);
6211 xfer += this->ia.write(oprot);
6212 xfer += oprot->writeFieldEnd();
6213 }
6214 xfer += oprot->writeFieldStop();
6215 xfer += oprot->writeStructEnd();
6216 return xfer;
6217 }
6218
6219 uint32_t Hbase_mutateRows_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
6220
6221 uint32_t xfer = 0;
6222 std::string fname;
6223 ::apache::thrift::protocol::TType ftype;
6224 int16_t fid;
6225
6226 xfer += iprot->readStructBegin(fname);
6227
6228 using ::apache::thrift::protocol::TProtocolException;
6229
6230
6231 while (true)
6232 {
6233 xfer += iprot->readFieldBegin(fname, ftype, fid);
6234 if (ftype == ::apache::thrift::protocol::T_STOP) {
6235 break;
6236 }
6237 switch (fid)
6238 {
6239 case 1:
6240 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
6241 xfer += this->io.read(iprot);
6242 this->__isset.io = true;
6243 } else {
6244 xfer += iprot->skip(ftype);
6245 }
6246 break;
6247 case 2:
6248 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
6249 xfer += this->ia.read(iprot);
6250 this->__isset.ia = true;
6251 } else {
6252 xfer += iprot->skip(ftype);
6253 }
6254 break;
6255 default:
6256 xfer += iprot->skip(ftype);
6257 break;
6258 }
6259 xfer += iprot->readFieldEnd();
6260 }
6261
6262 xfer += iprot->readStructEnd();
6263
6264 return xfer;
6265 }
6266
6267 uint32_t Hbase_mutateRowsTs_args::read(::apache::thrift::protocol::TProtocol* iprot) {
6268
6269 uint32_t xfer = 0;
6270 std::string fname;
6271 ::apache::thrift::protocol::TType ftype;
6272 int16_t fid;
6273
6274 xfer += iprot->readStructBegin(fname);
6275
6276 using ::apache::thrift::protocol::TProtocolException;
6277
6278
6279 while (true)
6280 {
6281 xfer += iprot->readFieldBegin(fname, ftype, fid);
6282 if (ftype == ::apache::thrift::protocol::T_STOP) {
6283 break;
6284 }
6285 switch (fid)
6286 {
6287 case 1:
6288 if (ftype == ::apache::thrift::protocol::T_STRING) {
6289 xfer += iprot->readBinary(this->tableName);
6290 this->__isset.tableName = true;
6291 } else {
6292 xfer += iprot->skip(ftype);
6293 }
6294 break;
6295 case 2:
6296 if (ftype == ::apache::thrift::protocol::T_LIST) {
6297 {
6298 this->rowBatches.clear();
6299 uint32_t _size388;
6300 ::apache::thrift::protocol::TType _etype391;
6301 xfer += iprot->readListBegin(_etype391, _size388);
6302 this->rowBatches.resize(_size388);
6303 uint32_t _i392;
6304 for (_i392 = 0; _i392 < _size388; ++_i392)
6305 {
6306 xfer += this->rowBatches[_i392].read(iprot);
6307 }
6308 xfer += iprot->readListEnd();
6309 }
6310 this->__isset.rowBatches = true;
6311 } else {
6312 xfer += iprot->skip(ftype);
6313 }
6314 break;
6315 case 3:
6316 if (ftype == ::apache::thrift::protocol::T_I64) {
6317 xfer += iprot->readI64(this->timestamp);
6318 this->__isset.timestamp = true;
6319 } else {
6320 xfer += iprot->skip(ftype);
6321 }
6322 break;
6323 case 4:
6324 if (ftype == ::apache::thrift::protocol::T_MAP) {
6325 {
6326 this->attributes.clear();
6327 uint32_t _size393;
6328 ::apache::thrift::protocol::TType _ktype394;
6329 ::apache::thrift::protocol::TType _vtype395;
6330 xfer += iprot->readMapBegin(_ktype394, _vtype395, _size393);
6331 uint32_t _i397;
6332 for (_i397 = 0; _i397 < _size393; ++_i397)
6333 {
6334 Text _key398;
6335 xfer += iprot->readBinary(_key398);
6336 Text& _val399 = this->attributes[_key398];
6337 xfer += iprot->readBinary(_val399);
6338 }
6339 xfer += iprot->readMapEnd();
6340 }
6341 this->__isset.attributes = true;
6342 } else {
6343 xfer += iprot->skip(ftype);
6344 }
6345 break;
6346 default:
6347 xfer += iprot->skip(ftype);
6348 break;
6349 }
6350 xfer += iprot->readFieldEnd();
6351 }
6352
6353 xfer += iprot->readStructEnd();
6354
6355 return xfer;
6356 }
6357
6358 uint32_t Hbase_mutateRowsTs_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
6359 uint32_t xfer = 0;
6360 xfer += oprot->writeStructBegin("Hbase_mutateRowsTs_args");
6361
6362 xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
6363 xfer += oprot->writeBinary(this->tableName);
6364 xfer += oprot->writeFieldEnd();
6365
6366 xfer += oprot->writeFieldBegin("rowBatches", ::apache::thrift::protocol::T_LIST, 2);
6367 {
6368 xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->rowBatches.size()));
6369 std::vector<BatchMutation> ::const_iterator _iter400;
6370 for (_iter400 = this->rowBatches.begin(); _iter400 != this->rowBatches.end(); ++_iter400)
6371 {
6372 xfer += (*_iter400).write(oprot);
6373 }
6374 xfer += oprot->writeListEnd();
6375 }
6376 xfer += oprot->writeFieldEnd();
6377
6378 xfer += oprot->writeFieldBegin("timestamp", ::apache::thrift::protocol::T_I64, 3);
6379 xfer += oprot->writeI64(this->timestamp);
6380 xfer += oprot->writeFieldEnd();
6381
6382 xfer += oprot->writeFieldBegin("attributes", ::apache::thrift::protocol::T_MAP, 4);
6383 {
6384 xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->attributes.size()));
6385 std::map<Text, Text> ::const_iterator _iter401;
6386 for (_iter401 = this->attributes.begin(); _iter401 != this->attributes.end(); ++_iter401)
6387 {
6388 xfer += oprot->writeBinary(_iter401->first);
6389 xfer += oprot->writeBinary(_iter401->second);
6390 }
6391 xfer += oprot->writeMapEnd();
6392 }
6393 xfer += oprot->writeFieldEnd();
6394
6395 xfer += oprot->writeFieldStop();
6396 xfer += oprot->writeStructEnd();
6397 return xfer;
6398 }
6399
6400 uint32_t Hbase_mutateRowsTs_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
6401 uint32_t xfer = 0;
6402 xfer += oprot->writeStructBegin("Hbase_mutateRowsTs_pargs");
6403
6404 xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
6405 xfer += oprot->writeBinary((*(this->tableName)));
6406 xfer += oprot->writeFieldEnd();
6407
6408 xfer += oprot->writeFieldBegin("rowBatches", ::apache::thrift::protocol::T_LIST, 2);
6409 {
6410 xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>((*(this->rowBatches)).size()));
6411 std::vector<BatchMutation> ::const_iterator _iter402;
6412 for (_iter402 = (*(this->rowBatches)).begin(); _iter402 != (*(this->rowBatches)).end(); ++_iter402)
6413 {
6414 xfer += (*_iter402).write(oprot);
6415 }
6416 xfer += oprot->writeListEnd();
6417 }
6418 xfer += oprot->writeFieldEnd();
6419
6420 xfer += oprot->writeFieldBegin("timestamp", ::apache::thrift::protocol::T_I64, 3);
6421 xfer += oprot->writeI64((*(this->timestamp)));
6422 xfer += oprot->writeFieldEnd();
6423
6424 xfer += oprot->writeFieldBegin("attributes", ::apache::thrift::protocol::T_MAP, 4);
6425 {
6426 xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->attributes)).size()));
6427 std::map<Text, Text> ::const_iterator _iter403;
6428 for (_iter403 = (*(this->attributes)).begin(); _iter403 != (*(this->attributes)).end(); ++_iter403)
6429 {
6430 xfer += oprot->writeBinary(_iter403->first);
6431 xfer += oprot->writeBinary(_iter403->second);
6432 }
6433 xfer += oprot->writeMapEnd();
6434 }
6435 xfer += oprot->writeFieldEnd();
6436
6437 xfer += oprot->writeFieldStop();
6438 xfer += oprot->writeStructEnd();
6439 return xfer;
6440 }
6441
6442 uint32_t Hbase_mutateRowsTs_result::read(::apache::thrift::protocol::TProtocol* iprot) {
6443
6444 uint32_t xfer = 0;
6445 std::string fname;
6446 ::apache::thrift::protocol::TType ftype;
6447 int16_t fid;
6448
6449 xfer += iprot->readStructBegin(fname);
6450
6451 using ::apache::thrift::protocol::TProtocolException;
6452
6453
6454 while (true)
6455 {
6456 xfer += iprot->readFieldBegin(fname, ftype, fid);
6457 if (ftype == ::apache::thrift::protocol::T_STOP) {
6458 break;
6459 }
6460 switch (fid)
6461 {
6462 case 1:
6463 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
6464 xfer += this->io.read(iprot);
6465 this->__isset.io = true;
6466 } else {
6467 xfer += iprot->skip(ftype);
6468 }
6469 break;
6470 case 2:
6471 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
6472 xfer += this->ia.read(iprot);
6473 this->__isset.ia = true;
6474 } else {
6475 xfer += iprot->skip(ftype);
6476 }
6477 break;
6478 default:
6479 xfer += iprot->skip(ftype);
6480 break;
6481 }
6482 xfer += iprot->readFieldEnd();
6483 }
6484
6485 xfer += iprot->readStructEnd();
6486
6487 return xfer;
6488 }
6489
6490 uint32_t Hbase_mutateRowsTs_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
6491
6492 uint32_t xfer = 0;
6493
6494 xfer += oprot->writeStructBegin("Hbase_mutateRowsTs_result");
6495
6496 if (this->__isset.io) {
6497 xfer += oprot->writeFieldBegin("io", ::apache::thrift::protocol::T_STRUCT, 1);
6498 xfer += this->io.write(oprot);
6499 xfer += oprot->writeFieldEnd();
6500 } else if (this->__isset.ia) {
6501 xfer += oprot->writeFieldBegin("ia", ::apache::thrift::protocol::T_STRUCT, 2);
6502 xfer += this->ia.write(oprot);
6503 xfer += oprot->writeFieldEnd();
6504 }
6505 xfer += oprot->writeFieldStop();
6506 xfer += oprot->writeStructEnd();
6507 return xfer;
6508 }
6509
6510 uint32_t Hbase_mutateRowsTs_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
6511
6512 uint32_t xfer = 0;
6513 std::string fname;
6514 ::apache::thrift::protocol::TType ftype;
6515 int16_t fid;
6516
6517 xfer += iprot->readStructBegin(fname);
6518
6519 using ::apache::thrift::protocol::TProtocolException;
6520
6521
6522 while (true)
6523 {
6524 xfer += iprot->readFieldBegin(fname, ftype, fid);
6525 if (ftype == ::apache::thrift::protocol::T_STOP) {
6526 break;
6527 }
6528 switch (fid)
6529 {
6530 case 1:
6531 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
6532 xfer += this->io.read(iprot);
6533 this->__isset.io = true;
6534 } else {
6535 xfer += iprot->skip(ftype);
6536 }
6537 break;
6538 case 2:
6539 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
6540 xfer += this->ia.read(iprot);
6541 this->__isset.ia = true;
6542 } else {
6543 xfer += iprot->skip(ftype);
6544 }
6545 break;
6546 default:
6547 xfer += iprot->skip(ftype);
6548 break;
6549 }
6550 xfer += iprot->readFieldEnd();
6551 }
6552
6553 xfer += iprot->readStructEnd();
6554
6555 return xfer;
6556 }
6557
6558 uint32_t Hbase_atomicIncrement_args::read(::apache::thrift::protocol::TProtocol* iprot) {
6559
6560 uint32_t xfer = 0;
6561 std::string fname;
6562 ::apache::thrift::protocol::TType ftype;
6563 int16_t fid;
6564
6565 xfer += iprot->readStructBegin(fname);
6566
6567 using ::apache::thrift::protocol::TProtocolException;
6568
6569
6570 while (true)
6571 {
6572 xfer += iprot->readFieldBegin(fname, ftype, fid);
6573 if (ftype == ::apache::thrift::protocol::T_STOP) {
6574 break;
6575 }
6576 switch (fid)
6577 {
6578 case 1:
6579 if (ftype == ::apache::thrift::protocol::T_STRING) {
6580 xfer += iprot->readBinary(this->tableName);
6581 this->__isset.tableName = true;
6582 } else {
6583 xfer += iprot->skip(ftype);
6584 }
6585 break;
6586 case 2:
6587 if (ftype == ::apache::thrift::protocol::T_STRING) {
6588 xfer += iprot->readBinary(this->row);
6589 this->__isset.row = true;
6590 } else {
6591 xfer += iprot->skip(ftype);
6592 }
6593 break;
6594 case 3:
6595 if (ftype == ::apache::thrift::protocol::T_STRING) {
6596 xfer += iprot->readBinary(this->column);
6597 this->__isset.column = true;
6598 } else {
6599 xfer += iprot->skip(ftype);
6600 }
6601 break;
6602 case 4:
6603 if (ftype == ::apache::thrift::protocol::T_I64) {
6604 xfer += iprot->readI64(this->value);
6605 this->__isset.value = true;
6606 } else {
6607 xfer += iprot->skip(ftype);
6608 }
6609 break;
6610 default:
6611 xfer += iprot->skip(ftype);
6612 break;
6613 }
6614 xfer += iprot->readFieldEnd();
6615 }
6616
6617 xfer += iprot->readStructEnd();
6618
6619 return xfer;
6620 }
6621
6622 uint32_t Hbase_atomicIncrement_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
6623 uint32_t xfer = 0;
6624 xfer += oprot->writeStructBegin("Hbase_atomicIncrement_args");
6625
6626 xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
6627 xfer += oprot->writeBinary(this->tableName);
6628 xfer += oprot->writeFieldEnd();
6629
6630 xfer += oprot->writeFieldBegin("row", ::apache::thrift::protocol::T_STRING, 2);
6631 xfer += oprot->writeBinary(this->row);
6632 xfer += oprot->writeFieldEnd();
6633
6634 xfer += oprot->writeFieldBegin("column", ::apache::thrift::protocol::T_STRING, 3);
6635 xfer += oprot->writeBinary(this->column);
6636 xfer += oprot->writeFieldEnd();
6637
6638 xfer += oprot->writeFieldBegin("value", ::apache::thrift::protocol::T_I64, 4);
6639 xfer += oprot->writeI64(this->value);
6640 xfer += oprot->writeFieldEnd();
6641
6642 xfer += oprot->writeFieldStop();
6643 xfer += oprot->writeStructEnd();
6644 return xfer;
6645 }
6646
6647 uint32_t Hbase_atomicIncrement_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
6648 uint32_t xfer = 0;
6649 xfer += oprot->writeStructBegin("Hbase_atomicIncrement_pargs");
6650
6651 xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
6652 xfer += oprot->writeBinary((*(this->tableName)));
6653 xfer += oprot->writeFieldEnd();
6654
6655 xfer += oprot->writeFieldBegin("row", ::apache::thrift::protocol::T_STRING, 2);
6656 xfer += oprot->writeBinary((*(this->row)));
6657 xfer += oprot->writeFieldEnd();
6658
6659 xfer += oprot->writeFieldBegin("column", ::apache::thrift::protocol::T_STRING, 3);
6660 xfer += oprot->writeBinary((*(this->column)));
6661 xfer += oprot->writeFieldEnd();
6662
6663 xfer += oprot->writeFieldBegin("value", ::apache::thrift::protocol::T_I64, 4);
6664 xfer += oprot->writeI64((*(this->value)));
6665 xfer += oprot->writeFieldEnd();
6666
6667 xfer += oprot->writeFieldStop();
6668 xfer += oprot->writeStructEnd();
6669 return xfer;
6670 }
6671
6672 uint32_t Hbase_atomicIncrement_result::read(::apache::thrift::protocol::TProtocol* iprot) {
6673
6674 uint32_t xfer = 0;
6675 std::string fname;
6676 ::apache::thrift::protocol::TType ftype;
6677 int16_t fid;
6678
6679 xfer += iprot->readStructBegin(fname);
6680
6681 using ::apache::thrift::protocol::TProtocolException;
6682
6683
6684 while (true)
6685 {
6686 xfer += iprot->readFieldBegin(fname, ftype, fid);
6687 if (ftype == ::apache::thrift::protocol::T_STOP) {
6688 break;
6689 }
6690 switch (fid)
6691 {
6692 case 0:
6693 if (ftype == ::apache::thrift::protocol::T_I64) {
6694 xfer += iprot->readI64(this->success);
6695 this->__isset.success = true;
6696 } else {
6697 xfer += iprot->skip(ftype);
6698 }
6699 break;
6700 case 1:
6701 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
6702 xfer += this->io.read(iprot);
6703 this->__isset.io = true;
6704 } else {
6705 xfer += iprot->skip(ftype);
6706 }
6707 break;
6708 case 2:
6709 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
6710 xfer += this->ia.read(iprot);
6711 this->__isset.ia = true;
6712 } else {
6713 xfer += iprot->skip(ftype);
6714 }
6715 break;
6716 default:
6717 xfer += iprot->skip(ftype);
6718 break;
6719 }
6720 xfer += iprot->readFieldEnd();
6721 }
6722
6723 xfer += iprot->readStructEnd();
6724
6725 return xfer;
6726 }
6727
6728 uint32_t Hbase_atomicIncrement_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
6729
6730 uint32_t xfer = 0;
6731
6732 xfer += oprot->writeStructBegin("Hbase_atomicIncrement_result");
6733
6734 if (this->__isset.success) {
6735 xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_I64, 0);
6736 xfer += oprot->writeI64(this->success);
6737 xfer += oprot->writeFieldEnd();
6738 } else if (this->__isset.io) {
6739 xfer += oprot->writeFieldBegin("io", ::apache::thrift::protocol::T_STRUCT, 1);
6740 xfer += this->io.write(oprot);
6741 xfer += oprot->writeFieldEnd();
6742 } else if (this->__isset.ia) {
6743 xfer += oprot->writeFieldBegin("ia", ::apache::thrift::protocol::T_STRUCT, 2);
6744 xfer += this->ia.write(oprot);
6745 xfer += oprot->writeFieldEnd();
6746 }
6747 xfer += oprot->writeFieldStop();
6748 xfer += oprot->writeStructEnd();
6749 return xfer;
6750 }
6751
6752 uint32_t Hbase_atomicIncrement_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
6753
6754 uint32_t xfer = 0;
6755 std::string fname;
6756 ::apache::thrift::protocol::TType ftype;
6757 int16_t fid;
6758
6759 xfer += iprot->readStructBegin(fname);
6760
6761 using ::apache::thrift::protocol::TProtocolException;
6762
6763
6764 while (true)
6765 {
6766 xfer += iprot->readFieldBegin(fname, ftype, fid);
6767 if (ftype == ::apache::thrift::protocol::T_STOP) {
6768 break;
6769 }
6770 switch (fid)
6771 {
6772 case 0:
6773 if (ftype == ::apache::thrift::protocol::T_I64) {
6774 xfer += iprot->readI64((*(this->success)));
6775 this->__isset.success = true;
6776 } else {
6777 xfer += iprot->skip(ftype);
6778 }
6779 break;
6780 case 1:
6781 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
6782 xfer += this->io.read(iprot);
6783 this->__isset.io = true;
6784 } else {
6785 xfer += iprot->skip(ftype);
6786 }
6787 break;
6788 case 2:
6789 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
6790 xfer += this->ia.read(iprot);
6791 this->__isset.ia = true;
6792 } else {
6793 xfer += iprot->skip(ftype);
6794 }
6795 break;
6796 default:
6797 xfer += iprot->skip(ftype);
6798 break;
6799 }
6800 xfer += iprot->readFieldEnd();
6801 }
6802
6803 xfer += iprot->readStructEnd();
6804
6805 return xfer;
6806 }
6807
6808 uint32_t Hbase_deleteAll_args::read(::apache::thrift::protocol::TProtocol* iprot) {
6809
6810 uint32_t xfer = 0;
6811 std::string fname;
6812 ::apache::thrift::protocol::TType ftype;
6813 int16_t fid;
6814
6815 xfer += iprot->readStructBegin(fname);
6816
6817 using ::apache::thrift::protocol::TProtocolException;
6818
6819
6820 while (true)
6821 {
6822 xfer += iprot->readFieldBegin(fname, ftype, fid);
6823 if (ftype == ::apache::thrift::protocol::T_STOP) {
6824 break;
6825 }
6826 switch (fid)
6827 {
6828 case 1:
6829 if (ftype == ::apache::thrift::protocol::T_STRING) {
6830 xfer += iprot->readBinary(this->tableName);
6831 this->__isset.tableName = true;
6832 } else {
6833 xfer += iprot->skip(ftype);
6834 }
6835 break;
6836 case 2:
6837 if (ftype == ::apache::thrift::protocol::T_STRING) {
6838 xfer += iprot->readBinary(this->row);
6839 this->__isset.row = true;
6840 } else {
6841 xfer += iprot->skip(ftype);
6842 }
6843 break;
6844 case 3:
6845 if (ftype == ::apache::thrift::protocol::T_STRING) {
6846 xfer += iprot->readBinary(this->column);
6847 this->__isset.column = true;
6848 } else {
6849 xfer += iprot->skip(ftype);
6850 }
6851 break;
6852 case 4:
6853 if (ftype == ::apache::thrift::protocol::T_MAP) {
6854 {
6855 this->attributes.clear();
6856 uint32_t _size404;
6857 ::apache::thrift::protocol::TType _ktype405;
6858 ::apache::thrift::protocol::TType _vtype406;
6859 xfer += iprot->readMapBegin(_ktype405, _vtype406, _size404);
6860 uint32_t _i408;
6861 for (_i408 = 0; _i408 < _size404; ++_i408)
6862 {
6863 Text _key409;
6864 xfer += iprot->readBinary(_key409);
6865 Text& _val410 = this->attributes[_key409];
6866 xfer += iprot->readBinary(_val410);
6867 }
6868 xfer += iprot->readMapEnd();
6869 }
6870 this->__isset.attributes = true;
6871 } else {
6872 xfer += iprot->skip(ftype);
6873 }
6874 break;
6875 default:
6876 xfer += iprot->skip(ftype);
6877 break;
6878 }
6879 xfer += iprot->readFieldEnd();
6880 }
6881
6882 xfer += iprot->readStructEnd();
6883
6884 return xfer;
6885 }
6886
6887 uint32_t Hbase_deleteAll_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
6888 uint32_t xfer = 0;
6889 xfer += oprot->writeStructBegin("Hbase_deleteAll_args");
6890
6891 xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
6892 xfer += oprot->writeBinary(this->tableName);
6893 xfer += oprot->writeFieldEnd();
6894
6895 xfer += oprot->writeFieldBegin("row", ::apache::thrift::protocol::T_STRING, 2);
6896 xfer += oprot->writeBinary(this->row);
6897 xfer += oprot->writeFieldEnd();
6898
6899 xfer += oprot->writeFieldBegin("column", ::apache::thrift::protocol::T_STRING, 3);
6900 xfer += oprot->writeBinary(this->column);
6901 xfer += oprot->writeFieldEnd();
6902
6903 xfer += oprot->writeFieldBegin("attributes", ::apache::thrift::protocol::T_MAP, 4);
6904 {
6905 xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->attributes.size()));
6906 std::map<Text, Text> ::const_iterator _iter411;
6907 for (_iter411 = this->attributes.begin(); _iter411 != this->attributes.end(); ++_iter411)
6908 {
6909 xfer += oprot->writeBinary(_iter411->first);
6910 xfer += oprot->writeBinary(_iter411->second);
6911 }
6912 xfer += oprot->writeMapEnd();
6913 }
6914 xfer += oprot->writeFieldEnd();
6915
6916 xfer += oprot->writeFieldStop();
6917 xfer += oprot->writeStructEnd();
6918 return xfer;
6919 }
6920
6921 uint32_t Hbase_deleteAll_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
6922 uint32_t xfer = 0;
6923 xfer += oprot->writeStructBegin("Hbase_deleteAll_pargs");
6924
6925 xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
6926 xfer += oprot->writeBinary((*(this->tableName)));
6927 xfer += oprot->writeFieldEnd();
6928
6929 xfer += oprot->writeFieldBegin("row", ::apache::thrift::protocol::T_STRING, 2);
6930 xfer += oprot->writeBinary((*(this->row)));
6931 xfer += oprot->writeFieldEnd();
6932
6933 xfer += oprot->writeFieldBegin("column", ::apache::thrift::protocol::T_STRING, 3);
6934 xfer += oprot->writeBinary((*(this->column)));
6935 xfer += oprot->writeFieldEnd();
6936
6937 xfer += oprot->writeFieldBegin("attributes", ::apache::thrift::protocol::T_MAP, 4);
6938 {
6939 xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->attributes)).size()));
6940 std::map<Text, Text> ::const_iterator _iter412;
6941 for (_iter412 = (*(this->attributes)).begin(); _iter412 != (*(this->attributes)).end(); ++_iter412)
6942 {
6943 xfer += oprot->writeBinary(_iter412->first);
6944 xfer += oprot->writeBinary(_iter412->second);
6945 }
6946 xfer += oprot->writeMapEnd();
6947 }
6948 xfer += oprot->writeFieldEnd();
6949
6950 xfer += oprot->writeFieldStop();
6951 xfer += oprot->writeStructEnd();
6952 return xfer;
6953 }
6954
6955 uint32_t Hbase_deleteAll_result::read(::apache::thrift::protocol::TProtocol* iprot) {
6956
6957 uint32_t xfer = 0;
6958 std::string fname;
6959 ::apache::thrift::protocol::TType ftype;
6960 int16_t fid;
6961
6962 xfer += iprot->readStructBegin(fname);
6963
6964 using ::apache::thrift::protocol::TProtocolException;
6965
6966
6967 while (true)
6968 {
6969 xfer += iprot->readFieldBegin(fname, ftype, fid);
6970 if (ftype == ::apache::thrift::protocol::T_STOP) {
6971 break;
6972 }
6973 switch (fid)
6974 {
6975 case 1:
6976 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
6977 xfer += this->io.read(iprot);
6978 this->__isset.io = true;
6979 } else {
6980 xfer += iprot->skip(ftype);
6981 }
6982 break;
6983 default:
6984 xfer += iprot->skip(ftype);
6985 break;
6986 }
6987 xfer += iprot->readFieldEnd();
6988 }
6989
6990 xfer += iprot->readStructEnd();
6991
6992 return xfer;
6993 }
6994
6995 uint32_t Hbase_deleteAll_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
6996
6997 uint32_t xfer = 0;
6998
6999 xfer += oprot->writeStructBegin("Hbase_deleteAll_result");
7000
7001 if (this->__isset.io) {
7002 xfer += oprot->writeFieldBegin("io", ::apache::thrift::protocol::T_STRUCT, 1);
7003 xfer += this->io.write(oprot);
7004 xfer += oprot->writeFieldEnd();
7005 }
7006 xfer += oprot->writeFieldStop();
7007 xfer += oprot->writeStructEnd();
7008 return xfer;
7009 }
7010
7011 uint32_t Hbase_deleteAll_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
7012
7013 uint32_t xfer = 0;
7014 std::string fname;
7015 ::apache::thrift::protocol::TType ftype;
7016 int16_t fid;
7017
7018 xfer += iprot->readStructBegin(fname);
7019
7020 using ::apache::thrift::protocol::TProtocolException;
7021
7022
7023 while (true)
7024 {
7025 xfer += iprot->readFieldBegin(fname, ftype, fid);
7026 if (ftype == ::apache::thrift::protocol::T_STOP) {
7027 break;
7028 }
7029 switch (fid)
7030 {
7031 case 1:
7032 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
7033 xfer += this->io.read(iprot);
7034 this->__isset.io = true;
7035 } else {
7036 xfer += iprot->skip(ftype);
7037 }
7038 break;
7039 default:
7040 xfer += iprot->skip(ftype);
7041 break;
7042 }
7043 xfer += iprot->readFieldEnd();
7044 }
7045
7046 xfer += iprot->readStructEnd();
7047
7048 return xfer;
7049 }
7050
7051 uint32_t Hbase_deleteAllTs_args::read(::apache::thrift::protocol::TProtocol* iprot) {
7052
7053 uint32_t xfer = 0;
7054 std::string fname;
7055 ::apache::thrift::protocol::TType ftype;
7056 int16_t fid;
7057
7058 xfer += iprot->readStructBegin(fname);
7059
7060 using ::apache::thrift::protocol::TProtocolException;
7061
7062
7063 while (true)
7064 {
7065 xfer += iprot->readFieldBegin(fname, ftype, fid);
7066 if (ftype == ::apache::thrift::protocol::T_STOP) {
7067 break;
7068 }
7069 switch (fid)
7070 {
7071 case 1:
7072 if (ftype == ::apache::thrift::protocol::T_STRING) {
7073 xfer += iprot->readBinary(this->tableName);
7074 this->__isset.tableName = true;
7075 } else {
7076 xfer += iprot->skip(ftype);
7077 }
7078 break;
7079 case 2:
7080 if (ftype == ::apache::thrift::protocol::T_STRING) {
7081 xfer += iprot->readBinary(this->row);
7082 this->__isset.row = true;
7083 } else {
7084 xfer += iprot->skip(ftype);
7085 }
7086 break;
7087 case 3:
7088 if (ftype == ::apache::thrift::protocol::T_STRING) {
7089 xfer += iprot->readBinary(this->column);
7090 this->__isset.column = true;
7091 } else {
7092 xfer += iprot->skip(ftype);
7093 }
7094 break;
7095 case 4:
7096 if (ftype == ::apache::thrift::protocol::T_I64) {
7097 xfer += iprot->readI64(this->timestamp);
7098 this->__isset.timestamp = true;
7099 } else {
7100 xfer += iprot->skip(ftype);
7101 }
7102 break;
7103 case 5:
7104 if (ftype == ::apache::thrift::protocol::T_MAP) {
7105 {
7106 this->attributes.clear();
7107 uint32_t _size413;
7108 ::apache::thrift::protocol::TType _ktype414;
7109 ::apache::thrift::protocol::TType _vtype415;
7110 xfer += iprot->readMapBegin(_ktype414, _vtype415, _size413);
7111 uint32_t _i417;
7112 for (_i417 = 0; _i417 < _size413; ++_i417)
7113 {
7114 Text _key418;
7115 xfer += iprot->readBinary(_key418);
7116 Text& _val419 = this->attributes[_key418];
7117 xfer += iprot->readBinary(_val419);
7118 }
7119 xfer += iprot->readMapEnd();
7120 }
7121 this->__isset.attributes = true;
7122 } else {
7123 xfer += iprot->skip(ftype);
7124 }
7125 break;
7126 default:
7127 xfer += iprot->skip(ftype);
7128 break;
7129 }
7130 xfer += iprot->readFieldEnd();
7131 }
7132
7133 xfer += iprot->readStructEnd();
7134
7135 return xfer;
7136 }
7137
7138 uint32_t Hbase_deleteAllTs_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
7139 uint32_t xfer = 0;
7140 xfer += oprot->writeStructBegin("Hbase_deleteAllTs_args");
7141
7142 xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
7143 xfer += oprot->writeBinary(this->tableName);
7144 xfer += oprot->writeFieldEnd();
7145
7146 xfer += oprot->writeFieldBegin("row", ::apache::thrift::protocol::T_STRING, 2);
7147 xfer += oprot->writeBinary(this->row);
7148 xfer += oprot->writeFieldEnd();
7149
7150 xfer += oprot->writeFieldBegin("column", ::apache::thrift::protocol::T_STRING, 3);
7151 xfer += oprot->writeBinary(this->column);
7152 xfer += oprot->writeFieldEnd();
7153
7154 xfer += oprot->writeFieldBegin("timestamp", ::apache::thrift::protocol::T_I64, 4);
7155 xfer += oprot->writeI64(this->timestamp);
7156 xfer += oprot->writeFieldEnd();
7157
7158 xfer += oprot->writeFieldBegin("attributes", ::apache::thrift::protocol::T_MAP, 5);
7159 {
7160 xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->attributes.size()));
7161 std::map<Text, Text> ::const_iterator _iter420;
7162 for (_iter420 = this->attributes.begin(); _iter420 != this->attributes.end(); ++_iter420)
7163 {
7164 xfer += oprot->writeBinary(_iter420->first);
7165 xfer += oprot->writeBinary(_iter420->second);
7166 }
7167 xfer += oprot->writeMapEnd();
7168 }
7169 xfer += oprot->writeFieldEnd();
7170
7171 xfer += oprot->writeFieldStop();
7172 xfer += oprot->writeStructEnd();
7173 return xfer;
7174 }
7175
7176 uint32_t Hbase_deleteAllTs_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
7177 uint32_t xfer = 0;
7178 xfer += oprot->writeStructBegin("Hbase_deleteAllTs_pargs");
7179
7180 xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
7181 xfer += oprot->writeBinary((*(this->tableName)));
7182 xfer += oprot->writeFieldEnd();
7183
7184 xfer += oprot->writeFieldBegin("row", ::apache::thrift::protocol::T_STRING, 2);
7185 xfer += oprot->writeBinary((*(this->row)));
7186 xfer += oprot->writeFieldEnd();
7187
7188 xfer += oprot->writeFieldBegin("column", ::apache::thrift::protocol::T_STRING, 3);
7189 xfer += oprot->writeBinary((*(this->column)));
7190 xfer += oprot->writeFieldEnd();
7191
7192 xfer += oprot->writeFieldBegin("timestamp", ::apache::thrift::protocol::T_I64, 4);
7193 xfer += oprot->writeI64((*(this->timestamp)));
7194 xfer += oprot->writeFieldEnd();
7195
7196 xfer += oprot->writeFieldBegin("attributes", ::apache::thrift::protocol::T_MAP, 5);
7197 {
7198 xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->attributes)).size()));
7199 std::map<Text, Text> ::const_iterator _iter421;
7200 for (_iter421 = (*(this->attributes)).begin(); _iter421 != (*(this->attributes)).end(); ++_iter421)
7201 {
7202 xfer += oprot->writeBinary(_iter421->first);
7203 xfer += oprot->writeBinary(_iter421->second);
7204 }
7205 xfer += oprot->writeMapEnd();
7206 }
7207 xfer += oprot->writeFieldEnd();
7208
7209 xfer += oprot->writeFieldStop();
7210 xfer += oprot->writeStructEnd();
7211 return xfer;
7212 }
7213
7214 uint32_t Hbase_deleteAllTs_result::read(::apache::thrift::protocol::TProtocol* iprot) {
7215
7216 uint32_t xfer = 0;
7217 std::string fname;
7218 ::apache::thrift::protocol::TType ftype;
7219 int16_t fid;
7220
7221 xfer += iprot->readStructBegin(fname);
7222
7223 using ::apache::thrift::protocol::TProtocolException;
7224
7225
7226 while (true)
7227 {
7228 xfer += iprot->readFieldBegin(fname, ftype, fid);
7229 if (ftype == ::apache::thrift::protocol::T_STOP) {
7230 break;
7231 }
7232 switch (fid)
7233 {
7234 case 1:
7235 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
7236 xfer += this->io.read(iprot);
7237 this->__isset.io = true;
7238 } else {
7239 xfer += iprot->skip(ftype);
7240 }
7241 break;
7242 default:
7243 xfer += iprot->skip(ftype);
7244 break;
7245 }
7246 xfer += iprot->readFieldEnd();
7247 }
7248
7249 xfer += iprot->readStructEnd();
7250
7251 return xfer;
7252 }
7253
7254 uint32_t Hbase_deleteAllTs_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
7255
7256 uint32_t xfer = 0;
7257
7258 xfer += oprot->writeStructBegin("Hbase_deleteAllTs_result");
7259
7260 if (this->__isset.io) {
7261 xfer += oprot->writeFieldBegin("io", ::apache::thrift::protocol::T_STRUCT, 1);
7262 xfer += this->io.write(oprot);
7263 xfer += oprot->writeFieldEnd();
7264 }
7265 xfer += oprot->writeFieldStop();
7266 xfer += oprot->writeStructEnd();
7267 return xfer;
7268 }
7269
7270 uint32_t Hbase_deleteAllTs_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
7271
7272 uint32_t xfer = 0;
7273 std::string fname;
7274 ::apache::thrift::protocol::TType ftype;
7275 int16_t fid;
7276
7277 xfer += iprot->readStructBegin(fname);
7278
7279 using ::apache::thrift::protocol::TProtocolException;
7280
7281
7282 while (true)
7283 {
7284 xfer += iprot->readFieldBegin(fname, ftype, fid);
7285 if (ftype == ::apache::thrift::protocol::T_STOP) {
7286 break;
7287 }
7288 switch (fid)
7289 {
7290 case 1:
7291 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
7292 xfer += this->io.read(iprot);
7293 this->__isset.io = true;
7294 } else {
7295 xfer += iprot->skip(ftype);
7296 }
7297 break;
7298 default:
7299 xfer += iprot->skip(ftype);
7300 break;
7301 }
7302 xfer += iprot->readFieldEnd();
7303 }
7304
7305 xfer += iprot->readStructEnd();
7306
7307 return xfer;
7308 }
7309
7310 uint32_t Hbase_deleteAllRow_args::read(::apache::thrift::protocol::TProtocol* iprot) {
7311
7312 uint32_t xfer = 0;
7313 std::string fname;
7314 ::apache::thrift::protocol::TType ftype;
7315 int16_t fid;
7316
7317 xfer += iprot->readStructBegin(fname);
7318
7319 using ::apache::thrift::protocol::TProtocolException;
7320
7321
7322 while (true)
7323 {
7324 xfer += iprot->readFieldBegin(fname, ftype, fid);
7325 if (ftype == ::apache::thrift::protocol::T_STOP) {
7326 break;
7327 }
7328 switch (fid)
7329 {
7330 case 1:
7331 if (ftype == ::apache::thrift::protocol::T_STRING) {
7332 xfer += iprot->readBinary(this->tableName);
7333 this->__isset.tableName = true;
7334 } else {
7335 xfer += iprot->skip(ftype);
7336 }
7337 break;
7338 case 2:
7339 if (ftype == ::apache::thrift::protocol::T_STRING) {
7340 xfer += iprot->readBinary(this->row);
7341 this->__isset.row = true;
7342 } else {
7343 xfer += iprot->skip(ftype);
7344 }
7345 break;
7346 case 3:
7347 if (ftype == ::apache::thrift::protocol::T_MAP) {
7348 {
7349 this->attributes.clear();
7350 uint32_t _size422;
7351 ::apache::thrift::protocol::TType _ktype423;
7352 ::apache::thrift::protocol::TType _vtype424;
7353 xfer += iprot->readMapBegin(_ktype423, _vtype424, _size422);
7354 uint32_t _i426;
7355 for (_i426 = 0; _i426 < _size422; ++_i426)
7356 {
7357 Text _key427;
7358 xfer += iprot->readBinary(_key427);
7359 Text& _val428 = this->attributes[_key427];
7360 xfer += iprot->readBinary(_val428);
7361 }
7362 xfer += iprot->readMapEnd();
7363 }
7364 this->__isset.attributes = true;
7365 } else {
7366 xfer += iprot->skip(ftype);
7367 }
7368 break;
7369 default:
7370 xfer += iprot->skip(ftype);
7371 break;
7372 }
7373 xfer += iprot->readFieldEnd();
7374 }
7375
7376 xfer += iprot->readStructEnd();
7377
7378 return xfer;
7379 }
7380
7381 uint32_t Hbase_deleteAllRow_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
7382 uint32_t xfer = 0;
7383 xfer += oprot->writeStructBegin("Hbase_deleteAllRow_args");
7384
7385 xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
7386 xfer += oprot->writeBinary(this->tableName);
7387 xfer += oprot->writeFieldEnd();
7388
7389 xfer += oprot->writeFieldBegin("row", ::apache::thrift::protocol::T_STRING, 2);
7390 xfer += oprot->writeBinary(this->row);
7391 xfer += oprot->writeFieldEnd();
7392
7393 xfer += oprot->writeFieldBegin("attributes", ::apache::thrift::protocol::T_MAP, 3);
7394 {
7395 xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->attributes.size()));
7396 std::map<Text, Text> ::const_iterator _iter429;
7397 for (_iter429 = this->attributes.begin(); _iter429 != this->attributes.end(); ++_iter429)
7398 {
7399 xfer += oprot->writeBinary(_iter429->first);
7400 xfer += oprot->writeBinary(_iter429->second);
7401 }
7402 xfer += oprot->writeMapEnd();
7403 }
7404 xfer += oprot->writeFieldEnd();
7405
7406 xfer += oprot->writeFieldStop();
7407 xfer += oprot->writeStructEnd();
7408 return xfer;
7409 }
7410
7411 uint32_t Hbase_deleteAllRow_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
7412 uint32_t xfer = 0;
7413 xfer += oprot->writeStructBegin("Hbase_deleteAllRow_pargs");
7414
7415 xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
7416 xfer += oprot->writeBinary((*(this->tableName)));
7417 xfer += oprot->writeFieldEnd();
7418
7419 xfer += oprot->writeFieldBegin("row", ::apache::thrift::protocol::T_STRING, 2);
7420 xfer += oprot->writeBinary((*(this->row)));
7421 xfer += oprot->writeFieldEnd();
7422
7423 xfer += oprot->writeFieldBegin("attributes", ::apache::thrift::protocol::T_MAP, 3);
7424 {
7425 xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->attributes)).size()));
7426 std::map<Text, Text> ::const_iterator _iter430;
7427 for (_iter430 = (*(this->attributes)).begin(); _iter430 != (*(this->attributes)).end(); ++_iter430)
7428 {
7429 xfer += oprot->writeBinary(_iter430->first);
7430 xfer += oprot->writeBinary(_iter430->second);
7431 }
7432 xfer += oprot->writeMapEnd();
7433 }
7434 xfer += oprot->writeFieldEnd();
7435
7436 xfer += oprot->writeFieldStop();
7437 xfer += oprot->writeStructEnd();
7438 return xfer;
7439 }
7440
7441 uint32_t Hbase_deleteAllRow_result::read(::apache::thrift::protocol::TProtocol* iprot) {
7442
7443 uint32_t xfer = 0;
7444 std::string fname;
7445 ::apache::thrift::protocol::TType ftype;
7446 int16_t fid;
7447
7448 xfer += iprot->readStructBegin(fname);
7449
7450 using ::apache::thrift::protocol::TProtocolException;
7451
7452
7453 while (true)
7454 {
7455 xfer += iprot->readFieldBegin(fname, ftype, fid);
7456 if (ftype == ::apache::thrift::protocol::T_STOP) {
7457 break;
7458 }
7459 switch (fid)
7460 {
7461 case 1:
7462 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
7463 xfer += this->io.read(iprot);
7464 this->__isset.io = true;
7465 } else {
7466 xfer += iprot->skip(ftype);
7467 }
7468 break;
7469 default:
7470 xfer += iprot->skip(ftype);
7471 break;
7472 }
7473 xfer += iprot->readFieldEnd();
7474 }
7475
7476 xfer += iprot->readStructEnd();
7477
7478 return xfer;
7479 }
7480
7481 uint32_t Hbase_deleteAllRow_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
7482
7483 uint32_t xfer = 0;
7484
7485 xfer += oprot->writeStructBegin("Hbase_deleteAllRow_result");
7486
7487 if (this->__isset.io) {
7488 xfer += oprot->writeFieldBegin("io", ::apache::thrift::protocol::T_STRUCT, 1);
7489 xfer += this->io.write(oprot);
7490 xfer += oprot->writeFieldEnd();
7491 }
7492 xfer += oprot->writeFieldStop();
7493 xfer += oprot->writeStructEnd();
7494 return xfer;
7495 }
7496
7497 uint32_t Hbase_deleteAllRow_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
7498
7499 uint32_t xfer = 0;
7500 std::string fname;
7501 ::apache::thrift::protocol::TType ftype;
7502 int16_t fid;
7503
7504 xfer += iprot->readStructBegin(fname);
7505
7506 using ::apache::thrift::protocol::TProtocolException;
7507
7508
7509 while (true)
7510 {
7511 xfer += iprot->readFieldBegin(fname, ftype, fid);
7512 if (ftype == ::apache::thrift::protocol::T_STOP) {
7513 break;
7514 }
7515 switch (fid)
7516 {
7517 case 1:
7518 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
7519 xfer += this->io.read(iprot);
7520 this->__isset.io = true;
7521 } else {
7522 xfer += iprot->skip(ftype);
7523 }
7524 break;
7525 default:
7526 xfer += iprot->skip(ftype);
7527 break;
7528 }
7529 xfer += iprot->readFieldEnd();
7530 }
7531
7532 xfer += iprot->readStructEnd();
7533
7534 return xfer;
7535 }
7536
7537 uint32_t Hbase_increment_args::read(::apache::thrift::protocol::TProtocol* iprot) {
7538
7539 uint32_t xfer = 0;
7540 std::string fname;
7541 ::apache::thrift::protocol::TType ftype;
7542 int16_t fid;
7543
7544 xfer += iprot->readStructBegin(fname);
7545
7546 using ::apache::thrift::protocol::TProtocolException;
7547
7548
7549 while (true)
7550 {
7551 xfer += iprot->readFieldBegin(fname, ftype, fid);
7552 if (ftype == ::apache::thrift::protocol::T_STOP) {
7553 break;
7554 }
7555 switch (fid)
7556 {
7557 case 1:
7558 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
7559 xfer += this->increment.read(iprot);
7560 this->__isset.increment = true;
7561 } else {
7562 xfer += iprot->skip(ftype);
7563 }
7564 break;
7565 default:
7566 xfer += iprot->skip(ftype);
7567 break;
7568 }
7569 xfer += iprot->readFieldEnd();
7570 }
7571
7572 xfer += iprot->readStructEnd();
7573
7574 return xfer;
7575 }
7576
7577 uint32_t Hbase_increment_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
7578 uint32_t xfer = 0;
7579 xfer += oprot->writeStructBegin("Hbase_increment_args");
7580
7581 xfer += oprot->writeFieldBegin("increment", ::apache::thrift::protocol::T_STRUCT, 1);
7582 xfer += this->increment.write(oprot);
7583 xfer += oprot->writeFieldEnd();
7584
7585 xfer += oprot->writeFieldStop();
7586 xfer += oprot->writeStructEnd();
7587 return xfer;
7588 }
7589
7590 uint32_t Hbase_increment_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
7591 uint32_t xfer = 0;
7592 xfer += oprot->writeStructBegin("Hbase_increment_pargs");
7593
7594 xfer += oprot->writeFieldBegin("increment", ::apache::thrift::protocol::T_STRUCT, 1);
7595 xfer += (*(this->increment)).write(oprot);
7596 xfer += oprot->writeFieldEnd();
7597
7598 xfer += oprot->writeFieldStop();
7599 xfer += oprot->writeStructEnd();
7600 return xfer;
7601 }
7602
7603 uint32_t Hbase_increment_result::read(::apache::thrift::protocol::TProtocol* iprot) {
7604
7605 uint32_t xfer = 0;
7606 std::string fname;
7607 ::apache::thrift::protocol::TType ftype;
7608 int16_t fid;
7609
7610 xfer += iprot->readStructBegin(fname);
7611
7612 using ::apache::thrift::protocol::TProtocolException;
7613
7614
7615 while (true)
7616 {
7617 xfer += iprot->readFieldBegin(fname, ftype, fid);
7618 if (ftype == ::apache::thrift::protocol::T_STOP) {
7619 break;
7620 }
7621 switch (fid)
7622 {
7623 case 1:
7624 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
7625 xfer += this->io.read(iprot);
7626 this->__isset.io = true;
7627 } else {
7628 xfer += iprot->skip(ftype);
7629 }
7630 break;
7631 default:
7632 xfer += iprot->skip(ftype);
7633 break;
7634 }
7635 xfer += iprot->readFieldEnd();
7636 }
7637
7638 xfer += iprot->readStructEnd();
7639
7640 return xfer;
7641 }
7642
7643 uint32_t Hbase_increment_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
7644
7645 uint32_t xfer = 0;
7646
7647 xfer += oprot->writeStructBegin("Hbase_increment_result");
7648
7649 if (this->__isset.io) {
7650 xfer += oprot->writeFieldBegin("io", ::apache::thrift::protocol::T_STRUCT, 1);
7651 xfer += this->io.write(oprot);
7652 xfer += oprot->writeFieldEnd();
7653 }
7654 xfer += oprot->writeFieldStop();
7655 xfer += oprot->writeStructEnd();
7656 return xfer;
7657 }
7658
7659 uint32_t Hbase_increment_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
7660
7661 uint32_t xfer = 0;
7662 std::string fname;
7663 ::apache::thrift::protocol::TType ftype;
7664 int16_t fid;
7665
7666 xfer += iprot->readStructBegin(fname);
7667
7668 using ::apache::thrift::protocol::TProtocolException;
7669
7670
7671 while (true)
7672 {
7673 xfer += iprot->readFieldBegin(fname, ftype, fid);
7674 if (ftype == ::apache::thrift::protocol::T_STOP) {
7675 break;
7676 }
7677 switch (fid)
7678 {
7679 case 1:
7680 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
7681 xfer += this->io.read(iprot);
7682 this->__isset.io = true;
7683 } else {
7684 xfer += iprot->skip(ftype);
7685 }
7686 break;
7687 default:
7688 xfer += iprot->skip(ftype);
7689 break;
7690 }
7691 xfer += iprot->readFieldEnd();
7692 }
7693
7694 xfer += iprot->readStructEnd();
7695
7696 return xfer;
7697 }
7698
7699 uint32_t Hbase_incrementRows_args::read(::apache::thrift::protocol::TProtocol* iprot) {
7700
7701 uint32_t xfer = 0;
7702 std::string fname;
7703 ::apache::thrift::protocol::TType ftype;
7704 int16_t fid;
7705
7706 xfer += iprot->readStructBegin(fname);
7707
7708 using ::apache::thrift::protocol::TProtocolException;
7709
7710
7711 while (true)
7712 {
7713 xfer += iprot->readFieldBegin(fname, ftype, fid);
7714 if (ftype == ::apache::thrift::protocol::T_STOP) {
7715 break;
7716 }
7717 switch (fid)
7718 {
7719 case 1:
7720 if (ftype == ::apache::thrift::protocol::T_LIST) {
7721 {
7722 this->increments.clear();
7723 uint32_t _size431;
7724 ::apache::thrift::protocol::TType _etype434;
7725 xfer += iprot->readListBegin(_etype434, _size431);
7726 this->increments.resize(_size431);
7727 uint32_t _i435;
7728 for (_i435 = 0; _i435 < _size431; ++_i435)
7729 {
7730 xfer += this->increments[_i435].read(iprot);
7731 }
7732 xfer += iprot->readListEnd();
7733 }
7734 this->__isset.increments = true;
7735 } else {
7736 xfer += iprot->skip(ftype);
7737 }
7738 break;
7739 default:
7740 xfer += iprot->skip(ftype);
7741 break;
7742 }
7743 xfer += iprot->readFieldEnd();
7744 }
7745
7746 xfer += iprot->readStructEnd();
7747
7748 return xfer;
7749 }
7750
7751 uint32_t Hbase_incrementRows_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
7752 uint32_t xfer = 0;
7753 xfer += oprot->writeStructBegin("Hbase_incrementRows_args");
7754
7755 xfer += oprot->writeFieldBegin("increments", ::apache::thrift::protocol::T_LIST, 1);
7756 {
7757 xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->increments.size()));
7758 std::vector<TIncrement> ::const_iterator _iter436;
7759 for (_iter436 = this->increments.begin(); _iter436 != this->increments.end(); ++_iter436)
7760 {
7761 xfer += (*_iter436).write(oprot);
7762 }
7763 xfer += oprot->writeListEnd();
7764 }
7765 xfer += oprot->writeFieldEnd();
7766
7767 xfer += oprot->writeFieldStop();
7768 xfer += oprot->writeStructEnd();
7769 return xfer;
7770 }
7771
7772 uint32_t Hbase_incrementRows_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
7773 uint32_t xfer = 0;
7774 xfer += oprot->writeStructBegin("Hbase_incrementRows_pargs");
7775
7776 xfer += oprot->writeFieldBegin("increments", ::apache::thrift::protocol::T_LIST, 1);
7777 {
7778 xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>((*(this->increments)).size()));
7779 std::vector<TIncrement> ::const_iterator _iter437;
7780 for (_iter437 = (*(this->increments)).begin(); _iter437 != (*(this->increments)).end(); ++_iter437)
7781 {
7782 xfer += (*_iter437).write(oprot);
7783 }
7784 xfer += oprot->writeListEnd();
7785 }
7786 xfer += oprot->writeFieldEnd();
7787
7788 xfer += oprot->writeFieldStop();
7789 xfer += oprot->writeStructEnd();
7790 return xfer;
7791 }
7792
7793 uint32_t Hbase_incrementRows_result::read(::apache::thrift::protocol::TProtocol* iprot) {
7794
7795 uint32_t xfer = 0;
7796 std::string fname;
7797 ::apache::thrift::protocol::TType ftype;
7798 int16_t fid;
7799
7800 xfer += iprot->readStructBegin(fname);
7801
7802 using ::apache::thrift::protocol::TProtocolException;
7803
7804
7805 while (true)
7806 {
7807 xfer += iprot->readFieldBegin(fname, ftype, fid);
7808 if (ftype == ::apache::thrift::protocol::T_STOP) {
7809 break;
7810 }
7811 switch (fid)
7812 {
7813 case 1:
7814 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
7815 xfer += this->io.read(iprot);
7816 this->__isset.io = true;
7817 } else {
7818 xfer += iprot->skip(ftype);
7819 }
7820 break;
7821 default:
7822 xfer += iprot->skip(ftype);
7823 break;
7824 }
7825 xfer += iprot->readFieldEnd();
7826 }
7827
7828 xfer += iprot->readStructEnd();
7829
7830 return xfer;
7831 }
7832
7833 uint32_t Hbase_incrementRows_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
7834
7835 uint32_t xfer = 0;
7836
7837 xfer += oprot->writeStructBegin("Hbase_incrementRows_result");
7838
7839 if (this->__isset.io) {
7840 xfer += oprot->writeFieldBegin("io", ::apache::thrift::protocol::T_STRUCT, 1);
7841 xfer += this->io.write(oprot);
7842 xfer += oprot->writeFieldEnd();
7843 }
7844 xfer += oprot->writeFieldStop();
7845 xfer += oprot->writeStructEnd();
7846 return xfer;
7847 }
7848
7849 uint32_t Hbase_incrementRows_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
7850
7851 uint32_t xfer = 0;
7852 std::string fname;
7853 ::apache::thrift::protocol::TType ftype;
7854 int16_t fid;
7855
7856 xfer += iprot->readStructBegin(fname);
7857
7858 using ::apache::thrift::protocol::TProtocolException;
7859
7860
7861 while (true)
7862 {
7863 xfer += iprot->readFieldBegin(fname, ftype, fid);
7864 if (ftype == ::apache::thrift::protocol::T_STOP) {
7865 break;
7866 }
7867 switch (fid)
7868 {
7869 case 1:
7870 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
7871 xfer += this->io.read(iprot);
7872 this->__isset.io = true;
7873 } else {
7874 xfer += iprot->skip(ftype);
7875 }
7876 break;
7877 default:
7878 xfer += iprot->skip(ftype);
7879 break;
7880 }
7881 xfer += iprot->readFieldEnd();
7882 }
7883
7884 xfer += iprot->readStructEnd();
7885
7886 return xfer;
7887 }
7888
7889 uint32_t Hbase_deleteAllRowTs_args::read(::apache::thrift::protocol::TProtocol* iprot) {
7890
7891 uint32_t xfer = 0;
7892 std::string fname;
7893 ::apache::thrift::protocol::TType ftype;
7894 int16_t fid;
7895
7896 xfer += iprot->readStructBegin(fname);
7897
7898 using ::apache::thrift::protocol::TProtocolException;
7899
7900
7901 while (true)
7902 {
7903 xfer += iprot->readFieldBegin(fname, ftype, fid);
7904 if (ftype == ::apache::thrift::protocol::T_STOP) {
7905 break;
7906 }
7907 switch (fid)
7908 {
7909 case 1:
7910 if (ftype == ::apache::thrift::protocol::T_STRING) {
7911 xfer += iprot->readBinary(this->tableName);
7912 this->__isset.tableName = true;
7913 } else {
7914 xfer += iprot->skip(ftype);
7915 }
7916 break;
7917 case 2:
7918 if (ftype == ::apache::thrift::protocol::T_STRING) {
7919 xfer += iprot->readBinary(this->row);
7920 this->__isset.row = true;
7921 } else {
7922 xfer += iprot->skip(ftype);
7923 }
7924 break;
7925 case 3:
7926 if (ftype == ::apache::thrift::protocol::T_I64) {
7927 xfer += iprot->readI64(this->timestamp);
7928 this->__isset.timestamp = true;
7929 } else {
7930 xfer += iprot->skip(ftype);
7931 }
7932 break;
7933 case 4:
7934 if (ftype == ::apache::thrift::protocol::T_MAP) {
7935 {
7936 this->attributes.clear();
7937 uint32_t _size438;
7938 ::apache::thrift::protocol::TType _ktype439;
7939 ::apache::thrift::protocol::TType _vtype440;
7940 xfer += iprot->readMapBegin(_ktype439, _vtype440, _size438);
7941 uint32_t _i442;
7942 for (_i442 = 0; _i442 < _size438; ++_i442)
7943 {
7944 Text _key443;
7945 xfer += iprot->readBinary(_key443);
7946 Text& _val444 = this->attributes[_key443];
7947 xfer += iprot->readBinary(_val444);
7948 }
7949 xfer += iprot->readMapEnd();
7950 }
7951 this->__isset.attributes = true;
7952 } else {
7953 xfer += iprot->skip(ftype);
7954 }
7955 break;
7956 default:
7957 xfer += iprot->skip(ftype);
7958 break;
7959 }
7960 xfer += iprot->readFieldEnd();
7961 }
7962
7963 xfer += iprot->readStructEnd();
7964
7965 return xfer;
7966 }
7967
7968 uint32_t Hbase_deleteAllRowTs_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
7969 uint32_t xfer = 0;
7970 xfer += oprot->writeStructBegin("Hbase_deleteAllRowTs_args");
7971
7972 xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
7973 xfer += oprot->writeBinary(this->tableName);
7974 xfer += oprot->writeFieldEnd();
7975
7976 xfer += oprot->writeFieldBegin("row", ::apache::thrift::protocol::T_STRING, 2);
7977 xfer += oprot->writeBinary(this->row);
7978 xfer += oprot->writeFieldEnd();
7979
7980 xfer += oprot->writeFieldBegin("timestamp", ::apache::thrift::protocol::T_I64, 3);
7981 xfer += oprot->writeI64(this->timestamp);
7982 xfer += oprot->writeFieldEnd();
7983
7984 xfer += oprot->writeFieldBegin("attributes", ::apache::thrift::protocol::T_MAP, 4);
7985 {
7986 xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->attributes.size()));
7987 std::map<Text, Text> ::const_iterator _iter445;
7988 for (_iter445 = this->attributes.begin(); _iter445 != this->attributes.end(); ++_iter445)
7989 {
7990 xfer += oprot->writeBinary(_iter445->first);
7991 xfer += oprot->writeBinary(_iter445->second);
7992 }
7993 xfer += oprot->writeMapEnd();
7994 }
7995 xfer += oprot->writeFieldEnd();
7996
7997 xfer += oprot->writeFieldStop();
7998 xfer += oprot->writeStructEnd();
7999 return xfer;
8000 }
8001
8002 uint32_t Hbase_deleteAllRowTs_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
8003 uint32_t xfer = 0;
8004 xfer += oprot->writeStructBegin("Hbase_deleteAllRowTs_pargs");
8005
8006 xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
8007 xfer += oprot->writeBinary((*(this->tableName)));
8008 xfer += oprot->writeFieldEnd();
8009
8010 xfer += oprot->writeFieldBegin("row", ::apache::thrift::protocol::T_STRING, 2);
8011 xfer += oprot->writeBinary((*(this->row)));
8012 xfer += oprot->writeFieldEnd();
8013
8014 xfer += oprot->writeFieldBegin("timestamp", ::apache::thrift::protocol::T_I64, 3);
8015 xfer += oprot->writeI64((*(this->timestamp)));
8016 xfer += oprot->writeFieldEnd();
8017
8018 xfer += oprot->writeFieldBegin("attributes", ::apache::thrift::protocol::T_MAP, 4);
8019 {
8020 xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->attributes)).size()));
8021 std::map<Text, Text> ::const_iterator _iter446;
8022 for (_iter446 = (*(this->attributes)).begin(); _iter446 != (*(this->attributes)).end(); ++_iter446)
8023 {
8024 xfer += oprot->writeBinary(_iter446->first);
8025 xfer += oprot->writeBinary(_iter446->second);
8026 }
8027 xfer += oprot->writeMapEnd();
8028 }
8029 xfer += oprot->writeFieldEnd();
8030
8031 xfer += oprot->writeFieldStop();
8032 xfer += oprot->writeStructEnd();
8033 return xfer;
8034 }
8035
8036 uint32_t Hbase_deleteAllRowTs_result::read(::apache::thrift::protocol::TProtocol* iprot) {
8037
8038 uint32_t xfer = 0;
8039 std::string fname;
8040 ::apache::thrift::protocol::TType ftype;
8041 int16_t fid;
8042
8043 xfer += iprot->readStructBegin(fname);
8044
8045 using ::apache::thrift::protocol::TProtocolException;
8046
8047
8048 while (true)
8049 {
8050 xfer += iprot->readFieldBegin(fname, ftype, fid);
8051 if (ftype == ::apache::thrift::protocol::T_STOP) {
8052 break;
8053 }
8054 switch (fid)
8055 {
8056 case 1:
8057 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
8058 xfer += this->io.read(iprot);
8059 this->__isset.io = true;
8060 } else {
8061 xfer += iprot->skip(ftype);
8062 }
8063 break;
8064 default:
8065 xfer += iprot->skip(ftype);
8066 break;
8067 }
8068 xfer += iprot->readFieldEnd();
8069 }
8070
8071 xfer += iprot->readStructEnd();
8072
8073 return xfer;
8074 }
8075
8076 uint32_t Hbase_deleteAllRowTs_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
8077
8078 uint32_t xfer = 0;
8079
8080 xfer += oprot->writeStructBegin("Hbase_deleteAllRowTs_result");
8081
8082 if (this->__isset.io) {
8083 xfer += oprot->writeFieldBegin("io", ::apache::thrift::protocol::T_STRUCT, 1);
8084 xfer += this->io.write(oprot);
8085 xfer += oprot->writeFieldEnd();
8086 }
8087 xfer += oprot->writeFieldStop();
8088 xfer += oprot->writeStructEnd();
8089 return xfer;
8090 }
8091
8092 uint32_t Hbase_deleteAllRowTs_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
8093
8094 uint32_t xfer = 0;
8095 std::string fname;
8096 ::apache::thrift::protocol::TType ftype;
8097 int16_t fid;
8098
8099 xfer += iprot->readStructBegin(fname);
8100
8101 using ::apache::thrift::protocol::TProtocolException;
8102
8103
8104 while (true)
8105 {
8106 xfer += iprot->readFieldBegin(fname, ftype, fid);
8107 if (ftype == ::apache::thrift::protocol::T_STOP) {
8108 break;
8109 }
8110 switch (fid)
8111 {
8112 case 1:
8113 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
8114 xfer += this->io.read(iprot);
8115 this->__isset.io = true;
8116 } else {
8117 xfer += iprot->skip(ftype);
8118 }
8119 break;
8120 default:
8121 xfer += iprot->skip(ftype);
8122 break;
8123 }
8124 xfer += iprot->readFieldEnd();
8125 }
8126
8127 xfer += iprot->readStructEnd();
8128
8129 return xfer;
8130 }
8131
8132 uint32_t Hbase_scannerOpenWithScan_args::read(::apache::thrift::protocol::TProtocol* iprot) {
8133
8134 uint32_t xfer = 0;
8135 std::string fname;
8136 ::apache::thrift::protocol::TType ftype;
8137 int16_t fid;
8138
8139 xfer += iprot->readStructBegin(fname);
8140
8141 using ::apache::thrift::protocol::TProtocolException;
8142
8143
8144 while (true)
8145 {
8146 xfer += iprot->readFieldBegin(fname, ftype, fid);
8147 if (ftype == ::apache::thrift::protocol::T_STOP) {
8148 break;
8149 }
8150 switch (fid)
8151 {
8152 case 1:
8153 if (ftype == ::apache::thrift::protocol::T_STRING) {
8154 xfer += iprot->readBinary(this->tableName);
8155 this->__isset.tableName = true;
8156 } else {
8157 xfer += iprot->skip(ftype);
8158 }
8159 break;
8160 case 2:
8161 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
8162 xfer += this->scan.read(iprot);
8163 this->__isset.scan = true;
8164 } else {
8165 xfer += iprot->skip(ftype);
8166 }
8167 break;
8168 case 3:
8169 if (ftype == ::apache::thrift::protocol::T_MAP) {
8170 {
8171 this->attributes.clear();
8172 uint32_t _size447;
8173 ::apache::thrift::protocol::TType _ktype448;
8174 ::apache::thrift::protocol::TType _vtype449;
8175 xfer += iprot->readMapBegin(_ktype448, _vtype449, _size447);
8176 uint32_t _i451;
8177 for (_i451 = 0; _i451 < _size447; ++_i451)
8178 {
8179 Text _key452;
8180 xfer += iprot->readBinary(_key452);
8181 Text& _val453 = this->attributes[_key452];
8182 xfer += iprot->readBinary(_val453);
8183 }
8184 xfer += iprot->readMapEnd();
8185 }
8186 this->__isset.attributes = true;
8187 } else {
8188 xfer += iprot->skip(ftype);
8189 }
8190 break;
8191 default:
8192 xfer += iprot->skip(ftype);
8193 break;
8194 }
8195 xfer += iprot->readFieldEnd();
8196 }
8197
8198 xfer += iprot->readStructEnd();
8199
8200 return xfer;
8201 }
8202
8203 uint32_t Hbase_scannerOpenWithScan_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
8204 uint32_t xfer = 0;
8205 xfer += oprot->writeStructBegin("Hbase_scannerOpenWithScan_args");
8206
8207 xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
8208 xfer += oprot->writeBinary(this->tableName);
8209 xfer += oprot->writeFieldEnd();
8210
8211 xfer += oprot->writeFieldBegin("scan", ::apache::thrift::protocol::T_STRUCT, 2);
8212 xfer += this->scan.write(oprot);
8213 xfer += oprot->writeFieldEnd();
8214
8215 xfer += oprot->writeFieldBegin("attributes", ::apache::thrift::protocol::T_MAP, 3);
8216 {
8217 xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->attributes.size()));
8218 std::map<Text, Text> ::const_iterator _iter454;
8219 for (_iter454 = this->attributes.begin(); _iter454 != this->attributes.end(); ++_iter454)
8220 {
8221 xfer += oprot->writeBinary(_iter454->first);
8222 xfer += oprot->writeBinary(_iter454->second);
8223 }
8224 xfer += oprot->writeMapEnd();
8225 }
8226 xfer += oprot->writeFieldEnd();
8227
8228 xfer += oprot->writeFieldStop();
8229 xfer += oprot->writeStructEnd();
8230 return xfer;
8231 }
8232
8233 uint32_t Hbase_scannerOpenWithScan_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
8234 uint32_t xfer = 0;
8235 xfer += oprot->writeStructBegin("Hbase_scannerOpenWithScan_pargs");
8236
8237 xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
8238 xfer += oprot->writeBinary((*(this->tableName)));
8239 xfer += oprot->writeFieldEnd();
8240
8241 xfer += oprot->writeFieldBegin("scan", ::apache::thrift::protocol::T_STRUCT, 2);
8242 xfer += (*(this->scan)).write(oprot);
8243 xfer += oprot->writeFieldEnd();
8244
8245 xfer += oprot->writeFieldBegin("attributes", ::apache::thrift::protocol::T_MAP, 3);
8246 {
8247 xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->attributes)).size()));
8248 std::map<Text, Text> ::const_iterator _iter455;
8249 for (_iter455 = (*(this->attributes)).begin(); _iter455 != (*(this->attributes)).end(); ++_iter455)
8250 {
8251 xfer += oprot->writeBinary(_iter455->first);
8252 xfer += oprot->writeBinary(_iter455->second);
8253 }
8254 xfer += oprot->writeMapEnd();
8255 }
8256 xfer += oprot->writeFieldEnd();
8257
8258 xfer += oprot->writeFieldStop();
8259 xfer += oprot->writeStructEnd();
8260 return xfer;
8261 }
8262
8263 uint32_t Hbase_scannerOpenWithScan_result::read(::apache::thrift::protocol::TProtocol* iprot) {
8264
8265 uint32_t xfer = 0;
8266 std::string fname;
8267 ::apache::thrift::protocol::TType ftype;
8268 int16_t fid;
8269
8270 xfer += iprot->readStructBegin(fname);
8271
8272 using ::apache::thrift::protocol::TProtocolException;
8273
8274
8275 while (true)
8276 {
8277 xfer += iprot->readFieldBegin(fname, ftype, fid);
8278 if (ftype == ::apache::thrift::protocol::T_STOP) {
8279 break;
8280 }
8281 switch (fid)
8282 {
8283 case 0:
8284 if (ftype == ::apache::thrift::protocol::T_I32) {
8285 xfer += iprot->readI32(this->success);
8286 this->__isset.success = true;
8287 } else {
8288 xfer += iprot->skip(ftype);
8289 }
8290 break;
8291 case 1:
8292 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
8293 xfer += this->io.read(iprot);
8294 this->__isset.io = true;
8295 } else {
8296 xfer += iprot->skip(ftype);
8297 }
8298 break;
8299 default:
8300 xfer += iprot->skip(ftype);
8301 break;
8302 }
8303 xfer += iprot->readFieldEnd();
8304 }
8305
8306 xfer += iprot->readStructEnd();
8307
8308 return xfer;
8309 }
8310
8311 uint32_t Hbase_scannerOpenWithScan_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
8312
8313 uint32_t xfer = 0;
8314
8315 xfer += oprot->writeStructBegin("Hbase_scannerOpenWithScan_result");
8316
8317 if (this->__isset.success) {
8318 xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_I32, 0);
8319 xfer += oprot->writeI32(this->success);
8320 xfer += oprot->writeFieldEnd();
8321 } else if (this->__isset.io) {
8322 xfer += oprot->writeFieldBegin("io", ::apache::thrift::protocol::T_STRUCT, 1);
8323 xfer += this->io.write(oprot);
8324 xfer += oprot->writeFieldEnd();
8325 }
8326 xfer += oprot->writeFieldStop();
8327 xfer += oprot->writeStructEnd();
8328 return xfer;
8329 }
8330
8331 uint32_t Hbase_scannerOpenWithScan_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
8332
8333 uint32_t xfer = 0;
8334 std::string fname;
8335 ::apache::thrift::protocol::TType ftype;
8336 int16_t fid;
8337
8338 xfer += iprot->readStructBegin(fname);
8339
8340 using ::apache::thrift::protocol::TProtocolException;
8341
8342
8343 while (true)
8344 {
8345 xfer += iprot->readFieldBegin(fname, ftype, fid);
8346 if (ftype == ::apache::thrift::protocol::T_STOP) {
8347 break;
8348 }
8349 switch (fid)
8350 {
8351 case 0:
8352 if (ftype == ::apache::thrift::protocol::T_I32) {
8353 xfer += iprot->readI32((*(this->success)));
8354 this->__isset.success = true;
8355 } else {
8356 xfer += iprot->skip(ftype);
8357 }
8358 break;
8359 case 1:
8360 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
8361 xfer += this->io.read(iprot);
8362 this->__isset.io = true;
8363 } else {
8364 xfer += iprot->skip(ftype);
8365 }
8366 break;
8367 default:
8368 xfer += iprot->skip(ftype);
8369 break;
8370 }
8371 xfer += iprot->readFieldEnd();
8372 }
8373
8374 xfer += iprot->readStructEnd();
8375
8376 return xfer;
8377 }
8378
8379 uint32_t Hbase_scannerOpen_args::read(::apache::thrift::protocol::TProtocol* iprot) {
8380
8381 uint32_t xfer = 0;
8382 std::string fname;
8383 ::apache::thrift::protocol::TType ftype;
8384 int16_t fid;
8385
8386 xfer += iprot->readStructBegin(fname);
8387
8388 using ::apache::thrift::protocol::TProtocolException;
8389
8390
8391 while (true)
8392 {
8393 xfer += iprot->readFieldBegin(fname, ftype, fid);
8394 if (ftype == ::apache::thrift::protocol::T_STOP) {
8395 break;
8396 }
8397 switch (fid)
8398 {
8399 case 1:
8400 if (ftype == ::apache::thrift::protocol::T_STRING) {
8401 xfer += iprot->readBinary(this->tableName);
8402 this->__isset.tableName = true;
8403 } else {
8404 xfer += iprot->skip(ftype);
8405 }
8406 break;
8407 case 2:
8408 if (ftype == ::apache::thrift::protocol::T_STRING) {
8409 xfer += iprot->readBinary(this->startRow);
8410 this->__isset.startRow = true;
8411 } else {
8412 xfer += iprot->skip(ftype);
8413 }
8414 break;
8415 case 3:
8416 if (ftype == ::apache::thrift::protocol::T_LIST) {
8417 {
8418 this->columns.clear();
8419 uint32_t _size456;
8420 ::apache::thrift::protocol::TType _etype459;
8421 xfer += iprot->readListBegin(_etype459, _size456);
8422 this->columns.resize(_size456);
8423 uint32_t _i460;
8424 for (_i460 = 0; _i460 < _size456; ++_i460)
8425 {
8426 xfer += iprot->readBinary(this->columns[_i460]);
8427 }
8428 xfer += iprot->readListEnd();
8429 }
8430 this->__isset.columns = true;
8431 } else {
8432 xfer += iprot->skip(ftype);
8433 }
8434 break;
8435 case 4:
8436 if (ftype == ::apache::thrift::protocol::T_MAP) {
8437 {
8438 this->attributes.clear();
8439 uint32_t _size461;
8440 ::apache::thrift::protocol::TType _ktype462;
8441 ::apache::thrift::protocol::TType _vtype463;
8442 xfer += iprot->readMapBegin(_ktype462, _vtype463, _size461);
8443 uint32_t _i465;
8444 for (_i465 = 0; _i465 < _size461; ++_i465)
8445 {
8446 Text _key466;
8447 xfer += iprot->readBinary(_key466);
8448 Text& _val467 = this->attributes[_key466];
8449 xfer += iprot->readBinary(_val467);
8450 }
8451 xfer += iprot->readMapEnd();
8452 }
8453 this->__isset.attributes = true;
8454 } else {
8455 xfer += iprot->skip(ftype);
8456 }
8457 break;
8458 default:
8459 xfer += iprot->skip(ftype);
8460 break;
8461 }
8462 xfer += iprot->readFieldEnd();
8463 }
8464
8465 xfer += iprot->readStructEnd();
8466
8467 return xfer;
8468 }
8469
8470 uint32_t Hbase_scannerOpen_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
8471 uint32_t xfer = 0;
8472 xfer += oprot->writeStructBegin("Hbase_scannerOpen_args");
8473
8474 xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
8475 xfer += oprot->writeBinary(this->tableName);
8476 xfer += oprot->writeFieldEnd();
8477
8478 xfer += oprot->writeFieldBegin("startRow", ::apache::thrift::protocol::T_STRING, 2);
8479 xfer += oprot->writeBinary(this->startRow);
8480 xfer += oprot->writeFieldEnd();
8481
8482 xfer += oprot->writeFieldBegin("columns", ::apache::thrift::protocol::T_LIST, 3);
8483 {
8484 xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->columns.size()));
8485 std::vector<Text> ::const_iterator _iter468;
8486 for (_iter468 = this->columns.begin(); _iter468 != this->columns.end(); ++_iter468)
8487 {
8488 xfer += oprot->writeBinary((*_iter468));
8489 }
8490 xfer += oprot->writeListEnd();
8491 }
8492 xfer += oprot->writeFieldEnd();
8493
8494 xfer += oprot->writeFieldBegin("attributes", ::apache::thrift::protocol::T_MAP, 4);
8495 {
8496 xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->attributes.size()));
8497 std::map<Text, Text> ::const_iterator _iter469;
8498 for (_iter469 = this->attributes.begin(); _iter469 != this->attributes.end(); ++_iter469)
8499 {
8500 xfer += oprot->writeBinary(_iter469->first);
8501 xfer += oprot->writeBinary(_iter469->second);
8502 }
8503 xfer += oprot->writeMapEnd();
8504 }
8505 xfer += oprot->writeFieldEnd();
8506
8507 xfer += oprot->writeFieldStop();
8508 xfer += oprot->writeStructEnd();
8509 return xfer;
8510 }
8511
8512 uint32_t Hbase_scannerOpen_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
8513 uint32_t xfer = 0;
8514 xfer += oprot->writeStructBegin("Hbase_scannerOpen_pargs");
8515
8516 xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
8517 xfer += oprot->writeBinary((*(this->tableName)));
8518 xfer += oprot->writeFieldEnd();
8519
8520 xfer += oprot->writeFieldBegin("startRow", ::apache::thrift::protocol::T_STRING, 2);
8521 xfer += oprot->writeBinary((*(this->startRow)));
8522 xfer += oprot->writeFieldEnd();
8523
8524 xfer += oprot->writeFieldBegin("columns", ::apache::thrift::protocol::T_LIST, 3);
8525 {
8526 xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->columns)).size()));
8527 std::vector<Text> ::const_iterator _iter470;
8528 for (_iter470 = (*(this->columns)).begin(); _iter470 != (*(this->columns)).end(); ++_iter470)
8529 {
8530 xfer += oprot->writeBinary((*_iter470));
8531 }
8532 xfer += oprot->writeListEnd();
8533 }
8534 xfer += oprot->writeFieldEnd();
8535
8536 xfer += oprot->writeFieldBegin("attributes", ::apache::thrift::protocol::T_MAP, 4);
8537 {
8538 xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->attributes)).size()));
8539 std::map<Text, Text> ::const_iterator _iter471;
8540 for (_iter471 = (*(this->attributes)).begin(); _iter471 != (*(this->attributes)).end(); ++_iter471)
8541 {
8542 xfer += oprot->writeBinary(_iter471->first);
8543 xfer += oprot->writeBinary(_iter471->second);
8544 }
8545 xfer += oprot->writeMapEnd();
8546 }
8547 xfer += oprot->writeFieldEnd();
8548
8549 xfer += oprot->writeFieldStop();
8550 xfer += oprot->writeStructEnd();
8551 return xfer;
8552 }
8553
8554 uint32_t Hbase_scannerOpen_result::read(::apache::thrift::protocol::TProtocol* iprot) {
8555
8556 uint32_t xfer = 0;
8557 std::string fname;
8558 ::apache::thrift::protocol::TType ftype;
8559 int16_t fid;
8560
8561 xfer += iprot->readStructBegin(fname);
8562
8563 using ::apache::thrift::protocol::TProtocolException;
8564
8565
8566 while (true)
8567 {
8568 xfer += iprot->readFieldBegin(fname, ftype, fid);
8569 if (ftype == ::apache::thrift::protocol::T_STOP) {
8570 break;
8571 }
8572 switch (fid)
8573 {
8574 case 0:
8575 if (ftype == ::apache::thrift::protocol::T_I32) {
8576 xfer += iprot->readI32(this->success);
8577 this->__isset.success = true;
8578 } else {
8579 xfer += iprot->skip(ftype);
8580 }
8581 break;
8582 case 1:
8583 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
8584 xfer += this->io.read(iprot);
8585 this->__isset.io = true;
8586 } else {
8587 xfer += iprot->skip(ftype);
8588 }
8589 break;
8590 default:
8591 xfer += iprot->skip(ftype);
8592 break;
8593 }
8594 xfer += iprot->readFieldEnd();
8595 }
8596
8597 xfer += iprot->readStructEnd();
8598
8599 return xfer;
8600 }
8601
8602 uint32_t Hbase_scannerOpen_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
8603
8604 uint32_t xfer = 0;
8605
8606 xfer += oprot->writeStructBegin("Hbase_scannerOpen_result");
8607
8608 if (this->__isset.success) {
8609 xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_I32, 0);
8610 xfer += oprot->writeI32(this->success);
8611 xfer += oprot->writeFieldEnd();
8612 } else if (this->__isset.io) {
8613 xfer += oprot->writeFieldBegin("io", ::apache::thrift::protocol::T_STRUCT, 1);
8614 xfer += this->io.write(oprot);
8615 xfer += oprot->writeFieldEnd();
8616 }
8617 xfer += oprot->writeFieldStop();
8618 xfer += oprot->writeStructEnd();
8619 return xfer;
8620 }
8621
8622 uint32_t Hbase_scannerOpen_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
8623
8624 uint32_t xfer = 0;
8625 std::string fname;
8626 ::apache::thrift::protocol::TType ftype;
8627 int16_t fid;
8628
8629 xfer += iprot->readStructBegin(fname);
8630
8631 using ::apache::thrift::protocol::TProtocolException;
8632
8633
8634 while (true)
8635 {
8636 xfer += iprot->readFieldBegin(fname, ftype, fid);
8637 if (ftype == ::apache::thrift::protocol::T_STOP) {
8638 break;
8639 }
8640 switch (fid)
8641 {
8642 case 0:
8643 if (ftype == ::apache::thrift::protocol::T_I32) {
8644 xfer += iprot->readI32((*(this->success)));
8645 this->__isset.success = true;
8646 } else {
8647 xfer += iprot->skip(ftype);
8648 }
8649 break;
8650 case 1:
8651 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
8652 xfer += this->io.read(iprot);
8653 this->__isset.io = true;
8654 } else {
8655 xfer += iprot->skip(ftype);
8656 }
8657 break;
8658 default:
8659 xfer += iprot->skip(ftype);
8660 break;
8661 }
8662 xfer += iprot->readFieldEnd();
8663 }
8664
8665 xfer += iprot->readStructEnd();
8666
8667 return xfer;
8668 }
8669
8670 uint32_t Hbase_scannerOpenWithStop_args::read(::apache::thrift::protocol::TProtocol* iprot) {
8671
8672 uint32_t xfer = 0;
8673 std::string fname;
8674 ::apache::thrift::protocol::TType ftype;
8675 int16_t fid;
8676
8677 xfer += iprot->readStructBegin(fname);
8678
8679 using ::apache::thrift::protocol::TProtocolException;
8680
8681
8682 while (true)
8683 {
8684 xfer += iprot->readFieldBegin(fname, ftype, fid);
8685 if (ftype == ::apache::thrift::protocol::T_STOP) {
8686 break;
8687 }
8688 switch (fid)
8689 {
8690 case 1:
8691 if (ftype == ::apache::thrift::protocol::T_STRING) {
8692 xfer += iprot->readBinary(this->tableName);
8693 this->__isset.tableName = true;
8694 } else {
8695 xfer += iprot->skip(ftype);
8696 }
8697 break;
8698 case 2:
8699 if (ftype == ::apache::thrift::protocol::T_STRING) {
8700 xfer += iprot->readBinary(this->startRow);
8701 this->__isset.startRow = true;
8702 } else {
8703 xfer += iprot->skip(ftype);
8704 }
8705 break;
8706 case 3:
8707 if (ftype == ::apache::thrift::protocol::T_STRING) {
8708 xfer += iprot->readBinary(this->stopRow);
8709 this->__isset.stopRow = true;
8710 } else {
8711 xfer += iprot->skip(ftype);
8712 }
8713 break;
8714 case 4:
8715 if (ftype == ::apache::thrift::protocol::T_LIST) {
8716 {
8717 this->columns.clear();
8718 uint32_t _size472;
8719 ::apache::thrift::protocol::TType _etype475;
8720 xfer += iprot->readListBegin(_etype475, _size472);
8721 this->columns.resize(_size472);
8722 uint32_t _i476;
8723 for (_i476 = 0; _i476 < _size472; ++_i476)
8724 {
8725 xfer += iprot->readBinary(this->columns[_i476]);
8726 }
8727 xfer += iprot->readListEnd();
8728 }
8729 this->__isset.columns = true;
8730 } else {
8731 xfer += iprot->skip(ftype);
8732 }
8733 break;
8734 case 5:
8735 if (ftype == ::apache::thrift::protocol::T_MAP) {
8736 {
8737 this->attributes.clear();
8738 uint32_t _size477;
8739 ::apache::thrift::protocol::TType _ktype478;
8740 ::apache::thrift::protocol::TType _vtype479;
8741 xfer += iprot->readMapBegin(_ktype478, _vtype479, _size477);
8742 uint32_t _i481;
8743 for (_i481 = 0; _i481 < _size477; ++_i481)
8744 {
8745 Text _key482;
8746 xfer += iprot->readBinary(_key482);
8747 Text& _val483 = this->attributes[_key482];
8748 xfer += iprot->readBinary(_val483);
8749 }
8750 xfer += iprot->readMapEnd();
8751 }
8752 this->__isset.attributes = true;
8753 } else {
8754 xfer += iprot->skip(ftype);
8755 }
8756 break;
8757 default:
8758 xfer += iprot->skip(ftype);
8759 break;
8760 }
8761 xfer += iprot->readFieldEnd();
8762 }
8763
8764 xfer += iprot->readStructEnd();
8765
8766 return xfer;
8767 }
8768
8769 uint32_t Hbase_scannerOpenWithStop_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
8770 uint32_t xfer = 0;
8771 xfer += oprot->writeStructBegin("Hbase_scannerOpenWithStop_args");
8772
8773 xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
8774 xfer += oprot->writeBinary(this->tableName);
8775 xfer += oprot->writeFieldEnd();
8776
8777 xfer += oprot->writeFieldBegin("startRow", ::apache::thrift::protocol::T_STRING, 2);
8778 xfer += oprot->writeBinary(this->startRow);
8779 xfer += oprot->writeFieldEnd();
8780
8781 xfer += oprot->writeFieldBegin("stopRow", ::apache::thrift::protocol::T_STRING, 3);
8782 xfer += oprot->writeBinary(this->stopRow);
8783 xfer += oprot->writeFieldEnd();
8784
8785 xfer += oprot->writeFieldBegin("columns", ::apache::thrift::protocol::T_LIST, 4);
8786 {
8787 xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->columns.size()));
8788 std::vector<Text> ::const_iterator _iter484;
8789 for (_iter484 = this->columns.begin(); _iter484 != this->columns.end(); ++_iter484)
8790 {
8791 xfer += oprot->writeBinary((*_iter484));
8792 }
8793 xfer += oprot->writeListEnd();
8794 }
8795 xfer += oprot->writeFieldEnd();
8796
8797 xfer += oprot->writeFieldBegin("attributes", ::apache::thrift::protocol::T_MAP, 5);
8798 {
8799 xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->attributes.size()));
8800 std::map<Text, Text> ::const_iterator _iter485;
8801 for (_iter485 = this->attributes.begin(); _iter485 != this->attributes.end(); ++_iter485)
8802 {
8803 xfer += oprot->writeBinary(_iter485->first);
8804 xfer += oprot->writeBinary(_iter485->second);
8805 }
8806 xfer += oprot->writeMapEnd();
8807 }
8808 xfer += oprot->writeFieldEnd();
8809
8810 xfer += oprot->writeFieldStop();
8811 xfer += oprot->writeStructEnd();
8812 return xfer;
8813 }
8814
8815 uint32_t Hbase_scannerOpenWithStop_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
8816 uint32_t xfer = 0;
8817 xfer += oprot->writeStructBegin("Hbase_scannerOpenWithStop_pargs");
8818
8819 xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
8820 xfer += oprot->writeBinary((*(this->tableName)));
8821 xfer += oprot->writeFieldEnd();
8822
8823 xfer += oprot->writeFieldBegin("startRow", ::apache::thrift::protocol::T_STRING, 2);
8824 xfer += oprot->writeBinary((*(this->startRow)));
8825 xfer += oprot->writeFieldEnd();
8826
8827 xfer += oprot->writeFieldBegin("stopRow", ::apache::thrift::protocol::T_STRING, 3);
8828 xfer += oprot->writeBinary((*(this->stopRow)));
8829 xfer += oprot->writeFieldEnd();
8830
8831 xfer += oprot->writeFieldBegin("columns", ::apache::thrift::protocol::T_LIST, 4);
8832 {
8833 xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->columns)).size()));
8834 std::vector<Text> ::const_iterator _iter486;
8835 for (_iter486 = (*(this->columns)).begin(); _iter486 != (*(this->columns)).end(); ++_iter486)
8836 {
8837 xfer += oprot->writeBinary((*_iter486));
8838 }
8839 xfer += oprot->writeListEnd();
8840 }
8841 xfer += oprot->writeFieldEnd();
8842
8843 xfer += oprot->writeFieldBegin("attributes", ::apache::thrift::protocol::T_MAP, 5);
8844 {
8845 xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->attributes)).size()));
8846 std::map<Text, Text> ::const_iterator _iter487;
8847 for (_iter487 = (*(this->attributes)).begin(); _iter487 != (*(this->attributes)).end(); ++_iter487)
8848 {
8849 xfer += oprot->writeBinary(_iter487->first);
8850 xfer += oprot->writeBinary(_iter487->second);
8851 }
8852 xfer += oprot->writeMapEnd();
8853 }
8854 xfer += oprot->writeFieldEnd();
8855
8856 xfer += oprot->writeFieldStop();
8857 xfer += oprot->writeStructEnd();
8858 return xfer;
8859 }
8860
8861 uint32_t Hbase_scannerOpenWithStop_result::read(::apache::thrift::protocol::TProtocol* iprot) {
8862
8863 uint32_t xfer = 0;
8864 std::string fname;
8865 ::apache::thrift::protocol::TType ftype;
8866 int16_t fid;
8867
8868 xfer += iprot->readStructBegin(fname);
8869
8870 using ::apache::thrift::protocol::TProtocolException;
8871
8872
8873 while (true)
8874 {
8875 xfer += iprot->readFieldBegin(fname, ftype, fid);
8876 if (ftype == ::apache::thrift::protocol::T_STOP) {
8877 break;
8878 }
8879 switch (fid)
8880 {
8881 case 0:
8882 if (ftype == ::apache::thrift::protocol::T_I32) {
8883 xfer += iprot->readI32(this->success);
8884 this->__isset.success = true;
8885 } else {
8886 xfer += iprot->skip(ftype);
8887 }
8888 break;
8889 case 1:
8890 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
8891 xfer += this->io.read(iprot);
8892 this->__isset.io = true;
8893 } else {
8894 xfer += iprot->skip(ftype);
8895 }
8896 break;
8897 default:
8898 xfer += iprot->skip(ftype);
8899 break;
8900 }
8901 xfer += iprot->readFieldEnd();
8902 }
8903
8904 xfer += iprot->readStructEnd();
8905
8906 return xfer;
8907 }
8908
8909 uint32_t Hbase_scannerOpenWithStop_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
8910
8911 uint32_t xfer = 0;
8912
8913 xfer += oprot->writeStructBegin("Hbase_scannerOpenWithStop_result");
8914
8915 if (this->__isset.success) {
8916 xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_I32, 0);
8917 xfer += oprot->writeI32(this->success);
8918 xfer += oprot->writeFieldEnd();
8919 } else if (this->__isset.io) {
8920 xfer += oprot->writeFieldBegin("io", ::apache::thrift::protocol::T_STRUCT, 1);
8921 xfer += this->io.write(oprot);
8922 xfer += oprot->writeFieldEnd();
8923 }
8924 xfer += oprot->writeFieldStop();
8925 xfer += oprot->writeStructEnd();
8926 return xfer;
8927 }
8928
8929 uint32_t Hbase_scannerOpenWithStop_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
8930
8931 uint32_t xfer = 0;
8932 std::string fname;
8933 ::apache::thrift::protocol::TType ftype;
8934 int16_t fid;
8935
8936 xfer += iprot->readStructBegin(fname);
8937
8938 using ::apache::thrift::protocol::TProtocolException;
8939
8940
8941 while (true)
8942 {
8943 xfer += iprot->readFieldBegin(fname, ftype, fid);
8944 if (ftype == ::apache::thrift::protocol::T_STOP) {
8945 break;
8946 }
8947 switch (fid)
8948 {
8949 case 0:
8950 if (ftype == ::apache::thrift::protocol::T_I32) {
8951 xfer += iprot->readI32((*(this->success)));
8952 this->__isset.success = true;
8953 } else {
8954 xfer += iprot->skip(ftype);
8955 }
8956 break;
8957 case 1:
8958 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
8959 xfer += this->io.read(iprot);
8960 this->__isset.io = true;
8961 } else {
8962 xfer += iprot->skip(ftype);
8963 }
8964 break;
8965 default:
8966 xfer += iprot->skip(ftype);
8967 break;
8968 }
8969 xfer += iprot->readFieldEnd();
8970 }
8971
8972 xfer += iprot->readStructEnd();
8973
8974 return xfer;
8975 }
8976
8977 uint32_t Hbase_scannerOpenWithPrefix_args::read(::apache::thrift::protocol::TProtocol* iprot) {
8978
8979 uint32_t xfer = 0;
8980 std::string fname;
8981 ::apache::thrift::protocol::TType ftype;
8982 int16_t fid;
8983
8984 xfer += iprot->readStructBegin(fname);
8985
8986 using ::apache::thrift::protocol::TProtocolException;
8987
8988
8989 while (true)
8990 {
8991 xfer += iprot->readFieldBegin(fname, ftype, fid);
8992 if (ftype == ::apache::thrift::protocol::T_STOP) {
8993 break;
8994 }
8995 switch (fid)
8996 {
8997 case 1:
8998 if (ftype == ::apache::thrift::protocol::T_STRING) {
8999 xfer += iprot->readBinary(this->tableName);
9000 this->__isset.tableName = true;
9001 } else {
9002 xfer += iprot->skip(ftype);
9003 }
9004 break;
9005 case 2:
9006 if (ftype == ::apache::thrift::protocol::T_STRING) {
9007 xfer += iprot->readBinary(this->startAndPrefix);
9008 this->__isset.startAndPrefix = true;
9009 } else {
9010 xfer += iprot->skip(ftype);
9011 }
9012 break;
9013 case 3:
9014 if (ftype == ::apache::thrift::protocol::T_LIST) {
9015 {
9016 this->columns.clear();
9017 uint32_t _size488;
9018 ::apache::thrift::protocol::TType _etype491;
9019 xfer += iprot->readListBegin(_etype491, _size488);
9020 this->columns.resize(_size488);
9021 uint32_t _i492;
9022 for (_i492 = 0; _i492 < _size488; ++_i492)
9023 {
9024 xfer += iprot->readBinary(this->columns[_i492]);
9025 }
9026 xfer += iprot->readListEnd();
9027 }
9028 this->__isset.columns = true;
9029 } else {
9030 xfer += iprot->skip(ftype);
9031 }
9032 break;
9033 case 4:
9034 if (ftype == ::apache::thrift::protocol::T_MAP) {
9035 {
9036 this->attributes.clear();
9037 uint32_t _size493;
9038 ::apache::thrift::protocol::TType _ktype494;
9039 ::apache::thrift::protocol::TType _vtype495;
9040 xfer += iprot->readMapBegin(_ktype494, _vtype495, _size493);
9041 uint32_t _i497;
9042 for (_i497 = 0; _i497 < _size493; ++_i497)
9043 {
9044 Text _key498;
9045 xfer += iprot->readBinary(_key498);
9046 Text& _val499 = this->attributes[_key498];
9047 xfer += iprot->readBinary(_val499);
9048 }
9049 xfer += iprot->readMapEnd();
9050 }
9051 this->__isset.attributes = true;
9052 } else {
9053 xfer += iprot->skip(ftype);
9054 }
9055 break;
9056 default:
9057 xfer += iprot->skip(ftype);
9058 break;
9059 }
9060 xfer += iprot->readFieldEnd();
9061 }
9062
9063 xfer += iprot->readStructEnd();
9064
9065 return xfer;
9066 }
9067
9068 uint32_t Hbase_scannerOpenWithPrefix_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
9069 uint32_t xfer = 0;
9070 xfer += oprot->writeStructBegin("Hbase_scannerOpenWithPrefix_args");
9071
9072 xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
9073 xfer += oprot->writeBinary(this->tableName);
9074 xfer += oprot->writeFieldEnd();
9075
9076 xfer += oprot->writeFieldBegin("startAndPrefix", ::apache::thrift::protocol::T_STRING, 2);
9077 xfer += oprot->writeBinary(this->startAndPrefix);
9078 xfer += oprot->writeFieldEnd();
9079
9080 xfer += oprot->writeFieldBegin("columns", ::apache::thrift::protocol::T_LIST, 3);
9081 {
9082 xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->columns.size()));
9083 std::vector<Text> ::const_iterator _iter500;
9084 for (_iter500 = this->columns.begin(); _iter500 != this->columns.end(); ++_iter500)
9085 {
9086 xfer += oprot->writeBinary((*_iter500));
9087 }
9088 xfer += oprot->writeListEnd();
9089 }
9090 xfer += oprot->writeFieldEnd();
9091
9092 xfer += oprot->writeFieldBegin("attributes", ::apache::thrift::protocol::T_MAP, 4);
9093 {
9094 xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->attributes.size()));
9095 std::map<Text, Text> ::const_iterator _iter501;
9096 for (_iter501 = this->attributes.begin(); _iter501 != this->attributes.end(); ++_iter501)
9097 {
9098 xfer += oprot->writeBinary(_iter501->first);
9099 xfer += oprot->writeBinary(_iter501->second);
9100 }
9101 xfer += oprot->writeMapEnd();
9102 }
9103 xfer += oprot->writeFieldEnd();
9104
9105 xfer += oprot->writeFieldStop();
9106 xfer += oprot->writeStructEnd();
9107 return xfer;
9108 }
9109
9110 uint32_t Hbase_scannerOpenWithPrefix_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
9111 uint32_t xfer = 0;
9112 xfer += oprot->writeStructBegin("Hbase_scannerOpenWithPrefix_pargs");
9113
9114 xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
9115 xfer += oprot->writeBinary((*(this->tableName)));
9116 xfer += oprot->writeFieldEnd();
9117
9118 xfer += oprot->writeFieldBegin("startAndPrefix", ::apache::thrift::protocol::T_STRING, 2);
9119 xfer += oprot->writeBinary((*(this->startAndPrefix)));
9120 xfer += oprot->writeFieldEnd();
9121
9122 xfer += oprot->writeFieldBegin("columns", ::apache::thrift::protocol::T_LIST, 3);
9123 {
9124 xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->columns)).size()));
9125 std::vector<Text> ::const_iterator _iter502;
9126 for (_iter502 = (*(this->columns)).begin(); _iter502 != (*(this->columns)).end(); ++_iter502)
9127 {
9128 xfer += oprot->writeBinary((*_iter502));
9129 }
9130 xfer += oprot->writeListEnd();
9131 }
9132 xfer += oprot->writeFieldEnd();
9133
9134 xfer += oprot->writeFieldBegin("attributes", ::apache::thrift::protocol::T_MAP, 4);
9135 {
9136 xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->attributes)).size()));
9137 std::map<Text, Text> ::const_iterator _iter503;
9138 for (_iter503 = (*(this->attributes)).begin(); _iter503 != (*(this->attributes)).end(); ++_iter503)
9139 {
9140 xfer += oprot->writeBinary(_iter503->first);
9141 xfer += oprot->writeBinary(_iter503->second);
9142 }
9143 xfer += oprot->writeMapEnd();
9144 }
9145 xfer += oprot->writeFieldEnd();
9146
9147 xfer += oprot->writeFieldStop();
9148 xfer += oprot->writeStructEnd();
9149 return xfer;
9150 }
9151
9152 uint32_t Hbase_scannerOpenWithPrefix_result::read(::apache::thrift::protocol::TProtocol* iprot) {
9153
9154 uint32_t xfer = 0;
9155 std::string fname;
9156 ::apache::thrift::protocol::TType ftype;
9157 int16_t fid;
9158
9159 xfer += iprot->readStructBegin(fname);
9160
9161 using ::apache::thrift::protocol::TProtocolException;
9162
9163
9164 while (true)
9165 {
9166 xfer += iprot->readFieldBegin(fname, ftype, fid);
9167 if (ftype == ::apache::thrift::protocol::T_STOP) {
9168 break;
9169 }
9170 switch (fid)
9171 {
9172 case 0:
9173 if (ftype == ::apache::thrift::protocol::T_I32) {
9174 xfer += iprot->readI32(this->success);
9175 this->__isset.success = true;
9176 } else {
9177 xfer += iprot->skip(ftype);
9178 }
9179 break;
9180 case 1:
9181 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
9182 xfer += this->io.read(iprot);
9183 this->__isset.io = true;
9184 } else {
9185 xfer += iprot->skip(ftype);
9186 }
9187 break;
9188 default:
9189 xfer += iprot->skip(ftype);
9190 break;
9191 }
9192 xfer += iprot->readFieldEnd();
9193 }
9194
9195 xfer += iprot->readStructEnd();
9196
9197 return xfer;
9198 }
9199
9200 uint32_t Hbase_scannerOpenWithPrefix_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
9201
9202 uint32_t xfer = 0;
9203
9204 xfer += oprot->writeStructBegin("Hbase_scannerOpenWithPrefix_result");
9205
9206 if (this->__isset.success) {
9207 xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_I32, 0);
9208 xfer += oprot->writeI32(this->success);
9209 xfer += oprot->writeFieldEnd();
9210 } else if (this->__isset.io) {
9211 xfer += oprot->writeFieldBegin("io", ::apache::thrift::protocol::T_STRUCT, 1);
9212 xfer += this->io.write(oprot);
9213 xfer += oprot->writeFieldEnd();
9214 }
9215 xfer += oprot->writeFieldStop();
9216 xfer += oprot->writeStructEnd();
9217 return xfer;
9218 }
9219
9220 uint32_t Hbase_scannerOpenWithPrefix_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
9221
9222 uint32_t xfer = 0;
9223 std::string fname;
9224 ::apache::thrift::protocol::TType ftype;
9225 int16_t fid;
9226
9227 xfer += iprot->readStructBegin(fname);
9228
9229 using ::apache::thrift::protocol::TProtocolException;
9230
9231
9232 while (true)
9233 {
9234 xfer += iprot->readFieldBegin(fname, ftype, fid);
9235 if (ftype == ::apache::thrift::protocol::T_STOP) {
9236 break;
9237 }
9238 switch (fid)
9239 {
9240 case 0:
9241 if (ftype == ::apache::thrift::protocol::T_I32) {
9242 xfer += iprot->readI32((*(this->success)));
9243 this->__isset.success = true;
9244 } else {
9245 xfer += iprot->skip(ftype);
9246 }
9247 break;
9248 case 1:
9249 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
9250 xfer += this->io.read(iprot);
9251 this->__isset.io = true;
9252 } else {
9253 xfer += iprot->skip(ftype);
9254 }
9255 break;
9256 default:
9257 xfer += iprot->skip(ftype);
9258 break;
9259 }
9260 xfer += iprot->readFieldEnd();
9261 }
9262
9263 xfer += iprot->readStructEnd();
9264
9265 return xfer;
9266 }
9267
9268 uint32_t Hbase_scannerOpenTs_args::read(::apache::thrift::protocol::TProtocol* iprot) {
9269
9270 uint32_t xfer = 0;
9271 std::string fname;
9272 ::apache::thrift::protocol::TType ftype;
9273 int16_t fid;
9274
9275 xfer += iprot->readStructBegin(fname);
9276
9277 using ::apache::thrift::protocol::TProtocolException;
9278
9279
9280 while (true)
9281 {
9282 xfer += iprot->readFieldBegin(fname, ftype, fid);
9283 if (ftype == ::apache::thrift::protocol::T_STOP) {
9284 break;
9285 }
9286 switch (fid)
9287 {
9288 case 1:
9289 if (ftype == ::apache::thrift::protocol::T_STRING) {
9290 xfer += iprot->readBinary(this->tableName);
9291 this->__isset.tableName = true;
9292 } else {
9293 xfer += iprot->skip(ftype);
9294 }
9295 break;
9296 case 2:
9297 if (ftype == ::apache::thrift::protocol::T_STRING) {
9298 xfer += iprot->readBinary(this->startRow);
9299 this->__isset.startRow = true;
9300 } else {
9301 xfer += iprot->skip(ftype);
9302 }
9303 break;
9304 case 3:
9305 if (ftype == ::apache::thrift::protocol::T_LIST) {
9306 {
9307 this->columns.clear();
9308 uint32_t _size504;
9309 ::apache::thrift::protocol::TType _etype507;
9310 xfer += iprot->readListBegin(_etype507, _size504);
9311 this->columns.resize(_size504);
9312 uint32_t _i508;
9313 for (_i508 = 0; _i508 < _size504; ++_i508)
9314 {
9315 xfer += iprot->readBinary(this->columns[_i508]);
9316 }
9317 xfer += iprot->readListEnd();
9318 }
9319 this->__isset.columns = true;
9320 } else {
9321 xfer += iprot->skip(ftype);
9322 }
9323 break;
9324 case 4:
9325 if (ftype == ::apache::thrift::protocol::T_I64) {
9326 xfer += iprot->readI64(this->timestamp);
9327 this->__isset.timestamp = true;
9328 } else {
9329 xfer += iprot->skip(ftype);
9330 }
9331 break;
9332 case 5:
9333 if (ftype == ::apache::thrift::protocol::T_MAP) {
9334 {
9335 this->attributes.clear();
9336 uint32_t _size509;
9337 ::apache::thrift::protocol::TType _ktype510;
9338 ::apache::thrift::protocol::TType _vtype511;
9339 xfer += iprot->readMapBegin(_ktype510, _vtype511, _size509);
9340 uint32_t _i513;
9341 for (_i513 = 0; _i513 < _size509; ++_i513)
9342 {
9343 Text _key514;
9344 xfer += iprot->readBinary(_key514);
9345 Text& _val515 = this->attributes[_key514];
9346 xfer += iprot->readBinary(_val515);
9347 }
9348 xfer += iprot->readMapEnd();
9349 }
9350 this->__isset.attributes = true;
9351 } else {
9352 xfer += iprot->skip(ftype);
9353 }
9354 break;
9355 default:
9356 xfer += iprot->skip(ftype);
9357 break;
9358 }
9359 xfer += iprot->readFieldEnd();
9360 }
9361
9362 xfer += iprot->readStructEnd();
9363
9364 return xfer;
9365 }
9366
9367 uint32_t Hbase_scannerOpenTs_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
9368 uint32_t xfer = 0;
9369 xfer += oprot->writeStructBegin("Hbase_scannerOpenTs_args");
9370
9371 xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
9372 xfer += oprot->writeBinary(this->tableName);
9373 xfer += oprot->writeFieldEnd();
9374
9375 xfer += oprot->writeFieldBegin("startRow", ::apache::thrift::protocol::T_STRING, 2);
9376 xfer += oprot->writeBinary(this->startRow);
9377 xfer += oprot->writeFieldEnd();
9378
9379 xfer += oprot->writeFieldBegin("columns", ::apache::thrift::protocol::T_LIST, 3);
9380 {
9381 xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->columns.size()));
9382 std::vector<Text> ::const_iterator _iter516;
9383 for (_iter516 = this->columns.begin(); _iter516 != this->columns.end(); ++_iter516)
9384 {
9385 xfer += oprot->writeBinary((*_iter516));
9386 }
9387 xfer += oprot->writeListEnd();
9388 }
9389 xfer += oprot->writeFieldEnd();
9390
9391 xfer += oprot->writeFieldBegin("timestamp", ::apache::thrift::protocol::T_I64, 4);
9392 xfer += oprot->writeI64(this->timestamp);
9393 xfer += oprot->writeFieldEnd();
9394
9395 xfer += oprot->writeFieldBegin("attributes", ::apache::thrift::protocol::T_MAP, 5);
9396 {
9397 xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->attributes.size()));
9398 std::map<Text, Text> ::const_iterator _iter517;
9399 for (_iter517 = this->attributes.begin(); _iter517 != this->attributes.end(); ++_iter517)
9400 {
9401 xfer += oprot->writeBinary(_iter517->first);
9402 xfer += oprot->writeBinary(_iter517->second);
9403 }
9404 xfer += oprot->writeMapEnd();
9405 }
9406 xfer += oprot->writeFieldEnd();
9407
9408 xfer += oprot->writeFieldStop();
9409 xfer += oprot->writeStructEnd();
9410 return xfer;
9411 }
9412
9413 uint32_t Hbase_scannerOpenTs_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
9414 uint32_t xfer = 0;
9415 xfer += oprot->writeStructBegin("Hbase_scannerOpenTs_pargs");
9416
9417 xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
9418 xfer += oprot->writeBinary((*(this->tableName)));
9419 xfer += oprot->writeFieldEnd();
9420
9421 xfer += oprot->writeFieldBegin("startRow", ::apache::thrift::protocol::T_STRING, 2);
9422 xfer += oprot->writeBinary((*(this->startRow)));
9423 xfer += oprot->writeFieldEnd();
9424
9425 xfer += oprot->writeFieldBegin("columns", ::apache::thrift::protocol::T_LIST, 3);
9426 {
9427 xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->columns)).size()));
9428 std::vector<Text> ::const_iterator _iter518;
9429 for (_iter518 = (*(this->columns)).begin(); _iter518 != (*(this->columns)).end(); ++_iter518)
9430 {
9431 xfer += oprot->writeBinary((*_iter518));
9432 }
9433 xfer += oprot->writeListEnd();
9434 }
9435 xfer += oprot->writeFieldEnd();
9436
9437 xfer += oprot->writeFieldBegin("timestamp", ::apache::thrift::protocol::T_I64, 4);
9438 xfer += oprot->writeI64((*(this->timestamp)));
9439 xfer += oprot->writeFieldEnd();
9440
9441 xfer += oprot->writeFieldBegin("attributes", ::apache::thrift::protocol::T_MAP, 5);
9442 {
9443 xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->attributes)).size()));
9444 std::map<Text, Text> ::const_iterator _iter519;
9445 for (_iter519 = (*(this->attributes)).begin(); _iter519 != (*(this->attributes)).end(); ++_iter519)
9446 {
9447 xfer += oprot->writeBinary(_iter519->first);
9448 xfer += oprot->writeBinary(_iter519->second);
9449 }
9450 xfer += oprot->writeMapEnd();
9451 }
9452 xfer += oprot->writeFieldEnd();
9453
9454 xfer += oprot->writeFieldStop();
9455 xfer += oprot->writeStructEnd();
9456 return xfer;
9457 }
9458
9459 uint32_t Hbase_scannerOpenTs_result::read(::apache::thrift::protocol::TProtocol* iprot) {
9460
9461 uint32_t xfer = 0;
9462 std::string fname;
9463 ::apache::thrift::protocol::TType ftype;
9464 int16_t fid;
9465
9466 xfer += iprot->readStructBegin(fname);
9467
9468 using ::apache::thrift::protocol::TProtocolException;
9469
9470
9471 while (true)
9472 {
9473 xfer += iprot->readFieldBegin(fname, ftype, fid);
9474 if (ftype == ::apache::thrift::protocol::T_STOP) {
9475 break;
9476 }
9477 switch (fid)
9478 {
9479 case 0:
9480 if (ftype == ::apache::thrift::protocol::T_I32) {
9481 xfer += iprot->readI32(this->success);
9482 this->__isset.success = true;
9483 } else {
9484 xfer += iprot->skip(ftype);
9485 }
9486 break;
9487 case 1:
9488 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
9489 xfer += this->io.read(iprot);
9490 this->__isset.io = true;
9491 } else {
9492 xfer += iprot->skip(ftype);
9493 }
9494 break;
9495 default:
9496 xfer += iprot->skip(ftype);
9497 break;
9498 }
9499 xfer += iprot->readFieldEnd();
9500 }
9501
9502 xfer += iprot->readStructEnd();
9503
9504 return xfer;
9505 }
9506
9507 uint32_t Hbase_scannerOpenTs_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
9508
9509 uint32_t xfer = 0;
9510
9511 xfer += oprot->writeStructBegin("Hbase_scannerOpenTs_result");
9512
9513 if (this->__isset.success) {
9514 xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_I32, 0);
9515 xfer += oprot->writeI32(this->success);
9516 xfer += oprot->writeFieldEnd();
9517 } else if (this->__isset.io) {
9518 xfer += oprot->writeFieldBegin("io", ::apache::thrift::protocol::T_STRUCT, 1);
9519 xfer += this->io.write(oprot);
9520 xfer += oprot->writeFieldEnd();
9521 }
9522 xfer += oprot->writeFieldStop();
9523 xfer += oprot->writeStructEnd();
9524 return xfer;
9525 }
9526
9527 uint32_t Hbase_scannerOpenTs_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
9528
9529 uint32_t xfer = 0;
9530 std::string fname;
9531 ::apache::thrift::protocol::TType ftype;
9532 int16_t fid;
9533
9534 xfer += iprot->readStructBegin(fname);
9535
9536 using ::apache::thrift::protocol::TProtocolException;
9537
9538
9539 while (true)
9540 {
9541 xfer += iprot->readFieldBegin(fname, ftype, fid);
9542 if (ftype == ::apache::thrift::protocol::T_STOP) {
9543 break;
9544 }
9545 switch (fid)
9546 {
9547 case 0:
9548 if (ftype == ::apache::thrift::protocol::T_I32) {
9549 xfer += iprot->readI32((*(this->success)));
9550 this->__isset.success = true;
9551 } else {
9552 xfer += iprot->skip(ftype);
9553 }
9554 break;
9555 case 1:
9556 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
9557 xfer += this->io.read(iprot);
9558 this->__isset.io = true;
9559 } else {
9560 xfer += iprot->skip(ftype);
9561 }
9562 break;
9563 default:
9564 xfer += iprot->skip(ftype);
9565 break;
9566 }
9567 xfer += iprot->readFieldEnd();
9568 }
9569
9570 xfer += iprot->readStructEnd();
9571
9572 return xfer;
9573 }
9574
9575 uint32_t Hbase_scannerOpenWithStopTs_args::read(::apache::thrift::protocol::TProtocol* iprot) {
9576
9577 uint32_t xfer = 0;
9578 std::string fname;
9579 ::apache::thrift::protocol::TType ftype;
9580 int16_t fid;
9581
9582 xfer += iprot->readStructBegin(fname);
9583
9584 using ::apache::thrift::protocol::TProtocolException;
9585
9586
9587 while (true)
9588 {
9589 xfer += iprot->readFieldBegin(fname, ftype, fid);
9590 if (ftype == ::apache::thrift::protocol::T_STOP) {
9591 break;
9592 }
9593 switch (fid)
9594 {
9595 case 1:
9596 if (ftype == ::apache::thrift::protocol::T_STRING) {
9597 xfer += iprot->readBinary(this->tableName);
9598 this->__isset.tableName = true;
9599 } else {
9600 xfer += iprot->skip(ftype);
9601 }
9602 break;
9603 case 2:
9604 if (ftype == ::apache::thrift::protocol::T_STRING) {
9605 xfer += iprot->readBinary(this->startRow);
9606 this->__isset.startRow = true;
9607 } else {
9608 xfer += iprot->skip(ftype);
9609 }
9610 break;
9611 case 3:
9612 if (ftype == ::apache::thrift::protocol::T_STRING) {
9613 xfer += iprot->readBinary(this->stopRow);
9614 this->__isset.stopRow = true;
9615 } else {
9616 xfer += iprot->skip(ftype);
9617 }
9618 break;
9619 case 4:
9620 if (ftype == ::apache::thrift::protocol::T_LIST) {
9621 {
9622 this->columns.clear();
9623 uint32_t _size520;
9624 ::apache::thrift::protocol::TType _etype523;
9625 xfer += iprot->readListBegin(_etype523, _size520);
9626 this->columns.resize(_size520);
9627 uint32_t _i524;
9628 for (_i524 = 0; _i524 < _size520; ++_i524)
9629 {
9630 xfer += iprot->readBinary(this->columns[_i524]);
9631 }
9632 xfer += iprot->readListEnd();
9633 }
9634 this->__isset.columns = true;
9635 } else {
9636 xfer += iprot->skip(ftype);
9637 }
9638 break;
9639 case 5:
9640 if (ftype == ::apache::thrift::protocol::T_I64) {
9641 xfer += iprot->readI64(this->timestamp);
9642 this->__isset.timestamp = true;
9643 } else {
9644 xfer += iprot->skip(ftype);
9645 }
9646 break;
9647 case 6:
9648 if (ftype == ::apache::thrift::protocol::T_MAP) {
9649 {
9650 this->attributes.clear();
9651 uint32_t _size525;
9652 ::apache::thrift::protocol::TType _ktype526;
9653 ::apache::thrift::protocol::TType _vtype527;
9654 xfer += iprot->readMapBegin(_ktype526, _vtype527, _size525);
9655 uint32_t _i529;
9656 for (_i529 = 0; _i529 < _size525; ++_i529)
9657 {
9658 Text _key530;
9659 xfer += iprot->readBinary(_key530);
9660 Text& _val531 = this->attributes[_key530];
9661 xfer += iprot->readBinary(_val531);
9662 }
9663 xfer += iprot->readMapEnd();
9664 }
9665 this->__isset.attributes = true;
9666 } else {
9667 xfer += iprot->skip(ftype);
9668 }
9669 break;
9670 default:
9671 xfer += iprot->skip(ftype);
9672 break;
9673 }
9674 xfer += iprot->readFieldEnd();
9675 }
9676
9677 xfer += iprot->readStructEnd();
9678
9679 return xfer;
9680 }
9681
9682 uint32_t Hbase_scannerOpenWithStopTs_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
9683 uint32_t xfer = 0;
9684 xfer += oprot->writeStructBegin("Hbase_scannerOpenWithStopTs_args");
9685
9686 xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
9687 xfer += oprot->writeBinary(this->tableName);
9688 xfer += oprot->writeFieldEnd();
9689
9690 xfer += oprot->writeFieldBegin("startRow", ::apache::thrift::protocol::T_STRING, 2);
9691 xfer += oprot->writeBinary(this->startRow);
9692 xfer += oprot->writeFieldEnd();
9693
9694 xfer += oprot->writeFieldBegin("stopRow", ::apache::thrift::protocol::T_STRING, 3);
9695 xfer += oprot->writeBinary(this->stopRow);
9696 xfer += oprot->writeFieldEnd();
9697
9698 xfer += oprot->writeFieldBegin("columns", ::apache::thrift::protocol::T_LIST, 4);
9699 {
9700 xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->columns.size()));
9701 std::vector<Text> ::const_iterator _iter532;
9702 for (_iter532 = this->columns.begin(); _iter532 != this->columns.end(); ++_iter532)
9703 {
9704 xfer += oprot->writeBinary((*_iter532));
9705 }
9706 xfer += oprot->writeListEnd();
9707 }
9708 xfer += oprot->writeFieldEnd();
9709
9710 xfer += oprot->writeFieldBegin("timestamp", ::apache::thrift::protocol::T_I64, 5);
9711 xfer += oprot->writeI64(this->timestamp);
9712 xfer += oprot->writeFieldEnd();
9713
9714 xfer += oprot->writeFieldBegin("attributes", ::apache::thrift::protocol::T_MAP, 6);
9715 {
9716 xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->attributes.size()));
9717 std::map<Text, Text> ::const_iterator _iter533;
9718 for (_iter533 = this->attributes.begin(); _iter533 != this->attributes.end(); ++_iter533)
9719 {
9720 xfer += oprot->writeBinary(_iter533->first);
9721 xfer += oprot->writeBinary(_iter533->second);
9722 }
9723 xfer += oprot->writeMapEnd();
9724 }
9725 xfer += oprot->writeFieldEnd();
9726
9727 xfer += oprot->writeFieldStop();
9728 xfer += oprot->writeStructEnd();
9729 return xfer;
9730 }
9731
9732 uint32_t Hbase_scannerOpenWithStopTs_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
9733 uint32_t xfer = 0;
9734 xfer += oprot->writeStructBegin("Hbase_scannerOpenWithStopTs_pargs");
9735
9736 xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
9737 xfer += oprot->writeBinary((*(this->tableName)));
9738 xfer += oprot->writeFieldEnd();
9739
9740 xfer += oprot->writeFieldBegin("startRow", ::apache::thrift::protocol::T_STRING, 2);
9741 xfer += oprot->writeBinary((*(this->startRow)));
9742 xfer += oprot->writeFieldEnd();
9743
9744 xfer += oprot->writeFieldBegin("stopRow", ::apache::thrift::protocol::T_STRING, 3);
9745 xfer += oprot->writeBinary((*(this->stopRow)));
9746 xfer += oprot->writeFieldEnd();
9747
9748 xfer += oprot->writeFieldBegin("columns", ::apache::thrift::protocol::T_LIST, 4);
9749 {
9750 xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->columns)).size()));
9751 std::vector<Text> ::const_iterator _iter534;
9752 for (_iter534 = (*(this->columns)).begin(); _iter534 != (*(this->columns)).end(); ++_iter534)
9753 {
9754 xfer += oprot->writeBinary((*_iter534));
9755 }
9756 xfer += oprot->writeListEnd();
9757 }
9758 xfer += oprot->writeFieldEnd();
9759
9760 xfer += oprot->writeFieldBegin("timestamp", ::apache::thrift::protocol::T_I64, 5);
9761 xfer += oprot->writeI64((*(this->timestamp)));
9762 xfer += oprot->writeFieldEnd();
9763
9764 xfer += oprot->writeFieldBegin("attributes", ::apache::thrift::protocol::T_MAP, 6);
9765 {
9766 xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->attributes)).size()));
9767 std::map<Text, Text> ::const_iterator _iter535;
9768 for (_iter535 = (*(this->attributes)).begin(); _iter535 != (*(this->attributes)).end(); ++_iter535)
9769 {
9770 xfer += oprot->writeBinary(_iter535->first);
9771 xfer += oprot->writeBinary(_iter535->second);
9772 }
9773 xfer += oprot->writeMapEnd();
9774 }
9775 xfer += oprot->writeFieldEnd();
9776
9777 xfer += oprot->writeFieldStop();
9778 xfer += oprot->writeStructEnd();
9779 return xfer;
9780 }
9781
9782 uint32_t Hbase_scannerOpenWithStopTs_result::read(::apache::thrift::protocol::TProtocol* iprot) {
9783
9784 uint32_t xfer = 0;
9785 std::string fname;
9786 ::apache::thrift::protocol::TType ftype;
9787 int16_t fid;
9788
9789 xfer += iprot->readStructBegin(fname);
9790
9791 using ::apache::thrift::protocol::TProtocolException;
9792
9793
9794 while (true)
9795 {
9796 xfer += iprot->readFieldBegin(fname, ftype, fid);
9797 if (ftype == ::apache::thrift::protocol::T_STOP) {
9798 break;
9799 }
9800 switch (fid)
9801 {
9802 case 0:
9803 if (ftype == ::apache::thrift::protocol::T_I32) {
9804 xfer += iprot->readI32(this->success);
9805 this->__isset.success = true;
9806 } else {
9807 xfer += iprot->skip(ftype);
9808 }
9809 break;
9810 case 1:
9811 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
9812 xfer += this->io.read(iprot);
9813 this->__isset.io = true;
9814 } else {
9815 xfer += iprot->skip(ftype);
9816 }
9817 break;
9818 default:
9819 xfer += iprot->skip(ftype);
9820 break;
9821 }
9822 xfer += iprot->readFieldEnd();
9823 }
9824
9825 xfer += iprot->readStructEnd();
9826
9827 return xfer;
9828 }
9829
9830 uint32_t Hbase_scannerOpenWithStopTs_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
9831
9832 uint32_t xfer = 0;
9833
9834 xfer += oprot->writeStructBegin("Hbase_scannerOpenWithStopTs_result");
9835
9836 if (this->__isset.success) {
9837 xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_I32, 0);
9838 xfer += oprot->writeI32(this->success);
9839 xfer += oprot->writeFieldEnd();
9840 } else if (this->__isset.io) {
9841 xfer += oprot->writeFieldBegin("io", ::apache::thrift::protocol::T_STRUCT, 1);
9842 xfer += this->io.write(oprot);
9843 xfer += oprot->writeFieldEnd();
9844 }
9845 xfer += oprot->writeFieldStop();
9846 xfer += oprot->writeStructEnd();
9847 return xfer;
9848 }
9849
9850 uint32_t Hbase_scannerOpenWithStopTs_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
9851
9852 uint32_t xfer = 0;
9853 std::string fname;
9854 ::apache::thrift::protocol::TType ftype;
9855 int16_t fid;
9856
9857 xfer += iprot->readStructBegin(fname);
9858
9859 using ::apache::thrift::protocol::TProtocolException;
9860
9861
9862 while (true)
9863 {
9864 xfer += iprot->readFieldBegin(fname, ftype, fid);
9865 if (ftype == ::apache::thrift::protocol::T_STOP) {
9866 break;
9867 }
9868 switch (fid)
9869 {
9870 case 0:
9871 if (ftype == ::apache::thrift::protocol::T_I32) {
9872 xfer += iprot->readI32((*(this->success)));
9873 this->__isset.success = true;
9874 } else {
9875 xfer += iprot->skip(ftype);
9876 }
9877 break;
9878 case 1:
9879 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
9880 xfer += this->io.read(iprot);
9881 this->__isset.io = true;
9882 } else {
9883 xfer += iprot->skip(ftype);
9884 }
9885 break;
9886 default:
9887 xfer += iprot->skip(ftype);
9888 break;
9889 }
9890 xfer += iprot->readFieldEnd();
9891 }
9892
9893 xfer += iprot->readStructEnd();
9894
9895 return xfer;
9896 }
9897
9898 uint32_t Hbase_scannerGet_args::read(::apache::thrift::protocol::TProtocol* iprot) {
9899
9900 uint32_t xfer = 0;
9901 std::string fname;
9902 ::apache::thrift::protocol::TType ftype;
9903 int16_t fid;
9904
9905 xfer += iprot->readStructBegin(fname);
9906
9907 using ::apache::thrift::protocol::TProtocolException;
9908
9909
9910 while (true)
9911 {
9912 xfer += iprot->readFieldBegin(fname, ftype, fid);
9913 if (ftype == ::apache::thrift::protocol::T_STOP) {
9914 break;
9915 }
9916 switch (fid)
9917 {
9918 case 1:
9919 if (ftype == ::apache::thrift::protocol::T_I32) {
9920 xfer += iprot->readI32(this->id);
9921 this->__isset.id = true;
9922 } else {
9923 xfer += iprot->skip(ftype);
9924 }
9925 break;
9926 default:
9927 xfer += iprot->skip(ftype);
9928 break;
9929 }
9930 xfer += iprot->readFieldEnd();
9931 }
9932
9933 xfer += iprot->readStructEnd();
9934
9935 return xfer;
9936 }
9937
9938 uint32_t Hbase_scannerGet_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
9939 uint32_t xfer = 0;
9940 xfer += oprot->writeStructBegin("Hbase_scannerGet_args");
9941
9942 xfer += oprot->writeFieldBegin("id", ::apache::thrift::protocol::T_I32, 1);
9943 xfer += oprot->writeI32(this->id);
9944 xfer += oprot->writeFieldEnd();
9945
9946 xfer += oprot->writeFieldStop();
9947 xfer += oprot->writeStructEnd();
9948 return xfer;
9949 }
9950
9951 uint32_t Hbase_scannerGet_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
9952 uint32_t xfer = 0;
9953 xfer += oprot->writeStructBegin("Hbase_scannerGet_pargs");
9954
9955 xfer += oprot->writeFieldBegin("id", ::apache::thrift::protocol::T_I32, 1);
9956 xfer += oprot->writeI32((*(this->id)));
9957 xfer += oprot->writeFieldEnd();
9958
9959 xfer += oprot->writeFieldStop();
9960 xfer += oprot->writeStructEnd();
9961 return xfer;
9962 }
9963
9964 uint32_t Hbase_scannerGet_result::read(::apache::thrift::protocol::TProtocol* iprot) {
9965
9966 uint32_t xfer = 0;
9967 std::string fname;
9968 ::apache::thrift::protocol::TType ftype;
9969 int16_t fid;
9970
9971 xfer += iprot->readStructBegin(fname);
9972
9973 using ::apache::thrift::protocol::TProtocolException;
9974
9975
9976 while (true)
9977 {
9978 xfer += iprot->readFieldBegin(fname, ftype, fid);
9979 if (ftype == ::apache::thrift::protocol::T_STOP) {
9980 break;
9981 }
9982 switch (fid)
9983 {
9984 case 0:
9985 if (ftype == ::apache::thrift::protocol::T_LIST) {
9986 {
9987 this->success.clear();
9988 uint32_t _size536;
9989 ::apache::thrift::protocol::TType _etype539;
9990 xfer += iprot->readListBegin(_etype539, _size536);
9991 this->success.resize(_size536);
9992 uint32_t _i540;
9993 for (_i540 = 0; _i540 < _size536; ++_i540)
9994 {
9995 xfer += this->success[_i540].read(iprot);
9996 }
9997 xfer += iprot->readListEnd();
9998 }
9999 this->__isset.success = true;
10000 } else {
10001 xfer += iprot->skip(ftype);
10002 }
10003 break;
10004 case 1:
10005 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
10006 xfer += this->io.read(iprot);
10007 this->__isset.io = true;
10008 } else {
10009 xfer += iprot->skip(ftype);
10010 }
10011 break;
10012 case 2:
10013 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
10014 xfer += this->ia.read(iprot);
10015 this->__isset.ia = true;
10016 } else {
10017 xfer += iprot->skip(ftype);
10018 }
10019 break;
10020 default:
10021 xfer += iprot->skip(ftype);
10022 break;
10023 }
10024 xfer += iprot->readFieldEnd();
10025 }
10026
10027 xfer += iprot->readStructEnd();
10028
10029 return xfer;
10030 }
10031
10032 uint32_t Hbase_scannerGet_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
10033
10034 uint32_t xfer = 0;
10035
10036 xfer += oprot->writeStructBegin("Hbase_scannerGet_result");
10037
10038 if (this->__isset.success) {
10039 xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0);
10040 {
10041 xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->success.size()));
10042 std::vector<TRowResult> ::const_iterator _iter541;
10043 for (_iter541 = this->success.begin(); _iter541 != this->success.end(); ++_iter541)
10044 {
10045 xfer += (*_iter541).write(oprot);
10046 }
10047 xfer += oprot->writeListEnd();
10048 }
10049 xfer += oprot->writeFieldEnd();
10050 } else if (this->__isset.io) {
10051 xfer += oprot->writeFieldBegin("io", ::apache::thrift::protocol::T_STRUCT, 1);
10052 xfer += this->io.write(oprot);
10053 xfer += oprot->writeFieldEnd();
10054 } else if (this->__isset.ia) {
10055 xfer += oprot->writeFieldBegin("ia", ::apache::thrift::protocol::T_STRUCT, 2);
10056 xfer += this->ia.write(oprot);
10057 xfer += oprot->writeFieldEnd();
10058 }
10059 xfer += oprot->writeFieldStop();
10060 xfer += oprot->writeStructEnd();
10061 return xfer;
10062 }
10063
10064 uint32_t Hbase_scannerGet_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
10065
10066 uint32_t xfer = 0;
10067 std::string fname;
10068 ::apache::thrift::protocol::TType ftype;
10069 int16_t fid;
10070
10071 xfer += iprot->readStructBegin(fname);
10072
10073 using ::apache::thrift::protocol::TProtocolException;
10074
10075
10076 while (true)
10077 {
10078 xfer += iprot->readFieldBegin(fname, ftype, fid);
10079 if (ftype == ::apache::thrift::protocol::T_STOP) {
10080 break;
10081 }
10082 switch (fid)
10083 {
10084 case 0:
10085 if (ftype == ::apache::thrift::protocol::T_LIST) {
10086 {
10087 (*(this->success)).clear();
10088 uint32_t _size542;
10089 ::apache::thrift::protocol::TType _etype545;
10090 xfer += iprot->readListBegin(_etype545, _size542);
10091 (*(this->success)).resize(_size542);
10092 uint32_t _i546;
10093 for (_i546 = 0; _i546 < _size542; ++_i546)
10094 {
10095 xfer += (*(this->success))[_i546].read(iprot);
10096 }
10097 xfer += iprot->readListEnd();
10098 }
10099 this->__isset.success = true;
10100 } else {
10101 xfer += iprot->skip(ftype);
10102 }
10103 break;
10104 case 1:
10105 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
10106 xfer += this->io.read(iprot);
10107 this->__isset.io = true;
10108 } else {
10109 xfer += iprot->skip(ftype);
10110 }
10111 break;
10112 case 2:
10113 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
10114 xfer += this->ia.read(iprot);
10115 this->__isset.ia = true;
10116 } else {
10117 xfer += iprot->skip(ftype);
10118 }
10119 break;
10120 default:
10121 xfer += iprot->skip(ftype);
10122 break;
10123 }
10124 xfer += iprot->readFieldEnd();
10125 }
10126
10127 xfer += iprot->readStructEnd();
10128
10129 return xfer;
10130 }
10131
10132 uint32_t Hbase_scannerGetList_args::read(::apache::thrift::protocol::TProtocol* iprot) {
10133
10134 uint32_t xfer = 0;
10135 std::string fname;
10136 ::apache::thrift::protocol::TType ftype;
10137 int16_t fid;
10138
10139 xfer += iprot->readStructBegin(fname);
10140
10141 using ::apache::thrift::protocol::TProtocolException;
10142
10143
10144 while (true)
10145 {
10146 xfer += iprot->readFieldBegin(fname, ftype, fid);
10147 if (ftype == ::apache::thrift::protocol::T_STOP) {
10148 break;
10149 }
10150 switch (fid)
10151 {
10152 case 1:
10153 if (ftype == ::apache::thrift::protocol::T_I32) {
10154 xfer += iprot->readI32(this->id);
10155 this->__isset.id = true;
10156 } else {
10157 xfer += iprot->skip(ftype);
10158 }
10159 break;
10160 case 2:
10161 if (ftype == ::apache::thrift::protocol::T_I32) {
10162 xfer += iprot->readI32(this->nbRows);
10163 this->__isset.nbRows = true;
10164 } else {
10165 xfer += iprot->skip(ftype);
10166 }
10167 break;
10168 default:
10169 xfer += iprot->skip(ftype);
10170 break;
10171 }
10172 xfer += iprot->readFieldEnd();
10173 }
10174
10175 xfer += iprot->readStructEnd();
10176
10177 return xfer;
10178 }
10179
10180 uint32_t Hbase_scannerGetList_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
10181 uint32_t xfer = 0;
10182 xfer += oprot->writeStructBegin("Hbase_scannerGetList_args");
10183
10184 xfer += oprot->writeFieldBegin("id", ::apache::thrift::protocol::T_I32, 1);
10185 xfer += oprot->writeI32(this->id);
10186 xfer += oprot->writeFieldEnd();
10187
10188 xfer += oprot->writeFieldBegin("nbRows", ::apache::thrift::protocol::T_I32, 2);
10189 xfer += oprot->writeI32(this->nbRows);
10190 xfer += oprot->writeFieldEnd();
10191
10192 xfer += oprot->writeFieldStop();
10193 xfer += oprot->writeStructEnd();
10194 return xfer;
10195 }
10196
10197 uint32_t Hbase_scannerGetList_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
10198 uint32_t xfer = 0;
10199 xfer += oprot->writeStructBegin("Hbase_scannerGetList_pargs");
10200
10201 xfer += oprot->writeFieldBegin("id", ::apache::thrift::protocol::T_I32, 1);
10202 xfer += oprot->writeI32((*(this->id)));
10203 xfer += oprot->writeFieldEnd();
10204
10205 xfer += oprot->writeFieldBegin("nbRows", ::apache::thrift::protocol::T_I32, 2);
10206 xfer += oprot->writeI32((*(this->nbRows)));
10207 xfer += oprot->writeFieldEnd();
10208
10209 xfer += oprot->writeFieldStop();
10210 xfer += oprot->writeStructEnd();
10211 return xfer;
10212 }
10213
10214 uint32_t Hbase_scannerGetList_result::read(::apache::thrift::protocol::TProtocol* iprot) {
10215
10216 uint32_t xfer = 0;
10217 std::string fname;
10218 ::apache::thrift::protocol::TType ftype;
10219 int16_t fid;
10220
10221 xfer += iprot->readStructBegin(fname);
10222
10223 using ::apache::thrift::protocol::TProtocolException;
10224
10225
10226 while (true)
10227 {
10228 xfer += iprot->readFieldBegin(fname, ftype, fid);
10229 if (ftype == ::apache::thrift::protocol::T_STOP) {
10230 break;
10231 }
10232 switch (fid)
10233 {
10234 case 0:
10235 if (ftype == ::apache::thrift::protocol::T_LIST) {
10236 {
10237 this->success.clear();
10238 uint32_t _size547;
10239 ::apache::thrift::protocol::TType _etype550;
10240 xfer += iprot->readListBegin(_etype550, _size547);
10241 this->success.resize(_size547);
10242 uint32_t _i551;
10243 for (_i551 = 0; _i551 < _size547; ++_i551)
10244 {
10245 xfer += this->success[_i551].read(iprot);
10246 }
10247 xfer += iprot->readListEnd();
10248 }
10249 this->__isset.success = true;
10250 } else {
10251 xfer += iprot->skip(ftype);
10252 }
10253 break;
10254 case 1:
10255 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
10256 xfer += this->io.read(iprot);
10257 this->__isset.io = true;
10258 } else {
10259 xfer += iprot->skip(ftype);
10260 }
10261 break;
10262 case 2:
10263 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
10264 xfer += this->ia.read(iprot);
10265 this->__isset.ia = true;
10266 } else {
10267 xfer += iprot->skip(ftype);
10268 }
10269 break;
10270 default:
10271 xfer += iprot->skip(ftype);
10272 break;
10273 }
10274 xfer += iprot->readFieldEnd();
10275 }
10276
10277 xfer += iprot->readStructEnd();
10278
10279 return xfer;
10280 }
10281
10282 uint32_t Hbase_scannerGetList_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
10283
10284 uint32_t xfer = 0;
10285
10286 xfer += oprot->writeStructBegin("Hbase_scannerGetList_result");
10287
10288 if (this->__isset.success) {
10289 xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0);
10290 {
10291 xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->success.size()));
10292 std::vector<TRowResult> ::const_iterator _iter552;
10293 for (_iter552 = this->success.begin(); _iter552 != this->success.end(); ++_iter552)
10294 {
10295 xfer += (*_iter552).write(oprot);
10296 }
10297 xfer += oprot->writeListEnd();
10298 }
10299 xfer += oprot->writeFieldEnd();
10300 } else if (this->__isset.io) {
10301 xfer += oprot->writeFieldBegin("io", ::apache::thrift::protocol::T_STRUCT, 1);
10302 xfer += this->io.write(oprot);
10303 xfer += oprot->writeFieldEnd();
10304 } else if (this->__isset.ia) {
10305 xfer += oprot->writeFieldBegin("ia", ::apache::thrift::protocol::T_STRUCT, 2);
10306 xfer += this->ia.write(oprot);
10307 xfer += oprot->writeFieldEnd();
10308 }
10309 xfer += oprot->writeFieldStop();
10310 xfer += oprot->writeStructEnd();
10311 return xfer;
10312 }
10313
10314 uint32_t Hbase_scannerGetList_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
10315
10316 uint32_t xfer = 0;
10317 std::string fname;
10318 ::apache::thrift::protocol::TType ftype;
10319 int16_t fid;
10320
10321 xfer += iprot->readStructBegin(fname);
10322
10323 using ::apache::thrift::protocol::TProtocolException;
10324
10325
10326 while (true)
10327 {
10328 xfer += iprot->readFieldBegin(fname, ftype, fid);
10329 if (ftype == ::apache::thrift::protocol::T_STOP) {
10330 break;
10331 }
10332 switch (fid)
10333 {
10334 case 0:
10335 if (ftype == ::apache::thrift::protocol::T_LIST) {
10336 {
10337 (*(this->success)).clear();
10338 uint32_t _size553;
10339 ::apache::thrift::protocol::TType _etype556;
10340 xfer += iprot->readListBegin(_etype556, _size553);
10341 (*(this->success)).resize(_size553);
10342 uint32_t _i557;
10343 for (_i557 = 0; _i557 < _size553; ++_i557)
10344 {
10345 xfer += (*(this->success))[_i557].read(iprot);
10346 }
10347 xfer += iprot->readListEnd();
10348 }
10349 this->__isset.success = true;
10350 } else {
10351 xfer += iprot->skip(ftype);
10352 }
10353 break;
10354 case 1:
10355 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
10356 xfer += this->io.read(iprot);
10357 this->__isset.io = true;
10358 } else {
10359 xfer += iprot->skip(ftype);
10360 }
10361 break;
10362 case 2:
10363 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
10364 xfer += this->ia.read(iprot);
10365 this->__isset.ia = true;
10366 } else {
10367 xfer += iprot->skip(ftype);
10368 }
10369 break;
10370 default:
10371 xfer += iprot->skip(ftype);
10372 break;
10373 }
10374 xfer += iprot->readFieldEnd();
10375 }
10376
10377 xfer += iprot->readStructEnd();
10378
10379 return xfer;
10380 }
10381
10382 uint32_t Hbase_scannerClose_args::read(::apache::thrift::protocol::TProtocol* iprot) {
10383
10384 uint32_t xfer = 0;
10385 std::string fname;
10386 ::apache::thrift::protocol::TType ftype;
10387 int16_t fid;
10388
10389 xfer += iprot->readStructBegin(fname);
10390
10391 using ::apache::thrift::protocol::TProtocolException;
10392
10393
10394 while (true)
10395 {
10396 xfer += iprot->readFieldBegin(fname, ftype, fid);
10397 if (ftype == ::apache::thrift::protocol::T_STOP) {
10398 break;
10399 }
10400 switch (fid)
10401 {
10402 case 1:
10403 if (ftype == ::apache::thrift::protocol::T_I32) {
10404 xfer += iprot->readI32(this->id);
10405 this->__isset.id = true;
10406 } else {
10407 xfer += iprot->skip(ftype);
10408 }
10409 break;
10410 default:
10411 xfer += iprot->skip(ftype);
10412 break;
10413 }
10414 xfer += iprot->readFieldEnd();
10415 }
10416
10417 xfer += iprot->readStructEnd();
10418
10419 return xfer;
10420 }
10421
10422 uint32_t Hbase_scannerClose_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
10423 uint32_t xfer = 0;
10424 xfer += oprot->writeStructBegin("Hbase_scannerClose_args");
10425
10426 xfer += oprot->writeFieldBegin("id", ::apache::thrift::protocol::T_I32, 1);
10427 xfer += oprot->writeI32(this->id);
10428 xfer += oprot->writeFieldEnd();
10429
10430 xfer += oprot->writeFieldStop();
10431 xfer += oprot->writeStructEnd();
10432 return xfer;
10433 }
10434
10435 uint32_t Hbase_scannerClose_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
10436 uint32_t xfer = 0;
10437 xfer += oprot->writeStructBegin("Hbase_scannerClose_pargs");
10438
10439 xfer += oprot->writeFieldBegin("id", ::apache::thrift::protocol::T_I32, 1);
10440 xfer += oprot->writeI32((*(this->id)));
10441 xfer += oprot->writeFieldEnd();
10442
10443 xfer += oprot->writeFieldStop();
10444 xfer += oprot->writeStructEnd();
10445 return xfer;
10446 }
10447
10448 uint32_t Hbase_scannerClose_result::read(::apache::thrift::protocol::TProtocol* iprot) {
10449
10450 uint32_t xfer = 0;
10451 std::string fname;
10452 ::apache::thrift::protocol::TType ftype;
10453 int16_t fid;
10454
10455 xfer += iprot->readStructBegin(fname);
10456
10457 using ::apache::thrift::protocol::TProtocolException;
10458
10459
10460 while (true)
10461 {
10462 xfer += iprot->readFieldBegin(fname, ftype, fid);
10463 if (ftype == ::apache::thrift::protocol::T_STOP) {
10464 break;
10465 }
10466 switch (fid)
10467 {
10468 case 1:
10469 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
10470 xfer += this->io.read(iprot);
10471 this->__isset.io = true;
10472 } else {
10473 xfer += iprot->skip(ftype);
10474 }
10475 break;
10476 case 2:
10477 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
10478 xfer += this->ia.read(iprot);
10479 this->__isset.ia = true;
10480 } else {
10481 xfer += iprot->skip(ftype);
10482 }
10483 break;
10484 default:
10485 xfer += iprot->skip(ftype);
10486 break;
10487 }
10488 xfer += iprot->readFieldEnd();
10489 }
10490
10491 xfer += iprot->readStructEnd();
10492
10493 return xfer;
10494 }
10495
10496 uint32_t Hbase_scannerClose_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
10497
10498 uint32_t xfer = 0;
10499
10500 xfer += oprot->writeStructBegin("Hbase_scannerClose_result");
10501
10502 if (this->__isset.io) {
10503 xfer += oprot->writeFieldBegin("io", ::apache::thrift::protocol::T_STRUCT, 1);
10504 xfer += this->io.write(oprot);
10505 xfer += oprot->writeFieldEnd();
10506 } else if (this->__isset.ia) {
10507 xfer += oprot->writeFieldBegin("ia", ::apache::thrift::protocol::T_STRUCT, 2);
10508 xfer += this->ia.write(oprot);
10509 xfer += oprot->writeFieldEnd();
10510 }
10511 xfer += oprot->writeFieldStop();
10512 xfer += oprot->writeStructEnd();
10513 return xfer;
10514 }
10515
10516 uint32_t Hbase_scannerClose_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
10517
10518 uint32_t xfer = 0;
10519 std::string fname;
10520 ::apache::thrift::protocol::TType ftype;
10521 int16_t fid;
10522
10523 xfer += iprot->readStructBegin(fname);
10524
10525 using ::apache::thrift::protocol::TProtocolException;
10526
10527
10528 while (true)
10529 {
10530 xfer += iprot->readFieldBegin(fname, ftype, fid);
10531 if (ftype == ::apache::thrift::protocol::T_STOP) {
10532 break;
10533 }
10534 switch (fid)
10535 {
10536 case 1:
10537 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
10538 xfer += this->io.read(iprot);
10539 this->__isset.io = true;
10540 } else {
10541 xfer += iprot->skip(ftype);
10542 }
10543 break;
10544 case 2:
10545 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
10546 xfer += this->ia.read(iprot);
10547 this->__isset.ia = true;
10548 } else {
10549 xfer += iprot->skip(ftype);
10550 }
10551 break;
10552 default:
10553 xfer += iprot->skip(ftype);
10554 break;
10555 }
10556 xfer += iprot->readFieldEnd();
10557 }
10558
10559 xfer += iprot->readStructEnd();
10560
10561 return xfer;
10562 }
10563
10564 uint32_t Hbase_getRowOrBefore_args::read(::apache::thrift::protocol::TProtocol* iprot) {
10565
10566 uint32_t xfer = 0;
10567 std::string fname;
10568 ::apache::thrift::protocol::TType ftype;
10569 int16_t fid;
10570
10571 xfer += iprot->readStructBegin(fname);
10572
10573 using ::apache::thrift::protocol::TProtocolException;
10574
10575
10576 while (true)
10577 {
10578 xfer += iprot->readFieldBegin(fname, ftype, fid);
10579 if (ftype == ::apache::thrift::protocol::T_STOP) {
10580 break;
10581 }
10582 switch (fid)
10583 {
10584 case 1:
10585 if (ftype == ::apache::thrift::protocol::T_STRING) {
10586 xfer += iprot->readBinary(this->tableName);
10587 this->__isset.tableName = true;
10588 } else {
10589 xfer += iprot->skip(ftype);
10590 }
10591 break;
10592 case 2:
10593 if (ftype == ::apache::thrift::protocol::T_STRING) {
10594 xfer += iprot->readBinary(this->row);
10595 this->__isset.row = true;
10596 } else {
10597 xfer += iprot->skip(ftype);
10598 }
10599 break;
10600 case 3:
10601 if (ftype == ::apache::thrift::protocol::T_STRING) {
10602 xfer += iprot->readBinary(this->family);
10603 this->__isset.family = true;
10604 } else {
10605 xfer += iprot->skip(ftype);
10606 }
10607 break;
10608 default:
10609 xfer += iprot->skip(ftype);
10610 break;
10611 }
10612 xfer += iprot->readFieldEnd();
10613 }
10614
10615 xfer += iprot->readStructEnd();
10616
10617 return xfer;
10618 }
10619
10620 uint32_t Hbase_getRowOrBefore_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
10621 uint32_t xfer = 0;
10622 xfer += oprot->writeStructBegin("Hbase_getRowOrBefore_args");
10623
10624 xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
10625 xfer += oprot->writeBinary(this->tableName);
10626 xfer += oprot->writeFieldEnd();
10627
10628 xfer += oprot->writeFieldBegin("row", ::apache::thrift::protocol::T_STRING, 2);
10629 xfer += oprot->writeBinary(this->row);
10630 xfer += oprot->writeFieldEnd();
10631
10632 xfer += oprot->writeFieldBegin("family", ::apache::thrift::protocol::T_STRING, 3);
10633 xfer += oprot->writeBinary(this->family);
10634 xfer += oprot->writeFieldEnd();
10635
10636 xfer += oprot->writeFieldStop();
10637 xfer += oprot->writeStructEnd();
10638 return xfer;
10639 }
10640
10641 uint32_t Hbase_getRowOrBefore_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
10642 uint32_t xfer = 0;
10643 xfer += oprot->writeStructBegin("Hbase_getRowOrBefore_pargs");
10644
10645 xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
10646 xfer += oprot->writeBinary((*(this->tableName)));
10647 xfer += oprot->writeFieldEnd();
10648
10649 xfer += oprot->writeFieldBegin("row", ::apache::thrift::protocol::T_STRING, 2);
10650 xfer += oprot->writeBinary((*(this->row)));
10651 xfer += oprot->writeFieldEnd();
10652
10653 xfer += oprot->writeFieldBegin("family", ::apache::thrift::protocol::T_STRING, 3);
10654 xfer += oprot->writeBinary((*(this->family)));
10655 xfer += oprot->writeFieldEnd();
10656
10657 xfer += oprot->writeFieldStop();
10658 xfer += oprot->writeStructEnd();
10659 return xfer;
10660 }
10661
10662 uint32_t Hbase_getRowOrBefore_result::read(::apache::thrift::protocol::TProtocol* iprot) {
10663
10664 uint32_t xfer = 0;
10665 std::string fname;
10666 ::apache::thrift::protocol::TType ftype;
10667 int16_t fid;
10668
10669 xfer += iprot->readStructBegin(fname);
10670
10671 using ::apache::thrift::protocol::TProtocolException;
10672
10673
10674 while (true)
10675 {
10676 xfer += iprot->readFieldBegin(fname, ftype, fid);
10677 if (ftype == ::apache::thrift::protocol::T_STOP) {
10678 break;
10679 }
10680 switch (fid)
10681 {
10682 case 0:
10683 if (ftype == ::apache::thrift::protocol::T_LIST) {
10684 {
10685 this->success.clear();
10686 uint32_t _size558;
10687 ::apache::thrift::protocol::TType _etype561;
10688 xfer += iprot->readListBegin(_etype561, _size558);
10689 this->success.resize(_size558);
10690 uint32_t _i562;
10691 for (_i562 = 0; _i562 < _size558; ++_i562)
10692 {
10693 xfer += this->success[_i562].read(iprot);
10694 }
10695 xfer += iprot->readListEnd();
10696 }
10697 this->__isset.success = true;
10698 } else {
10699 xfer += iprot->skip(ftype);
10700 }
10701 break;
10702 case 1:
10703 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
10704 xfer += this->io.read(iprot);
10705 this->__isset.io = true;
10706 } else {
10707 xfer += iprot->skip(ftype);
10708 }
10709 break;
10710 default:
10711 xfer += iprot->skip(ftype);
10712 break;
10713 }
10714 xfer += iprot->readFieldEnd();
10715 }
10716
10717 xfer += iprot->readStructEnd();
10718
10719 return xfer;
10720 }
10721
10722 uint32_t Hbase_getRowOrBefore_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
10723
10724 uint32_t xfer = 0;
10725
10726 xfer += oprot->writeStructBegin("Hbase_getRowOrBefore_result");
10727
10728 if (this->__isset.success) {
10729 xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0);
10730 {
10731 xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->success.size()));
10732 std::vector<TCell> ::const_iterator _iter563;
10733 for (_iter563 = this->success.begin(); _iter563 != this->success.end(); ++_iter563)
10734 {
10735 xfer += (*_iter563).write(oprot);
10736 }
10737 xfer += oprot->writeListEnd();
10738 }
10739 xfer += oprot->writeFieldEnd();
10740 } else if (this->__isset.io) {
10741 xfer += oprot->writeFieldBegin("io", ::apache::thrift::protocol::T_STRUCT, 1);
10742 xfer += this->io.write(oprot);
10743 xfer += oprot->writeFieldEnd();
10744 }
10745 xfer += oprot->writeFieldStop();
10746 xfer += oprot->writeStructEnd();
10747 return xfer;
10748 }
10749
10750 uint32_t Hbase_getRowOrBefore_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
10751
10752 uint32_t xfer = 0;
10753 std::string fname;
10754 ::apache::thrift::protocol::TType ftype;
10755 int16_t fid;
10756
10757 xfer += iprot->readStructBegin(fname);
10758
10759 using ::apache::thrift::protocol::TProtocolException;
10760
10761
10762 while (true)
10763 {
10764 xfer += iprot->readFieldBegin(fname, ftype, fid);
10765 if (ftype == ::apache::thrift::protocol::T_STOP) {
10766 break;
10767 }
10768 switch (fid)
10769 {
10770 case 0:
10771 if (ftype == ::apache::thrift::protocol::T_LIST) {
10772 {
10773 (*(this->success)).clear();
10774 uint32_t _size564;
10775 ::apache::thrift::protocol::TType _etype567;
10776 xfer += iprot->readListBegin(_etype567, _size564);
10777 (*(this->success)).resize(_size564);
10778 uint32_t _i568;
10779 for (_i568 = 0; _i568 < _size564; ++_i568)
10780 {
10781 xfer += (*(this->success))[_i568].read(iprot);
10782 }
10783 xfer += iprot->readListEnd();
10784 }
10785 this->__isset.success = true;
10786 } else {
10787 xfer += iprot->skip(ftype);
10788 }
10789 break;
10790 case 1:
10791 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
10792 xfer += this->io.read(iprot);
10793 this->__isset.io = true;
10794 } else {
10795 xfer += iprot->skip(ftype);
10796 }
10797 break;
10798 default:
10799 xfer += iprot->skip(ftype);
10800 break;
10801 }
10802 xfer += iprot->readFieldEnd();
10803 }
10804
10805 xfer += iprot->readStructEnd();
10806
10807 return xfer;
10808 }
10809
10810 uint32_t Hbase_getRegionInfo_args::read(::apache::thrift::protocol::TProtocol* iprot) {
10811
10812 uint32_t xfer = 0;
10813 std::string fname;
10814 ::apache::thrift::protocol::TType ftype;
10815 int16_t fid;
10816
10817 xfer += iprot->readStructBegin(fname);
10818
10819 using ::apache::thrift::protocol::TProtocolException;
10820
10821
10822 while (true)
10823 {
10824 xfer += iprot->readFieldBegin(fname, ftype, fid);
10825 if (ftype == ::apache::thrift::protocol::T_STOP) {
10826 break;
10827 }
10828 switch (fid)
10829 {
10830 case 1:
10831 if (ftype == ::apache::thrift::protocol::T_STRING) {
10832 xfer += iprot->readBinary(this->row);
10833 this->__isset.row = true;
10834 } else {
10835 xfer += iprot->skip(ftype);
10836 }
10837 break;
10838 default:
10839 xfer += iprot->skip(ftype);
10840 break;
10841 }
10842 xfer += iprot->readFieldEnd();
10843 }
10844
10845 xfer += iprot->readStructEnd();
10846
10847 return xfer;
10848 }
10849
10850 uint32_t Hbase_getRegionInfo_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
10851 uint32_t xfer = 0;
10852 xfer += oprot->writeStructBegin("Hbase_getRegionInfo_args");
10853
10854 xfer += oprot->writeFieldBegin("row", ::apache::thrift::protocol::T_STRING, 1);
10855 xfer += oprot->writeBinary(this->row);
10856 xfer += oprot->writeFieldEnd();
10857
10858 xfer += oprot->writeFieldStop();
10859 xfer += oprot->writeStructEnd();
10860 return xfer;
10861 }
10862
10863 uint32_t Hbase_getRegionInfo_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
10864 uint32_t xfer = 0;
10865 xfer += oprot->writeStructBegin("Hbase_getRegionInfo_pargs");
10866
10867 xfer += oprot->writeFieldBegin("row", ::apache::thrift::protocol::T_STRING, 1);
10868 xfer += oprot->writeBinary((*(this->row)));
10869 xfer += oprot->writeFieldEnd();
10870
10871 xfer += oprot->writeFieldStop();
10872 xfer += oprot->writeStructEnd();
10873 return xfer;
10874 }
10875
10876 uint32_t Hbase_getRegionInfo_result::read(::apache::thrift::protocol::TProtocol* iprot) {
10877
10878 uint32_t xfer = 0;
10879 std::string fname;
10880 ::apache::thrift::protocol::TType ftype;
10881 int16_t fid;
10882
10883 xfer += iprot->readStructBegin(fname);
10884
10885 using ::apache::thrift::protocol::TProtocolException;
10886
10887
10888 while (true)
10889 {
10890 xfer += iprot->readFieldBegin(fname, ftype, fid);
10891 if (ftype == ::apache::thrift::protocol::T_STOP) {
10892 break;
10893 }
10894 switch (fid)
10895 {
10896 case 0:
10897 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
10898 xfer += this->success.read(iprot);
10899 this->__isset.success = true;
10900 } else {
10901 xfer += iprot->skip(ftype);
10902 }
10903 break;
10904 case 1:
10905 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
10906 xfer += this->io.read(iprot);
10907 this->__isset.io = true;
10908 } else {
10909 xfer += iprot->skip(ftype);
10910 }
10911 break;
10912 default:
10913 xfer += iprot->skip(ftype);
10914 break;
10915 }
10916 xfer += iprot->readFieldEnd();
10917 }
10918
10919 xfer += iprot->readStructEnd();
10920
10921 return xfer;
10922 }
10923
10924 uint32_t Hbase_getRegionInfo_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
10925
10926 uint32_t xfer = 0;
10927
10928 xfer += oprot->writeStructBegin("Hbase_getRegionInfo_result");
10929
10930 if (this->__isset.success) {
10931 xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0);
10932 xfer += this->success.write(oprot);
10933 xfer += oprot->writeFieldEnd();
10934 } else if (this->__isset.io) {
10935 xfer += oprot->writeFieldBegin("io", ::apache::thrift::protocol::T_STRUCT, 1);
10936 xfer += this->io.write(oprot);
10937 xfer += oprot->writeFieldEnd();
10938 }
10939 xfer += oprot->writeFieldStop();
10940 xfer += oprot->writeStructEnd();
10941 return xfer;
10942 }
10943
10944 uint32_t Hbase_getRegionInfo_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
10945
10946 uint32_t xfer = 0;
10947 std::string fname;
10948 ::apache::thrift::protocol::TType ftype;
10949 int16_t fid;
10950
10951 xfer += iprot->readStructBegin(fname);
10952
10953 using ::apache::thrift::protocol::TProtocolException;
10954
10955
10956 while (true)
10957 {
10958 xfer += iprot->readFieldBegin(fname, ftype, fid);
10959 if (ftype == ::apache::thrift::protocol::T_STOP) {
10960 break;
10961 }
10962 switch (fid)
10963 {
10964 case 0:
10965 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
10966 xfer += (*(this->success)).read(iprot);
10967 this->__isset.success = true;
10968 } else {
10969 xfer += iprot->skip(ftype);
10970 }
10971 break;
10972 case 1:
10973 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
10974 xfer += this->io.read(iprot);
10975 this->__isset.io = true;
10976 } else {
10977 xfer += iprot->skip(ftype);
10978 }
10979 break;
10980 default:
10981 xfer += iprot->skip(ftype);
10982 break;
10983 }
10984 xfer += iprot->readFieldEnd();
10985 }
10986
10987 xfer += iprot->readStructEnd();
10988
10989 return xfer;
10990 }
10991
10992 void HbaseClient::enableTable(const Bytes& tableName)
10993 {
10994 send_enableTable(tableName);
10995 recv_enableTable();
10996 }
10997
10998 void HbaseClient::send_enableTable(const Bytes& tableName)
10999 {
11000 int32_t cseqid = 0;
11001 oprot_->writeMessageBegin("enableTable", ::apache::thrift::protocol::T_CALL, cseqid);
11002
11003 Hbase_enableTable_pargs args;
11004 args.tableName = &tableName;
11005 args.write(oprot_);
11006
11007 oprot_->writeMessageEnd();
11008 oprot_->getTransport()->writeEnd();
11009 oprot_->getTransport()->flush();
11010 }
11011
11012 void HbaseClient::recv_enableTable()
11013 {
11014
11015 int32_t rseqid = 0;
11016 std::string fname;
11017 ::apache::thrift::protocol::TMessageType mtype;
11018
11019 iprot_->readMessageBegin(fname, mtype, rseqid);
11020 if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
11021 ::apache::thrift::TApplicationException x;
11022 x.read(iprot_);
11023 iprot_->readMessageEnd();
11024 iprot_->getTransport()->readEnd();
11025 throw x;
11026 }
11027 if (mtype != ::apache::thrift::protocol::T_REPLY) {
11028 iprot_->skip(::apache::thrift::protocol::T_STRUCT);
11029 iprot_->readMessageEnd();
11030 iprot_->getTransport()->readEnd();
11031 }
11032 if (fname.compare("enableTable") != 0) {
11033 iprot_->skip(::apache::thrift::protocol::T_STRUCT);
11034 iprot_->readMessageEnd();
11035 iprot_->getTransport()->readEnd();
11036 }
11037 Hbase_enableTable_presult result;
11038 result.read(iprot_);
11039 iprot_->readMessageEnd();
11040 iprot_->getTransport()->readEnd();
11041
11042 if (result.__isset.io) {
11043 throw result.io;
11044 }
11045 return;
11046 }
11047
11048 void HbaseClient::disableTable(const Bytes& tableName)
11049 {
11050 send_disableTable(tableName);
11051 recv_disableTable();
11052 }
11053
11054 void HbaseClient::send_disableTable(const Bytes& tableName)
11055 {
11056 int32_t cseqid = 0;
11057 oprot_->writeMessageBegin("disableTable", ::apache::thrift::protocol::T_CALL, cseqid);
11058
11059 Hbase_disableTable_pargs args;
11060 args.tableName = &tableName;
11061 args.write(oprot_);
11062
11063 oprot_->writeMessageEnd();
11064 oprot_->getTransport()->writeEnd();
11065 oprot_->getTransport()->flush();
11066 }
11067
11068 void HbaseClient::recv_disableTable()
11069 {
11070
11071 int32_t rseqid = 0;
11072 std::string fname;
11073 ::apache::thrift::protocol::TMessageType mtype;
11074
11075 iprot_->readMessageBegin(fname, mtype, rseqid);
11076 if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
11077 ::apache::thrift::TApplicationException x;
11078 x.read(iprot_);
11079 iprot_->readMessageEnd();
11080 iprot_->getTransport()->readEnd();
11081 throw x;
11082 }
11083 if (mtype != ::apache::thrift::protocol::T_REPLY) {
11084 iprot_->skip(::apache::thrift::protocol::T_STRUCT);
11085 iprot_->readMessageEnd();
11086 iprot_->getTransport()->readEnd();
11087 }
11088 if (fname.compare("disableTable") != 0) {
11089 iprot_->skip(::apache::thrift::protocol::T_STRUCT);
11090 iprot_->readMessageEnd();
11091 iprot_->getTransport()->readEnd();
11092 }
11093 Hbase_disableTable_presult result;
11094 result.read(iprot_);
11095 iprot_->readMessageEnd();
11096 iprot_->getTransport()->readEnd();
11097
11098 if (result.__isset.io) {
11099 throw result.io;
11100 }
11101 return;
11102 }
11103
11104 bool HbaseClient::isTableEnabled(const Bytes& tableName)
11105 {
11106 send_isTableEnabled(tableName);
11107 return recv_isTableEnabled();
11108 }
11109
11110 void HbaseClient::send_isTableEnabled(const Bytes& tableName)
11111 {
11112 int32_t cseqid = 0;
11113 oprot_->writeMessageBegin("isTableEnabled", ::apache::thrift::protocol::T_CALL, cseqid);
11114
11115 Hbase_isTableEnabled_pargs args;
11116 args.tableName = &tableName;
11117 args.write(oprot_);
11118
11119 oprot_->writeMessageEnd();
11120 oprot_->getTransport()->writeEnd();
11121 oprot_->getTransport()->flush();
11122 }
11123
11124 bool HbaseClient::recv_isTableEnabled()
11125 {
11126
11127 int32_t rseqid = 0;
11128 std::string fname;
11129 ::apache::thrift::protocol::TMessageType mtype;
11130
11131 iprot_->readMessageBegin(fname, mtype, rseqid);
11132 if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
11133 ::apache::thrift::TApplicationException x;
11134 x.read(iprot_);
11135 iprot_->readMessageEnd();
11136 iprot_->getTransport()->readEnd();
11137 throw x;
11138 }
11139 if (mtype != ::apache::thrift::protocol::T_REPLY) {
11140 iprot_->skip(::apache::thrift::protocol::T_STRUCT);
11141 iprot_->readMessageEnd();
11142 iprot_->getTransport()->readEnd();
11143 }
11144 if (fname.compare("isTableEnabled") != 0) {
11145 iprot_->skip(::apache::thrift::protocol::T_STRUCT);
11146 iprot_->readMessageEnd();
11147 iprot_->getTransport()->readEnd();
11148 }
11149 bool _return;
11150 Hbase_isTableEnabled_presult result;
11151 result.success = &_return;
11152 result.read(iprot_);
11153 iprot_->readMessageEnd();
11154 iprot_->getTransport()->readEnd();
11155
11156 if (result.__isset.success) {
11157 return _return;
11158 }
11159 if (result.__isset.io) {
11160 throw result.io;
11161 }
11162 throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "isTableEnabled failed: unknown result");
11163 }
11164
11165 void HbaseClient::compact(const Bytes& tableNameOrRegionName)
11166 {
11167 send_compact(tableNameOrRegionName);
11168 recv_compact();
11169 }
11170
11171 void HbaseClient::send_compact(const Bytes& tableNameOrRegionName)
11172 {
11173 int32_t cseqid = 0;
11174 oprot_->writeMessageBegin("compact", ::apache::thrift::protocol::T_CALL, cseqid);
11175
11176 Hbase_compact_pargs args;
11177 args.tableNameOrRegionName = &tableNameOrRegionName;
11178 args.write(oprot_);
11179
11180 oprot_->writeMessageEnd();
11181 oprot_->getTransport()->writeEnd();
11182 oprot_->getTransport()->flush();
11183 }
11184
11185 void HbaseClient::recv_compact()
11186 {
11187
11188 int32_t rseqid = 0;
11189 std::string fname;
11190 ::apache::thrift::protocol::TMessageType mtype;
11191
11192 iprot_->readMessageBegin(fname, mtype, rseqid);
11193 if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
11194 ::apache::thrift::TApplicationException x;
11195 x.read(iprot_);
11196 iprot_->readMessageEnd();
11197 iprot_->getTransport()->readEnd();
11198 throw x;
11199 }
11200 if (mtype != ::apache::thrift::protocol::T_REPLY) {
11201 iprot_->skip(::apache::thrift::protocol::T_STRUCT);
11202 iprot_->readMessageEnd();
11203 iprot_->getTransport()->readEnd();
11204 }
11205 if (fname.compare("compact") != 0) {
11206 iprot_->skip(::apache::thrift::protocol::T_STRUCT);
11207 iprot_->readMessageEnd();
11208 iprot_->getTransport()->readEnd();
11209 }
11210 Hbase_compact_presult result;
11211 result.read(iprot_);
11212 iprot_->readMessageEnd();
11213 iprot_->getTransport()->readEnd();
11214
11215 if (result.__isset.io) {
11216 throw result.io;
11217 }
11218 return;
11219 }
11220
11221 void HbaseClient::majorCompact(const Bytes& tableNameOrRegionName)
11222 {
11223 send_majorCompact(tableNameOrRegionName);
11224 recv_majorCompact();
11225 }
11226
11227 void HbaseClient::send_majorCompact(const Bytes& tableNameOrRegionName)
11228 {
11229 int32_t cseqid = 0;
11230 oprot_->writeMessageBegin("majorCompact", ::apache::thrift::protocol::T_CALL, cseqid);
11231
11232 Hbase_majorCompact_pargs args;
11233 args.tableNameOrRegionName = &tableNameOrRegionName;
11234 args.write(oprot_);
11235
11236 oprot_->writeMessageEnd();
11237 oprot_->getTransport()->writeEnd();
11238 oprot_->getTransport()->flush();
11239 }
11240
11241 void HbaseClient::recv_majorCompact()
11242 {
11243
11244 int32_t rseqid = 0;
11245 std::string fname;
11246 ::apache::thrift::protocol::TMessageType mtype;
11247
11248 iprot_->readMessageBegin(fname, mtype, rseqid);
11249 if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
11250 ::apache::thrift::TApplicationException x;
11251 x.read(iprot_);
11252 iprot_->readMessageEnd();
11253 iprot_->getTransport()->readEnd();
11254 throw x;
11255 }
11256 if (mtype != ::apache::thrift::protocol::T_REPLY) {
11257 iprot_->skip(::apache::thrift::protocol::T_STRUCT);
11258 iprot_->readMessageEnd();
11259 iprot_->getTransport()->readEnd();
11260 }
11261 if (fname.compare("majorCompact") != 0) {
11262 iprot_->skip(::apache::thrift::protocol::T_STRUCT);
11263 iprot_->readMessageEnd();
11264 iprot_->getTransport()->readEnd();
11265 }
11266 Hbase_majorCompact_presult result;
11267 result.read(iprot_);
11268 iprot_->readMessageEnd();
11269 iprot_->getTransport()->readEnd();
11270
11271 if (result.__isset.io) {
11272 throw result.io;
11273 }
11274 return;
11275 }
11276
11277 void HbaseClient::getTableNames(std::vector<Text> & _return)
11278 {
11279 send_getTableNames();
11280 recv_getTableNames(_return);
11281 }
11282
11283 void HbaseClient::send_getTableNames()
11284 {
11285 int32_t cseqid = 0;
11286 oprot_->writeMessageBegin("getTableNames", ::apache::thrift::protocol::T_CALL, cseqid);
11287
11288 Hbase_getTableNames_pargs args;
11289 args.write(oprot_);
11290
11291 oprot_->writeMessageEnd();
11292 oprot_->getTransport()->writeEnd();
11293 oprot_->getTransport()->flush();
11294 }
11295
11296 void HbaseClient::recv_getTableNames(std::vector<Text> & _return)
11297 {
11298
11299 int32_t rseqid = 0;
11300 std::string fname;
11301 ::apache::thrift::protocol::TMessageType mtype;
11302
11303 iprot_->readMessageBegin(fname, mtype, rseqid);
11304 if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
11305 ::apache::thrift::TApplicationException x;
11306 x.read(iprot_);
11307 iprot_->readMessageEnd();
11308 iprot_->getTransport()->readEnd();
11309 throw x;
11310 }
11311 if (mtype != ::apache::thrift::protocol::T_REPLY) {
11312 iprot_->skip(::apache::thrift::protocol::T_STRUCT);
11313 iprot_->readMessageEnd();
11314 iprot_->getTransport()->readEnd();
11315 }
11316 if (fname.compare("getTableNames") != 0) {
11317 iprot_->skip(::apache::thrift::protocol::T_STRUCT);
11318 iprot_->readMessageEnd();
11319 iprot_->getTransport()->readEnd();
11320 }
11321 Hbase_getTableNames_presult result;
11322 result.success = &_return;
11323 result.read(iprot_);
11324 iprot_->readMessageEnd();
11325 iprot_->getTransport()->readEnd();
11326
11327 if (result.__isset.success) {
11328 // _return pointer has now been filled
11329 return;
11330 }
11331 if (result.__isset.io) {
11332 throw result.io;
11333 }
11334 throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getTableNames failed: unknown result");
11335 }
11336
11337 void HbaseClient::getColumnDescriptors(std::map<Text, ColumnDescriptor> & _return, const Text& tableName)
11338 {
11339 send_getColumnDescriptors(tableName);
11340 recv_getColumnDescriptors(_return);
11341 }
11342
11343 void HbaseClient::send_getColumnDescriptors(const Text& tableName)
11344 {
11345 int32_t cseqid = 0;
11346 oprot_->writeMessageBegin("getColumnDescriptors", ::apache::thrift::protocol::T_CALL, cseqid);
11347
11348 Hbase_getColumnDescriptors_pargs args;
11349 args.tableName = &tableName;
11350 args.write(oprot_);
11351
11352 oprot_->writeMessageEnd();
11353 oprot_->getTransport()->writeEnd();
11354 oprot_->getTransport()->flush();
11355 }
11356
11357 void HbaseClient::recv_getColumnDescriptors(std::map<Text, ColumnDescriptor> & _return)
11358 {
11359
11360 int32_t rseqid = 0;
11361 std::string fname;
11362 ::apache::thrift::protocol::TMessageType mtype;
11363
11364 iprot_->readMessageBegin(fname, mtype, rseqid);
11365 if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
11366 ::apache::thrift::TApplicationException x;
11367 x.read(iprot_);
11368 iprot_->readMessageEnd();
11369 iprot_->getTransport()->readEnd();
11370 throw x;
11371 }
11372 if (mtype != ::apache::thrift::protocol::T_REPLY) {
11373 iprot_->skip(::apache::thrift::protocol::T_STRUCT);
11374 iprot_->readMessageEnd();
11375 iprot_->getTransport()->readEnd();
11376 }
11377 if (fname.compare("getColumnDescriptors") != 0) {
11378 iprot_->skip(::apache::thrift::protocol::T_STRUCT);
11379 iprot_->readMessageEnd();
11380 iprot_->getTransport()->readEnd();
11381 }
11382 Hbase_getColumnDescriptors_presult result;
11383 result.success = &_return;
11384 result.read(iprot_);
11385 iprot_->readMessageEnd();
11386 iprot_->getTransport()->readEnd();
11387
11388 if (result.__isset.success) {
11389 // _return pointer has now been filled
11390 return;
11391 }
11392 if (result.__isset.io) {
11393 throw result.io;
11394 }
11395 throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getColumnDescriptors failed: unknown result");
11396 }
11397
11398 void HbaseClient::getTableRegions(std::vector<TRegionInfo> & _return, const Text& tableName)
11399 {
11400 send_getTableRegions(tableName);
11401 recv_getTableRegions(_return);
11402 }
11403
11404 void HbaseClient::send_getTableRegions(const Text& tableName)
11405 {
11406 int32_t cseqid = 0;
11407 oprot_->writeMessageBegin("getTableRegions", ::apache::thrift::protocol::T_CALL, cseqid);
11408
11409 Hbase_getTableRegions_pargs args;
11410 args.tableName = &tableName;
11411 args.write(oprot_);
11412
11413 oprot_->writeMessageEnd();
11414 oprot_->getTransport()->writeEnd();
11415 oprot_->getTransport()->flush();
11416 }
11417
11418 void HbaseClient::recv_getTableRegions(std::vector<TRegionInfo> & _return)
11419 {
11420
11421 int32_t rseqid = 0;
11422 std::string fname;
11423 ::apache::thrift::protocol::TMessageType mtype;
11424
11425 iprot_->readMessageBegin(fname, mtype, rseqid);
11426 if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
11427 ::apache::thrift::TApplicationException x;
11428 x.read(iprot_);
11429 iprot_->readMessageEnd();
11430 iprot_->getTransport()->readEnd();
11431 throw x;
11432 }
11433 if (mtype != ::apache::thrift::protocol::T_REPLY) {
11434 iprot_->skip(::apache::thrift::protocol::T_STRUCT);
11435 iprot_->readMessageEnd();
11436 iprot_->getTransport()->readEnd();
11437 }
11438 if (fname.compare("getTableRegions") != 0) {
11439 iprot_->skip(::apache::thrift::protocol::T_STRUCT);
11440 iprot_->readMessageEnd();
11441 iprot_->getTransport()->readEnd();
11442 }
11443 Hbase_getTableRegions_presult result;
11444 result.success = &_return;
11445 result.read(iprot_);
11446 iprot_->readMessageEnd();
11447 iprot_->getTransport()->readEnd();
11448
11449 if (result.__isset.success) {
11450 // _return pointer has now been filled
11451 return;
11452 }
11453 if (result.__isset.io) {
11454 throw result.io;
11455 }
11456 throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getTableRegions failed: unknown result");
11457 }
11458
11459 void HbaseClient::createTable(const Text& tableName, const std::vector<ColumnDescriptor> & columnFamilies)
11460 {
11461 send_createTable(tableName, columnFamilies);
11462 recv_createTable();
11463 }
11464
11465 void HbaseClient::send_createTable(const Text& tableName, const std::vector<ColumnDescriptor> & columnFamilies)
11466 {
11467 int32_t cseqid = 0;
11468 oprot_->writeMessageBegin("createTable", ::apache::thrift::protocol::T_CALL, cseqid);
11469
11470 Hbase_createTable_pargs args;
11471 args.tableName = &tableName;
11472 args.columnFamilies = &columnFamilies;
11473 args.write(oprot_);
11474
11475 oprot_->writeMessageEnd();
11476 oprot_->getTransport()->writeEnd();
11477 oprot_->getTransport()->flush();
11478 }
11479
11480 void HbaseClient::recv_createTable()
11481 {
11482
11483 int32_t rseqid = 0;
11484 std::string fname;
11485 ::apache::thrift::protocol::TMessageType mtype;
11486
11487 iprot_->readMessageBegin(fname, mtype, rseqid);
11488 if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
11489 ::apache::thrift::TApplicationException x;
11490 x.read(iprot_);
11491 iprot_->readMessageEnd();
11492 iprot_->getTransport()->readEnd();
11493 throw x;
11494 }
11495 if (mtype != ::apache::thrift::protocol::T_REPLY) {
11496 iprot_->skip(::apache::thrift::protocol::T_STRUCT);
11497 iprot_->readMessageEnd();
11498 iprot_->getTransport()->readEnd();
11499 }
11500 if (fname.compare("createTable") != 0) {
11501 iprot_->skip(::apache::thrift::protocol::T_STRUCT);
11502 iprot_->readMessageEnd();
11503 iprot_->getTransport()->readEnd();
11504 }
11505 Hbase_createTable_presult result;
11506 result.read(iprot_);
11507 iprot_->readMessageEnd();
11508 iprot_->getTransport()->readEnd();
11509
11510 if (result.__isset.io) {
11511 throw result.io;
11512 }
11513 if (result.__isset.ia) {
11514 throw result.ia;
11515 }
11516 if (result.__isset.exist) {
11517 throw result.exist;
11518 }
11519 return;
11520 }
11521
11522 void HbaseClient::deleteTable(const Text& tableName)
11523 {
11524 send_deleteTable(tableName);
11525 recv_deleteTable();
11526 }
11527
11528 void HbaseClient::send_deleteTable(const Text& tableName)
11529 {
11530 int32_t cseqid = 0;
11531 oprot_->writeMessageBegin("deleteTable", ::apache::thrift::protocol::T_CALL, cseqid);
11532
11533 Hbase_deleteTable_pargs args;
11534 args.tableName = &tableName;
11535 args.write(oprot_);
11536
11537 oprot_->writeMessageEnd();
11538 oprot_->getTransport()->writeEnd();
11539 oprot_->getTransport()->flush();
11540 }
11541
11542 void HbaseClient::recv_deleteTable()
11543 {
11544
11545 int32_t rseqid = 0;
11546 std::string fname;
11547 ::apache::thrift::protocol::TMessageType mtype;
11548
11549 iprot_->readMessageBegin(fname, mtype, rseqid);
11550 if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
11551 ::apache::thrift::TApplicationException x;
11552 x.read(iprot_);
11553 iprot_->readMessageEnd();
11554 iprot_->getTransport()->readEnd();
11555 throw x;
11556 }
11557 if (mtype != ::apache::thrift::protocol::T_REPLY) {
11558 iprot_->skip(::apache::thrift::protocol::T_STRUCT);
11559 iprot_->readMessageEnd();
11560 iprot_->getTransport()->readEnd();
11561 }
11562 if (fname.compare("deleteTable") != 0) {
11563 iprot_->skip(::apache::thrift::protocol::T_STRUCT);
11564 iprot_->readMessageEnd();
11565 iprot_->getTransport()->readEnd();
11566 }
11567 Hbase_deleteTable_presult result;
11568 result.read(iprot_);
11569 iprot_->readMessageEnd();
11570 iprot_->getTransport()->readEnd();
11571
11572 if (result.__isset.io) {
11573 throw result.io;
11574 }
11575 return;
11576 }
11577
11578 void HbaseClient::get(std::vector<TCell> & _return, const Text& tableName, const Text& row, const Text& column, const std::map<Text, Text> & attributes)
11579 {
11580 send_get(tableName, row, column, attributes);
11581 recv_get(_return);
11582 }
11583
11584 void HbaseClient::send_get(const Text& tableName, const Text& row, const Text& column, const std::map<Text, Text> & attributes)
11585 {
11586 int32_t cseqid = 0;
11587 oprot_->writeMessageBegin("get", ::apache::thrift::protocol::T_CALL, cseqid);
11588
11589 Hbase_get_pargs args;
11590 args.tableName = &tableName;
11591 args.row = &row;
11592 args.column = &column;
11593 args.attributes = &attributes;
11594 args.write(oprot_);
11595
11596 oprot_->writeMessageEnd();
11597 oprot_->getTransport()->writeEnd();
11598 oprot_->getTransport()->flush();
11599 }
11600
11601 void HbaseClient::recv_get(std::vector<TCell> & _return)
11602 {
11603
11604 int32_t rseqid = 0;
11605 std::string fname;
11606 ::apache::thrift::protocol::TMessageType mtype;
11607
11608 iprot_->readMessageBegin(fname, mtype, rseqid);
11609 if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
11610 ::apache::thrift::TApplicationException x;
11611 x.read(iprot_);
11612 iprot_->readMessageEnd();
11613 iprot_->getTransport()->readEnd();
11614 throw x;
11615 }
11616 if (mtype != ::apache::thrift::protocol::T_REPLY) {
11617 iprot_->skip(::apache::thrift::protocol::T_STRUCT);
11618 iprot_->readMessageEnd();
11619 iprot_->getTransport()->readEnd();
11620 }
11621 if (fname.compare("get") != 0) {
11622 iprot_->skip(::apache::thrift::protocol::T_STRUCT);
11623 iprot_->readMessageEnd();
11624 iprot_->getTransport()->readEnd();
11625 }
11626 Hbase_get_presult result;
11627 result.success = &_return;
11628 result.read(iprot_);
11629 iprot_->readMessageEnd();
11630 iprot_->getTransport()->readEnd();
11631
11632 if (result.__isset.success) {
11633 // _return pointer has now been filled
11634 return;
11635 }
11636 if (result.__isset.io) {
11637 throw result.io;
11638 }
11639 throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get failed: unknown result");
11640 }
11641
11642 void HbaseClient::getVer(std::vector<TCell> & _return, const Text& tableName, const Text& row, const Text& column, const int32_t numVersions, const std::map<Text, Text> & attributes)
11643 {
11644 send_getVer(tableName, row, column, numVersions, attributes);
11645 recv_getVer(_return);
11646 }
11647
11648 void HbaseClient::send_getVer(const Text& tableName, const Text& row, const Text& column, const int32_t numVersions, const std::map<Text, Text> & attributes)
11649 {
11650 int32_t cseqid = 0;
11651 oprot_->writeMessageBegin("getVer", ::apache::thrift::protocol::T_CALL, cseqid);
11652
11653 Hbase_getVer_pargs args;
11654 args.tableName = &tableName;
11655 args.row = &row;
11656 args.column = &column;
11657 args.numVersions = &numVersions;
11658 args.attributes = &attributes;
11659 args.write(oprot_);
11660
11661 oprot_->writeMessageEnd();
11662 oprot_->getTransport()->writeEnd();
11663 oprot_->getTransport()->flush();
11664 }
11665
11666 void HbaseClient::recv_getVer(std::vector<TCell> & _return)
11667 {
11668
11669 int32_t rseqid = 0;
11670 std::string fname;
11671 ::apache::thrift::protocol::TMessageType mtype;
11672
11673 iprot_->readMessageBegin(fname, mtype, rseqid);
11674 if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
11675 ::apache::thrift::TApplicationException x;
11676 x.read(iprot_);
11677 iprot_->readMessageEnd();
11678 iprot_->getTransport()->readEnd();
11679 throw x;
11680 }
11681 if (mtype != ::apache::thrift::protocol::T_REPLY) {
11682 iprot_->skip(::apache::thrift::protocol::T_STRUCT);
11683 iprot_->readMessageEnd();
11684 iprot_->getTransport()->readEnd();
11685 }
11686 if (fname.compare("getVer") != 0) {
11687 iprot_->skip(::apache::thrift::protocol::T_STRUCT);
11688 iprot_->readMessageEnd();
11689 iprot_->getTransport()->readEnd();
11690 }
11691 Hbase_getVer_presult result;
11692 result.success = &_return;
11693 result.read(iprot_);
11694 iprot_->readMessageEnd();
11695 iprot_->getTransport()->readEnd();
11696
11697 if (result.__isset.success) {
11698 // _return pointer has now been filled
11699 return;
11700 }
11701 if (result.__isset.io) {
11702 throw result.io;
11703 }
11704 throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getVer failed: unknown result");
11705 }
11706
11707 void HbaseClient::getVerTs(std::vector<TCell> & _return, const Text& tableName, const Text& row, const Text& column, const int64_t timestamp, const int32_t numVersions, const std::map<Text, Text> & attributes)
11708 {
11709 send_getVerTs(tableName, row, column, timestamp, numVersions, attributes);
11710 recv_getVerTs(_return);
11711 }
11712
11713 void HbaseClient::send_getVerTs(const Text& tableName, const Text& row, const Text& column, const int64_t timestamp, const int32_t numVersions, const std::map<Text, Text> & attributes)
11714 {
11715 int32_t cseqid = 0;
11716 oprot_->writeMessageBegin("getVerTs", ::apache::thrift::protocol::T_CALL, cseqid);
11717
11718 Hbase_getVerTs_pargs args;
11719 args.tableName = &tableName;
11720 args.row = &row;
11721 args.column = &column;
11722 args.timestamp = &timestamp;
11723 args.numVersions = &numVersions;
11724 args.attributes = &attributes;
11725 args.write(oprot_);
11726
11727 oprot_->writeMessageEnd();
11728 oprot_->getTransport()->writeEnd();
11729 oprot_->getTransport()->flush();
11730 }
11731
11732 void HbaseClient::recv_getVerTs(std::vector<TCell> & _return)
11733 {
11734
11735 int32_t rseqid = 0;
11736 std::string fname;
11737 ::apache::thrift::protocol::TMessageType mtype;
11738
11739 iprot_->readMessageBegin(fname, mtype, rseqid);
11740 if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
11741 ::apache::thrift::TApplicationException x;
11742 x.read(iprot_);
11743 iprot_->readMessageEnd();
11744 iprot_->getTransport()->readEnd();
11745 throw x;
11746 }
11747 if (mtype != ::apache::thrift::protocol::T_REPLY) {
11748 iprot_->skip(::apache::thrift::protocol::T_STRUCT);
11749 iprot_->readMessageEnd();
11750 iprot_->getTransport()->readEnd();
11751 }
11752 if (fname.compare("getVerTs") != 0) {
11753 iprot_->skip(::apache::thrift::protocol::T_STRUCT);
11754 iprot_->readMessageEnd();
11755 iprot_->getTransport()->readEnd();
11756 }
11757 Hbase_getVerTs_presult result;
11758 result.success = &_return;
11759 result.read(iprot_);
11760 iprot_->readMessageEnd();
11761 iprot_->getTransport()->readEnd();
11762
11763 if (result.__isset.success) {
11764 // _return pointer has now been filled
11765 return;
11766 }
11767 if (result.__isset.io) {
11768 throw result.io;
11769 }
11770 throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getVerTs failed: unknown result");
11771 }
11772
11773 void HbaseClient::getRow(std::vector<TRowResult> & _return, const Text& tableName, const Text& row, const std::map<Text, Text> & attributes)
11774 {
11775 send_getRow(tableName, row, attributes);
11776 recv_getRow(_return);
11777 }
11778
11779 void HbaseClient::send_getRow(const Text& tableName, const Text& row, const std::map<Text, Text> & attributes)
11780 {
11781 int32_t cseqid = 0;
11782 oprot_->writeMessageBegin("getRow", ::apache::thrift::protocol::T_CALL, cseqid);
11783
11784 Hbase_getRow_pargs args;
11785 args.tableName = &tableName;
11786 args.row = &row;
11787 args.attributes = &attributes;
11788 args.write(oprot_);
11789
11790 oprot_->writeMessageEnd();
11791 oprot_->getTransport()->writeEnd();
11792 oprot_->getTransport()->flush();
11793 }
11794
11795 void HbaseClient::recv_getRow(std::vector<TRowResult> & _return)
11796 {
11797
11798 int32_t rseqid = 0;
11799 std::string fname;
11800 ::apache::thrift::protocol::TMessageType mtype;
11801
11802 iprot_->readMessageBegin(fname, mtype, rseqid);
11803 if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
11804 ::apache::thrift::TApplicationException x;
11805 x.read(iprot_);
11806 iprot_->readMessageEnd();
11807 iprot_->getTransport()->readEnd();
11808 throw x;
11809 }
11810 if (mtype != ::apache::thrift::protocol::T_REPLY) {
11811 iprot_->skip(::apache::thrift::protocol::T_STRUCT);
11812 iprot_->readMessageEnd();
11813 iprot_->getTransport()->readEnd();
11814 }
11815 if (fname.compare("getRow") != 0) {
11816 iprot_->skip(::apache::thrift::protocol::T_STRUCT);
11817 iprot_->readMessageEnd();
11818 iprot_->getTransport()->readEnd();
11819 }
11820 Hbase_getRow_presult result;
11821 result.success = &_return;
11822 result.read(iprot_);
11823 iprot_->readMessageEnd();
11824 iprot_->getTransport()->readEnd();
11825
11826 if (result.__isset.success) {
11827 // _return pointer has now been filled
11828 return;
11829 }
11830 if (result.__isset.io) {
11831 throw result.io;
11832 }
11833 throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getRow failed: unknown result");
11834 }
11835
11836 void HbaseClient::getRowWithColumns(std::vector<TRowResult> & _return, const Text& tableName, const Text& row, const std::vector<Text> & columns, const std::map<Text, Text> & attributes)
11837 {
11838 send_getRowWithColumns(tableName, row, columns, attributes);
11839 recv_getRowWithColumns(_return);
11840 }
11841
11842 void HbaseClient::send_getRowWithColumns(const Text& tableName, const Text& row, const std::vector<Text> & columns, const std::map<Text, Text> & attributes)
11843 {
11844 int32_t cseqid = 0;
11845 oprot_->writeMessageBegin("getRowWithColumns", ::apache::thrift::protocol::T_CALL, cseqid);
11846
11847 Hbase_getRowWithColumns_pargs args;
11848 args.tableName = &tableName;
11849 args.row = &row;
11850 args.columns = &columns;
11851 args.attributes = &attributes;
11852 args.write(oprot_);
11853
11854 oprot_->writeMessageEnd();
11855 oprot_->getTransport()->writeEnd();
11856 oprot_->getTransport()->flush();
11857 }
11858
11859 void HbaseClient::recv_getRowWithColumns(std::vector<TRowResult> & _return)
11860 {
11861
11862 int32_t rseqid = 0;
11863 std::string fname;
11864 ::apache::thrift::protocol::TMessageType mtype;
11865
11866 iprot_->readMessageBegin(fname, mtype, rseqid);
11867 if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
11868 ::apache::thrift::TApplicationException x;
11869 x.read(iprot_);
11870 iprot_->readMessageEnd();
11871 iprot_->getTransport()->readEnd();
11872 throw x;
11873 }
11874 if (mtype != ::apache::thrift::protocol::T_REPLY) {
11875 iprot_->skip(::apache::thrift::protocol::T_STRUCT);
11876 iprot_->readMessageEnd();
11877 iprot_->getTransport()->readEnd();
11878 }
11879 if (fname.compare("getRowWithColumns") != 0) {
11880 iprot_->skip(::apache::thrift::protocol::T_STRUCT);
11881 iprot_->readMessageEnd();
11882 iprot_->getTransport()->readEnd();
11883 }
11884 Hbase_getRowWithColumns_presult result;
11885 result.success = &_return;
11886 result.read(iprot_);
11887 iprot_->readMessageEnd();
11888 iprot_->getTransport()->readEnd();
11889
11890 if (result.__isset.success) {
11891 // _return pointer has now been filled
11892 return;
11893 }
11894 if (result.__isset.io) {
11895 throw result.io;
11896 }
11897 throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getRowWithColumns failed: unknown result");
11898 }
11899
11900 void HbaseClient::getRowTs(std::vector<TRowResult> & _return, const Text& tableName, const Text& row, const int64_t timestamp, const std::map<Text, Text> & attributes)
11901 {
11902 send_getRowTs(tableName, row, timestamp, attributes);
11903 recv_getRowTs(_return);
11904 }
11905
11906 void HbaseClient::send_getRowTs(const Text& tableName, const Text& row, const int64_t timestamp, const std::map<Text, Text> & attributes)
11907 {
11908 int32_t cseqid = 0;
11909 oprot_->writeMessageBegin("getRowTs", ::apache::thrift::protocol::T_CALL, cseqid);
11910
11911 Hbase_getRowTs_pargs args;
11912 args.tableName = &tableName;
11913 args.row = &row;
11914 args.timestamp = &timestamp;
11915 args.attributes = &attributes;
11916 args.write(oprot_);
11917
11918 oprot_->writeMessageEnd();
11919 oprot_->getTransport()->writeEnd();
11920 oprot_->getTransport()->flush();
11921 }
11922
11923 void HbaseClient::recv_getRowTs(std::vector<TRowResult> & _return)
11924 {
11925
11926 int32_t rseqid = 0;
11927 std::string fname;
11928 ::apache::thrift::protocol::TMessageType mtype;
11929
11930 iprot_->readMessageBegin(fname, mtype, rseqid);
11931 if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
11932 ::apache::thrift::TApplicationException x;
11933 x.read(iprot_);
11934 iprot_->readMessageEnd();
11935 iprot_->getTransport()->readEnd();
11936 throw x;
11937 }
11938 if (mtype != ::apache::thrift::protocol::T_REPLY) {
11939 iprot_->skip(::apache::thrift::protocol::T_STRUCT);
11940 iprot_->readMessageEnd();
11941 iprot_->getTransport()->readEnd();
11942 }
11943 if (fname.compare("getRowTs") != 0) {
11944 iprot_->skip(::apache::thrift::protocol::T_STRUCT);
11945 iprot_->readMessageEnd();
11946 iprot_->getTransport()->readEnd();
11947 }
11948 Hbase_getRowTs_presult result;
11949 result.success = &_return;
11950 result.read(iprot_);
11951 iprot_->readMessageEnd();
11952 iprot_->getTransport()->readEnd();
11953
11954 if (result.__isset.success) {
11955 // _return pointer has now been filled
11956 return;
11957 }
11958 if (result.__isset.io) {
11959 throw result.io;
11960 }
11961 throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getRowTs failed: unknown result");
11962 }
11963
11964 void HbaseClient::getRowWithColumnsTs(std::vector<TRowResult> & _return, const Text& tableName, const Text& row, const std::vector<Text> & columns, const int64_t timestamp, const std::map<Text, Text> & attributes)
11965 {
11966 send_getRowWithColumnsTs(tableName, row, columns, timestamp, attributes);
11967 recv_getRowWithColumnsTs(_return);
11968 }
11969
11970 void HbaseClient::send_getRowWithColumnsTs(const Text& tableName, const Text& row, const std::vector<Text> & columns, const int64_t timestamp, const std::map<Text, Text> & attributes)
11971 {
11972 int32_t cseqid = 0;
11973 oprot_->writeMessageBegin("getRowWithColumnsTs", ::apache::thrift::protocol::T_CALL, cseqid);
11974
11975 Hbase_getRowWithColumnsTs_pargs args;
11976 args.tableName = &tableName;
11977 args.row = &row;
11978 args.columns = &columns;
11979 args.timestamp = &timestamp;
11980 args.attributes = &attributes;
11981 args.write(oprot_);
11982
11983 oprot_->writeMessageEnd();
11984 oprot_->getTransport()->writeEnd();
11985 oprot_->getTransport()->flush();
11986 }
11987
11988 void HbaseClient::recv_getRowWithColumnsTs(std::vector<TRowResult> & _return)
11989 {
11990
11991 int32_t rseqid = 0;
11992 std::string fname;
11993 ::apache::thrift::protocol::TMessageType mtype;
11994
11995 iprot_->readMessageBegin(fname, mtype, rseqid);
11996 if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
11997 ::apache::thrift::TApplicationException x;
11998 x.read(iprot_);
11999 iprot_->readMessageEnd();
12000 iprot_->getTransport()->readEnd();
12001 throw x;
12002 }
12003 if (mtype != ::apache::thrift::protocol::T_REPLY) {
12004 iprot_->skip(::apache::thrift::protocol::T_STRUCT);
12005 iprot_->readMessageEnd();
12006 iprot_->getTransport()->readEnd();
12007 }
12008 if (fname.compare("getRowWithColumnsTs") != 0) {
12009 iprot_->skip(::apache::thrift::protocol::T_STRUCT);
12010 iprot_->readMessageEnd();
12011 iprot_->getTransport()->readEnd();
12012 }
12013 Hbase_getRowWithColumnsTs_presult result;
12014 result.success = &_return;
12015 result.read(iprot_);
12016 iprot_->readMessageEnd();
12017 iprot_->getTransport()->readEnd();
12018
12019 if (result.__isset.success) {
12020 // _return pointer has now been filled
12021 return;
12022 }
12023 if (result.__isset.io) {
12024 throw result.io;
12025 }
12026 throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getRowWithColumnsTs failed: unknown result");
12027 }
12028
12029 void HbaseClient::getRows(std::vector<TRowResult> & _return, const Text& tableName, const std::vector<Text> & rows, const std::map<Text, Text> & attributes)
12030 {
12031 send_getRows(tableName, rows, attributes);
12032 recv_getRows(_return);
12033 }
12034
12035 void HbaseClient::send_getRows(const Text& tableName, const std::vector<Text> & rows, const std::map<Text, Text> & attributes)
12036 {
12037 int32_t cseqid = 0;
12038 oprot_->writeMessageBegin("getRows", ::apache::thrift::protocol::T_CALL, cseqid);
12039
12040 Hbase_getRows_pargs args;
12041 args.tableName = &tableName;
12042 args.rows = &rows;
12043 args.attributes = &attributes;
12044 args.write(oprot_);
12045
12046 oprot_->writeMessageEnd();
12047 oprot_->getTransport()->writeEnd();
12048 oprot_->getTransport()->flush();
12049 }
12050
12051 void HbaseClient::recv_getRows(std::vector<TRowResult> & _return)
12052 {
12053
12054 int32_t rseqid = 0;
12055 std::string fname;
12056 ::apache::thrift::protocol::TMessageType mtype;
12057
12058 iprot_->readMessageBegin(fname, mtype, rseqid);
12059 if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
12060 ::apache::thrift::TApplicationException x;
12061 x.read(iprot_);
12062 iprot_->readMessageEnd();
12063 iprot_->getTransport()->readEnd();
12064 throw x;
12065 }
12066 if (mtype != ::apache::thrift::protocol::T_REPLY) {
12067 iprot_->skip(::apache::thrift::protocol::T_STRUCT);
12068 iprot_->readMessageEnd();
12069 iprot_->getTransport()->readEnd();
12070 }
12071 if (fname.compare("getRows") != 0) {
12072 iprot_->skip(::apache::thrift::protocol::T_STRUCT);
12073 iprot_->readMessageEnd();
12074 iprot_->getTransport()->readEnd();
12075 }
12076 Hbase_getRows_presult result;
12077 result.success = &_return;
12078 result.read(iprot_);
12079 iprot_->readMessageEnd();
12080 iprot_->getTransport()->readEnd();
12081
12082 if (result.__isset.success) {
12083 // _return pointer has now been filled
12084 return;
12085 }
12086 if (result.__isset.io) {
12087 throw result.io;
12088 }
12089 throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getRows failed: unknown result");
12090 }
12091
12092 void HbaseClient::getRowsWithColumns(std::vector<TRowResult> & _return, const Text& tableName, const std::vector<Text> & rows, const std::vector<Text> & columns, const std::map<Text, Text> & attributes)
12093 {
12094 send_getRowsWithColumns(tableName, rows, columns, attributes);
12095 recv_getRowsWithColumns(_return);
12096 }
12097
12098 void HbaseClient::send_getRowsWithColumns(const Text& tableName, const std::vector<Text> & rows, const std::vector<Text> & columns, const std::map<Text, Text> & attributes)
12099 {
12100 int32_t cseqid = 0;
12101 oprot_->writeMessageBegin("getRowsWithColumns", ::apache::thrift::protocol::T_CALL, cseqid);
12102
12103 Hbase_getRowsWithColumns_pargs args;
12104 args.tableName = &tableName;
12105 args.rows = &rows;
12106 args.columns = &columns;
12107 args.attributes = &attributes;
12108 args.write(oprot_);
12109
12110 oprot_->writeMessageEnd();
12111 oprot_->getTransport()->writeEnd();
12112 oprot_->getTransport()->flush();
12113 }
12114
12115 void HbaseClient::recv_getRowsWithColumns(std::vector<TRowResult> & _return)
12116 {
12117
12118 int32_t rseqid = 0;
12119 std::string fname;
12120 ::apache::thrift::protocol::TMessageType mtype;
12121
12122 iprot_->readMessageBegin(fname, mtype, rseqid);
12123 if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
12124 ::apache::thrift::TApplicationException x;
12125 x.read(iprot_);
12126 iprot_->readMessageEnd();
12127 iprot_->getTransport()->readEnd();
12128 throw x;
12129 }
12130 if (mtype != ::apache::thrift::protocol::T_REPLY) {
12131 iprot_->skip(::apache::thrift::protocol::T_STRUCT);
12132 iprot_->readMessageEnd();
12133 iprot_->getTransport()->readEnd();
12134 }
12135 if (fname.compare("getRowsWithColumns") != 0) {
12136 iprot_->skip(::apache::thrift::protocol::T_STRUCT);
12137 iprot_->readMessageEnd();
12138 iprot_->getTransport()->readEnd();
12139 }
12140 Hbase_getRowsWithColumns_presult result;
12141 result.success = &_return;
12142 result.read(iprot_);
12143 iprot_->readMessageEnd();
12144 iprot_->getTransport()->readEnd();
12145
12146 if (result.__isset.success) {
12147 // _return pointer has now been filled
12148 return;
12149 }
12150 if (result.__isset.io) {
12151 throw result.io;
12152 }
12153 throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getRowsWithColumns failed: unknown result");
12154 }
12155
12156 void HbaseClient::getRowsTs(std::vector<TRowResult> & _return, const Text& tableName, const std::vector<Text> & rows, const int64_t timestamp, const std::map<Text, Text> & attributes)
12157 {
12158 send_getRowsTs(tableName, rows, timestamp, attributes);
12159 recv_getRowsTs(_return);
12160 }
12161
12162 void HbaseClient::send_getRowsTs(const Text& tableName, const std::vector<Text> & rows, const int64_t timestamp, const std::map<Text, Text> & attributes)
12163 {
12164 int32_t cseqid = 0;
12165 oprot_->writeMessageBegin("getRowsTs", ::apache::thrift::protocol::T_CALL, cseqid);
12166
12167 Hbase_getRowsTs_pargs args;
12168 args.tableName = &tableName;
12169 args.rows = &rows;
12170 args.timestamp = &timestamp;
12171 args.attributes = &attributes;
12172 args.write(oprot_);
12173
12174 oprot_->writeMessageEnd();
12175 oprot_->getTransport()->writeEnd();
12176 oprot_->getTransport()->flush();
12177 }
12178
12179 void HbaseClient::recv_getRowsTs(std::vector<TRowResult> & _return)
12180 {
12181
12182 int32_t rseqid = 0;
12183 std::string fname;
12184 ::apache::thrift::protocol::TMessageType mtype;
12185
12186 iprot_->readMessageBegin(fname, mtype, rseqid);
12187 if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
12188 ::apache::thrift::TApplicationException x;
12189 x.read(iprot_);
12190 iprot_->readMessageEnd();
12191 iprot_->getTransport()->readEnd();
12192 throw x;
12193 }
12194 if (mtype != ::apache::thrift::protocol::T_REPLY) {
12195 iprot_->skip(::apache::thrift::protocol::T_STRUCT);
12196 iprot_->readMessageEnd();
12197 iprot_->getTransport()->readEnd();
12198 }
12199 if (fname.compare("getRowsTs") != 0) {
12200 iprot_->skip(::apache::thrift::protocol::T_STRUCT);
12201 iprot_->readMessageEnd();
12202 iprot_->getTransport()->readEnd();
12203 }
12204 Hbase_getRowsTs_presult result;
12205 result.success = &_return;
12206 result.read(iprot_);
12207 iprot_->readMessageEnd();
12208 iprot_->getTransport()->readEnd();
12209
12210 if (result.__isset.success) {
12211 // _return pointer has now been filled
12212 return;
12213 }
12214 if (result.__isset.io) {
12215 throw result.io;
12216 }
12217 throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getRowsTs failed: unknown result");
12218 }
12219
12220 void HbaseClient::getRowsWithColumnsTs(std::vector<TRowResult> & _return, const Text& tableName, const std::vector<Text> & rows, const std::vector<Text> & columns, const int64_t timestamp, const std::map<Text, Text> & attributes)
12221 {
12222 send_getRowsWithColumnsTs(tableName, rows, columns, timestamp, attributes);
12223 recv_getRowsWithColumnsTs(_return);
12224 }
12225
12226 void HbaseClient::send_getRowsWithColumnsTs(const Text& tableName, const std::vector<Text> & rows, const std::vector<Text> & columns, const int64_t timestamp, const std::map<Text, Text> & attributes)
12227 {
12228 int32_t cseqid = 0;
12229 oprot_->writeMessageBegin("getRowsWithColumnsTs", ::apache::thrift::protocol::T_CALL, cseqid);
12230
12231 Hbase_getRowsWithColumnsTs_pargs args;
12232 args.tableName = &tableName;
12233 args.rows = &rows;
12234 args.columns = &columns;
12235 args.timestamp = &timestamp;
12236 args.attributes = &attributes;
12237 args.write(oprot_);
12238
12239 oprot_->writeMessageEnd();
12240 oprot_->getTransport()->writeEnd();
12241 oprot_->getTransport()->flush();
12242 }
12243
12244 void HbaseClient::recv_getRowsWithColumnsTs(std::vector<TRowResult> & _return)
12245 {
12246
12247 int32_t rseqid = 0;
12248 std::string fname;
12249 ::apache::thrift::protocol::TMessageType mtype;
12250
12251 iprot_->readMessageBegin(fname, mtype, rseqid);
12252 if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
12253 ::apache::thrift::TApplicationException x;
12254 x.read(iprot_);
12255 iprot_->readMessageEnd();
12256 iprot_->getTransport()->readEnd();
12257 throw x;
12258 }
12259 if (mtype != ::apache::thrift::protocol::T_REPLY) {
12260 iprot_->skip(::apache::thrift::protocol::T_STRUCT);
12261 iprot_->readMessageEnd();
12262 iprot_->getTransport()->readEnd();
12263 }
12264 if (fname.compare("getRowsWithColumnsTs") != 0) {
12265 iprot_->skip(::apache::thrift::protocol::T_STRUCT);
12266 iprot_->readMessageEnd();
12267 iprot_->getTransport()->readEnd();
12268 }
12269 Hbase_getRowsWithColumnsTs_presult result;
12270 result.success = &_return;
12271 result.read(iprot_);
12272 iprot_->readMessageEnd();
12273 iprot_->getTransport()->readEnd();
12274
12275 if (result.__isset.success) {
12276 // _return pointer has now been filled
12277 return;
12278 }
12279 if (result.__isset.io) {
12280 throw result.io;
12281 }
12282 throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getRowsWithColumnsTs failed: unknown result");
12283 }
12284
12285 void HbaseClient::mutateRow(const Text& tableName, const Text& row, const std::vector<Mutation> & mutations, const std::map<Text, Text> & attributes)
12286 {
12287 send_mutateRow(tableName, row, mutations, attributes);
12288 recv_mutateRow();
12289 }
12290
12291 void HbaseClient::send_mutateRow(const Text& tableName, const Text& row, const std::vector<Mutation> & mutations, const std::map<Text, Text> & attributes)
12292 {
12293 int32_t cseqid = 0;
12294 oprot_->writeMessageBegin("mutateRow", ::apache::thrift::protocol::T_CALL, cseqid);
12295
12296 Hbase_mutateRow_pargs args;
12297 args.tableName = &tableName;
12298 args.row = &row;
12299 args.mutations = &mutations;
12300 args.attributes = &attributes;
12301 args.write(oprot_);
12302
12303 oprot_->writeMessageEnd();
12304 oprot_->getTransport()->writeEnd();
12305 oprot_->getTransport()->flush();
12306 }
12307
12308 void HbaseClient::recv_mutateRow()
12309 {
12310
12311 int32_t rseqid = 0;
12312 std::string fname;
12313 ::apache::thrift::protocol::TMessageType mtype;
12314
12315 iprot_->readMessageBegin(fname, mtype, rseqid);
12316 if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
12317 ::apache::thrift::TApplicationException x;
12318 x.read(iprot_);
12319 iprot_->readMessageEnd();
12320 iprot_->getTransport()->readEnd();
12321 throw x;
12322 }
12323 if (mtype != ::apache::thrift::protocol::T_REPLY) {
12324 iprot_->skip(::apache::thrift::protocol::T_STRUCT);
12325 iprot_->readMessageEnd();
12326 iprot_->getTransport()->readEnd();
12327 }
12328 if (fname.compare("mutateRow") != 0) {
12329 iprot_->skip(::apache::thrift::protocol::T_STRUCT);
12330 iprot_->readMessageEnd();
12331 iprot_->getTransport()->readEnd();
12332 }
12333 Hbase_mutateRow_presult result;
12334 result.read(iprot_);
12335 iprot_->readMessageEnd();
12336 iprot_->getTransport()->readEnd();
12337
12338 if (result.__isset.io) {
12339 throw result.io;
12340 }
12341 if (result.__isset.ia) {
12342 throw result.ia;
12343 }
12344 return;
12345 }
12346
12347 void HbaseClient::mutateRowTs(const Text& tableName, const Text& row, const std::vector<Mutation> & mutations, const int64_t timestamp, const std::map<Text, Text> & attributes)
12348 {
12349 send_mutateRowTs(tableName, row, mutations, timestamp, attributes);
12350 recv_mutateRowTs();
12351 }
12352
12353 void HbaseClient::send_mutateRowTs(const Text& tableName, const Text& row, const std::vector<Mutation> & mutations, const int64_t timestamp, const std::map<Text, Text> & attributes)
12354 {
12355 int32_t cseqid = 0;
12356 oprot_->writeMessageBegin("mutateRowTs", ::apache::thrift::protocol::T_CALL, cseqid);
12357
12358 Hbase_mutateRowTs_pargs args;
12359 args.tableName = &tableName;
12360 args.row = &row;
12361 args.mutations = &mutations;
12362 args.timestamp = &timestamp;
12363 args.attributes = &attributes;
12364 args.write(oprot_);
12365
12366 oprot_->writeMessageEnd();
12367 oprot_->getTransport()->writeEnd();
12368 oprot_->getTransport()->flush();
12369 }
12370
12371 void HbaseClient::recv_mutateRowTs()
12372 {
12373
12374 int32_t rseqid = 0;
12375 std::string fname;
12376 ::apache::thrift::protocol::TMessageType mtype;
12377
12378 iprot_->readMessageBegin(fname, mtype, rseqid);
12379 if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
12380 ::apache::thrift::TApplicationException x;
12381 x.read(iprot_);
12382 iprot_->readMessageEnd();
12383 iprot_->getTransport()->readEnd();
12384 throw x;
12385 }
12386 if (mtype != ::apache::thrift::protocol::T_REPLY) {
12387 iprot_->skip(::apache::thrift::protocol::T_STRUCT);
12388 iprot_->readMessageEnd();
12389 iprot_->getTransport()->readEnd();
12390 }
12391 if (fname.compare("mutateRowTs") != 0) {
12392 iprot_->skip(::apache::thrift::protocol::T_STRUCT);
12393 iprot_->readMessageEnd();
12394 iprot_->getTransport()->readEnd();
12395 }
12396 Hbase_mutateRowTs_presult result;
12397 result.read(iprot_);
12398 iprot_->readMessageEnd();
12399 iprot_->getTransport()->readEnd();
12400
12401 if (result.__isset.io) {
12402 throw result.io;
12403 }
12404 if (result.__isset.ia) {
12405 throw result.ia;
12406 }
12407 return;
12408 }
12409
12410 void HbaseClient::mutateRows(const Text& tableName, const std::vector<BatchMutation> & rowBatches, const std::map<Text, Text> & attributes)
12411 {
12412 send_mutateRows(tableName, rowBatches, attributes);
12413 recv_mutateRows();
12414 }
12415
12416 void HbaseClient::send_mutateRows(const Text& tableName, const std::vector<BatchMutation> & rowBatches, const std::map<Text, Text> & attributes)
12417 {
12418 int32_t cseqid = 0;
12419 oprot_->writeMessageBegin("mutateRows", ::apache::thrift::protocol::T_CALL, cseqid);
12420
12421 Hbase_mutateRows_pargs args;
12422 args.tableName = &tableName;
12423 args.rowBatches = &rowBatches;
12424 args.attributes = &attributes;
12425 args.write(oprot_);
12426
12427 oprot_->writeMessageEnd();
12428 oprot_->getTransport()->writeEnd();
12429 oprot_->getTransport()->flush();
12430 }
12431
12432 void HbaseClient::recv_mutateRows()
12433 {
12434
12435 int32_t rseqid = 0;
12436 std::string fname;
12437 ::apache::thrift::protocol::TMessageType mtype;
12438
12439 iprot_->readMessageBegin(fname, mtype, rseqid);
12440 if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
12441 ::apache::thrift::TApplicationException x;
12442 x.read(iprot_);
12443 iprot_->readMessageEnd();
12444 iprot_->getTransport()->readEnd();
12445 throw x;
12446 }
12447 if (mtype != ::apache::thrift::protocol::T_REPLY) {
12448 iprot_->skip(::apache::thrift::protocol::T_STRUCT);
12449 iprot_->readMessageEnd();
12450 iprot_->getTransport()->readEnd();
12451 }
12452 if (fname.compare("mutateRows") != 0) {
12453 iprot_->skip(::apache::thrift::protocol::T_STRUCT);
12454 iprot_->readMessageEnd();
12455 iprot_->getTransport()->readEnd();
12456 }
12457 Hbase_mutateRows_presult result;
12458 result.read(iprot_);
12459 iprot_->readMessageEnd();
12460 iprot_->getTransport()->readEnd();
12461
12462 if (result.__isset.io) {
12463 throw result.io;
12464 }
12465 if (result.__isset.ia) {
12466 throw result.ia;
12467 }
12468 return;
12469 }
12470
12471 void HbaseClient::mutateRowsTs(const Text& tableName, const std::vector<BatchMutation> & rowBatches, const int64_t timestamp, const std::map<Text, Text> & attributes)
12472 {
12473 send_mutateRowsTs(tableName, rowBatches, timestamp, attributes);
12474 recv_mutateRowsTs();
12475 }
12476
12477 void HbaseClient::send_mutateRowsTs(const Text& tableName, const std::vector<BatchMutation> & rowBatches, const int64_t timestamp, const std::map<Text, Text> & attributes)
12478 {
12479 int32_t cseqid = 0;
12480 oprot_->writeMessageBegin("mutateRowsTs", ::apache::thrift::protocol::T_CALL, cseqid);
12481
12482 Hbase_mutateRowsTs_pargs args;
12483 args.tableName = &tableName;
12484 args.rowBatches = &rowBatches;
12485 args.timestamp = &timestamp;
12486 args.attributes = &attributes;
12487 args.write(oprot_);
12488
12489 oprot_->writeMessageEnd();
12490 oprot_->getTransport()->writeEnd();
12491 oprot_->getTransport()->flush();
12492 }
12493
12494 void HbaseClient::recv_mutateRowsTs()
12495 {
12496
12497 int32_t rseqid = 0;
12498 std::string fname;
12499 ::apache::thrift::protocol::TMessageType mtype;
12500
12501 iprot_->readMessageBegin(fname, mtype, rseqid);
12502 if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
12503 ::apache::thrift::TApplicationException x;
12504 x.read(iprot_);
12505 iprot_->readMessageEnd();
12506 iprot_->getTransport()->readEnd();
12507 throw x;
12508 }
12509 if (mtype != ::apache::thrift::protocol::T_REPLY) {
12510 iprot_->skip(::apache::thrift::protocol::T_STRUCT);
12511 iprot_->readMessageEnd();
12512 iprot_->getTransport()->readEnd();
12513 }
12514 if (fname.compare("mutateRowsTs") != 0) {
12515 iprot_->skip(::apache::thrift::protocol::T_STRUCT);
12516 iprot_->readMessageEnd();
12517 iprot_->getTransport()->readEnd();
12518 }
12519 Hbase_mutateRowsTs_presult result;
12520 result.read(iprot_);
12521 iprot_->readMessageEnd();
12522 iprot_->getTransport()->readEnd();
12523
12524 if (result.__isset.io) {
12525 throw result.io;
12526 }
12527 if (result.__isset.ia) {
12528 throw result.ia;
12529 }
12530 return;
12531 }
12532
12533 int64_t HbaseClient::atomicIncrement(const Text& tableName, const Text& row, const Text& column, const int64_t value)
12534 {
12535 send_atomicIncrement(tableName, row, column, value);
12536 return recv_atomicIncrement();
12537 }
12538
12539 void HbaseClient::send_atomicIncrement(const Text& tableName, const Text& row, const Text& column, const int64_t value)
12540 {
12541 int32_t cseqid = 0;
12542 oprot_->writeMessageBegin("atomicIncrement", ::apache::thrift::protocol::T_CALL, cseqid);
12543
12544 Hbase_atomicIncrement_pargs args;
12545 args.tableName = &tableName;
12546 args.row = &row;
12547 args.column = &column;
12548 args.value = &value;
12549 args.write(oprot_);
12550
12551 oprot_->writeMessageEnd();
12552 oprot_->getTransport()->writeEnd();
12553 oprot_->getTransport()->flush();
12554 }
12555
12556 int64_t HbaseClient::recv_atomicIncrement()
12557 {
12558
12559 int32_t rseqid = 0;
12560 std::string fname;
12561 ::apache::thrift::protocol::TMessageType mtype;
12562
12563 iprot_->readMessageBegin(fname, mtype, rseqid);
12564 if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
12565 ::apache::thrift::TApplicationException x;
12566 x.read(iprot_);
12567 iprot_->readMessageEnd();
12568 iprot_->getTransport()->readEnd();
12569 throw x;
12570 }
12571 if (mtype != ::apache::thrift::protocol::T_REPLY) {
12572 iprot_->skip(::apache::thrift::protocol::T_STRUCT);
12573 iprot_->readMessageEnd();
12574 iprot_->getTransport()->readEnd();
12575 }
12576 if (fname.compare("atomicIncrement") != 0) {
12577 iprot_->skip(::apache::thrift::protocol::T_STRUCT);
12578 iprot_->readMessageEnd();
12579 iprot_->getTransport()->readEnd();
12580 }
12581 int64_t _return;
12582 Hbase_atomicIncrement_presult result;
12583 result.success = &_return;
12584 result.read(iprot_);
12585 iprot_->readMessageEnd();
12586 iprot_->getTransport()->readEnd();
12587
12588 if (result.__isset.success) {
12589 return _return;
12590 }
12591 if (result.__isset.io) {
12592 throw result.io;
12593 }
12594 if (result.__isset.ia) {
12595 throw result.ia;
12596 }
12597 throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "atomicIncrement failed: unknown result");
12598 }
12599
12600 void HbaseClient::deleteAll(const Text& tableName, const Text& row, const Text& column, const std::map<Text, Text> & attributes)
12601 {
12602 send_deleteAll(tableName, row, column, attributes);
12603 recv_deleteAll();
12604 }
12605
12606 void HbaseClient::send_deleteAll(const Text& tableName, const Text& row, const Text& column, const std::map<Text, Text> & attributes)
12607 {
12608 int32_t cseqid = 0;
12609 oprot_->writeMessageBegin("deleteAll", ::apache::thrift::protocol::T_CALL, cseqid);
12610
12611 Hbase_deleteAll_pargs args;
12612 args.tableName = &tableName;
12613 args.row = &row;
12614 args.column = &column;
12615 args.attributes = &attributes;
12616 args.write(oprot_);
12617
12618 oprot_->writeMessageEnd();
12619 oprot_->getTransport()->writeEnd();
12620 oprot_->getTransport()->flush();
12621 }
12622
12623 void HbaseClient::recv_deleteAll()
12624 {
12625
12626 int32_t rseqid = 0;
12627 std::string fname;
12628 ::apache::thrift::protocol::TMessageType mtype;
12629
12630 iprot_->readMessageBegin(fname, mtype, rseqid);
12631 if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
12632 ::apache::thrift::TApplicationException x;
12633 x.read(iprot_);
12634 iprot_->readMessageEnd();
12635 iprot_->getTransport()->readEnd();
12636 throw x;
12637 }
12638 if (mtype != ::apache::thrift::protocol::T_REPLY) {
12639 iprot_->skip(::apache::thrift::protocol::T_STRUCT);
12640 iprot_->readMessageEnd();
12641 iprot_->getTransport()->readEnd();
12642 }
12643 if (fname.compare("deleteAll") != 0) {
12644 iprot_->skip(::apache::thrift::protocol::T_STRUCT);
12645 iprot_->readMessageEnd();
12646 iprot_->getTransport()->readEnd();
12647 }
12648 Hbase_deleteAll_presult result;
12649 result.read(iprot_);
12650 iprot_->readMessageEnd();
12651 iprot_->getTransport()->readEnd();
12652
12653 if (result.__isset.io) {
12654 throw result.io;
12655 }
12656 return;
12657 }
12658
12659 void HbaseClient::deleteAllTs(const Text& tableName, const Text& row, const Text& column, const int64_t timestamp, const std::map<Text, Text> & attributes)
12660 {
12661 send_deleteAllTs(tableName, row, column, timestamp, attributes);
12662 recv_deleteAllTs();
12663 }
12664
12665 void HbaseClient::send_deleteAllTs(const Text& tableName, const Text& row, const Text& column, const int64_t timestamp, const std::map<Text, Text> & attributes)
12666 {
12667 int32_t cseqid = 0;
12668 oprot_->writeMessageBegin("deleteAllTs", ::apache::thrift::protocol::T_CALL, cseqid);
12669
12670 Hbase_deleteAllTs_pargs args;
12671 args.tableName = &tableName;
12672 args.row = &row;
12673 args.column = &column;
12674 args.timestamp = &timestamp;
12675 args.attributes = &attributes;
12676 args.write(oprot_);
12677
12678 oprot_->writeMessageEnd();
12679 oprot_->getTransport()->writeEnd();
12680 oprot_->getTransport()->flush();
12681 }
12682
12683 void HbaseClient::recv_deleteAllTs()
12684 {
12685
12686 int32_t rseqid = 0;
12687 std::string fname;
12688 ::apache::thrift::protocol::TMessageType mtype;
12689
12690 iprot_->readMessageBegin(fname, mtype, rseqid);
12691 if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
12692 ::apache::thrift::TApplicationException x;
12693 x.read(iprot_);
12694 iprot_->readMessageEnd();
12695 iprot_->getTransport()->readEnd();
12696 throw x;
12697 }
12698 if (mtype != ::apache::thrift::protocol::T_REPLY) {
12699 iprot_->skip(::apache::thrift::protocol::T_STRUCT);
12700 iprot_->readMessageEnd();
12701 iprot_->getTransport()->readEnd();
12702 }
12703 if (fname.compare("deleteAllTs") != 0) {
12704 iprot_->skip(::apache::thrift::protocol::T_STRUCT);
12705 iprot_->readMessageEnd();
12706 iprot_->getTransport()->readEnd();
12707 }
12708 Hbase_deleteAllTs_presult result;
12709 result.read(iprot_);
12710 iprot_->readMessageEnd();
12711 iprot_->getTransport()->readEnd();
12712
12713 if (result.__isset.io) {
12714 throw result.io;
12715 }
12716 return;
12717 }
12718
12719 void HbaseClient::deleteAllRow(const Text& tableName, const Text& row, const std::map<Text, Text> & attributes)
12720 {
12721 send_deleteAllRow(tableName, row, attributes);
12722 recv_deleteAllRow();
12723 }
12724
12725 void HbaseClient::send_deleteAllRow(const Text& tableName, const Text& row, const std::map<Text, Text> & attributes)
12726 {
12727 int32_t cseqid = 0;
12728 oprot_->writeMessageBegin("deleteAllRow", ::apache::thrift::protocol::T_CALL, cseqid);
12729
12730 Hbase_deleteAllRow_pargs args;
12731 args.tableName = &tableName;
12732 args.row = &row;
12733 args.attributes = &attributes;
12734 args.write(oprot_);
12735
12736 oprot_->writeMessageEnd();
12737 oprot_->getTransport()->writeEnd();
12738 oprot_->getTransport()->flush();
12739 }
12740
12741 void HbaseClient::recv_deleteAllRow()
12742 {
12743
12744 int32_t rseqid = 0;
12745 std::string fname;
12746 ::apache::thrift::protocol::TMessageType mtype;
12747
12748 iprot_->readMessageBegin(fname, mtype, rseqid);
12749 if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
12750 ::apache::thrift::TApplicationException x;
12751 x.read(iprot_);
12752 iprot_->readMessageEnd();
12753 iprot_->getTransport()->readEnd();
12754 throw x;
12755 }
12756 if (mtype != ::apache::thrift::protocol::T_REPLY) {
12757 iprot_->skip(::apache::thrift::protocol::T_STRUCT);
12758 iprot_->readMessageEnd();
12759 iprot_->getTransport()->readEnd();
12760 }
12761 if (fname.compare("deleteAllRow") != 0) {
12762 iprot_->skip(::apache::thrift::protocol::T_STRUCT);
12763 iprot_->readMessageEnd();
12764 iprot_->getTransport()->readEnd();
12765 }
12766 Hbase_deleteAllRow_presult result;
12767 result.read(iprot_);
12768 iprot_->readMessageEnd();
12769 iprot_->getTransport()->readEnd();
12770
12771 if (result.__isset.io) {
12772 throw result.io;
12773 }
12774 return;
12775 }
12776
12777 void HbaseClient::increment(const TIncrement& increment)
12778 {
12779 send_increment(increment);
12780 recv_increment();
12781 }
12782
12783 void HbaseClient::send_increment(const TIncrement& increment)
12784 {
12785 int32_t cseqid = 0;
12786 oprot_->writeMessageBegin("increment", ::apache::thrift::protocol::T_CALL, cseqid);
12787
12788 Hbase_increment_pargs args;
12789 args.increment = &increment;
12790 args.write(oprot_);
12791
12792 oprot_->writeMessageEnd();
12793 oprot_->getTransport()->writeEnd();
12794 oprot_->getTransport()->flush();
12795 }
12796
12797 void HbaseClient::recv_increment()
12798 {
12799
12800 int32_t rseqid = 0;
12801 std::string fname;
12802 ::apache::thrift::protocol::TMessageType mtype;
12803
12804 iprot_->readMessageBegin(fname, mtype, rseqid);
12805 if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
12806 ::apache::thrift::TApplicationException x;
12807 x.read(iprot_);
12808 iprot_->readMessageEnd();
12809 iprot_->getTransport()->readEnd();
12810 throw x;
12811 }
12812 if (mtype != ::apache::thrift::protocol::T_REPLY) {
12813 iprot_->skip(::apache::thrift::protocol::T_STRUCT);
12814 iprot_->readMessageEnd();
12815 iprot_->getTransport()->readEnd();
12816 }
12817 if (fname.compare("increment") != 0) {
12818 iprot_->skip(::apache::thrift::protocol::T_STRUCT);
12819 iprot_->readMessageEnd();
12820 iprot_->getTransport()->readEnd();
12821 }
12822 Hbase_increment_presult result;
12823 result.read(iprot_);
12824 iprot_->readMessageEnd();
12825 iprot_->getTransport()->readEnd();
12826
12827 if (result.__isset.io) {
12828 throw result.io;
12829 }
12830 return;
12831 }
12832
12833 void HbaseClient::incrementRows(const std::vector<TIncrement> & increments)
12834 {
12835 send_incrementRows(increments);
12836 recv_incrementRows();
12837 }
12838
12839 void HbaseClient::send_incrementRows(const std::vector<TIncrement> & increments)
12840 {
12841 int32_t cseqid = 0;
12842 oprot_->writeMessageBegin("incrementRows", ::apache::thrift::protocol::T_CALL, cseqid);
12843
12844 Hbase_incrementRows_pargs args;
12845 args.increments = &increments;
12846 args.write(oprot_);
12847
12848 oprot_->writeMessageEnd();
12849 oprot_->getTransport()->writeEnd();
12850 oprot_->getTransport()->flush();
12851 }
12852
12853 void HbaseClient::recv_incrementRows()
12854 {
12855
12856 int32_t rseqid = 0;
12857 std::string fname;
12858 ::apache::thrift::protocol::TMessageType mtype;
12859
12860 iprot_->readMessageBegin(fname, mtype, rseqid);
12861 if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
12862 ::apache::thrift::TApplicationException x;
12863 x.read(iprot_);
12864 iprot_->readMessageEnd();
12865 iprot_->getTransport()->readEnd();
12866 throw x;
12867 }
12868 if (mtype != ::apache::thrift::protocol::T_REPLY) {
12869 iprot_->skip(::apache::thrift::protocol::T_STRUCT);
12870 iprot_->readMessageEnd();
12871 iprot_->getTransport()->readEnd();
12872 }
12873 if (fname.compare("incrementRows") != 0) {
12874 iprot_->skip(::apache::thrift::protocol::T_STRUCT);
12875 iprot_->readMessageEnd();
12876 iprot_->getTransport()->readEnd();
12877 }
12878 Hbase_incrementRows_presult result;
12879 result.read(iprot_);
12880 iprot_->readMessageEnd();
12881 iprot_->getTransport()->readEnd();
12882
12883 if (result.__isset.io) {
12884 throw result.io;
12885 }
12886 return;
12887 }
12888
12889 void HbaseClient::deleteAllRowTs(const Text& tableName, const Text& row, const int64_t timestamp, const std::map<Text, Text> & attributes)
12890 {
12891 send_deleteAllRowTs(tableName, row, timestamp, attributes);
12892 recv_deleteAllRowTs();
12893 }
12894
12895 void HbaseClient::send_deleteAllRowTs(const Text& tableName, const Text& row, const int64_t timestamp, const std::map<Text, Text> & attributes)
12896 {
12897 int32_t cseqid = 0;
12898 oprot_->writeMessageBegin("deleteAllRowTs", ::apache::thrift::protocol::T_CALL, cseqid);
12899
12900 Hbase_deleteAllRowTs_pargs args;
12901 args.tableName = &tableName;
12902 args.row = &row;
12903 args.timestamp = &timestamp;
12904 args.attributes = &attributes;
12905 args.write(oprot_);
12906
12907 oprot_->writeMessageEnd();
12908 oprot_->getTransport()->writeEnd();
12909 oprot_->getTransport()->flush();
12910 }
12911
12912 void HbaseClient::recv_deleteAllRowTs()
12913 {
12914
12915 int32_t rseqid = 0;
12916 std::string fname;
12917 ::apache::thrift::protocol::TMessageType mtype;
12918
12919 iprot_->readMessageBegin(fname, mtype, rseqid);
12920 if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
12921 ::apache::thrift::TApplicationException x;
12922 x.read(iprot_);
12923 iprot_->readMessageEnd();
12924 iprot_->getTransport()->readEnd();
12925 throw x;
12926 }
12927 if (mtype != ::apache::thrift::protocol::T_REPLY) {
12928 iprot_->skip(::apache::thrift::protocol::T_STRUCT);
12929 iprot_->readMessageEnd();
12930 iprot_->getTransport()->readEnd();
12931 }
12932 if (fname.compare("deleteAllRowTs") != 0) {
12933 iprot_->skip(::apache::thrift::protocol::T_STRUCT);
12934 iprot_->readMessageEnd();
12935 iprot_->getTransport()->readEnd();
12936 }
12937 Hbase_deleteAllRowTs_presult result;
12938 result.read(iprot_);
12939 iprot_->readMessageEnd();
12940 iprot_->getTransport()->readEnd();
12941
12942 if (result.__isset.io) {
12943 throw result.io;
12944 }
12945 return;
12946 }
12947
12948 ScannerID HbaseClient::scannerOpenWithScan(const Text& tableName, const TScan& scan, const std::map<Text, Text> & attributes)
12949 {
12950 send_scannerOpenWithScan(tableName, scan, attributes);
12951 return recv_scannerOpenWithScan();
12952 }
12953
12954 void HbaseClient::send_scannerOpenWithScan(const Text& tableName, const TScan& scan, const std::map<Text, Text> & attributes)
12955 {
12956 int32_t cseqid = 0;
12957 oprot_->writeMessageBegin("scannerOpenWithScan", ::apache::thrift::protocol::T_CALL, cseqid);
12958
12959 Hbase_scannerOpenWithScan_pargs args;
12960 args.tableName = &tableName;
12961 args.scan = &scan;
12962 args.attributes = &attributes;
12963 args.write(oprot_);
12964
12965 oprot_->writeMessageEnd();
12966 oprot_->getTransport()->writeEnd();
12967 oprot_->getTransport()->flush();
12968 }
12969
12970 ScannerID HbaseClient::recv_scannerOpenWithScan()
12971 {
12972
12973 int32_t rseqid = 0;
12974 std::string fname;
12975 ::apache::thrift::protocol::TMessageType mtype;
12976
12977 iprot_->readMessageBegin(fname, mtype, rseqid);
12978 if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
12979 ::apache::thrift::TApplicationException x;
12980 x.read(iprot_);
12981 iprot_->readMessageEnd();
12982 iprot_->getTransport()->readEnd();
12983 throw x;
12984 }
12985 if (mtype != ::apache::thrift::protocol::T_REPLY) {
12986 iprot_->skip(::apache::thrift::protocol::T_STRUCT);
12987 iprot_->readMessageEnd();
12988 iprot_->getTransport()->readEnd();
12989 }
12990 if (fname.compare("scannerOpenWithScan") != 0) {
12991 iprot_->skip(::apache::thrift::protocol::T_STRUCT);
12992 iprot_->readMessageEnd();
12993 iprot_->getTransport()->readEnd();
12994 }
12995 ScannerID _return;
12996 Hbase_scannerOpenWithScan_presult result;
12997 result.success = &_return;
12998 result.read(iprot_);
12999 iprot_->readMessageEnd();
13000 iprot_->getTransport()->readEnd();
13001
13002 if (result.__isset.success) {
13003 return _return;
13004 }
13005 if (result.__isset.io) {
13006 throw result.io;
13007 }
13008 throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "scannerOpenWithScan failed: unknown result");
13009 }
13010
13011 ScannerID HbaseClient::scannerOpen(const Text& tableName, const Text& startRow, const std::vector<Text> & columns, const std::map<Text, Text> & attributes)
13012 {
13013 send_scannerOpen(tableName, startRow, columns, attributes);
13014 return recv_scannerOpen();
13015 }
13016
13017 void HbaseClient::send_scannerOpen(const Text& tableName, const Text& startRow, const std::vector<Text> & columns, const std::map<Text, Text> & attributes)
13018 {
13019 int32_t cseqid = 0;
13020 oprot_->writeMessageBegin("scannerOpen", ::apache::thrift::protocol::T_CALL, cseqid);
13021
13022 Hbase_scannerOpen_pargs args;
13023 args.tableName = &tableName;
13024 args.startRow = &startRow;
13025 args.columns = &columns;
13026 args.attributes = &attributes;
13027 args.write(oprot_);
13028
13029 oprot_->writeMessageEnd();
13030 oprot_->getTransport()->writeEnd();
13031 oprot_->getTransport()->flush();
13032 }
13033
13034 ScannerID HbaseClient::recv_scannerOpen()
13035 {
13036
13037 int32_t rseqid = 0;
13038 std::string fname;
13039 ::apache::thrift::protocol::TMessageType mtype;
13040
13041 iprot_->readMessageBegin(fname, mtype, rseqid);
13042 if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
13043 ::apache::thrift::TApplicationException x;
13044 x.read(iprot_);
13045 iprot_->readMessageEnd();
13046 iprot_->getTransport()->readEnd();
13047 throw x;
13048 }
13049 if (mtype != ::apache::thrift::protocol::T_REPLY) {
13050 iprot_->skip(::apache::thrift::protocol::T_STRUCT);
13051 iprot_->readMessageEnd();
13052 iprot_->getTransport()->readEnd();
13053 }
13054 if (fname.compare("scannerOpen") != 0) {
13055 iprot_->skip(::apache::thrift::protocol::T_STRUCT);
13056 iprot_->readMessageEnd();
13057 iprot_->getTransport()->readEnd();
13058 }
13059 ScannerID _return;
13060 Hbase_scannerOpen_presult result;
13061 result.success = &_return;
13062 result.read(iprot_);
13063 iprot_->readMessageEnd();
13064 iprot_->getTransport()->readEnd();
13065
13066 if (result.__isset.success) {
13067 return _return;
13068 }
13069 if (result.__isset.io) {
13070 throw result.io;
13071 }
13072 throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "scannerOpen failed: unknown result");
13073 }
13074
13075 ScannerID HbaseClient::scannerOpenWithStop(const Text& tableName, const Text& startRow, const Text& stopRow, const std::vector<Text> & columns, const std::map<Text, Text> & attributes)
13076 {
13077 send_scannerOpenWithStop(tableName, startRow, stopRow, columns, attributes);
13078 return recv_scannerOpenWithStop();
13079 }
13080
13081 void HbaseClient::send_scannerOpenWithStop(const Text& tableName, const Text& startRow, const Text& stopRow, const std::vector<Text> & columns, const std::map<Text, Text> & attributes)
13082 {
13083 int32_t cseqid = 0;
13084 oprot_->writeMessageBegin("scannerOpenWithStop", ::apache::thrift::protocol::T_CALL, cseqid);
13085
13086 Hbase_scannerOpenWithStop_pargs args;
13087 args.tableName = &tableName;
13088 args.startRow = &startRow;
13089 args.stopRow = &stopRow;
13090 args.columns = &columns;
13091 args.attributes = &attributes;
13092 args.write(oprot_);
13093
13094 oprot_->writeMessageEnd();
13095 oprot_->getTransport()->writeEnd();
13096 oprot_->getTransport()->flush();
13097 }
13098
13099 ScannerID HbaseClient::recv_scannerOpenWithStop()
13100 {
13101
13102 int32_t rseqid = 0;
13103 std::string fname;
13104 ::apache::thrift::protocol::TMessageType mtype;
13105
13106 iprot_->readMessageBegin(fname, mtype, rseqid);
13107 if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
13108 ::apache::thrift::TApplicationException x;
13109 x.read(iprot_);
13110 iprot_->readMessageEnd();
13111 iprot_->getTransport()->readEnd();
13112 throw x;
13113 }
13114 if (mtype != ::apache::thrift::protocol::T_REPLY) {
13115 iprot_->skip(::apache::thrift::protocol::T_STRUCT);
13116 iprot_->readMessageEnd();
13117 iprot_->getTransport()->readEnd();
13118 }
13119 if (fname.compare("scannerOpenWithStop") != 0) {
13120 iprot_->skip(::apache::thrift::protocol::T_STRUCT);
13121 iprot_->readMessageEnd();
13122 iprot_->getTransport()->readEnd();
13123 }
13124 ScannerID _return;
13125 Hbase_scannerOpenWithStop_presult result;
13126 result.success = &_return;
13127 result.read(iprot_);
13128 iprot_->readMessageEnd();
13129 iprot_->getTransport()->readEnd();
13130
13131 if (result.__isset.success) {
13132 return _return;
13133 }
13134 if (result.__isset.io) {
13135 throw result.io;
13136 }
13137 throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "scannerOpenWithStop failed: unknown result");
13138 }
13139
13140 ScannerID HbaseClient::scannerOpenWithPrefix(const Text& tableName, const Text& startAndPrefix, const std::vector<Text> & columns, const std::map<Text, Text> & attributes)
13141 {
13142 send_scannerOpenWithPrefix(tableName, startAndPrefix, columns, attributes);
13143 return recv_scannerOpenWithPrefix();
13144 }
13145
13146 void HbaseClient::send_scannerOpenWithPrefix(const Text& tableName, const Text& startAndPrefix, const std::vector<Text> & columns, const std::map<Text, Text> & attributes)
13147 {
13148 int32_t cseqid = 0;
13149 oprot_->writeMessageBegin("scannerOpenWithPrefix", ::apache::thrift::protocol::T_CALL, cseqid);
13150
13151 Hbase_scannerOpenWithPrefix_pargs args;
13152 args.tableName = &tableName;
13153 args.startAndPrefix = &startAndPrefix;
13154 args.columns = &columns;
13155 args.attributes = &attributes;
13156 args.write(oprot_);
13157
13158 oprot_->writeMessageEnd();
13159 oprot_->getTransport()->writeEnd();
13160 oprot_->getTransport()->flush();
13161 }
13162
13163 ScannerID HbaseClient::recv_scannerOpenWithPrefix()
13164 {
13165
13166 int32_t rseqid = 0;
13167 std::string fname;
13168 ::apache::thrift::protocol::TMessageType mtype;
13169
13170 iprot_->readMessageBegin(fname, mtype, rseqid);
13171 if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
13172 ::apache::thrift::TApplicationException x;
13173 x.read(iprot_);
13174 iprot_->readMessageEnd();
13175 iprot_->getTransport()->readEnd();
13176 throw x;
13177 }
13178 if (mtype != ::apache::thrift::protocol::T_REPLY) {
13179 iprot_->skip(::apache::thrift::protocol::T_STRUCT);
13180 iprot_->readMessageEnd();
13181 iprot_->getTransport()->readEnd();
13182 }
13183 if (fname.compare("scannerOpenWithPrefix") != 0) {
13184 iprot_->skip(::apache::thrift::protocol::T_STRUCT);
13185 iprot_->readMessageEnd();
13186 iprot_->getTransport()->readEnd();
13187 }
13188 ScannerID _return;
13189 Hbase_scannerOpenWithPrefix_presult result;
13190 result.success = &_return;
13191 result.read(iprot_);
13192 iprot_->readMessageEnd();
13193 iprot_->getTransport()->readEnd();
13194
13195 if (result.__isset.success) {
13196 return _return;
13197 }
13198 if (result.__isset.io) {
13199 throw result.io;
13200 }
13201 throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "scannerOpenWithPrefix failed: unknown result");
13202 }
13203
13204 ScannerID HbaseClient::scannerOpenTs(const Text& tableName, const Text& startRow, const std::vector<Text> & columns, const int64_t timestamp, const std::map<Text, Text> & attributes)
13205 {
13206 send_scannerOpenTs(tableName, startRow, columns, timestamp, attributes);
13207 return recv_scannerOpenTs();
13208 }
13209
13210 void HbaseClient::send_scannerOpenTs(const Text& tableName, const Text& startRow, const std::vector<Text> & columns, const int64_t timestamp, const std::map<Text, Text> & attributes)
13211 {
13212 int32_t cseqid = 0;
13213 oprot_->writeMessageBegin("scannerOpenTs", ::apache::thrift::protocol::T_CALL, cseqid);
13214
13215 Hbase_scannerOpenTs_pargs args;
13216 args.tableName = &tableName;
13217 args.startRow = &startRow;
13218 args.columns = &columns;
13219 args.timestamp = &timestamp;
13220 args.attributes = &attributes;
13221 args.write(oprot_);
13222
13223 oprot_->writeMessageEnd();
13224 oprot_->getTransport()->writeEnd();
13225 oprot_->getTransport()->flush();
13226 }
13227
13228 ScannerID HbaseClient::recv_scannerOpenTs()
13229 {
13230
13231 int32_t rseqid = 0;
13232 std::string fname;
13233 ::apache::thrift::protocol::TMessageType mtype;
13234
13235 iprot_->readMessageBegin(fname, mtype, rseqid);
13236 if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
13237 ::apache::thrift::TApplicationException x;
13238 x.read(iprot_);
13239 iprot_->readMessageEnd();
13240 iprot_->getTransport()->readEnd();
13241 throw x;
13242 }
13243 if (mtype != ::apache::thrift::protocol::T_REPLY) {
13244 iprot_->skip(::apache::thrift::protocol::T_STRUCT);
13245 iprot_->readMessageEnd();
13246 iprot_->getTransport()->readEnd();
13247 }
13248 if (fname.compare("scannerOpenTs") != 0) {
13249 iprot_->skip(::apache::thrift::protocol::T_STRUCT);
13250 iprot_->readMessageEnd();
13251 iprot_->getTransport()->readEnd();
13252 }
13253 ScannerID _return;
13254 Hbase_scannerOpenTs_presult result;
13255 result.success = &_return;
13256 result.read(iprot_);
13257 iprot_->readMessageEnd();
13258 iprot_->getTransport()->readEnd();
13259
13260 if (result.__isset.success) {
13261 return _return;
13262 }
13263 if (result.__isset.io) {
13264 throw result.io;
13265 }
13266 throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "scannerOpenTs failed: unknown result");
13267 }
13268
13269 ScannerID HbaseClient::scannerOpenWithStopTs(const Text& tableName, const Text& startRow, const Text& stopRow, const std::vector<Text> & columns, const int64_t timestamp, const std::map<Text, Text> & attributes)
13270 {
13271 send_scannerOpenWithStopTs(tableName, startRow, stopRow, columns, timestamp, attributes);
13272 return recv_scannerOpenWithStopTs();
13273 }
13274
13275 void HbaseClient::send_scannerOpenWithStopTs(const Text& tableName, const Text& startRow, const Text& stopRow, const std::vector<Text> & columns, const int64_t timestamp, const std::map<Text, Text> & attributes)
13276 {
13277 int32_t cseqid = 0;
13278 oprot_->writeMessageBegin("scannerOpenWithStopTs", ::apache::thrift::protocol::T_CALL, cseqid);
13279
13280 Hbase_scannerOpenWithStopTs_pargs args;
13281 args.tableName = &tableName;
13282 args.startRow = &startRow;
13283 args.stopRow = &stopRow;
13284 args.columns = &columns;
13285 args.timestamp = &timestamp;
13286 args.attributes = &attributes;
13287 args.write(oprot_);
13288
13289 oprot_->writeMessageEnd();
13290 oprot_->getTransport()->writeEnd();
13291 oprot_->getTransport()->flush();
13292 }
13293
13294 ScannerID HbaseClient::recv_scannerOpenWithStopTs()
13295 {
13296
13297 int32_t rseqid = 0;
13298 std::string fname;
13299 ::apache::thrift::protocol::TMessageType mtype;
13300
13301 iprot_->readMessageBegin(fname, mtype, rseqid);
13302 if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
13303 ::apache::thrift::TApplicationException x;
13304 x.read(iprot_);
13305 iprot_->readMessageEnd();
13306 iprot_->getTransport()->readEnd();
13307 throw x;
13308 }
13309 if (mtype != ::apache::thrift::protocol::T_REPLY) {
13310 iprot_->skip(::apache::thrift::protocol::T_STRUCT);
13311 iprot_->readMessageEnd();
13312 iprot_->getTransport()->readEnd();
13313 }
13314 if (fname.compare("scannerOpenWithStopTs") != 0) {
13315 iprot_->skip(::apache::thrift::protocol::T_STRUCT);
13316 iprot_->readMessageEnd();
13317 iprot_->getTransport()->readEnd();
13318 }
13319 ScannerID _return;
13320 Hbase_scannerOpenWithStopTs_presult result;
13321 result.success = &_return;
13322 result.read(iprot_);
13323 iprot_->readMessageEnd();
13324 iprot_->getTransport()->readEnd();
13325
13326 if (result.__isset.success) {
13327 return _return;
13328 }
13329 if (result.__isset.io) {
13330 throw result.io;
13331 }
13332 throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "scannerOpenWithStopTs failed: unknown result");
13333 }
13334
13335 void HbaseClient::scannerGet(std::vector<TRowResult> & _return, const ScannerID id)
13336 {
13337 send_scannerGet(id);
13338 recv_scannerGet(_return);
13339 }
13340
13341 void HbaseClient::send_scannerGet(const ScannerID id)
13342 {
13343 int32_t cseqid = 0;
13344 oprot_->writeMessageBegin("scannerGet", ::apache::thrift::protocol::T_CALL, cseqid);
13345
13346 Hbase_scannerGet_pargs args;
13347 args.id = &id;
13348 args.write(oprot_);
13349
13350 oprot_->writeMessageEnd();
13351 oprot_->getTransport()->writeEnd();
13352 oprot_->getTransport()->flush();
13353 }
13354
13355 void HbaseClient::recv_scannerGet(std::vector<TRowResult> & _return)
13356 {
13357
13358 int32_t rseqid = 0;
13359 std::string fname;
13360 ::apache::thrift::protocol::TMessageType mtype;
13361
13362 iprot_->readMessageBegin(fname, mtype, rseqid);
13363 if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
13364 ::apache::thrift::TApplicationException x;
13365 x.read(iprot_);
13366 iprot_->readMessageEnd();
13367 iprot_->getTransport()->readEnd();
13368 throw x;
13369 }
13370 if (mtype != ::apache::thrift::protocol::T_REPLY) {
13371 iprot_->skip(::apache::thrift::protocol::T_STRUCT);
13372 iprot_->readMessageEnd();
13373 iprot_->getTransport()->readEnd();
13374 }
13375 if (fname.compare("scannerGet") != 0) {
13376 iprot_->skip(::apache::thrift::protocol::T_STRUCT);
13377 iprot_->readMessageEnd();
13378 iprot_->getTransport()->readEnd();
13379 }
13380 Hbase_scannerGet_presult result;
13381 result.success = &_return;
13382 result.read(iprot_);
13383 iprot_->readMessageEnd();
13384 iprot_->getTransport()->readEnd();
13385
13386 if (result.__isset.success) {
13387 // _return pointer has now been filled
13388 return;
13389 }
13390 if (result.__isset.io) {
13391 throw result.io;
13392 }
13393 if (result.__isset.ia) {
13394 throw result.ia;
13395 }
13396 throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "scannerGet failed: unknown result");
13397 }
13398
13399 void HbaseClient::scannerGetList(std::vector<TRowResult> & _return, const ScannerID id, const int32_t nbRows)
13400 {
13401 send_scannerGetList(id, nbRows);
13402 recv_scannerGetList(_return);
13403 }
13404
13405 void HbaseClient::send_scannerGetList(const ScannerID id, const int32_t nbRows)
13406 {
13407 int32_t cseqid = 0;
13408 oprot_->writeMessageBegin("scannerGetList", ::apache::thrift::protocol::T_CALL, cseqid);
13409
13410 Hbase_scannerGetList_pargs args;
13411 args.id = &id;
13412 args.nbRows = &nbRows;
13413 args.write(oprot_);
13414
13415 oprot_->writeMessageEnd();
13416 oprot_->getTransport()->writeEnd();
13417 oprot_->getTransport()->flush();
13418 }
13419
13420 void HbaseClient::recv_scannerGetList(std::vector<TRowResult> & _return)
13421 {
13422
13423 int32_t rseqid = 0;
13424 std::string fname;
13425 ::apache::thrift::protocol::TMessageType mtype;
13426
13427 iprot_->readMessageBegin(fname, mtype, rseqid);
13428 if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
13429 ::apache::thrift::TApplicationException x;
13430 x.read(iprot_);
13431 iprot_->readMessageEnd();
13432 iprot_->getTransport()->readEnd();
13433 throw x;
13434 }
13435 if (mtype != ::apache::thrift::protocol::T_REPLY) {
13436 iprot_->skip(::apache::thrift::protocol::T_STRUCT);
13437 iprot_->readMessageEnd();
13438 iprot_->getTransport()->readEnd();
13439 }
13440 if (fname.compare("scannerGetList") != 0) {
13441 iprot_->skip(::apache::thrift::protocol::T_STRUCT);
13442 iprot_->readMessageEnd();
13443 iprot_->getTransport()->readEnd();
13444 }
13445 Hbase_scannerGetList_presult result;
13446 result.success = &_return;
13447 result.read(iprot_);
13448 iprot_->readMessageEnd();
13449 iprot_->getTransport()->readEnd();
13450
13451 if (result.__isset.success) {
13452 // _return pointer has now been filled
13453 return;
13454 }
13455 if (result.__isset.io) {
13456 throw result.io;
13457 }
13458 if (result.__isset.ia) {
13459 throw result.ia;
13460 }
13461 throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "scannerGetList failed: unknown result");
13462 }
13463
13464 void HbaseClient::scannerClose(const ScannerID id)
13465 {
13466 send_scannerClose(id);
13467 recv_scannerClose();
13468 }
13469
13470 void HbaseClient::send_scannerClose(const ScannerID id)
13471 {
13472 int32_t cseqid = 0;
13473 oprot_->writeMessageBegin("scannerClose", ::apache::thrift::protocol::T_CALL, cseqid);
13474
13475 Hbase_scannerClose_pargs args;
13476 args.id = &id;
13477 args.write(oprot_);
13478
13479 oprot_->writeMessageEnd();
13480 oprot_->getTransport()->writeEnd();
13481 oprot_->getTransport()->flush();
13482 }
13483
13484 void HbaseClient::recv_scannerClose()
13485 {
13486
13487 int32_t rseqid = 0;
13488 std::string fname;
13489 ::apache::thrift::protocol::TMessageType mtype;
13490
13491 iprot_->readMessageBegin(fname, mtype, rseqid);
13492 if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
13493 ::apache::thrift::TApplicationException x;
13494 x.read(iprot_);
13495 iprot_->readMessageEnd();
13496 iprot_->getTransport()->readEnd();
13497 throw x;
13498 }
13499 if (mtype != ::apache::thrift::protocol::T_REPLY) {
13500 iprot_->skip(::apache::thrift::protocol::T_STRUCT);
13501 iprot_->readMessageEnd();
13502 iprot_->getTransport()->readEnd();
13503 }
13504 if (fname.compare("scannerClose") != 0) {
13505 iprot_->skip(::apache::thrift::protocol::T_STRUCT);
13506 iprot_->readMessageEnd();
13507 iprot_->getTransport()->readEnd();
13508 }
13509 Hbase_scannerClose_presult result;
13510 result.read(iprot_);
13511 iprot_->readMessageEnd();
13512 iprot_->getTransport()->readEnd();
13513
13514 if (result.__isset.io) {
13515 throw result.io;
13516 }
13517 if (result.__isset.ia) {
13518 throw result.ia;
13519 }
13520 return;
13521 }
13522
13523 void HbaseClient::getRowOrBefore(std::vector<TCell> & _return, const Text& tableName, const Text& row, const Text& family)
13524 {
13525 send_getRowOrBefore(tableName, row, family);
13526 recv_getRowOrBefore(_return);
13527 }
13528
13529 void HbaseClient::send_getRowOrBefore(const Text& tableName, const Text& row, const Text& family)
13530 {
13531 int32_t cseqid = 0;
13532 oprot_->writeMessageBegin("getRowOrBefore", ::apache::thrift::protocol::T_CALL, cseqid);
13533
13534 Hbase_getRowOrBefore_pargs args;
13535 args.tableName = &tableName;
13536 args.row = &row;
13537 args.family = &family;
13538 args.write(oprot_);
13539
13540 oprot_->writeMessageEnd();
13541 oprot_->getTransport()->writeEnd();
13542 oprot_->getTransport()->flush();
13543 }
13544
13545 void HbaseClient::recv_getRowOrBefore(std::vector<TCell> & _return)
13546 {
13547
13548 int32_t rseqid = 0;
13549 std::string fname;
13550 ::apache::thrift::protocol::TMessageType mtype;
13551
13552 iprot_->readMessageBegin(fname, mtype, rseqid);
13553 if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
13554 ::apache::thrift::TApplicationException x;
13555 x.read(iprot_);
13556 iprot_->readMessageEnd();
13557 iprot_->getTransport()->readEnd();
13558 throw x;
13559 }
13560 if (mtype != ::apache::thrift::protocol::T_REPLY) {
13561 iprot_->skip(::apache::thrift::protocol::T_STRUCT);
13562 iprot_->readMessageEnd();
13563 iprot_->getTransport()->readEnd();
13564 }
13565 if (fname.compare("getRowOrBefore") != 0) {
13566 iprot_->skip(::apache::thrift::protocol::T_STRUCT);
13567 iprot_->readMessageEnd();
13568 iprot_->getTransport()->readEnd();
13569 }
13570 Hbase_getRowOrBefore_presult result;
13571 result.success = &_return;
13572 result.read(iprot_);
13573 iprot_->readMessageEnd();
13574 iprot_->getTransport()->readEnd();
13575
13576 if (result.__isset.success) {
13577 // _return pointer has now been filled
13578 return;
13579 }
13580 if (result.__isset.io) {
13581 throw result.io;
13582 }
13583 throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getRowOrBefore failed: unknown result");
13584 }
13585
13586 void HbaseClient::getRegionInfo(TRegionInfo& _return, const Text& row)
13587 {
13588 send_getRegionInfo(row);
13589 recv_getRegionInfo(_return);
13590 }
13591
13592 void HbaseClient::send_getRegionInfo(const Text& row)
13593 {
13594 int32_t cseqid = 0;
13595 oprot_->writeMessageBegin("getRegionInfo", ::apache::thrift::protocol::T_CALL, cseqid);
13596
13597 Hbase_getRegionInfo_pargs args;
13598 args.row = &row;
13599 args.write(oprot_);
13600
13601 oprot_->writeMessageEnd();
13602 oprot_->getTransport()->writeEnd();
13603 oprot_->getTransport()->flush();
13604 }
13605
13606 void HbaseClient::recv_getRegionInfo(TRegionInfo& _return)
13607 {
13608
13609 int32_t rseqid = 0;
13610 std::string fname;
13611 ::apache::thrift::protocol::TMessageType mtype;
13612
13613 iprot_->readMessageBegin(fname, mtype, rseqid);
13614 if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
13615 ::apache::thrift::TApplicationException x;
13616 x.read(iprot_);
13617 iprot_->readMessageEnd();
13618 iprot_->getTransport()->readEnd();
13619 throw x;
13620 }
13621 if (mtype != ::apache::thrift::protocol::T_REPLY) {
13622 iprot_->skip(::apache::thrift::protocol::T_STRUCT);
13623 iprot_->readMessageEnd();
13624 iprot_->getTransport()->readEnd();
13625 }
13626 if (fname.compare("getRegionInfo") != 0) {
13627 iprot_->skip(::apache::thrift::protocol::T_STRUCT);
13628 iprot_->readMessageEnd();
13629 iprot_->getTransport()->readEnd();
13630 }
13631 Hbase_getRegionInfo_presult result;
13632 result.success = &_return;
13633 result.read(iprot_);
13634 iprot_->readMessageEnd();
13635 iprot_->getTransport()->readEnd();
13636
13637 if (result.__isset.success) {
13638 // _return pointer has now been filled
13639 return;
13640 }
13641 if (result.__isset.io) {
13642 throw result.io;
13643 }
13644 throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getRegionInfo failed: unknown result");
13645 }
13646
13647 bool HbaseProcessor::dispatchCall(::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, const std::string& fname, int32_t seqid, void* callContext) {
13648 ProcessMap::iterator pfn;
13649 pfn = processMap_.find(fname);
13650 if (pfn == processMap_.end()) {
13651 iprot->skip(::apache::thrift::protocol::T_STRUCT);
13652 iprot->readMessageEnd();
13653 iprot->getTransport()->readEnd();
13654 ::apache::thrift::TApplicationException x(::apache::thrift::TApplicationException::UNKNOWN_METHOD, "Invalid method name: '"+fname+"'");
13655 oprot->writeMessageBegin(fname, ::apache::thrift::protocol::T_EXCEPTION, seqid);
13656 x.write(oprot);
13657 oprot->writeMessageEnd();
13658 oprot->getTransport()->writeEnd();
13659 oprot->getTransport()->flush();
13660 return true;
13661 }
13662 (this->*(pfn->second))(seqid, iprot, oprot, callContext);
13663 return true;
13664 }
13665
13666 void HbaseProcessor::process_enableTable(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
13667 {
13668 void* ctx = NULL;
13669 if (this->eventHandler_.get() != NULL) {
13670 ctx = this->eventHandler_->getContext("Hbase.enableTable", callContext);
13671 }
13672 ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "Hbase.enableTable");
13673
13674 if (this->eventHandler_.get() != NULL) {
13675 this->eventHandler_->preRead(ctx, "Hbase.enableTable");
13676 }
13677
13678 Hbase_enableTable_args args;
13679 args.read(iprot);
13680 iprot->readMessageEnd();
13681 uint32_t bytes = iprot->getTransport()->readEnd();
13682
13683 if (this->eventHandler_.get() != NULL) {
13684 this->eventHandler_->postRead(ctx, "Hbase.enableTable", bytes);
13685 }
13686
13687 Hbase_enableTable_result result;
13688 try {
13689 iface_->enableTable(args.tableName);
13690 } catch (IOError &io) {
13691 result.io = io;
13692 result.__isset.io = true;
13693 } catch (const std::exception& e) {
13694 if (this->eventHandler_.get() != NULL) {
13695 this->eventHandler_->handlerError(ctx, "Hbase.enableTable");
13696 }
13697
13698 ::apache::thrift::TApplicationException x(e.what());
13699 oprot->writeMessageBegin("enableTable", ::apache::thrift::protocol::T_EXCEPTION, seqid);
13700 x.write(oprot);
13701 oprot->writeMessageEnd();
13702 oprot->getTransport()->writeEnd();
13703 oprot->getTransport()->flush();
13704 return;
13705 }
13706
13707 if (this->eventHandler_.get() != NULL) {
13708 this->eventHandler_->preWrite(ctx, "Hbase.enableTable");
13709 }
13710
13711 oprot->writeMessageBegin("enableTable", ::apache::thrift::protocol::T_REPLY, seqid);
13712 result.write(oprot);
13713 oprot->writeMessageEnd();
13714 bytes = oprot->getTransport()->writeEnd();
13715 oprot->getTransport()->flush();
13716
13717 if (this->eventHandler_.get() != NULL) {
13718 this->eventHandler_->postWrite(ctx, "Hbase.enableTable", bytes);
13719 }
13720 }
13721
13722 void HbaseProcessor::process_disableTable(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
13723 {
13724 void* ctx = NULL;
13725 if (this->eventHandler_.get() != NULL) {
13726 ctx = this->eventHandler_->getContext("Hbase.disableTable", callContext);
13727 }
13728 ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "Hbase.disableTable");
13729
13730 if (this->eventHandler_.get() != NULL) {
13731 this->eventHandler_->preRead(ctx, "Hbase.disableTable");
13732 }
13733
13734 Hbase_disableTable_args args;
13735 args.read(iprot);
13736 iprot->readMessageEnd();
13737 uint32_t bytes = iprot->getTransport()->readEnd();
13738
13739 if (this->eventHandler_.get() != NULL) {
13740 this->eventHandler_->postRead(ctx, "Hbase.disableTable", bytes);
13741 }
13742
13743 Hbase_disableTable_result result;
13744 try {
13745 iface_->disableTable(args.tableName);
13746 } catch (IOError &io) {
13747 result.io = io;
13748 result.__isset.io = true;
13749 } catch (const std::exception& e) {
13750 if (this->eventHandler_.get() != NULL) {
13751 this->eventHandler_->handlerError(ctx, "Hbase.disableTable");
13752 }
13753
13754 ::apache::thrift::TApplicationException x(e.what());
13755 oprot->writeMessageBegin("disableTable", ::apache::thrift::protocol::T_EXCEPTION, seqid);
13756 x.write(oprot);
13757 oprot->writeMessageEnd();
13758 oprot->getTransport()->writeEnd();
13759 oprot->getTransport()->flush();
13760 return;
13761 }
13762
13763 if (this->eventHandler_.get() != NULL) {
13764 this->eventHandler_->preWrite(ctx, "Hbase.disableTable");
13765 }
13766
13767 oprot->writeMessageBegin("disableTable", ::apache::thrift::protocol::T_REPLY, seqid);
13768 result.write(oprot);
13769 oprot->writeMessageEnd();
13770 bytes = oprot->getTransport()->writeEnd();
13771 oprot->getTransport()->flush();
13772
13773 if (this->eventHandler_.get() != NULL) {
13774 this->eventHandler_->postWrite(ctx, "Hbase.disableTable", bytes);
13775 }
13776 }
13777
13778 void HbaseProcessor::process_isTableEnabled(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
13779 {
13780 void* ctx = NULL;
13781 if (this->eventHandler_.get() != NULL) {
13782 ctx = this->eventHandler_->getContext("Hbase.isTableEnabled", callContext);
13783 }
13784 ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "Hbase.isTableEnabled");
13785
13786 if (this->eventHandler_.get() != NULL) {
13787 this->eventHandler_->preRead(ctx, "Hbase.isTableEnabled");
13788 }
13789
13790 Hbase_isTableEnabled_args args;
13791 args.read(iprot);
13792 iprot->readMessageEnd();
13793 uint32_t bytes = iprot->getTransport()->readEnd();
13794
13795 if (this->eventHandler_.get() != NULL) {
13796 this->eventHandler_->postRead(ctx, "Hbase.isTableEnabled", bytes);
13797 }
13798
13799 Hbase_isTableEnabled_result result;
13800 try {
13801 result.success = iface_->isTableEnabled(args.tableName);
13802 result.__isset.success = true;
13803 } catch (IOError &io) {
13804 result.io = io;
13805 result.__isset.io = true;
13806 } catch (const std::exception& e) {
13807 if (this->eventHandler_.get() != NULL) {
13808 this->eventHandler_->handlerError(ctx, "Hbase.isTableEnabled");
13809 }
13810
13811 ::apache::thrift::TApplicationException x(e.what());
13812 oprot->writeMessageBegin("isTableEnabled", ::apache::thrift::protocol::T_EXCEPTION, seqid);
13813 x.write(oprot);
13814 oprot->writeMessageEnd();
13815 oprot->getTransport()->writeEnd();
13816 oprot->getTransport()->flush();
13817 return;
13818 }
13819
13820 if (this->eventHandler_.get() != NULL) {
13821 this->eventHandler_->preWrite(ctx, "Hbase.isTableEnabled");
13822 }
13823
13824 oprot->writeMessageBegin("isTableEnabled", ::apache::thrift::protocol::T_REPLY, seqid);
13825 result.write(oprot);
13826 oprot->writeMessageEnd();
13827 bytes = oprot->getTransport()->writeEnd();
13828 oprot->getTransport()->flush();
13829
13830 if (this->eventHandler_.get() != NULL) {
13831 this->eventHandler_->postWrite(ctx, "Hbase.isTableEnabled", bytes);
13832 }
13833 }
13834
13835 void HbaseProcessor::process_compact(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
13836 {
13837 void* ctx = NULL;
13838 if (this->eventHandler_.get() != NULL) {
13839 ctx = this->eventHandler_->getContext("Hbase.compact", callContext);
13840 }
13841 ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "Hbase.compact");
13842
13843 if (this->eventHandler_.get() != NULL) {
13844 this->eventHandler_->preRead(ctx, "Hbase.compact");
13845 }
13846
13847 Hbase_compact_args args;
13848 args.read(iprot);
13849 iprot->readMessageEnd();
13850 uint32_t bytes = iprot->getTransport()->readEnd();
13851
13852 if (this->eventHandler_.get() != NULL) {
13853 this->eventHandler_->postRead(ctx, "Hbase.compact", bytes);
13854 }
13855
13856 Hbase_compact_result result;
13857 try {
13858 iface_->compact(args.tableNameOrRegionName);
13859 } catch (IOError &io) {
13860 result.io = io;
13861 result.__isset.io = true;
13862 } catch (const std::exception& e) {
13863 if (this->eventHandler_.get() != NULL) {
13864 this->eventHandler_->handlerError(ctx, "Hbase.compact");
13865 }
13866
13867 ::apache::thrift::TApplicationException x(e.what());
13868 oprot->writeMessageBegin("compact", ::apache::thrift::protocol::T_EXCEPTION, seqid);
13869 x.write(oprot);
13870 oprot->writeMessageEnd();
13871 oprot->getTransport()->writeEnd();
13872 oprot->getTransport()->flush();
13873 return;
13874 }
13875
13876 if (this->eventHandler_.get() != NULL) {
13877 this->eventHandler_->preWrite(ctx, "Hbase.compact");
13878 }
13879
13880 oprot->writeMessageBegin("compact", ::apache::thrift::protocol::T_REPLY, seqid);
13881 result.write(oprot);
13882 oprot->writeMessageEnd();
13883 bytes = oprot->getTransport()->writeEnd();
13884 oprot->getTransport()->flush();
13885
13886 if (this->eventHandler_.get() != NULL) {
13887 this->eventHandler_->postWrite(ctx, "Hbase.compact", bytes);
13888 }
13889 }
13890
13891 void HbaseProcessor::process_majorCompact(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
13892 {
13893 void* ctx = NULL;
13894 if (this->eventHandler_.get() != NULL) {
13895 ctx = this->eventHandler_->getContext("Hbase.majorCompact", callContext);
13896 }
13897 ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "Hbase.majorCompact");
13898
13899 if (this->eventHandler_.get() != NULL) {
13900 this->eventHandler_->preRead(ctx, "Hbase.majorCompact");
13901 }
13902
13903 Hbase_majorCompact_args args;
13904 args.read(iprot);
13905 iprot->readMessageEnd();
13906 uint32_t bytes = iprot->getTransport()->readEnd();
13907
13908 if (this->eventHandler_.get() != NULL) {
13909 this->eventHandler_->postRead(ctx, "Hbase.majorCompact", bytes);
13910 }
13911
13912 Hbase_majorCompact_result result;
13913 try {
13914 iface_->majorCompact(args.tableNameOrRegionName);
13915 } catch (IOError &io) {
13916 result.io = io;
13917 result.__isset.io = true;
13918 } catch (const std::exception& e) {
13919 if (this->eventHandler_.get() != NULL) {
13920 this->eventHandler_->handlerError(ctx, "Hbase.majorCompact");
13921 }
13922
13923 ::apache::thrift::TApplicationException x(e.what());
13924 oprot->writeMessageBegin("majorCompact", ::apache::thrift::protocol::T_EXCEPTION, seqid);
13925 x.write(oprot);
13926 oprot->writeMessageEnd();
13927 oprot->getTransport()->writeEnd();
13928 oprot->getTransport()->flush();
13929 return;
13930 }
13931
13932 if (this->eventHandler_.get() != NULL) {
13933 this->eventHandler_->preWrite(ctx, "Hbase.majorCompact");
13934 }
13935
13936 oprot->writeMessageBegin("majorCompact", ::apache::thrift::protocol::T_REPLY, seqid);
13937 result.write(oprot);
13938 oprot->writeMessageEnd();
13939 bytes = oprot->getTransport()->writeEnd();
13940 oprot->getTransport()->flush();
13941
13942 if (this->eventHandler_.get() != NULL) {
13943 this->eventHandler_->postWrite(ctx, "Hbase.majorCompact", bytes);
13944 }
13945 }
13946
13947 void HbaseProcessor::process_getTableNames(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
13948 {
13949 void* ctx = NULL;
13950 if (this->eventHandler_.get() != NULL) {
13951 ctx = this->eventHandler_->getContext("Hbase.getTableNames", callContext);
13952 }
13953 ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "Hbase.getTableNames");
13954
13955 if (this->eventHandler_.get() != NULL) {
13956 this->eventHandler_->preRead(ctx, "Hbase.getTableNames");
13957 }
13958
13959 Hbase_getTableNames_args args;
13960 args.read(iprot);
13961 iprot->readMessageEnd();
13962 uint32_t bytes = iprot->getTransport()->readEnd();
13963
13964 if (this->eventHandler_.get() != NULL) {
13965 this->eventHandler_->postRead(ctx, "Hbase.getTableNames", bytes);
13966 }
13967
13968 Hbase_getTableNames_result result;
13969 try {
13970 iface_->getTableNames(result.success);
13971 result.__isset.success = true;
13972 } catch (IOError &io) {
13973 result.io = io;
13974 result.__isset.io = true;
13975 } catch (const std::exception& e) {
13976 if (this->eventHandler_.get() != NULL) {
13977 this->eventHandler_->handlerError(ctx, "Hbase.getTableNames");
13978 }
13979
13980 ::apache::thrift::TApplicationException x(e.what());
13981 oprot->writeMessageBegin("getTableNames", ::apache::thrift::protocol::T_EXCEPTION, seqid);
13982 x.write(oprot);
13983 oprot->writeMessageEnd();
13984 oprot->getTransport()->writeEnd();
13985 oprot->getTransport()->flush();
13986 return;
13987 }
13988
13989 if (this->eventHandler_.get() != NULL) {
13990 this->eventHandler_->preWrite(ctx, "Hbase.getTableNames");
13991 }
13992
13993 oprot->writeMessageBegin("getTableNames", ::apache::thrift::protocol::T_REPLY, seqid);
13994 result.write(oprot);
13995 oprot->writeMessageEnd();
13996 bytes = oprot->getTransport()->writeEnd();
13997 oprot->getTransport()->flush();
13998
13999 if (this->eventHandler_.get() != NULL) {
14000 this->eventHandler_->postWrite(ctx, "Hbase.getTableNames", bytes);
14001 }
14002 }
14003
14004 void HbaseProcessor::process_getColumnDescriptors(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
14005 {
14006 void* ctx = NULL;
14007 if (this->eventHandler_.get() != NULL) {
14008 ctx = this->eventHandler_->getContext("Hbase.getColumnDescriptors", callContext);
14009 }
14010 ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "Hbase.getColumnDescriptors");
14011
14012 if (this->eventHandler_.get() != NULL) {
14013 this->eventHandler_->preRead(ctx, "Hbase.getColumnDescriptors");
14014 }
14015
14016 Hbase_getColumnDescriptors_args args;
14017 args.read(iprot);
14018 iprot->readMessageEnd();
14019 uint32_t bytes = iprot->getTransport()->readEnd();
14020
14021 if (this->eventHandler_.get() != NULL) {
14022 this->eventHandler_->postRead(ctx, "Hbase.getColumnDescriptors", bytes);
14023 }
14024
14025 Hbase_getColumnDescriptors_result result;
14026 try {
14027 iface_->getColumnDescriptors(result.success, args.tableName);
14028 result.__isset.success = true;
14029 } catch (IOError &io) {
14030 result.io = io;
14031 result.__isset.io = true;
14032 } catch (const std::exception& e) {
14033 if (this->eventHandler_.get() != NULL) {
14034 this->eventHandler_->handlerError(ctx, "Hbase.getColumnDescriptors");
14035 }
14036
14037 ::apache::thrift::TApplicationException x(e.what());
14038 oprot->writeMessageBegin("getColumnDescriptors", ::apache::thrift::protocol::T_EXCEPTION, seqid);
14039 x.write(oprot);
14040 oprot->writeMessageEnd();
14041 oprot->getTransport()->writeEnd();
14042 oprot->getTransport()->flush();
14043 return;
14044 }
14045
14046 if (this->eventHandler_.get() != NULL) {
14047 this->eventHandler_->preWrite(ctx, "Hbase.getColumnDescriptors");
14048 }
14049
14050 oprot->writeMessageBegin("getColumnDescriptors", ::apache::thrift::protocol::T_REPLY, seqid);
14051 result.write(oprot);
14052 oprot->writeMessageEnd();
14053 bytes = oprot->getTransport()->writeEnd();
14054 oprot->getTransport()->flush();
14055
14056 if (this->eventHandler_.get() != NULL) {
14057 this->eventHandler_->postWrite(ctx, "Hbase.getColumnDescriptors", bytes);
14058 }
14059 }
14060
14061 void HbaseProcessor::process_getTableRegions(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
14062 {
14063 void* ctx = NULL;
14064 if (this->eventHandler_.get() != NULL) {
14065 ctx = this->eventHandler_->getContext("Hbase.getTableRegions", callContext);
14066 }
14067 ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "Hbase.getTableRegions");
14068
14069 if (this->eventHandler_.get() != NULL) {
14070 this->eventHandler_->preRead(ctx, "Hbase.getTableRegions");
14071 }
14072
14073 Hbase_getTableRegions_args args;
14074 args.read(iprot);
14075 iprot->readMessageEnd();
14076 uint32_t bytes = iprot->getTransport()->readEnd();
14077
14078 if (this->eventHandler_.get() != NULL) {
14079 this->eventHandler_->postRead(ctx, "Hbase.getTableRegions", bytes);
14080 }
14081
14082 Hbase_getTableRegions_result result;
14083 try {
14084 iface_->getTableRegions(result.success, args.tableName);
14085 result.__isset.success = true;
14086 } catch (IOError &io) {
14087 result.io = io;
14088 result.__isset.io = true;
14089 } catch (const std::exception& e) {
14090 if (this->eventHandler_.get() != NULL) {
14091 this->eventHandler_->handlerError(ctx, "Hbase.getTableRegions");
14092 }
14093
14094 ::apache::thrift::TApplicationException x(e.what());
14095 oprot->writeMessageBegin("getTableRegions", ::apache::thrift::protocol::T_EXCEPTION, seqid);
14096 x.write(oprot);
14097 oprot->writeMessageEnd();
14098 oprot->getTransport()->writeEnd();
14099 oprot->getTransport()->flush();
14100 return;
14101 }
14102
14103 if (this->eventHandler_.get() != NULL) {
14104 this->eventHandler_->preWrite(ctx, "Hbase.getTableRegions");
14105 }
14106
14107 oprot->writeMessageBegin("getTableRegions", ::apache::thrift::protocol::T_REPLY, seqid);
14108 result.write(oprot);
14109 oprot->writeMessageEnd();
14110 bytes = oprot->getTransport()->writeEnd();
14111 oprot->getTransport()->flush();
14112
14113 if (this->eventHandler_.get() != NULL) {
14114 this->eventHandler_->postWrite(ctx, "Hbase.getTableRegions", bytes);
14115 }
14116 }
14117
14118 void HbaseProcessor::process_createTable(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
14119 {
14120 void* ctx = NULL;
14121 if (this->eventHandler_.get() != NULL) {
14122 ctx = this->eventHandler_->getContext("Hbase.createTable", callContext);
14123 }
14124 ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "Hbase.createTable");
14125
14126 if (this->eventHandler_.get() != NULL) {
14127 this->eventHandler_->preRead(ctx, "Hbase.createTable");
14128 }
14129
14130 Hbase_createTable_args args;
14131 args.read(iprot);
14132 iprot->readMessageEnd();
14133 uint32_t bytes = iprot->getTransport()->readEnd();
14134
14135 if (this->eventHandler_.get() != NULL) {
14136 this->eventHandler_->postRead(ctx, "Hbase.createTable", bytes);
14137 }
14138
14139 Hbase_createTable_result result;
14140 try {
14141 iface_->createTable(args.tableName, args.columnFamilies);
14142 } catch (IOError &io) {
14143 result.io = io;
14144 result.__isset.io = true;
14145 } catch (IllegalArgument &ia) {
14146 result.ia = ia;
14147 result.__isset.ia = true;
14148 } catch (AlreadyExists &exist) {
14149 result.exist = exist;
14150 result.__isset.exist = true;
14151 } catch (const std::exception& e) {
14152 if (this->eventHandler_.get() != NULL) {
14153 this->eventHandler_->handlerError(ctx, "Hbase.createTable");
14154 }
14155
14156 ::apache::thrift::TApplicationException x(e.what());
14157 oprot->writeMessageBegin("createTable", ::apache::thrift::protocol::T_EXCEPTION, seqid);
14158 x.write(oprot);
14159 oprot->writeMessageEnd();
14160 oprot->getTransport()->writeEnd();
14161 oprot->getTransport()->flush();
14162 return;
14163 }
14164
14165 if (this->eventHandler_.get() != NULL) {
14166 this->eventHandler_->preWrite(ctx, "Hbase.createTable");
14167 }
14168
14169 oprot->writeMessageBegin("createTable", ::apache::thrift::protocol::T_REPLY, seqid);
14170 result.write(oprot);
14171 oprot->writeMessageEnd();
14172 bytes = oprot->getTransport()->writeEnd();
14173 oprot->getTransport()->flush();
14174
14175 if (this->eventHandler_.get() != NULL) {
14176 this->eventHandler_->postWrite(ctx, "Hbase.createTable", bytes);
14177 }
14178 }
14179
14180 void HbaseProcessor::process_deleteTable(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
14181 {
14182 void* ctx = NULL;
14183 if (this->eventHandler_.get() != NULL) {
14184 ctx = this->eventHandler_->getContext("Hbase.deleteTable", callContext);
14185 }
14186 ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "Hbase.deleteTable");
14187
14188 if (this->eventHandler_.get() != NULL) {
14189 this->eventHandler_->preRead(ctx, "Hbase.deleteTable");
14190 }
14191
14192 Hbase_deleteTable_args args;
14193 args.read(iprot);
14194 iprot->readMessageEnd();
14195 uint32_t bytes = iprot->getTransport()->readEnd();
14196
14197 if (this->eventHandler_.get() != NULL) {
14198 this->eventHandler_->postRead(ctx, "Hbase.deleteTable", bytes);
14199 }
14200
14201 Hbase_deleteTable_result result;
14202 try {
14203 iface_->deleteTable(args.tableName);
14204 } catch (IOError &io) {
14205 result.io = io;
14206 result.__isset.io = true;
14207 } catch (const std::exception& e) {
14208 if (this->eventHandler_.get() != NULL) {
14209 this->eventHandler_->handlerError(ctx, "Hbase.deleteTable");
14210 }
14211
14212 ::apache::thrift::TApplicationException x(e.what());
14213 oprot->writeMessageBegin("deleteTable", ::apache::thrift::protocol::T_EXCEPTION, seqid);
14214 x.write(oprot);
14215 oprot->writeMessageEnd();
14216 oprot->getTransport()->writeEnd();
14217 oprot->getTransport()->flush();
14218 return;
14219 }
14220
14221 if (this->eventHandler_.get() != NULL) {
14222 this->eventHandler_->preWrite(ctx, "Hbase.deleteTable");
14223 }
14224
14225 oprot->writeMessageBegin("deleteTable", ::apache::thrift::protocol::T_REPLY, seqid);
14226 result.write(oprot);
14227 oprot->writeMessageEnd();
14228 bytes = oprot->getTransport()->writeEnd();
14229 oprot->getTransport()->flush();
14230
14231 if (this->eventHandler_.get() != NULL) {
14232 this->eventHandler_->postWrite(ctx, "Hbase.deleteTable", bytes);
14233 }
14234 }
14235
14236 void HbaseProcessor::process_get(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
14237 {
14238 void* ctx = NULL;
14239 if (this->eventHandler_.get() != NULL) {
14240 ctx = this->eventHandler_->getContext("Hbase.get", callContext);
14241 }
14242 ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "Hbase.get");
14243
14244 if (this->eventHandler_.get() != NULL) {
14245 this->eventHandler_->preRead(ctx, "Hbase.get");
14246 }
14247
14248 Hbase_get_args args;
14249 args.read(iprot);
14250 iprot->readMessageEnd();
14251 uint32_t bytes = iprot->getTransport()->readEnd();
14252
14253 if (this->eventHandler_.get() != NULL) {
14254 this->eventHandler_->postRead(ctx, "Hbase.get", bytes);
14255 }
14256
14257 Hbase_get_result result;
14258 try {
14259 iface_->get(result.success, args.tableName, args.row, args.column, args.attributes);
14260 result.__isset.success = true;
14261 } catch (IOError &io) {
14262 result.io = io;
14263 result.__isset.io = true;
14264 } catch (const std::exception& e) {
14265 if (this->eventHandler_.get() != NULL) {
14266 this->eventHandler_->handlerError(ctx, "Hbase.get");
14267 }
14268
14269 ::apache::thrift::TApplicationException x(e.what());
14270 oprot->writeMessageBegin("get", ::apache::thrift::protocol::T_EXCEPTION, seqid);
14271 x.write(oprot);
14272 oprot->writeMessageEnd();
14273 oprot->getTransport()->writeEnd();
14274 oprot->getTransport()->flush();
14275 return;
14276 }
14277
14278 if (this->eventHandler_.get() != NULL) {
14279 this->eventHandler_->preWrite(ctx, "Hbase.get");
14280 }
14281
14282 oprot->writeMessageBegin("get", ::apache::thrift::protocol::T_REPLY, seqid);
14283 result.write(oprot);
14284 oprot->writeMessageEnd();
14285 bytes = oprot->getTransport()->writeEnd();
14286 oprot->getTransport()->flush();
14287
14288 if (this->eventHandler_.get() != NULL) {
14289 this->eventHandler_->postWrite(ctx, "Hbase.get", bytes);
14290 }
14291 }
14292
14293 void HbaseProcessor::process_getVer(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
14294 {
14295 void* ctx = NULL;
14296 if (this->eventHandler_.get() != NULL) {
14297 ctx = this->eventHandler_->getContext("Hbase.getVer", callContext);
14298 }
14299 ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "Hbase.getVer");
14300
14301 if (this->eventHandler_.get() != NULL) {
14302 this->eventHandler_->preRead(ctx, "Hbase.getVer");
14303 }
14304
14305 Hbase_getVer_args args;
14306 args.read(iprot);
14307 iprot->readMessageEnd();
14308 uint32_t bytes = iprot->getTransport()->readEnd();
14309
14310 if (this->eventHandler_.get() != NULL) {
14311 this->eventHandler_->postRead(ctx, "Hbase.getVer", bytes);
14312 }
14313
14314 Hbase_getVer_result result;
14315 try {
14316 iface_->getVer(result.success, args.tableName, args.row, args.column, args.numVersions, args.attributes);
14317 result.__isset.success = true;
14318 } catch (IOError &io) {
14319 result.io = io;
14320 result.__isset.io = true;
14321 } catch (const std::exception& e) {
14322 if (this->eventHandler_.get() != NULL) {
14323 this->eventHandler_->handlerError(ctx, "Hbase.getVer");
14324 }
14325
14326 ::apache::thrift::TApplicationException x(e.what());
14327 oprot->writeMessageBegin("getVer", ::apache::thrift::protocol::T_EXCEPTION, seqid);
14328 x.write(oprot);
14329 oprot->writeMessageEnd();
14330 oprot->getTransport()->writeEnd();
14331 oprot->getTransport()->flush();
14332 return;
14333 }
14334
14335 if (this->eventHandler_.get() != NULL) {
14336 this->eventHandler_->preWrite(ctx, "Hbase.getVer");
14337 }
14338
14339 oprot->writeMessageBegin("getVer", ::apache::thrift::protocol::T_REPLY, seqid);
14340 result.write(oprot);
14341 oprot->writeMessageEnd();
14342 bytes = oprot->getTransport()->writeEnd();
14343 oprot->getTransport()->flush();
14344
14345 if (this->eventHandler_.get() != NULL) {
14346 this->eventHandler_->postWrite(ctx, "Hbase.getVer", bytes);
14347 }
14348 }
14349
14350 void HbaseProcessor::process_getVerTs(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
14351 {
14352 void* ctx = NULL;
14353 if (this->eventHandler_.get() != NULL) {
14354 ctx = this->eventHandler_->getContext("Hbase.getVerTs", callContext);
14355 }
14356 ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "Hbase.getVerTs");
14357
14358 if (this->eventHandler_.get() != NULL) {
14359 this->eventHandler_->preRead(ctx, "Hbase.getVerTs");
14360 }
14361
14362 Hbase_getVerTs_args args;
14363 args.read(iprot);
14364 iprot->readMessageEnd();
14365 uint32_t bytes = iprot->getTransport()->readEnd();
14366
14367 if (this->eventHandler_.get() != NULL) {
14368 this->eventHandler_->postRead(ctx, "Hbase.getVerTs", bytes);
14369 }
14370
14371 Hbase_getVerTs_result result;
14372 try {
14373 iface_->getVerTs(result.success, args.tableName, args.row, args.column, args.timestamp, args.numVersions, args.attributes);
14374 result.__isset.success = true;
14375 } catch (IOError &io) {
14376 result.io = io;
14377 result.__isset.io = true;
14378 } catch (const std::exception& e) {
14379 if (this->eventHandler_.get() != NULL) {
14380 this->eventHandler_->handlerError(ctx, "Hbase.getVerTs");
14381 }
14382
14383 ::apache::thrift::TApplicationException x(e.what());
14384 oprot->writeMessageBegin("getVerTs", ::apache::thrift::protocol::T_EXCEPTION, seqid);
14385 x.write(oprot);
14386 oprot->writeMessageEnd();
14387 oprot->getTransport()->writeEnd();
14388 oprot->getTransport()->flush();
14389 return;
14390 }
14391
14392 if (this->eventHandler_.get() != NULL) {
14393 this->eventHandler_->preWrite(ctx, "Hbase.getVerTs");
14394 }
14395
14396 oprot->writeMessageBegin("getVerTs", ::apache::thrift::protocol::T_REPLY, seqid);
14397 result.write(oprot);
14398 oprot->writeMessageEnd();
14399 bytes = oprot->getTransport()->writeEnd();
14400 oprot->getTransport()->flush();
14401
14402 if (this->eventHandler_.get() != NULL) {
14403 this->eventHandler_->postWrite(ctx, "Hbase.getVerTs", bytes);
14404 }
14405 }
14406
14407 void HbaseProcessor::process_getRow(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
14408 {
14409 void* ctx = NULL;
14410 if (this->eventHandler_.get() != NULL) {
14411 ctx = this->eventHandler_->getContext("Hbase.getRow", callContext);
14412 }
14413 ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "Hbase.getRow");
14414
14415 if (this->eventHandler_.get() != NULL) {
14416 this->eventHandler_->preRead(ctx, "Hbase.getRow");
14417 }
14418
14419 Hbase_getRow_args args;
14420 args.read(iprot);
14421 iprot->readMessageEnd();
14422 uint32_t bytes = iprot->getTransport()->readEnd();
14423
14424 if (this->eventHandler_.get() != NULL) {
14425 this->eventHandler_->postRead(ctx, "Hbase.getRow", bytes);
14426 }
14427
14428 Hbase_getRow_result result;
14429 try {
14430 iface_->getRow(result.success, args.tableName, args.row, args.attributes);
14431 result.__isset.success = true;
14432 } catch (IOError &io) {
14433 result.io = io;
14434 result.__isset.io = true;
14435 } catch (const std::exception& e) {
14436 if (this->eventHandler_.get() != NULL) {
14437 this->eventHandler_->handlerError(ctx, "Hbase.getRow");
14438 }
14439
14440 ::apache::thrift::TApplicationException x(e.what());
14441 oprot->writeMessageBegin("getRow", ::apache::thrift::protocol::T_EXCEPTION, seqid);
14442 x.write(oprot);
14443 oprot->writeMessageEnd();
14444 oprot->getTransport()->writeEnd();
14445 oprot->getTransport()->flush();
14446 return;
14447 }
14448
14449 if (this->eventHandler_.get() != NULL) {
14450 this->eventHandler_->preWrite(ctx, "Hbase.getRow");
14451 }
14452
14453 oprot->writeMessageBegin("getRow", ::apache::thrift::protocol::T_REPLY, seqid);
14454 result.write(oprot);
14455 oprot->writeMessageEnd();
14456 bytes = oprot->getTransport()->writeEnd();
14457 oprot->getTransport()->flush();
14458
14459 if (this->eventHandler_.get() != NULL) {
14460 this->eventHandler_->postWrite(ctx, "Hbase.getRow", bytes);
14461 }
14462 }
14463
14464 void HbaseProcessor::process_getRowWithColumns(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
14465 {
14466 void* ctx = NULL;
14467 if (this->eventHandler_.get() != NULL) {
14468 ctx = this->eventHandler_->getContext("Hbase.getRowWithColumns", callContext);
14469 }
14470 ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "Hbase.getRowWithColumns");
14471
14472 if (this->eventHandler_.get() != NULL) {
14473 this->eventHandler_->preRead(ctx, "Hbase.getRowWithColumns");
14474 }
14475
14476 Hbase_getRowWithColumns_args args;
14477 args.read(iprot);
14478 iprot->readMessageEnd();
14479 uint32_t bytes = iprot->getTransport()->readEnd();
14480
14481 if (this->eventHandler_.get() != NULL) {
14482 this->eventHandler_->postRead(ctx, "Hbase.getRowWithColumns", bytes);
14483 }
14484
14485 Hbase_getRowWithColumns_result result;
14486 try {
14487 iface_->getRowWithColumns(result.success, args.tableName, args.row, args.columns, args.attributes);
14488 result.__isset.success = true;
14489 } catch (IOError &io) {
14490 result.io = io;
14491 result.__isset.io = true;
14492 } catch (const std::exception& e) {
14493 if (this->eventHandler_.get() != NULL) {
14494 this->eventHandler_->handlerError(ctx, "Hbase.getRowWithColumns");
14495 }
14496
14497 ::apache::thrift::TApplicationException x(e.what());
14498 oprot->writeMessageBegin("getRowWithColumns", ::apache::thrift::protocol::T_EXCEPTION, seqid);
14499 x.write(oprot);
14500 oprot->writeMessageEnd();
14501 oprot->getTransport()->writeEnd();
14502 oprot->getTransport()->flush();
14503 return;
14504 }
14505
14506 if (this->eventHandler_.get() != NULL) {
14507 this->eventHandler_->preWrite(ctx, "Hbase.getRowWithColumns");
14508 }
14509
14510 oprot->writeMessageBegin("getRowWithColumns", ::apache::thrift::protocol::T_REPLY, seqid);
14511 result.write(oprot);
14512 oprot->writeMessageEnd();
14513 bytes = oprot->getTransport()->writeEnd();
14514 oprot->getTransport()->flush();
14515
14516 if (this->eventHandler_.get() != NULL) {
14517 this->eventHandler_->postWrite(ctx, "Hbase.getRowWithColumns", bytes);
14518 }
14519 }
14520
14521 void HbaseProcessor::process_getRowTs(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
14522 {
14523 void* ctx = NULL;
14524 if (this->eventHandler_.get() != NULL) {
14525 ctx = this->eventHandler_->getContext("Hbase.getRowTs", callContext);
14526 }
14527 ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "Hbase.getRowTs");
14528
14529 if (this->eventHandler_.get() != NULL) {
14530 this->eventHandler_->preRead(ctx, "Hbase.getRowTs");
14531 }
14532
14533 Hbase_getRowTs_args args;
14534 args.read(iprot);
14535 iprot->readMessageEnd();
14536 uint32_t bytes = iprot->getTransport()->readEnd();
14537
14538 if (this->eventHandler_.get() != NULL) {
14539 this->eventHandler_->postRead(ctx, "Hbase.getRowTs", bytes);
14540 }
14541
14542 Hbase_getRowTs_result result;
14543 try {
14544 iface_->getRowTs(result.success, args.tableName, args.row, args.timestamp, args.attributes);
14545 result.__isset.success = true;
14546 } catch (IOError &io) {
14547 result.io = io;
14548 result.__isset.io = true;
14549 } catch (const std::exception& e) {
14550 if (this->eventHandler_.get() != NULL) {
14551 this->eventHandler_->handlerError(ctx, "Hbase.getRowTs");
14552 }
14553
14554 ::apache::thrift::TApplicationException x(e.what());
14555 oprot->writeMessageBegin("getRowTs", ::apache::thrift::protocol::T_EXCEPTION, seqid);
14556 x.write(oprot);
14557 oprot->writeMessageEnd();
14558 oprot->getTransport()->writeEnd();
14559 oprot->getTransport()->flush();
14560 return;
14561 }
14562
14563 if (this->eventHandler_.get() != NULL) {
14564 this->eventHandler_->preWrite(ctx, "Hbase.getRowTs");
14565 }
14566
14567 oprot->writeMessageBegin("getRowTs", ::apache::thrift::protocol::T_REPLY, seqid);
14568 result.write(oprot);
14569 oprot->writeMessageEnd();
14570 bytes = oprot->getTransport()->writeEnd();
14571 oprot->getTransport()->flush();
14572
14573 if (this->eventHandler_.get() != NULL) {
14574 this->eventHandler_->postWrite(ctx, "Hbase.getRowTs", bytes);
14575 }
14576 }
14577
14578 void HbaseProcessor::process_getRowWithColumnsTs(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
14579 {
14580 void* ctx = NULL;
14581 if (this->eventHandler_.get() != NULL) {
14582 ctx = this->eventHandler_->getContext("Hbase.getRowWithColumnsTs", callContext);
14583 }
14584 ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "Hbase.getRowWithColumnsTs");
14585
14586 if (this->eventHandler_.get() != NULL) {
14587 this->eventHandler_->preRead(ctx, "Hbase.getRowWithColumnsTs");
14588 }
14589
14590 Hbase_getRowWithColumnsTs_args args;
14591 args.read(iprot);
14592 iprot->readMessageEnd();
14593 uint32_t bytes = iprot->getTransport()->readEnd();
14594
14595 if (this->eventHandler_.get() != NULL) {
14596 this->eventHandler_->postRead(ctx, "Hbase.getRowWithColumnsTs", bytes);
14597 }
14598
14599 Hbase_getRowWithColumnsTs_result result;
14600 try {
14601 iface_->getRowWithColumnsTs(result.success, args.tableName, args.row, args.columns, args.timestamp, args.attributes);
14602 result.__isset.success = true;
14603 } catch (IOError &io) {
14604 result.io = io;
14605 result.__isset.io = true;
14606 } catch (const std::exception& e) {
14607 if (this->eventHandler_.get() != NULL) {
14608 this->eventHandler_->handlerError(ctx, "Hbase.getRowWithColumnsTs");
14609 }
14610
14611 ::apache::thrift::TApplicationException x(e.what());
14612 oprot->writeMessageBegin("getRowWithColumnsTs", ::apache::thrift::protocol::T_EXCEPTION, seqid);
14613 x.write(oprot);
14614 oprot->writeMessageEnd();
14615 oprot->getTransport()->writeEnd();
14616 oprot->getTransport()->flush();
14617 return;
14618 }
14619
14620 if (this->eventHandler_.get() != NULL) {
14621 this->eventHandler_->preWrite(ctx, "Hbase.getRowWithColumnsTs");
14622 }
14623
14624 oprot->writeMessageBegin("getRowWithColumnsTs", ::apache::thrift::protocol::T_REPLY, seqid);
14625 result.write(oprot);
14626 oprot->writeMessageEnd();
14627 bytes = oprot->getTransport()->writeEnd();
14628 oprot->getTransport()->flush();
14629
14630 if (this->eventHandler_.get() != NULL) {
14631 this->eventHandler_->postWrite(ctx, "Hbase.getRowWithColumnsTs", bytes);
14632 }
14633 }
14634
14635 void HbaseProcessor::process_getRows(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
14636 {
14637 void* ctx = NULL;
14638 if (this->eventHandler_.get() != NULL) {
14639 ctx = this->eventHandler_->getContext("Hbase.getRows", callContext);
14640 }
14641 ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "Hbase.getRows");
14642
14643 if (this->eventHandler_.get() != NULL) {
14644 this->eventHandler_->preRead(ctx, "Hbase.getRows");
14645 }
14646
14647 Hbase_getRows_args args;
14648 args.read(iprot);
14649 iprot->readMessageEnd();
14650 uint32_t bytes = iprot->getTransport()->readEnd();
14651
14652 if (this->eventHandler_.get() != NULL) {
14653 this->eventHandler_->postRead(ctx, "Hbase.getRows", bytes);
14654 }
14655
14656 Hbase_getRows_result result;
14657 try {
14658 iface_->getRows(result.success, args.tableName, args.rows, args.attributes);
14659 result.__isset.success = true;
14660 } catch (IOError &io) {
14661 result.io = io;
14662 result.__isset.io = true;
14663 } catch (const std::exception& e) {
14664 if (this->eventHandler_.get() != NULL) {
14665 this->eventHandler_->handlerError(ctx, "Hbase.getRows");
14666 }
14667
14668 ::apache::thrift::TApplicationException x(e.what());
14669 oprot->writeMessageBegin("getRows", ::apache::thrift::protocol::T_EXCEPTION, seqid);
14670 x.write(oprot);
14671 oprot->writeMessageEnd();
14672 oprot->getTransport()->writeEnd();
14673 oprot->getTransport()->flush();
14674 return;
14675 }
14676
14677 if (this->eventHandler_.get() != NULL) {
14678 this->eventHandler_->preWrite(ctx, "Hbase.getRows");
14679 }
14680
14681 oprot->writeMessageBegin("getRows", ::apache::thrift::protocol::T_REPLY, seqid);
14682 result.write(oprot);
14683 oprot->writeMessageEnd();
14684 bytes = oprot->getTransport()->writeEnd();
14685 oprot->getTransport()->flush();
14686
14687 if (this->eventHandler_.get() != NULL) {
14688 this->eventHandler_->postWrite(ctx, "Hbase.getRows", bytes);
14689 }
14690 }
14691
14692 void HbaseProcessor::process_getRowsWithColumns(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
14693 {
14694 void* ctx = NULL;
14695 if (this->eventHandler_.get() != NULL) {
14696 ctx = this->eventHandler_->getContext("Hbase.getRowsWithColumns", callContext);
14697 }
14698 ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "Hbase.getRowsWithColumns");
14699
14700 if (this->eventHandler_.get() != NULL) {
14701 this->eventHandler_->preRead(ctx, "Hbase.getRowsWithColumns");
14702 }
14703
14704 Hbase_getRowsWithColumns_args args;
14705 args.read(iprot);
14706 iprot->readMessageEnd();
14707 uint32_t bytes = iprot->getTransport()->readEnd();
14708
14709 if (this->eventHandler_.get() != NULL) {
14710 this->eventHandler_->postRead(ctx, "Hbase.getRowsWithColumns", bytes);
14711 }
14712
14713 Hbase_getRowsWithColumns_result result;
14714 try {
14715 iface_->getRowsWithColumns(result.success, args.tableName, args.rows, args.columns, args.attributes);
14716 result.__isset.success = true;
14717 } catch (IOError &io) {
14718 result.io = io;
14719 result.__isset.io = true;
14720 } catch (const std::exception& e) {
14721 if (this->eventHandler_.get() != NULL) {
14722 this->eventHandler_->handlerError(ctx, "Hbase.getRowsWithColumns");
14723 }
14724
14725 ::apache::thrift::TApplicationException x(e.what());
14726 oprot->writeMessageBegin("getRowsWithColumns", ::apache::thrift::protocol::T_EXCEPTION, seqid);
14727 x.write(oprot);
14728 oprot->writeMessageEnd();
14729 oprot->getTransport()->writeEnd();
14730 oprot->getTransport()->flush();
14731 return;
14732 }
14733
14734 if (this->eventHandler_.get() != NULL) {
14735 this->eventHandler_->preWrite(ctx, "Hbase.getRowsWithColumns");
14736 }
14737
14738 oprot->writeMessageBegin("getRowsWithColumns", ::apache::thrift::protocol::T_REPLY, seqid);
14739 result.write(oprot);
14740 oprot->writeMessageEnd();
14741 bytes = oprot->getTransport()->writeEnd();
14742 oprot->getTransport()->flush();
14743
14744 if (this->eventHandler_.get() != NULL) {
14745 this->eventHandler_->postWrite(ctx, "Hbase.getRowsWithColumns", bytes);
14746 }
14747 }
14748
14749 void HbaseProcessor::process_getRowsTs(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
14750 {
14751 void* ctx = NULL;
14752 if (this->eventHandler_.get() != NULL) {
14753 ctx = this->eventHandler_->getContext("Hbase.getRowsTs", callContext);
14754 }
14755 ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "Hbase.getRowsTs");
14756
14757 if (this->eventHandler_.get() != NULL) {
14758 this->eventHandler_->preRead(ctx, "Hbase.getRowsTs");
14759 }
14760
14761 Hbase_getRowsTs_args args;
14762 args.read(iprot);
14763 iprot->readMessageEnd();
14764 uint32_t bytes = iprot->getTransport()->readEnd();
14765
14766 if (this->eventHandler_.get() != NULL) {
14767 this->eventHandler_->postRead(ctx, "Hbase.getRowsTs", bytes);
14768 }
14769
14770 Hbase_getRowsTs_result result;
14771 try {
14772 iface_->getRowsTs(result.success, args.tableName, args.rows, args.timestamp, args.attributes);
14773 result.__isset.success = true;
14774 } catch (IOError &io) {
14775 result.io = io;
14776 result.__isset.io = true;
14777 } catch (const std::exception& e) {
14778 if (this->eventHandler_.get() != NULL) {
14779 this->eventHandler_->handlerError(ctx, "Hbase.getRowsTs");
14780 }
14781
14782 ::apache::thrift::TApplicationException x(e.what());
14783 oprot->writeMessageBegin("getRowsTs", ::apache::thrift::protocol::T_EXCEPTION, seqid);
14784 x.write(oprot);
14785 oprot->writeMessageEnd();
14786 oprot->getTransport()->writeEnd();
14787 oprot->getTransport()->flush();
14788 return;
14789 }
14790
14791 if (this->eventHandler_.get() != NULL) {
14792 this->eventHandler_->preWrite(ctx, "Hbase.getRowsTs");
14793 }
14794
14795 oprot->writeMessageBegin("getRowsTs", ::apache::thrift::protocol::T_REPLY, seqid);
14796 result.write(oprot);
14797 oprot->writeMessageEnd();
14798 bytes = oprot->getTransport()->writeEnd();
14799 oprot->getTransport()->flush();
14800
14801 if (this->eventHandler_.get() != NULL) {
14802 this->eventHandler_->postWrite(ctx, "Hbase.getRowsTs", bytes);
14803 }
14804 }
14805
14806 void HbaseProcessor::process_getRowsWithColumnsTs(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
14807 {
14808 void* ctx = NULL;
14809 if (this->eventHandler_.get() != NULL) {
14810 ctx = this->eventHandler_->getContext("Hbase.getRowsWithColumnsTs", callContext);
14811 }
14812 ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "Hbase.getRowsWithColumnsTs");
14813
14814 if (this->eventHandler_.get() != NULL) {
14815 this->eventHandler_->preRead(ctx, "Hbase.getRowsWithColumnsTs");
14816 }
14817
14818 Hbase_getRowsWithColumnsTs_args args;
14819 args.read(iprot);
14820 iprot->readMessageEnd();
14821 uint32_t bytes = iprot->getTransport()->readEnd();
14822
14823 if (this->eventHandler_.get() != NULL) {
14824 this->eventHandler_->postRead(ctx, "Hbase.getRowsWithColumnsTs", bytes);
14825 }
14826
14827 Hbase_getRowsWithColumnsTs_result result;
14828 try {
14829 iface_->getRowsWithColumnsTs(result.success, args.tableName, args.rows, args.columns, args.timestamp, args.attributes);
14830 result.__isset.success = true;
14831 } catch (IOError &io) {
14832 result.io = io;
14833 result.__isset.io = true;
14834 } catch (const std::exception& e) {
14835 if (this->eventHandler_.get() != NULL) {
14836 this->eventHandler_->handlerError(ctx, "Hbase.getRowsWithColumnsTs");
14837 }
14838
14839 ::apache::thrift::TApplicationException x(e.what());
14840 oprot->writeMessageBegin("getRowsWithColumnsTs", ::apache::thrift::protocol::T_EXCEPTION, seqid);
14841 x.write(oprot);
14842 oprot->writeMessageEnd();
14843 oprot->getTransport()->writeEnd();
14844 oprot->getTransport()->flush();
14845 return;
14846 }
14847
14848 if (this->eventHandler_.get() != NULL) {
14849 this->eventHandler_->preWrite(ctx, "Hbase.getRowsWithColumnsTs");
14850 }
14851
14852 oprot->writeMessageBegin("getRowsWithColumnsTs", ::apache::thrift::protocol::T_REPLY, seqid);
14853 result.write(oprot);
14854 oprot->writeMessageEnd();
14855 bytes = oprot->getTransport()->writeEnd();
14856 oprot->getTransport()->flush();
14857
14858 if (this->eventHandler_.get() != NULL) {
14859 this->eventHandler_->postWrite(ctx, "Hbase.getRowsWithColumnsTs", bytes);
14860 }
14861 }
14862
14863 void HbaseProcessor::process_mutateRow(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
14864 {
14865 void* ctx = NULL;
14866 if (this->eventHandler_.get() != NULL) {
14867 ctx = this->eventHandler_->getContext("Hbase.mutateRow", callContext);
14868 }
14869 ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "Hbase.mutateRow");
14870
14871 if (this->eventHandler_.get() != NULL) {
14872 this->eventHandler_->preRead(ctx, "Hbase.mutateRow");
14873 }
14874
14875 Hbase_mutateRow_args args;
14876 args.read(iprot);
14877 iprot->readMessageEnd();
14878 uint32_t bytes = iprot->getTransport()->readEnd();
14879
14880 if (this->eventHandler_.get() != NULL) {
14881 this->eventHandler_->postRead(ctx, "Hbase.mutateRow", bytes);
14882 }
14883
14884 Hbase_mutateRow_result result;
14885 try {
14886 iface_->mutateRow(args.tableName, args.row, args.mutations, args.attributes);
14887 } catch (IOError &io) {
14888 result.io = io;
14889 result.__isset.io = true;
14890 } catch (IllegalArgument &ia) {
14891 result.ia = ia;
14892 result.__isset.ia = true;
14893 } catch (const std::exception& e) {
14894 if (this->eventHandler_.get() != NULL) {
14895 this->eventHandler_->handlerError(ctx, "Hbase.mutateRow");
14896 }
14897
14898 ::apache::thrift::TApplicationException x(e.what());
14899 oprot->writeMessageBegin("mutateRow", ::apache::thrift::protocol::T_EXCEPTION, seqid);
14900 x.write(oprot);
14901 oprot->writeMessageEnd();
14902 oprot->getTransport()->writeEnd();
14903 oprot->getTransport()->flush();
14904 return;
14905 }
14906
14907 if (this->eventHandler_.get() != NULL) {
14908 this->eventHandler_->preWrite(ctx, "Hbase.mutateRow");
14909 }
14910
14911 oprot->writeMessageBegin("mutateRow", ::apache::thrift::protocol::T_REPLY, seqid);
14912 result.write(oprot);
14913 oprot->writeMessageEnd();
14914 bytes = oprot->getTransport()->writeEnd();
14915 oprot->getTransport()->flush();
14916
14917 if (this->eventHandler_.get() != NULL) {
14918 this->eventHandler_->postWrite(ctx, "Hbase.mutateRow", bytes);
14919 }
14920 }
14921
14922 void HbaseProcessor::process_mutateRowTs(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
14923 {
14924 void* ctx = NULL;
14925 if (this->eventHandler_.get() != NULL) {
14926 ctx = this->eventHandler_->getContext("Hbase.mutateRowTs", callContext);
14927 }
14928 ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "Hbase.mutateRowTs");
14929
14930 if (this->eventHandler_.get() != NULL) {
14931 this->eventHandler_->preRead(ctx, "Hbase.mutateRowTs");
14932 }
14933
14934 Hbase_mutateRowTs_args args;
14935 args.read(iprot);
14936 iprot->readMessageEnd();
14937 uint32_t bytes = iprot->getTransport()->readEnd();
14938
14939 if (this->eventHandler_.get() != NULL) {
14940 this->eventHandler_->postRead(ctx, "Hbase.mutateRowTs", bytes);
14941 }
14942
14943 Hbase_mutateRowTs_result result;
14944 try {
14945 iface_->mutateRowTs(args.tableName, args.row, args.mutations, args.timestamp, args.attributes);
14946 } catch (IOError &io) {
14947 result.io = io;
14948 result.__isset.io = true;
14949 } catch (IllegalArgument &ia) {
14950 result.ia = ia;
14951 result.__isset.ia = true;
14952 } catch (const std::exception& e) {
14953 if (this->eventHandler_.get() != NULL) {
14954 this->eventHandler_->handlerError(ctx, "Hbase.mutateRowTs");
14955 }
14956
14957 ::apache::thrift::TApplicationException x(e.what());
14958 oprot->writeMessageBegin("mutateRowTs", ::apache::thrift::protocol::T_EXCEPTION, seqid);
14959 x.write(oprot);
14960 oprot->writeMessageEnd();
14961 oprot->getTransport()->writeEnd();
14962 oprot->getTransport()->flush();
14963 return;
14964 }
14965
14966 if (this->eventHandler_.get() != NULL) {
14967 this->eventHandler_->preWrite(ctx, "Hbase.mutateRowTs");
14968 }
14969
14970 oprot->writeMessageBegin("mutateRowTs", ::apache::thrift::protocol::T_REPLY, seqid);
14971 result.write(oprot);
14972 oprot->writeMessageEnd();
14973 bytes = oprot->getTransport()->writeEnd();
14974 oprot->getTransport()->flush();
14975
14976 if (this->eventHandler_.get() != NULL) {
14977 this->eventHandler_->postWrite(ctx, "Hbase.mutateRowTs", bytes);
14978 }
14979 }
14980
14981 void HbaseProcessor::process_mutateRows(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
14982 {
14983 void* ctx = NULL;
14984 if (this->eventHandler_.get() != NULL) {
14985 ctx = this->eventHandler_->getContext("Hbase.mutateRows", callContext);
14986 }
14987 ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "Hbase.mutateRows");
14988
14989 if (this->eventHandler_.get() != NULL) {
14990 this->eventHandler_->preRead(ctx, "Hbase.mutateRows");
14991 }
14992
14993 Hbase_mutateRows_args args;
14994 args.read(iprot);
14995 iprot->readMessageEnd();
14996 uint32_t bytes = iprot->getTransport()->readEnd();
14997
14998 if (this->eventHandler_.get() != NULL) {
14999 this->eventHandler_->postRead(ctx, "Hbase.mutateRows", bytes);
15000 }
15001
15002 Hbase_mutateRows_result result;
15003 try {
15004 iface_->mutateRows(args.tableName, args.rowBatches, args.attributes);
15005 } catch (IOError &io) {
15006 result.io = io;
15007 result.__isset.io = true;
15008 } catch (IllegalArgument &ia) {
15009 result.ia = ia;
15010 result.__isset.ia = true;
15011 } catch (const std::exception& e) {
15012 if (this->eventHandler_.get() != NULL) {
15013 this->eventHandler_->handlerError(ctx, "Hbase.mutateRows");
15014 }
15015
15016 ::apache::thrift::TApplicationException x(e.what());
15017 oprot->writeMessageBegin("mutateRows", ::apache::thrift::protocol::T_EXCEPTION, seqid);
15018 x.write(oprot);
15019 oprot->writeMessageEnd();
15020 oprot->getTransport()->writeEnd();
15021 oprot->getTransport()->flush();
15022 return;
15023 }
15024
15025 if (this->eventHandler_.get() != NULL) {
15026 this->eventHandler_->preWrite(ctx, "Hbase.mutateRows");
15027 }
15028
15029 oprot->writeMessageBegin("mutateRows", ::apache::thrift::protocol::T_REPLY, seqid);
15030 result.write(oprot);
15031 oprot->writeMessageEnd();
15032 bytes = oprot->getTransport()->writeEnd();
15033 oprot->getTransport()->flush();
15034
15035 if (this->eventHandler_.get() != NULL) {
15036 this->eventHandler_->postWrite(ctx, "Hbase.mutateRows", bytes);
15037 }
15038 }
15039
15040 void HbaseProcessor::process_mutateRowsTs(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
15041 {
15042 void* ctx = NULL;
15043 if (this->eventHandler_.get() != NULL) {
15044 ctx = this->eventHandler_->getContext("Hbase.mutateRowsTs", callContext);
15045 }
15046 ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "Hbase.mutateRowsTs");
15047
15048 if (this->eventHandler_.get() != NULL) {
15049 this->eventHandler_->preRead(ctx, "Hbase.mutateRowsTs");
15050 }
15051
15052 Hbase_mutateRowsTs_args args;
15053 args.read(iprot);
15054 iprot->readMessageEnd();
15055 uint32_t bytes = iprot->getTransport()->readEnd();
15056
15057 if (this->eventHandler_.get() != NULL) {
15058 this->eventHandler_->postRead(ctx, "Hbase.mutateRowsTs", bytes);
15059 }
15060
15061 Hbase_mutateRowsTs_result result;
15062 try {
15063 iface_->mutateRowsTs(args.tableName, args.rowBatches, args.timestamp, args.attributes);
15064 } catch (IOError &io) {
15065 result.io = io;
15066 result.__isset.io = true;
15067 } catch (IllegalArgument &ia) {
15068 result.ia = ia;
15069 result.__isset.ia = true;
15070 } catch (const std::exception& e) {
15071 if (this->eventHandler_.get() != NULL) {
15072 this->eventHandler_->handlerError(ctx, "Hbase.mutateRowsTs");
15073 }
15074
15075 ::apache::thrift::TApplicationException x(e.what());
15076 oprot->writeMessageBegin("mutateRowsTs", ::apache::thrift::protocol::T_EXCEPTION, seqid);
15077 x.write(oprot);
15078 oprot->writeMessageEnd();
15079 oprot->getTransport()->writeEnd();
15080 oprot->getTransport()->flush();
15081 return;
15082 }
15083
15084 if (this->eventHandler_.get() != NULL) {
15085 this->eventHandler_->preWrite(ctx, "Hbase.mutateRowsTs");
15086 }
15087
15088 oprot->writeMessageBegin("mutateRowsTs", ::apache::thrift::protocol::T_REPLY, seqid);
15089 result.write(oprot);
15090 oprot->writeMessageEnd();
15091 bytes = oprot->getTransport()->writeEnd();
15092 oprot->getTransport()->flush();
15093
15094 if (this->eventHandler_.get() != NULL) {
15095 this->eventHandler_->postWrite(ctx, "Hbase.mutateRowsTs", bytes);
15096 }
15097 }
15098
15099 void HbaseProcessor::process_atomicIncrement(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
15100 {
15101 void* ctx = NULL;
15102 if (this->eventHandler_.get() != NULL) {
15103 ctx = this->eventHandler_->getContext("Hbase.atomicIncrement", callContext);
15104 }
15105 ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "Hbase.atomicIncrement");
15106
15107 if (this->eventHandler_.get() != NULL) {
15108 this->eventHandler_->preRead(ctx, "Hbase.atomicIncrement");
15109 }
15110
15111 Hbase_atomicIncrement_args args;
15112 args.read(iprot);
15113 iprot->readMessageEnd();
15114 uint32_t bytes = iprot->getTransport()->readEnd();
15115
15116 if (this->eventHandler_.get() != NULL) {
15117 this->eventHandler_->postRead(ctx, "Hbase.atomicIncrement", bytes);
15118 }
15119
15120 Hbase_atomicIncrement_result result;
15121 try {
15122 result.success = iface_->atomicIncrement(args.tableName, args.row, args.column, args.value);
15123 result.__isset.success = true;
15124 } catch (IOError &io) {
15125 result.io = io;
15126 result.__isset.io = true;
15127 } catch (IllegalArgument &ia) {
15128 result.ia = ia;
15129 result.__isset.ia = true;
15130 } catch (const std::exception& e) {
15131 if (this->eventHandler_.get() != NULL) {
15132 this->eventHandler_->handlerError(ctx, "Hbase.atomicIncrement");
15133 }
15134
15135 ::apache::thrift::TApplicationException x(e.what());
15136 oprot->writeMessageBegin("atomicIncrement", ::apache::thrift::protocol::T_EXCEPTION, seqid);
15137 x.write(oprot);
15138 oprot->writeMessageEnd();
15139 oprot->getTransport()->writeEnd();
15140 oprot->getTransport()->flush();
15141 return;
15142 }
15143
15144 if (this->eventHandler_.get() != NULL) {
15145 this->eventHandler_->preWrite(ctx, "Hbase.atomicIncrement");
15146 }
15147
15148 oprot->writeMessageBegin("atomicIncrement", ::apache::thrift::protocol::T_REPLY, seqid);
15149 result.write(oprot);
15150 oprot->writeMessageEnd();
15151 bytes = oprot->getTransport()->writeEnd();
15152 oprot->getTransport()->flush();
15153
15154 if (this->eventHandler_.get() != NULL) {
15155 this->eventHandler_->postWrite(ctx, "Hbase.atomicIncrement", bytes);
15156 }
15157 }
15158
15159 void HbaseProcessor::process_deleteAll(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
15160 {
15161 void* ctx = NULL;
15162 if (this->eventHandler_.get() != NULL) {
15163 ctx = this->eventHandler_->getContext("Hbase.deleteAll", callContext);
15164 }
15165 ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "Hbase.deleteAll");
15166
15167 if (this->eventHandler_.get() != NULL) {
15168 this->eventHandler_->preRead(ctx, "Hbase.deleteAll");
15169 }
15170
15171 Hbase_deleteAll_args args;
15172 args.read(iprot);
15173 iprot->readMessageEnd();
15174 uint32_t bytes = iprot->getTransport()->readEnd();
15175
15176 if (this->eventHandler_.get() != NULL) {
15177 this->eventHandler_->postRead(ctx, "Hbase.deleteAll", bytes);
15178 }
15179
15180 Hbase_deleteAll_result result;
15181 try {
15182 iface_->deleteAll(args.tableName, args.row, args.column, args.attributes);
15183 } catch (IOError &io) {
15184 result.io = io;
15185 result.__isset.io = true;
15186 } catch (const std::exception& e) {
15187 if (this->eventHandler_.get() != NULL) {
15188 this->eventHandler_->handlerError(ctx, "Hbase.deleteAll");
15189 }
15190
15191 ::apache::thrift::TApplicationException x(e.what());
15192 oprot->writeMessageBegin("deleteAll", ::apache::thrift::protocol::T_EXCEPTION, seqid);
15193 x.write(oprot);
15194 oprot->writeMessageEnd();
15195 oprot->getTransport()->writeEnd();
15196 oprot->getTransport()->flush();
15197 return;
15198 }
15199
15200 if (this->eventHandler_.get() != NULL) {
15201 this->eventHandler_->preWrite(ctx, "Hbase.deleteAll");
15202 }
15203
15204 oprot->writeMessageBegin("deleteAll", ::apache::thrift::protocol::T_REPLY, seqid);
15205 result.write(oprot);
15206 oprot->writeMessageEnd();
15207 bytes = oprot->getTransport()->writeEnd();
15208 oprot->getTransport()->flush();
15209
15210 if (this->eventHandler_.get() != NULL) {
15211 this->eventHandler_->postWrite(ctx, "Hbase.deleteAll", bytes);
15212 }
15213 }
15214
15215 void HbaseProcessor::process_deleteAllTs(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
15216 {
15217 void* ctx = NULL;
15218 if (this->eventHandler_.get() != NULL) {
15219 ctx = this->eventHandler_->getContext("Hbase.deleteAllTs", callContext);
15220 }
15221 ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "Hbase.deleteAllTs");
15222
15223 if (this->eventHandler_.get() != NULL) {
15224 this->eventHandler_->preRead(ctx, "Hbase.deleteAllTs");
15225 }
15226
15227 Hbase_deleteAllTs_args args;
15228 args.read(iprot);
15229 iprot->readMessageEnd();
15230 uint32_t bytes = iprot->getTransport()->readEnd();
15231
15232 if (this->eventHandler_.get() != NULL) {
15233 this->eventHandler_->postRead(ctx, "Hbase.deleteAllTs", bytes);
15234 }
15235
15236 Hbase_deleteAllTs_result result;
15237 try {
15238 iface_->deleteAllTs(args.tableName, args.row, args.column, args.timestamp, args.attributes);
15239 } catch (IOError &io) {
15240 result.io = io;
15241 result.__isset.io = true;
15242 } catch (const std::exception& e) {
15243 if (this->eventHandler_.get() != NULL) {
15244 this->eventHandler_->handlerError(ctx, "Hbase.deleteAllTs");
15245 }
15246
15247 ::apache::thrift::TApplicationException x(e.what());
15248 oprot->writeMessageBegin("deleteAllTs", ::apache::thrift::protocol::T_EXCEPTION, seqid);
15249 x.write(oprot);
15250 oprot->writeMessageEnd();
15251 oprot->getTransport()->writeEnd();
15252 oprot->getTransport()->flush();
15253 return;
15254 }
15255
15256 if (this->eventHandler_.get() != NULL) {
15257 this->eventHandler_->preWrite(ctx, "Hbase.deleteAllTs");
15258 }
15259
15260 oprot->writeMessageBegin("deleteAllTs", ::apache::thrift::protocol::T_REPLY, seqid);
15261 result.write(oprot);
15262 oprot->writeMessageEnd();
15263 bytes = oprot->getTransport()->writeEnd();
15264 oprot->getTransport()->flush();
15265
15266 if (this->eventHandler_.get() != NULL) {
15267 this->eventHandler_->postWrite(ctx, "Hbase.deleteAllTs", bytes);
15268 }
15269 }
15270
15271 void HbaseProcessor::process_deleteAllRow(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
15272 {
15273 void* ctx = NULL;
15274 if (this->eventHandler_.get() != NULL) {
15275 ctx = this->eventHandler_->getContext("Hbase.deleteAllRow", callContext);
15276 }
15277 ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "Hbase.deleteAllRow");
15278
15279 if (this->eventHandler_.get() != NULL) {
15280 this->eventHandler_->preRead(ctx, "Hbase.deleteAllRow");
15281 }
15282
15283 Hbase_deleteAllRow_args args;
15284 args.read(iprot);
15285 iprot->readMessageEnd();
15286 uint32_t bytes = iprot->getTransport()->readEnd();
15287
15288 if (this->eventHandler_.get() != NULL) {
15289 this->eventHandler_->postRead(ctx, "Hbase.deleteAllRow", bytes);
15290 }
15291
15292 Hbase_deleteAllRow_result result;
15293 try {
15294 iface_->deleteAllRow(args.tableName, args.row, args.attributes);
15295 } catch (IOError &io) {
15296 result.io = io;
15297 result.__isset.io = true;
15298 } catch (const std::exception& e) {
15299 if (this->eventHandler_.get() != NULL) {
15300 this->eventHandler_->handlerError(ctx, "Hbase.deleteAllRow");
15301 }
15302
15303 ::apache::thrift::TApplicationException x(e.what());
15304 oprot->writeMessageBegin("deleteAllRow", ::apache::thrift::protocol::T_EXCEPTION, seqid);
15305 x.write(oprot);
15306 oprot->writeMessageEnd();
15307 oprot->getTransport()->writeEnd();
15308 oprot->getTransport()->flush();
15309 return;
15310 }
15311
15312 if (this->eventHandler_.get() != NULL) {
15313 this->eventHandler_->preWrite(ctx, "Hbase.deleteAllRow");
15314 }
15315
15316 oprot->writeMessageBegin("deleteAllRow", ::apache::thrift::protocol::T_REPLY, seqid);
15317 result.write(oprot);
15318 oprot->writeMessageEnd();
15319 bytes = oprot->getTransport()->writeEnd();
15320 oprot->getTransport()->flush();
15321
15322 if (this->eventHandler_.get() != NULL) {
15323 this->eventHandler_->postWrite(ctx, "Hbase.deleteAllRow", bytes);
15324 }
15325 }
15326
15327 void HbaseProcessor::process_increment(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
15328 {
15329 void* ctx = NULL;
15330 if (this->eventHandler_.get() != NULL) {
15331 ctx = this->eventHandler_->getContext("Hbase.increment", callContext);
15332 }
15333 ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "Hbase.increment");
15334
15335 if (this->eventHandler_.get() != NULL) {
15336 this->eventHandler_->preRead(ctx, "Hbase.increment");
15337 }
15338
15339 Hbase_increment_args args;
15340 args.read(iprot);
15341 iprot->readMessageEnd();
15342 uint32_t bytes = iprot->getTransport()->readEnd();
15343
15344 if (this->eventHandler_.get() != NULL) {
15345 this->eventHandler_->postRead(ctx, "Hbase.increment", bytes);
15346 }
15347
15348 Hbase_increment_result result;
15349 try {
15350 iface_->increment(args.increment);
15351 } catch (IOError &io) {
15352 result.io = io;
15353 result.__isset.io = true;
15354 } catch (const std::exception& e) {
15355 if (this->eventHandler_.get() != NULL) {
15356 this->eventHandler_->handlerError(ctx, "Hbase.increment");
15357 }
15358
15359 ::apache::thrift::TApplicationException x(e.what());
15360 oprot->writeMessageBegin("increment", ::apache::thrift::protocol::T_EXCEPTION, seqid);
15361 x.write(oprot);
15362 oprot->writeMessageEnd();
15363 oprot->getTransport()->writeEnd();
15364 oprot->getTransport()->flush();
15365 return;
15366 }
15367
15368 if (this->eventHandler_.get() != NULL) {
15369 this->eventHandler_->preWrite(ctx, "Hbase.increment");
15370 }
15371
15372 oprot->writeMessageBegin("increment", ::apache::thrift::protocol::T_REPLY, seqid);
15373 result.write(oprot);
15374 oprot->writeMessageEnd();
15375 bytes = oprot->getTransport()->writeEnd();
15376 oprot->getTransport()->flush();
15377
15378 if (this->eventHandler_.get() != NULL) {
15379 this->eventHandler_->postWrite(ctx, "Hbase.increment", bytes);
15380 }
15381 }
15382
15383 void HbaseProcessor::process_incrementRows(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
15384 {
15385 void* ctx = NULL;
15386 if (this->eventHandler_.get() != NULL) {
15387 ctx = this->eventHandler_->getContext("Hbase.incrementRows", callContext);
15388 }
15389 ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "Hbase.incrementRows");
15390
15391 if (this->eventHandler_.get() != NULL) {
15392 this->eventHandler_->preRead(ctx, "Hbase.incrementRows");
15393 }
15394
15395 Hbase_incrementRows_args args;
15396 args.read(iprot);
15397 iprot->readMessageEnd();
15398 uint32_t bytes = iprot->getTransport()->readEnd();
15399
15400 if (this->eventHandler_.get() != NULL) {
15401 this->eventHandler_->postRead(ctx, "Hbase.incrementRows", bytes);
15402 }
15403
15404 Hbase_incrementRows_result result;
15405 try {
15406 iface_->incrementRows(args.increments);
15407 } catch (IOError &io) {
15408 result.io = io;
15409 result.__isset.io = true;
15410 } catch (const std::exception& e) {
15411 if (this->eventHandler_.get() != NULL) {
15412 this->eventHandler_->handlerError(ctx, "Hbase.incrementRows");
15413 }
15414
15415 ::apache::thrift::TApplicationException x(e.what());
15416 oprot->writeMessageBegin("incrementRows", ::apache::thrift::protocol::T_EXCEPTION, seqid);
15417 x.write(oprot);
15418 oprot->writeMessageEnd();
15419 oprot->getTransport()->writeEnd();
15420 oprot->getTransport()->flush();
15421 return;
15422 }
15423
15424 if (this->eventHandler_.get() != NULL) {
15425 this->eventHandler_->preWrite(ctx, "Hbase.incrementRows");
15426 }
15427
15428 oprot->writeMessageBegin("incrementRows", ::apache::thrift::protocol::T_REPLY, seqid);
15429 result.write(oprot);
15430 oprot->writeMessageEnd();
15431 bytes = oprot->getTransport()->writeEnd();
15432 oprot->getTransport()->flush();
15433
15434 if (this->eventHandler_.get() != NULL) {
15435 this->eventHandler_->postWrite(ctx, "Hbase.incrementRows", bytes);
15436 }
15437 }
15438
15439 void HbaseProcessor::process_deleteAllRowTs(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
15440 {
15441 void* ctx = NULL;
15442 if (this->eventHandler_.get() != NULL) {
15443 ctx = this->eventHandler_->getContext("Hbase.deleteAllRowTs", callContext);
15444 }
15445 ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "Hbase.deleteAllRowTs");
15446
15447 if (this->eventHandler_.get() != NULL) {
15448 this->eventHandler_->preRead(ctx, "Hbase.deleteAllRowTs");
15449 }
15450
15451 Hbase_deleteAllRowTs_args args;
15452 args.read(iprot);
15453 iprot->readMessageEnd();
15454 uint32_t bytes = iprot->getTransport()->readEnd();
15455
15456 if (this->eventHandler_.get() != NULL) {
15457 this->eventHandler_->postRead(ctx, "Hbase.deleteAllRowTs", bytes);
15458 }
15459
15460 Hbase_deleteAllRowTs_result result;
15461 try {
15462 iface_->deleteAllRowTs(args.tableName, args.row, args.timestamp, args.attributes);
15463 } catch (IOError &io) {
15464 result.io = io;
15465 result.__isset.io = true;
15466 } catch (const std::exception& e) {
15467 if (this->eventHandler_.get() != NULL) {
15468 this->eventHandler_->handlerError(ctx, "Hbase.deleteAllRowTs");
15469 }
15470
15471 ::apache::thrift::TApplicationException x(e.what());
15472 oprot->writeMessageBegin("deleteAllRowTs", ::apache::thrift::protocol::T_EXCEPTION, seqid);
15473 x.write(oprot);
15474 oprot->writeMessageEnd();
15475 oprot->getTransport()->writeEnd();
15476 oprot->getTransport()->flush();
15477 return;
15478 }
15479
15480 if (this->eventHandler_.get() != NULL) {
15481 this->eventHandler_->preWrite(ctx, "Hbase.deleteAllRowTs");
15482 }
15483
15484 oprot->writeMessageBegin("deleteAllRowTs", ::apache::thrift::protocol::T_REPLY, seqid);
15485 result.write(oprot);
15486 oprot->writeMessageEnd();
15487 bytes = oprot->getTransport()->writeEnd();
15488 oprot->getTransport()->flush();
15489
15490 if (this->eventHandler_.get() != NULL) {
15491 this->eventHandler_->postWrite(ctx, "Hbase.deleteAllRowTs", bytes);
15492 }
15493 }
15494
15495 void HbaseProcessor::process_scannerOpenWithScan(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
15496 {
15497 void* ctx = NULL;
15498 if (this->eventHandler_.get() != NULL) {
15499 ctx = this->eventHandler_->getContext("Hbase.scannerOpenWithScan", callContext);
15500 }
15501 ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "Hbase.scannerOpenWithScan");
15502
15503 if (this->eventHandler_.get() != NULL) {
15504 this->eventHandler_->preRead(ctx, "Hbase.scannerOpenWithScan");
15505 }
15506
15507 Hbase_scannerOpenWithScan_args args;
15508 args.read(iprot);
15509 iprot->readMessageEnd();
15510 uint32_t bytes = iprot->getTransport()->readEnd();
15511
15512 if (this->eventHandler_.get() != NULL) {
15513 this->eventHandler_->postRead(ctx, "Hbase.scannerOpenWithScan", bytes);
15514 }
15515
15516 Hbase_scannerOpenWithScan_result result;
15517 try {
15518 result.success = iface_->scannerOpenWithScan(args.tableName, args.scan, args.attributes);
15519 result.__isset.success = true;
15520 } catch (IOError &io) {
15521 result.io = io;
15522 result.__isset.io = true;
15523 } catch (const std::exception& e) {
15524 if (this->eventHandler_.get() != NULL) {
15525 this->eventHandler_->handlerError(ctx, "Hbase.scannerOpenWithScan");
15526 }
15527
15528 ::apache::thrift::TApplicationException x(e.what());
15529 oprot->writeMessageBegin("scannerOpenWithScan", ::apache::thrift::protocol::T_EXCEPTION, seqid);
15530 x.write(oprot);
15531 oprot->writeMessageEnd();
15532 oprot->getTransport()->writeEnd();
15533 oprot->getTransport()->flush();
15534 return;
15535 }
15536
15537 if (this->eventHandler_.get() != NULL) {
15538 this->eventHandler_->preWrite(ctx, "Hbase.scannerOpenWithScan");
15539 }
15540
15541 oprot->writeMessageBegin("scannerOpenWithScan", ::apache::thrift::protocol::T_REPLY, seqid);
15542 result.write(oprot);
15543 oprot->writeMessageEnd();
15544 bytes = oprot->getTransport()->writeEnd();
15545 oprot->getTransport()->flush();
15546
15547 if (this->eventHandler_.get() != NULL) {
15548 this->eventHandler_->postWrite(ctx, "Hbase.scannerOpenWithScan", bytes);
15549 }
15550 }
15551
15552 void HbaseProcessor::process_scannerOpen(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
15553 {
15554 void* ctx = NULL;
15555 if (this->eventHandler_.get() != NULL) {
15556 ctx = this->eventHandler_->getContext("Hbase.scannerOpen", callContext);
15557 }
15558 ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "Hbase.scannerOpen");
15559
15560 if (this->eventHandler_.get() != NULL) {
15561 this->eventHandler_->preRead(ctx, "Hbase.scannerOpen");
15562 }
15563
15564 Hbase_scannerOpen_args args;
15565 args.read(iprot);
15566 iprot->readMessageEnd();
15567 uint32_t bytes = iprot->getTransport()->readEnd();
15568
15569 if (this->eventHandler_.get() != NULL) {
15570 this->eventHandler_->postRead(ctx, "Hbase.scannerOpen", bytes);
15571 }
15572
15573 Hbase_scannerOpen_result result;
15574 try {
15575 result.success = iface_->scannerOpen(args.tableName, args.startRow, args.columns, args.attributes);
15576 result.__isset.success = true;
15577 } catch (IOError &io) {
15578 result.io = io;
15579 result.__isset.io = true;
15580 } catch (const std::exception& e) {
15581 if (this->eventHandler_.get() != NULL) {
15582 this->eventHandler_->handlerError(ctx, "Hbase.scannerOpen");
15583 }
15584
15585 ::apache::thrift::TApplicationException x(e.what());
15586 oprot->writeMessageBegin("scannerOpen", ::apache::thrift::protocol::T_EXCEPTION, seqid);
15587 x.write(oprot);
15588 oprot->writeMessageEnd();
15589 oprot->getTransport()->writeEnd();
15590 oprot->getTransport()->flush();
15591 return;
15592 }
15593
15594 if (this->eventHandler_.get() != NULL) {
15595 this->eventHandler_->preWrite(ctx, "Hbase.scannerOpen");
15596 }
15597
15598 oprot->writeMessageBegin("scannerOpen", ::apache::thrift::protocol::T_REPLY, seqid);
15599 result.write(oprot);
15600 oprot->writeMessageEnd();
15601 bytes = oprot->getTransport()->writeEnd();
15602 oprot->getTransport()->flush();
15603
15604 if (this->eventHandler_.get() != NULL) {
15605 this->eventHandler_->postWrite(ctx, "Hbase.scannerOpen", bytes);
15606 }
15607 }
15608
15609 void HbaseProcessor::process_scannerOpenWithStop(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
15610 {
15611 void* ctx = NULL;
15612 if (this->eventHandler_.get() != NULL) {
15613 ctx = this->eventHandler_->getContext("Hbase.scannerOpenWithStop", callContext);
15614 }
15615 ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "Hbase.scannerOpenWithStop");
15616
15617 if (this->eventHandler_.get() != NULL) {
15618 this->eventHandler_->preRead(ctx, "Hbase.scannerOpenWithStop");
15619 }
15620
15621 Hbase_scannerOpenWithStop_args args;
15622 args.read(iprot);
15623 iprot->readMessageEnd();
15624 uint32_t bytes = iprot->getTransport()->readEnd();
15625
15626 if (this->eventHandler_.get() != NULL) {
15627 this->eventHandler_->postRead(ctx, "Hbase.scannerOpenWithStop", bytes);
15628 }
15629
15630 Hbase_scannerOpenWithStop_result result;
15631 try {
15632 result.success = iface_->scannerOpenWithStop(args.tableName, args.startRow, args.stopRow, args.columns, args.attributes);
15633 result.__isset.success = true;
15634 } catch (IOError &io) {
15635 result.io = io;
15636 result.__isset.io = true;
15637 } catch (const std::exception& e) {
15638 if (this->eventHandler_.get() != NULL) {
15639 this->eventHandler_->handlerError(ctx, "Hbase.scannerOpenWithStop");
15640 }
15641
15642 ::apache::thrift::TApplicationException x(e.what());
15643 oprot->writeMessageBegin("scannerOpenWithStop", ::apache::thrift::protocol::T_EXCEPTION, seqid);
15644 x.write(oprot);
15645 oprot->writeMessageEnd();
15646 oprot->getTransport()->writeEnd();
15647 oprot->getTransport()->flush();
15648 return;
15649 }
15650
15651 if (this->eventHandler_.get() != NULL) {
15652 this->eventHandler_->preWrite(ctx, "Hbase.scannerOpenWithStop");
15653 }
15654
15655 oprot->writeMessageBegin("scannerOpenWithStop", ::apache::thrift::protocol::T_REPLY, seqid);
15656 result.write(oprot);
15657 oprot->writeMessageEnd();
15658 bytes = oprot->getTransport()->writeEnd();
15659 oprot->getTransport()->flush();
15660
15661 if (this->eventHandler_.get() != NULL) {
15662 this->eventHandler_->postWrite(ctx, "Hbase.scannerOpenWithStop", bytes);
15663 }
15664 }
15665
15666 void HbaseProcessor::process_scannerOpenWithPrefix(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
15667 {
15668 void* ctx = NULL;
15669 if (this->eventHandler_.get() != NULL) {
15670 ctx = this->eventHandler_->getContext("Hbase.scannerOpenWithPrefix", callContext);
15671 }
15672 ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "Hbase.scannerOpenWithPrefix");
15673
15674 if (this->eventHandler_.get() != NULL) {
15675 this->eventHandler_->preRead(ctx, "Hbase.scannerOpenWithPrefix");
15676 }
15677
15678 Hbase_scannerOpenWithPrefix_args args;
15679 args.read(iprot);
15680 iprot->readMessageEnd();
15681 uint32_t bytes = iprot->getTransport()->readEnd();
15682
15683 if (this->eventHandler_.get() != NULL) {
15684 this->eventHandler_->postRead(ctx, "Hbase.scannerOpenWithPrefix", bytes);
15685 }
15686
15687 Hbase_scannerOpenWithPrefix_result result;
15688 try {
15689 result.success = iface_->scannerOpenWithPrefix(args.tableName, args.startAndPrefix, args.columns, args.attributes);
15690 result.__isset.success = true;
15691 } catch (IOError &io) {
15692 result.io = io;
15693 result.__isset.io = true;
15694 } catch (const std::exception& e) {
15695 if (this->eventHandler_.get() != NULL) {
15696 this->eventHandler_->handlerError(ctx, "Hbase.scannerOpenWithPrefix");
15697 }
15698
15699 ::apache::thrift::TApplicationException x(e.what());
15700 oprot->writeMessageBegin("scannerOpenWithPrefix", ::apache::thrift::protocol::T_EXCEPTION, seqid);
15701 x.write(oprot);
15702 oprot->writeMessageEnd();
15703 oprot->getTransport()->writeEnd();
15704 oprot->getTransport()->flush();
15705 return;
15706 }
15707
15708 if (this->eventHandler_.get() != NULL) {
15709 this->eventHandler_->preWrite(ctx, "Hbase.scannerOpenWithPrefix");
15710 }
15711
15712 oprot->writeMessageBegin("scannerOpenWithPrefix", ::apache::thrift::protocol::T_REPLY, seqid);
15713 result.write(oprot);
15714 oprot->writeMessageEnd();
15715 bytes = oprot->getTransport()->writeEnd();
15716 oprot->getTransport()->flush();
15717
15718 if (this->eventHandler_.get() != NULL) {
15719 this->eventHandler_->postWrite(ctx, "Hbase.scannerOpenWithPrefix", bytes);
15720 }
15721 }
15722
15723 void HbaseProcessor::process_scannerOpenTs(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
15724 {
15725 void* ctx = NULL;
15726 if (this->eventHandler_.get() != NULL) {
15727 ctx = this->eventHandler_->getContext("Hbase.scannerOpenTs", callContext);
15728 }
15729 ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "Hbase.scannerOpenTs");
15730
15731 if (this->eventHandler_.get() != NULL) {
15732 this->eventHandler_->preRead(ctx, "Hbase.scannerOpenTs");
15733 }
15734
15735 Hbase_scannerOpenTs_args args;
15736 args.read(iprot);
15737 iprot->readMessageEnd();
15738 uint32_t bytes = iprot->getTransport()->readEnd();
15739
15740 if (this->eventHandler_.get() != NULL) {
15741 this->eventHandler_->postRead(ctx, "Hbase.scannerOpenTs", bytes);
15742 }
15743
15744 Hbase_scannerOpenTs_result result;
15745 try {
15746 result.success = iface_->scannerOpenTs(args.tableName, args.startRow, args.columns, args.timestamp, args.attributes);
15747 result.__isset.success = true;
15748 } catch (IOError &io) {
15749 result.io = io;
15750 result.__isset.io = true;
15751 } catch (const std::exception& e) {
15752 if (this->eventHandler_.get() != NULL) {
15753 this->eventHandler_->handlerError(ctx, "Hbase.scannerOpenTs");
15754 }
15755
15756 ::apache::thrift::TApplicationException x(e.what());
15757 oprot->writeMessageBegin("scannerOpenTs", ::apache::thrift::protocol::T_EXCEPTION, seqid);
15758 x.write(oprot);
15759 oprot->writeMessageEnd();
15760 oprot->getTransport()->writeEnd();
15761 oprot->getTransport()->flush();
15762 return;
15763 }
15764
15765 if (this->eventHandler_.get() != NULL) {
15766 this->eventHandler_->preWrite(ctx, "Hbase.scannerOpenTs");
15767 }
15768
15769 oprot->writeMessageBegin("scannerOpenTs", ::apache::thrift::protocol::T_REPLY, seqid);
15770 result.write(oprot);
15771 oprot->writeMessageEnd();
15772 bytes = oprot->getTransport()->writeEnd();
15773 oprot->getTransport()->flush();
15774
15775 if (this->eventHandler_.get() != NULL) {
15776 this->eventHandler_->postWrite(ctx, "Hbase.scannerOpenTs", bytes);
15777 }
15778 }
15779
15780 void HbaseProcessor::process_scannerOpenWithStopTs(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
15781 {
15782 void* ctx = NULL;
15783 if (this->eventHandler_.get() != NULL) {
15784 ctx = this->eventHandler_->getContext("Hbase.scannerOpenWithStopTs", callContext);
15785 }
15786 ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "Hbase.scannerOpenWithStopTs");
15787
15788 if (this->eventHandler_.get() != NULL) {
15789 this->eventHandler_->preRead(ctx, "Hbase.scannerOpenWithStopTs");
15790 }
15791
15792 Hbase_scannerOpenWithStopTs_args args;
15793 args.read(iprot);
15794 iprot->readMessageEnd();
15795 uint32_t bytes = iprot->getTransport()->readEnd();
15796
15797 if (this->eventHandler_.get() != NULL) {
15798 this->eventHandler_->postRead(ctx, "Hbase.scannerOpenWithStopTs", bytes);
15799 }
15800
15801 Hbase_scannerOpenWithStopTs_result result;
15802 try {
15803 result.success = iface_->scannerOpenWithStopTs(args.tableName, args.startRow, args.stopRow, args.columns, args.timestamp, args.attributes);
15804 result.__isset.success = true;
15805 } catch (IOError &io) {
15806 result.io = io;
15807 result.__isset.io = true;
15808 } catch (const std::exception& e) {
15809 if (this->eventHandler_.get() != NULL) {
15810 this->eventHandler_->handlerError(ctx, "Hbase.scannerOpenWithStopTs");
15811 }
15812
15813 ::apache::thrift::TApplicationException x(e.what());
15814 oprot->writeMessageBegin("scannerOpenWithStopTs", ::apache::thrift::protocol::T_EXCEPTION, seqid);
15815 x.write(oprot);
15816 oprot->writeMessageEnd();
15817 oprot->getTransport()->writeEnd();
15818 oprot->getTransport()->flush();
15819 return;
15820 }
15821
15822 if (this->eventHandler_.get() != NULL) {
15823 this->eventHandler_->preWrite(ctx, "Hbase.scannerOpenWithStopTs");
15824 }
15825
15826 oprot->writeMessageBegin("scannerOpenWithStopTs", ::apache::thrift::protocol::T_REPLY, seqid);
15827 result.write(oprot);
15828 oprot->writeMessageEnd();
15829 bytes = oprot->getTransport()->writeEnd();
15830 oprot->getTransport()->flush();
15831
15832 if (this->eventHandler_.get() != NULL) {
15833 this->eventHandler_->postWrite(ctx, "Hbase.scannerOpenWithStopTs", bytes);
15834 }
15835 }
15836
15837 void HbaseProcessor::process_scannerGet(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
15838 {
15839 void* ctx = NULL;
15840 if (this->eventHandler_.get() != NULL) {
15841 ctx = this->eventHandler_->getContext("Hbase.scannerGet", callContext);
15842 }
15843 ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "Hbase.scannerGet");
15844
15845 if (this->eventHandler_.get() != NULL) {
15846 this->eventHandler_->preRead(ctx, "Hbase.scannerGet");
15847 }
15848
15849 Hbase_scannerGet_args args;
15850 args.read(iprot);
15851 iprot->readMessageEnd();
15852 uint32_t bytes = iprot->getTransport()->readEnd();
15853
15854 if (this->eventHandler_.get() != NULL) {
15855 this->eventHandler_->postRead(ctx, "Hbase.scannerGet", bytes);
15856 }
15857
15858 Hbase_scannerGet_result result;
15859 try {
15860 iface_->scannerGet(result.success, args.id);
15861 result.__isset.success = true;
15862 } catch (IOError &io) {
15863 result.io = io;
15864 result.__isset.io = true;
15865 } catch (IllegalArgument &ia) {
15866 result.ia = ia;
15867 result.__isset.ia = true;
15868 } catch (const std::exception& e) {
15869 if (this->eventHandler_.get() != NULL) {
15870 this->eventHandler_->handlerError(ctx, "Hbase.scannerGet");
15871 }
15872
15873 ::apache::thrift::TApplicationException x(e.what());
15874 oprot->writeMessageBegin("scannerGet", ::apache::thrift::protocol::T_EXCEPTION, seqid);
15875 x.write(oprot);
15876 oprot->writeMessageEnd();
15877 oprot->getTransport()->writeEnd();
15878 oprot->getTransport()->flush();
15879 return;
15880 }
15881
15882 if (this->eventHandler_.get() != NULL) {
15883 this->eventHandler_->preWrite(ctx, "Hbase.scannerGet");
15884 }
15885
15886 oprot->writeMessageBegin("scannerGet", ::apache::thrift::protocol::T_REPLY, seqid);
15887 result.write(oprot);
15888 oprot->writeMessageEnd();
15889 bytes = oprot->getTransport()->writeEnd();
15890 oprot->getTransport()->flush();
15891
15892 if (this->eventHandler_.get() != NULL) {
15893 this->eventHandler_->postWrite(ctx, "Hbase.scannerGet", bytes);
15894 }
15895 }
15896
15897 void HbaseProcessor::process_scannerGetList(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
15898 {
15899 void* ctx = NULL;
15900 if (this->eventHandler_.get() != NULL) {
15901 ctx = this->eventHandler_->getContext("Hbase.scannerGetList", callContext);
15902 }
15903 ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "Hbase.scannerGetList");
15904
15905 if (this->eventHandler_.get() != NULL) {
15906 this->eventHandler_->preRead(ctx, "Hbase.scannerGetList");
15907 }
15908
15909 Hbase_scannerGetList_args args;
15910 args.read(iprot);
15911 iprot->readMessageEnd();
15912 uint32_t bytes = iprot->getTransport()->readEnd();
15913
15914 if (this->eventHandler_.get() != NULL) {
15915 this->eventHandler_->postRead(ctx, "Hbase.scannerGetList", bytes);
15916 }
15917
15918 Hbase_scannerGetList_result result;
15919 try {
15920 iface_->scannerGetList(result.success, args.id, args.nbRows);
15921 result.__isset.success = true;
15922 } catch (IOError &io) {
15923 result.io = io;
15924 result.__isset.io = true;
15925 } catch (IllegalArgument &ia) {
15926 result.ia = ia;
15927 result.__isset.ia = true;
15928 } catch (const std::exception& e) {
15929 if (this->eventHandler_.get() != NULL) {
15930 this->eventHandler_->handlerError(ctx, "Hbase.scannerGetList");
15931 }
15932
15933 ::apache::thrift::TApplicationException x(e.what());
15934 oprot->writeMessageBegin("scannerGetList", ::apache::thrift::protocol::T_EXCEPTION, seqid);
15935 x.write(oprot);
15936 oprot->writeMessageEnd();
15937 oprot->getTransport()->writeEnd();
15938 oprot->getTransport()->flush();
15939 return;
15940 }
15941
15942 if (this->eventHandler_.get() != NULL) {
15943 this->eventHandler_->preWrite(ctx, "Hbase.scannerGetList");
15944 }
15945
15946 oprot->writeMessageBegin("scannerGetList", ::apache::thrift::protocol::T_REPLY, seqid);
15947 result.write(oprot);
15948 oprot->writeMessageEnd();
15949 bytes = oprot->getTransport()->writeEnd();
15950 oprot->getTransport()->flush();
15951
15952 if (this->eventHandler_.get() != NULL) {
15953 this->eventHandler_->postWrite(ctx, "Hbase.scannerGetList", bytes);
15954 }
15955 }
15956
15957 void HbaseProcessor::process_scannerClose(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
15958 {
15959 void* ctx = NULL;
15960 if (this->eventHandler_.get() != NULL) {
15961 ctx = this->eventHandler_->getContext("Hbase.scannerClose", callContext);
15962 }
15963 ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "Hbase.scannerClose");
15964
15965 if (this->eventHandler_.get() != NULL) {
15966 this->eventHandler_->preRead(ctx, "Hbase.scannerClose");
15967 }
15968
15969 Hbase_scannerClose_args args;
15970 args.read(iprot);
15971 iprot->readMessageEnd();
15972 uint32_t bytes = iprot->getTransport()->readEnd();
15973
15974 if (this->eventHandler_.get() != NULL) {
15975 this->eventHandler_->postRead(ctx, "Hbase.scannerClose", bytes);
15976 }
15977
15978 Hbase_scannerClose_result result;
15979 try {
15980 iface_->scannerClose(args.id);
15981 } catch (IOError &io) {
15982 result.io = io;
15983 result.__isset.io = true;
15984 } catch (IllegalArgument &ia) {
15985 result.ia = ia;
15986 result.__isset.ia = true;
15987 } catch (const std::exception& e) {
15988 if (this->eventHandler_.get() != NULL) {
15989 this->eventHandler_->handlerError(ctx, "Hbase.scannerClose");
15990 }
15991
15992 ::apache::thrift::TApplicationException x(e.what());
15993 oprot->writeMessageBegin("scannerClose", ::apache::thrift::protocol::T_EXCEPTION, seqid);
15994 x.write(oprot);
15995 oprot->writeMessageEnd();
15996 oprot->getTransport()->writeEnd();
15997 oprot->getTransport()->flush();
15998 return;
15999 }
16000
16001 if (this->eventHandler_.get() != NULL) {
16002 this->eventHandler_->preWrite(ctx, "Hbase.scannerClose");
16003 }
16004
16005 oprot->writeMessageBegin("scannerClose", ::apache::thrift::protocol::T_REPLY, seqid);
16006 result.write(oprot);
16007 oprot->writeMessageEnd();
16008 bytes = oprot->getTransport()->writeEnd();
16009 oprot->getTransport()->flush();
16010
16011 if (this->eventHandler_.get() != NULL) {
16012 this->eventHandler_->postWrite(ctx, "Hbase.scannerClose", bytes);
16013 }
16014 }
16015
16016 void HbaseProcessor::process_getRowOrBefore(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
16017 {
16018 void* ctx = NULL;
16019 if (this->eventHandler_.get() != NULL) {
16020 ctx = this->eventHandler_->getContext("Hbase.getRowOrBefore", callContext);
16021 }
16022 ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "Hbase.getRowOrBefore");
16023
16024 if (this->eventHandler_.get() != NULL) {
16025 this->eventHandler_->preRead(ctx, "Hbase.getRowOrBefore");
16026 }
16027
16028 Hbase_getRowOrBefore_args args;
16029 args.read(iprot);
16030 iprot->readMessageEnd();
16031 uint32_t bytes = iprot->getTransport()->readEnd();
16032
16033 if (this->eventHandler_.get() != NULL) {
16034 this->eventHandler_->postRead(ctx, "Hbase.getRowOrBefore", bytes);
16035 }
16036
16037 Hbase_getRowOrBefore_result result;
16038 try {
16039 iface_->getRowOrBefore(result.success, args.tableName, args.row, args.family);
16040 result.__isset.success = true;
16041 } catch (IOError &io) {
16042 result.io = io;
16043 result.__isset.io = true;
16044 } catch (const std::exception& e) {
16045 if (this->eventHandler_.get() != NULL) {
16046 this->eventHandler_->handlerError(ctx, "Hbase.getRowOrBefore");
16047 }
16048
16049 ::apache::thrift::TApplicationException x(e.what());
16050 oprot->writeMessageBegin("getRowOrBefore", ::apache::thrift::protocol::T_EXCEPTION, seqid);
16051 x.write(oprot);
16052 oprot->writeMessageEnd();
16053 oprot->getTransport()->writeEnd();
16054 oprot->getTransport()->flush();
16055 return;
16056 }
16057
16058 if (this->eventHandler_.get() != NULL) {
16059 this->eventHandler_->preWrite(ctx, "Hbase.getRowOrBefore");
16060 }
16061
16062 oprot->writeMessageBegin("getRowOrBefore", ::apache::thrift::protocol::T_REPLY, seqid);
16063 result.write(oprot);
16064 oprot->writeMessageEnd();
16065 bytes = oprot->getTransport()->writeEnd();
16066 oprot->getTransport()->flush();
16067
16068 if (this->eventHandler_.get() != NULL) {
16069 this->eventHandler_->postWrite(ctx, "Hbase.getRowOrBefore", bytes);
16070 }
16071 }
16072
16073 void HbaseProcessor::process_getRegionInfo(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
16074 {
16075 void* ctx = NULL;
16076 if (this->eventHandler_.get() != NULL) {
16077 ctx = this->eventHandler_->getContext("Hbase.getRegionInfo", callContext);
16078 }
16079 ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "Hbase.getRegionInfo");
16080
16081 if (this->eventHandler_.get() != NULL) {
16082 this->eventHandler_->preRead(ctx, "Hbase.getRegionInfo");
16083 }
16084
16085 Hbase_getRegionInfo_args args;
16086 args.read(iprot);
16087 iprot->readMessageEnd();
16088 uint32_t bytes = iprot->getTransport()->readEnd();
16089
16090 if (this->eventHandler_.get() != NULL) {
16091 this->eventHandler_->postRead(ctx, "Hbase.getRegionInfo", bytes);
16092 }
16093
16094 Hbase_getRegionInfo_result result;
16095 try {
16096 iface_->getRegionInfo(result.success, args.row);
16097 result.__isset.success = true;
16098 } catch (IOError &io) {
16099 result.io = io;
16100 result.__isset.io = true;
16101 } catch (const std::exception& e) {
16102 if (this->eventHandler_.get() != NULL) {
16103 this->eventHandler_->handlerError(ctx, "Hbase.getRegionInfo");
16104 }
16105
16106 ::apache::thrift::TApplicationException x(e.what());
16107 oprot->writeMessageBegin("getRegionInfo", ::apache::thrift::protocol::T_EXCEPTION, seqid);
16108 x.write(oprot);
16109 oprot->writeMessageEnd();
16110 oprot->getTransport()->writeEnd();
16111 oprot->getTransport()->flush();
16112 return;
16113 }
16114
16115 if (this->eventHandler_.get() != NULL) {
16116 this->eventHandler_->preWrite(ctx, "Hbase.getRegionInfo");
16117 }
16118
16119 oprot->writeMessageBegin("getRegionInfo", ::apache::thrift::protocol::T_REPLY, seqid);
16120 result.write(oprot);
16121 oprot->writeMessageEnd();
16122 bytes = oprot->getTransport()->writeEnd();
16123 oprot->getTransport()->flush();
16124
16125 if (this->eventHandler_.get() != NULL) {
16126 this->eventHandler_->postWrite(ctx, "Hbase.getRegionInfo", bytes);
16127 }
16128 }
16129
16130 std::shared_ptr< ::apache::thrift::TProcessor > HbaseProcessorFactory::getProcessor(const ::apache::thrift::TConnectionInfo& connInfo) {
16131 ::apache::thrift::ReleaseHandler< HbaseIfFactory > cleanup(handlerFactory_);
16132 std::shared_ptr< HbaseIf > handler(handlerFactory_->getHandler(connInfo), cleanup);
16133 std::shared_ptr< ::apache::thrift::TProcessor > processor(new HbaseProcessor(handler));
16134 return processor;
16135 }
16136 }}}} // namespace
16137
HBase