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