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