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_types.h"
8
9 #include <algorithm>
10
11 namespace apache { namespace hadoop { namespace hbase { namespace thrift {
12
13 const char* TCell::ascii_fingerprint = "1CCCF6FC31CFD1D61BBBB1BAF3590620";
14 const uint8_t TCell::binary_fingerprint[16] = {0x1C,0xCC,0xF6,0xFC,0x31,0xCF,0xD1,0xD6,0x1B,0xBB,0xB1,0xBA,0xF3,0x59,0x06,0x20};
15
read(::apache::thrift::protocol::TProtocol * iprot)16 uint32_t TCell::read(::apache::thrift::protocol::TProtocol* iprot) {
17
18 uint32_t xfer = 0;
19 std::string fname;
20 ::apache::thrift::protocol::TType ftype;
21 int16_t fid;
22
23 xfer += iprot->readStructBegin(fname);
24
25 using ::apache::thrift::protocol::TProtocolException;
26
27
28 while (true)
29 {
30 xfer += iprot->readFieldBegin(fname, ftype, fid);
31 if (ftype == ::apache::thrift::protocol::T_STOP) {
32 break;
33 }
34 switch (fid)
35 {
36 case 1:
37 if (ftype == ::apache::thrift::protocol::T_STRING) {
38 xfer += iprot->readBinary(this->value);
39 this->__isset.value = true;
40 } else {
41 xfer += iprot->skip(ftype);
42 }
43 break;
44 case 2:
45 if (ftype == ::apache::thrift::protocol::T_I64) {
46 xfer += iprot->readI64(this->timestamp);
47 this->__isset.timestamp = true;
48 } else {
49 xfer += iprot->skip(ftype);
50 }
51 break;
52 default:
53 xfer += iprot->skip(ftype);
54 break;
55 }
56 xfer += iprot->readFieldEnd();
57 }
58
59 xfer += iprot->readStructEnd();
60
61 return xfer;
62 }
63
write(::apache::thrift::protocol::TProtocol * oprot) const64 uint32_t TCell::write(::apache::thrift::protocol::TProtocol* oprot) const {
65 uint32_t xfer = 0;
66 xfer += oprot->writeStructBegin("TCell");
67
68 xfer += oprot->writeFieldBegin("value", ::apache::thrift::protocol::T_STRING, 1);
69 xfer += oprot->writeBinary(this->value);
70 xfer += oprot->writeFieldEnd();
71
72 xfer += oprot->writeFieldBegin("timestamp", ::apache::thrift::protocol::T_I64, 2);
73 xfer += oprot->writeI64(this->timestamp);
74 xfer += oprot->writeFieldEnd();
75
76 xfer += oprot->writeFieldStop();
77 xfer += oprot->writeStructEnd();
78 return xfer;
79 }
80
swap(TCell & a,TCell & b)81 void swap(TCell &a, TCell &b) {
82 using ::std::swap;
83 swap(a.value, b.value);
84 swap(a.timestamp, b.timestamp);
85 swap(a.__isset, b.__isset);
86 }
87
88 const char* ColumnDescriptor::ascii_fingerprint = "3B18638852FDF9DD911BC1174265F92E";
89 const uint8_t ColumnDescriptor::binary_fingerprint[16] = {0x3B,0x18,0x63,0x88,0x52,0xFD,0xF9,0xDD,0x91,0x1B,0xC1,0x17,0x42,0x65,0xF9,0x2E};
90
read(::apache::thrift::protocol::TProtocol * iprot)91 uint32_t ColumnDescriptor::read(::apache::thrift::protocol::TProtocol* iprot) {
92
93 uint32_t xfer = 0;
94 std::string fname;
95 ::apache::thrift::protocol::TType ftype;
96 int16_t fid;
97
98 xfer += iprot->readStructBegin(fname);
99
100 using ::apache::thrift::protocol::TProtocolException;
101
102
103 while (true)
104 {
105 xfer += iprot->readFieldBegin(fname, ftype, fid);
106 if (ftype == ::apache::thrift::protocol::T_STOP) {
107 break;
108 }
109 switch (fid)
110 {
111 case 1:
112 if (ftype == ::apache::thrift::protocol::T_STRING) {
113 xfer += iprot->readBinary(this->name);
114 this->__isset.name = true;
115 } else {
116 xfer += iprot->skip(ftype);
117 }
118 break;
119 case 2:
120 if (ftype == ::apache::thrift::protocol::T_I32) {
121 xfer += iprot->readI32(this->maxVersions);
122 this->__isset.maxVersions = true;
123 } else {
124 xfer += iprot->skip(ftype);
125 }
126 break;
127 case 3:
128 if (ftype == ::apache::thrift::protocol::T_STRING) {
129 xfer += iprot->readString(this->compression);
130 this->__isset.compression = true;
131 } else {
132 xfer += iprot->skip(ftype);
133 }
134 break;
135 case 4:
136 if (ftype == ::apache::thrift::protocol::T_BOOL) {
137 xfer += iprot->readBool(this->inMemory);
138 this->__isset.inMemory = true;
139 } else {
140 xfer += iprot->skip(ftype);
141 }
142 break;
143 case 5:
144 if (ftype == ::apache::thrift::protocol::T_STRING) {
145 xfer += iprot->readString(this->bloomFilterType);
146 this->__isset.bloomFilterType = true;
147 } else {
148 xfer += iprot->skip(ftype);
149 }
150 break;
151 case 6:
152 if (ftype == ::apache::thrift::protocol::T_I32) {
153 xfer += iprot->readI32(this->bloomFilterVectorSize);
154 this->__isset.bloomFilterVectorSize = true;
155 } else {
156 xfer += iprot->skip(ftype);
157 }
158 break;
159 case 7:
160 if (ftype == ::apache::thrift::protocol::T_I32) {
161 xfer += iprot->readI32(this->bloomFilterNbHashes);
162 this->__isset.bloomFilterNbHashes = true;
163 } else {
164 xfer += iprot->skip(ftype);
165 }
166 break;
167 case 8:
168 if (ftype == ::apache::thrift::protocol::T_BOOL) {
169 xfer += iprot->readBool(this->blockCacheEnabled);
170 this->__isset.blockCacheEnabled = true;
171 } else {
172 xfer += iprot->skip(ftype);
173 }
174 break;
175 case 9:
176 if (ftype == ::apache::thrift::protocol::T_I32) {
177 xfer += iprot->readI32(this->timeToLive);
178 this->__isset.timeToLive = true;
179 } else {
180 xfer += iprot->skip(ftype);
181 }
182 break;
183 default:
184 xfer += iprot->skip(ftype);
185 break;
186 }
187 xfer += iprot->readFieldEnd();
188 }
189
190 xfer += iprot->readStructEnd();
191
192 return xfer;
193 }
194
write(::apache::thrift::protocol::TProtocol * oprot) const195 uint32_t ColumnDescriptor::write(::apache::thrift::protocol::TProtocol* oprot) const {
196 uint32_t xfer = 0;
197 xfer += oprot->writeStructBegin("ColumnDescriptor");
198
199 xfer += oprot->writeFieldBegin("name", ::apache::thrift::protocol::T_STRING, 1);
200 xfer += oprot->writeBinary(this->name);
201 xfer += oprot->writeFieldEnd();
202
203 xfer += oprot->writeFieldBegin("maxVersions", ::apache::thrift::protocol::T_I32, 2);
204 xfer += oprot->writeI32(this->maxVersions);
205 xfer += oprot->writeFieldEnd();
206
207 xfer += oprot->writeFieldBegin("compression", ::apache::thrift::protocol::T_STRING, 3);
208 xfer += oprot->writeString(this->compression);
209 xfer += oprot->writeFieldEnd();
210
211 xfer += oprot->writeFieldBegin("inMemory", ::apache::thrift::protocol::T_BOOL, 4);
212 xfer += oprot->writeBool(this->inMemory);
213 xfer += oprot->writeFieldEnd();
214
215 xfer += oprot->writeFieldBegin("bloomFilterType", ::apache::thrift::protocol::T_STRING, 5);
216 xfer += oprot->writeString(this->bloomFilterType);
217 xfer += oprot->writeFieldEnd();
218
219 xfer += oprot->writeFieldBegin("bloomFilterVectorSize", ::apache::thrift::protocol::T_I32, 6);
220 xfer += oprot->writeI32(this->bloomFilterVectorSize);
221 xfer += oprot->writeFieldEnd();
222
223 xfer += oprot->writeFieldBegin("bloomFilterNbHashes", ::apache::thrift::protocol::T_I32, 7);
224 xfer += oprot->writeI32(this->bloomFilterNbHashes);
225 xfer += oprot->writeFieldEnd();
226
227 xfer += oprot->writeFieldBegin("blockCacheEnabled", ::apache::thrift::protocol::T_BOOL, 8);
228 xfer += oprot->writeBool(this->blockCacheEnabled);
229 xfer += oprot->writeFieldEnd();
230
231 xfer += oprot->writeFieldBegin("timeToLive", ::apache::thrift::protocol::T_I32, 9);
232 xfer += oprot->writeI32(this->timeToLive);
233 xfer += oprot->writeFieldEnd();
234
235 xfer += oprot->writeFieldStop();
236 xfer += oprot->writeStructEnd();
237 return xfer;
238 }
239
swap(ColumnDescriptor & a,ColumnDescriptor & b)240 void swap(ColumnDescriptor &a, ColumnDescriptor &b) {
241 using ::std::swap;
242 swap(a.name, b.name);
243 swap(a.maxVersions, b.maxVersions);
244 swap(a.compression, b.compression);
245 swap(a.inMemory, b.inMemory);
246 swap(a.bloomFilterType, b.bloomFilterType);
247 swap(a.bloomFilterVectorSize, b.bloomFilterVectorSize);
248 swap(a.bloomFilterNbHashes, b.bloomFilterNbHashes);
249 swap(a.blockCacheEnabled, b.blockCacheEnabled);
250 swap(a.timeToLive, b.timeToLive);
251 swap(a.__isset, b.__isset);
252 }
253
254 const char* TRegionInfo::ascii_fingerprint = "B58AB7A239831F8614F7B6709C89DC7B";
255 const uint8_t TRegionInfo::binary_fingerprint[16] = {0xB5,0x8A,0xB7,0xA2,0x39,0x83,0x1F,0x86,0x14,0xF7,0xB6,0x70,0x9C,0x89,0xDC,0x7B};
256
read(::apache::thrift::protocol::TProtocol * iprot)257 uint32_t TRegionInfo::read(::apache::thrift::protocol::TProtocol* iprot) {
258
259 uint32_t xfer = 0;
260 std::string fname;
261 ::apache::thrift::protocol::TType ftype;
262 int16_t fid;
263
264 xfer += iprot->readStructBegin(fname);
265
266 using ::apache::thrift::protocol::TProtocolException;
267
268
269 while (true)
270 {
271 xfer += iprot->readFieldBegin(fname, ftype, fid);
272 if (ftype == ::apache::thrift::protocol::T_STOP) {
273 break;
274 }
275 switch (fid)
276 {
277 case 1:
278 if (ftype == ::apache::thrift::protocol::T_STRING) {
279 xfer += iprot->readBinary(this->startKey);
280 this->__isset.startKey = true;
281 } else {
282 xfer += iprot->skip(ftype);
283 }
284 break;
285 case 2:
286 if (ftype == ::apache::thrift::protocol::T_STRING) {
287 xfer += iprot->readBinary(this->endKey);
288 this->__isset.endKey = true;
289 } else {
290 xfer += iprot->skip(ftype);
291 }
292 break;
293 case 3:
294 if (ftype == ::apache::thrift::protocol::T_I64) {
295 xfer += iprot->readI64(this->id);
296 this->__isset.id = true;
297 } else {
298 xfer += iprot->skip(ftype);
299 }
300 break;
301 case 4:
302 if (ftype == ::apache::thrift::protocol::T_STRING) {
303 xfer += iprot->readBinary(this->name);
304 this->__isset.name = true;
305 } else {
306 xfer += iprot->skip(ftype);
307 }
308 break;
309 case 5:
310 if (ftype == ::apache::thrift::protocol::T_BYTE) {
311 xfer += iprot->readByte(this->version);
312 this->__isset.version = true;
313 } else {
314 xfer += iprot->skip(ftype);
315 }
316 break;
317 case 6:
318 if (ftype == ::apache::thrift::protocol::T_STRING) {
319 xfer += iprot->readBinary(this->serverName);
320 this->__isset.serverName = true;
321 } else {
322 xfer += iprot->skip(ftype);
323 }
324 break;
325 case 7:
326 if (ftype == ::apache::thrift::protocol::T_I32) {
327 xfer += iprot->readI32(this->port);
328 this->__isset.port = true;
329 } else {
330 xfer += iprot->skip(ftype);
331 }
332 break;
333 default:
334 xfer += iprot->skip(ftype);
335 break;
336 }
337 xfer += iprot->readFieldEnd();
338 }
339
340 xfer += iprot->readStructEnd();
341
342 return xfer;
343 }
344
write(::apache::thrift::protocol::TProtocol * oprot) const345 uint32_t TRegionInfo::write(::apache::thrift::protocol::TProtocol* oprot) const {
346 uint32_t xfer = 0;
347 xfer += oprot->writeStructBegin("TRegionInfo");
348
349 xfer += oprot->writeFieldBegin("startKey", ::apache::thrift::protocol::T_STRING, 1);
350 xfer += oprot->writeBinary(this->startKey);
351 xfer += oprot->writeFieldEnd();
352
353 xfer += oprot->writeFieldBegin("endKey", ::apache::thrift::protocol::T_STRING, 2);
354 xfer += oprot->writeBinary(this->endKey);
355 xfer += oprot->writeFieldEnd();
356
357 xfer += oprot->writeFieldBegin("id", ::apache::thrift::protocol::T_I64, 3);
358 xfer += oprot->writeI64(this->id);
359 xfer += oprot->writeFieldEnd();
360
361 xfer += oprot->writeFieldBegin("name", ::apache::thrift::protocol::T_STRING, 4);
362 xfer += oprot->writeBinary(this->name);
363 xfer += oprot->writeFieldEnd();
364
365 xfer += oprot->writeFieldBegin("version", ::apache::thrift::protocol::T_BYTE, 5);
366 xfer += oprot->writeByte(this->version);
367 xfer += oprot->writeFieldEnd();
368
369 xfer += oprot->writeFieldBegin("serverName", ::apache::thrift::protocol::T_STRING, 6);
370 xfer += oprot->writeBinary(this->serverName);
371 xfer += oprot->writeFieldEnd();
372
373 xfer += oprot->writeFieldBegin("port", ::apache::thrift::protocol::T_I32, 7);
374 xfer += oprot->writeI32(this->port);
375 xfer += oprot->writeFieldEnd();
376
377 xfer += oprot->writeFieldStop();
378 xfer += oprot->writeStructEnd();
379 return xfer;
380 }
381
swap(TRegionInfo & a,TRegionInfo & b)382 void swap(TRegionInfo &a, TRegionInfo &b) {
383 using ::std::swap;
384 swap(a.startKey, b.startKey);
385 swap(a.endKey, b.endKey);
386 swap(a.id, b.id);
387 swap(a.name, b.name);
388 swap(a.version, b.version);
389 swap(a.serverName, b.serverName);
390 swap(a.port, b.port);
391 swap(a.__isset, b.__isset);
392 }
393
394 const char* Mutation::ascii_fingerprint = "CD9E9D4A6406AD402C90440434AE18A0";
395 const uint8_t Mutation::binary_fingerprint[16] = {0xCD,0x9E,0x9D,0x4A,0x64,0x06,0xAD,0x40,0x2C,0x90,0x44,0x04,0x34,0xAE,0x18,0xA0};
396
read(::apache::thrift::protocol::TProtocol * iprot)397 uint32_t Mutation::read(::apache::thrift::protocol::TProtocol* iprot) {
398
399 uint32_t xfer = 0;
400 std::string fname;
401 ::apache::thrift::protocol::TType ftype;
402 int16_t fid;
403
404 xfer += iprot->readStructBegin(fname);
405
406 using ::apache::thrift::protocol::TProtocolException;
407
408
409 while (true)
410 {
411 xfer += iprot->readFieldBegin(fname, ftype, fid);
412 if (ftype == ::apache::thrift::protocol::T_STOP) {
413 break;
414 }
415 switch (fid)
416 {
417 case 1:
418 if (ftype == ::apache::thrift::protocol::T_BOOL) {
419 xfer += iprot->readBool(this->isDelete);
420 this->__isset.isDelete = true;
421 } else {
422 xfer += iprot->skip(ftype);
423 }
424 break;
425 case 2:
426 if (ftype == ::apache::thrift::protocol::T_STRING) {
427 xfer += iprot->readBinary(this->column);
428 this->__isset.column = true;
429 } else {
430 xfer += iprot->skip(ftype);
431 }
432 break;
433 case 3:
434 if (ftype == ::apache::thrift::protocol::T_STRING) {
435 xfer += iprot->readBinary(this->value);
436 this->__isset.value = true;
437 } else {
438 xfer += iprot->skip(ftype);
439 }
440 break;
441 case 4:
442 if (ftype == ::apache::thrift::protocol::T_BOOL) {
443 xfer += iprot->readBool(this->writeToWAL);
444 this->__isset.writeToWAL = true;
445 } else {
446 xfer += iprot->skip(ftype);
447 }
448 break;
449 default:
450 xfer += iprot->skip(ftype);
451 break;
452 }
453 xfer += iprot->readFieldEnd();
454 }
455
456 xfer += iprot->readStructEnd();
457
458 return xfer;
459 }
460
write(::apache::thrift::protocol::TProtocol * oprot) const461 uint32_t Mutation::write(::apache::thrift::protocol::TProtocol* oprot) const {
462 uint32_t xfer = 0;
463 xfer += oprot->writeStructBegin("Mutation");
464
465 xfer += oprot->writeFieldBegin("isDelete", ::apache::thrift::protocol::T_BOOL, 1);
466 xfer += oprot->writeBool(this->isDelete);
467 xfer += oprot->writeFieldEnd();
468
469 xfer += oprot->writeFieldBegin("column", ::apache::thrift::protocol::T_STRING, 2);
470 xfer += oprot->writeBinary(this->column);
471 xfer += oprot->writeFieldEnd();
472
473 xfer += oprot->writeFieldBegin("value", ::apache::thrift::protocol::T_STRING, 3);
474 xfer += oprot->writeBinary(this->value);
475 xfer += oprot->writeFieldEnd();
476
477 xfer += oprot->writeFieldBegin("writeToWAL", ::apache::thrift::protocol::T_BOOL, 4);
478 xfer += oprot->writeBool(this->writeToWAL);
479 xfer += oprot->writeFieldEnd();
480
481 xfer += oprot->writeFieldStop();
482 xfer += oprot->writeStructEnd();
483 return xfer;
484 }
485
swap(Mutation & a,Mutation & b)486 void swap(Mutation &a, Mutation &b) {
487 using ::std::swap;
488 swap(a.isDelete, b.isDelete);
489 swap(a.column, b.column);
490 swap(a.value, b.value);
491 swap(a.writeToWAL, b.writeToWAL);
492 swap(a.__isset, b.__isset);
493 }
494
495 const char* BatchMutation::ascii_fingerprint = "4B8A4A9E051CAFF532E1C0D54F6AD2AB";
496 const uint8_t BatchMutation::binary_fingerprint[16] = {0x4B,0x8A,0x4A,0x9E,0x05,0x1C,0xAF,0xF5,0x32,0xE1,0xC0,0xD5,0x4F,0x6A,0xD2,0xAB};
497
read(::apache::thrift::protocol::TProtocol * iprot)498 uint32_t BatchMutation::read(::apache::thrift::protocol::TProtocol* iprot) {
499
500 uint32_t xfer = 0;
501 std::string fname;
502 ::apache::thrift::protocol::TType ftype;
503 int16_t fid;
504
505 xfer += iprot->readStructBegin(fname);
506
507 using ::apache::thrift::protocol::TProtocolException;
508
509
510 while (true)
511 {
512 xfer += iprot->readFieldBegin(fname, ftype, fid);
513 if (ftype == ::apache::thrift::protocol::T_STOP) {
514 break;
515 }
516 switch (fid)
517 {
518 case 1:
519 if (ftype == ::apache::thrift::protocol::T_STRING) {
520 xfer += iprot->readBinary(this->row);
521 this->__isset.row = true;
522 } else {
523 xfer += iprot->skip(ftype);
524 }
525 break;
526 case 2:
527 if (ftype == ::apache::thrift::protocol::T_LIST) {
528 {
529 this->mutations.clear();
530 uint32_t _size0;
531 ::apache::thrift::protocol::TType _etype3;
532 xfer += iprot->readListBegin(_etype3, _size0);
533 this->mutations.resize(_size0);
534 uint32_t _i4;
535 for (_i4 = 0; _i4 < _size0; ++_i4)
536 {
537 xfer += this->mutations[_i4].read(iprot);
538 }
539 xfer += iprot->readListEnd();
540 }
541 this->__isset.mutations = true;
542 } else {
543 xfer += iprot->skip(ftype);
544 }
545 break;
546 default:
547 xfer += iprot->skip(ftype);
548 break;
549 }
550 xfer += iprot->readFieldEnd();
551 }
552
553 xfer += iprot->readStructEnd();
554
555 return xfer;
556 }
557
write(::apache::thrift::protocol::TProtocol * oprot) const558 uint32_t BatchMutation::write(::apache::thrift::protocol::TProtocol* oprot) const {
559 uint32_t xfer = 0;
560 xfer += oprot->writeStructBegin("BatchMutation");
561
562 xfer += oprot->writeFieldBegin("row", ::apache::thrift::protocol::T_STRING, 1);
563 xfer += oprot->writeBinary(this->row);
564 xfer += oprot->writeFieldEnd();
565
566 xfer += oprot->writeFieldBegin("mutations", ::apache::thrift::protocol::T_LIST, 2);
567 {
568 xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->mutations.size()));
569 std::vector<Mutation> ::const_iterator _iter5;
570 for (_iter5 = this->mutations.begin(); _iter5 != this->mutations.end(); ++_iter5)
571 {
572 xfer += (*_iter5).write(oprot);
573 }
574 xfer += oprot->writeListEnd();
575 }
576 xfer += oprot->writeFieldEnd();
577
578 xfer += oprot->writeFieldStop();
579 xfer += oprot->writeStructEnd();
580 return xfer;
581 }
582
swap(BatchMutation & a,BatchMutation & b)583 void swap(BatchMutation &a, BatchMutation &b) {
584 using ::std::swap;
585 swap(a.row, b.row);
586 swap(a.mutations, b.mutations);
587 swap(a.__isset, b.__isset);
588 }
589
590 const char* TIncrement::ascii_fingerprint = "5F9965D46A4F3845985AC0F9B81C3C69";
591 const uint8_t TIncrement::binary_fingerprint[16] = {0x5F,0x99,0x65,0xD4,0x6A,0x4F,0x38,0x45,0x98,0x5A,0xC0,0xF9,0xB8,0x1C,0x3C,0x69};
592
read(::apache::thrift::protocol::TProtocol * iprot)593 uint32_t TIncrement::read(::apache::thrift::protocol::TProtocol* iprot) {
594
595 uint32_t xfer = 0;
596 std::string fname;
597 ::apache::thrift::protocol::TType ftype;
598 int16_t fid;
599
600 xfer += iprot->readStructBegin(fname);
601
602 using ::apache::thrift::protocol::TProtocolException;
603
604
605 while (true)
606 {
607 xfer += iprot->readFieldBegin(fname, ftype, fid);
608 if (ftype == ::apache::thrift::protocol::T_STOP) {
609 break;
610 }
611 switch (fid)
612 {
613 case 1:
614 if (ftype == ::apache::thrift::protocol::T_STRING) {
615 xfer += iprot->readBinary(this->table);
616 this->__isset.table = true;
617 } else {
618 xfer += iprot->skip(ftype);
619 }
620 break;
621 case 2:
622 if (ftype == ::apache::thrift::protocol::T_STRING) {
623 xfer += iprot->readBinary(this->row);
624 this->__isset.row = true;
625 } else {
626 xfer += iprot->skip(ftype);
627 }
628 break;
629 case 3:
630 if (ftype == ::apache::thrift::protocol::T_STRING) {
631 xfer += iprot->readBinary(this->column);
632 this->__isset.column = true;
633 } else {
634 xfer += iprot->skip(ftype);
635 }
636 break;
637 case 4:
638 if (ftype == ::apache::thrift::protocol::T_I64) {
639 xfer += iprot->readI64(this->ammount);
640 this->__isset.ammount = true;
641 } else {
642 xfer += iprot->skip(ftype);
643 }
644 break;
645 default:
646 xfer += iprot->skip(ftype);
647 break;
648 }
649 xfer += iprot->readFieldEnd();
650 }
651
652 xfer += iprot->readStructEnd();
653
654 return xfer;
655 }
656
write(::apache::thrift::protocol::TProtocol * oprot) const657 uint32_t TIncrement::write(::apache::thrift::protocol::TProtocol* oprot) const {
658 uint32_t xfer = 0;
659 xfer += oprot->writeStructBegin("TIncrement");
660
661 xfer += oprot->writeFieldBegin("table", ::apache::thrift::protocol::T_STRING, 1);
662 xfer += oprot->writeBinary(this->table);
663 xfer += oprot->writeFieldEnd();
664
665 xfer += oprot->writeFieldBegin("row", ::apache::thrift::protocol::T_STRING, 2);
666 xfer += oprot->writeBinary(this->row);
667 xfer += oprot->writeFieldEnd();
668
669 xfer += oprot->writeFieldBegin("column", ::apache::thrift::protocol::T_STRING, 3);
670 xfer += oprot->writeBinary(this->column);
671 xfer += oprot->writeFieldEnd();
672
673 xfer += oprot->writeFieldBegin("ammount", ::apache::thrift::protocol::T_I64, 4);
674 xfer += oprot->writeI64(this->ammount);
675 xfer += oprot->writeFieldEnd();
676
677 xfer += oprot->writeFieldStop();
678 xfer += oprot->writeStructEnd();
679 return xfer;
680 }
681
swap(TIncrement & a,TIncrement & b)682 void swap(TIncrement &a, TIncrement &b) {
683 using ::std::swap;
684 swap(a.table, b.table);
685 swap(a.row, b.row);
686 swap(a.column, b.column);
687 swap(a.ammount, b.ammount);
688 swap(a.__isset, b.__isset);
689 }
690
691 const char* TRowResult::ascii_fingerprint = "AE98EA4F344566FAFE04FA5E5823D1ED";
692 const uint8_t TRowResult::binary_fingerprint[16] = {0xAE,0x98,0xEA,0x4F,0x34,0x45,0x66,0xFA,0xFE,0x04,0xFA,0x5E,0x58,0x23,0xD1,0xED};
693
read(::apache::thrift::protocol::TProtocol * iprot)694 uint32_t TRowResult::read(::apache::thrift::protocol::TProtocol* iprot) {
695
696 uint32_t xfer = 0;
697 std::string fname;
698 ::apache::thrift::protocol::TType ftype;
699 int16_t fid;
700
701 xfer += iprot->readStructBegin(fname);
702
703 using ::apache::thrift::protocol::TProtocolException;
704
705
706 while (true)
707 {
708 xfer += iprot->readFieldBegin(fname, ftype, fid);
709 if (ftype == ::apache::thrift::protocol::T_STOP) {
710 break;
711 }
712 switch (fid)
713 {
714 case 1:
715 if (ftype == ::apache::thrift::protocol::T_STRING) {
716 xfer += iprot->readBinary(this->row);
717 this->__isset.row = true;
718 } else {
719 xfer += iprot->skip(ftype);
720 }
721 break;
722 case 2:
723 if (ftype == ::apache::thrift::protocol::T_MAP) {
724 {
725 this->columns.clear();
726 uint32_t _size6;
727 ::apache::thrift::protocol::TType _ktype7;
728 ::apache::thrift::protocol::TType _vtype8;
729 xfer += iprot->readMapBegin(_ktype7, _vtype8, _size6);
730 uint32_t _i10;
731 for (_i10 = 0; _i10 < _size6; ++_i10)
732 {
733 Text _key11;
734 xfer += iprot->readBinary(_key11);
735 TCell& _val12 = this->columns[_key11];
736 xfer += _val12.read(iprot);
737 }
738 xfer += iprot->readMapEnd();
739 }
740 this->__isset.columns = true;
741 } else {
742 xfer += iprot->skip(ftype);
743 }
744 break;
745 default:
746 xfer += iprot->skip(ftype);
747 break;
748 }
749 xfer += iprot->readFieldEnd();
750 }
751
752 xfer += iprot->readStructEnd();
753
754 return xfer;
755 }
756
write(::apache::thrift::protocol::TProtocol * oprot) const757 uint32_t TRowResult::write(::apache::thrift::protocol::TProtocol* oprot) const {
758 uint32_t xfer = 0;
759 xfer += oprot->writeStructBegin("TRowResult");
760
761 xfer += oprot->writeFieldBegin("row", ::apache::thrift::protocol::T_STRING, 1);
762 xfer += oprot->writeBinary(this->row);
763 xfer += oprot->writeFieldEnd();
764
765 xfer += oprot->writeFieldBegin("columns", ::apache::thrift::protocol::T_MAP, 2);
766 {
767 xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->columns.size()));
768 std::map<Text, TCell> ::const_iterator _iter13;
769 for (_iter13 = this->columns.begin(); _iter13 != this->columns.end(); ++_iter13)
770 {
771 xfer += oprot->writeBinary(_iter13->first);
772 xfer += _iter13->second.write(oprot);
773 }
774 xfer += oprot->writeMapEnd();
775 }
776 xfer += oprot->writeFieldEnd();
777
778 xfer += oprot->writeFieldStop();
779 xfer += oprot->writeStructEnd();
780 return xfer;
781 }
782
swap(TRowResult & a,TRowResult & b)783 void swap(TRowResult &a, TRowResult &b) {
784 using ::std::swap;
785 swap(a.row, b.row);
786 swap(a.columns, b.columns);
787 swap(a.__isset, b.__isset);
788 }
789
790 const char* TScan::ascii_fingerprint = "2C111FDF8CD162886ECCCBB9C9051083";
791 const uint8_t TScan::binary_fingerprint[16] = {0x2C,0x11,0x1F,0xDF,0x8C,0xD1,0x62,0x88,0x6E,0xCC,0xCB,0xB9,0xC9,0x05,0x10,0x83};
792
read(::apache::thrift::protocol::TProtocol * iprot)793 uint32_t TScan::read(::apache::thrift::protocol::TProtocol* iprot) {
794
795 uint32_t xfer = 0;
796 std::string fname;
797 ::apache::thrift::protocol::TType ftype;
798 int16_t fid;
799
800 xfer += iprot->readStructBegin(fname);
801
802 using ::apache::thrift::protocol::TProtocolException;
803
804
805 while (true)
806 {
807 xfer += iprot->readFieldBegin(fname, ftype, fid);
808 if (ftype == ::apache::thrift::protocol::T_STOP) {
809 break;
810 }
811 switch (fid)
812 {
813 case 1:
814 if (ftype == ::apache::thrift::protocol::T_STRING) {
815 xfer += iprot->readBinary(this->startRow);
816 this->__isset.startRow = true;
817 } else {
818 xfer += iprot->skip(ftype);
819 }
820 break;
821 case 2:
822 if (ftype == ::apache::thrift::protocol::T_STRING) {
823 xfer += iprot->readBinary(this->stopRow);
824 this->__isset.stopRow = true;
825 } else {
826 xfer += iprot->skip(ftype);
827 }
828 break;
829 case 3:
830 if (ftype == ::apache::thrift::protocol::T_I64) {
831 xfer += iprot->readI64(this->timestamp);
832 this->__isset.timestamp = true;
833 } else {
834 xfer += iprot->skip(ftype);
835 }
836 break;
837 case 4:
838 if (ftype == ::apache::thrift::protocol::T_LIST) {
839 {
840 this->columns.clear();
841 uint32_t _size14;
842 ::apache::thrift::protocol::TType _etype17;
843 xfer += iprot->readListBegin(_etype17, _size14);
844 this->columns.resize(_size14);
845 uint32_t _i18;
846 for (_i18 = 0; _i18 < _size14; ++_i18)
847 {
848 xfer += iprot->readBinary(this->columns[_i18]);
849 }
850 xfer += iprot->readListEnd();
851 }
852 this->__isset.columns = true;
853 } else {
854 xfer += iprot->skip(ftype);
855 }
856 break;
857 case 5:
858 if (ftype == ::apache::thrift::protocol::T_I32) {
859 xfer += iprot->readI32(this->caching);
860 this->__isset.caching = true;
861 } else {
862 xfer += iprot->skip(ftype);
863 }
864 break;
865 case 6:
866 if (ftype == ::apache::thrift::protocol::T_STRING) {
867 xfer += iprot->readBinary(this->filterString);
868 this->__isset.filterString = true;
869 } else {
870 xfer += iprot->skip(ftype);
871 }
872 break;
873 default:
874 xfer += iprot->skip(ftype);
875 break;
876 }
877 xfer += iprot->readFieldEnd();
878 }
879
880 xfer += iprot->readStructEnd();
881
882 return xfer;
883 }
884
write(::apache::thrift::protocol::TProtocol * oprot) const885 uint32_t TScan::write(::apache::thrift::protocol::TProtocol* oprot) const {
886 uint32_t xfer = 0;
887 xfer += oprot->writeStructBegin("TScan");
888
889 if (this->__isset.startRow) {
890 xfer += oprot->writeFieldBegin("startRow", ::apache::thrift::protocol::T_STRING, 1);
891 xfer += oprot->writeBinary(this->startRow);
892 xfer += oprot->writeFieldEnd();
893 }
894 if (this->__isset.stopRow) {
895 xfer += oprot->writeFieldBegin("stopRow", ::apache::thrift::protocol::T_STRING, 2);
896 xfer += oprot->writeBinary(this->stopRow);
897 xfer += oprot->writeFieldEnd();
898 }
899 if (this->__isset.timestamp) {
900 xfer += oprot->writeFieldBegin("timestamp", ::apache::thrift::protocol::T_I64, 3);
901 xfer += oprot->writeI64(this->timestamp);
902 xfer += oprot->writeFieldEnd();
903 }
904 if (this->__isset.columns) {
905 xfer += oprot->writeFieldBegin("columns", ::apache::thrift::protocol::T_LIST, 4);
906 {
907 xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->columns.size()));
908 std::vector<Text> ::const_iterator _iter19;
909 for (_iter19 = this->columns.begin(); _iter19 != this->columns.end(); ++_iter19)
910 {
911 xfer += oprot->writeBinary((*_iter19));
912 }
913 xfer += oprot->writeListEnd();
914 }
915 xfer += oprot->writeFieldEnd();
916 }
917 if (this->__isset.caching) {
918 xfer += oprot->writeFieldBegin("caching", ::apache::thrift::protocol::T_I32, 5);
919 xfer += oprot->writeI32(this->caching);
920 xfer += oprot->writeFieldEnd();
921 }
922 if (this->__isset.filterString) {
923 xfer += oprot->writeFieldBegin("filterString", ::apache::thrift::protocol::T_STRING, 6);
924 xfer += oprot->writeBinary(this->filterString);
925 xfer += oprot->writeFieldEnd();
926 }
927 xfer += oprot->writeFieldStop();
928 xfer += oprot->writeStructEnd();
929 return xfer;
930 }
931
swap(TScan & a,TScan & b)932 void swap(TScan &a, TScan &b) {
933 using ::std::swap;
934 swap(a.startRow, b.startRow);
935 swap(a.stopRow, b.stopRow);
936 swap(a.timestamp, b.timestamp);
937 swap(a.columns, b.columns);
938 swap(a.caching, b.caching);
939 swap(a.filterString, b.filterString);
940 swap(a.__isset, b.__isset);
941 }
942
943 const char* IOError::ascii_fingerprint = "EFB929595D312AC8F305D5A794CFEDA1";
944 const uint8_t IOError::binary_fingerprint[16] = {0xEF,0xB9,0x29,0x59,0x5D,0x31,0x2A,0xC8,0xF3,0x05,0xD5,0xA7,0x94,0xCF,0xED,0xA1};
945
read(::apache::thrift::protocol::TProtocol * iprot)946 uint32_t IOError::read(::apache::thrift::protocol::TProtocol* iprot) {
947
948 uint32_t xfer = 0;
949 std::string fname;
950 ::apache::thrift::protocol::TType ftype;
951 int16_t fid;
952
953 xfer += iprot->readStructBegin(fname);
954
955 using ::apache::thrift::protocol::TProtocolException;
956
957
958 while (true)
959 {
960 xfer += iprot->readFieldBegin(fname, ftype, fid);
961 if (ftype == ::apache::thrift::protocol::T_STOP) {
962 break;
963 }
964 switch (fid)
965 {
966 case 1:
967 if (ftype == ::apache::thrift::protocol::T_STRING) {
968 xfer += iprot->readString(this->message);
969 this->__isset.message = true;
970 } else {
971 xfer += iprot->skip(ftype);
972 }
973 break;
974 default:
975 xfer += iprot->skip(ftype);
976 break;
977 }
978 xfer += iprot->readFieldEnd();
979 }
980
981 xfer += iprot->readStructEnd();
982
983 return xfer;
984 }
985
write(::apache::thrift::protocol::TProtocol * oprot) const986 uint32_t IOError::write(::apache::thrift::protocol::TProtocol* oprot) const {
987 uint32_t xfer = 0;
988 xfer += oprot->writeStructBegin("IOError");
989
990 xfer += oprot->writeFieldBegin("message", ::apache::thrift::protocol::T_STRING, 1);
991 xfer += oprot->writeString(this->message);
992 xfer += oprot->writeFieldEnd();
993
994 xfer += oprot->writeFieldStop();
995 xfer += oprot->writeStructEnd();
996 return xfer;
997 }
998
swap(IOError & a,IOError & b)999 void swap(IOError &a, IOError &b) {
1000 using ::std::swap;
1001 swap(a.message, b.message);
1002 swap(a.__isset, b.__isset);
1003 }
1004
1005 const char* IllegalArgument::ascii_fingerprint = "EFB929595D312AC8F305D5A794CFEDA1";
1006 const uint8_t IllegalArgument::binary_fingerprint[16] = {0xEF,0xB9,0x29,0x59,0x5D,0x31,0x2A,0xC8,0xF3,0x05,0xD5,0xA7,0x94,0xCF,0xED,0xA1};
1007
read(::apache::thrift::protocol::TProtocol * iprot)1008 uint32_t IllegalArgument::read(::apache::thrift::protocol::TProtocol* iprot) {
1009
1010 uint32_t xfer = 0;
1011 std::string fname;
1012 ::apache::thrift::protocol::TType ftype;
1013 int16_t fid;
1014
1015 xfer += iprot->readStructBegin(fname);
1016
1017 using ::apache::thrift::protocol::TProtocolException;
1018
1019
1020 while (true)
1021 {
1022 xfer += iprot->readFieldBegin(fname, ftype, fid);
1023 if (ftype == ::apache::thrift::protocol::T_STOP) {
1024 break;
1025 }
1026 switch (fid)
1027 {
1028 case 1:
1029 if (ftype == ::apache::thrift::protocol::T_STRING) {
1030 xfer += iprot->readString(this->message);
1031 this->__isset.message = true;
1032 } else {
1033 xfer += iprot->skip(ftype);
1034 }
1035 break;
1036 default:
1037 xfer += iprot->skip(ftype);
1038 break;
1039 }
1040 xfer += iprot->readFieldEnd();
1041 }
1042
1043 xfer += iprot->readStructEnd();
1044
1045 return xfer;
1046 }
1047
write(::apache::thrift::protocol::TProtocol * oprot) const1048 uint32_t IllegalArgument::write(::apache::thrift::protocol::TProtocol* oprot) const {
1049 uint32_t xfer = 0;
1050 xfer += oprot->writeStructBegin("IllegalArgument");
1051
1052 xfer += oprot->writeFieldBegin("message", ::apache::thrift::protocol::T_STRING, 1);
1053 xfer += oprot->writeString(this->message);
1054 xfer += oprot->writeFieldEnd();
1055
1056 xfer += oprot->writeFieldStop();
1057 xfer += oprot->writeStructEnd();
1058 return xfer;
1059 }
1060
swap(IllegalArgument & a,IllegalArgument & b)1061 void swap(IllegalArgument &a, IllegalArgument &b) {
1062 using ::std::swap;
1063 swap(a.message, b.message);
1064 swap(a.__isset, b.__isset);
1065 }
1066
1067 const char* AlreadyExists::ascii_fingerprint = "EFB929595D312AC8F305D5A794CFEDA1";
1068 const uint8_t AlreadyExists::binary_fingerprint[16] = {0xEF,0xB9,0x29,0x59,0x5D,0x31,0x2A,0xC8,0xF3,0x05,0xD5,0xA7,0x94,0xCF,0xED,0xA1};
1069
read(::apache::thrift::protocol::TProtocol * iprot)1070 uint32_t AlreadyExists::read(::apache::thrift::protocol::TProtocol* iprot) {
1071
1072 uint32_t xfer = 0;
1073 std::string fname;
1074 ::apache::thrift::protocol::TType ftype;
1075 int16_t fid;
1076
1077 xfer += iprot->readStructBegin(fname);
1078
1079 using ::apache::thrift::protocol::TProtocolException;
1080
1081
1082 while (true)
1083 {
1084 xfer += iprot->readFieldBegin(fname, ftype, fid);
1085 if (ftype == ::apache::thrift::protocol::T_STOP) {
1086 break;
1087 }
1088 switch (fid)
1089 {
1090 case 1:
1091 if (ftype == ::apache::thrift::protocol::T_STRING) {
1092 xfer += iprot->readString(this->message);
1093 this->__isset.message = true;
1094 } else {
1095 xfer += iprot->skip(ftype);
1096 }
1097 break;
1098 default:
1099 xfer += iprot->skip(ftype);
1100 break;
1101 }
1102 xfer += iprot->readFieldEnd();
1103 }
1104
1105 xfer += iprot->readStructEnd();
1106
1107 return xfer;
1108 }
1109
write(::apache::thrift::protocol::TProtocol * oprot) const1110 uint32_t AlreadyExists::write(::apache::thrift::protocol::TProtocol* oprot) const {
1111 uint32_t xfer = 0;
1112 xfer += oprot->writeStructBegin("AlreadyExists");
1113
1114 xfer += oprot->writeFieldBegin("message", ::apache::thrift::protocol::T_STRING, 1);
1115 xfer += oprot->writeString(this->message);
1116 xfer += oprot->writeFieldEnd();
1117
1118 xfer += oprot->writeFieldStop();
1119 xfer += oprot->writeStructEnd();
1120 return xfer;
1121 }
1122
swap(AlreadyExists & a,AlreadyExists & b)1123 void swap(AlreadyExists &a, AlreadyExists &b) {
1124 using ::std::swap;
1125 swap(a.message, b.message);
1126 swap(a.__isset, b.__isset);
1127 }
1128
1129 }}}} // namespace
1130