Hbase.cpp
Go to the documentation of this file.
00001 
00006 #include "Hbase.h"
00007 
00008 namespace apache { namespace hadoop { namespace hbase { namespace thrift {
00009 
00010 uint32_t Hbase_enableTable_args::read(::apache::thrift::protocol::TProtocol* iprot) {
00011 
00012   uint32_t xfer = 0;
00013   std::string fname;
00014   ::apache::thrift::protocol::TType ftype;
00015   int16_t fid;
00016 
00017   xfer += iprot->readStructBegin(fname);
00018 
00019   using ::apache::thrift::protocol::TProtocolException;
00020 
00021 
00022   while (true)
00023   {
00024     xfer += iprot->readFieldBegin(fname, ftype, fid);
00025     if (ftype == ::apache::thrift::protocol::T_STOP) {
00026       break;
00027     }
00028     switch (fid)
00029     {
00030       case 1:
00031         if (ftype == ::apache::thrift::protocol::T_STRING) {
00032           xfer += iprot->readBinary(this->tableName);
00033           this->__isset.tableName = true;
00034         } else {
00035           xfer += iprot->skip(ftype);
00036         }
00037         break;
00038       default:
00039         xfer += iprot->skip(ftype);
00040         break;
00041     }
00042     xfer += iprot->readFieldEnd();
00043   }
00044 
00045   xfer += iprot->readStructEnd();
00046 
00047   return xfer;
00048 }
00049 
00050 uint32_t Hbase_enableTable_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
00051   uint32_t xfer = 0;
00052   xfer += oprot->writeStructBegin("Hbase_enableTable_args");
00053   xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
00054   xfer += oprot->writeBinary(this->tableName);
00055   xfer += oprot->writeFieldEnd();
00056   xfer += oprot->writeFieldStop();
00057   xfer += oprot->writeStructEnd();
00058   return xfer;
00059 }
00060 
00061 uint32_t Hbase_enableTable_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
00062   uint32_t xfer = 0;
00063   xfer += oprot->writeStructBegin("Hbase_enableTable_pargs");
00064   xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
00065   xfer += oprot->writeBinary((*(this->tableName)));
00066   xfer += oprot->writeFieldEnd();
00067   xfer += oprot->writeFieldStop();
00068   xfer += oprot->writeStructEnd();
00069   return xfer;
00070 }
00071 
00072 uint32_t Hbase_enableTable_result::read(::apache::thrift::protocol::TProtocol* iprot) {
00073 
00074   uint32_t xfer = 0;
00075   std::string fname;
00076   ::apache::thrift::protocol::TType ftype;
00077   int16_t fid;
00078 
00079   xfer += iprot->readStructBegin(fname);
00080 
00081   using ::apache::thrift::protocol::TProtocolException;
00082 
00083 
00084   while (true)
00085   {
00086     xfer += iprot->readFieldBegin(fname, ftype, fid);
00087     if (ftype == ::apache::thrift::protocol::T_STOP) {
00088       break;
00089     }
00090     switch (fid)
00091     {
00092       case 1:
00093         if (ftype == ::apache::thrift::protocol::T_STRUCT) {
00094           xfer += this->io.read(iprot);
00095           this->__isset.io = true;
00096         } else {
00097           xfer += iprot->skip(ftype);
00098         }
00099         break;
00100       default:
00101         xfer += iprot->skip(ftype);
00102         break;
00103     }
00104     xfer += iprot->readFieldEnd();
00105   }
00106 
00107   xfer += iprot->readStructEnd();
00108 
00109   return xfer;
00110 }
00111 
00112 uint32_t Hbase_enableTable_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
00113 
00114   uint32_t xfer = 0;
00115 
00116   xfer += oprot->writeStructBegin("Hbase_enableTable_result");
00117 
00118   if (this->__isset.io) {
00119     xfer += oprot->writeFieldBegin("io", ::apache::thrift::protocol::T_STRUCT, 1);
00120     xfer += this->io.write(oprot);
00121     xfer += oprot->writeFieldEnd();
00122   }
00123   xfer += oprot->writeFieldStop();
00124   xfer += oprot->writeStructEnd();
00125   return xfer;
00126 }
00127 
00128 uint32_t Hbase_enableTable_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
00129 
00130   uint32_t xfer = 0;
00131   std::string fname;
00132   ::apache::thrift::protocol::TType ftype;
00133   int16_t fid;
00134 
00135   xfer += iprot->readStructBegin(fname);
00136 
00137   using ::apache::thrift::protocol::TProtocolException;
00138 
00139 
00140   while (true)
00141   {
00142     xfer += iprot->readFieldBegin(fname, ftype, fid);
00143     if (ftype == ::apache::thrift::protocol::T_STOP) {
00144       break;
00145     }
00146     switch (fid)
00147     {
00148       case 1:
00149         if (ftype == ::apache::thrift::protocol::T_STRUCT) {
00150           xfer += this->io.read(iprot);
00151           this->__isset.io = true;
00152         } else {
00153           xfer += iprot->skip(ftype);
00154         }
00155         break;
00156       default:
00157         xfer += iprot->skip(ftype);
00158         break;
00159     }
00160     xfer += iprot->readFieldEnd();
00161   }
00162 
00163   xfer += iprot->readStructEnd();
00164 
00165   return xfer;
00166 }
00167 
00168 uint32_t Hbase_disableTable_args::read(::apache::thrift::protocol::TProtocol* iprot) {
00169 
00170   uint32_t xfer = 0;
00171   std::string fname;
00172   ::apache::thrift::protocol::TType ftype;
00173   int16_t fid;
00174 
00175   xfer += iprot->readStructBegin(fname);
00176 
00177   using ::apache::thrift::protocol::TProtocolException;
00178 
00179 
00180   while (true)
00181   {
00182     xfer += iprot->readFieldBegin(fname, ftype, fid);
00183     if (ftype == ::apache::thrift::protocol::T_STOP) {
00184       break;
00185     }
00186     switch (fid)
00187     {
00188       case 1:
00189         if (ftype == ::apache::thrift::protocol::T_STRING) {
00190           xfer += iprot->readBinary(this->tableName);
00191           this->__isset.tableName = true;
00192         } else {
00193           xfer += iprot->skip(ftype);
00194         }
00195         break;
00196       default:
00197         xfer += iprot->skip(ftype);
00198         break;
00199     }
00200     xfer += iprot->readFieldEnd();
00201   }
00202 
00203   xfer += iprot->readStructEnd();
00204 
00205   return xfer;
00206 }
00207 
00208 uint32_t Hbase_disableTable_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
00209   uint32_t xfer = 0;
00210   xfer += oprot->writeStructBegin("Hbase_disableTable_args");
00211   xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
00212   xfer += oprot->writeBinary(this->tableName);
00213   xfer += oprot->writeFieldEnd();
00214   xfer += oprot->writeFieldStop();
00215   xfer += oprot->writeStructEnd();
00216   return xfer;
00217 }
00218 
00219 uint32_t Hbase_disableTable_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
00220   uint32_t xfer = 0;
00221   xfer += oprot->writeStructBegin("Hbase_disableTable_pargs");
00222   xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
00223   xfer += oprot->writeBinary((*(this->tableName)));
00224   xfer += oprot->writeFieldEnd();
00225   xfer += oprot->writeFieldStop();
00226   xfer += oprot->writeStructEnd();
00227   return xfer;
00228 }
00229 
00230 uint32_t Hbase_disableTable_result::read(::apache::thrift::protocol::TProtocol* iprot) {
00231 
00232   uint32_t xfer = 0;
00233   std::string fname;
00234   ::apache::thrift::protocol::TType ftype;
00235   int16_t fid;
00236 
00237   xfer += iprot->readStructBegin(fname);
00238 
00239   using ::apache::thrift::protocol::TProtocolException;
00240 
00241 
00242   while (true)
00243   {
00244     xfer += iprot->readFieldBegin(fname, ftype, fid);
00245     if (ftype == ::apache::thrift::protocol::T_STOP) {
00246       break;
00247     }
00248     switch (fid)
00249     {
00250       case 1:
00251         if (ftype == ::apache::thrift::protocol::T_STRUCT) {
00252           xfer += this->io.read(iprot);
00253           this->__isset.io = true;
00254         } else {
00255           xfer += iprot->skip(ftype);
00256         }
00257         break;
00258       default:
00259         xfer += iprot->skip(ftype);
00260         break;
00261     }
00262     xfer += iprot->readFieldEnd();
00263   }
00264 
00265   xfer += iprot->readStructEnd();
00266 
00267   return xfer;
00268 }
00269 
00270 uint32_t Hbase_disableTable_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
00271 
00272   uint32_t xfer = 0;
00273 
00274   xfer += oprot->writeStructBegin("Hbase_disableTable_result");
00275 
00276   if (this->__isset.io) {
00277     xfer += oprot->writeFieldBegin("io", ::apache::thrift::protocol::T_STRUCT, 1);
00278     xfer += this->io.write(oprot);
00279     xfer += oprot->writeFieldEnd();
00280   }
00281   xfer += oprot->writeFieldStop();
00282   xfer += oprot->writeStructEnd();
00283   return xfer;
00284 }
00285 
00286 uint32_t Hbase_disableTable_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
00287 
00288   uint32_t xfer = 0;
00289   std::string fname;
00290   ::apache::thrift::protocol::TType ftype;
00291   int16_t fid;
00292 
00293   xfer += iprot->readStructBegin(fname);
00294 
00295   using ::apache::thrift::protocol::TProtocolException;
00296 
00297 
00298   while (true)
00299   {
00300     xfer += iprot->readFieldBegin(fname, ftype, fid);
00301     if (ftype == ::apache::thrift::protocol::T_STOP) {
00302       break;
00303     }
00304     switch (fid)
00305     {
00306       case 1:
00307         if (ftype == ::apache::thrift::protocol::T_STRUCT) {
00308           xfer += this->io.read(iprot);
00309           this->__isset.io = true;
00310         } else {
00311           xfer += iprot->skip(ftype);
00312         }
00313         break;
00314       default:
00315         xfer += iprot->skip(ftype);
00316         break;
00317     }
00318     xfer += iprot->readFieldEnd();
00319   }
00320 
00321   xfer += iprot->readStructEnd();
00322 
00323   return xfer;
00324 }
00325 
00326 uint32_t Hbase_isTableEnabled_args::read(::apache::thrift::protocol::TProtocol* iprot) {
00327 
00328   uint32_t xfer = 0;
00329   std::string fname;
00330   ::apache::thrift::protocol::TType ftype;
00331   int16_t fid;
00332 
00333   xfer += iprot->readStructBegin(fname);
00334 
00335   using ::apache::thrift::protocol::TProtocolException;
00336 
00337 
00338   while (true)
00339   {
00340     xfer += iprot->readFieldBegin(fname, ftype, fid);
00341     if (ftype == ::apache::thrift::protocol::T_STOP) {
00342       break;
00343     }
00344     switch (fid)
00345     {
00346       case 1:
00347         if (ftype == ::apache::thrift::protocol::T_STRING) {
00348           xfer += iprot->readBinary(this->tableName);
00349           this->__isset.tableName = true;
00350         } else {
00351           xfer += iprot->skip(ftype);
00352         }
00353         break;
00354       default:
00355         xfer += iprot->skip(ftype);
00356         break;
00357     }
00358     xfer += iprot->readFieldEnd();
00359   }
00360 
00361   xfer += iprot->readStructEnd();
00362 
00363   return xfer;
00364 }
00365 
00366 uint32_t Hbase_isTableEnabled_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
00367   uint32_t xfer = 0;
00368   xfer += oprot->writeStructBegin("Hbase_isTableEnabled_args");
00369   xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
00370   xfer += oprot->writeBinary(this->tableName);
00371   xfer += oprot->writeFieldEnd();
00372   xfer += oprot->writeFieldStop();
00373   xfer += oprot->writeStructEnd();
00374   return xfer;
00375 }
00376 
00377 uint32_t Hbase_isTableEnabled_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
00378   uint32_t xfer = 0;
00379   xfer += oprot->writeStructBegin("Hbase_isTableEnabled_pargs");
00380   xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
00381   xfer += oprot->writeBinary((*(this->tableName)));
00382   xfer += oprot->writeFieldEnd();
00383   xfer += oprot->writeFieldStop();
00384   xfer += oprot->writeStructEnd();
00385   return xfer;
00386 }
00387 
00388 uint32_t Hbase_isTableEnabled_result::read(::apache::thrift::protocol::TProtocol* iprot) {
00389 
00390   uint32_t xfer = 0;
00391   std::string fname;
00392   ::apache::thrift::protocol::TType ftype;
00393   int16_t fid;
00394 
00395   xfer += iprot->readStructBegin(fname);
00396 
00397   using ::apache::thrift::protocol::TProtocolException;
00398 
00399 
00400   while (true)
00401   {
00402     xfer += iprot->readFieldBegin(fname, ftype, fid);
00403     if (ftype == ::apache::thrift::protocol::T_STOP) {
00404       break;
00405     }
00406     switch (fid)
00407     {
00408       case 0:
00409         if (ftype == ::apache::thrift::protocol::T_BOOL) {
00410           xfer += iprot->readBool(this->success);
00411           this->__isset.success = true;
00412         } else {
00413           xfer += iprot->skip(ftype);
00414         }
00415         break;
00416       case 1:
00417         if (ftype == ::apache::thrift::protocol::T_STRUCT) {
00418           xfer += this->io.read(iprot);
00419           this->__isset.io = true;
00420         } else {
00421           xfer += iprot->skip(ftype);
00422         }
00423         break;
00424       default:
00425         xfer += iprot->skip(ftype);
00426         break;
00427     }
00428     xfer += iprot->readFieldEnd();
00429   }
00430 
00431   xfer += iprot->readStructEnd();
00432 
00433   return xfer;
00434 }
00435 
00436 uint32_t Hbase_isTableEnabled_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
00437 
00438   uint32_t xfer = 0;
00439 
00440   xfer += oprot->writeStructBegin("Hbase_isTableEnabled_result");
00441 
00442   if (this->__isset.success) {
00443     xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_BOOL, 0);
00444     xfer += oprot->writeBool(this->success);
00445     xfer += oprot->writeFieldEnd();
00446   } else if (this->__isset.io) {
00447     xfer += oprot->writeFieldBegin("io", ::apache::thrift::protocol::T_STRUCT, 1);
00448     xfer += this->io.write(oprot);
00449     xfer += oprot->writeFieldEnd();
00450   }
00451   xfer += oprot->writeFieldStop();
00452   xfer += oprot->writeStructEnd();
00453   return xfer;
00454 }
00455 
00456 uint32_t Hbase_isTableEnabled_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
00457 
00458   uint32_t xfer = 0;
00459   std::string fname;
00460   ::apache::thrift::protocol::TType ftype;
00461   int16_t fid;
00462 
00463   xfer += iprot->readStructBegin(fname);
00464 
00465   using ::apache::thrift::protocol::TProtocolException;
00466 
00467 
00468   while (true)
00469   {
00470     xfer += iprot->readFieldBegin(fname, ftype, fid);
00471     if (ftype == ::apache::thrift::protocol::T_STOP) {
00472       break;
00473     }
00474     switch (fid)
00475     {
00476       case 0:
00477         if (ftype == ::apache::thrift::protocol::T_BOOL) {
00478           xfer += iprot->readBool((*(this->success)));
00479           this->__isset.success = true;
00480         } else {
00481           xfer += iprot->skip(ftype);
00482         }
00483         break;
00484       case 1:
00485         if (ftype == ::apache::thrift::protocol::T_STRUCT) {
00486           xfer += this->io.read(iprot);
00487           this->__isset.io = true;
00488         } else {
00489           xfer += iprot->skip(ftype);
00490         }
00491         break;
00492       default:
00493         xfer += iprot->skip(ftype);
00494         break;
00495     }
00496     xfer += iprot->readFieldEnd();
00497   }
00498 
00499   xfer += iprot->readStructEnd();
00500 
00501   return xfer;
00502 }
00503 
00504 uint32_t Hbase_compact_args::read(::apache::thrift::protocol::TProtocol* iprot) {
00505 
00506   uint32_t xfer = 0;
00507   std::string fname;
00508   ::apache::thrift::protocol::TType ftype;
00509   int16_t fid;
00510 
00511   xfer += iprot->readStructBegin(fname);
00512 
00513   using ::apache::thrift::protocol::TProtocolException;
00514 
00515 
00516   while (true)
00517   {
00518     xfer += iprot->readFieldBegin(fname, ftype, fid);
00519     if (ftype == ::apache::thrift::protocol::T_STOP) {
00520       break;
00521     }
00522     switch (fid)
00523     {
00524       case 1:
00525         if (ftype == ::apache::thrift::protocol::T_STRING) {
00526           xfer += iprot->readBinary(this->tableNameOrRegionName);
00527           this->__isset.tableNameOrRegionName = true;
00528         } else {
00529           xfer += iprot->skip(ftype);
00530         }
00531         break;
00532       default:
00533         xfer += iprot->skip(ftype);
00534         break;
00535     }
00536     xfer += iprot->readFieldEnd();
00537   }
00538 
00539   xfer += iprot->readStructEnd();
00540 
00541   return xfer;
00542 }
00543 
00544 uint32_t Hbase_compact_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
00545   uint32_t xfer = 0;
00546   xfer += oprot->writeStructBegin("Hbase_compact_args");
00547   xfer += oprot->writeFieldBegin("tableNameOrRegionName", ::apache::thrift::protocol::T_STRING, 1);
00548   xfer += oprot->writeBinary(this->tableNameOrRegionName);
00549   xfer += oprot->writeFieldEnd();
00550   xfer += oprot->writeFieldStop();
00551   xfer += oprot->writeStructEnd();
00552   return xfer;
00553 }
00554 
00555 uint32_t Hbase_compact_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
00556   uint32_t xfer = 0;
00557   xfer += oprot->writeStructBegin("Hbase_compact_pargs");
00558   xfer += oprot->writeFieldBegin("tableNameOrRegionName", ::apache::thrift::protocol::T_STRING, 1);
00559   xfer += oprot->writeBinary((*(this->tableNameOrRegionName)));
00560   xfer += oprot->writeFieldEnd();
00561   xfer += oprot->writeFieldStop();
00562   xfer += oprot->writeStructEnd();
00563   return xfer;
00564 }
00565 
00566 uint32_t Hbase_compact_result::read(::apache::thrift::protocol::TProtocol* iprot) {
00567 
00568   uint32_t xfer = 0;
00569   std::string fname;
00570   ::apache::thrift::protocol::TType ftype;
00571   int16_t fid;
00572 
00573   xfer += iprot->readStructBegin(fname);
00574 
00575   using ::apache::thrift::protocol::TProtocolException;
00576 
00577 
00578   while (true)
00579   {
00580     xfer += iprot->readFieldBegin(fname, ftype, fid);
00581     if (ftype == ::apache::thrift::protocol::T_STOP) {
00582       break;
00583     }
00584     switch (fid)
00585     {
00586       case 1:
00587         if (ftype == ::apache::thrift::protocol::T_STRUCT) {
00588           xfer += this->io.read(iprot);
00589           this->__isset.io = true;
00590         } else {
00591           xfer += iprot->skip(ftype);
00592         }
00593         break;
00594       default:
00595         xfer += iprot->skip(ftype);
00596         break;
00597     }
00598     xfer += iprot->readFieldEnd();
00599   }
00600 
00601   xfer += iprot->readStructEnd();
00602 
00603   return xfer;
00604 }
00605 
00606 uint32_t Hbase_compact_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
00607 
00608   uint32_t xfer = 0;
00609 
00610   xfer += oprot->writeStructBegin("Hbase_compact_result");
00611 
00612   if (this->__isset.io) {
00613     xfer += oprot->writeFieldBegin("io", ::apache::thrift::protocol::T_STRUCT, 1);
00614     xfer += this->io.write(oprot);
00615     xfer += oprot->writeFieldEnd();
00616   }
00617   xfer += oprot->writeFieldStop();
00618   xfer += oprot->writeStructEnd();
00619   return xfer;
00620 }
00621 
00622 uint32_t Hbase_compact_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
00623 
00624   uint32_t xfer = 0;
00625   std::string fname;
00626   ::apache::thrift::protocol::TType ftype;
00627   int16_t fid;
00628 
00629   xfer += iprot->readStructBegin(fname);
00630 
00631   using ::apache::thrift::protocol::TProtocolException;
00632 
00633 
00634   while (true)
00635   {
00636     xfer += iprot->readFieldBegin(fname, ftype, fid);
00637     if (ftype == ::apache::thrift::protocol::T_STOP) {
00638       break;
00639     }
00640     switch (fid)
00641     {
00642       case 1:
00643         if (ftype == ::apache::thrift::protocol::T_STRUCT) {
00644           xfer += this->io.read(iprot);
00645           this->__isset.io = true;
00646         } else {
00647           xfer += iprot->skip(ftype);
00648         }
00649         break;
00650       default:
00651         xfer += iprot->skip(ftype);
00652         break;
00653     }
00654     xfer += iprot->readFieldEnd();
00655   }
00656 
00657   xfer += iprot->readStructEnd();
00658 
00659   return xfer;
00660 }
00661 
00662 uint32_t Hbase_majorCompact_args::read(::apache::thrift::protocol::TProtocol* iprot) {
00663 
00664   uint32_t xfer = 0;
00665   std::string fname;
00666   ::apache::thrift::protocol::TType ftype;
00667   int16_t fid;
00668 
00669   xfer += iprot->readStructBegin(fname);
00670 
00671   using ::apache::thrift::protocol::TProtocolException;
00672 
00673 
00674   while (true)
00675   {
00676     xfer += iprot->readFieldBegin(fname, ftype, fid);
00677     if (ftype == ::apache::thrift::protocol::T_STOP) {
00678       break;
00679     }
00680     switch (fid)
00681     {
00682       case 1:
00683         if (ftype == ::apache::thrift::protocol::T_STRING) {
00684           xfer += iprot->readBinary(this->tableNameOrRegionName);
00685           this->__isset.tableNameOrRegionName = true;
00686         } else {
00687           xfer += iprot->skip(ftype);
00688         }
00689         break;
00690       default:
00691         xfer += iprot->skip(ftype);
00692         break;
00693     }
00694     xfer += iprot->readFieldEnd();
00695   }
00696 
00697   xfer += iprot->readStructEnd();
00698 
00699   return xfer;
00700 }
00701 
00702 uint32_t Hbase_majorCompact_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
00703   uint32_t xfer = 0;
00704   xfer += oprot->writeStructBegin("Hbase_majorCompact_args");
00705   xfer += oprot->writeFieldBegin("tableNameOrRegionName", ::apache::thrift::protocol::T_STRING, 1);
00706   xfer += oprot->writeBinary(this->tableNameOrRegionName);
00707   xfer += oprot->writeFieldEnd();
00708   xfer += oprot->writeFieldStop();
00709   xfer += oprot->writeStructEnd();
00710   return xfer;
00711 }
00712 
00713 uint32_t Hbase_majorCompact_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
00714   uint32_t xfer = 0;
00715   xfer += oprot->writeStructBegin("Hbase_majorCompact_pargs");
00716   xfer += oprot->writeFieldBegin("tableNameOrRegionName", ::apache::thrift::protocol::T_STRING, 1);
00717   xfer += oprot->writeBinary((*(this->tableNameOrRegionName)));
00718   xfer += oprot->writeFieldEnd();
00719   xfer += oprot->writeFieldStop();
00720   xfer += oprot->writeStructEnd();
00721   return xfer;
00722 }
00723 
00724 uint32_t Hbase_majorCompact_result::read(::apache::thrift::protocol::TProtocol* iprot) {
00725 
00726   uint32_t xfer = 0;
00727   std::string fname;
00728   ::apache::thrift::protocol::TType ftype;
00729   int16_t fid;
00730 
00731   xfer += iprot->readStructBegin(fname);
00732 
00733   using ::apache::thrift::protocol::TProtocolException;
00734 
00735 
00736   while (true)
00737   {
00738     xfer += iprot->readFieldBegin(fname, ftype, fid);
00739     if (ftype == ::apache::thrift::protocol::T_STOP) {
00740       break;
00741     }
00742     switch (fid)
00743     {
00744       case 1:
00745         if (ftype == ::apache::thrift::protocol::T_STRUCT) {
00746           xfer += this->io.read(iprot);
00747           this->__isset.io = true;
00748         } else {
00749           xfer += iprot->skip(ftype);
00750         }
00751         break;
00752       default:
00753         xfer += iprot->skip(ftype);
00754         break;
00755     }
00756     xfer += iprot->readFieldEnd();
00757   }
00758 
00759   xfer += iprot->readStructEnd();
00760 
00761   return xfer;
00762 }
00763 
00764 uint32_t Hbase_majorCompact_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
00765 
00766   uint32_t xfer = 0;
00767 
00768   xfer += oprot->writeStructBegin("Hbase_majorCompact_result");
00769 
00770   if (this->__isset.io) {
00771     xfer += oprot->writeFieldBegin("io", ::apache::thrift::protocol::T_STRUCT, 1);
00772     xfer += this->io.write(oprot);
00773     xfer += oprot->writeFieldEnd();
00774   }
00775   xfer += oprot->writeFieldStop();
00776   xfer += oprot->writeStructEnd();
00777   return xfer;
00778 }
00779 
00780 uint32_t Hbase_majorCompact_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
00781 
00782   uint32_t xfer = 0;
00783   std::string fname;
00784   ::apache::thrift::protocol::TType ftype;
00785   int16_t fid;
00786 
00787   xfer += iprot->readStructBegin(fname);
00788 
00789   using ::apache::thrift::protocol::TProtocolException;
00790 
00791 
00792   while (true)
00793   {
00794     xfer += iprot->readFieldBegin(fname, ftype, fid);
00795     if (ftype == ::apache::thrift::protocol::T_STOP) {
00796       break;
00797     }
00798     switch (fid)
00799     {
00800       case 1:
00801         if (ftype == ::apache::thrift::protocol::T_STRUCT) {
00802           xfer += this->io.read(iprot);
00803           this->__isset.io = true;
00804         } else {
00805           xfer += iprot->skip(ftype);
00806         }
00807         break;
00808       default:
00809         xfer += iprot->skip(ftype);
00810         break;
00811     }
00812     xfer += iprot->readFieldEnd();
00813   }
00814 
00815   xfer += iprot->readStructEnd();
00816 
00817   return xfer;
00818 }
00819 
00820 uint32_t Hbase_getTableNames_args::read(::apache::thrift::protocol::TProtocol* iprot) {
00821 
00822   uint32_t xfer = 0;
00823   std::string fname;
00824   ::apache::thrift::protocol::TType ftype;
00825   int16_t fid;
00826 
00827   xfer += iprot->readStructBegin(fname);
00828 
00829   using ::apache::thrift::protocol::TProtocolException;
00830 
00831 
00832   while (true)
00833   {
00834     xfer += iprot->readFieldBegin(fname, ftype, fid);
00835     if (ftype == ::apache::thrift::protocol::T_STOP) {
00836       break;
00837     }
00838     switch (fid)
00839     {
00840       default:
00841         xfer += iprot->skip(ftype);
00842         break;
00843     }
00844     xfer += iprot->readFieldEnd();
00845   }
00846 
00847   xfer += iprot->readStructEnd();
00848 
00849   return xfer;
00850 }
00851 
00852 uint32_t Hbase_getTableNames_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
00853   uint32_t xfer = 0;
00854   xfer += oprot->writeStructBegin("Hbase_getTableNames_args");
00855   xfer += oprot->writeFieldStop();
00856   xfer += oprot->writeStructEnd();
00857   return xfer;
00858 }
00859 
00860 uint32_t Hbase_getTableNames_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
00861   uint32_t xfer = 0;
00862   xfer += oprot->writeStructBegin("Hbase_getTableNames_pargs");
00863   xfer += oprot->writeFieldStop();
00864   xfer += oprot->writeStructEnd();
00865   return xfer;
00866 }
00867 
00868 uint32_t Hbase_getTableNames_result::read(::apache::thrift::protocol::TProtocol* iprot) {
00869 
00870   uint32_t xfer = 0;
00871   std::string fname;
00872   ::apache::thrift::protocol::TType ftype;
00873   int16_t fid;
00874 
00875   xfer += iprot->readStructBegin(fname);
00876 
00877   using ::apache::thrift::protocol::TProtocolException;
00878 
00879 
00880   while (true)
00881   {
00882     xfer += iprot->readFieldBegin(fname, ftype, fid);
00883     if (ftype == ::apache::thrift::protocol::T_STOP) {
00884       break;
00885     }
00886     switch (fid)
00887     {
00888       case 0:
00889         if (ftype == ::apache::thrift::protocol::T_LIST) {
00890           {
00891             this->success.clear();
00892             uint32_t _size20;
00893             ::apache::thrift::protocol::TType _etype23;
00894             iprot->readListBegin(_etype23, _size20);
00895             this->success.resize(_size20);
00896             uint32_t _i24;
00897             for (_i24 = 0; _i24 < _size20; ++_i24)
00898             {
00899               xfer += iprot->readBinary(this->success[_i24]);
00900             }
00901             iprot->readListEnd();
00902           }
00903           this->__isset.success = true;
00904         } else {
00905           xfer += iprot->skip(ftype);
00906         }
00907         break;
00908       case 1:
00909         if (ftype == ::apache::thrift::protocol::T_STRUCT) {
00910           xfer += this->io.read(iprot);
00911           this->__isset.io = true;
00912         } else {
00913           xfer += iprot->skip(ftype);
00914         }
00915         break;
00916       default:
00917         xfer += iprot->skip(ftype);
00918         break;
00919     }
00920     xfer += iprot->readFieldEnd();
00921   }
00922 
00923   xfer += iprot->readStructEnd();
00924 
00925   return xfer;
00926 }
00927 
00928 uint32_t Hbase_getTableNames_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
00929 
00930   uint32_t xfer = 0;
00931 
00932   xfer += oprot->writeStructBegin("Hbase_getTableNames_result");
00933 
00934   if (this->__isset.success) {
00935     xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0);
00936     {
00937       xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->success.size()));
00938       std::vector<Text> ::const_iterator _iter25;
00939       for (_iter25 = this->success.begin(); _iter25 != this->success.end(); ++_iter25)
00940       {
00941         xfer += oprot->writeBinary((*_iter25));
00942       }
00943       xfer += oprot->writeListEnd();
00944     }
00945     xfer += oprot->writeFieldEnd();
00946   } else if (this->__isset.io) {
00947     xfer += oprot->writeFieldBegin("io", ::apache::thrift::protocol::T_STRUCT, 1);
00948     xfer += this->io.write(oprot);
00949     xfer += oprot->writeFieldEnd();
00950   }
00951   xfer += oprot->writeFieldStop();
00952   xfer += oprot->writeStructEnd();
00953   return xfer;
00954 }
00955 
00956 uint32_t Hbase_getTableNames_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
00957 
00958   uint32_t xfer = 0;
00959   std::string fname;
00960   ::apache::thrift::protocol::TType ftype;
00961   int16_t fid;
00962 
00963   xfer += iprot->readStructBegin(fname);
00964 
00965   using ::apache::thrift::protocol::TProtocolException;
00966 
00967 
00968   while (true)
00969   {
00970     xfer += iprot->readFieldBegin(fname, ftype, fid);
00971     if (ftype == ::apache::thrift::protocol::T_STOP) {
00972       break;
00973     }
00974     switch (fid)
00975     {
00976       case 0:
00977         if (ftype == ::apache::thrift::protocol::T_LIST) {
00978           {
00979             (*(this->success)).clear();
00980             uint32_t _size26;
00981             ::apache::thrift::protocol::TType _etype29;
00982             iprot->readListBegin(_etype29, _size26);
00983             (*(this->success)).resize(_size26);
00984             uint32_t _i30;
00985             for (_i30 = 0; _i30 < _size26; ++_i30)
00986             {
00987               xfer += iprot->readBinary((*(this->success))[_i30]);
00988             }
00989             iprot->readListEnd();
00990           }
00991           this->__isset.success = true;
00992         } else {
00993           xfer += iprot->skip(ftype);
00994         }
00995         break;
00996       case 1:
00997         if (ftype == ::apache::thrift::protocol::T_STRUCT) {
00998           xfer += this->io.read(iprot);
00999           this->__isset.io = true;
01000         } else {
01001           xfer += iprot->skip(ftype);
01002         }
01003         break;
01004       default:
01005         xfer += iprot->skip(ftype);
01006         break;
01007     }
01008     xfer += iprot->readFieldEnd();
01009   }
01010 
01011   xfer += iprot->readStructEnd();
01012 
01013   return xfer;
01014 }
01015 
01016 uint32_t Hbase_getColumnDescriptors_args::read(::apache::thrift::protocol::TProtocol* iprot) {
01017 
01018   uint32_t xfer = 0;
01019   std::string fname;
01020   ::apache::thrift::protocol::TType ftype;
01021   int16_t fid;
01022 
01023   xfer += iprot->readStructBegin(fname);
01024 
01025   using ::apache::thrift::protocol::TProtocolException;
01026 
01027 
01028   while (true)
01029   {
01030     xfer += iprot->readFieldBegin(fname, ftype, fid);
01031     if (ftype == ::apache::thrift::protocol::T_STOP) {
01032       break;
01033     }
01034     switch (fid)
01035     {
01036       case 1:
01037         if (ftype == ::apache::thrift::protocol::T_STRING) {
01038           xfer += iprot->readBinary(this->tableName);
01039           this->__isset.tableName = true;
01040         } else {
01041           xfer += iprot->skip(ftype);
01042         }
01043         break;
01044       default:
01045         xfer += iprot->skip(ftype);
01046         break;
01047     }
01048     xfer += iprot->readFieldEnd();
01049   }
01050 
01051   xfer += iprot->readStructEnd();
01052 
01053   return xfer;
01054 }
01055 
01056 uint32_t Hbase_getColumnDescriptors_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
01057   uint32_t xfer = 0;
01058   xfer += oprot->writeStructBegin("Hbase_getColumnDescriptors_args");
01059   xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
01060   xfer += oprot->writeBinary(this->tableName);
01061   xfer += oprot->writeFieldEnd();
01062   xfer += oprot->writeFieldStop();
01063   xfer += oprot->writeStructEnd();
01064   return xfer;
01065 }
01066 
01067 uint32_t Hbase_getColumnDescriptors_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
01068   uint32_t xfer = 0;
01069   xfer += oprot->writeStructBegin("Hbase_getColumnDescriptors_pargs");
01070   xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
01071   xfer += oprot->writeBinary((*(this->tableName)));
01072   xfer += oprot->writeFieldEnd();
01073   xfer += oprot->writeFieldStop();
01074   xfer += oprot->writeStructEnd();
01075   return xfer;
01076 }
01077 
01078 uint32_t Hbase_getColumnDescriptors_result::read(::apache::thrift::protocol::TProtocol* iprot) {
01079 
01080   uint32_t xfer = 0;
01081   std::string fname;
01082   ::apache::thrift::protocol::TType ftype;
01083   int16_t fid;
01084 
01085   xfer += iprot->readStructBegin(fname);
01086 
01087   using ::apache::thrift::protocol::TProtocolException;
01088 
01089 
01090   while (true)
01091   {
01092     xfer += iprot->readFieldBegin(fname, ftype, fid);
01093     if (ftype == ::apache::thrift::protocol::T_STOP) {
01094       break;
01095     }
01096     switch (fid)
01097     {
01098       case 0:
01099         if (ftype == ::apache::thrift::protocol::T_MAP) {
01100           {
01101             this->success.clear();
01102             uint32_t _size31;
01103             ::apache::thrift::protocol::TType _ktype32;
01104             ::apache::thrift::protocol::TType _vtype33;
01105             iprot->readMapBegin(_ktype32, _vtype33, _size31);
01106             uint32_t _i35;
01107             for (_i35 = 0; _i35 < _size31; ++_i35)
01108             {
01109               Text _key36;
01110               xfer += iprot->readBinary(_key36);
01111               ColumnDescriptor& _val37 = this->success[_key36];
01112               xfer += _val37.read(iprot);
01113             }
01114             iprot->readMapEnd();
01115           }
01116           this->__isset.success = true;
01117         } else {
01118           xfer += iprot->skip(ftype);
01119         }
01120         break;
01121       case 1:
01122         if (ftype == ::apache::thrift::protocol::T_STRUCT) {
01123           xfer += this->io.read(iprot);
01124           this->__isset.io = true;
01125         } else {
01126           xfer += iprot->skip(ftype);
01127         }
01128         break;
01129       default:
01130         xfer += iprot->skip(ftype);
01131         break;
01132     }
01133     xfer += iprot->readFieldEnd();
01134   }
01135 
01136   xfer += iprot->readStructEnd();
01137 
01138   return xfer;
01139 }
01140 
01141 uint32_t Hbase_getColumnDescriptors_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
01142 
01143   uint32_t xfer = 0;
01144 
01145   xfer += oprot->writeStructBegin("Hbase_getColumnDescriptors_result");
01146 
01147   if (this->__isset.success) {
01148     xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_MAP, 0);
01149     {
01150       xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->success.size()));
01151       std::map<Text, ColumnDescriptor> ::const_iterator _iter38;
01152       for (_iter38 = this->success.begin(); _iter38 != this->success.end(); ++_iter38)
01153       {
01154         xfer += oprot->writeBinary(_iter38->first);
01155         xfer += _iter38->second.write(oprot);
01156       }
01157       xfer += oprot->writeMapEnd();
01158     }
01159     xfer += oprot->writeFieldEnd();
01160   } else if (this->__isset.io) {
01161     xfer += oprot->writeFieldBegin("io", ::apache::thrift::protocol::T_STRUCT, 1);
01162     xfer += this->io.write(oprot);
01163     xfer += oprot->writeFieldEnd();
01164   }
01165   xfer += oprot->writeFieldStop();
01166   xfer += oprot->writeStructEnd();
01167   return xfer;
01168 }
01169 
01170 uint32_t Hbase_getColumnDescriptors_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
01171 
01172   uint32_t xfer = 0;
01173   std::string fname;
01174   ::apache::thrift::protocol::TType ftype;
01175   int16_t fid;
01176 
01177   xfer += iprot->readStructBegin(fname);
01178 
01179   using ::apache::thrift::protocol::TProtocolException;
01180 
01181 
01182   while (true)
01183   {
01184     xfer += iprot->readFieldBegin(fname, ftype, fid);
01185     if (ftype == ::apache::thrift::protocol::T_STOP) {
01186       break;
01187     }
01188     switch (fid)
01189     {
01190       case 0:
01191         if (ftype == ::apache::thrift::protocol::T_MAP) {
01192           {
01193             (*(this->success)).clear();
01194             uint32_t _size39;
01195             ::apache::thrift::protocol::TType _ktype40;
01196             ::apache::thrift::protocol::TType _vtype41;
01197             iprot->readMapBegin(_ktype40, _vtype41, _size39);
01198             uint32_t _i43;
01199             for (_i43 = 0; _i43 < _size39; ++_i43)
01200             {
01201               Text _key44;
01202               xfer += iprot->readBinary(_key44);
01203               ColumnDescriptor& _val45 = (*(this->success))[_key44];
01204               xfer += _val45.read(iprot);
01205             }
01206             iprot->readMapEnd();
01207           }
01208           this->__isset.success = true;
01209         } else {
01210           xfer += iprot->skip(ftype);
01211         }
01212         break;
01213       case 1:
01214         if (ftype == ::apache::thrift::protocol::T_STRUCT) {
01215           xfer += this->io.read(iprot);
01216           this->__isset.io = true;
01217         } else {
01218           xfer += iprot->skip(ftype);
01219         }
01220         break;
01221       default:
01222         xfer += iprot->skip(ftype);
01223         break;
01224     }
01225     xfer += iprot->readFieldEnd();
01226   }
01227 
01228   xfer += iprot->readStructEnd();
01229 
01230   return xfer;
01231 }
01232 
01233 uint32_t Hbase_getTableRegions_args::read(::apache::thrift::protocol::TProtocol* iprot) {
01234 
01235   uint32_t xfer = 0;
01236   std::string fname;
01237   ::apache::thrift::protocol::TType ftype;
01238   int16_t fid;
01239 
01240   xfer += iprot->readStructBegin(fname);
01241 
01242   using ::apache::thrift::protocol::TProtocolException;
01243 
01244 
01245   while (true)
01246   {
01247     xfer += iprot->readFieldBegin(fname, ftype, fid);
01248     if (ftype == ::apache::thrift::protocol::T_STOP) {
01249       break;
01250     }
01251     switch (fid)
01252     {
01253       case 1:
01254         if (ftype == ::apache::thrift::protocol::T_STRING) {
01255           xfer += iprot->readBinary(this->tableName);
01256           this->__isset.tableName = true;
01257         } else {
01258           xfer += iprot->skip(ftype);
01259         }
01260         break;
01261       default:
01262         xfer += iprot->skip(ftype);
01263         break;
01264     }
01265     xfer += iprot->readFieldEnd();
01266   }
01267 
01268   xfer += iprot->readStructEnd();
01269 
01270   return xfer;
01271 }
01272 
01273 uint32_t Hbase_getTableRegions_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
01274   uint32_t xfer = 0;
01275   xfer += oprot->writeStructBegin("Hbase_getTableRegions_args");
01276   xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
01277   xfer += oprot->writeBinary(this->tableName);
01278   xfer += oprot->writeFieldEnd();
01279   xfer += oprot->writeFieldStop();
01280   xfer += oprot->writeStructEnd();
01281   return xfer;
01282 }
01283 
01284 uint32_t Hbase_getTableRegions_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
01285   uint32_t xfer = 0;
01286   xfer += oprot->writeStructBegin("Hbase_getTableRegions_pargs");
01287   xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
01288   xfer += oprot->writeBinary((*(this->tableName)));
01289   xfer += oprot->writeFieldEnd();
01290   xfer += oprot->writeFieldStop();
01291   xfer += oprot->writeStructEnd();
01292   return xfer;
01293 }
01294 
01295 uint32_t Hbase_getTableRegions_result::read(::apache::thrift::protocol::TProtocol* iprot) {
01296 
01297   uint32_t xfer = 0;
01298   std::string fname;
01299   ::apache::thrift::protocol::TType ftype;
01300   int16_t fid;
01301 
01302   xfer += iprot->readStructBegin(fname);
01303 
01304   using ::apache::thrift::protocol::TProtocolException;
01305 
01306 
01307   while (true)
01308   {
01309     xfer += iprot->readFieldBegin(fname, ftype, fid);
01310     if (ftype == ::apache::thrift::protocol::T_STOP) {
01311       break;
01312     }
01313     switch (fid)
01314     {
01315       case 0:
01316         if (ftype == ::apache::thrift::protocol::T_LIST) {
01317           {
01318             this->success.clear();
01319             uint32_t _size46;
01320             ::apache::thrift::protocol::TType _etype49;
01321             iprot->readListBegin(_etype49, _size46);
01322             this->success.resize(_size46);
01323             uint32_t _i50;
01324             for (_i50 = 0; _i50 < _size46; ++_i50)
01325             {
01326               xfer += this->success[_i50].read(iprot);
01327             }
01328             iprot->readListEnd();
01329           }
01330           this->__isset.success = true;
01331         } else {
01332           xfer += iprot->skip(ftype);
01333         }
01334         break;
01335       case 1:
01336         if (ftype == ::apache::thrift::protocol::T_STRUCT) {
01337           xfer += this->io.read(iprot);
01338           this->__isset.io = true;
01339         } else {
01340           xfer += iprot->skip(ftype);
01341         }
01342         break;
01343       default:
01344         xfer += iprot->skip(ftype);
01345         break;
01346     }
01347     xfer += iprot->readFieldEnd();
01348   }
01349 
01350   xfer += iprot->readStructEnd();
01351 
01352   return xfer;
01353 }
01354 
01355 uint32_t Hbase_getTableRegions_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
01356 
01357   uint32_t xfer = 0;
01358 
01359   xfer += oprot->writeStructBegin("Hbase_getTableRegions_result");
01360 
01361   if (this->__isset.success) {
01362     xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0);
01363     {
01364       xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->success.size()));
01365       std::vector<TRegionInfo> ::const_iterator _iter51;
01366       for (_iter51 = this->success.begin(); _iter51 != this->success.end(); ++_iter51)
01367       {
01368         xfer += (*_iter51).write(oprot);
01369       }
01370       xfer += oprot->writeListEnd();
01371     }
01372     xfer += oprot->writeFieldEnd();
01373   } else if (this->__isset.io) {
01374     xfer += oprot->writeFieldBegin("io", ::apache::thrift::protocol::T_STRUCT, 1);
01375     xfer += this->io.write(oprot);
01376     xfer += oprot->writeFieldEnd();
01377   }
01378   xfer += oprot->writeFieldStop();
01379   xfer += oprot->writeStructEnd();
01380   return xfer;
01381 }
01382 
01383 uint32_t Hbase_getTableRegions_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
01384 
01385   uint32_t xfer = 0;
01386   std::string fname;
01387   ::apache::thrift::protocol::TType ftype;
01388   int16_t fid;
01389 
01390   xfer += iprot->readStructBegin(fname);
01391 
01392   using ::apache::thrift::protocol::TProtocolException;
01393 
01394 
01395   while (true)
01396   {
01397     xfer += iprot->readFieldBegin(fname, ftype, fid);
01398     if (ftype == ::apache::thrift::protocol::T_STOP) {
01399       break;
01400     }
01401     switch (fid)
01402     {
01403       case 0:
01404         if (ftype == ::apache::thrift::protocol::T_LIST) {
01405           {
01406             (*(this->success)).clear();
01407             uint32_t _size52;
01408             ::apache::thrift::protocol::TType _etype55;
01409             iprot->readListBegin(_etype55, _size52);
01410             (*(this->success)).resize(_size52);
01411             uint32_t _i56;
01412             for (_i56 = 0; _i56 < _size52; ++_i56)
01413             {
01414               xfer += (*(this->success))[_i56].read(iprot);
01415             }
01416             iprot->readListEnd();
01417           }
01418           this->__isset.success = true;
01419         } else {
01420           xfer += iprot->skip(ftype);
01421         }
01422         break;
01423       case 1:
01424         if (ftype == ::apache::thrift::protocol::T_STRUCT) {
01425           xfer += this->io.read(iprot);
01426           this->__isset.io = true;
01427         } else {
01428           xfer += iprot->skip(ftype);
01429         }
01430         break;
01431       default:
01432         xfer += iprot->skip(ftype);
01433         break;
01434     }
01435     xfer += iprot->readFieldEnd();
01436   }
01437 
01438   xfer += iprot->readStructEnd();
01439 
01440   return xfer;
01441 }
01442 
01443 uint32_t Hbase_createTable_args::read(::apache::thrift::protocol::TProtocol* iprot) {
01444 
01445   uint32_t xfer = 0;
01446   std::string fname;
01447   ::apache::thrift::protocol::TType ftype;
01448   int16_t fid;
01449 
01450   xfer += iprot->readStructBegin(fname);
01451 
01452   using ::apache::thrift::protocol::TProtocolException;
01453 
01454 
01455   while (true)
01456   {
01457     xfer += iprot->readFieldBegin(fname, ftype, fid);
01458     if (ftype == ::apache::thrift::protocol::T_STOP) {
01459       break;
01460     }
01461     switch (fid)
01462     {
01463       case 1:
01464         if (ftype == ::apache::thrift::protocol::T_STRING) {
01465           xfer += iprot->readBinary(this->tableName);
01466           this->__isset.tableName = true;
01467         } else {
01468           xfer += iprot->skip(ftype);
01469         }
01470         break;
01471       case 2:
01472         if (ftype == ::apache::thrift::protocol::T_LIST) {
01473           {
01474             this->columnFamilies.clear();
01475             uint32_t _size57;
01476             ::apache::thrift::protocol::TType _etype60;
01477             iprot->readListBegin(_etype60, _size57);
01478             this->columnFamilies.resize(_size57);
01479             uint32_t _i61;
01480             for (_i61 = 0; _i61 < _size57; ++_i61)
01481             {
01482               xfer += this->columnFamilies[_i61].read(iprot);
01483             }
01484             iprot->readListEnd();
01485           }
01486           this->__isset.columnFamilies = true;
01487         } else {
01488           xfer += iprot->skip(ftype);
01489         }
01490         break;
01491       default:
01492         xfer += iprot->skip(ftype);
01493         break;
01494     }
01495     xfer += iprot->readFieldEnd();
01496   }
01497 
01498   xfer += iprot->readStructEnd();
01499 
01500   return xfer;
01501 }
01502 
01503 uint32_t Hbase_createTable_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
01504   uint32_t xfer = 0;
01505   xfer += oprot->writeStructBegin("Hbase_createTable_args");
01506   xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
01507   xfer += oprot->writeBinary(this->tableName);
01508   xfer += oprot->writeFieldEnd();
01509   xfer += oprot->writeFieldBegin("columnFamilies", ::apache::thrift::protocol::T_LIST, 2);
01510   {
01511     xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->columnFamilies.size()));
01512     std::vector<ColumnDescriptor> ::const_iterator _iter62;
01513     for (_iter62 = this->columnFamilies.begin(); _iter62 != this->columnFamilies.end(); ++_iter62)
01514     {
01515       xfer += (*_iter62).write(oprot);
01516     }
01517     xfer += oprot->writeListEnd();
01518   }
01519   xfer += oprot->writeFieldEnd();
01520   xfer += oprot->writeFieldStop();
01521   xfer += oprot->writeStructEnd();
01522   return xfer;
01523 }
01524 
01525 uint32_t Hbase_createTable_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
01526   uint32_t xfer = 0;
01527   xfer += oprot->writeStructBegin("Hbase_createTable_pargs");
01528   xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
01529   xfer += oprot->writeBinary((*(this->tableName)));
01530   xfer += oprot->writeFieldEnd();
01531   xfer += oprot->writeFieldBegin("columnFamilies", ::apache::thrift::protocol::T_LIST, 2);
01532   {
01533     xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>((*(this->columnFamilies)).size()));
01534     std::vector<ColumnDescriptor> ::const_iterator _iter63;
01535     for (_iter63 = (*(this->columnFamilies)).begin(); _iter63 != (*(this->columnFamilies)).end(); ++_iter63)
01536     {
01537       xfer += (*_iter63).write(oprot);
01538     }
01539     xfer += oprot->writeListEnd();
01540   }
01541   xfer += oprot->writeFieldEnd();
01542   xfer += oprot->writeFieldStop();
01543   xfer += oprot->writeStructEnd();
01544   return xfer;
01545 }
01546 
01547 uint32_t Hbase_createTable_result::read(::apache::thrift::protocol::TProtocol* iprot) {
01548 
01549   uint32_t xfer = 0;
01550   std::string fname;
01551   ::apache::thrift::protocol::TType ftype;
01552   int16_t fid;
01553 
01554   xfer += iprot->readStructBegin(fname);
01555 
01556   using ::apache::thrift::protocol::TProtocolException;
01557 
01558 
01559   while (true)
01560   {
01561     xfer += iprot->readFieldBegin(fname, ftype, fid);
01562     if (ftype == ::apache::thrift::protocol::T_STOP) {
01563       break;
01564     }
01565     switch (fid)
01566     {
01567       case 1:
01568         if (ftype == ::apache::thrift::protocol::T_STRUCT) {
01569           xfer += this->io.read(iprot);
01570           this->__isset.io = true;
01571         } else {
01572           xfer += iprot->skip(ftype);
01573         }
01574         break;
01575       case 2:
01576         if (ftype == ::apache::thrift::protocol::T_STRUCT) {
01577           xfer += this->ia.read(iprot);
01578           this->__isset.ia = true;
01579         } else {
01580           xfer += iprot->skip(ftype);
01581         }
01582         break;
01583       case 3:
01584         if (ftype == ::apache::thrift::protocol::T_STRUCT) {
01585           xfer += this->exist.read(iprot);
01586           this->__isset.exist = true;
01587         } else {
01588           xfer += iprot->skip(ftype);
01589         }
01590         break;
01591       default:
01592         xfer += iprot->skip(ftype);
01593         break;
01594     }
01595     xfer += iprot->readFieldEnd();
01596   }
01597 
01598   xfer += iprot->readStructEnd();
01599 
01600   return xfer;
01601 }
01602 
01603 uint32_t Hbase_createTable_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
01604 
01605   uint32_t xfer = 0;
01606 
01607   xfer += oprot->writeStructBegin("Hbase_createTable_result");
01608 
01609   if (this->__isset.io) {
01610     xfer += oprot->writeFieldBegin("io", ::apache::thrift::protocol::T_STRUCT, 1);
01611     xfer += this->io.write(oprot);
01612     xfer += oprot->writeFieldEnd();
01613   } else if (this->__isset.ia) {
01614     xfer += oprot->writeFieldBegin("ia", ::apache::thrift::protocol::T_STRUCT, 2);
01615     xfer += this->ia.write(oprot);
01616     xfer += oprot->writeFieldEnd();
01617   } else if (this->__isset.exist) {
01618     xfer += oprot->writeFieldBegin("exist", ::apache::thrift::protocol::T_STRUCT, 3);
01619     xfer += this->exist.write(oprot);
01620     xfer += oprot->writeFieldEnd();
01621   }
01622   xfer += oprot->writeFieldStop();
01623   xfer += oprot->writeStructEnd();
01624   return xfer;
01625 }
01626 
01627 uint32_t Hbase_createTable_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
01628 
01629   uint32_t xfer = 0;
01630   std::string fname;
01631   ::apache::thrift::protocol::TType ftype;
01632   int16_t fid;
01633 
01634   xfer += iprot->readStructBegin(fname);
01635 
01636   using ::apache::thrift::protocol::TProtocolException;
01637 
01638 
01639   while (true)
01640   {
01641     xfer += iprot->readFieldBegin(fname, ftype, fid);
01642     if (ftype == ::apache::thrift::protocol::T_STOP) {
01643       break;
01644     }
01645     switch (fid)
01646     {
01647       case 1:
01648         if (ftype == ::apache::thrift::protocol::T_STRUCT) {
01649           xfer += this->io.read(iprot);
01650           this->__isset.io = true;
01651         } else {
01652           xfer += iprot->skip(ftype);
01653         }
01654         break;
01655       case 2:
01656         if (ftype == ::apache::thrift::protocol::T_STRUCT) {
01657           xfer += this->ia.read(iprot);
01658           this->__isset.ia = true;
01659         } else {
01660           xfer += iprot->skip(ftype);
01661         }
01662         break;
01663       case 3:
01664         if (ftype == ::apache::thrift::protocol::T_STRUCT) {
01665           xfer += this->exist.read(iprot);
01666           this->__isset.exist = true;
01667         } else {
01668           xfer += iprot->skip(ftype);
01669         }
01670         break;
01671       default:
01672         xfer += iprot->skip(ftype);
01673         break;
01674     }
01675     xfer += iprot->readFieldEnd();
01676   }
01677 
01678   xfer += iprot->readStructEnd();
01679 
01680   return xfer;
01681 }
01682 
01683 uint32_t Hbase_deleteTable_args::read(::apache::thrift::protocol::TProtocol* iprot) {
01684 
01685   uint32_t xfer = 0;
01686   std::string fname;
01687   ::apache::thrift::protocol::TType ftype;
01688   int16_t fid;
01689 
01690   xfer += iprot->readStructBegin(fname);
01691 
01692   using ::apache::thrift::protocol::TProtocolException;
01693 
01694 
01695   while (true)
01696   {
01697     xfer += iprot->readFieldBegin(fname, ftype, fid);
01698     if (ftype == ::apache::thrift::protocol::T_STOP) {
01699       break;
01700     }
01701     switch (fid)
01702     {
01703       case 1:
01704         if (ftype == ::apache::thrift::protocol::T_STRING) {
01705           xfer += iprot->readBinary(this->tableName);
01706           this->__isset.tableName = true;
01707         } else {
01708           xfer += iprot->skip(ftype);
01709         }
01710         break;
01711       default:
01712         xfer += iprot->skip(ftype);
01713         break;
01714     }
01715     xfer += iprot->readFieldEnd();
01716   }
01717 
01718   xfer += iprot->readStructEnd();
01719 
01720   return xfer;
01721 }
01722 
01723 uint32_t Hbase_deleteTable_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
01724   uint32_t xfer = 0;
01725   xfer += oprot->writeStructBegin("Hbase_deleteTable_args");
01726   xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
01727   xfer += oprot->writeBinary(this->tableName);
01728   xfer += oprot->writeFieldEnd();
01729   xfer += oprot->writeFieldStop();
01730   xfer += oprot->writeStructEnd();
01731   return xfer;
01732 }
01733 
01734 uint32_t Hbase_deleteTable_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
01735   uint32_t xfer = 0;
01736   xfer += oprot->writeStructBegin("Hbase_deleteTable_pargs");
01737   xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
01738   xfer += oprot->writeBinary((*(this->tableName)));
01739   xfer += oprot->writeFieldEnd();
01740   xfer += oprot->writeFieldStop();
01741   xfer += oprot->writeStructEnd();
01742   return xfer;
01743 }
01744 
01745 uint32_t Hbase_deleteTable_result::read(::apache::thrift::protocol::TProtocol* iprot) {
01746 
01747   uint32_t xfer = 0;
01748   std::string fname;
01749   ::apache::thrift::protocol::TType ftype;
01750   int16_t fid;
01751 
01752   xfer += iprot->readStructBegin(fname);
01753 
01754   using ::apache::thrift::protocol::TProtocolException;
01755 
01756 
01757   while (true)
01758   {
01759     xfer += iprot->readFieldBegin(fname, ftype, fid);
01760     if (ftype == ::apache::thrift::protocol::T_STOP) {
01761       break;
01762     }
01763     switch (fid)
01764     {
01765       case 1:
01766         if (ftype == ::apache::thrift::protocol::T_STRUCT) {
01767           xfer += this->io.read(iprot);
01768           this->__isset.io = true;
01769         } else {
01770           xfer += iprot->skip(ftype);
01771         }
01772         break;
01773       default:
01774         xfer += iprot->skip(ftype);
01775         break;
01776     }
01777     xfer += iprot->readFieldEnd();
01778   }
01779 
01780   xfer += iprot->readStructEnd();
01781 
01782   return xfer;
01783 }
01784 
01785 uint32_t Hbase_deleteTable_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
01786 
01787   uint32_t xfer = 0;
01788 
01789   xfer += oprot->writeStructBegin("Hbase_deleteTable_result");
01790 
01791   if (this->__isset.io) {
01792     xfer += oprot->writeFieldBegin("io", ::apache::thrift::protocol::T_STRUCT, 1);
01793     xfer += this->io.write(oprot);
01794     xfer += oprot->writeFieldEnd();
01795   }
01796   xfer += oprot->writeFieldStop();
01797   xfer += oprot->writeStructEnd();
01798   return xfer;
01799 }
01800 
01801 uint32_t Hbase_deleteTable_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
01802 
01803   uint32_t xfer = 0;
01804   std::string fname;
01805   ::apache::thrift::protocol::TType ftype;
01806   int16_t fid;
01807 
01808   xfer += iprot->readStructBegin(fname);
01809 
01810   using ::apache::thrift::protocol::TProtocolException;
01811 
01812 
01813   while (true)
01814   {
01815     xfer += iprot->readFieldBegin(fname, ftype, fid);
01816     if (ftype == ::apache::thrift::protocol::T_STOP) {
01817       break;
01818     }
01819     switch (fid)
01820     {
01821       case 1:
01822         if (ftype == ::apache::thrift::protocol::T_STRUCT) {
01823           xfer += this->io.read(iprot);
01824           this->__isset.io = true;
01825         } else {
01826           xfer += iprot->skip(ftype);
01827         }
01828         break;
01829       default:
01830         xfer += iprot->skip(ftype);
01831         break;
01832     }
01833     xfer += iprot->readFieldEnd();
01834   }
01835 
01836   xfer += iprot->readStructEnd();
01837 
01838   return xfer;
01839 }
01840 
01841 uint32_t Hbase_get_args::read(::apache::thrift::protocol::TProtocol* iprot) {
01842 
01843   uint32_t xfer = 0;
01844   std::string fname;
01845   ::apache::thrift::protocol::TType ftype;
01846   int16_t fid;
01847 
01848   xfer += iprot->readStructBegin(fname);
01849 
01850   using ::apache::thrift::protocol::TProtocolException;
01851 
01852 
01853   while (true)
01854   {
01855     xfer += iprot->readFieldBegin(fname, ftype, fid);
01856     if (ftype == ::apache::thrift::protocol::T_STOP) {
01857       break;
01858     }
01859     switch (fid)
01860     {
01861       case 1:
01862         if (ftype == ::apache::thrift::protocol::T_STRING) {
01863           xfer += iprot->readBinary(this->tableName);
01864           this->__isset.tableName = true;
01865         } else {
01866           xfer += iprot->skip(ftype);
01867         }
01868         break;
01869       case 2:
01870         if (ftype == ::apache::thrift::protocol::T_STRING) {
01871           xfer += iprot->readBinary(this->row);
01872           this->__isset.row = true;
01873         } else {
01874           xfer += iprot->skip(ftype);
01875         }
01876         break;
01877       case 3:
01878         if (ftype == ::apache::thrift::protocol::T_STRING) {
01879           xfer += iprot->readBinary(this->column);
01880           this->__isset.column = true;
01881         } else {
01882           xfer += iprot->skip(ftype);
01883         }
01884         break;
01885       default:
01886         xfer += iprot->skip(ftype);
01887         break;
01888     }
01889     xfer += iprot->readFieldEnd();
01890   }
01891 
01892   xfer += iprot->readStructEnd();
01893 
01894   return xfer;
01895 }
01896 
01897 uint32_t Hbase_get_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
01898   uint32_t xfer = 0;
01899   xfer += oprot->writeStructBegin("Hbase_get_args");
01900   xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
01901   xfer += oprot->writeBinary(this->tableName);
01902   xfer += oprot->writeFieldEnd();
01903   xfer += oprot->writeFieldBegin("row", ::apache::thrift::protocol::T_STRING, 2);
01904   xfer += oprot->writeBinary(this->row);
01905   xfer += oprot->writeFieldEnd();
01906   xfer += oprot->writeFieldBegin("column", ::apache::thrift::protocol::T_STRING, 3);
01907   xfer += oprot->writeBinary(this->column);
01908   xfer += oprot->writeFieldEnd();
01909   xfer += oprot->writeFieldStop();
01910   xfer += oprot->writeStructEnd();
01911   return xfer;
01912 }
01913 
01914 uint32_t Hbase_get_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
01915   uint32_t xfer = 0;
01916   xfer += oprot->writeStructBegin("Hbase_get_pargs");
01917   xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
01918   xfer += oprot->writeBinary((*(this->tableName)));
01919   xfer += oprot->writeFieldEnd();
01920   xfer += oprot->writeFieldBegin("row", ::apache::thrift::protocol::T_STRING, 2);
01921   xfer += oprot->writeBinary((*(this->row)));
01922   xfer += oprot->writeFieldEnd();
01923   xfer += oprot->writeFieldBegin("column", ::apache::thrift::protocol::T_STRING, 3);
01924   xfer += oprot->writeBinary((*(this->column)));
01925   xfer += oprot->writeFieldEnd();
01926   xfer += oprot->writeFieldStop();
01927   xfer += oprot->writeStructEnd();
01928   return xfer;
01929 }
01930 
01931 uint32_t Hbase_get_result::read(::apache::thrift::protocol::TProtocol* iprot) {
01932 
01933   uint32_t xfer = 0;
01934   std::string fname;
01935   ::apache::thrift::protocol::TType ftype;
01936   int16_t fid;
01937 
01938   xfer += iprot->readStructBegin(fname);
01939 
01940   using ::apache::thrift::protocol::TProtocolException;
01941 
01942 
01943   while (true)
01944   {
01945     xfer += iprot->readFieldBegin(fname, ftype, fid);
01946     if (ftype == ::apache::thrift::protocol::T_STOP) {
01947       break;
01948     }
01949     switch (fid)
01950     {
01951       case 0:
01952         if (ftype == ::apache::thrift::protocol::T_LIST) {
01953           {
01954             this->success.clear();
01955             uint32_t _size64;
01956             ::apache::thrift::protocol::TType _etype67;
01957             iprot->readListBegin(_etype67, _size64);
01958             this->success.resize(_size64);
01959             uint32_t _i68;
01960             for (_i68 = 0; _i68 < _size64; ++_i68)
01961             {
01962               xfer += this->success[_i68].read(iprot);
01963             }
01964             iprot->readListEnd();
01965           }
01966           this->__isset.success = true;
01967         } else {
01968           xfer += iprot->skip(ftype);
01969         }
01970         break;
01971       case 1:
01972         if (ftype == ::apache::thrift::protocol::T_STRUCT) {
01973           xfer += this->io.read(iprot);
01974           this->__isset.io = true;
01975         } else {
01976           xfer += iprot->skip(ftype);
01977         }
01978         break;
01979       default:
01980         xfer += iprot->skip(ftype);
01981         break;
01982     }
01983     xfer += iprot->readFieldEnd();
01984   }
01985 
01986   xfer += iprot->readStructEnd();
01987 
01988   return xfer;
01989 }
01990 
01991 uint32_t Hbase_get_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
01992 
01993   uint32_t xfer = 0;
01994 
01995   xfer += oprot->writeStructBegin("Hbase_get_result");
01996 
01997   if (this->__isset.success) {
01998     xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0);
01999     {
02000       xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->success.size()));
02001       std::vector<TCell> ::const_iterator _iter69;
02002       for (_iter69 = this->success.begin(); _iter69 != this->success.end(); ++_iter69)
02003       {
02004         xfer += (*_iter69).write(oprot);
02005       }
02006       xfer += oprot->writeListEnd();
02007     }
02008     xfer += oprot->writeFieldEnd();
02009   } else if (this->__isset.io) {
02010     xfer += oprot->writeFieldBegin("io", ::apache::thrift::protocol::T_STRUCT, 1);
02011     xfer += this->io.write(oprot);
02012     xfer += oprot->writeFieldEnd();
02013   }
02014   xfer += oprot->writeFieldStop();
02015   xfer += oprot->writeStructEnd();
02016   return xfer;
02017 }
02018 
02019 uint32_t Hbase_get_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
02020 
02021   uint32_t xfer = 0;
02022   std::string fname;
02023   ::apache::thrift::protocol::TType ftype;
02024   int16_t fid;
02025 
02026   xfer += iprot->readStructBegin(fname);
02027 
02028   using ::apache::thrift::protocol::TProtocolException;
02029 
02030 
02031   while (true)
02032   {
02033     xfer += iprot->readFieldBegin(fname, ftype, fid);
02034     if (ftype == ::apache::thrift::protocol::T_STOP) {
02035       break;
02036     }
02037     switch (fid)
02038     {
02039       case 0:
02040         if (ftype == ::apache::thrift::protocol::T_LIST) {
02041           {
02042             (*(this->success)).clear();
02043             uint32_t _size70;
02044             ::apache::thrift::protocol::TType _etype73;
02045             iprot->readListBegin(_etype73, _size70);
02046             (*(this->success)).resize(_size70);
02047             uint32_t _i74;
02048             for (_i74 = 0; _i74 < _size70; ++_i74)
02049             {
02050               xfer += (*(this->success))[_i74].read(iprot);
02051             }
02052             iprot->readListEnd();
02053           }
02054           this->__isset.success = true;
02055         } else {
02056           xfer += iprot->skip(ftype);
02057         }
02058         break;
02059       case 1:
02060         if (ftype == ::apache::thrift::protocol::T_STRUCT) {
02061           xfer += this->io.read(iprot);
02062           this->__isset.io = true;
02063         } else {
02064           xfer += iprot->skip(ftype);
02065         }
02066         break;
02067       default:
02068         xfer += iprot->skip(ftype);
02069         break;
02070     }
02071     xfer += iprot->readFieldEnd();
02072   }
02073 
02074   xfer += iprot->readStructEnd();
02075 
02076   return xfer;
02077 }
02078 
02079 uint32_t Hbase_getVer_args::read(::apache::thrift::protocol::TProtocol* iprot) {
02080 
02081   uint32_t xfer = 0;
02082   std::string fname;
02083   ::apache::thrift::protocol::TType ftype;
02084   int16_t fid;
02085 
02086   xfer += iprot->readStructBegin(fname);
02087 
02088   using ::apache::thrift::protocol::TProtocolException;
02089 
02090 
02091   while (true)
02092   {
02093     xfer += iprot->readFieldBegin(fname, ftype, fid);
02094     if (ftype == ::apache::thrift::protocol::T_STOP) {
02095       break;
02096     }
02097     switch (fid)
02098     {
02099       case 1:
02100         if (ftype == ::apache::thrift::protocol::T_STRING) {
02101           xfer += iprot->readBinary(this->tableName);
02102           this->__isset.tableName = true;
02103         } else {
02104           xfer += iprot->skip(ftype);
02105         }
02106         break;
02107       case 2:
02108         if (ftype == ::apache::thrift::protocol::T_STRING) {
02109           xfer += iprot->readBinary(this->row);
02110           this->__isset.row = true;
02111         } else {
02112           xfer += iprot->skip(ftype);
02113         }
02114         break;
02115       case 3:
02116         if (ftype == ::apache::thrift::protocol::T_STRING) {
02117           xfer += iprot->readBinary(this->column);
02118           this->__isset.column = true;
02119         } else {
02120           xfer += iprot->skip(ftype);
02121         }
02122         break;
02123       case 4:
02124         if (ftype == ::apache::thrift::protocol::T_I32) {
02125           xfer += iprot->readI32(this->numVersions);
02126           this->__isset.numVersions = true;
02127         } else {
02128           xfer += iprot->skip(ftype);
02129         }
02130         break;
02131       default:
02132         xfer += iprot->skip(ftype);
02133         break;
02134     }
02135     xfer += iprot->readFieldEnd();
02136   }
02137 
02138   xfer += iprot->readStructEnd();
02139 
02140   return xfer;
02141 }
02142 
02143 uint32_t Hbase_getVer_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
02144   uint32_t xfer = 0;
02145   xfer += oprot->writeStructBegin("Hbase_getVer_args");
02146   xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
02147   xfer += oprot->writeBinary(this->tableName);
02148   xfer += oprot->writeFieldEnd();
02149   xfer += oprot->writeFieldBegin("row", ::apache::thrift::protocol::T_STRING, 2);
02150   xfer += oprot->writeBinary(this->row);
02151   xfer += oprot->writeFieldEnd();
02152   xfer += oprot->writeFieldBegin("column", ::apache::thrift::protocol::T_STRING, 3);
02153   xfer += oprot->writeBinary(this->column);
02154   xfer += oprot->writeFieldEnd();
02155   xfer += oprot->writeFieldBegin("numVersions", ::apache::thrift::protocol::T_I32, 4);
02156   xfer += oprot->writeI32(this->numVersions);
02157   xfer += oprot->writeFieldEnd();
02158   xfer += oprot->writeFieldStop();
02159   xfer += oprot->writeStructEnd();
02160   return xfer;
02161 }
02162 
02163 uint32_t Hbase_getVer_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
02164   uint32_t xfer = 0;
02165   xfer += oprot->writeStructBegin("Hbase_getVer_pargs");
02166   xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
02167   xfer += oprot->writeBinary((*(this->tableName)));
02168   xfer += oprot->writeFieldEnd();
02169   xfer += oprot->writeFieldBegin("row", ::apache::thrift::protocol::T_STRING, 2);
02170   xfer += oprot->writeBinary((*(this->row)));
02171   xfer += oprot->writeFieldEnd();
02172   xfer += oprot->writeFieldBegin("column", ::apache::thrift::protocol::T_STRING, 3);
02173   xfer += oprot->writeBinary((*(this->column)));
02174   xfer += oprot->writeFieldEnd();
02175   xfer += oprot->writeFieldBegin("numVersions", ::apache::thrift::protocol::T_I32, 4);
02176   xfer += oprot->writeI32((*(this->numVersions)));
02177   xfer += oprot->writeFieldEnd();
02178   xfer += oprot->writeFieldStop();
02179   xfer += oprot->writeStructEnd();
02180   return xfer;
02181 }
02182 
02183 uint32_t Hbase_getVer_result::read(::apache::thrift::protocol::TProtocol* iprot) {
02184 
02185   uint32_t xfer = 0;
02186   std::string fname;
02187   ::apache::thrift::protocol::TType ftype;
02188   int16_t fid;
02189 
02190   xfer += iprot->readStructBegin(fname);
02191 
02192   using ::apache::thrift::protocol::TProtocolException;
02193 
02194 
02195   while (true)
02196   {
02197     xfer += iprot->readFieldBegin(fname, ftype, fid);
02198     if (ftype == ::apache::thrift::protocol::T_STOP) {
02199       break;
02200     }
02201     switch (fid)
02202     {
02203       case 0:
02204         if (ftype == ::apache::thrift::protocol::T_LIST) {
02205           {
02206             this->success.clear();
02207             uint32_t _size75;
02208             ::apache::thrift::protocol::TType _etype78;
02209             iprot->readListBegin(_etype78, _size75);
02210             this->success.resize(_size75);
02211             uint32_t _i79;
02212             for (_i79 = 0; _i79 < _size75; ++_i79)
02213             {
02214               xfer += this->success[_i79].read(iprot);
02215             }
02216             iprot->readListEnd();
02217           }
02218           this->__isset.success = true;
02219         } else {
02220           xfer += iprot->skip(ftype);
02221         }
02222         break;
02223       case 1:
02224         if (ftype == ::apache::thrift::protocol::T_STRUCT) {
02225           xfer += this->io.read(iprot);
02226           this->__isset.io = true;
02227         } else {
02228           xfer += iprot->skip(ftype);
02229         }
02230         break;
02231       default:
02232         xfer += iprot->skip(ftype);
02233         break;
02234     }
02235     xfer += iprot->readFieldEnd();
02236   }
02237 
02238   xfer += iprot->readStructEnd();
02239 
02240   return xfer;
02241 }
02242 
02243 uint32_t Hbase_getVer_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
02244 
02245   uint32_t xfer = 0;
02246 
02247   xfer += oprot->writeStructBegin("Hbase_getVer_result");
02248 
02249   if (this->__isset.success) {
02250     xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0);
02251     {
02252       xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->success.size()));
02253       std::vector<TCell> ::const_iterator _iter80;
02254       for (_iter80 = this->success.begin(); _iter80 != this->success.end(); ++_iter80)
02255       {
02256         xfer += (*_iter80).write(oprot);
02257       }
02258       xfer += oprot->writeListEnd();
02259     }
02260     xfer += oprot->writeFieldEnd();
02261   } else if (this->__isset.io) {
02262     xfer += oprot->writeFieldBegin("io", ::apache::thrift::protocol::T_STRUCT, 1);
02263     xfer += this->io.write(oprot);
02264     xfer += oprot->writeFieldEnd();
02265   }
02266   xfer += oprot->writeFieldStop();
02267   xfer += oprot->writeStructEnd();
02268   return xfer;
02269 }
02270 
02271 uint32_t Hbase_getVer_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
02272 
02273   uint32_t xfer = 0;
02274   std::string fname;
02275   ::apache::thrift::protocol::TType ftype;
02276   int16_t fid;
02277 
02278   xfer += iprot->readStructBegin(fname);
02279 
02280   using ::apache::thrift::protocol::TProtocolException;
02281 
02282 
02283   while (true)
02284   {
02285     xfer += iprot->readFieldBegin(fname, ftype, fid);
02286     if (ftype == ::apache::thrift::protocol::T_STOP) {
02287       break;
02288     }
02289     switch (fid)
02290     {
02291       case 0:
02292         if (ftype == ::apache::thrift::protocol::T_LIST) {
02293           {
02294             (*(this->success)).clear();
02295             uint32_t _size81;
02296             ::apache::thrift::protocol::TType _etype84;
02297             iprot->readListBegin(_etype84, _size81);
02298             (*(this->success)).resize(_size81);
02299             uint32_t _i85;
02300             for (_i85 = 0; _i85 < _size81; ++_i85)
02301             {
02302               xfer += (*(this->success))[_i85].read(iprot);
02303             }
02304             iprot->readListEnd();
02305           }
02306           this->__isset.success = true;
02307         } else {
02308           xfer += iprot->skip(ftype);
02309         }
02310         break;
02311       case 1:
02312         if (ftype == ::apache::thrift::protocol::T_STRUCT) {
02313           xfer += this->io.read(iprot);
02314           this->__isset.io = true;
02315         } else {
02316           xfer += iprot->skip(ftype);
02317         }
02318         break;
02319       default:
02320         xfer += iprot->skip(ftype);
02321         break;
02322     }
02323     xfer += iprot->readFieldEnd();
02324   }
02325 
02326   xfer += iprot->readStructEnd();
02327 
02328   return xfer;
02329 }
02330 
02331 uint32_t Hbase_getVerTs_args::read(::apache::thrift::protocol::TProtocol* iprot) {
02332 
02333   uint32_t xfer = 0;
02334   std::string fname;
02335   ::apache::thrift::protocol::TType ftype;
02336   int16_t fid;
02337 
02338   xfer += iprot->readStructBegin(fname);
02339 
02340   using ::apache::thrift::protocol::TProtocolException;
02341 
02342 
02343   while (true)
02344   {
02345     xfer += iprot->readFieldBegin(fname, ftype, fid);
02346     if (ftype == ::apache::thrift::protocol::T_STOP) {
02347       break;
02348     }
02349     switch (fid)
02350     {
02351       case 1:
02352         if (ftype == ::apache::thrift::protocol::T_STRING) {
02353           xfer += iprot->readBinary(this->tableName);
02354           this->__isset.tableName = true;
02355         } else {
02356           xfer += iprot->skip(ftype);
02357         }
02358         break;
02359       case 2:
02360         if (ftype == ::apache::thrift::protocol::T_STRING) {
02361           xfer += iprot->readBinary(this->row);
02362           this->__isset.row = true;
02363         } else {
02364           xfer += iprot->skip(ftype);
02365         }
02366         break;
02367       case 3:
02368         if (ftype == ::apache::thrift::protocol::T_STRING) {
02369           xfer += iprot->readBinary(this->column);
02370           this->__isset.column = true;
02371         } else {
02372           xfer += iprot->skip(ftype);
02373         }
02374         break;
02375       case 4:
02376         if (ftype == ::apache::thrift::protocol::T_I64) {
02377           xfer += iprot->readI64(this->timestamp);
02378           this->__isset.timestamp = true;
02379         } else {
02380           xfer += iprot->skip(ftype);
02381         }
02382         break;
02383       case 5:
02384         if (ftype == ::apache::thrift::protocol::T_I32) {
02385           xfer += iprot->readI32(this->numVersions);
02386           this->__isset.numVersions = true;
02387         } else {
02388           xfer += iprot->skip(ftype);
02389         }
02390         break;
02391       default:
02392         xfer += iprot->skip(ftype);
02393         break;
02394     }
02395     xfer += iprot->readFieldEnd();
02396   }
02397 
02398   xfer += iprot->readStructEnd();
02399 
02400   return xfer;
02401 }
02402 
02403 uint32_t Hbase_getVerTs_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
02404   uint32_t xfer = 0;
02405   xfer += oprot->writeStructBegin("Hbase_getVerTs_args");
02406   xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
02407   xfer += oprot->writeBinary(this->tableName);
02408   xfer += oprot->writeFieldEnd();
02409   xfer += oprot->writeFieldBegin("row", ::apache::thrift::protocol::T_STRING, 2);
02410   xfer += oprot->writeBinary(this->row);
02411   xfer += oprot->writeFieldEnd();
02412   xfer += oprot->writeFieldBegin("column", ::apache::thrift::protocol::T_STRING, 3);
02413   xfer += oprot->writeBinary(this->column);
02414   xfer += oprot->writeFieldEnd();
02415   xfer += oprot->writeFieldBegin("timestamp", ::apache::thrift::protocol::T_I64, 4);
02416   xfer += oprot->writeI64(this->timestamp);
02417   xfer += oprot->writeFieldEnd();
02418   xfer += oprot->writeFieldBegin("numVersions", ::apache::thrift::protocol::T_I32, 5);
02419   xfer += oprot->writeI32(this->numVersions);
02420   xfer += oprot->writeFieldEnd();
02421   xfer += oprot->writeFieldStop();
02422   xfer += oprot->writeStructEnd();
02423   return xfer;
02424 }
02425 
02426 uint32_t Hbase_getVerTs_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
02427   uint32_t xfer = 0;
02428   xfer += oprot->writeStructBegin("Hbase_getVerTs_pargs");
02429   xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
02430   xfer += oprot->writeBinary((*(this->tableName)));
02431   xfer += oprot->writeFieldEnd();
02432   xfer += oprot->writeFieldBegin("row", ::apache::thrift::protocol::T_STRING, 2);
02433   xfer += oprot->writeBinary((*(this->row)));
02434   xfer += oprot->writeFieldEnd();
02435   xfer += oprot->writeFieldBegin("column", ::apache::thrift::protocol::T_STRING, 3);
02436   xfer += oprot->writeBinary((*(this->column)));
02437   xfer += oprot->writeFieldEnd();
02438   xfer += oprot->writeFieldBegin("timestamp", ::apache::thrift::protocol::T_I64, 4);
02439   xfer += oprot->writeI64((*(this->timestamp)));
02440   xfer += oprot->writeFieldEnd();
02441   xfer += oprot->writeFieldBegin("numVersions", ::apache::thrift::protocol::T_I32, 5);
02442   xfer += oprot->writeI32((*(this->numVersions)));
02443   xfer += oprot->writeFieldEnd();
02444   xfer += oprot->writeFieldStop();
02445   xfer += oprot->writeStructEnd();
02446   return xfer;
02447 }
02448 
02449 uint32_t Hbase_getVerTs_result::read(::apache::thrift::protocol::TProtocol* iprot) {
02450 
02451   uint32_t xfer = 0;
02452   std::string fname;
02453   ::apache::thrift::protocol::TType ftype;
02454   int16_t fid;
02455 
02456   xfer += iprot->readStructBegin(fname);
02457 
02458   using ::apache::thrift::protocol::TProtocolException;
02459 
02460 
02461   while (true)
02462   {
02463     xfer += iprot->readFieldBegin(fname, ftype, fid);
02464     if (ftype == ::apache::thrift::protocol::T_STOP) {
02465       break;
02466     }
02467     switch (fid)
02468     {
02469       case 0:
02470         if (ftype == ::apache::thrift::protocol::T_LIST) {
02471           {
02472             this->success.clear();
02473             uint32_t _size86;
02474             ::apache::thrift::protocol::TType _etype89;
02475             iprot->readListBegin(_etype89, _size86);
02476             this->success.resize(_size86);
02477             uint32_t _i90;
02478             for (_i90 = 0; _i90 < _size86; ++_i90)
02479             {
02480               xfer += this->success[_i90].read(iprot);
02481             }
02482             iprot->readListEnd();
02483           }
02484           this->__isset.success = true;
02485         } else {
02486           xfer += iprot->skip(ftype);
02487         }
02488         break;
02489       case 1:
02490         if (ftype == ::apache::thrift::protocol::T_STRUCT) {
02491           xfer += this->io.read(iprot);
02492           this->__isset.io = true;
02493         } else {
02494           xfer += iprot->skip(ftype);
02495         }
02496         break;
02497       default:
02498         xfer += iprot->skip(ftype);
02499         break;
02500     }
02501     xfer += iprot->readFieldEnd();
02502   }
02503 
02504   xfer += iprot->readStructEnd();
02505 
02506   return xfer;
02507 }
02508 
02509 uint32_t Hbase_getVerTs_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
02510 
02511   uint32_t xfer = 0;
02512 
02513   xfer += oprot->writeStructBegin("Hbase_getVerTs_result");
02514 
02515   if (this->__isset.success) {
02516     xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0);
02517     {
02518       xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->success.size()));
02519       std::vector<TCell> ::const_iterator _iter91;
02520       for (_iter91 = this->success.begin(); _iter91 != this->success.end(); ++_iter91)
02521       {
02522         xfer += (*_iter91).write(oprot);
02523       }
02524       xfer += oprot->writeListEnd();
02525     }
02526     xfer += oprot->writeFieldEnd();
02527   } else if (this->__isset.io) {
02528     xfer += oprot->writeFieldBegin("io", ::apache::thrift::protocol::T_STRUCT, 1);
02529     xfer += this->io.write(oprot);
02530     xfer += oprot->writeFieldEnd();
02531   }
02532   xfer += oprot->writeFieldStop();
02533   xfer += oprot->writeStructEnd();
02534   return xfer;
02535 }
02536 
02537 uint32_t Hbase_getVerTs_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
02538 
02539   uint32_t xfer = 0;
02540   std::string fname;
02541   ::apache::thrift::protocol::TType ftype;
02542   int16_t fid;
02543 
02544   xfer += iprot->readStructBegin(fname);
02545 
02546   using ::apache::thrift::protocol::TProtocolException;
02547 
02548 
02549   while (true)
02550   {
02551     xfer += iprot->readFieldBegin(fname, ftype, fid);
02552     if (ftype == ::apache::thrift::protocol::T_STOP) {
02553       break;
02554     }
02555     switch (fid)
02556     {
02557       case 0:
02558         if (ftype == ::apache::thrift::protocol::T_LIST) {
02559           {
02560             (*(this->success)).clear();
02561             uint32_t _size92;
02562             ::apache::thrift::protocol::TType _etype95;
02563             iprot->readListBegin(_etype95, _size92);
02564             (*(this->success)).resize(_size92);
02565             uint32_t _i96;
02566             for (_i96 = 0; _i96 < _size92; ++_i96)
02567             {
02568               xfer += (*(this->success))[_i96].read(iprot);
02569             }
02570             iprot->readListEnd();
02571           }
02572           this->__isset.success = true;
02573         } else {
02574           xfer += iprot->skip(ftype);
02575         }
02576         break;
02577       case 1:
02578         if (ftype == ::apache::thrift::protocol::T_STRUCT) {
02579           xfer += this->io.read(iprot);
02580           this->__isset.io = true;
02581         } else {
02582           xfer += iprot->skip(ftype);
02583         }
02584         break;
02585       default:
02586         xfer += iprot->skip(ftype);
02587         break;
02588     }
02589     xfer += iprot->readFieldEnd();
02590   }
02591 
02592   xfer += iprot->readStructEnd();
02593 
02594   return xfer;
02595 }
02596 
02597 uint32_t Hbase_getRow_args::read(::apache::thrift::protocol::TProtocol* iprot) {
02598 
02599   uint32_t xfer = 0;
02600   std::string fname;
02601   ::apache::thrift::protocol::TType ftype;
02602   int16_t fid;
02603 
02604   xfer += iprot->readStructBegin(fname);
02605 
02606   using ::apache::thrift::protocol::TProtocolException;
02607 
02608 
02609   while (true)
02610   {
02611     xfer += iprot->readFieldBegin(fname, ftype, fid);
02612     if (ftype == ::apache::thrift::protocol::T_STOP) {
02613       break;
02614     }
02615     switch (fid)
02616     {
02617       case 1:
02618         if (ftype == ::apache::thrift::protocol::T_STRING) {
02619           xfer += iprot->readBinary(this->tableName);
02620           this->__isset.tableName = true;
02621         } else {
02622           xfer += iprot->skip(ftype);
02623         }
02624         break;
02625       case 2:
02626         if (ftype == ::apache::thrift::protocol::T_STRING) {
02627           xfer += iprot->readBinary(this->row);
02628           this->__isset.row = true;
02629         } else {
02630           xfer += iprot->skip(ftype);
02631         }
02632         break;
02633       default:
02634         xfer += iprot->skip(ftype);
02635         break;
02636     }
02637     xfer += iprot->readFieldEnd();
02638   }
02639 
02640   xfer += iprot->readStructEnd();
02641 
02642   return xfer;
02643 }
02644 
02645 uint32_t Hbase_getRow_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
02646   uint32_t xfer = 0;
02647   xfer += oprot->writeStructBegin("Hbase_getRow_args");
02648   xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
02649   xfer += oprot->writeBinary(this->tableName);
02650   xfer += oprot->writeFieldEnd();
02651   xfer += oprot->writeFieldBegin("row", ::apache::thrift::protocol::T_STRING, 2);
02652   xfer += oprot->writeBinary(this->row);
02653   xfer += oprot->writeFieldEnd();
02654   xfer += oprot->writeFieldStop();
02655   xfer += oprot->writeStructEnd();
02656   return xfer;
02657 }
02658 
02659 uint32_t Hbase_getRow_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
02660   uint32_t xfer = 0;
02661   xfer += oprot->writeStructBegin("Hbase_getRow_pargs");
02662   xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
02663   xfer += oprot->writeBinary((*(this->tableName)));
02664   xfer += oprot->writeFieldEnd();
02665   xfer += oprot->writeFieldBegin("row", ::apache::thrift::protocol::T_STRING, 2);
02666   xfer += oprot->writeBinary((*(this->row)));
02667   xfer += oprot->writeFieldEnd();
02668   xfer += oprot->writeFieldStop();
02669   xfer += oprot->writeStructEnd();
02670   return xfer;
02671 }
02672 
02673 uint32_t Hbase_getRow_result::read(::apache::thrift::protocol::TProtocol* iprot) {
02674 
02675   uint32_t xfer = 0;
02676   std::string fname;
02677   ::apache::thrift::protocol::TType ftype;
02678   int16_t fid;
02679 
02680   xfer += iprot->readStructBegin(fname);
02681 
02682   using ::apache::thrift::protocol::TProtocolException;
02683 
02684 
02685   while (true)
02686   {
02687     xfer += iprot->readFieldBegin(fname, ftype, fid);
02688     if (ftype == ::apache::thrift::protocol::T_STOP) {
02689       break;
02690     }
02691     switch (fid)
02692     {
02693       case 0:
02694         if (ftype == ::apache::thrift::protocol::T_LIST) {
02695           {
02696             this->success.clear();
02697             uint32_t _size97;
02698             ::apache::thrift::protocol::TType _etype100;
02699             iprot->readListBegin(_etype100, _size97);
02700             this->success.resize(_size97);
02701             uint32_t _i101;
02702             for (_i101 = 0; _i101 < _size97; ++_i101)
02703             {
02704               xfer += this->success[_i101].read(iprot);
02705             }
02706             iprot->readListEnd();
02707           }
02708           this->__isset.success = true;
02709         } else {
02710           xfer += iprot->skip(ftype);
02711         }
02712         break;
02713       case 1:
02714         if (ftype == ::apache::thrift::protocol::T_STRUCT) {
02715           xfer += this->io.read(iprot);
02716           this->__isset.io = true;
02717         } else {
02718           xfer += iprot->skip(ftype);
02719         }
02720         break;
02721       default:
02722         xfer += iprot->skip(ftype);
02723         break;
02724     }
02725     xfer += iprot->readFieldEnd();
02726   }
02727 
02728   xfer += iprot->readStructEnd();
02729 
02730   return xfer;
02731 }
02732 
02733 uint32_t Hbase_getRow_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
02734 
02735   uint32_t xfer = 0;
02736 
02737   xfer += oprot->writeStructBegin("Hbase_getRow_result");
02738 
02739   if (this->__isset.success) {
02740     xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0);
02741     {
02742       xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->success.size()));
02743       std::vector<TRowResult> ::const_iterator _iter102;
02744       for (_iter102 = this->success.begin(); _iter102 != this->success.end(); ++_iter102)
02745       {
02746         xfer += (*_iter102).write(oprot);
02747       }
02748       xfer += oprot->writeListEnd();
02749     }
02750     xfer += oprot->writeFieldEnd();
02751   } else if (this->__isset.io) {
02752     xfer += oprot->writeFieldBegin("io", ::apache::thrift::protocol::T_STRUCT, 1);
02753     xfer += this->io.write(oprot);
02754     xfer += oprot->writeFieldEnd();
02755   }
02756   xfer += oprot->writeFieldStop();
02757   xfer += oprot->writeStructEnd();
02758   return xfer;
02759 }
02760 
02761 uint32_t Hbase_getRow_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
02762 
02763   uint32_t xfer = 0;
02764   std::string fname;
02765   ::apache::thrift::protocol::TType ftype;
02766   int16_t fid;
02767 
02768   xfer += iprot->readStructBegin(fname);
02769 
02770   using ::apache::thrift::protocol::TProtocolException;
02771 
02772 
02773   while (true)
02774   {
02775     xfer += iprot->readFieldBegin(fname, ftype, fid);
02776     if (ftype == ::apache::thrift::protocol::T_STOP) {
02777       break;
02778     }
02779     switch (fid)
02780     {
02781       case 0:
02782         if (ftype == ::apache::thrift::protocol::T_LIST) {
02783           {
02784             (*(this->success)).clear();
02785             uint32_t _size103;
02786             ::apache::thrift::protocol::TType _etype106;
02787             iprot->readListBegin(_etype106, _size103);
02788             (*(this->success)).resize(_size103);
02789             uint32_t _i107;
02790             for (_i107 = 0; _i107 < _size103; ++_i107)
02791             {
02792               xfer += (*(this->success))[_i107].read(iprot);
02793             }
02794             iprot->readListEnd();
02795           }
02796           this->__isset.success = true;
02797         } else {
02798           xfer += iprot->skip(ftype);
02799         }
02800         break;
02801       case 1:
02802         if (ftype == ::apache::thrift::protocol::T_STRUCT) {
02803           xfer += this->io.read(iprot);
02804           this->__isset.io = true;
02805         } else {
02806           xfer += iprot->skip(ftype);
02807         }
02808         break;
02809       default:
02810         xfer += iprot->skip(ftype);
02811         break;
02812     }
02813     xfer += iprot->readFieldEnd();
02814   }
02815 
02816   xfer += iprot->readStructEnd();
02817 
02818   return xfer;
02819 }
02820 
02821 uint32_t Hbase_getRowWithColumns_args::read(::apache::thrift::protocol::TProtocol* iprot) {
02822 
02823   uint32_t xfer = 0;
02824   std::string fname;
02825   ::apache::thrift::protocol::TType ftype;
02826   int16_t fid;
02827 
02828   xfer += iprot->readStructBegin(fname);
02829 
02830   using ::apache::thrift::protocol::TProtocolException;
02831 
02832 
02833   while (true)
02834   {
02835     xfer += iprot->readFieldBegin(fname, ftype, fid);
02836     if (ftype == ::apache::thrift::protocol::T_STOP) {
02837       break;
02838     }
02839     switch (fid)
02840     {
02841       case 1:
02842         if (ftype == ::apache::thrift::protocol::T_STRING) {
02843           xfer += iprot->readBinary(this->tableName);
02844           this->__isset.tableName = true;
02845         } else {
02846           xfer += iprot->skip(ftype);
02847         }
02848         break;
02849       case 2:
02850         if (ftype == ::apache::thrift::protocol::T_STRING) {
02851           xfer += iprot->readBinary(this->row);
02852           this->__isset.row = true;
02853         } else {
02854           xfer += iprot->skip(ftype);
02855         }
02856         break;
02857       case 3:
02858         if (ftype == ::apache::thrift::protocol::T_LIST) {
02859           {
02860             this->columns.clear();
02861             uint32_t _size108;
02862             ::apache::thrift::protocol::TType _etype111;
02863             iprot->readListBegin(_etype111, _size108);
02864             this->columns.resize(_size108);
02865             uint32_t _i112;
02866             for (_i112 = 0; _i112 < _size108; ++_i112)
02867             {
02868               xfer += iprot->readBinary(this->columns[_i112]);
02869             }
02870             iprot->readListEnd();
02871           }
02872           this->__isset.columns = true;
02873         } else {
02874           xfer += iprot->skip(ftype);
02875         }
02876         break;
02877       default:
02878         xfer += iprot->skip(ftype);
02879         break;
02880     }
02881     xfer += iprot->readFieldEnd();
02882   }
02883 
02884   xfer += iprot->readStructEnd();
02885 
02886   return xfer;
02887 }
02888 
02889 uint32_t Hbase_getRowWithColumns_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
02890   uint32_t xfer = 0;
02891   xfer += oprot->writeStructBegin("Hbase_getRowWithColumns_args");
02892   xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
02893   xfer += oprot->writeBinary(this->tableName);
02894   xfer += oprot->writeFieldEnd();
02895   xfer += oprot->writeFieldBegin("row", ::apache::thrift::protocol::T_STRING, 2);
02896   xfer += oprot->writeBinary(this->row);
02897   xfer += oprot->writeFieldEnd();
02898   xfer += oprot->writeFieldBegin("columns", ::apache::thrift::protocol::T_LIST, 3);
02899   {
02900     xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->columns.size()));
02901     std::vector<Text> ::const_iterator _iter113;
02902     for (_iter113 = this->columns.begin(); _iter113 != this->columns.end(); ++_iter113)
02903     {
02904       xfer += oprot->writeBinary((*_iter113));
02905     }
02906     xfer += oprot->writeListEnd();
02907   }
02908   xfer += oprot->writeFieldEnd();
02909   xfer += oprot->writeFieldStop();
02910   xfer += oprot->writeStructEnd();
02911   return xfer;
02912 }
02913 
02914 uint32_t Hbase_getRowWithColumns_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
02915   uint32_t xfer = 0;
02916   xfer += oprot->writeStructBegin("Hbase_getRowWithColumns_pargs");
02917   xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
02918   xfer += oprot->writeBinary((*(this->tableName)));
02919   xfer += oprot->writeFieldEnd();
02920   xfer += oprot->writeFieldBegin("row", ::apache::thrift::protocol::T_STRING, 2);
02921   xfer += oprot->writeBinary((*(this->row)));
02922   xfer += oprot->writeFieldEnd();
02923   xfer += oprot->writeFieldBegin("columns", ::apache::thrift::protocol::T_LIST, 3);
02924   {
02925     xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->columns)).size()));
02926     std::vector<Text> ::const_iterator _iter114;
02927     for (_iter114 = (*(this->columns)).begin(); _iter114 != (*(this->columns)).end(); ++_iter114)
02928     {
02929       xfer += oprot->writeBinary((*_iter114));
02930     }
02931     xfer += oprot->writeListEnd();
02932   }
02933   xfer += oprot->writeFieldEnd();
02934   xfer += oprot->writeFieldStop();
02935   xfer += oprot->writeStructEnd();
02936   return xfer;
02937 }
02938 
02939 uint32_t Hbase_getRowWithColumns_result::read(::apache::thrift::protocol::TProtocol* iprot) {
02940 
02941   uint32_t xfer = 0;
02942   std::string fname;
02943   ::apache::thrift::protocol::TType ftype;
02944   int16_t fid;
02945 
02946   xfer += iprot->readStructBegin(fname);
02947 
02948   using ::apache::thrift::protocol::TProtocolException;
02949 
02950 
02951   while (true)
02952   {
02953     xfer += iprot->readFieldBegin(fname, ftype, fid);
02954     if (ftype == ::apache::thrift::protocol::T_STOP) {
02955       break;
02956     }
02957     switch (fid)
02958     {
02959       case 0:
02960         if (ftype == ::apache::thrift::protocol::T_LIST) {
02961           {
02962             this->success.clear();
02963             uint32_t _size115;
02964             ::apache::thrift::protocol::TType _etype118;
02965             iprot->readListBegin(_etype118, _size115);
02966             this->success.resize(_size115);
02967             uint32_t _i119;
02968             for (_i119 = 0; _i119 < _size115; ++_i119)
02969             {
02970               xfer += this->success[_i119].read(iprot);
02971             }
02972             iprot->readListEnd();
02973           }
02974           this->__isset.success = true;
02975         } else {
02976           xfer += iprot->skip(ftype);
02977         }
02978         break;
02979       case 1:
02980         if (ftype == ::apache::thrift::protocol::T_STRUCT) {
02981           xfer += this->io.read(iprot);
02982           this->__isset.io = true;
02983         } else {
02984           xfer += iprot->skip(ftype);
02985         }
02986         break;
02987       default:
02988         xfer += iprot->skip(ftype);
02989         break;
02990     }
02991     xfer += iprot->readFieldEnd();
02992   }
02993 
02994   xfer += iprot->readStructEnd();
02995 
02996   return xfer;
02997 }
02998 
02999 uint32_t Hbase_getRowWithColumns_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
03000 
03001   uint32_t xfer = 0;
03002 
03003   xfer += oprot->writeStructBegin("Hbase_getRowWithColumns_result");
03004 
03005   if (this->__isset.success) {
03006     xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0);
03007     {
03008       xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->success.size()));
03009       std::vector<TRowResult> ::const_iterator _iter120;
03010       for (_iter120 = this->success.begin(); _iter120 != this->success.end(); ++_iter120)
03011       {
03012         xfer += (*_iter120).write(oprot);
03013       }
03014       xfer += oprot->writeListEnd();
03015     }
03016     xfer += oprot->writeFieldEnd();
03017   } else if (this->__isset.io) {
03018     xfer += oprot->writeFieldBegin("io", ::apache::thrift::protocol::T_STRUCT, 1);
03019     xfer += this->io.write(oprot);
03020     xfer += oprot->writeFieldEnd();
03021   }
03022   xfer += oprot->writeFieldStop();
03023   xfer += oprot->writeStructEnd();
03024   return xfer;
03025 }
03026 
03027 uint32_t Hbase_getRowWithColumns_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
03028 
03029   uint32_t xfer = 0;
03030   std::string fname;
03031   ::apache::thrift::protocol::TType ftype;
03032   int16_t fid;
03033 
03034   xfer += iprot->readStructBegin(fname);
03035 
03036   using ::apache::thrift::protocol::TProtocolException;
03037 
03038 
03039   while (true)
03040   {
03041     xfer += iprot->readFieldBegin(fname, ftype, fid);
03042     if (ftype == ::apache::thrift::protocol::T_STOP) {
03043       break;
03044     }
03045     switch (fid)
03046     {
03047       case 0:
03048         if (ftype == ::apache::thrift::protocol::T_LIST) {
03049           {
03050             (*(this->success)).clear();
03051             uint32_t _size121;
03052             ::apache::thrift::protocol::TType _etype124;
03053             iprot->readListBegin(_etype124, _size121);
03054             (*(this->success)).resize(_size121);
03055             uint32_t _i125;
03056             for (_i125 = 0; _i125 < _size121; ++_i125)
03057             {
03058               xfer += (*(this->success))[_i125].read(iprot);
03059             }
03060             iprot->readListEnd();
03061           }
03062           this->__isset.success = true;
03063         } else {
03064           xfer += iprot->skip(ftype);
03065         }
03066         break;
03067       case 1:
03068         if (ftype == ::apache::thrift::protocol::T_STRUCT) {
03069           xfer += this->io.read(iprot);
03070           this->__isset.io = true;
03071         } else {
03072           xfer += iprot->skip(ftype);
03073         }
03074         break;
03075       default:
03076         xfer += iprot->skip(ftype);
03077         break;
03078     }
03079     xfer += iprot->readFieldEnd();
03080   }
03081 
03082   xfer += iprot->readStructEnd();
03083 
03084   return xfer;
03085 }
03086 
03087 uint32_t Hbase_getRowTs_args::read(::apache::thrift::protocol::TProtocol* iprot) {
03088 
03089   uint32_t xfer = 0;
03090   std::string fname;
03091   ::apache::thrift::protocol::TType ftype;
03092   int16_t fid;
03093 
03094   xfer += iprot->readStructBegin(fname);
03095 
03096   using ::apache::thrift::protocol::TProtocolException;
03097 
03098 
03099   while (true)
03100   {
03101     xfer += iprot->readFieldBegin(fname, ftype, fid);
03102     if (ftype == ::apache::thrift::protocol::T_STOP) {
03103       break;
03104     }
03105     switch (fid)
03106     {
03107       case 1:
03108         if (ftype == ::apache::thrift::protocol::T_STRING) {
03109           xfer += iprot->readBinary(this->tableName);
03110           this->__isset.tableName = true;
03111         } else {
03112           xfer += iprot->skip(ftype);
03113         }
03114         break;
03115       case 2:
03116         if (ftype == ::apache::thrift::protocol::T_STRING) {
03117           xfer += iprot->readBinary(this->row);
03118           this->__isset.row = true;
03119         } else {
03120           xfer += iprot->skip(ftype);
03121         }
03122         break;
03123       case 3:
03124         if (ftype == ::apache::thrift::protocol::T_I64) {
03125           xfer += iprot->readI64(this->timestamp);
03126           this->__isset.timestamp = true;
03127         } else {
03128           xfer += iprot->skip(ftype);
03129         }
03130         break;
03131       default:
03132         xfer += iprot->skip(ftype);
03133         break;
03134     }
03135     xfer += iprot->readFieldEnd();
03136   }
03137 
03138   xfer += iprot->readStructEnd();
03139 
03140   return xfer;
03141 }
03142 
03143 uint32_t Hbase_getRowTs_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
03144   uint32_t xfer = 0;
03145   xfer += oprot->writeStructBegin("Hbase_getRowTs_args");
03146   xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
03147   xfer += oprot->writeBinary(this->tableName);
03148   xfer += oprot->writeFieldEnd();
03149   xfer += oprot->writeFieldBegin("row", ::apache::thrift::protocol::T_STRING, 2);
03150   xfer += oprot->writeBinary(this->row);
03151   xfer += oprot->writeFieldEnd();
03152   xfer += oprot->writeFieldBegin("timestamp", ::apache::thrift::protocol::T_I64, 3);
03153   xfer += oprot->writeI64(this->timestamp);
03154   xfer += oprot->writeFieldEnd();
03155   xfer += oprot->writeFieldStop();
03156   xfer += oprot->writeStructEnd();
03157   return xfer;
03158 }
03159 
03160 uint32_t Hbase_getRowTs_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
03161   uint32_t xfer = 0;
03162   xfer += oprot->writeStructBegin("Hbase_getRowTs_pargs");
03163   xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
03164   xfer += oprot->writeBinary((*(this->tableName)));
03165   xfer += oprot->writeFieldEnd();
03166   xfer += oprot->writeFieldBegin("row", ::apache::thrift::protocol::T_STRING, 2);
03167   xfer += oprot->writeBinary((*(this->row)));
03168   xfer += oprot->writeFieldEnd();
03169   xfer += oprot->writeFieldBegin("timestamp", ::apache::thrift::protocol::T_I64, 3);
03170   xfer += oprot->writeI64((*(this->timestamp)));
03171   xfer += oprot->writeFieldEnd();
03172   xfer += oprot->writeFieldStop();
03173   xfer += oprot->writeStructEnd();
03174   return xfer;
03175 }
03176 
03177 uint32_t Hbase_getRowTs_result::read(::apache::thrift::protocol::TProtocol* iprot) {
03178 
03179   uint32_t xfer = 0;
03180   std::string fname;
03181   ::apache::thrift::protocol::TType ftype;
03182   int16_t fid;
03183 
03184   xfer += iprot->readStructBegin(fname);
03185 
03186   using ::apache::thrift::protocol::TProtocolException;
03187 
03188 
03189   while (true)
03190   {
03191     xfer += iprot->readFieldBegin(fname, ftype, fid);
03192     if (ftype == ::apache::thrift::protocol::T_STOP) {
03193       break;
03194     }
03195     switch (fid)
03196     {
03197       case 0:
03198         if (ftype == ::apache::thrift::protocol::T_LIST) {
03199           {
03200             this->success.clear();
03201             uint32_t _size126;
03202             ::apache::thrift::protocol::TType _etype129;
03203             iprot->readListBegin(_etype129, _size126);
03204             this->success.resize(_size126);
03205             uint32_t _i130;
03206             for (_i130 = 0; _i130 < _size126; ++_i130)
03207             {
03208               xfer += this->success[_i130].read(iprot);
03209             }
03210             iprot->readListEnd();
03211           }
03212           this->__isset.success = true;
03213         } else {
03214           xfer += iprot->skip(ftype);
03215         }
03216         break;
03217       case 1:
03218         if (ftype == ::apache::thrift::protocol::T_STRUCT) {
03219           xfer += this->io.read(iprot);
03220           this->__isset.io = true;
03221         } else {
03222           xfer += iprot->skip(ftype);
03223         }
03224         break;
03225       default:
03226         xfer += iprot->skip(ftype);
03227         break;
03228     }
03229     xfer += iprot->readFieldEnd();
03230   }
03231 
03232   xfer += iprot->readStructEnd();
03233 
03234   return xfer;
03235 }
03236 
03237 uint32_t Hbase_getRowTs_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
03238 
03239   uint32_t xfer = 0;
03240 
03241   xfer += oprot->writeStructBegin("Hbase_getRowTs_result");
03242 
03243   if (this->__isset.success) {
03244     xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0);
03245     {
03246       xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->success.size()));
03247       std::vector<TRowResult> ::const_iterator _iter131;
03248       for (_iter131 = this->success.begin(); _iter131 != this->success.end(); ++_iter131)
03249       {
03250         xfer += (*_iter131).write(oprot);
03251       }
03252       xfer += oprot->writeListEnd();
03253     }
03254     xfer += oprot->writeFieldEnd();
03255   } else if (this->__isset.io) {
03256     xfer += oprot->writeFieldBegin("io", ::apache::thrift::protocol::T_STRUCT, 1);
03257     xfer += this->io.write(oprot);
03258     xfer += oprot->writeFieldEnd();
03259   }
03260   xfer += oprot->writeFieldStop();
03261   xfer += oprot->writeStructEnd();
03262   return xfer;
03263 }
03264 
03265 uint32_t Hbase_getRowTs_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
03266 
03267   uint32_t xfer = 0;
03268   std::string fname;
03269   ::apache::thrift::protocol::TType ftype;
03270   int16_t fid;
03271 
03272   xfer += iprot->readStructBegin(fname);
03273 
03274   using ::apache::thrift::protocol::TProtocolException;
03275 
03276 
03277   while (true)
03278   {
03279     xfer += iprot->readFieldBegin(fname, ftype, fid);
03280     if (ftype == ::apache::thrift::protocol::T_STOP) {
03281       break;
03282     }
03283     switch (fid)
03284     {
03285       case 0:
03286         if (ftype == ::apache::thrift::protocol::T_LIST) {
03287           {
03288             (*(this->success)).clear();
03289             uint32_t _size132;
03290             ::apache::thrift::protocol::TType _etype135;
03291             iprot->readListBegin(_etype135, _size132);
03292             (*(this->success)).resize(_size132);
03293             uint32_t _i136;
03294             for (_i136 = 0; _i136 < _size132; ++_i136)
03295             {
03296               xfer += (*(this->success))[_i136].read(iprot);
03297             }
03298             iprot->readListEnd();
03299           }
03300           this->__isset.success = true;
03301         } else {
03302           xfer += iprot->skip(ftype);
03303         }
03304         break;
03305       case 1:
03306         if (ftype == ::apache::thrift::protocol::T_STRUCT) {
03307           xfer += this->io.read(iprot);
03308           this->__isset.io = true;
03309         } else {
03310           xfer += iprot->skip(ftype);
03311         }
03312         break;
03313       default:
03314         xfer += iprot->skip(ftype);
03315         break;
03316     }
03317     xfer += iprot->readFieldEnd();
03318   }
03319 
03320   xfer += iprot->readStructEnd();
03321 
03322   return xfer;
03323 }
03324 
03325 uint32_t Hbase_getRowWithColumnsTs_args::read(::apache::thrift::protocol::TProtocol* iprot) {
03326 
03327   uint32_t xfer = 0;
03328   std::string fname;
03329   ::apache::thrift::protocol::TType ftype;
03330   int16_t fid;
03331 
03332   xfer += iprot->readStructBegin(fname);
03333 
03334   using ::apache::thrift::protocol::TProtocolException;
03335 
03336 
03337   while (true)
03338   {
03339     xfer += iprot->readFieldBegin(fname, ftype, fid);
03340     if (ftype == ::apache::thrift::protocol::T_STOP) {
03341       break;
03342     }
03343     switch (fid)
03344     {
03345       case 1:
03346         if (ftype == ::apache::thrift::protocol::T_STRING) {
03347           xfer += iprot->readBinary(this->tableName);
03348           this->__isset.tableName = true;
03349         } else {
03350           xfer += iprot->skip(ftype);
03351         }
03352         break;
03353       case 2:
03354         if (ftype == ::apache::thrift::protocol::T_STRING) {
03355           xfer += iprot->readBinary(this->row);
03356           this->__isset.row = true;
03357         } else {
03358           xfer += iprot->skip(ftype);
03359         }
03360         break;
03361       case 3:
03362         if (ftype == ::apache::thrift::protocol::T_LIST) {
03363           {
03364             this->columns.clear();
03365             uint32_t _size137;
03366             ::apache::thrift::protocol::TType _etype140;
03367             iprot->readListBegin(_etype140, _size137);
03368             this->columns.resize(_size137);
03369             uint32_t _i141;
03370             for (_i141 = 0; _i141 < _size137; ++_i141)
03371             {
03372               xfer += iprot->readBinary(this->columns[_i141]);
03373             }
03374             iprot->readListEnd();
03375           }
03376           this->__isset.columns = true;
03377         } else {
03378           xfer += iprot->skip(ftype);
03379         }
03380         break;
03381       case 4:
03382         if (ftype == ::apache::thrift::protocol::T_I64) {
03383           xfer += iprot->readI64(this->timestamp);
03384           this->__isset.timestamp = true;
03385         } else {
03386           xfer += iprot->skip(ftype);
03387         }
03388         break;
03389       default:
03390         xfer += iprot->skip(ftype);
03391         break;
03392     }
03393     xfer += iprot->readFieldEnd();
03394   }
03395 
03396   xfer += iprot->readStructEnd();
03397 
03398   return xfer;
03399 }
03400 
03401 uint32_t Hbase_getRowWithColumnsTs_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
03402   uint32_t xfer = 0;
03403   xfer += oprot->writeStructBegin("Hbase_getRowWithColumnsTs_args");
03404   xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
03405   xfer += oprot->writeBinary(this->tableName);
03406   xfer += oprot->writeFieldEnd();
03407   xfer += oprot->writeFieldBegin("row", ::apache::thrift::protocol::T_STRING, 2);
03408   xfer += oprot->writeBinary(this->row);
03409   xfer += oprot->writeFieldEnd();
03410   xfer += oprot->writeFieldBegin("columns", ::apache::thrift::protocol::T_LIST, 3);
03411   {
03412     xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->columns.size()));
03413     std::vector<Text> ::const_iterator _iter142;
03414     for (_iter142 = this->columns.begin(); _iter142 != this->columns.end(); ++_iter142)
03415     {
03416       xfer += oprot->writeBinary((*_iter142));
03417     }
03418     xfer += oprot->writeListEnd();
03419   }
03420   xfer += oprot->writeFieldEnd();
03421   xfer += oprot->writeFieldBegin("timestamp", ::apache::thrift::protocol::T_I64, 4);
03422   xfer += oprot->writeI64(this->timestamp);
03423   xfer += oprot->writeFieldEnd();
03424   xfer += oprot->writeFieldStop();
03425   xfer += oprot->writeStructEnd();
03426   return xfer;
03427 }
03428 
03429 uint32_t Hbase_getRowWithColumnsTs_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
03430   uint32_t xfer = 0;
03431   xfer += oprot->writeStructBegin("Hbase_getRowWithColumnsTs_pargs");
03432   xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
03433   xfer += oprot->writeBinary((*(this->tableName)));
03434   xfer += oprot->writeFieldEnd();
03435   xfer += oprot->writeFieldBegin("row", ::apache::thrift::protocol::T_STRING, 2);
03436   xfer += oprot->writeBinary((*(this->row)));
03437   xfer += oprot->writeFieldEnd();
03438   xfer += oprot->writeFieldBegin("columns", ::apache::thrift::protocol::T_LIST, 3);
03439   {
03440     xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->columns)).size()));
03441     std::vector<Text> ::const_iterator _iter143;
03442     for (_iter143 = (*(this->columns)).begin(); _iter143 != (*(this->columns)).end(); ++_iter143)
03443     {
03444       xfer += oprot->writeBinary((*_iter143));
03445     }
03446     xfer += oprot->writeListEnd();
03447   }
03448   xfer += oprot->writeFieldEnd();
03449   xfer += oprot->writeFieldBegin("timestamp", ::apache::thrift::protocol::T_I64, 4);
03450   xfer += oprot->writeI64((*(this->timestamp)));
03451   xfer += oprot->writeFieldEnd();
03452   xfer += oprot->writeFieldStop();
03453   xfer += oprot->writeStructEnd();
03454   return xfer;
03455 }
03456 
03457 uint32_t Hbase_getRowWithColumnsTs_result::read(::apache::thrift::protocol::TProtocol* iprot) {
03458 
03459   uint32_t xfer = 0;
03460   std::string fname;
03461   ::apache::thrift::protocol::TType ftype;
03462   int16_t fid;
03463 
03464   xfer += iprot->readStructBegin(fname);
03465 
03466   using ::apache::thrift::protocol::TProtocolException;
03467 
03468 
03469   while (true)
03470   {
03471     xfer += iprot->readFieldBegin(fname, ftype, fid);
03472     if (ftype == ::apache::thrift::protocol::T_STOP) {
03473       break;
03474     }
03475     switch (fid)
03476     {
03477       case 0:
03478         if (ftype == ::apache::thrift::protocol::T_LIST) {
03479           {
03480             this->success.clear();
03481             uint32_t _size144;
03482             ::apache::thrift::protocol::TType _etype147;
03483             iprot->readListBegin(_etype147, _size144);
03484             this->success.resize(_size144);
03485             uint32_t _i148;
03486             for (_i148 = 0; _i148 < _size144; ++_i148)
03487             {
03488               xfer += this->success[_i148].read(iprot);
03489             }
03490             iprot->readListEnd();
03491           }
03492           this->__isset.success = true;
03493         } else {
03494           xfer += iprot->skip(ftype);
03495         }
03496         break;
03497       case 1:
03498         if (ftype == ::apache::thrift::protocol::T_STRUCT) {
03499           xfer += this->io.read(iprot);
03500           this->__isset.io = true;
03501         } else {
03502           xfer += iprot->skip(ftype);
03503         }
03504         break;
03505       default:
03506         xfer += iprot->skip(ftype);
03507         break;
03508     }
03509     xfer += iprot->readFieldEnd();
03510   }
03511 
03512   xfer += iprot->readStructEnd();
03513 
03514   return xfer;
03515 }
03516 
03517 uint32_t Hbase_getRowWithColumnsTs_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
03518 
03519   uint32_t xfer = 0;
03520 
03521   xfer += oprot->writeStructBegin("Hbase_getRowWithColumnsTs_result");
03522 
03523   if (this->__isset.success) {
03524     xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0);
03525     {
03526       xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->success.size()));
03527       std::vector<TRowResult> ::const_iterator _iter149;
03528       for (_iter149 = this->success.begin(); _iter149 != this->success.end(); ++_iter149)
03529       {
03530         xfer += (*_iter149).write(oprot);
03531       }
03532       xfer += oprot->writeListEnd();
03533     }
03534     xfer += oprot->writeFieldEnd();
03535   } else if (this->__isset.io) {
03536     xfer += oprot->writeFieldBegin("io", ::apache::thrift::protocol::T_STRUCT, 1);
03537     xfer += this->io.write(oprot);
03538     xfer += oprot->writeFieldEnd();
03539   }
03540   xfer += oprot->writeFieldStop();
03541   xfer += oprot->writeStructEnd();
03542   return xfer;
03543 }
03544 
03545 uint32_t Hbase_getRowWithColumnsTs_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
03546 
03547   uint32_t xfer = 0;
03548   std::string fname;
03549   ::apache::thrift::protocol::TType ftype;
03550   int16_t fid;
03551 
03552   xfer += iprot->readStructBegin(fname);
03553 
03554   using ::apache::thrift::protocol::TProtocolException;
03555 
03556 
03557   while (true)
03558   {
03559     xfer += iprot->readFieldBegin(fname, ftype, fid);
03560     if (ftype == ::apache::thrift::protocol::T_STOP) {
03561       break;
03562     }
03563     switch (fid)
03564     {
03565       case 0:
03566         if (ftype == ::apache::thrift::protocol::T_LIST) {
03567           {
03568             (*(this->success)).clear();
03569             uint32_t _size150;
03570             ::apache::thrift::protocol::TType _etype153;
03571             iprot->readListBegin(_etype153, _size150);
03572             (*(this->success)).resize(_size150);
03573             uint32_t _i154;
03574             for (_i154 = 0; _i154 < _size150; ++_i154)
03575             {
03576               xfer += (*(this->success))[_i154].read(iprot);
03577             }
03578             iprot->readListEnd();
03579           }
03580           this->__isset.success = true;
03581         } else {
03582           xfer += iprot->skip(ftype);
03583         }
03584         break;
03585       case 1:
03586         if (ftype == ::apache::thrift::protocol::T_STRUCT) {
03587           xfer += this->io.read(iprot);
03588           this->__isset.io = true;
03589         } else {
03590           xfer += iprot->skip(ftype);
03591         }
03592         break;
03593       default:
03594         xfer += iprot->skip(ftype);
03595         break;
03596     }
03597     xfer += iprot->readFieldEnd();
03598   }
03599 
03600   xfer += iprot->readStructEnd();
03601 
03602   return xfer;
03603 }
03604 
03605 uint32_t Hbase_getRows_args::read(::apache::thrift::protocol::TProtocol* iprot) {
03606 
03607   uint32_t xfer = 0;
03608   std::string fname;
03609   ::apache::thrift::protocol::TType ftype;
03610   int16_t fid;
03611 
03612   xfer += iprot->readStructBegin(fname);
03613 
03614   using ::apache::thrift::protocol::TProtocolException;
03615 
03616 
03617   while (true)
03618   {
03619     xfer += iprot->readFieldBegin(fname, ftype, fid);
03620     if (ftype == ::apache::thrift::protocol::T_STOP) {
03621       break;
03622     }
03623     switch (fid)
03624     {
03625       case 1:
03626         if (ftype == ::apache::thrift::protocol::T_STRING) {
03627           xfer += iprot->readBinary(this->tableName);
03628           this->__isset.tableName = true;
03629         } else {
03630           xfer += iprot->skip(ftype);
03631         }
03632         break;
03633       case 2:
03634         if (ftype == ::apache::thrift::protocol::T_LIST) {
03635           {
03636             this->rows.clear();
03637             uint32_t _size155;
03638             ::apache::thrift::protocol::TType _etype158;
03639             iprot->readListBegin(_etype158, _size155);
03640             this->rows.resize(_size155);
03641             uint32_t _i159;
03642             for (_i159 = 0; _i159 < _size155; ++_i159)
03643             {
03644               xfer += iprot->readBinary(this->rows[_i159]);
03645             }
03646             iprot->readListEnd();
03647           }
03648           this->__isset.rows = true;
03649         } else {
03650           xfer += iprot->skip(ftype);
03651         }
03652         break;
03653       default:
03654         xfer += iprot->skip(ftype);
03655         break;
03656     }
03657     xfer += iprot->readFieldEnd();
03658   }
03659 
03660   xfer += iprot->readStructEnd();
03661 
03662   return xfer;
03663 }
03664 
03665 uint32_t Hbase_getRows_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
03666   uint32_t xfer = 0;
03667   xfer += oprot->writeStructBegin("Hbase_getRows_args");
03668   xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
03669   xfer += oprot->writeBinary(this->tableName);
03670   xfer += oprot->writeFieldEnd();
03671   xfer += oprot->writeFieldBegin("rows", ::apache::thrift::protocol::T_LIST, 2);
03672   {
03673     xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->rows.size()));
03674     std::vector<Text> ::const_iterator _iter160;
03675     for (_iter160 = this->rows.begin(); _iter160 != this->rows.end(); ++_iter160)
03676     {
03677       xfer += oprot->writeBinary((*_iter160));
03678     }
03679     xfer += oprot->writeListEnd();
03680   }
03681   xfer += oprot->writeFieldEnd();
03682   xfer += oprot->writeFieldStop();
03683   xfer += oprot->writeStructEnd();
03684   return xfer;
03685 }
03686 
03687 uint32_t Hbase_getRows_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
03688   uint32_t xfer = 0;
03689   xfer += oprot->writeStructBegin("Hbase_getRows_pargs");
03690   xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
03691   xfer += oprot->writeBinary((*(this->tableName)));
03692   xfer += oprot->writeFieldEnd();
03693   xfer += oprot->writeFieldBegin("rows", ::apache::thrift::protocol::T_LIST, 2);
03694   {
03695     xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->rows)).size()));
03696     std::vector<Text> ::const_iterator _iter161;
03697     for (_iter161 = (*(this->rows)).begin(); _iter161 != (*(this->rows)).end(); ++_iter161)
03698     {
03699       xfer += oprot->writeBinary((*_iter161));
03700     }
03701     xfer += oprot->writeListEnd();
03702   }
03703   xfer += oprot->writeFieldEnd();
03704   xfer += oprot->writeFieldStop();
03705   xfer += oprot->writeStructEnd();
03706   return xfer;
03707 }
03708 
03709 uint32_t Hbase_getRows_result::read(::apache::thrift::protocol::TProtocol* iprot) {
03710 
03711   uint32_t xfer = 0;
03712   std::string fname;
03713   ::apache::thrift::protocol::TType ftype;
03714   int16_t fid;
03715 
03716   xfer += iprot->readStructBegin(fname);
03717 
03718   using ::apache::thrift::protocol::TProtocolException;
03719 
03720 
03721   while (true)
03722   {
03723     xfer += iprot->readFieldBegin(fname, ftype, fid);
03724     if (ftype == ::apache::thrift::protocol::T_STOP) {
03725       break;
03726     }
03727     switch (fid)
03728     {
03729       case 0:
03730         if (ftype == ::apache::thrift::protocol::T_LIST) {
03731           {
03732             this->success.clear();
03733             uint32_t _size162;
03734             ::apache::thrift::protocol::TType _etype165;
03735             iprot->readListBegin(_etype165, _size162);
03736             this->success.resize(_size162);
03737             uint32_t _i166;
03738             for (_i166 = 0; _i166 < _size162; ++_i166)
03739             {
03740               xfer += this->success[_i166].read(iprot);
03741             }
03742             iprot->readListEnd();
03743           }
03744           this->__isset.success = true;
03745         } else {
03746           xfer += iprot->skip(ftype);
03747         }
03748         break;
03749       case 1:
03750         if (ftype == ::apache::thrift::protocol::T_STRUCT) {
03751           xfer += this->io.read(iprot);
03752           this->__isset.io = true;
03753         } else {
03754           xfer += iprot->skip(ftype);
03755         }
03756         break;
03757       default:
03758         xfer += iprot->skip(ftype);
03759         break;
03760     }
03761     xfer += iprot->readFieldEnd();
03762   }
03763 
03764   xfer += iprot->readStructEnd();
03765 
03766   return xfer;
03767 }
03768 
03769 uint32_t Hbase_getRows_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
03770 
03771   uint32_t xfer = 0;
03772 
03773   xfer += oprot->writeStructBegin("Hbase_getRows_result");
03774 
03775   if (this->__isset.success) {
03776     xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0);
03777     {
03778       xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->success.size()));
03779       std::vector<TRowResult> ::const_iterator _iter167;
03780       for (_iter167 = this->success.begin(); _iter167 != this->success.end(); ++_iter167)
03781       {
03782         xfer += (*_iter167).write(oprot);
03783       }
03784       xfer += oprot->writeListEnd();
03785     }
03786     xfer += oprot->writeFieldEnd();
03787   } else if (this->__isset.io) {
03788     xfer += oprot->writeFieldBegin("io", ::apache::thrift::protocol::T_STRUCT, 1);
03789     xfer += this->io.write(oprot);
03790     xfer += oprot->writeFieldEnd();
03791   }
03792   xfer += oprot->writeFieldStop();
03793   xfer += oprot->writeStructEnd();
03794   return xfer;
03795 }
03796 
03797 uint32_t Hbase_getRows_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
03798 
03799   uint32_t xfer = 0;
03800   std::string fname;
03801   ::apache::thrift::protocol::TType ftype;
03802   int16_t fid;
03803 
03804   xfer += iprot->readStructBegin(fname);
03805 
03806   using ::apache::thrift::protocol::TProtocolException;
03807 
03808 
03809   while (true)
03810   {
03811     xfer += iprot->readFieldBegin(fname, ftype, fid);
03812     if (ftype == ::apache::thrift::protocol::T_STOP) {
03813       break;
03814     }
03815     switch (fid)
03816     {
03817       case 0:
03818         if (ftype == ::apache::thrift::protocol::T_LIST) {
03819           {
03820             (*(this->success)).clear();
03821             uint32_t _size168;
03822             ::apache::thrift::protocol::TType _etype171;
03823             iprot->readListBegin(_etype171, _size168);
03824             (*(this->success)).resize(_size168);
03825             uint32_t _i172;
03826             for (_i172 = 0; _i172 < _size168; ++_i172)
03827             {
03828               xfer += (*(this->success))[_i172].read(iprot);
03829             }
03830             iprot->readListEnd();
03831           }
03832           this->__isset.success = true;
03833         } else {
03834           xfer += iprot->skip(ftype);
03835         }
03836         break;
03837       case 1:
03838         if (ftype == ::apache::thrift::protocol::T_STRUCT) {
03839           xfer += this->io.read(iprot);
03840           this->__isset.io = true;
03841         } else {
03842           xfer += iprot->skip(ftype);
03843         }
03844         break;
03845       default:
03846         xfer += iprot->skip(ftype);
03847         break;
03848     }
03849     xfer += iprot->readFieldEnd();
03850   }
03851 
03852   xfer += iprot->readStructEnd();
03853 
03854   return xfer;
03855 }
03856 
03857 uint32_t Hbase_getRowsWithColumns_args::read(::apache::thrift::protocol::TProtocol* iprot) {
03858 
03859   uint32_t xfer = 0;
03860   std::string fname;
03861   ::apache::thrift::protocol::TType ftype;
03862   int16_t fid;
03863 
03864   xfer += iprot->readStructBegin(fname);
03865 
03866   using ::apache::thrift::protocol::TProtocolException;
03867 
03868 
03869   while (true)
03870   {
03871     xfer += iprot->readFieldBegin(fname, ftype, fid);
03872     if (ftype == ::apache::thrift::protocol::T_STOP) {
03873       break;
03874     }
03875     switch (fid)
03876     {
03877       case 1:
03878         if (ftype == ::apache::thrift::protocol::T_STRING) {
03879           xfer += iprot->readBinary(this->tableName);
03880           this->__isset.tableName = true;
03881         } else {
03882           xfer += iprot->skip(ftype);
03883         }
03884         break;
03885       case 2:
03886         if (ftype == ::apache::thrift::protocol::T_LIST) {
03887           {
03888             this->rows.clear();
03889             uint32_t _size173;
03890             ::apache::thrift::protocol::TType _etype176;
03891             iprot->readListBegin(_etype176, _size173);
03892             this->rows.resize(_size173);
03893             uint32_t _i177;
03894             for (_i177 = 0; _i177 < _size173; ++_i177)
03895             {
03896               xfer += iprot->readBinary(this->rows[_i177]);
03897             }
03898             iprot->readListEnd();
03899           }
03900           this->__isset.rows = true;
03901         } else {
03902           xfer += iprot->skip(ftype);
03903         }
03904         break;
03905       case 3:
03906         if (ftype == ::apache::thrift::protocol::T_LIST) {
03907           {
03908             this->columns.clear();
03909             uint32_t _size178;
03910             ::apache::thrift::protocol::TType _etype181;
03911             iprot->readListBegin(_etype181, _size178);
03912             this->columns.resize(_size178);
03913             uint32_t _i182;
03914             for (_i182 = 0; _i182 < _size178; ++_i182)
03915             {
03916               xfer += iprot->readBinary(this->columns[_i182]);
03917             }
03918             iprot->readListEnd();
03919           }
03920           this->__isset.columns = true;
03921         } else {
03922           xfer += iprot->skip(ftype);
03923         }
03924         break;
03925       default:
03926         xfer += iprot->skip(ftype);
03927         break;
03928     }
03929     xfer += iprot->readFieldEnd();
03930   }
03931 
03932   xfer += iprot->readStructEnd();
03933 
03934   return xfer;
03935 }
03936 
03937 uint32_t Hbase_getRowsWithColumns_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
03938   uint32_t xfer = 0;
03939   xfer += oprot->writeStructBegin("Hbase_getRowsWithColumns_args");
03940   xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
03941   xfer += oprot->writeBinary(this->tableName);
03942   xfer += oprot->writeFieldEnd();
03943   xfer += oprot->writeFieldBegin("rows", ::apache::thrift::protocol::T_LIST, 2);
03944   {
03945     xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->rows.size()));
03946     std::vector<Text> ::const_iterator _iter183;
03947     for (_iter183 = this->rows.begin(); _iter183 != this->rows.end(); ++_iter183)
03948     {
03949       xfer += oprot->writeBinary((*_iter183));
03950     }
03951     xfer += oprot->writeListEnd();
03952   }
03953   xfer += oprot->writeFieldEnd();
03954   xfer += oprot->writeFieldBegin("columns", ::apache::thrift::protocol::T_LIST, 3);
03955   {
03956     xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->columns.size()));
03957     std::vector<Text> ::const_iterator _iter184;
03958     for (_iter184 = this->columns.begin(); _iter184 != this->columns.end(); ++_iter184)
03959     {
03960       xfer += oprot->writeBinary((*_iter184));
03961     }
03962     xfer += oprot->writeListEnd();
03963   }
03964   xfer += oprot->writeFieldEnd();
03965   xfer += oprot->writeFieldStop();
03966   xfer += oprot->writeStructEnd();
03967   return xfer;
03968 }
03969 
03970 uint32_t Hbase_getRowsWithColumns_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
03971   uint32_t xfer = 0;
03972   xfer += oprot->writeStructBegin("Hbase_getRowsWithColumns_pargs");
03973   xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
03974   xfer += oprot->writeBinary((*(this->tableName)));
03975   xfer += oprot->writeFieldEnd();
03976   xfer += oprot->writeFieldBegin("rows", ::apache::thrift::protocol::T_LIST, 2);
03977   {
03978     xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->rows)).size()));
03979     std::vector<Text> ::const_iterator _iter185;
03980     for (_iter185 = (*(this->rows)).begin(); _iter185 != (*(this->rows)).end(); ++_iter185)
03981     {
03982       xfer += oprot->writeBinary((*_iter185));
03983     }
03984     xfer += oprot->writeListEnd();
03985   }
03986   xfer += oprot->writeFieldEnd();
03987   xfer += oprot->writeFieldBegin("columns", ::apache::thrift::protocol::T_LIST, 3);
03988   {
03989     xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->columns)).size()));
03990     std::vector<Text> ::const_iterator _iter186;
03991     for (_iter186 = (*(this->columns)).begin(); _iter186 != (*(this->columns)).end(); ++_iter186)
03992     {
03993       xfer += oprot->writeBinary((*_iter186));
03994     }
03995     xfer += oprot->writeListEnd();
03996   }
03997   xfer += oprot->writeFieldEnd();
03998   xfer += oprot->writeFieldStop();
03999   xfer += oprot->writeStructEnd();
04000   return xfer;
04001 }
04002 
04003 uint32_t Hbase_getRowsWithColumns_result::read(::apache::thrift::protocol::TProtocol* iprot) {
04004 
04005   uint32_t xfer = 0;
04006   std::string fname;
04007   ::apache::thrift::protocol::TType ftype;
04008   int16_t fid;
04009 
04010   xfer += iprot->readStructBegin(fname);
04011 
04012   using ::apache::thrift::protocol::TProtocolException;
04013 
04014 
04015   while (true)
04016   {
04017     xfer += iprot->readFieldBegin(fname, ftype, fid);
04018     if (ftype == ::apache::thrift::protocol::T_STOP) {
04019       break;
04020     }
04021     switch (fid)
04022     {
04023       case 0:
04024         if (ftype == ::apache::thrift::protocol::T_LIST) {
04025           {
04026             this->success.clear();
04027             uint32_t _size187;
04028             ::apache::thrift::protocol::TType _etype190;
04029             iprot->readListBegin(_etype190, _size187);
04030             this->success.resize(_size187);
04031             uint32_t _i191;
04032             for (_i191 = 0; _i191 < _size187; ++_i191)
04033             {
04034               xfer += this->success[_i191].read(iprot);
04035             }
04036             iprot->readListEnd();
04037           }
04038           this->__isset.success = true;
04039         } else {
04040           xfer += iprot->skip(ftype);
04041         }
04042         break;
04043       case 1:
04044         if (ftype == ::apache::thrift::protocol::T_STRUCT) {
04045           xfer += this->io.read(iprot);
04046           this->__isset.io = true;
04047         } else {
04048           xfer += iprot->skip(ftype);
04049         }
04050         break;
04051       default:
04052         xfer += iprot->skip(ftype);
04053         break;
04054     }
04055     xfer += iprot->readFieldEnd();
04056   }
04057 
04058   xfer += iprot->readStructEnd();
04059 
04060   return xfer;
04061 }
04062 
04063 uint32_t Hbase_getRowsWithColumns_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
04064 
04065   uint32_t xfer = 0;
04066 
04067   xfer += oprot->writeStructBegin("Hbase_getRowsWithColumns_result");
04068 
04069   if (this->__isset.success) {
04070     xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0);
04071     {
04072       xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->success.size()));
04073       std::vector<TRowResult> ::const_iterator _iter192;
04074       for (_iter192 = this->success.begin(); _iter192 != this->success.end(); ++_iter192)
04075       {
04076         xfer += (*_iter192).write(oprot);
04077       }
04078       xfer += oprot->writeListEnd();
04079     }
04080     xfer += oprot->writeFieldEnd();
04081   } else if (this->__isset.io) {
04082     xfer += oprot->writeFieldBegin("io", ::apache::thrift::protocol::T_STRUCT, 1);
04083     xfer += this->io.write(oprot);
04084     xfer += oprot->writeFieldEnd();
04085   }
04086   xfer += oprot->writeFieldStop();
04087   xfer += oprot->writeStructEnd();
04088   return xfer;
04089 }
04090 
04091 uint32_t Hbase_getRowsWithColumns_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
04092 
04093   uint32_t xfer = 0;
04094   std::string fname;
04095   ::apache::thrift::protocol::TType ftype;
04096   int16_t fid;
04097 
04098   xfer += iprot->readStructBegin(fname);
04099 
04100   using ::apache::thrift::protocol::TProtocolException;
04101 
04102 
04103   while (true)
04104   {
04105     xfer += iprot->readFieldBegin(fname, ftype, fid);
04106     if (ftype == ::apache::thrift::protocol::T_STOP) {
04107       break;
04108     }
04109     switch (fid)
04110     {
04111       case 0:
04112         if (ftype == ::apache::thrift::protocol::T_LIST) {
04113           {
04114             (*(this->success)).clear();
04115             uint32_t _size193;
04116             ::apache::thrift::protocol::TType _etype196;
04117             iprot->readListBegin(_etype196, _size193);
04118             (*(this->success)).resize(_size193);
04119             uint32_t _i197;
04120             for (_i197 = 0; _i197 < _size193; ++_i197)
04121             {
04122               xfer += (*(this->success))[_i197].read(iprot);
04123             }
04124             iprot->readListEnd();
04125           }
04126           this->__isset.success = true;
04127         } else {
04128           xfer += iprot->skip(ftype);
04129         }
04130         break;
04131       case 1:
04132         if (ftype == ::apache::thrift::protocol::T_STRUCT) {
04133           xfer += this->io.read(iprot);
04134           this->__isset.io = true;
04135         } else {
04136           xfer += iprot->skip(ftype);
04137         }
04138         break;
04139       default:
04140         xfer += iprot->skip(ftype);
04141         break;
04142     }
04143     xfer += iprot->readFieldEnd();
04144   }
04145 
04146   xfer += iprot->readStructEnd();
04147 
04148   return xfer;
04149 }
04150 
04151 uint32_t Hbase_getRowsTs_args::read(::apache::thrift::protocol::TProtocol* iprot) {
04152 
04153   uint32_t xfer = 0;
04154   std::string fname;
04155   ::apache::thrift::protocol::TType ftype;
04156   int16_t fid;
04157 
04158   xfer += iprot->readStructBegin(fname);
04159 
04160   using ::apache::thrift::protocol::TProtocolException;
04161 
04162 
04163   while (true)
04164   {
04165     xfer += iprot->readFieldBegin(fname, ftype, fid);
04166     if (ftype == ::apache::thrift::protocol::T_STOP) {
04167       break;
04168     }
04169     switch (fid)
04170     {
04171       case 1:
04172         if (ftype == ::apache::thrift::protocol::T_STRING) {
04173           xfer += iprot->readBinary(this->tableName);
04174           this->__isset.tableName = true;
04175         } else {
04176           xfer += iprot->skip(ftype);
04177         }
04178         break;
04179       case 2:
04180         if (ftype == ::apache::thrift::protocol::T_LIST) {
04181           {
04182             this->rows.clear();
04183             uint32_t _size198;
04184             ::apache::thrift::protocol::TType _etype201;
04185             iprot->readListBegin(_etype201, _size198);
04186             this->rows.resize(_size198);
04187             uint32_t _i202;
04188             for (_i202 = 0; _i202 < _size198; ++_i202)
04189             {
04190               xfer += iprot->readBinary(this->rows[_i202]);
04191             }
04192             iprot->readListEnd();
04193           }
04194           this->__isset.rows = true;
04195         } else {
04196           xfer += iprot->skip(ftype);
04197         }
04198         break;
04199       case 3:
04200         if (ftype == ::apache::thrift::protocol::T_I64) {
04201           xfer += iprot->readI64(this->timestamp);
04202           this->__isset.timestamp = true;
04203         } else {
04204           xfer += iprot->skip(ftype);
04205         }
04206         break;
04207       default:
04208         xfer += iprot->skip(ftype);
04209         break;
04210     }
04211     xfer += iprot->readFieldEnd();
04212   }
04213 
04214   xfer += iprot->readStructEnd();
04215 
04216   return xfer;
04217 }
04218 
04219 uint32_t Hbase_getRowsTs_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
04220   uint32_t xfer = 0;
04221   xfer += oprot->writeStructBegin("Hbase_getRowsTs_args");
04222   xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
04223   xfer += oprot->writeBinary(this->tableName);
04224   xfer += oprot->writeFieldEnd();
04225   xfer += oprot->writeFieldBegin("rows", ::apache::thrift::protocol::T_LIST, 2);
04226   {
04227     xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->rows.size()));
04228     std::vector<Text> ::const_iterator _iter203;
04229     for (_iter203 = this->rows.begin(); _iter203 != this->rows.end(); ++_iter203)
04230     {
04231       xfer += oprot->writeBinary((*_iter203));
04232     }
04233     xfer += oprot->writeListEnd();
04234   }
04235   xfer += oprot->writeFieldEnd();
04236   xfer += oprot->writeFieldBegin("timestamp", ::apache::thrift::protocol::T_I64, 3);
04237   xfer += oprot->writeI64(this->timestamp);
04238   xfer += oprot->writeFieldEnd();
04239   xfer += oprot->writeFieldStop();
04240   xfer += oprot->writeStructEnd();
04241   return xfer;
04242 }
04243 
04244 uint32_t Hbase_getRowsTs_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
04245   uint32_t xfer = 0;
04246   xfer += oprot->writeStructBegin("Hbase_getRowsTs_pargs");
04247   xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
04248   xfer += oprot->writeBinary((*(this->tableName)));
04249   xfer += oprot->writeFieldEnd();
04250   xfer += oprot->writeFieldBegin("rows", ::apache::thrift::protocol::T_LIST, 2);
04251   {
04252     xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->rows)).size()));
04253     std::vector<Text> ::const_iterator _iter204;
04254     for (_iter204 = (*(this->rows)).begin(); _iter204 != (*(this->rows)).end(); ++_iter204)
04255     {
04256       xfer += oprot->writeBinary((*_iter204));
04257     }
04258     xfer += oprot->writeListEnd();
04259   }
04260   xfer += oprot->writeFieldEnd();
04261   xfer += oprot->writeFieldBegin("timestamp", ::apache::thrift::protocol::T_I64, 3);
04262   xfer += oprot->writeI64((*(this->timestamp)));
04263   xfer += oprot->writeFieldEnd();
04264   xfer += oprot->writeFieldStop();
04265   xfer += oprot->writeStructEnd();
04266   return xfer;
04267 }
04268 
04269 uint32_t Hbase_getRowsTs_result::read(::apache::thrift::protocol::TProtocol* iprot) {
04270 
04271   uint32_t xfer = 0;
04272   std::string fname;
04273   ::apache::thrift::protocol::TType ftype;
04274   int16_t fid;
04275 
04276   xfer += iprot->readStructBegin(fname);
04277 
04278   using ::apache::thrift::protocol::TProtocolException;
04279 
04280 
04281   while (true)
04282   {
04283     xfer += iprot->readFieldBegin(fname, ftype, fid);
04284     if (ftype == ::apache::thrift::protocol::T_STOP) {
04285       break;
04286     }
04287     switch (fid)
04288     {
04289       case 0:
04290         if (ftype == ::apache::thrift::protocol::T_LIST) {
04291           {
04292             this->success.clear();
04293             uint32_t _size205;
04294             ::apache::thrift::protocol::TType _etype208;
04295             iprot->readListBegin(_etype208, _size205);
04296             this->success.resize(_size205);
04297             uint32_t _i209;
04298             for (_i209 = 0; _i209 < _size205; ++_i209)
04299             {
04300               xfer += this->success[_i209].read(iprot);
04301             }
04302             iprot->readListEnd();
04303           }
04304           this->__isset.success = true;
04305         } else {
04306           xfer += iprot->skip(ftype);
04307         }
04308         break;
04309       case 1:
04310         if (ftype == ::apache::thrift::protocol::T_STRUCT) {
04311           xfer += this->io.read(iprot);
04312           this->__isset.io = true;
04313         } else {
04314           xfer += iprot->skip(ftype);
04315         }
04316         break;
04317       default:
04318         xfer += iprot->skip(ftype);
04319         break;
04320     }
04321     xfer += iprot->readFieldEnd();
04322   }
04323 
04324   xfer += iprot->readStructEnd();
04325 
04326   return xfer;
04327 }
04328 
04329 uint32_t Hbase_getRowsTs_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
04330 
04331   uint32_t xfer = 0;
04332 
04333   xfer += oprot->writeStructBegin("Hbase_getRowsTs_result");
04334 
04335   if (this->__isset.success) {
04336     xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0);
04337     {
04338       xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->success.size()));
04339       std::vector<TRowResult> ::const_iterator _iter210;
04340       for (_iter210 = this->success.begin(); _iter210 != this->success.end(); ++_iter210)
04341       {
04342         xfer += (*_iter210).write(oprot);
04343       }
04344       xfer += oprot->writeListEnd();
04345     }
04346     xfer += oprot->writeFieldEnd();
04347   } else if (this->__isset.io) {
04348     xfer += oprot->writeFieldBegin("io", ::apache::thrift::protocol::T_STRUCT, 1);
04349     xfer += this->io.write(oprot);
04350     xfer += oprot->writeFieldEnd();
04351   }
04352   xfer += oprot->writeFieldStop();
04353   xfer += oprot->writeStructEnd();
04354   return xfer;
04355 }
04356 
04357 uint32_t Hbase_getRowsTs_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
04358 
04359   uint32_t xfer = 0;
04360   std::string fname;
04361   ::apache::thrift::protocol::TType ftype;
04362   int16_t fid;
04363 
04364   xfer += iprot->readStructBegin(fname);
04365 
04366   using ::apache::thrift::protocol::TProtocolException;
04367 
04368 
04369   while (true)
04370   {
04371     xfer += iprot->readFieldBegin(fname, ftype, fid);
04372     if (ftype == ::apache::thrift::protocol::T_STOP) {
04373       break;
04374     }
04375     switch (fid)
04376     {
04377       case 0:
04378         if (ftype == ::apache::thrift::protocol::T_LIST) {
04379           {
04380             (*(this->success)).clear();
04381             uint32_t _size211;
04382             ::apache::thrift::protocol::TType _etype214;
04383             iprot->readListBegin(_etype214, _size211);
04384             (*(this->success)).resize(_size211);
04385             uint32_t _i215;
04386             for (_i215 = 0; _i215 < _size211; ++_i215)
04387             {
04388               xfer += (*(this->success))[_i215].read(iprot);
04389             }
04390             iprot->readListEnd();
04391           }
04392           this->__isset.success = true;
04393         } else {
04394           xfer += iprot->skip(ftype);
04395         }
04396         break;
04397       case 1:
04398         if (ftype == ::apache::thrift::protocol::T_STRUCT) {
04399           xfer += this->io.read(iprot);
04400           this->__isset.io = true;
04401         } else {
04402           xfer += iprot->skip(ftype);
04403         }
04404         break;
04405       default:
04406         xfer += iprot->skip(ftype);
04407         break;
04408     }
04409     xfer += iprot->readFieldEnd();
04410   }
04411 
04412   xfer += iprot->readStructEnd();
04413 
04414   return xfer;
04415 }
04416 
04417 uint32_t Hbase_getRowsWithColumnsTs_args::read(::apache::thrift::protocol::TProtocol* iprot) {
04418 
04419   uint32_t xfer = 0;
04420   std::string fname;
04421   ::apache::thrift::protocol::TType ftype;
04422   int16_t fid;
04423 
04424   xfer += iprot->readStructBegin(fname);
04425 
04426   using ::apache::thrift::protocol::TProtocolException;
04427 
04428 
04429   while (true)
04430   {
04431     xfer += iprot->readFieldBegin(fname, ftype, fid);
04432     if (ftype == ::apache::thrift::protocol::T_STOP) {
04433       break;
04434     }
04435     switch (fid)
04436     {
04437       case 1:
04438         if (ftype == ::apache::thrift::protocol::T_STRING) {
04439           xfer += iprot->readBinary(this->tableName);
04440           this->__isset.tableName = true;
04441         } else {
04442           xfer += iprot->skip(ftype);
04443         }
04444         break;
04445       case 2:
04446         if (ftype == ::apache::thrift::protocol::T_LIST) {
04447           {
04448             this->rows.clear();
04449             uint32_t _size216;
04450             ::apache::thrift::protocol::TType _etype219;
04451             iprot->readListBegin(_etype219, _size216);
04452             this->rows.resize(_size216);
04453             uint32_t _i220;
04454             for (_i220 = 0; _i220 < _size216; ++_i220)
04455             {
04456               xfer += iprot->readBinary(this->rows[_i220]);
04457             }
04458             iprot->readListEnd();
04459           }
04460           this->__isset.rows = true;
04461         } else {
04462           xfer += iprot->skip(ftype);
04463         }
04464         break;
04465       case 3:
04466         if (ftype == ::apache::thrift::protocol::T_LIST) {
04467           {
04468             this->columns.clear();
04469             uint32_t _size221;
04470             ::apache::thrift::protocol::TType _etype224;
04471             iprot->readListBegin(_etype224, _size221);
04472             this->columns.resize(_size221);
04473             uint32_t _i225;
04474             for (_i225 = 0; _i225 < _size221; ++_i225)
04475             {
04476               xfer += iprot->readBinary(this->columns[_i225]);
04477             }
04478             iprot->readListEnd();
04479           }
04480           this->__isset.columns = true;
04481         } else {
04482           xfer += iprot->skip(ftype);
04483         }
04484         break;
04485       case 4:
04486         if (ftype == ::apache::thrift::protocol::T_I64) {
04487           xfer += iprot->readI64(this->timestamp);
04488           this->__isset.timestamp = true;
04489         } else {
04490           xfer += iprot->skip(ftype);
04491         }
04492         break;
04493       default:
04494         xfer += iprot->skip(ftype);
04495         break;
04496     }
04497     xfer += iprot->readFieldEnd();
04498   }
04499 
04500   xfer += iprot->readStructEnd();
04501 
04502   return xfer;
04503 }
04504 
04505 uint32_t Hbase_getRowsWithColumnsTs_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
04506   uint32_t xfer = 0;
04507   xfer += oprot->writeStructBegin("Hbase_getRowsWithColumnsTs_args");
04508   xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
04509   xfer += oprot->writeBinary(this->tableName);
04510   xfer += oprot->writeFieldEnd();
04511   xfer += oprot->writeFieldBegin("rows", ::apache::thrift::protocol::T_LIST, 2);
04512   {
04513     xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->rows.size()));
04514     std::vector<Text> ::const_iterator _iter226;
04515     for (_iter226 = this->rows.begin(); _iter226 != this->rows.end(); ++_iter226)
04516     {
04517       xfer += oprot->writeBinary((*_iter226));
04518     }
04519     xfer += oprot->writeListEnd();
04520   }
04521   xfer += oprot->writeFieldEnd();
04522   xfer += oprot->writeFieldBegin("columns", ::apache::thrift::protocol::T_LIST, 3);
04523   {
04524     xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->columns.size()));
04525     std::vector<Text> ::const_iterator _iter227;
04526     for (_iter227 = this->columns.begin(); _iter227 != this->columns.end(); ++_iter227)
04527     {
04528       xfer += oprot->writeBinary((*_iter227));
04529     }
04530     xfer += oprot->writeListEnd();
04531   }
04532   xfer += oprot->writeFieldEnd();
04533   xfer += oprot->writeFieldBegin("timestamp", ::apache::thrift::protocol::T_I64, 4);
04534   xfer += oprot->writeI64(this->timestamp);
04535   xfer += oprot->writeFieldEnd();
04536   xfer += oprot->writeFieldStop();
04537   xfer += oprot->writeStructEnd();
04538   return xfer;
04539 }
04540 
04541 uint32_t Hbase_getRowsWithColumnsTs_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
04542   uint32_t xfer = 0;
04543   xfer += oprot->writeStructBegin("Hbase_getRowsWithColumnsTs_pargs");
04544   xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
04545   xfer += oprot->writeBinary((*(this->tableName)));
04546   xfer += oprot->writeFieldEnd();
04547   xfer += oprot->writeFieldBegin("rows", ::apache::thrift::protocol::T_LIST, 2);
04548   {
04549     xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->rows)).size()));
04550     std::vector<Text> ::const_iterator _iter228;
04551     for (_iter228 = (*(this->rows)).begin(); _iter228 != (*(this->rows)).end(); ++_iter228)
04552     {
04553       xfer += oprot->writeBinary((*_iter228));
04554     }
04555     xfer += oprot->writeListEnd();
04556   }
04557   xfer += oprot->writeFieldEnd();
04558   xfer += oprot->writeFieldBegin("columns", ::apache::thrift::protocol::T_LIST, 3);
04559   {
04560     xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->columns)).size()));
04561     std::vector<Text> ::const_iterator _iter229;
04562     for (_iter229 = (*(this->columns)).begin(); _iter229 != (*(this->columns)).end(); ++_iter229)
04563     {
04564       xfer += oprot->writeBinary((*_iter229));
04565     }
04566     xfer += oprot->writeListEnd();
04567   }
04568   xfer += oprot->writeFieldEnd();
04569   xfer += oprot->writeFieldBegin("timestamp", ::apache::thrift::protocol::T_I64, 4);
04570   xfer += oprot->writeI64((*(this->timestamp)));
04571   xfer += oprot->writeFieldEnd();
04572   xfer += oprot->writeFieldStop();
04573   xfer += oprot->writeStructEnd();
04574   return xfer;
04575 }
04576 
04577 uint32_t Hbase_getRowsWithColumnsTs_result::read(::apache::thrift::protocol::TProtocol* iprot) {
04578 
04579   uint32_t xfer = 0;
04580   std::string fname;
04581   ::apache::thrift::protocol::TType ftype;
04582   int16_t fid;
04583 
04584   xfer += iprot->readStructBegin(fname);
04585 
04586   using ::apache::thrift::protocol::TProtocolException;
04587 
04588 
04589   while (true)
04590   {
04591     xfer += iprot->readFieldBegin(fname, ftype, fid);
04592     if (ftype == ::apache::thrift::protocol::T_STOP) {
04593       break;
04594     }
04595     switch (fid)
04596     {
04597       case 0:
04598         if (ftype == ::apache::thrift::protocol::T_LIST) {
04599           {
04600             this->success.clear();
04601             uint32_t _size230;
04602             ::apache::thrift::protocol::TType _etype233;
04603             iprot->readListBegin(_etype233, _size230);
04604             this->success.resize(_size230);
04605             uint32_t _i234;
04606             for (_i234 = 0; _i234 < _size230; ++_i234)
04607             {
04608               xfer += this->success[_i234].read(iprot);
04609             }
04610             iprot->readListEnd();
04611           }
04612           this->__isset.success = true;
04613         } else {
04614           xfer += iprot->skip(ftype);
04615         }
04616         break;
04617       case 1:
04618         if (ftype == ::apache::thrift::protocol::T_STRUCT) {
04619           xfer += this->io.read(iprot);
04620           this->__isset.io = true;
04621         } else {
04622           xfer += iprot->skip(ftype);
04623         }
04624         break;
04625       default:
04626         xfer += iprot->skip(ftype);
04627         break;
04628     }
04629     xfer += iprot->readFieldEnd();
04630   }
04631 
04632   xfer += iprot->readStructEnd();
04633 
04634   return xfer;
04635 }
04636 
04637 uint32_t Hbase_getRowsWithColumnsTs_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
04638 
04639   uint32_t xfer = 0;
04640 
04641   xfer += oprot->writeStructBegin("Hbase_getRowsWithColumnsTs_result");
04642 
04643   if (this->__isset.success) {
04644     xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0);
04645     {
04646       xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->success.size()));
04647       std::vector<TRowResult> ::const_iterator _iter235;
04648       for (_iter235 = this->success.begin(); _iter235 != this->success.end(); ++_iter235)
04649       {
04650         xfer += (*_iter235).write(oprot);
04651       }
04652       xfer += oprot->writeListEnd();
04653     }
04654     xfer += oprot->writeFieldEnd();
04655   } else if (this->__isset.io) {
04656     xfer += oprot->writeFieldBegin("io", ::apache::thrift::protocol::T_STRUCT, 1);
04657     xfer += this->io.write(oprot);
04658     xfer += oprot->writeFieldEnd();
04659   }
04660   xfer += oprot->writeFieldStop();
04661   xfer += oprot->writeStructEnd();
04662   return xfer;
04663 }
04664 
04665 uint32_t Hbase_getRowsWithColumnsTs_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
04666 
04667   uint32_t xfer = 0;
04668   std::string fname;
04669   ::apache::thrift::protocol::TType ftype;
04670   int16_t fid;
04671 
04672   xfer += iprot->readStructBegin(fname);
04673 
04674   using ::apache::thrift::protocol::TProtocolException;
04675 
04676 
04677   while (true)
04678   {
04679     xfer += iprot->readFieldBegin(fname, ftype, fid);
04680     if (ftype == ::apache::thrift::protocol::T_STOP) {
04681       break;
04682     }
04683     switch (fid)
04684     {
04685       case 0:
04686         if (ftype == ::apache::thrift::protocol::T_LIST) {
04687           {
04688             (*(this->success)).clear();
04689             uint32_t _size236;
04690             ::apache::thrift::protocol::TType _etype239;
04691             iprot->readListBegin(_etype239, _size236);
04692             (*(this->success)).resize(_size236);
04693             uint32_t _i240;
04694             for (_i240 = 0; _i240 < _size236; ++_i240)
04695             {
04696               xfer += (*(this->success))[_i240].read(iprot);
04697             }
04698             iprot->readListEnd();
04699           }
04700           this->__isset.success = true;
04701         } else {
04702           xfer += iprot->skip(ftype);
04703         }
04704         break;
04705       case 1:
04706         if (ftype == ::apache::thrift::protocol::T_STRUCT) {
04707           xfer += this->io.read(iprot);
04708           this->__isset.io = true;
04709         } else {
04710           xfer += iprot->skip(ftype);
04711         }
04712         break;
04713       default:
04714         xfer += iprot->skip(ftype);
04715         break;
04716     }
04717     xfer += iprot->readFieldEnd();
04718   }
04719 
04720   xfer += iprot->readStructEnd();
04721 
04722   return xfer;
04723 }
04724 
04725 uint32_t Hbase_mutateRow_args::read(::apache::thrift::protocol::TProtocol* iprot) {
04726 
04727   uint32_t xfer = 0;
04728   std::string fname;
04729   ::apache::thrift::protocol::TType ftype;
04730   int16_t fid;
04731 
04732   xfer += iprot->readStructBegin(fname);
04733 
04734   using ::apache::thrift::protocol::TProtocolException;
04735 
04736 
04737   while (true)
04738   {
04739     xfer += iprot->readFieldBegin(fname, ftype, fid);
04740     if (ftype == ::apache::thrift::protocol::T_STOP) {
04741       break;
04742     }
04743     switch (fid)
04744     {
04745       case 1:
04746         if (ftype == ::apache::thrift::protocol::T_STRING) {
04747           xfer += iprot->readBinary(this->tableName);
04748           this->__isset.tableName = true;
04749         } else {
04750           xfer += iprot->skip(ftype);
04751         }
04752         break;
04753       case 2:
04754         if (ftype == ::apache::thrift::protocol::T_STRING) {
04755           xfer += iprot->readBinary(this->row);
04756           this->__isset.row = true;
04757         } else {
04758           xfer += iprot->skip(ftype);
04759         }
04760         break;
04761       case 3:
04762         if (ftype == ::apache::thrift::protocol::T_LIST) {
04763           {
04764             this->mutations.clear();
04765             uint32_t _size241;
04766             ::apache::thrift::protocol::TType _etype244;
04767             iprot->readListBegin(_etype244, _size241);
04768             this->mutations.resize(_size241);
04769             uint32_t _i245;
04770             for (_i245 = 0; _i245 < _size241; ++_i245)
04771             {
04772               xfer += this->mutations[_i245].read(iprot);
04773             }
04774             iprot->readListEnd();
04775           }
04776           this->__isset.mutations = true;
04777         } else {
04778           xfer += iprot->skip(ftype);
04779         }
04780         break;
04781       default:
04782         xfer += iprot->skip(ftype);
04783         break;
04784     }
04785     xfer += iprot->readFieldEnd();
04786   }
04787 
04788   xfer += iprot->readStructEnd();
04789 
04790   return xfer;
04791 }
04792 
04793 uint32_t Hbase_mutateRow_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
04794   uint32_t xfer = 0;
04795   xfer += oprot->writeStructBegin("Hbase_mutateRow_args");
04796   xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
04797   xfer += oprot->writeBinary(this->tableName);
04798   xfer += oprot->writeFieldEnd();
04799   xfer += oprot->writeFieldBegin("row", ::apache::thrift::protocol::T_STRING, 2);
04800   xfer += oprot->writeBinary(this->row);
04801   xfer += oprot->writeFieldEnd();
04802   xfer += oprot->writeFieldBegin("mutations", ::apache::thrift::protocol::T_LIST, 3);
04803   {
04804     xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->mutations.size()));
04805     std::vector<Mutation> ::const_iterator _iter246;
04806     for (_iter246 = this->mutations.begin(); _iter246 != this->mutations.end(); ++_iter246)
04807     {
04808       xfer += (*_iter246).write(oprot);
04809     }
04810     xfer += oprot->writeListEnd();
04811   }
04812   xfer += oprot->writeFieldEnd();
04813   xfer += oprot->writeFieldStop();
04814   xfer += oprot->writeStructEnd();
04815   return xfer;
04816 }
04817 
04818 uint32_t Hbase_mutateRow_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
04819   uint32_t xfer = 0;
04820   xfer += oprot->writeStructBegin("Hbase_mutateRow_pargs");
04821   xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
04822   xfer += oprot->writeBinary((*(this->tableName)));
04823   xfer += oprot->writeFieldEnd();
04824   xfer += oprot->writeFieldBegin("row", ::apache::thrift::protocol::T_STRING, 2);
04825   xfer += oprot->writeBinary((*(this->row)));
04826   xfer += oprot->writeFieldEnd();
04827   xfer += oprot->writeFieldBegin("mutations", ::apache::thrift::protocol::T_LIST, 3);
04828   {
04829     xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>((*(this->mutations)).size()));
04830     std::vector<Mutation> ::const_iterator _iter247;
04831     for (_iter247 = (*(this->mutations)).begin(); _iter247 != (*(this->mutations)).end(); ++_iter247)
04832     {
04833       xfer += (*_iter247).write(oprot);
04834     }
04835     xfer += oprot->writeListEnd();
04836   }
04837   xfer += oprot->writeFieldEnd();
04838   xfer += oprot->writeFieldStop();
04839   xfer += oprot->writeStructEnd();
04840   return xfer;
04841 }
04842 
04843 uint32_t Hbase_mutateRow_result::read(::apache::thrift::protocol::TProtocol* iprot) {
04844 
04845   uint32_t xfer = 0;
04846   std::string fname;
04847   ::apache::thrift::protocol::TType ftype;
04848   int16_t fid;
04849 
04850   xfer += iprot->readStructBegin(fname);
04851 
04852   using ::apache::thrift::protocol::TProtocolException;
04853 
04854 
04855   while (true)
04856   {
04857     xfer += iprot->readFieldBegin(fname, ftype, fid);
04858     if (ftype == ::apache::thrift::protocol::T_STOP) {
04859       break;
04860     }
04861     switch (fid)
04862     {
04863       case 1:
04864         if (ftype == ::apache::thrift::protocol::T_STRUCT) {
04865           xfer += this->io.read(iprot);
04866           this->__isset.io = true;
04867         } else {
04868           xfer += iprot->skip(ftype);
04869         }
04870         break;
04871       case 2:
04872         if (ftype == ::apache::thrift::protocol::T_STRUCT) {
04873           xfer += this->ia.read(iprot);
04874           this->__isset.ia = true;
04875         } else {
04876           xfer += iprot->skip(ftype);
04877         }
04878         break;
04879       default:
04880         xfer += iprot->skip(ftype);
04881         break;
04882     }
04883     xfer += iprot->readFieldEnd();
04884   }
04885 
04886   xfer += iprot->readStructEnd();
04887 
04888   return xfer;
04889 }
04890 
04891 uint32_t Hbase_mutateRow_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
04892 
04893   uint32_t xfer = 0;
04894 
04895   xfer += oprot->writeStructBegin("Hbase_mutateRow_result");
04896 
04897   if (this->__isset.io) {
04898     xfer += oprot->writeFieldBegin("io", ::apache::thrift::protocol::T_STRUCT, 1);
04899     xfer += this->io.write(oprot);
04900     xfer += oprot->writeFieldEnd();
04901   } else if (this->__isset.ia) {
04902     xfer += oprot->writeFieldBegin("ia", ::apache::thrift::protocol::T_STRUCT, 2);
04903     xfer += this->ia.write(oprot);
04904     xfer += oprot->writeFieldEnd();
04905   }
04906   xfer += oprot->writeFieldStop();
04907   xfer += oprot->writeStructEnd();
04908   return xfer;
04909 }
04910 
04911 uint32_t Hbase_mutateRow_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
04912 
04913   uint32_t xfer = 0;
04914   std::string fname;
04915   ::apache::thrift::protocol::TType ftype;
04916   int16_t fid;
04917 
04918   xfer += iprot->readStructBegin(fname);
04919 
04920   using ::apache::thrift::protocol::TProtocolException;
04921 
04922 
04923   while (true)
04924   {
04925     xfer += iprot->readFieldBegin(fname, ftype, fid);
04926     if (ftype == ::apache::thrift::protocol::T_STOP) {
04927       break;
04928     }
04929     switch (fid)
04930     {
04931       case 1:
04932         if (ftype == ::apache::thrift::protocol::T_STRUCT) {
04933           xfer += this->io.read(iprot);
04934           this->__isset.io = true;
04935         } else {
04936           xfer += iprot->skip(ftype);
04937         }
04938         break;
04939       case 2:
04940         if (ftype == ::apache::thrift::protocol::T_STRUCT) {
04941           xfer += this->ia.read(iprot);
04942           this->__isset.ia = true;
04943         } else {
04944           xfer += iprot->skip(ftype);
04945         }
04946         break;
04947       default:
04948         xfer += iprot->skip(ftype);
04949         break;
04950     }
04951     xfer += iprot->readFieldEnd();
04952   }
04953 
04954   xfer += iprot->readStructEnd();
04955 
04956   return xfer;
04957 }
04958 
04959 uint32_t Hbase_mutateRowTs_args::read(::apache::thrift::protocol::TProtocol* iprot) {
04960 
04961   uint32_t xfer = 0;
04962   std::string fname;
04963   ::apache::thrift::protocol::TType ftype;
04964   int16_t fid;
04965 
04966   xfer += iprot->readStructBegin(fname);
04967 
04968   using ::apache::thrift::protocol::TProtocolException;
04969 
04970 
04971   while (true)
04972   {
04973     xfer += iprot->readFieldBegin(fname, ftype, fid);
04974     if (ftype == ::apache::thrift::protocol::T_STOP) {
04975       break;
04976     }
04977     switch (fid)
04978     {
04979       case 1:
04980         if (ftype == ::apache::thrift::protocol::T_STRING) {
04981           xfer += iprot->readBinary(this->tableName);
04982           this->__isset.tableName = true;
04983         } else {
04984           xfer += iprot->skip(ftype);
04985         }
04986         break;
04987       case 2:
04988         if (ftype == ::apache::thrift::protocol::T_STRING) {
04989           xfer += iprot->readBinary(this->row);
04990           this->__isset.row = true;
04991         } else {
04992           xfer += iprot->skip(ftype);
04993         }
04994         break;
04995       case 3:
04996         if (ftype == ::apache::thrift::protocol::T_LIST) {
04997           {
04998             this->mutations.clear();
04999             uint32_t _size248;
05000             ::apache::thrift::protocol::TType _etype251;
05001             iprot->readListBegin(_etype251, _size248);
05002             this->mutations.resize(_size248);
05003             uint32_t _i252;
05004             for (_i252 = 0; _i252 < _size248; ++_i252)
05005             {
05006               xfer += this->mutations[_i252].read(iprot);
05007             }
05008             iprot->readListEnd();
05009           }
05010           this->__isset.mutations = true;
05011         } else {
05012           xfer += iprot->skip(ftype);
05013         }
05014         break;
05015       case 4:
05016         if (ftype == ::apache::thrift::protocol::T_I64) {
05017           xfer += iprot->readI64(this->timestamp);
05018           this->__isset.timestamp = true;
05019         } else {
05020           xfer += iprot->skip(ftype);
05021         }
05022         break;
05023       default:
05024         xfer += iprot->skip(ftype);
05025         break;
05026     }
05027     xfer += iprot->readFieldEnd();
05028   }
05029 
05030   xfer += iprot->readStructEnd();
05031 
05032   return xfer;
05033 }
05034 
05035 uint32_t Hbase_mutateRowTs_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
05036   uint32_t xfer = 0;
05037   xfer += oprot->writeStructBegin("Hbase_mutateRowTs_args");
05038   xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
05039   xfer += oprot->writeBinary(this->tableName);
05040   xfer += oprot->writeFieldEnd();
05041   xfer += oprot->writeFieldBegin("row", ::apache::thrift::protocol::T_STRING, 2);
05042   xfer += oprot->writeBinary(this->row);
05043   xfer += oprot->writeFieldEnd();
05044   xfer += oprot->writeFieldBegin("mutations", ::apache::thrift::protocol::T_LIST, 3);
05045   {
05046     xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->mutations.size()));
05047     std::vector<Mutation> ::const_iterator _iter253;
05048     for (_iter253 = this->mutations.begin(); _iter253 != this->mutations.end(); ++_iter253)
05049     {
05050       xfer += (*_iter253).write(oprot);
05051     }
05052     xfer += oprot->writeListEnd();
05053   }
05054   xfer += oprot->writeFieldEnd();
05055   xfer += oprot->writeFieldBegin("timestamp", ::apache::thrift::protocol::T_I64, 4);
05056   xfer += oprot->writeI64(this->timestamp);
05057   xfer += oprot->writeFieldEnd();
05058   xfer += oprot->writeFieldStop();
05059   xfer += oprot->writeStructEnd();
05060   return xfer;
05061 }
05062 
05063 uint32_t Hbase_mutateRowTs_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
05064   uint32_t xfer = 0;
05065   xfer += oprot->writeStructBegin("Hbase_mutateRowTs_pargs");
05066   xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
05067   xfer += oprot->writeBinary((*(this->tableName)));
05068   xfer += oprot->writeFieldEnd();
05069   xfer += oprot->writeFieldBegin("row", ::apache::thrift::protocol::T_STRING, 2);
05070   xfer += oprot->writeBinary((*(this->row)));
05071   xfer += oprot->writeFieldEnd();
05072   xfer += oprot->writeFieldBegin("mutations", ::apache::thrift::protocol::T_LIST, 3);
05073   {
05074     xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>((*(this->mutations)).size()));
05075     std::vector<Mutation> ::const_iterator _iter254;
05076     for (_iter254 = (*(this->mutations)).begin(); _iter254 != (*(this->mutations)).end(); ++_iter254)
05077     {
05078       xfer += (*_iter254).write(oprot);
05079     }
05080     xfer += oprot->writeListEnd();
05081   }
05082   xfer += oprot->writeFieldEnd();
05083   xfer += oprot->writeFieldBegin("timestamp", ::apache::thrift::protocol::T_I64, 4);
05084   xfer += oprot->writeI64((*(this->timestamp)));
05085   xfer += oprot->writeFieldEnd();
05086   xfer += oprot->writeFieldStop();
05087   xfer += oprot->writeStructEnd();
05088   return xfer;
05089 }
05090 
05091 uint32_t Hbase_mutateRowTs_result::read(::apache::thrift::protocol::TProtocol* iprot) {
05092 
05093   uint32_t xfer = 0;
05094   std::string fname;
05095   ::apache::thrift::protocol::TType ftype;
05096   int16_t fid;
05097 
05098   xfer += iprot->readStructBegin(fname);
05099 
05100   using ::apache::thrift::protocol::TProtocolException;
05101 
05102 
05103   while (true)
05104   {
05105     xfer += iprot->readFieldBegin(fname, ftype, fid);
05106     if (ftype == ::apache::thrift::protocol::T_STOP) {
05107       break;
05108     }
05109     switch (fid)
05110     {
05111       case 1:
05112         if (ftype == ::apache::thrift::protocol::T_STRUCT) {
05113           xfer += this->io.read(iprot);
05114           this->__isset.io = true;
05115         } else {
05116           xfer += iprot->skip(ftype);
05117         }
05118         break;
05119       case 2:
05120         if (ftype == ::apache::thrift::protocol::T_STRUCT) {
05121           xfer += this->ia.read(iprot);
05122           this->__isset.ia = true;
05123         } else {
05124           xfer += iprot->skip(ftype);
05125         }
05126         break;
05127       default:
05128         xfer += iprot->skip(ftype);
05129         break;
05130     }
05131     xfer += iprot->readFieldEnd();
05132   }
05133 
05134   xfer += iprot->readStructEnd();
05135 
05136   return xfer;
05137 }
05138 
05139 uint32_t Hbase_mutateRowTs_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
05140 
05141   uint32_t xfer = 0;
05142 
05143   xfer += oprot->writeStructBegin("Hbase_mutateRowTs_result");
05144 
05145   if (this->__isset.io) {
05146     xfer += oprot->writeFieldBegin("io", ::apache::thrift::protocol::T_STRUCT, 1);
05147     xfer += this->io.write(oprot);
05148     xfer += oprot->writeFieldEnd();
05149   } else if (this->__isset.ia) {
05150     xfer += oprot->writeFieldBegin("ia", ::apache::thrift::protocol::T_STRUCT, 2);
05151     xfer += this->ia.write(oprot);
05152     xfer += oprot->writeFieldEnd();
05153   }
05154   xfer += oprot->writeFieldStop();
05155   xfer += oprot->writeStructEnd();
05156   return xfer;
05157 }
05158 
05159 uint32_t Hbase_mutateRowTs_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
05160 
05161   uint32_t xfer = 0;
05162   std::string fname;
05163   ::apache::thrift::protocol::TType ftype;
05164   int16_t fid;
05165 
05166   xfer += iprot->readStructBegin(fname);
05167 
05168   using ::apache::thrift::protocol::TProtocolException;
05169 
05170 
05171   while (true)
05172   {
05173     xfer += iprot->readFieldBegin(fname, ftype, fid);
05174     if (ftype == ::apache::thrift::protocol::T_STOP) {
05175       break;
05176     }
05177     switch (fid)
05178     {
05179       case 1:
05180         if (ftype == ::apache::thrift::protocol::T_STRUCT) {
05181           xfer += this->io.read(iprot);
05182           this->__isset.io = true;
05183         } else {
05184           xfer += iprot->skip(ftype);
05185         }
05186         break;
05187       case 2:
05188         if (ftype == ::apache::thrift::protocol::T_STRUCT) {
05189           xfer += this->ia.read(iprot);
05190           this->__isset.ia = true;
05191         } else {
05192           xfer += iprot->skip(ftype);
05193         }
05194         break;
05195       default:
05196         xfer += iprot->skip(ftype);
05197         break;
05198     }
05199     xfer += iprot->readFieldEnd();
05200   }
05201 
05202   xfer += iprot->readStructEnd();
05203 
05204   return xfer;
05205 }
05206 
05207 uint32_t Hbase_mutateRows_args::read(::apache::thrift::protocol::TProtocol* iprot) {
05208 
05209   uint32_t xfer = 0;
05210   std::string fname;
05211   ::apache::thrift::protocol::TType ftype;
05212   int16_t fid;
05213 
05214   xfer += iprot->readStructBegin(fname);
05215 
05216   using ::apache::thrift::protocol::TProtocolException;
05217 
05218 
05219   while (true)
05220   {
05221     xfer += iprot->readFieldBegin(fname, ftype, fid);
05222     if (ftype == ::apache::thrift::protocol::T_STOP) {
05223       break;
05224     }
05225     switch (fid)
05226     {
05227       case 1:
05228         if (ftype == ::apache::thrift::protocol::T_STRING) {
05229           xfer += iprot->readBinary(this->tableName);
05230           this->__isset.tableName = true;
05231         } else {
05232           xfer += iprot->skip(ftype);
05233         }
05234         break;
05235       case 2:
05236         if (ftype == ::apache::thrift::protocol::T_LIST) {
05237           {
05238             this->rowBatches.clear();
05239             uint32_t _size255;
05240             ::apache::thrift::protocol::TType _etype258;
05241             iprot->readListBegin(_etype258, _size255);
05242             this->rowBatches.resize(_size255);
05243             uint32_t _i259;
05244             for (_i259 = 0; _i259 < _size255; ++_i259)
05245             {
05246               xfer += this->rowBatches[_i259].read(iprot);
05247             }
05248             iprot->readListEnd();
05249           }
05250           this->__isset.rowBatches = true;
05251         } else {
05252           xfer += iprot->skip(ftype);
05253         }
05254         break;
05255       default:
05256         xfer += iprot->skip(ftype);
05257         break;
05258     }
05259     xfer += iprot->readFieldEnd();
05260   }
05261 
05262   xfer += iprot->readStructEnd();
05263 
05264   return xfer;
05265 }
05266 
05267 uint32_t Hbase_mutateRows_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
05268   uint32_t xfer = 0;
05269   xfer += oprot->writeStructBegin("Hbase_mutateRows_args");
05270   xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
05271   xfer += oprot->writeBinary(this->tableName);
05272   xfer += oprot->writeFieldEnd();
05273   xfer += oprot->writeFieldBegin("rowBatches", ::apache::thrift::protocol::T_LIST, 2);
05274   {
05275     xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->rowBatches.size()));
05276     std::vector<BatchMutation> ::const_iterator _iter260;
05277     for (_iter260 = this->rowBatches.begin(); _iter260 != this->rowBatches.end(); ++_iter260)
05278     {
05279       xfer += (*_iter260).write(oprot);
05280     }
05281     xfer += oprot->writeListEnd();
05282   }
05283   xfer += oprot->writeFieldEnd();
05284   xfer += oprot->writeFieldStop();
05285   xfer += oprot->writeStructEnd();
05286   return xfer;
05287 }
05288 
05289 uint32_t Hbase_mutateRows_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
05290   uint32_t xfer = 0;
05291   xfer += oprot->writeStructBegin("Hbase_mutateRows_pargs");
05292   xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
05293   xfer += oprot->writeBinary((*(this->tableName)));
05294   xfer += oprot->writeFieldEnd();
05295   xfer += oprot->writeFieldBegin("rowBatches", ::apache::thrift::protocol::T_LIST, 2);
05296   {
05297     xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>((*(this->rowBatches)).size()));
05298     std::vector<BatchMutation> ::const_iterator _iter261;
05299     for (_iter261 = (*(this->rowBatches)).begin(); _iter261 != (*(this->rowBatches)).end(); ++_iter261)
05300     {
05301       xfer += (*_iter261).write(oprot);
05302     }
05303     xfer += oprot->writeListEnd();
05304   }
05305   xfer += oprot->writeFieldEnd();
05306   xfer += oprot->writeFieldStop();
05307   xfer += oprot->writeStructEnd();
05308   return xfer;
05309 }
05310 
05311 uint32_t Hbase_mutateRows_result::read(::apache::thrift::protocol::TProtocol* iprot) {
05312 
05313   uint32_t xfer = 0;
05314   std::string fname;
05315   ::apache::thrift::protocol::TType ftype;
05316   int16_t fid;
05317 
05318   xfer += iprot->readStructBegin(fname);
05319 
05320   using ::apache::thrift::protocol::TProtocolException;
05321 
05322 
05323   while (true)
05324   {
05325     xfer += iprot->readFieldBegin(fname, ftype, fid);
05326     if (ftype == ::apache::thrift::protocol::T_STOP) {
05327       break;
05328     }
05329     switch (fid)
05330     {
05331       case 1:
05332         if (ftype == ::apache::thrift::protocol::T_STRUCT) {
05333           xfer += this->io.read(iprot);
05334           this->__isset.io = true;
05335         } else {
05336           xfer += iprot->skip(ftype);
05337         }
05338         break;
05339       case 2:
05340         if (ftype == ::apache::thrift::protocol::T_STRUCT) {
05341           xfer += this->ia.read(iprot);
05342           this->__isset.ia = true;
05343         } else {
05344           xfer += iprot->skip(ftype);
05345         }
05346         break;
05347       default:
05348         xfer += iprot->skip(ftype);
05349         break;
05350     }
05351     xfer += iprot->readFieldEnd();
05352   }
05353 
05354   xfer += iprot->readStructEnd();
05355 
05356   return xfer;
05357 }
05358 
05359 uint32_t Hbase_mutateRows_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
05360 
05361   uint32_t xfer = 0;
05362 
05363   xfer += oprot->writeStructBegin("Hbase_mutateRows_result");
05364 
05365   if (this->__isset.io) {
05366     xfer += oprot->writeFieldBegin("io", ::apache::thrift::protocol::T_STRUCT, 1);
05367     xfer += this->io.write(oprot);
05368     xfer += oprot->writeFieldEnd();
05369   } else if (this->__isset.ia) {
05370     xfer += oprot->writeFieldBegin("ia", ::apache::thrift::protocol::T_STRUCT, 2);
05371     xfer += this->ia.write(oprot);
05372     xfer += oprot->writeFieldEnd();
05373   }
05374   xfer += oprot->writeFieldStop();
05375   xfer += oprot->writeStructEnd();
05376   return xfer;
05377 }
05378 
05379 uint32_t Hbase_mutateRows_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
05380 
05381   uint32_t xfer = 0;
05382   std::string fname;
05383   ::apache::thrift::protocol::TType ftype;
05384   int16_t fid;
05385 
05386   xfer += iprot->readStructBegin(fname);
05387 
05388   using ::apache::thrift::protocol::TProtocolException;
05389 
05390 
05391   while (true)
05392   {
05393     xfer += iprot->readFieldBegin(fname, ftype, fid);
05394     if (ftype == ::apache::thrift::protocol::T_STOP) {
05395       break;
05396     }
05397     switch (fid)
05398     {
05399       case 1:
05400         if (ftype == ::apache::thrift::protocol::T_STRUCT) {
05401           xfer += this->io.read(iprot);
05402           this->__isset.io = true;
05403         } else {
05404           xfer += iprot->skip(ftype);
05405         }
05406         break;
05407       case 2:
05408         if (ftype == ::apache::thrift::protocol::T_STRUCT) {
05409           xfer += this->ia.read(iprot);
05410           this->__isset.ia = true;
05411         } else {
05412           xfer += iprot->skip(ftype);
05413         }
05414         break;
05415       default:
05416         xfer += iprot->skip(ftype);
05417         break;
05418     }
05419     xfer += iprot->readFieldEnd();
05420   }
05421 
05422   xfer += iprot->readStructEnd();
05423 
05424   return xfer;
05425 }
05426 
05427 uint32_t Hbase_mutateRowsTs_args::read(::apache::thrift::protocol::TProtocol* iprot) {
05428 
05429   uint32_t xfer = 0;
05430   std::string fname;
05431   ::apache::thrift::protocol::TType ftype;
05432   int16_t fid;
05433 
05434   xfer += iprot->readStructBegin(fname);
05435 
05436   using ::apache::thrift::protocol::TProtocolException;
05437 
05438 
05439   while (true)
05440   {
05441     xfer += iprot->readFieldBegin(fname, ftype, fid);
05442     if (ftype == ::apache::thrift::protocol::T_STOP) {
05443       break;
05444     }
05445     switch (fid)
05446     {
05447       case 1:
05448         if (ftype == ::apache::thrift::protocol::T_STRING) {
05449           xfer += iprot->readBinary(this->tableName);
05450           this->__isset.tableName = true;
05451         } else {
05452           xfer += iprot->skip(ftype);
05453         }
05454         break;
05455       case 2:
05456         if (ftype == ::apache::thrift::protocol::T_LIST) {
05457           {
05458             this->rowBatches.clear();
05459             uint32_t _size262;
05460             ::apache::thrift::protocol::TType _etype265;
05461             iprot->readListBegin(_etype265, _size262);
05462             this->rowBatches.resize(_size262);
05463             uint32_t _i266;
05464             for (_i266 = 0; _i266 < _size262; ++_i266)
05465             {
05466               xfer += this->rowBatches[_i266].read(iprot);
05467             }
05468             iprot->readListEnd();
05469           }
05470           this->__isset.rowBatches = true;
05471         } else {
05472           xfer += iprot->skip(ftype);
05473         }
05474         break;
05475       case 3:
05476         if (ftype == ::apache::thrift::protocol::T_I64) {
05477           xfer += iprot->readI64(this->timestamp);
05478           this->__isset.timestamp = true;
05479         } else {
05480           xfer += iprot->skip(ftype);
05481         }
05482         break;
05483       default:
05484         xfer += iprot->skip(ftype);
05485         break;
05486     }
05487     xfer += iprot->readFieldEnd();
05488   }
05489 
05490   xfer += iprot->readStructEnd();
05491 
05492   return xfer;
05493 }
05494 
05495 uint32_t Hbase_mutateRowsTs_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
05496   uint32_t xfer = 0;
05497   xfer += oprot->writeStructBegin("Hbase_mutateRowsTs_args");
05498   xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
05499   xfer += oprot->writeBinary(this->tableName);
05500   xfer += oprot->writeFieldEnd();
05501   xfer += oprot->writeFieldBegin("rowBatches", ::apache::thrift::protocol::T_LIST, 2);
05502   {
05503     xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->rowBatches.size()));
05504     std::vector<BatchMutation> ::const_iterator _iter267;
05505     for (_iter267 = this->rowBatches.begin(); _iter267 != this->rowBatches.end(); ++_iter267)
05506     {
05507       xfer += (*_iter267).write(oprot);
05508     }
05509     xfer += oprot->writeListEnd();
05510   }
05511   xfer += oprot->writeFieldEnd();
05512   xfer += oprot->writeFieldBegin("timestamp", ::apache::thrift::protocol::T_I64, 3);
05513   xfer += oprot->writeI64(this->timestamp);
05514   xfer += oprot->writeFieldEnd();
05515   xfer += oprot->writeFieldStop();
05516   xfer += oprot->writeStructEnd();
05517   return xfer;
05518 }
05519 
05520 uint32_t Hbase_mutateRowsTs_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
05521   uint32_t xfer = 0;
05522   xfer += oprot->writeStructBegin("Hbase_mutateRowsTs_pargs");
05523   xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
05524   xfer += oprot->writeBinary((*(this->tableName)));
05525   xfer += oprot->writeFieldEnd();
05526   xfer += oprot->writeFieldBegin("rowBatches", ::apache::thrift::protocol::T_LIST, 2);
05527   {
05528     xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>((*(this->rowBatches)).size()));
05529     std::vector<BatchMutation> ::const_iterator _iter268;
05530     for (_iter268 = (*(this->rowBatches)).begin(); _iter268 != (*(this->rowBatches)).end(); ++_iter268)
05531     {
05532       xfer += (*_iter268).write(oprot);
05533     }
05534     xfer += oprot->writeListEnd();
05535   }
05536   xfer += oprot->writeFieldEnd();
05537   xfer += oprot->writeFieldBegin("timestamp", ::apache::thrift::protocol::T_I64, 3);
05538   xfer += oprot->writeI64((*(this->timestamp)));
05539   xfer += oprot->writeFieldEnd();
05540   xfer += oprot->writeFieldStop();
05541   xfer += oprot->writeStructEnd();
05542   return xfer;
05543 }
05544 
05545 uint32_t Hbase_mutateRowsTs_result::read(::apache::thrift::protocol::TProtocol* iprot) {
05546 
05547   uint32_t xfer = 0;
05548   std::string fname;
05549   ::apache::thrift::protocol::TType ftype;
05550   int16_t fid;
05551 
05552   xfer += iprot->readStructBegin(fname);
05553 
05554   using ::apache::thrift::protocol::TProtocolException;
05555 
05556 
05557   while (true)
05558   {
05559     xfer += iprot->readFieldBegin(fname, ftype, fid);
05560     if (ftype == ::apache::thrift::protocol::T_STOP) {
05561       break;
05562     }
05563     switch (fid)
05564     {
05565       case 1:
05566         if (ftype == ::apache::thrift::protocol::T_STRUCT) {
05567           xfer += this->io.read(iprot);
05568           this->__isset.io = true;
05569         } else {
05570           xfer += iprot->skip(ftype);
05571         }
05572         break;
05573       case 2:
05574         if (ftype == ::apache::thrift::protocol::T_STRUCT) {
05575           xfer += this->ia.read(iprot);
05576           this->__isset.ia = true;
05577         } else {
05578           xfer += iprot->skip(ftype);
05579         }
05580         break;
05581       default:
05582         xfer += iprot->skip(ftype);
05583         break;
05584     }
05585     xfer += iprot->readFieldEnd();
05586   }
05587 
05588   xfer += iprot->readStructEnd();
05589 
05590   return xfer;
05591 }
05592 
05593 uint32_t Hbase_mutateRowsTs_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
05594 
05595   uint32_t xfer = 0;
05596 
05597   xfer += oprot->writeStructBegin("Hbase_mutateRowsTs_result");
05598 
05599   if (this->__isset.io) {
05600     xfer += oprot->writeFieldBegin("io", ::apache::thrift::protocol::T_STRUCT, 1);
05601     xfer += this->io.write(oprot);
05602     xfer += oprot->writeFieldEnd();
05603   } else if (this->__isset.ia) {
05604     xfer += oprot->writeFieldBegin("ia", ::apache::thrift::protocol::T_STRUCT, 2);
05605     xfer += this->ia.write(oprot);
05606     xfer += oprot->writeFieldEnd();
05607   }
05608   xfer += oprot->writeFieldStop();
05609   xfer += oprot->writeStructEnd();
05610   return xfer;
05611 }
05612 
05613 uint32_t Hbase_mutateRowsTs_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
05614 
05615   uint32_t xfer = 0;
05616   std::string fname;
05617   ::apache::thrift::protocol::TType ftype;
05618   int16_t fid;
05619 
05620   xfer += iprot->readStructBegin(fname);
05621 
05622   using ::apache::thrift::protocol::TProtocolException;
05623 
05624 
05625   while (true)
05626   {
05627     xfer += iprot->readFieldBegin(fname, ftype, fid);
05628     if (ftype == ::apache::thrift::protocol::T_STOP) {
05629       break;
05630     }
05631     switch (fid)
05632     {
05633       case 1:
05634         if (ftype == ::apache::thrift::protocol::T_STRUCT) {
05635           xfer += this->io.read(iprot);
05636           this->__isset.io = true;
05637         } else {
05638           xfer += iprot->skip(ftype);
05639         }
05640         break;
05641       case 2:
05642         if (ftype == ::apache::thrift::protocol::T_STRUCT) {
05643           xfer += this->ia.read(iprot);
05644           this->__isset.ia = true;
05645         } else {
05646           xfer += iprot->skip(ftype);
05647         }
05648         break;
05649       default:
05650         xfer += iprot->skip(ftype);
05651         break;
05652     }
05653     xfer += iprot->readFieldEnd();
05654   }
05655 
05656   xfer += iprot->readStructEnd();
05657 
05658   return xfer;
05659 }
05660 
05661 uint32_t Hbase_atomicIncrement_args::read(::apache::thrift::protocol::TProtocol* iprot) {
05662 
05663   uint32_t xfer = 0;
05664   std::string fname;
05665   ::apache::thrift::protocol::TType ftype;
05666   int16_t fid;
05667 
05668   xfer += iprot->readStructBegin(fname);
05669 
05670   using ::apache::thrift::protocol::TProtocolException;
05671 
05672 
05673   while (true)
05674   {
05675     xfer += iprot->readFieldBegin(fname, ftype, fid);
05676     if (ftype == ::apache::thrift::protocol::T_STOP) {
05677       break;
05678     }
05679     switch (fid)
05680     {
05681       case 1:
05682         if (ftype == ::apache::thrift::protocol::T_STRING) {
05683           xfer += iprot->readBinary(this->tableName);
05684           this->__isset.tableName = true;
05685         } else {
05686           xfer += iprot->skip(ftype);
05687         }
05688         break;
05689       case 2:
05690         if (ftype == ::apache::thrift::protocol::T_STRING) {
05691           xfer += iprot->readBinary(this->row);
05692           this->__isset.row = true;
05693         } else {
05694           xfer += iprot->skip(ftype);
05695         }
05696         break;
05697       case 3:
05698         if (ftype == ::apache::thrift::protocol::T_STRING) {
05699           xfer += iprot->readBinary(this->column);
05700           this->__isset.column = true;
05701         } else {
05702           xfer += iprot->skip(ftype);
05703         }
05704         break;
05705       case 4:
05706         if (ftype == ::apache::thrift::protocol::T_I64) {
05707           xfer += iprot->readI64(this->value);
05708           this->__isset.value = true;
05709         } else {
05710           xfer += iprot->skip(ftype);
05711         }
05712         break;
05713       default:
05714         xfer += iprot->skip(ftype);
05715         break;
05716     }
05717     xfer += iprot->readFieldEnd();
05718   }
05719 
05720   xfer += iprot->readStructEnd();
05721 
05722   return xfer;
05723 }
05724 
05725 uint32_t Hbase_atomicIncrement_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
05726   uint32_t xfer = 0;
05727   xfer += oprot->writeStructBegin("Hbase_atomicIncrement_args");
05728   xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
05729   xfer += oprot->writeBinary(this->tableName);
05730   xfer += oprot->writeFieldEnd();
05731   xfer += oprot->writeFieldBegin("row", ::apache::thrift::protocol::T_STRING, 2);
05732   xfer += oprot->writeBinary(this->row);
05733   xfer += oprot->writeFieldEnd();
05734   xfer += oprot->writeFieldBegin("column", ::apache::thrift::protocol::T_STRING, 3);
05735   xfer += oprot->writeBinary(this->column);
05736   xfer += oprot->writeFieldEnd();
05737   xfer += oprot->writeFieldBegin("value", ::apache::thrift::protocol::T_I64, 4);
05738   xfer += oprot->writeI64(this->value);
05739   xfer += oprot->writeFieldEnd();
05740   xfer += oprot->writeFieldStop();
05741   xfer += oprot->writeStructEnd();
05742   return xfer;
05743 }
05744 
05745 uint32_t Hbase_atomicIncrement_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
05746   uint32_t xfer = 0;
05747   xfer += oprot->writeStructBegin("Hbase_atomicIncrement_pargs");
05748   xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
05749   xfer += oprot->writeBinary((*(this->tableName)));
05750   xfer += oprot->writeFieldEnd();
05751   xfer += oprot->writeFieldBegin("row", ::apache::thrift::protocol::T_STRING, 2);
05752   xfer += oprot->writeBinary((*(this->row)));
05753   xfer += oprot->writeFieldEnd();
05754   xfer += oprot->writeFieldBegin("column", ::apache::thrift::protocol::T_STRING, 3);
05755   xfer += oprot->writeBinary((*(this->column)));
05756   xfer += oprot->writeFieldEnd();
05757   xfer += oprot->writeFieldBegin("value", ::apache::thrift::protocol::T_I64, 4);
05758   xfer += oprot->writeI64((*(this->value)));
05759   xfer += oprot->writeFieldEnd();
05760   xfer += oprot->writeFieldStop();
05761   xfer += oprot->writeStructEnd();
05762   return xfer;
05763 }
05764 
05765 uint32_t Hbase_atomicIncrement_result::read(::apache::thrift::protocol::TProtocol* iprot) {
05766 
05767   uint32_t xfer = 0;
05768   std::string fname;
05769   ::apache::thrift::protocol::TType ftype;
05770   int16_t fid;
05771 
05772   xfer += iprot->readStructBegin(fname);
05773 
05774   using ::apache::thrift::protocol::TProtocolException;
05775 
05776 
05777   while (true)
05778   {
05779     xfer += iprot->readFieldBegin(fname, ftype, fid);
05780     if (ftype == ::apache::thrift::protocol::T_STOP) {
05781       break;
05782     }
05783     switch (fid)
05784     {
05785       case 0:
05786         if (ftype == ::apache::thrift::protocol::T_I64) {
05787           xfer += iprot->readI64(this->success);
05788           this->__isset.success = true;
05789         } else {
05790           xfer += iprot->skip(ftype);
05791         }
05792         break;
05793       case 1:
05794         if (ftype == ::apache::thrift::protocol::T_STRUCT) {
05795           xfer += this->io.read(iprot);
05796           this->__isset.io = true;
05797         } else {
05798           xfer += iprot->skip(ftype);
05799         }
05800         break;
05801       case 2:
05802         if (ftype == ::apache::thrift::protocol::T_STRUCT) {
05803           xfer += this->ia.read(iprot);
05804           this->__isset.ia = true;
05805         } else {
05806           xfer += iprot->skip(ftype);
05807         }
05808         break;
05809       default:
05810         xfer += iprot->skip(ftype);
05811         break;
05812     }
05813     xfer += iprot->readFieldEnd();
05814   }
05815 
05816   xfer += iprot->readStructEnd();
05817 
05818   return xfer;
05819 }
05820 
05821 uint32_t Hbase_atomicIncrement_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
05822 
05823   uint32_t xfer = 0;
05824 
05825   xfer += oprot->writeStructBegin("Hbase_atomicIncrement_result");
05826 
05827   if (this->__isset.success) {
05828     xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_I64, 0);
05829     xfer += oprot->writeI64(this->success);
05830     xfer += oprot->writeFieldEnd();
05831   } else if (this->__isset.io) {
05832     xfer += oprot->writeFieldBegin("io", ::apache::thrift::protocol::T_STRUCT, 1);
05833     xfer += this->io.write(oprot);
05834     xfer += oprot->writeFieldEnd();
05835   } else if (this->__isset.ia) {
05836     xfer += oprot->writeFieldBegin("ia", ::apache::thrift::protocol::T_STRUCT, 2);
05837     xfer += this->ia.write(oprot);
05838     xfer += oprot->writeFieldEnd();
05839   }
05840   xfer += oprot->writeFieldStop();
05841   xfer += oprot->writeStructEnd();
05842   return xfer;
05843 }
05844 
05845 uint32_t Hbase_atomicIncrement_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
05846 
05847   uint32_t xfer = 0;
05848   std::string fname;
05849   ::apache::thrift::protocol::TType ftype;
05850   int16_t fid;
05851 
05852   xfer += iprot->readStructBegin(fname);
05853 
05854   using ::apache::thrift::protocol::TProtocolException;
05855 
05856 
05857   while (true)
05858   {
05859     xfer += iprot->readFieldBegin(fname, ftype, fid);
05860     if (ftype == ::apache::thrift::protocol::T_STOP) {
05861       break;
05862     }
05863     switch (fid)
05864     {
05865       case 0:
05866         if (ftype == ::apache::thrift::protocol::T_I64) {
05867           xfer += iprot->readI64((*(this->success)));
05868           this->__isset.success = true;
05869         } else {
05870           xfer += iprot->skip(ftype);
05871         }
05872         break;
05873       case 1:
05874         if (ftype == ::apache::thrift::protocol::T_STRUCT) {
05875           xfer += this->io.read(iprot);
05876           this->__isset.io = true;
05877         } else {
05878           xfer += iprot->skip(ftype);
05879         }
05880         break;
05881       case 2:
05882         if (ftype == ::apache::thrift::protocol::T_STRUCT) {
05883           xfer += this->ia.read(iprot);
05884           this->__isset.ia = true;
05885         } else {
05886           xfer += iprot->skip(ftype);
05887         }
05888         break;
05889       default:
05890         xfer += iprot->skip(ftype);
05891         break;
05892     }
05893     xfer += iprot->readFieldEnd();
05894   }
05895 
05896   xfer += iprot->readStructEnd();
05897 
05898   return xfer;
05899 }
05900 
05901 uint32_t Hbase_deleteAll_args::read(::apache::thrift::protocol::TProtocol* iprot) {
05902 
05903   uint32_t xfer = 0;
05904   std::string fname;
05905   ::apache::thrift::protocol::TType ftype;
05906   int16_t fid;
05907 
05908   xfer += iprot->readStructBegin(fname);
05909 
05910   using ::apache::thrift::protocol::TProtocolException;
05911 
05912 
05913   while (true)
05914   {
05915     xfer += iprot->readFieldBegin(fname, ftype, fid);
05916     if (ftype == ::apache::thrift::protocol::T_STOP) {
05917       break;
05918     }
05919     switch (fid)
05920     {
05921       case 1:
05922         if (ftype == ::apache::thrift::protocol::T_STRING) {
05923           xfer += iprot->readBinary(this->tableName);
05924           this->__isset.tableName = true;
05925         } else {
05926           xfer += iprot->skip(ftype);
05927         }
05928         break;
05929       case 2:
05930         if (ftype == ::apache::thrift::protocol::T_STRING) {
05931           xfer += iprot->readBinary(this->row);
05932           this->__isset.row = true;
05933         } else {
05934           xfer += iprot->skip(ftype);
05935         }
05936         break;
05937       case 3:
05938         if (ftype == ::apache::thrift::protocol::T_STRING) {
05939           xfer += iprot->readBinary(this->column);
05940           this->__isset.column = true;
05941         } else {
05942           xfer += iprot->skip(ftype);
05943         }
05944         break;
05945       default:
05946         xfer += iprot->skip(ftype);
05947         break;
05948     }
05949     xfer += iprot->readFieldEnd();
05950   }
05951 
05952   xfer += iprot->readStructEnd();
05953 
05954   return xfer;
05955 }
05956 
05957 uint32_t Hbase_deleteAll_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
05958   uint32_t xfer = 0;
05959   xfer += oprot->writeStructBegin("Hbase_deleteAll_args");
05960   xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
05961   xfer += oprot->writeBinary(this->tableName);
05962   xfer += oprot->writeFieldEnd();
05963   xfer += oprot->writeFieldBegin("row", ::apache::thrift::protocol::T_STRING, 2);
05964   xfer += oprot->writeBinary(this->row);
05965   xfer += oprot->writeFieldEnd();
05966   xfer += oprot->writeFieldBegin("column", ::apache::thrift::protocol::T_STRING, 3);
05967   xfer += oprot->writeBinary(this->column);
05968   xfer += oprot->writeFieldEnd();
05969   xfer += oprot->writeFieldStop();
05970   xfer += oprot->writeStructEnd();
05971   return xfer;
05972 }
05973 
05974 uint32_t Hbase_deleteAll_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
05975   uint32_t xfer = 0;
05976   xfer += oprot->writeStructBegin("Hbase_deleteAll_pargs");
05977   xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
05978   xfer += oprot->writeBinary((*(this->tableName)));
05979   xfer += oprot->writeFieldEnd();
05980   xfer += oprot->writeFieldBegin("row", ::apache::thrift::protocol::T_STRING, 2);
05981   xfer += oprot->writeBinary((*(this->row)));
05982   xfer += oprot->writeFieldEnd();
05983   xfer += oprot->writeFieldBegin("column", ::apache::thrift::protocol::T_STRING, 3);
05984   xfer += oprot->writeBinary((*(this->column)));
05985   xfer += oprot->writeFieldEnd();
05986   xfer += oprot->writeFieldStop();
05987   xfer += oprot->writeStructEnd();
05988   return xfer;
05989 }
05990 
05991 uint32_t Hbase_deleteAll_result::read(::apache::thrift::protocol::TProtocol* iprot) {
05992 
05993   uint32_t xfer = 0;
05994   std::string fname;
05995   ::apache::thrift::protocol::TType ftype;
05996   int16_t fid;
05997 
05998   xfer += iprot->readStructBegin(fname);
05999 
06000   using ::apache::thrift::protocol::TProtocolException;
06001 
06002 
06003   while (true)
06004   {
06005     xfer += iprot->readFieldBegin(fname, ftype, fid);
06006     if (ftype == ::apache::thrift::protocol::T_STOP) {
06007       break;
06008     }
06009     switch (fid)
06010     {
06011       case 1:
06012         if (ftype == ::apache::thrift::protocol::T_STRUCT) {
06013           xfer += this->io.read(iprot);
06014           this->__isset.io = true;
06015         } else {
06016           xfer += iprot->skip(ftype);
06017         }
06018         break;
06019       default:
06020         xfer += iprot->skip(ftype);
06021         break;
06022     }
06023     xfer += iprot->readFieldEnd();
06024   }
06025 
06026   xfer += iprot->readStructEnd();
06027 
06028   return xfer;
06029 }
06030 
06031 uint32_t Hbase_deleteAll_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
06032 
06033   uint32_t xfer = 0;
06034 
06035   xfer += oprot->writeStructBegin("Hbase_deleteAll_result");
06036 
06037   if (this->__isset.io) {
06038     xfer += oprot->writeFieldBegin("io", ::apache::thrift::protocol::T_STRUCT, 1);
06039     xfer += this->io.write(oprot);
06040     xfer += oprot->writeFieldEnd();
06041   }
06042   xfer += oprot->writeFieldStop();
06043   xfer += oprot->writeStructEnd();
06044   return xfer;
06045 }
06046 
06047 uint32_t Hbase_deleteAll_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
06048 
06049   uint32_t xfer = 0;
06050   std::string fname;
06051   ::apache::thrift::protocol::TType ftype;
06052   int16_t fid;
06053 
06054   xfer += iprot->readStructBegin(fname);
06055 
06056   using ::apache::thrift::protocol::TProtocolException;
06057 
06058 
06059   while (true)
06060   {
06061     xfer += iprot->readFieldBegin(fname, ftype, fid);
06062     if (ftype == ::apache::thrift::protocol::T_STOP) {
06063       break;
06064     }
06065     switch (fid)
06066     {
06067       case 1:
06068         if (ftype == ::apache::thrift::protocol::T_STRUCT) {
06069           xfer += this->io.read(iprot);
06070           this->__isset.io = true;
06071         } else {
06072           xfer += iprot->skip(ftype);
06073         }
06074         break;
06075       default:
06076         xfer += iprot->skip(ftype);
06077         break;
06078     }
06079     xfer += iprot->readFieldEnd();
06080   }
06081 
06082   xfer += iprot->readStructEnd();
06083 
06084   return xfer;
06085 }
06086 
06087 uint32_t Hbase_deleteAllTs_args::read(::apache::thrift::protocol::TProtocol* iprot) {
06088 
06089   uint32_t xfer = 0;
06090   std::string fname;
06091   ::apache::thrift::protocol::TType ftype;
06092   int16_t fid;
06093 
06094   xfer += iprot->readStructBegin(fname);
06095 
06096   using ::apache::thrift::protocol::TProtocolException;
06097 
06098 
06099   while (true)
06100   {
06101     xfer += iprot->readFieldBegin(fname, ftype, fid);
06102     if (ftype == ::apache::thrift::protocol::T_STOP) {
06103       break;
06104     }
06105     switch (fid)
06106     {
06107       case 1:
06108         if (ftype == ::apache::thrift::protocol::T_STRING) {
06109           xfer += iprot->readBinary(this->tableName);
06110           this->__isset.tableName = true;
06111         } else {
06112           xfer += iprot->skip(ftype);
06113         }
06114         break;
06115       case 2:
06116         if (ftype == ::apache::thrift::protocol::T_STRING) {
06117           xfer += iprot->readBinary(this->row);
06118           this->__isset.row = true;
06119         } else {
06120           xfer += iprot->skip(ftype);
06121         }
06122         break;
06123       case 3:
06124         if (ftype == ::apache::thrift::protocol::T_STRING) {
06125           xfer += iprot->readBinary(this->column);
06126           this->__isset.column = true;
06127         } else {
06128           xfer += iprot->skip(ftype);
06129         }
06130         break;
06131       case 4:
06132         if (ftype == ::apache::thrift::protocol::T_I64) {
06133           xfer += iprot->readI64(this->timestamp);
06134           this->__isset.timestamp = true;
06135         } else {
06136           xfer += iprot->skip(ftype);
06137         }
06138         break;
06139       default:
06140         xfer += iprot->skip(ftype);
06141         break;
06142     }
06143     xfer += iprot->readFieldEnd();
06144   }
06145 
06146   xfer += iprot->readStructEnd();
06147 
06148   return xfer;
06149 }
06150 
06151 uint32_t Hbase_deleteAllTs_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
06152   uint32_t xfer = 0;
06153   xfer += oprot->writeStructBegin("Hbase_deleteAllTs_args");
06154   xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
06155   xfer += oprot->writeBinary(this->tableName);
06156   xfer += oprot->writeFieldEnd();
06157   xfer += oprot->writeFieldBegin("row", ::apache::thrift::protocol::T_STRING, 2);
06158   xfer += oprot->writeBinary(this->row);
06159   xfer += oprot->writeFieldEnd();
06160   xfer += oprot->writeFieldBegin("column", ::apache::thrift::protocol::T_STRING, 3);
06161   xfer += oprot->writeBinary(this->column);
06162   xfer += oprot->writeFieldEnd();
06163   xfer += oprot->writeFieldBegin("timestamp", ::apache::thrift::protocol::T_I64, 4);
06164   xfer += oprot->writeI64(this->timestamp);
06165   xfer += oprot->writeFieldEnd();
06166   xfer += oprot->writeFieldStop();
06167   xfer += oprot->writeStructEnd();
06168   return xfer;
06169 }
06170 
06171 uint32_t Hbase_deleteAllTs_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
06172   uint32_t xfer = 0;
06173   xfer += oprot->writeStructBegin("Hbase_deleteAllTs_pargs");
06174   xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
06175   xfer += oprot->writeBinary((*(this->tableName)));
06176   xfer += oprot->writeFieldEnd();
06177   xfer += oprot->writeFieldBegin("row", ::apache::thrift::protocol::T_STRING, 2);
06178   xfer += oprot->writeBinary((*(this->row)));
06179   xfer += oprot->writeFieldEnd();
06180   xfer += oprot->writeFieldBegin("column", ::apache::thrift::protocol::T_STRING, 3);
06181   xfer += oprot->writeBinary((*(this->column)));
06182   xfer += oprot->writeFieldEnd();
06183   xfer += oprot->writeFieldBegin("timestamp", ::apache::thrift::protocol::T_I64, 4);
06184   xfer += oprot->writeI64((*(this->timestamp)));
06185   xfer += oprot->writeFieldEnd();
06186   xfer += oprot->writeFieldStop();
06187   xfer += oprot->writeStructEnd();
06188   return xfer;
06189 }
06190 
06191 uint32_t Hbase_deleteAllTs_result::read(::apache::thrift::protocol::TProtocol* iprot) {
06192 
06193   uint32_t xfer = 0;
06194   std::string fname;
06195   ::apache::thrift::protocol::TType ftype;
06196   int16_t fid;
06197 
06198   xfer += iprot->readStructBegin(fname);
06199 
06200   using ::apache::thrift::protocol::TProtocolException;
06201 
06202 
06203   while (true)
06204   {
06205     xfer += iprot->readFieldBegin(fname, ftype, fid);
06206     if (ftype == ::apache::thrift::protocol::T_STOP) {
06207       break;
06208     }
06209     switch (fid)
06210     {
06211       case 1:
06212         if (ftype == ::apache::thrift::protocol::T_STRUCT) {
06213           xfer += this->io.read(iprot);
06214           this->__isset.io = true;
06215         } else {
06216           xfer += iprot->skip(ftype);
06217         }
06218         break;
06219       default:
06220         xfer += iprot->skip(ftype);
06221         break;
06222     }
06223     xfer += iprot->readFieldEnd();
06224   }
06225 
06226   xfer += iprot->readStructEnd();
06227 
06228   return xfer;
06229 }
06230 
06231 uint32_t Hbase_deleteAllTs_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
06232 
06233   uint32_t xfer = 0;
06234 
06235   xfer += oprot->writeStructBegin("Hbase_deleteAllTs_result");
06236 
06237   if (this->__isset.io) {
06238     xfer += oprot->writeFieldBegin("io", ::apache::thrift::protocol::T_STRUCT, 1);
06239     xfer += this->io.write(oprot);
06240     xfer += oprot->writeFieldEnd();
06241   }
06242   xfer += oprot->writeFieldStop();
06243   xfer += oprot->writeStructEnd();
06244   return xfer;
06245 }
06246 
06247 uint32_t Hbase_deleteAllTs_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
06248 
06249   uint32_t xfer = 0;
06250   std::string fname;
06251   ::apache::thrift::protocol::TType ftype;
06252   int16_t fid;
06253 
06254   xfer += iprot->readStructBegin(fname);
06255 
06256   using ::apache::thrift::protocol::TProtocolException;
06257 
06258 
06259   while (true)
06260   {
06261     xfer += iprot->readFieldBegin(fname, ftype, fid);
06262     if (ftype == ::apache::thrift::protocol::T_STOP) {
06263       break;
06264     }
06265     switch (fid)
06266     {
06267       case 1:
06268         if (ftype == ::apache::thrift::protocol::T_STRUCT) {
06269           xfer += this->io.read(iprot);
06270           this->__isset.io = true;
06271         } else {
06272           xfer += iprot->skip(ftype);
06273         }
06274         break;
06275       default:
06276         xfer += iprot->skip(ftype);
06277         break;
06278     }
06279     xfer += iprot->readFieldEnd();
06280   }
06281 
06282   xfer += iprot->readStructEnd();
06283 
06284   return xfer;
06285 }
06286 
06287 uint32_t Hbase_deleteAllRow_args::read(::apache::thrift::protocol::TProtocol* iprot) {
06288 
06289   uint32_t xfer = 0;
06290   std::string fname;
06291   ::apache::thrift::protocol::TType ftype;
06292   int16_t fid;
06293 
06294   xfer += iprot->readStructBegin(fname);
06295 
06296   using ::apache::thrift::protocol::TProtocolException;
06297 
06298 
06299   while (true)
06300   {
06301     xfer += iprot->readFieldBegin(fname, ftype, fid);
06302     if (ftype == ::apache::thrift::protocol::T_STOP) {
06303       break;
06304     }
06305     switch (fid)
06306     {
06307       case 1:
06308         if (ftype == ::apache::thrift::protocol::T_STRING) {
06309           xfer += iprot->readBinary(this->tableName);
06310           this->__isset.tableName = true;
06311         } else {
06312           xfer += iprot->skip(ftype);
06313         }
06314         break;
06315       case 2:
06316         if (ftype == ::apache::thrift::protocol::T_STRING) {
06317           xfer += iprot->readBinary(this->row);
06318           this->__isset.row = true;
06319         } else {
06320           xfer += iprot->skip(ftype);
06321         }
06322         break;
06323       default:
06324         xfer += iprot->skip(ftype);
06325         break;
06326     }
06327     xfer += iprot->readFieldEnd();
06328   }
06329 
06330   xfer += iprot->readStructEnd();
06331 
06332   return xfer;
06333 }
06334 
06335 uint32_t Hbase_deleteAllRow_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
06336   uint32_t xfer = 0;
06337   xfer += oprot->writeStructBegin("Hbase_deleteAllRow_args");
06338   xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
06339   xfer += oprot->writeBinary(this->tableName);
06340   xfer += oprot->writeFieldEnd();
06341   xfer += oprot->writeFieldBegin("row", ::apache::thrift::protocol::T_STRING, 2);
06342   xfer += oprot->writeBinary(this->row);
06343   xfer += oprot->writeFieldEnd();
06344   xfer += oprot->writeFieldStop();
06345   xfer += oprot->writeStructEnd();
06346   return xfer;
06347 }
06348 
06349 uint32_t Hbase_deleteAllRow_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
06350   uint32_t xfer = 0;
06351   xfer += oprot->writeStructBegin("Hbase_deleteAllRow_pargs");
06352   xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
06353   xfer += oprot->writeBinary((*(this->tableName)));
06354   xfer += oprot->writeFieldEnd();
06355   xfer += oprot->writeFieldBegin("row", ::apache::thrift::protocol::T_STRING, 2);
06356   xfer += oprot->writeBinary((*(this->row)));
06357   xfer += oprot->writeFieldEnd();
06358   xfer += oprot->writeFieldStop();
06359   xfer += oprot->writeStructEnd();
06360   return xfer;
06361 }
06362 
06363 uint32_t Hbase_deleteAllRow_result::read(::apache::thrift::protocol::TProtocol* iprot) {
06364 
06365   uint32_t xfer = 0;
06366   std::string fname;
06367   ::apache::thrift::protocol::TType ftype;
06368   int16_t fid;
06369 
06370   xfer += iprot->readStructBegin(fname);
06371 
06372   using ::apache::thrift::protocol::TProtocolException;
06373 
06374 
06375   while (true)
06376   {
06377     xfer += iprot->readFieldBegin(fname, ftype, fid);
06378     if (ftype == ::apache::thrift::protocol::T_STOP) {
06379       break;
06380     }
06381     switch (fid)
06382     {
06383       case 1:
06384         if (ftype == ::apache::thrift::protocol::T_STRUCT) {
06385           xfer += this->io.read(iprot);
06386           this->__isset.io = true;
06387         } else {
06388           xfer += iprot->skip(ftype);
06389         }
06390         break;
06391       default:
06392         xfer += iprot->skip(ftype);
06393         break;
06394     }
06395     xfer += iprot->readFieldEnd();
06396   }
06397 
06398   xfer += iprot->readStructEnd();
06399 
06400   return xfer;
06401 }
06402 
06403 uint32_t Hbase_deleteAllRow_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
06404 
06405   uint32_t xfer = 0;
06406 
06407   xfer += oprot->writeStructBegin("Hbase_deleteAllRow_result");
06408 
06409   if (this->__isset.io) {
06410     xfer += oprot->writeFieldBegin("io", ::apache::thrift::protocol::T_STRUCT, 1);
06411     xfer += this->io.write(oprot);
06412     xfer += oprot->writeFieldEnd();
06413   }
06414   xfer += oprot->writeFieldStop();
06415   xfer += oprot->writeStructEnd();
06416   return xfer;
06417 }
06418 
06419 uint32_t Hbase_deleteAllRow_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
06420 
06421   uint32_t xfer = 0;
06422   std::string fname;
06423   ::apache::thrift::protocol::TType ftype;
06424   int16_t fid;
06425 
06426   xfer += iprot->readStructBegin(fname);
06427 
06428   using ::apache::thrift::protocol::TProtocolException;
06429 
06430 
06431   while (true)
06432   {
06433     xfer += iprot->readFieldBegin(fname, ftype, fid);
06434     if (ftype == ::apache::thrift::protocol::T_STOP) {
06435       break;
06436     }
06437     switch (fid)
06438     {
06439       case 1:
06440         if (ftype == ::apache::thrift::protocol::T_STRUCT) {
06441           xfer += this->io.read(iprot);
06442           this->__isset.io = true;
06443         } else {
06444           xfer += iprot->skip(ftype);
06445         }
06446         break;
06447       default:
06448         xfer += iprot->skip(ftype);
06449         break;
06450     }
06451     xfer += iprot->readFieldEnd();
06452   }
06453 
06454   xfer += iprot->readStructEnd();
06455 
06456   return xfer;
06457 }
06458 
06459 uint32_t Hbase_deleteAllRowTs_args::read(::apache::thrift::protocol::TProtocol* iprot) {
06460 
06461   uint32_t xfer = 0;
06462   std::string fname;
06463   ::apache::thrift::protocol::TType ftype;
06464   int16_t fid;
06465 
06466   xfer += iprot->readStructBegin(fname);
06467 
06468   using ::apache::thrift::protocol::TProtocolException;
06469 
06470 
06471   while (true)
06472   {
06473     xfer += iprot->readFieldBegin(fname, ftype, fid);
06474     if (ftype == ::apache::thrift::protocol::T_STOP) {
06475       break;
06476     }
06477     switch (fid)
06478     {
06479       case 1:
06480         if (ftype == ::apache::thrift::protocol::T_STRING) {
06481           xfer += iprot->readBinary(this->tableName);
06482           this->__isset.tableName = true;
06483         } else {
06484           xfer += iprot->skip(ftype);
06485         }
06486         break;
06487       case 2:
06488         if (ftype == ::apache::thrift::protocol::T_STRING) {
06489           xfer += iprot->readBinary(this->row);
06490           this->__isset.row = true;
06491         } else {
06492           xfer += iprot->skip(ftype);
06493         }
06494         break;
06495       case 3:
06496         if (ftype == ::apache::thrift::protocol::T_I64) {
06497           xfer += iprot->readI64(this->timestamp);
06498           this->__isset.timestamp = true;
06499         } else {
06500           xfer += iprot->skip(ftype);
06501         }
06502         break;
06503       default:
06504         xfer += iprot->skip(ftype);
06505         break;
06506     }
06507     xfer += iprot->readFieldEnd();
06508   }
06509 
06510   xfer += iprot->readStructEnd();
06511 
06512   return xfer;
06513 }
06514 
06515 uint32_t Hbase_deleteAllRowTs_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
06516   uint32_t xfer = 0;
06517   xfer += oprot->writeStructBegin("Hbase_deleteAllRowTs_args");
06518   xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
06519   xfer += oprot->writeBinary(this->tableName);
06520   xfer += oprot->writeFieldEnd();
06521   xfer += oprot->writeFieldBegin("row", ::apache::thrift::protocol::T_STRING, 2);
06522   xfer += oprot->writeBinary(this->row);
06523   xfer += oprot->writeFieldEnd();
06524   xfer += oprot->writeFieldBegin("timestamp", ::apache::thrift::protocol::T_I64, 3);
06525   xfer += oprot->writeI64(this->timestamp);
06526   xfer += oprot->writeFieldEnd();
06527   xfer += oprot->writeFieldStop();
06528   xfer += oprot->writeStructEnd();
06529   return xfer;
06530 }
06531 
06532 uint32_t Hbase_deleteAllRowTs_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
06533   uint32_t xfer = 0;
06534   xfer += oprot->writeStructBegin("Hbase_deleteAllRowTs_pargs");
06535   xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
06536   xfer += oprot->writeBinary((*(this->tableName)));
06537   xfer += oprot->writeFieldEnd();
06538   xfer += oprot->writeFieldBegin("row", ::apache::thrift::protocol::T_STRING, 2);
06539   xfer += oprot->writeBinary((*(this->row)));
06540   xfer += oprot->writeFieldEnd();
06541   xfer += oprot->writeFieldBegin("timestamp", ::apache::thrift::protocol::T_I64, 3);
06542   xfer += oprot->writeI64((*(this->timestamp)));
06543   xfer += oprot->writeFieldEnd();
06544   xfer += oprot->writeFieldStop();
06545   xfer += oprot->writeStructEnd();
06546   return xfer;
06547 }
06548 
06549 uint32_t Hbase_deleteAllRowTs_result::read(::apache::thrift::protocol::TProtocol* iprot) {
06550 
06551   uint32_t xfer = 0;
06552   std::string fname;
06553   ::apache::thrift::protocol::TType ftype;
06554   int16_t fid;
06555 
06556   xfer += iprot->readStructBegin(fname);
06557 
06558   using ::apache::thrift::protocol::TProtocolException;
06559 
06560 
06561   while (true)
06562   {
06563     xfer += iprot->readFieldBegin(fname, ftype, fid);
06564     if (ftype == ::apache::thrift::protocol::T_STOP) {
06565       break;
06566     }
06567     switch (fid)
06568     {
06569       case 1:
06570         if (ftype == ::apache::thrift::protocol::T_STRUCT) {
06571           xfer += this->io.read(iprot);
06572           this->__isset.io = true;
06573         } else {
06574           xfer += iprot->skip(ftype);
06575         }
06576         break;
06577       default:
06578         xfer += iprot->skip(ftype);
06579         break;
06580     }
06581     xfer += iprot->readFieldEnd();
06582   }
06583 
06584   xfer += iprot->readStructEnd();
06585 
06586   return xfer;
06587 }
06588 
06589 uint32_t Hbase_deleteAllRowTs_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
06590 
06591   uint32_t xfer = 0;
06592 
06593   xfer += oprot->writeStructBegin("Hbase_deleteAllRowTs_result");
06594 
06595   if (this->__isset.io) {
06596     xfer += oprot->writeFieldBegin("io", ::apache::thrift::protocol::T_STRUCT, 1);
06597     xfer += this->io.write(oprot);
06598     xfer += oprot->writeFieldEnd();
06599   }
06600   xfer += oprot->writeFieldStop();
06601   xfer += oprot->writeStructEnd();
06602   return xfer;
06603 }
06604 
06605 uint32_t Hbase_deleteAllRowTs_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
06606 
06607   uint32_t xfer = 0;
06608   std::string fname;
06609   ::apache::thrift::protocol::TType ftype;
06610   int16_t fid;
06611 
06612   xfer += iprot->readStructBegin(fname);
06613 
06614   using ::apache::thrift::protocol::TProtocolException;
06615 
06616 
06617   while (true)
06618   {
06619     xfer += iprot->readFieldBegin(fname, ftype, fid);
06620     if (ftype == ::apache::thrift::protocol::T_STOP) {
06621       break;
06622     }
06623     switch (fid)
06624     {
06625       case 1:
06626         if (ftype == ::apache::thrift::protocol::T_STRUCT) {
06627           xfer += this->io.read(iprot);
06628           this->__isset.io = true;
06629         } else {
06630           xfer += iprot->skip(ftype);
06631         }
06632         break;
06633       default:
06634         xfer += iprot->skip(ftype);
06635         break;
06636     }
06637     xfer += iprot->readFieldEnd();
06638   }
06639 
06640   xfer += iprot->readStructEnd();
06641 
06642   return xfer;
06643 }
06644 
06645 uint32_t Hbase_scannerOpenWithScan_args::read(::apache::thrift::protocol::TProtocol* iprot) {
06646 
06647   uint32_t xfer = 0;
06648   std::string fname;
06649   ::apache::thrift::protocol::TType ftype;
06650   int16_t fid;
06651 
06652   xfer += iprot->readStructBegin(fname);
06653 
06654   using ::apache::thrift::protocol::TProtocolException;
06655 
06656 
06657   while (true)
06658   {
06659     xfer += iprot->readFieldBegin(fname, ftype, fid);
06660     if (ftype == ::apache::thrift::protocol::T_STOP) {
06661       break;
06662     }
06663     switch (fid)
06664     {
06665       case 1:
06666         if (ftype == ::apache::thrift::protocol::T_STRING) {
06667           xfer += iprot->readBinary(this->tableName);
06668           this->__isset.tableName = true;
06669         } else {
06670           xfer += iprot->skip(ftype);
06671         }
06672         break;
06673       case 2:
06674         if (ftype == ::apache::thrift::protocol::T_STRUCT) {
06675           xfer += this->scan.read(iprot);
06676           this->__isset.scan = true;
06677         } else {
06678           xfer += iprot->skip(ftype);
06679         }
06680         break;
06681       default:
06682         xfer += iprot->skip(ftype);
06683         break;
06684     }
06685     xfer += iprot->readFieldEnd();
06686   }
06687 
06688   xfer += iprot->readStructEnd();
06689 
06690   return xfer;
06691 }
06692 
06693 uint32_t Hbase_scannerOpenWithScan_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
06694   uint32_t xfer = 0;
06695   xfer += oprot->writeStructBegin("Hbase_scannerOpenWithScan_args");
06696   xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
06697   xfer += oprot->writeBinary(this->tableName);
06698   xfer += oprot->writeFieldEnd();
06699   xfer += oprot->writeFieldBegin("scan", ::apache::thrift::protocol::T_STRUCT, 2);
06700   xfer += this->scan.write(oprot);
06701   xfer += oprot->writeFieldEnd();
06702   xfer += oprot->writeFieldStop();
06703   xfer += oprot->writeStructEnd();
06704   return xfer;
06705 }
06706 
06707 uint32_t Hbase_scannerOpenWithScan_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
06708   uint32_t xfer = 0;
06709   xfer += oprot->writeStructBegin("Hbase_scannerOpenWithScan_pargs");
06710   xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
06711   xfer += oprot->writeBinary((*(this->tableName)));
06712   xfer += oprot->writeFieldEnd();
06713   xfer += oprot->writeFieldBegin("scan", ::apache::thrift::protocol::T_STRUCT, 2);
06714   xfer += (*(this->scan)).write(oprot);
06715   xfer += oprot->writeFieldEnd();
06716   xfer += oprot->writeFieldStop();
06717   xfer += oprot->writeStructEnd();
06718   return xfer;
06719 }
06720 
06721 uint32_t Hbase_scannerOpenWithScan_result::read(::apache::thrift::protocol::TProtocol* iprot) {
06722 
06723   uint32_t xfer = 0;
06724   std::string fname;
06725   ::apache::thrift::protocol::TType ftype;
06726   int16_t fid;
06727 
06728   xfer += iprot->readStructBegin(fname);
06729 
06730   using ::apache::thrift::protocol::TProtocolException;
06731 
06732 
06733   while (true)
06734   {
06735     xfer += iprot->readFieldBegin(fname, ftype, fid);
06736     if (ftype == ::apache::thrift::protocol::T_STOP) {
06737       break;
06738     }
06739     switch (fid)
06740     {
06741       case 0:
06742         if (ftype == ::apache::thrift::protocol::T_I32) {
06743           xfer += iprot->readI32(this->success);
06744           this->__isset.success = true;
06745         } else {
06746           xfer += iprot->skip(ftype);
06747         }
06748         break;
06749       case 1:
06750         if (ftype == ::apache::thrift::protocol::T_STRUCT) {
06751           xfer += this->io.read(iprot);
06752           this->__isset.io = true;
06753         } else {
06754           xfer += iprot->skip(ftype);
06755         }
06756         break;
06757       default:
06758         xfer += iprot->skip(ftype);
06759         break;
06760     }
06761     xfer += iprot->readFieldEnd();
06762   }
06763 
06764   xfer += iprot->readStructEnd();
06765 
06766   return xfer;
06767 }
06768 
06769 uint32_t Hbase_scannerOpenWithScan_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
06770 
06771   uint32_t xfer = 0;
06772 
06773   xfer += oprot->writeStructBegin("Hbase_scannerOpenWithScan_result");
06774 
06775   if (this->__isset.success) {
06776     xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_I32, 0);
06777     xfer += oprot->writeI32(this->success);
06778     xfer += oprot->writeFieldEnd();
06779   } else if (this->__isset.io) {
06780     xfer += oprot->writeFieldBegin("io", ::apache::thrift::protocol::T_STRUCT, 1);
06781     xfer += this->io.write(oprot);
06782     xfer += oprot->writeFieldEnd();
06783   }
06784   xfer += oprot->writeFieldStop();
06785   xfer += oprot->writeStructEnd();
06786   return xfer;
06787 }
06788 
06789 uint32_t Hbase_scannerOpenWithScan_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
06790 
06791   uint32_t xfer = 0;
06792   std::string fname;
06793   ::apache::thrift::protocol::TType ftype;
06794   int16_t fid;
06795 
06796   xfer += iprot->readStructBegin(fname);
06797 
06798   using ::apache::thrift::protocol::TProtocolException;
06799 
06800 
06801   while (true)
06802   {
06803     xfer += iprot->readFieldBegin(fname, ftype, fid);
06804     if (ftype == ::apache::thrift::protocol::T_STOP) {
06805       break;
06806     }
06807     switch (fid)
06808     {
06809       case 0:
06810         if (ftype == ::apache::thrift::protocol::T_I32) {
06811           xfer += iprot->readI32((*(this->success)));
06812           this->__isset.success = true;
06813         } else {
06814           xfer += iprot->skip(ftype);
06815         }
06816         break;
06817       case 1:
06818         if (ftype == ::apache::thrift::protocol::T_STRUCT) {
06819           xfer += this->io.read(iprot);
06820           this->__isset.io = true;
06821         } else {
06822           xfer += iprot->skip(ftype);
06823         }
06824         break;
06825       default:
06826         xfer += iprot->skip(ftype);
06827         break;
06828     }
06829     xfer += iprot->readFieldEnd();
06830   }
06831 
06832   xfer += iprot->readStructEnd();
06833 
06834   return xfer;
06835 }
06836 
06837 uint32_t Hbase_scannerOpen_args::read(::apache::thrift::protocol::TProtocol* iprot) {
06838 
06839   uint32_t xfer = 0;
06840   std::string fname;
06841   ::apache::thrift::protocol::TType ftype;
06842   int16_t fid;
06843 
06844   xfer += iprot->readStructBegin(fname);
06845 
06846   using ::apache::thrift::protocol::TProtocolException;
06847 
06848 
06849   while (true)
06850   {
06851     xfer += iprot->readFieldBegin(fname, ftype, fid);
06852     if (ftype == ::apache::thrift::protocol::T_STOP) {
06853       break;
06854     }
06855     switch (fid)
06856     {
06857       case 1:
06858         if (ftype == ::apache::thrift::protocol::T_STRING) {
06859           xfer += iprot->readBinary(this->tableName);
06860           this->__isset.tableName = true;
06861         } else {
06862           xfer += iprot->skip(ftype);
06863         }
06864         break;
06865       case 2:
06866         if (ftype == ::apache::thrift::protocol::T_STRING) {
06867           xfer += iprot->readBinary(this->startRow);
06868           this->__isset.startRow = true;
06869         } else {
06870           xfer += iprot->skip(ftype);
06871         }
06872         break;
06873       case 3:
06874         if (ftype == ::apache::thrift::protocol::T_LIST) {
06875           {
06876             this->columns.clear();
06877             uint32_t _size269;
06878             ::apache::thrift::protocol::TType _etype272;
06879             iprot->readListBegin(_etype272, _size269);
06880             this->columns.resize(_size269);
06881             uint32_t _i273;
06882             for (_i273 = 0; _i273 < _size269; ++_i273)
06883             {
06884               xfer += iprot->readBinary(this->columns[_i273]);
06885             }
06886             iprot->readListEnd();
06887           }
06888           this->__isset.columns = true;
06889         } else {
06890           xfer += iprot->skip(ftype);
06891         }
06892         break;
06893       default:
06894         xfer += iprot->skip(ftype);
06895         break;
06896     }
06897     xfer += iprot->readFieldEnd();
06898   }
06899 
06900   xfer += iprot->readStructEnd();
06901 
06902   return xfer;
06903 }
06904 
06905 uint32_t Hbase_scannerOpen_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
06906   uint32_t xfer = 0;
06907   xfer += oprot->writeStructBegin("Hbase_scannerOpen_args");
06908   xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
06909   xfer += oprot->writeBinary(this->tableName);
06910   xfer += oprot->writeFieldEnd();
06911   xfer += oprot->writeFieldBegin("startRow", ::apache::thrift::protocol::T_STRING, 2);
06912   xfer += oprot->writeBinary(this->startRow);
06913   xfer += oprot->writeFieldEnd();
06914   xfer += oprot->writeFieldBegin("columns", ::apache::thrift::protocol::T_LIST, 3);
06915   {
06916     xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->columns.size()));
06917     std::vector<Text> ::const_iterator _iter274;
06918     for (_iter274 = this->columns.begin(); _iter274 != this->columns.end(); ++_iter274)
06919     {
06920       xfer += oprot->writeBinary((*_iter274));
06921     }
06922     xfer += oprot->writeListEnd();
06923   }
06924   xfer += oprot->writeFieldEnd();
06925   xfer += oprot->writeFieldStop();
06926   xfer += oprot->writeStructEnd();
06927   return xfer;
06928 }
06929 
06930 uint32_t Hbase_scannerOpen_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
06931   uint32_t xfer = 0;
06932   xfer += oprot->writeStructBegin("Hbase_scannerOpen_pargs");
06933   xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
06934   xfer += oprot->writeBinary((*(this->tableName)));
06935   xfer += oprot->writeFieldEnd();
06936   xfer += oprot->writeFieldBegin("startRow", ::apache::thrift::protocol::T_STRING, 2);
06937   xfer += oprot->writeBinary((*(this->startRow)));
06938   xfer += oprot->writeFieldEnd();
06939   xfer += oprot->writeFieldBegin("columns", ::apache::thrift::protocol::T_LIST, 3);
06940   {
06941     xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->columns)).size()));
06942     std::vector<Text> ::const_iterator _iter275;
06943     for (_iter275 = (*(this->columns)).begin(); _iter275 != (*(this->columns)).end(); ++_iter275)
06944     {
06945       xfer += oprot->writeBinary((*_iter275));
06946     }
06947     xfer += oprot->writeListEnd();
06948   }
06949   xfer += oprot->writeFieldEnd();
06950   xfer += oprot->writeFieldStop();
06951   xfer += oprot->writeStructEnd();
06952   return xfer;
06953 }
06954 
06955 uint32_t Hbase_scannerOpen_result::read(::apache::thrift::protocol::TProtocol* iprot) {
06956 
06957   uint32_t xfer = 0;
06958   std::string fname;
06959   ::apache::thrift::protocol::TType ftype;
06960   int16_t fid;
06961 
06962   xfer += iprot->readStructBegin(fname);
06963 
06964   using ::apache::thrift::protocol::TProtocolException;
06965 
06966 
06967   while (true)
06968   {
06969     xfer += iprot->readFieldBegin(fname, ftype, fid);
06970     if (ftype == ::apache::thrift::protocol::T_STOP) {
06971       break;
06972     }
06973     switch (fid)
06974     {
06975       case 0:
06976         if (ftype == ::apache::thrift::protocol::T_I32) {
06977           xfer += iprot->readI32(this->success);
06978           this->__isset.success = true;
06979         } else {
06980           xfer += iprot->skip(ftype);
06981         }
06982         break;
06983       case 1:
06984         if (ftype == ::apache::thrift::protocol::T_STRUCT) {
06985           xfer += this->io.read(iprot);
06986           this->__isset.io = true;
06987         } else {
06988           xfer += iprot->skip(ftype);
06989         }
06990         break;
06991       default:
06992         xfer += iprot->skip(ftype);
06993         break;
06994     }
06995     xfer += iprot->readFieldEnd();
06996   }
06997 
06998   xfer += iprot->readStructEnd();
06999 
07000   return xfer;
07001 }
07002 
07003 uint32_t Hbase_scannerOpen_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
07004 
07005   uint32_t xfer = 0;
07006 
07007   xfer += oprot->writeStructBegin("Hbase_scannerOpen_result");
07008 
07009   if (this->__isset.success) {
07010     xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_I32, 0);
07011     xfer += oprot->writeI32(this->success);
07012     xfer += oprot->writeFieldEnd();
07013   } else if (this->__isset.io) {
07014     xfer += oprot->writeFieldBegin("io", ::apache::thrift::protocol::T_STRUCT, 1);
07015     xfer += this->io.write(oprot);
07016     xfer += oprot->writeFieldEnd();
07017   }
07018   xfer += oprot->writeFieldStop();
07019   xfer += oprot->writeStructEnd();
07020   return xfer;
07021 }
07022 
07023 uint32_t Hbase_scannerOpen_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
07024 
07025   uint32_t xfer = 0;
07026   std::string fname;
07027   ::apache::thrift::protocol::TType ftype;
07028   int16_t fid;
07029 
07030   xfer += iprot->readStructBegin(fname);
07031 
07032   using ::apache::thrift::protocol::TProtocolException;
07033 
07034 
07035   while (true)
07036   {
07037     xfer += iprot->readFieldBegin(fname, ftype, fid);
07038     if (ftype == ::apache::thrift::protocol::T_STOP) {
07039       break;
07040     }
07041     switch (fid)
07042     {
07043       case 0:
07044         if (ftype == ::apache::thrift::protocol::T_I32) {
07045           xfer += iprot->readI32((*(this->success)));
07046           this->__isset.success = true;
07047         } else {
07048           xfer += iprot->skip(ftype);
07049         }
07050         break;
07051       case 1:
07052         if (ftype == ::apache::thrift::protocol::T_STRUCT) {
07053           xfer += this->io.read(iprot);
07054           this->__isset.io = true;
07055         } else {
07056           xfer += iprot->skip(ftype);
07057         }
07058         break;
07059       default:
07060         xfer += iprot->skip(ftype);
07061         break;
07062     }
07063     xfer += iprot->readFieldEnd();
07064   }
07065 
07066   xfer += iprot->readStructEnd();
07067 
07068   return xfer;
07069 }
07070 
07071 uint32_t Hbase_scannerOpenWithStop_args::read(::apache::thrift::protocol::TProtocol* iprot) {
07072 
07073   uint32_t xfer = 0;
07074   std::string fname;
07075   ::apache::thrift::protocol::TType ftype;
07076   int16_t fid;
07077 
07078   xfer += iprot->readStructBegin(fname);
07079 
07080   using ::apache::thrift::protocol::TProtocolException;
07081 
07082 
07083   while (true)
07084   {
07085     xfer += iprot->readFieldBegin(fname, ftype, fid);
07086     if (ftype == ::apache::thrift::protocol::T_STOP) {
07087       break;
07088     }
07089     switch (fid)
07090     {
07091       case 1:
07092         if (ftype == ::apache::thrift::protocol::T_STRING) {
07093           xfer += iprot->readBinary(this->tableName);
07094           this->__isset.tableName = true;
07095         } else {
07096           xfer += iprot->skip(ftype);
07097         }
07098         break;
07099       case 2:
07100         if (ftype == ::apache::thrift::protocol::T_STRING) {
07101           xfer += iprot->readBinary(this->startRow);
07102           this->__isset.startRow = true;
07103         } else {
07104           xfer += iprot->skip(ftype);
07105         }
07106         break;
07107       case 3:
07108         if (ftype == ::apache::thrift::protocol::T_STRING) {
07109           xfer += iprot->readBinary(this->stopRow);
07110           this->__isset.stopRow = true;
07111         } else {
07112           xfer += iprot->skip(ftype);
07113         }
07114         break;
07115       case 4:
07116         if (ftype == ::apache::thrift::protocol::T_LIST) {
07117           {
07118             this->columns.clear();
07119             uint32_t _size276;
07120             ::apache::thrift::protocol::TType _etype279;
07121             iprot->readListBegin(_etype279, _size276);
07122             this->columns.resize(_size276);
07123             uint32_t _i280;
07124             for (_i280 = 0; _i280 < _size276; ++_i280)
07125             {
07126               xfer += iprot->readBinary(this->columns[_i280]);
07127             }
07128             iprot->readListEnd();
07129           }
07130           this->__isset.columns = true;
07131         } else {
07132           xfer += iprot->skip(ftype);
07133         }
07134         break;
07135       default:
07136         xfer += iprot->skip(ftype);
07137         break;
07138     }
07139     xfer += iprot->readFieldEnd();
07140   }
07141 
07142   xfer += iprot->readStructEnd();
07143 
07144   return xfer;
07145 }
07146 
07147 uint32_t Hbase_scannerOpenWithStop_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
07148   uint32_t xfer = 0;
07149   xfer += oprot->writeStructBegin("Hbase_scannerOpenWithStop_args");
07150   xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
07151   xfer += oprot->writeBinary(this->tableName);
07152   xfer += oprot->writeFieldEnd();
07153   xfer += oprot->writeFieldBegin("startRow", ::apache::thrift::protocol::T_STRING, 2);
07154   xfer += oprot->writeBinary(this->startRow);
07155   xfer += oprot->writeFieldEnd();
07156   xfer += oprot->writeFieldBegin("stopRow", ::apache::thrift::protocol::T_STRING, 3);
07157   xfer += oprot->writeBinary(this->stopRow);
07158   xfer += oprot->writeFieldEnd();
07159   xfer += oprot->writeFieldBegin("columns", ::apache::thrift::protocol::T_LIST, 4);
07160   {
07161     xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->columns.size()));
07162     std::vector<Text> ::const_iterator _iter281;
07163     for (_iter281 = this->columns.begin(); _iter281 != this->columns.end(); ++_iter281)
07164     {
07165       xfer += oprot->writeBinary((*_iter281));
07166     }
07167     xfer += oprot->writeListEnd();
07168   }
07169   xfer += oprot->writeFieldEnd();
07170   xfer += oprot->writeFieldStop();
07171   xfer += oprot->writeStructEnd();
07172   return xfer;
07173 }
07174 
07175 uint32_t Hbase_scannerOpenWithStop_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
07176   uint32_t xfer = 0;
07177   xfer += oprot->writeStructBegin("Hbase_scannerOpenWithStop_pargs");
07178   xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
07179   xfer += oprot->writeBinary((*(this->tableName)));
07180   xfer += oprot->writeFieldEnd();
07181   xfer += oprot->writeFieldBegin("startRow", ::apache::thrift::protocol::T_STRING, 2);
07182   xfer += oprot->writeBinary((*(this->startRow)));
07183   xfer += oprot->writeFieldEnd();
07184   xfer += oprot->writeFieldBegin("stopRow", ::apache::thrift::protocol::T_STRING, 3);
07185   xfer += oprot->writeBinary((*(this->stopRow)));
07186   xfer += oprot->writeFieldEnd();
07187   xfer += oprot->writeFieldBegin("columns", ::apache::thrift::protocol::T_LIST, 4);
07188   {
07189     xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->columns)).size()));
07190     std::vector<Text> ::const_iterator _iter282;
07191     for (_iter282 = (*(this->columns)).begin(); _iter282 != (*(this->columns)).end(); ++_iter282)
07192     {
07193       xfer += oprot->writeBinary((*_iter282));
07194     }
07195     xfer += oprot->writeListEnd();
07196   }
07197   xfer += oprot->writeFieldEnd();
07198   xfer += oprot->writeFieldStop();
07199   xfer += oprot->writeStructEnd();
07200   return xfer;
07201 }
07202 
07203 uint32_t Hbase_scannerOpenWithStop_result::read(::apache::thrift::protocol::TProtocol* iprot) {
07204 
07205   uint32_t xfer = 0;
07206   std::string fname;
07207   ::apache::thrift::protocol::TType ftype;
07208   int16_t fid;
07209 
07210   xfer += iprot->readStructBegin(fname);
07211 
07212   using ::apache::thrift::protocol::TProtocolException;
07213 
07214 
07215   while (true)
07216   {
07217     xfer += iprot->readFieldBegin(fname, ftype, fid);
07218     if (ftype == ::apache::thrift::protocol::T_STOP) {
07219       break;
07220     }
07221     switch (fid)
07222     {
07223       case 0:
07224         if (ftype == ::apache::thrift::protocol::T_I32) {
07225           xfer += iprot->readI32(this->success);
07226           this->__isset.success = true;
07227         } else {
07228           xfer += iprot->skip(ftype);
07229         }
07230         break;
07231       case 1:
07232         if (ftype == ::apache::thrift::protocol::T_STRUCT) {
07233           xfer += this->io.read(iprot);
07234           this->__isset.io = true;
07235         } else {
07236           xfer += iprot->skip(ftype);
07237         }
07238         break;
07239       default:
07240         xfer += iprot->skip(ftype);
07241         break;
07242     }
07243     xfer += iprot->readFieldEnd();
07244   }
07245 
07246   xfer += iprot->readStructEnd();
07247 
07248   return xfer;
07249 }
07250 
07251 uint32_t Hbase_scannerOpenWithStop_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
07252 
07253   uint32_t xfer = 0;
07254 
07255   xfer += oprot->writeStructBegin("Hbase_scannerOpenWithStop_result");
07256 
07257   if (this->__isset.success) {
07258     xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_I32, 0);
07259     xfer += oprot->writeI32(this->success);
07260     xfer += oprot->writeFieldEnd();
07261   } else if (this->__isset.io) {
07262     xfer += oprot->writeFieldBegin("io", ::apache::thrift::protocol::T_STRUCT, 1);
07263     xfer += this->io.write(oprot);
07264     xfer += oprot->writeFieldEnd();
07265   }
07266   xfer += oprot->writeFieldStop();
07267   xfer += oprot->writeStructEnd();
07268   return xfer;
07269 }
07270 
07271 uint32_t Hbase_scannerOpenWithStop_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
07272 
07273   uint32_t xfer = 0;
07274   std::string fname;
07275   ::apache::thrift::protocol::TType ftype;
07276   int16_t fid;
07277 
07278   xfer += iprot->readStructBegin(fname);
07279 
07280   using ::apache::thrift::protocol::TProtocolException;
07281 
07282 
07283   while (true)
07284   {
07285     xfer += iprot->readFieldBegin(fname, ftype, fid);
07286     if (ftype == ::apache::thrift::protocol::T_STOP) {
07287       break;
07288     }
07289     switch (fid)
07290     {
07291       case 0:
07292         if (ftype == ::apache::thrift::protocol::T_I32) {
07293           xfer += iprot->readI32((*(this->success)));
07294           this->__isset.success = true;
07295         } else {
07296           xfer += iprot->skip(ftype);
07297         }
07298         break;
07299       case 1:
07300         if (ftype == ::apache::thrift::protocol::T_STRUCT) {
07301           xfer += this->io.read(iprot);
07302           this->__isset.io = true;
07303         } else {
07304           xfer += iprot->skip(ftype);
07305         }
07306         break;
07307       default:
07308         xfer += iprot->skip(ftype);
07309         break;
07310     }
07311     xfer += iprot->readFieldEnd();
07312   }
07313 
07314   xfer += iprot->readStructEnd();
07315 
07316   return xfer;
07317 }
07318 
07319 uint32_t Hbase_scannerOpenWithPrefix_args::read(::apache::thrift::protocol::TProtocol* iprot) {
07320 
07321   uint32_t xfer = 0;
07322   std::string fname;
07323   ::apache::thrift::protocol::TType ftype;
07324   int16_t fid;
07325 
07326   xfer += iprot->readStructBegin(fname);
07327 
07328   using ::apache::thrift::protocol::TProtocolException;
07329 
07330 
07331   while (true)
07332   {
07333     xfer += iprot->readFieldBegin(fname, ftype, fid);
07334     if (ftype == ::apache::thrift::protocol::T_STOP) {
07335       break;
07336     }
07337     switch (fid)
07338     {
07339       case 1:
07340         if (ftype == ::apache::thrift::protocol::T_STRING) {
07341           xfer += iprot->readBinary(this->tableName);
07342           this->__isset.tableName = true;
07343         } else {
07344           xfer += iprot->skip(ftype);
07345         }
07346         break;
07347       case 2:
07348         if (ftype == ::apache::thrift::protocol::T_STRING) {
07349           xfer += iprot->readBinary(this->startAndPrefix);
07350           this->__isset.startAndPrefix = true;
07351         } else {
07352           xfer += iprot->skip(ftype);
07353         }
07354         break;
07355       case 3:
07356         if (ftype == ::apache::thrift::protocol::T_LIST) {
07357           {
07358             this->columns.clear();
07359             uint32_t _size283;
07360             ::apache::thrift::protocol::TType _etype286;
07361             iprot->readListBegin(_etype286, _size283);
07362             this->columns.resize(_size283);
07363             uint32_t _i287;
07364             for (_i287 = 0; _i287 < _size283; ++_i287)
07365             {
07366               xfer += iprot->readBinary(this->columns[_i287]);
07367             }
07368             iprot->readListEnd();
07369           }
07370           this->__isset.columns = true;
07371         } else {
07372           xfer += iprot->skip(ftype);
07373         }
07374         break;
07375       default:
07376         xfer += iprot->skip(ftype);
07377         break;
07378     }
07379     xfer += iprot->readFieldEnd();
07380   }
07381 
07382   xfer += iprot->readStructEnd();
07383 
07384   return xfer;
07385 }
07386 
07387 uint32_t Hbase_scannerOpenWithPrefix_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
07388   uint32_t xfer = 0;
07389   xfer += oprot->writeStructBegin("Hbase_scannerOpenWithPrefix_args");
07390   xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
07391   xfer += oprot->writeBinary(this->tableName);
07392   xfer += oprot->writeFieldEnd();
07393   xfer += oprot->writeFieldBegin("startAndPrefix", ::apache::thrift::protocol::T_STRING, 2);
07394   xfer += oprot->writeBinary(this->startAndPrefix);
07395   xfer += oprot->writeFieldEnd();
07396   xfer += oprot->writeFieldBegin("columns", ::apache::thrift::protocol::T_LIST, 3);
07397   {
07398     xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->columns.size()));
07399     std::vector<Text> ::const_iterator _iter288;
07400     for (_iter288 = this->columns.begin(); _iter288 != this->columns.end(); ++_iter288)
07401     {
07402       xfer += oprot->writeBinary((*_iter288));
07403     }
07404     xfer += oprot->writeListEnd();
07405   }
07406   xfer += oprot->writeFieldEnd();
07407   xfer += oprot->writeFieldStop();
07408   xfer += oprot->writeStructEnd();
07409   return xfer;
07410 }
07411 
07412 uint32_t Hbase_scannerOpenWithPrefix_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
07413   uint32_t xfer = 0;
07414   xfer += oprot->writeStructBegin("Hbase_scannerOpenWithPrefix_pargs");
07415   xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
07416   xfer += oprot->writeBinary((*(this->tableName)));
07417   xfer += oprot->writeFieldEnd();
07418   xfer += oprot->writeFieldBegin("startAndPrefix", ::apache::thrift::protocol::T_STRING, 2);
07419   xfer += oprot->writeBinary((*(this->startAndPrefix)));
07420   xfer += oprot->writeFieldEnd();
07421   xfer += oprot->writeFieldBegin("columns", ::apache::thrift::protocol::T_LIST, 3);
07422   {
07423     xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->columns)).size()));
07424     std::vector<Text> ::const_iterator _iter289;
07425     for (_iter289 = (*(this->columns)).begin(); _iter289 != (*(this->columns)).end(); ++_iter289)
07426     {
07427       xfer += oprot->writeBinary((*_iter289));
07428     }
07429     xfer += oprot->writeListEnd();
07430   }
07431   xfer += oprot->writeFieldEnd();
07432   xfer += oprot->writeFieldStop();
07433   xfer += oprot->writeStructEnd();
07434   return xfer;
07435 }
07436 
07437 uint32_t Hbase_scannerOpenWithPrefix_result::read(::apache::thrift::protocol::TProtocol* iprot) {
07438 
07439   uint32_t xfer = 0;
07440   std::string fname;
07441   ::apache::thrift::protocol::TType ftype;
07442   int16_t fid;
07443 
07444   xfer += iprot->readStructBegin(fname);
07445 
07446   using ::apache::thrift::protocol::TProtocolException;
07447 
07448 
07449   while (true)
07450   {
07451     xfer += iprot->readFieldBegin(fname, ftype, fid);
07452     if (ftype == ::apache::thrift::protocol::T_STOP) {
07453       break;
07454     }
07455     switch (fid)
07456     {
07457       case 0:
07458         if (ftype == ::apache::thrift::protocol::T_I32) {
07459           xfer += iprot->readI32(this->success);
07460           this->__isset.success = true;
07461         } else {
07462           xfer += iprot->skip(ftype);
07463         }
07464         break;
07465       case 1:
07466         if (ftype == ::apache::thrift::protocol::T_STRUCT) {
07467           xfer += this->io.read(iprot);
07468           this->__isset.io = true;
07469         } else {
07470           xfer += iprot->skip(ftype);
07471         }
07472         break;
07473       default:
07474         xfer += iprot->skip(ftype);
07475         break;
07476     }
07477     xfer += iprot->readFieldEnd();
07478   }
07479 
07480   xfer += iprot->readStructEnd();
07481 
07482   return xfer;
07483 }
07484 
07485 uint32_t Hbase_scannerOpenWithPrefix_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
07486 
07487   uint32_t xfer = 0;
07488 
07489   xfer += oprot->writeStructBegin("Hbase_scannerOpenWithPrefix_result");
07490 
07491   if (this->__isset.success) {
07492     xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_I32, 0);
07493     xfer += oprot->writeI32(this->success);
07494     xfer += oprot->writeFieldEnd();
07495   } else if (this->__isset.io) {
07496     xfer += oprot->writeFieldBegin("io", ::apache::thrift::protocol::T_STRUCT, 1);
07497     xfer += this->io.write(oprot);
07498     xfer += oprot->writeFieldEnd();
07499   }
07500   xfer += oprot->writeFieldStop();
07501   xfer += oprot->writeStructEnd();
07502   return xfer;
07503 }
07504 
07505 uint32_t Hbase_scannerOpenWithPrefix_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
07506 
07507   uint32_t xfer = 0;
07508   std::string fname;
07509   ::apache::thrift::protocol::TType ftype;
07510   int16_t fid;
07511 
07512   xfer += iprot->readStructBegin(fname);
07513 
07514   using ::apache::thrift::protocol::TProtocolException;
07515 
07516 
07517   while (true)
07518   {
07519     xfer += iprot->readFieldBegin(fname, ftype, fid);
07520     if (ftype == ::apache::thrift::protocol::T_STOP) {
07521       break;
07522     }
07523     switch (fid)
07524     {
07525       case 0:
07526         if (ftype == ::apache::thrift::protocol::T_I32) {
07527           xfer += iprot->readI32((*(this->success)));
07528           this->__isset.success = true;
07529         } else {
07530           xfer += iprot->skip(ftype);
07531         }
07532         break;
07533       case 1:
07534         if (ftype == ::apache::thrift::protocol::T_STRUCT) {
07535           xfer += this->io.read(iprot);
07536           this->__isset.io = true;
07537         } else {
07538           xfer += iprot->skip(ftype);
07539         }
07540         break;
07541       default:
07542         xfer += iprot->skip(ftype);
07543         break;
07544     }
07545     xfer += iprot->readFieldEnd();
07546   }
07547 
07548   xfer += iprot->readStructEnd();
07549 
07550   return xfer;
07551 }
07552 
07553 uint32_t Hbase_scannerOpenTs_args::read(::apache::thrift::protocol::TProtocol* iprot) {
07554 
07555   uint32_t xfer = 0;
07556   std::string fname;
07557   ::apache::thrift::protocol::TType ftype;
07558   int16_t fid;
07559 
07560   xfer += iprot->readStructBegin(fname);
07561 
07562   using ::apache::thrift::protocol::TProtocolException;
07563 
07564 
07565   while (true)
07566   {
07567     xfer += iprot->readFieldBegin(fname, ftype, fid);
07568     if (ftype == ::apache::thrift::protocol::T_STOP) {
07569       break;
07570     }
07571     switch (fid)
07572     {
07573       case 1:
07574         if (ftype == ::apache::thrift::protocol::T_STRING) {
07575           xfer += iprot->readBinary(this->tableName);
07576           this->__isset.tableName = true;
07577         } else {
07578           xfer += iprot->skip(ftype);
07579         }
07580         break;
07581       case 2:
07582         if (ftype == ::apache::thrift::protocol::T_STRING) {
07583           xfer += iprot->readBinary(this->startRow);
07584           this->__isset.startRow = true;
07585         } else {
07586           xfer += iprot->skip(ftype);
07587         }
07588         break;
07589       case 3:
07590         if (ftype == ::apache::thrift::protocol::T_LIST) {
07591           {
07592             this->columns.clear();
07593             uint32_t _size290;
07594             ::apache::thrift::protocol::TType _etype293;
07595             iprot->readListBegin(_etype293, _size290);
07596             this->columns.resize(_size290);
07597             uint32_t _i294;
07598             for (_i294 = 0; _i294 < _size290; ++_i294)
07599             {
07600               xfer += iprot->readBinary(this->columns[_i294]);
07601             }
07602             iprot->readListEnd();
07603           }
07604           this->__isset.columns = true;
07605         } else {
07606           xfer += iprot->skip(ftype);
07607         }
07608         break;
07609       case 4:
07610         if (ftype == ::apache::thrift::protocol::T_I64) {
07611           xfer += iprot->readI64(this->timestamp);
07612           this->__isset.timestamp = true;
07613         } else {
07614           xfer += iprot->skip(ftype);
07615         }
07616         break;
07617       default:
07618         xfer += iprot->skip(ftype);
07619         break;
07620     }
07621     xfer += iprot->readFieldEnd();
07622   }
07623 
07624   xfer += iprot->readStructEnd();
07625 
07626   return xfer;
07627 }
07628 
07629 uint32_t Hbase_scannerOpenTs_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
07630   uint32_t xfer = 0;
07631   xfer += oprot->writeStructBegin("Hbase_scannerOpenTs_args");
07632   xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
07633   xfer += oprot->writeBinary(this->tableName);
07634   xfer += oprot->writeFieldEnd();
07635   xfer += oprot->writeFieldBegin("startRow", ::apache::thrift::protocol::T_STRING, 2);
07636   xfer += oprot->writeBinary(this->startRow);
07637   xfer += oprot->writeFieldEnd();
07638   xfer += oprot->writeFieldBegin("columns", ::apache::thrift::protocol::T_LIST, 3);
07639   {
07640     xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->columns.size()));
07641     std::vector<Text> ::const_iterator _iter295;
07642     for (_iter295 = this->columns.begin(); _iter295 != this->columns.end(); ++_iter295)
07643     {
07644       xfer += oprot->writeBinary((*_iter295));
07645     }
07646     xfer += oprot->writeListEnd();
07647   }
07648   xfer += oprot->writeFieldEnd();
07649   xfer += oprot->writeFieldBegin("timestamp", ::apache::thrift::protocol::T_I64, 4);
07650   xfer += oprot->writeI64(this->timestamp);
07651   xfer += oprot->writeFieldEnd();
07652   xfer += oprot->writeFieldStop();
07653   xfer += oprot->writeStructEnd();
07654   return xfer;
07655 }
07656 
07657 uint32_t Hbase_scannerOpenTs_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
07658   uint32_t xfer = 0;
07659   xfer += oprot->writeStructBegin("Hbase_scannerOpenTs_pargs");
07660   xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
07661   xfer += oprot->writeBinary((*(this->tableName)));
07662   xfer += oprot->writeFieldEnd();
07663   xfer += oprot->writeFieldBegin("startRow", ::apache::thrift::protocol::T_STRING, 2);
07664   xfer += oprot->writeBinary((*(this->startRow)));
07665   xfer += oprot->writeFieldEnd();
07666   xfer += oprot->writeFieldBegin("columns", ::apache::thrift::protocol::T_LIST, 3);
07667   {
07668     xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->columns)).size()));
07669     std::vector<Text> ::const_iterator _iter296;
07670     for (_iter296 = (*(this->columns)).begin(); _iter296 != (*(this->columns)).end(); ++_iter296)
07671     {
07672       xfer += oprot->writeBinary((*_iter296));
07673     }
07674     xfer += oprot->writeListEnd();
07675   }
07676   xfer += oprot->writeFieldEnd();
07677   xfer += oprot->writeFieldBegin("timestamp", ::apache::thrift::protocol::T_I64, 4);
07678   xfer += oprot->writeI64((*(this->timestamp)));
07679   xfer += oprot->writeFieldEnd();
07680   xfer += oprot->writeFieldStop();
07681   xfer += oprot->writeStructEnd();
07682   return xfer;
07683 }
07684 
07685 uint32_t Hbase_scannerOpenTs_result::read(::apache::thrift::protocol::TProtocol* iprot) {
07686 
07687   uint32_t xfer = 0;
07688   std::string fname;
07689   ::apache::thrift::protocol::TType ftype;
07690   int16_t fid;
07691 
07692   xfer += iprot->readStructBegin(fname);
07693 
07694   using ::apache::thrift::protocol::TProtocolException;
07695 
07696 
07697   while (true)
07698   {
07699     xfer += iprot->readFieldBegin(fname, ftype, fid);
07700     if (ftype == ::apache::thrift::protocol::T_STOP) {
07701       break;
07702     }
07703     switch (fid)
07704     {
07705       case 0:
07706         if (ftype == ::apache::thrift::protocol::T_I32) {
07707           xfer += iprot->readI32(this->success);
07708           this->__isset.success = true;
07709         } else {
07710           xfer += iprot->skip(ftype);
07711         }
07712         break;
07713       case 1:
07714         if (ftype == ::apache::thrift::protocol::T_STRUCT) {
07715           xfer += this->io.read(iprot);
07716           this->__isset.io = true;
07717         } else {
07718           xfer += iprot->skip(ftype);
07719         }
07720         break;
07721       default:
07722         xfer += iprot->skip(ftype);
07723         break;
07724     }
07725     xfer += iprot->readFieldEnd();
07726   }
07727 
07728   xfer += iprot->readStructEnd();
07729 
07730   return xfer;
07731 }
07732 
07733 uint32_t Hbase_scannerOpenTs_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
07734 
07735   uint32_t xfer = 0;
07736 
07737   xfer += oprot->writeStructBegin("Hbase_scannerOpenTs_result");
07738 
07739   if (this->__isset.success) {
07740     xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_I32, 0);
07741     xfer += oprot->writeI32(this->success);
07742     xfer += oprot->writeFieldEnd();
07743   } else if (this->__isset.io) {
07744     xfer += oprot->writeFieldBegin("io", ::apache::thrift::protocol::T_STRUCT, 1);
07745     xfer += this->io.write(oprot);
07746     xfer += oprot->writeFieldEnd();
07747   }
07748   xfer += oprot->writeFieldStop();
07749   xfer += oprot->writeStructEnd();
07750   return xfer;
07751 }
07752 
07753 uint32_t Hbase_scannerOpenTs_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
07754 
07755   uint32_t xfer = 0;
07756   std::string fname;
07757   ::apache::thrift::protocol::TType ftype;
07758   int16_t fid;
07759 
07760   xfer += iprot->readStructBegin(fname);
07761 
07762   using ::apache::thrift::protocol::TProtocolException;
07763 
07764 
07765   while (true)
07766   {
07767     xfer += iprot->readFieldBegin(fname, ftype, fid);
07768     if (ftype == ::apache::thrift::protocol::T_STOP) {
07769       break;
07770     }
07771     switch (fid)
07772     {
07773       case 0:
07774         if (ftype == ::apache::thrift::protocol::T_I32) {
07775           xfer += iprot->readI32((*(this->success)));
07776           this->__isset.success = true;
07777         } else {
07778           xfer += iprot->skip(ftype);
07779         }
07780         break;
07781       case 1:
07782         if (ftype == ::apache::thrift::protocol::T_STRUCT) {
07783           xfer += this->io.read(iprot);
07784           this->__isset.io = true;
07785         } else {
07786           xfer += iprot->skip(ftype);
07787         }
07788         break;
07789       default:
07790         xfer += iprot->skip(ftype);
07791         break;
07792     }
07793     xfer += iprot->readFieldEnd();
07794   }
07795 
07796   xfer += iprot->readStructEnd();
07797 
07798   return xfer;
07799 }
07800 
07801 uint32_t Hbase_scannerOpenWithStopTs_args::read(::apache::thrift::protocol::TProtocol* iprot) {
07802 
07803   uint32_t xfer = 0;
07804   std::string fname;
07805   ::apache::thrift::protocol::TType ftype;
07806   int16_t fid;
07807 
07808   xfer += iprot->readStructBegin(fname);
07809 
07810   using ::apache::thrift::protocol::TProtocolException;
07811 
07812 
07813   while (true)
07814   {
07815     xfer += iprot->readFieldBegin(fname, ftype, fid);
07816     if (ftype == ::apache::thrift::protocol::T_STOP) {
07817       break;
07818     }
07819     switch (fid)
07820     {
07821       case 1:
07822         if (ftype == ::apache::thrift::protocol::T_STRING) {
07823           xfer += iprot->readBinary(this->tableName);
07824           this->__isset.tableName = true;
07825         } else {
07826           xfer += iprot->skip(ftype);
07827         }
07828         break;
07829       case 2:
07830         if (ftype == ::apache::thrift::protocol::T_STRING) {
07831           xfer += iprot->readBinary(this->startRow);
07832           this->__isset.startRow = true;
07833         } else {
07834           xfer += iprot->skip(ftype);
07835         }
07836         break;
07837       case 3:
07838         if (ftype == ::apache::thrift::protocol::T_STRING) {
07839           xfer += iprot->readBinary(this->stopRow);
07840           this->__isset.stopRow = true;
07841         } else {
07842           xfer += iprot->skip(ftype);
07843         }
07844         break;
07845       case 4:
07846         if (ftype == ::apache::thrift::protocol::T_LIST) {
07847           {
07848             this->columns.clear();
07849             uint32_t _size297;
07850             ::apache::thrift::protocol::TType _etype300;
07851             iprot->readListBegin(_etype300, _size297);
07852             this->columns.resize(_size297);
07853             uint32_t _i301;
07854             for (_i301 = 0; _i301 < _size297; ++_i301)
07855             {
07856               xfer += iprot->readBinary(this->columns[_i301]);
07857             }
07858             iprot->readListEnd();
07859           }
07860           this->__isset.columns = true;
07861         } else {
07862           xfer += iprot->skip(ftype);
07863         }
07864         break;
07865       case 5:
07866         if (ftype == ::apache::thrift::protocol::T_I64) {
07867           xfer += iprot->readI64(this->timestamp);
07868           this->__isset.timestamp = true;
07869         } else {
07870           xfer += iprot->skip(ftype);
07871         }
07872         break;
07873       default:
07874         xfer += iprot->skip(ftype);
07875         break;
07876     }
07877     xfer += iprot->readFieldEnd();
07878   }
07879 
07880   xfer += iprot->readStructEnd();
07881 
07882   return xfer;
07883 }
07884 
07885 uint32_t Hbase_scannerOpenWithStopTs_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
07886   uint32_t xfer = 0;
07887   xfer += oprot->writeStructBegin("Hbase_scannerOpenWithStopTs_args");
07888   xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
07889   xfer += oprot->writeBinary(this->tableName);
07890   xfer += oprot->writeFieldEnd();
07891   xfer += oprot->writeFieldBegin("startRow", ::apache::thrift::protocol::T_STRING, 2);
07892   xfer += oprot->writeBinary(this->startRow);
07893   xfer += oprot->writeFieldEnd();
07894   xfer += oprot->writeFieldBegin("stopRow", ::apache::thrift::protocol::T_STRING, 3);
07895   xfer += oprot->writeBinary(this->stopRow);
07896   xfer += oprot->writeFieldEnd();
07897   xfer += oprot->writeFieldBegin("columns", ::apache::thrift::protocol::T_LIST, 4);
07898   {
07899     xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->columns.size()));
07900     std::vector<Text> ::const_iterator _iter302;
07901     for (_iter302 = this->columns.begin(); _iter302 != this->columns.end(); ++_iter302)
07902     {
07903       xfer += oprot->writeBinary((*_iter302));
07904     }
07905     xfer += oprot->writeListEnd();
07906   }
07907   xfer += oprot->writeFieldEnd();
07908   xfer += oprot->writeFieldBegin("timestamp", ::apache::thrift::protocol::T_I64, 5);
07909   xfer += oprot->writeI64(this->timestamp);
07910   xfer += oprot->writeFieldEnd();
07911   xfer += oprot->writeFieldStop();
07912   xfer += oprot->writeStructEnd();
07913   return xfer;
07914 }
07915 
07916 uint32_t Hbase_scannerOpenWithStopTs_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
07917   uint32_t xfer = 0;
07918   xfer += oprot->writeStructBegin("Hbase_scannerOpenWithStopTs_pargs");
07919   xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
07920   xfer += oprot->writeBinary((*(this->tableName)));
07921   xfer += oprot->writeFieldEnd();
07922   xfer += oprot->writeFieldBegin("startRow", ::apache::thrift::protocol::T_STRING, 2);
07923   xfer += oprot->writeBinary((*(this->startRow)));
07924   xfer += oprot->writeFieldEnd();
07925   xfer += oprot->writeFieldBegin("stopRow", ::apache::thrift::protocol::T_STRING, 3);
07926   xfer += oprot->writeBinary((*(this->stopRow)));
07927   xfer += oprot->writeFieldEnd();
07928   xfer += oprot->writeFieldBegin("columns", ::apache::thrift::protocol::T_LIST, 4);
07929   {
07930     xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->columns)).size()));
07931     std::vector<Text> ::const_iterator _iter303;
07932     for (_iter303 = (*(this->columns)).begin(); _iter303 != (*(this->columns)).end(); ++_iter303)
07933     {
07934       xfer += oprot->writeBinary((*_iter303));
07935     }
07936     xfer += oprot->writeListEnd();
07937   }
07938   xfer += oprot->writeFieldEnd();
07939   xfer += oprot->writeFieldBegin("timestamp", ::apache::thrift::protocol::T_I64, 5);
07940   xfer += oprot->writeI64((*(this->timestamp)));
07941   xfer += oprot->writeFieldEnd();
07942   xfer += oprot->writeFieldStop();
07943   xfer += oprot->writeStructEnd();
07944   return xfer;
07945 }
07946 
07947 uint32_t Hbase_scannerOpenWithStopTs_result::read(::apache::thrift::protocol::TProtocol* iprot) {
07948 
07949   uint32_t xfer = 0;
07950   std::string fname;
07951   ::apache::thrift::protocol::TType ftype;
07952   int16_t fid;
07953 
07954   xfer += iprot->readStructBegin(fname);
07955 
07956   using ::apache::thrift::protocol::TProtocolException;
07957 
07958 
07959   while (true)
07960   {
07961     xfer += iprot->readFieldBegin(fname, ftype, fid);
07962     if (ftype == ::apache::thrift::protocol::T_STOP) {
07963       break;
07964     }
07965     switch (fid)
07966     {
07967       case 0:
07968         if (ftype == ::apache::thrift::protocol::T_I32) {
07969           xfer += iprot->readI32(this->success);
07970           this->__isset.success = true;
07971         } else {
07972           xfer += iprot->skip(ftype);
07973         }
07974         break;
07975       case 1:
07976         if (ftype == ::apache::thrift::protocol::T_STRUCT) {
07977           xfer += this->io.read(iprot);
07978           this->__isset.io = true;
07979         } else {
07980           xfer += iprot->skip(ftype);
07981         }
07982         break;
07983       default:
07984         xfer += iprot->skip(ftype);
07985         break;
07986     }
07987     xfer += iprot->readFieldEnd();
07988   }
07989 
07990   xfer += iprot->readStructEnd();
07991 
07992   return xfer;
07993 }
07994 
07995 uint32_t Hbase_scannerOpenWithStopTs_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
07996 
07997   uint32_t xfer = 0;
07998 
07999   xfer += oprot->writeStructBegin("Hbase_scannerOpenWithStopTs_result");
08000 
08001   if (this->__isset.success) {
08002     xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_I32, 0);
08003     xfer += oprot->writeI32(this->success);
08004     xfer += oprot->writeFieldEnd();
08005   } else if (this->__isset.io) {
08006     xfer += oprot->writeFieldBegin("io", ::apache::thrift::protocol::T_STRUCT, 1);
08007     xfer += this->io.write(oprot);
08008     xfer += oprot->writeFieldEnd();
08009   }
08010   xfer += oprot->writeFieldStop();
08011   xfer += oprot->writeStructEnd();
08012   return xfer;
08013 }
08014 
08015 uint32_t Hbase_scannerOpenWithStopTs_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
08016 
08017   uint32_t xfer = 0;
08018   std::string fname;
08019   ::apache::thrift::protocol::TType ftype;
08020   int16_t fid;
08021 
08022   xfer += iprot->readStructBegin(fname);
08023 
08024   using ::apache::thrift::protocol::TProtocolException;
08025 
08026 
08027   while (true)
08028   {
08029     xfer += iprot->readFieldBegin(fname, ftype, fid);
08030     if (ftype == ::apache::thrift::protocol::T_STOP) {
08031       break;
08032     }
08033     switch (fid)
08034     {
08035       case 0:
08036         if (ftype == ::apache::thrift::protocol::T_I32) {
08037           xfer += iprot->readI32((*(this->success)));
08038           this->__isset.success = true;
08039         } else {
08040           xfer += iprot->skip(ftype);
08041         }
08042         break;
08043       case 1:
08044         if (ftype == ::apache::thrift::protocol::T_STRUCT) {
08045           xfer += this->io.read(iprot);
08046           this->__isset.io = true;
08047         } else {
08048           xfer += iprot->skip(ftype);
08049         }
08050         break;
08051       default:
08052         xfer += iprot->skip(ftype);
08053         break;
08054     }
08055     xfer += iprot->readFieldEnd();
08056   }
08057 
08058   xfer += iprot->readStructEnd();
08059 
08060   return xfer;
08061 }
08062 
08063 uint32_t Hbase_scannerGet_args::read(::apache::thrift::protocol::TProtocol* iprot) {
08064 
08065   uint32_t xfer = 0;
08066   std::string fname;
08067   ::apache::thrift::protocol::TType ftype;
08068   int16_t fid;
08069 
08070   xfer += iprot->readStructBegin(fname);
08071 
08072   using ::apache::thrift::protocol::TProtocolException;
08073 
08074 
08075   while (true)
08076   {
08077     xfer += iprot->readFieldBegin(fname, ftype, fid);
08078     if (ftype == ::apache::thrift::protocol::T_STOP) {
08079       break;
08080     }
08081     switch (fid)
08082     {
08083       case 1:
08084         if (ftype == ::apache::thrift::protocol::T_I32) {
08085           xfer += iprot->readI32(this->id);
08086           this->__isset.id = true;
08087         } else {
08088           xfer += iprot->skip(ftype);
08089         }
08090         break;
08091       default:
08092         xfer += iprot->skip(ftype);
08093         break;
08094     }
08095     xfer += iprot->readFieldEnd();
08096   }
08097 
08098   xfer += iprot->readStructEnd();
08099 
08100   return xfer;
08101 }
08102 
08103 uint32_t Hbase_scannerGet_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
08104   uint32_t xfer = 0;
08105   xfer += oprot->writeStructBegin("Hbase_scannerGet_args");
08106   xfer += oprot->writeFieldBegin("id", ::apache::thrift::protocol::T_I32, 1);
08107   xfer += oprot->writeI32(this->id);
08108   xfer += oprot->writeFieldEnd();
08109   xfer += oprot->writeFieldStop();
08110   xfer += oprot->writeStructEnd();
08111   return xfer;
08112 }
08113 
08114 uint32_t Hbase_scannerGet_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
08115   uint32_t xfer = 0;
08116   xfer += oprot->writeStructBegin("Hbase_scannerGet_pargs");
08117   xfer += oprot->writeFieldBegin("id", ::apache::thrift::protocol::T_I32, 1);
08118   xfer += oprot->writeI32((*(this->id)));
08119   xfer += oprot->writeFieldEnd();
08120   xfer += oprot->writeFieldStop();
08121   xfer += oprot->writeStructEnd();
08122   return xfer;
08123 }
08124 
08125 uint32_t Hbase_scannerGet_result::read(::apache::thrift::protocol::TProtocol* iprot) {
08126 
08127   uint32_t xfer = 0;
08128   std::string fname;
08129   ::apache::thrift::protocol::TType ftype;
08130   int16_t fid;
08131 
08132   xfer += iprot->readStructBegin(fname);
08133 
08134   using ::apache::thrift::protocol::TProtocolException;
08135 
08136 
08137   while (true)
08138   {
08139     xfer += iprot->readFieldBegin(fname, ftype, fid);
08140     if (ftype == ::apache::thrift::protocol::T_STOP) {
08141       break;
08142     }
08143     switch (fid)
08144     {
08145       case 0:
08146         if (ftype == ::apache::thrift::protocol::T_LIST) {
08147           {
08148             this->success.clear();
08149             uint32_t _size304;
08150             ::apache::thrift::protocol::TType _etype307;
08151             iprot->readListBegin(_etype307, _size304);
08152             this->success.resize(_size304);
08153             uint32_t _i308;
08154             for (_i308 = 0; _i308 < _size304; ++_i308)
08155             {
08156               xfer += this->success[_i308].read(iprot);
08157             }
08158             iprot->readListEnd();
08159           }
08160           this->__isset.success = true;
08161         } else {
08162           xfer += iprot->skip(ftype);
08163         }
08164         break;
08165       case 1:
08166         if (ftype == ::apache::thrift::protocol::T_STRUCT) {
08167           xfer += this->io.read(iprot);
08168           this->__isset.io = true;
08169         } else {
08170           xfer += iprot->skip(ftype);
08171         }
08172         break;
08173       case 2:
08174         if (ftype == ::apache::thrift::protocol::T_STRUCT) {
08175           xfer += this->ia.read(iprot);
08176           this->__isset.ia = true;
08177         } else {
08178           xfer += iprot->skip(ftype);
08179         }
08180         break;
08181       default:
08182         xfer += iprot->skip(ftype);
08183         break;
08184     }
08185     xfer += iprot->readFieldEnd();
08186   }
08187 
08188   xfer += iprot->readStructEnd();
08189 
08190   return xfer;
08191 }
08192 
08193 uint32_t Hbase_scannerGet_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
08194 
08195   uint32_t xfer = 0;
08196 
08197   xfer += oprot->writeStructBegin("Hbase_scannerGet_result");
08198 
08199   if (this->__isset.success) {
08200     xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0);
08201     {
08202       xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->success.size()));
08203       std::vector<TRowResult> ::const_iterator _iter309;
08204       for (_iter309 = this->success.begin(); _iter309 != this->success.end(); ++_iter309)
08205       {
08206         xfer += (*_iter309).write(oprot);
08207       }
08208       xfer += oprot->writeListEnd();
08209     }
08210     xfer += oprot->writeFieldEnd();
08211   } else if (this->__isset.io) {
08212     xfer += oprot->writeFieldBegin("io", ::apache::thrift::protocol::T_STRUCT, 1);
08213     xfer += this->io.write(oprot);
08214     xfer += oprot->writeFieldEnd();
08215   } else if (this->__isset.ia) {
08216     xfer += oprot->writeFieldBegin("ia", ::apache::thrift::protocol::T_STRUCT, 2);
08217     xfer += this->ia.write(oprot);
08218     xfer += oprot->writeFieldEnd();
08219   }
08220   xfer += oprot->writeFieldStop();
08221   xfer += oprot->writeStructEnd();
08222   return xfer;
08223 }
08224 
08225 uint32_t Hbase_scannerGet_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
08226 
08227   uint32_t xfer = 0;
08228   std::string fname;
08229   ::apache::thrift::protocol::TType ftype;
08230   int16_t fid;
08231 
08232   xfer += iprot->readStructBegin(fname);
08233 
08234   using ::apache::thrift::protocol::TProtocolException;
08235 
08236 
08237   while (true)
08238   {
08239     xfer += iprot->readFieldBegin(fname, ftype, fid);
08240     if (ftype == ::apache::thrift::protocol::T_STOP) {
08241       break;
08242     }
08243     switch (fid)
08244     {
08245       case 0:
08246         if (ftype == ::apache::thrift::protocol::T_LIST) {
08247           {
08248             (*(this->success)).clear();
08249             uint32_t _size310;
08250             ::apache::thrift::protocol::TType _etype313;
08251             iprot->readListBegin(_etype313, _size310);
08252             (*(this->success)).resize(_size310);
08253             uint32_t _i314;
08254             for (_i314 = 0; _i314 < _size310; ++_i314)
08255             {
08256               xfer += (*(this->success))[_i314].read(iprot);
08257             }
08258             iprot->readListEnd();
08259           }
08260           this->__isset.success = true;
08261         } else {
08262           xfer += iprot->skip(ftype);
08263         }
08264         break;
08265       case 1:
08266         if (ftype == ::apache::thrift::protocol::T_STRUCT) {
08267           xfer += this->io.read(iprot);
08268           this->__isset.io = true;
08269         } else {
08270           xfer += iprot->skip(ftype);
08271         }
08272         break;
08273       case 2:
08274         if (ftype == ::apache::thrift::protocol::T_STRUCT) {
08275           xfer += this->ia.read(iprot);
08276           this->__isset.ia = true;
08277         } else {
08278           xfer += iprot->skip(ftype);
08279         }
08280         break;
08281       default:
08282         xfer += iprot->skip(ftype);
08283         break;
08284     }
08285     xfer += iprot->readFieldEnd();
08286   }
08287 
08288   xfer += iprot->readStructEnd();
08289 
08290   return xfer;
08291 }
08292 
08293 uint32_t Hbase_scannerGetList_args::read(::apache::thrift::protocol::TProtocol* iprot) {
08294 
08295   uint32_t xfer = 0;
08296   std::string fname;
08297   ::apache::thrift::protocol::TType ftype;
08298   int16_t fid;
08299 
08300   xfer += iprot->readStructBegin(fname);
08301 
08302   using ::apache::thrift::protocol::TProtocolException;
08303 
08304 
08305   while (true)
08306   {
08307     xfer += iprot->readFieldBegin(fname, ftype, fid);
08308     if (ftype == ::apache::thrift::protocol::T_STOP) {
08309       break;
08310     }
08311     switch (fid)
08312     {
08313       case 1:
08314         if (ftype == ::apache::thrift::protocol::T_I32) {
08315           xfer += iprot->readI32(this->id);
08316           this->__isset.id = true;
08317         } else {
08318           xfer += iprot->skip(ftype);
08319         }
08320         break;
08321       case 2:
08322         if (ftype == ::apache::thrift::protocol::T_I32) {
08323           xfer += iprot->readI32(this->nbRows);
08324           this->__isset.nbRows = true;
08325         } else {
08326           xfer += iprot->skip(ftype);
08327         }
08328         break;
08329       default:
08330         xfer += iprot->skip(ftype);
08331         break;
08332     }
08333     xfer += iprot->readFieldEnd();
08334   }
08335 
08336   xfer += iprot->readStructEnd();
08337 
08338   return xfer;
08339 }
08340 
08341 uint32_t Hbase_scannerGetList_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
08342   uint32_t xfer = 0;
08343   xfer += oprot->writeStructBegin("Hbase_scannerGetList_args");
08344   xfer += oprot->writeFieldBegin("id", ::apache::thrift::protocol::T_I32, 1);
08345   xfer += oprot->writeI32(this->id);
08346   xfer += oprot->writeFieldEnd();
08347   xfer += oprot->writeFieldBegin("nbRows", ::apache::thrift::protocol::T_I32, 2);
08348   xfer += oprot->writeI32(this->nbRows);
08349   xfer += oprot->writeFieldEnd();
08350   xfer += oprot->writeFieldStop();
08351   xfer += oprot->writeStructEnd();
08352   return xfer;
08353 }
08354 
08355 uint32_t Hbase_scannerGetList_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
08356   uint32_t xfer = 0;
08357   xfer += oprot->writeStructBegin("Hbase_scannerGetList_pargs");
08358   xfer += oprot->writeFieldBegin("id", ::apache::thrift::protocol::T_I32, 1);
08359   xfer += oprot->writeI32((*(this->id)));
08360   xfer += oprot->writeFieldEnd();
08361   xfer += oprot->writeFieldBegin("nbRows", ::apache::thrift::protocol::T_I32, 2);
08362   xfer += oprot->writeI32((*(this->nbRows)));
08363   xfer += oprot->writeFieldEnd();
08364   xfer += oprot->writeFieldStop();
08365   xfer += oprot->writeStructEnd();
08366   return xfer;
08367 }
08368 
08369 uint32_t Hbase_scannerGetList_result::read(::apache::thrift::protocol::TProtocol* iprot) {
08370 
08371   uint32_t xfer = 0;
08372   std::string fname;
08373   ::apache::thrift::protocol::TType ftype;
08374   int16_t fid;
08375 
08376   xfer += iprot->readStructBegin(fname);
08377 
08378   using ::apache::thrift::protocol::TProtocolException;
08379 
08380 
08381   while (true)
08382   {
08383     xfer += iprot->readFieldBegin(fname, ftype, fid);
08384     if (ftype == ::apache::thrift::protocol::T_STOP) {
08385       break;
08386     }
08387     switch (fid)
08388     {
08389       case 0:
08390         if (ftype == ::apache::thrift::protocol::T_LIST) {
08391           {
08392             this->success.clear();
08393             uint32_t _size315;
08394             ::apache::thrift::protocol::TType _etype318;
08395             iprot->readListBegin(_etype318, _size315);
08396             this->success.resize(_size315);
08397             uint32_t _i319;
08398             for (_i319 = 0; _i319 < _size315; ++_i319)
08399             {
08400               xfer += this->success[_i319].read(iprot);
08401             }
08402             iprot->readListEnd();
08403           }
08404           this->__isset.success = true;
08405         } else {
08406           xfer += iprot->skip(ftype);
08407         }
08408         break;
08409       case 1:
08410         if (ftype == ::apache::thrift::protocol::T_STRUCT) {
08411           xfer += this->io.read(iprot);
08412           this->__isset.io = true;
08413         } else {
08414           xfer += iprot->skip(ftype);
08415         }
08416         break;
08417       case 2:
08418         if (ftype == ::apache::thrift::protocol::T_STRUCT) {
08419           xfer += this->ia.read(iprot);
08420           this->__isset.ia = true;
08421         } else {
08422           xfer += iprot->skip(ftype);
08423         }
08424         break;
08425       default:
08426         xfer += iprot->skip(ftype);
08427         break;
08428     }
08429     xfer += iprot->readFieldEnd();
08430   }
08431 
08432   xfer += iprot->readStructEnd();
08433 
08434   return xfer;
08435 }
08436 
08437 uint32_t Hbase_scannerGetList_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
08438 
08439   uint32_t xfer = 0;
08440 
08441   xfer += oprot->writeStructBegin("Hbase_scannerGetList_result");
08442 
08443   if (this->__isset.success) {
08444     xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0);
08445     {
08446       xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->success.size()));
08447       std::vector<TRowResult> ::const_iterator _iter320;
08448       for (_iter320 = this->success.begin(); _iter320 != this->success.end(); ++_iter320)
08449       {
08450         xfer += (*_iter320).write(oprot);
08451       }
08452       xfer += oprot->writeListEnd();
08453     }
08454     xfer += oprot->writeFieldEnd();
08455   } else if (this->__isset.io) {
08456     xfer += oprot->writeFieldBegin("io", ::apache::thrift::protocol::T_STRUCT, 1);
08457     xfer += this->io.write(oprot);
08458     xfer += oprot->writeFieldEnd();
08459   } else if (this->__isset.ia) {
08460     xfer += oprot->writeFieldBegin("ia", ::apache::thrift::protocol::T_STRUCT, 2);
08461     xfer += this->ia.write(oprot);
08462     xfer += oprot->writeFieldEnd();
08463   }
08464   xfer += oprot->writeFieldStop();
08465   xfer += oprot->writeStructEnd();
08466   return xfer;
08467 }
08468 
08469 uint32_t Hbase_scannerGetList_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
08470 
08471   uint32_t xfer = 0;
08472   std::string fname;
08473   ::apache::thrift::protocol::TType ftype;
08474   int16_t fid;
08475 
08476   xfer += iprot->readStructBegin(fname);
08477 
08478   using ::apache::thrift::protocol::TProtocolException;
08479 
08480 
08481   while (true)
08482   {
08483     xfer += iprot->readFieldBegin(fname, ftype, fid);
08484     if (ftype == ::apache::thrift::protocol::T_STOP) {
08485       break;
08486     }
08487     switch (fid)
08488     {
08489       case 0:
08490         if (ftype == ::apache::thrift::protocol::T_LIST) {
08491           {
08492             (*(this->success)).clear();
08493             uint32_t _size321;
08494             ::apache::thrift::protocol::TType _etype324;
08495             iprot->readListBegin(_etype324, _size321);
08496             (*(this->success)).resize(_size321);
08497             uint32_t _i325;
08498             for (_i325 = 0; _i325 < _size321; ++_i325)
08499             {
08500               xfer += (*(this->success))[_i325].read(iprot);
08501             }
08502             iprot->readListEnd();
08503           }
08504           this->__isset.success = true;
08505         } else {
08506           xfer += iprot->skip(ftype);
08507         }
08508         break;
08509       case 1:
08510         if (ftype == ::apache::thrift::protocol::T_STRUCT) {
08511           xfer += this->io.read(iprot);
08512           this->__isset.io = true;
08513         } else {
08514           xfer += iprot->skip(ftype);
08515         }
08516         break;
08517       case 2:
08518         if (ftype == ::apache::thrift::protocol::T_STRUCT) {
08519           xfer += this->ia.read(iprot);
08520           this->__isset.ia = true;
08521         } else {
08522           xfer += iprot->skip(ftype);
08523         }
08524         break;
08525       default:
08526         xfer += iprot->skip(ftype);
08527         break;
08528     }
08529     xfer += iprot->readFieldEnd();
08530   }
08531 
08532   xfer += iprot->readStructEnd();
08533 
08534   return xfer;
08535 }
08536 
08537 uint32_t Hbase_scannerClose_args::read(::apache::thrift::protocol::TProtocol* iprot) {
08538 
08539   uint32_t xfer = 0;
08540   std::string fname;
08541   ::apache::thrift::protocol::TType ftype;
08542   int16_t fid;
08543 
08544   xfer += iprot->readStructBegin(fname);
08545 
08546   using ::apache::thrift::protocol::TProtocolException;
08547 
08548 
08549   while (true)
08550   {
08551     xfer += iprot->readFieldBegin(fname, ftype, fid);
08552     if (ftype == ::apache::thrift::protocol::T_STOP) {
08553       break;
08554     }
08555     switch (fid)
08556     {
08557       case 1:
08558         if (ftype == ::apache::thrift::protocol::T_I32) {
08559           xfer += iprot->readI32(this->id);
08560           this->__isset.id = true;
08561         } else {
08562           xfer += iprot->skip(ftype);
08563         }
08564         break;
08565       default:
08566         xfer += iprot->skip(ftype);
08567         break;
08568     }
08569     xfer += iprot->readFieldEnd();
08570   }
08571 
08572   xfer += iprot->readStructEnd();
08573 
08574   return xfer;
08575 }
08576 
08577 uint32_t Hbase_scannerClose_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
08578   uint32_t xfer = 0;
08579   xfer += oprot->writeStructBegin("Hbase_scannerClose_args");
08580   xfer += oprot->writeFieldBegin("id", ::apache::thrift::protocol::T_I32, 1);
08581   xfer += oprot->writeI32(this->id);
08582   xfer += oprot->writeFieldEnd();
08583   xfer += oprot->writeFieldStop();
08584   xfer += oprot->writeStructEnd();
08585   return xfer;
08586 }
08587 
08588 uint32_t Hbase_scannerClose_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
08589   uint32_t xfer = 0;
08590   xfer += oprot->writeStructBegin("Hbase_scannerClose_pargs");
08591   xfer += oprot->writeFieldBegin("id", ::apache::thrift::protocol::T_I32, 1);
08592   xfer += oprot->writeI32((*(this->id)));
08593   xfer += oprot->writeFieldEnd();
08594   xfer += oprot->writeFieldStop();
08595   xfer += oprot->writeStructEnd();
08596   return xfer;
08597 }
08598 
08599 uint32_t Hbase_scannerClose_result::read(::apache::thrift::protocol::TProtocol* iprot) {
08600 
08601   uint32_t xfer = 0;
08602   std::string fname;
08603   ::apache::thrift::protocol::TType ftype;
08604   int16_t fid;
08605 
08606   xfer += iprot->readStructBegin(fname);
08607 
08608   using ::apache::thrift::protocol::TProtocolException;
08609 
08610 
08611   while (true)
08612   {
08613     xfer += iprot->readFieldBegin(fname, ftype, fid);
08614     if (ftype == ::apache::thrift::protocol::T_STOP) {
08615       break;
08616     }
08617     switch (fid)
08618     {
08619       case 1:
08620         if (ftype == ::apache::thrift::protocol::T_STRUCT) {
08621           xfer += this->io.read(iprot);
08622           this->__isset.io = true;
08623         } else {
08624           xfer += iprot->skip(ftype);
08625         }
08626         break;
08627       case 2:
08628         if (ftype == ::apache::thrift::protocol::T_STRUCT) {
08629           xfer += this->ia.read(iprot);
08630           this->__isset.ia = true;
08631         } else {
08632           xfer += iprot->skip(ftype);
08633         }
08634         break;
08635       default:
08636         xfer += iprot->skip(ftype);
08637         break;
08638     }
08639     xfer += iprot->readFieldEnd();
08640   }
08641 
08642   xfer += iprot->readStructEnd();
08643 
08644   return xfer;
08645 }
08646 
08647 uint32_t Hbase_scannerClose_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
08648 
08649   uint32_t xfer = 0;
08650 
08651   xfer += oprot->writeStructBegin("Hbase_scannerClose_result");
08652 
08653   if (this->__isset.io) {
08654     xfer += oprot->writeFieldBegin("io", ::apache::thrift::protocol::T_STRUCT, 1);
08655     xfer += this->io.write(oprot);
08656     xfer += oprot->writeFieldEnd();
08657   } else if (this->__isset.ia) {
08658     xfer += oprot->writeFieldBegin("ia", ::apache::thrift::protocol::T_STRUCT, 2);
08659     xfer += this->ia.write(oprot);
08660     xfer += oprot->writeFieldEnd();
08661   }
08662   xfer += oprot->writeFieldStop();
08663   xfer += oprot->writeStructEnd();
08664   return xfer;
08665 }
08666 
08667 uint32_t Hbase_scannerClose_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
08668 
08669   uint32_t xfer = 0;
08670   std::string fname;
08671   ::apache::thrift::protocol::TType ftype;
08672   int16_t fid;
08673 
08674   xfer += iprot->readStructBegin(fname);
08675 
08676   using ::apache::thrift::protocol::TProtocolException;
08677 
08678 
08679   while (true)
08680   {
08681     xfer += iprot->readFieldBegin(fname, ftype, fid);
08682     if (ftype == ::apache::thrift::protocol::T_STOP) {
08683       break;
08684     }
08685     switch (fid)
08686     {
08687       case 1:
08688         if (ftype == ::apache::thrift::protocol::T_STRUCT) {
08689           xfer += this->io.read(iprot);
08690           this->__isset.io = true;
08691         } else {
08692           xfer += iprot->skip(ftype);
08693         }
08694         break;
08695       case 2:
08696         if (ftype == ::apache::thrift::protocol::T_STRUCT) {
08697           xfer += this->ia.read(iprot);
08698           this->__isset.ia = true;
08699         } else {
08700           xfer += iprot->skip(ftype);
08701         }
08702         break;
08703       default:
08704         xfer += iprot->skip(ftype);
08705         break;
08706     }
08707     xfer += iprot->readFieldEnd();
08708   }
08709 
08710   xfer += iprot->readStructEnd();
08711 
08712   return xfer;
08713 }
08714 
08715 uint32_t Hbase_getRowOrBefore_args::read(::apache::thrift::protocol::TProtocol* iprot) {
08716 
08717   uint32_t xfer = 0;
08718   std::string fname;
08719   ::apache::thrift::protocol::TType ftype;
08720   int16_t fid;
08721 
08722   xfer += iprot->readStructBegin(fname);
08723 
08724   using ::apache::thrift::protocol::TProtocolException;
08725 
08726 
08727   while (true)
08728   {
08729     xfer += iprot->readFieldBegin(fname, ftype, fid);
08730     if (ftype == ::apache::thrift::protocol::T_STOP) {
08731       break;
08732     }
08733     switch (fid)
08734     {
08735       case 1:
08736         if (ftype == ::apache::thrift::protocol::T_STRING) {
08737           xfer += iprot->readBinary(this->tableName);
08738           this->__isset.tableName = true;
08739         } else {
08740           xfer += iprot->skip(ftype);
08741         }
08742         break;
08743       case 2:
08744         if (ftype == ::apache::thrift::protocol::T_STRING) {
08745           xfer += iprot->readBinary(this->row);
08746           this->__isset.row = true;
08747         } else {
08748           xfer += iprot->skip(ftype);
08749         }
08750         break;
08751       case 3:
08752         if (ftype == ::apache::thrift::protocol::T_STRING) {
08753           xfer += iprot->readBinary(this->family);
08754           this->__isset.family = true;
08755         } else {
08756           xfer += iprot->skip(ftype);
08757         }
08758         break;
08759       default:
08760         xfer += iprot->skip(ftype);
08761         break;
08762     }
08763     xfer += iprot->readFieldEnd();
08764   }
08765 
08766   xfer += iprot->readStructEnd();
08767 
08768   return xfer;
08769 }
08770 
08771 uint32_t Hbase_getRowOrBefore_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
08772   uint32_t xfer = 0;
08773   xfer += oprot->writeStructBegin("Hbase_getRowOrBefore_args");
08774   xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
08775   xfer += oprot->writeBinary(this->tableName);
08776   xfer += oprot->writeFieldEnd();
08777   xfer += oprot->writeFieldBegin("row", ::apache::thrift::protocol::T_STRING, 2);
08778   xfer += oprot->writeBinary(this->row);
08779   xfer += oprot->writeFieldEnd();
08780   xfer += oprot->writeFieldBegin("family", ::apache::thrift::protocol::T_STRING, 3);
08781   xfer += oprot->writeBinary(this->family);
08782   xfer += oprot->writeFieldEnd();
08783   xfer += oprot->writeFieldStop();
08784   xfer += oprot->writeStructEnd();
08785   return xfer;
08786 }
08787 
08788 uint32_t Hbase_getRowOrBefore_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
08789   uint32_t xfer = 0;
08790   xfer += oprot->writeStructBegin("Hbase_getRowOrBefore_pargs");
08791   xfer += oprot->writeFieldBegin("tableName", ::apache::thrift::protocol::T_STRING, 1);
08792   xfer += oprot->writeBinary((*(this->tableName)));
08793   xfer += oprot->writeFieldEnd();
08794   xfer += oprot->writeFieldBegin("row", ::apache::thrift::protocol::T_STRING, 2);
08795   xfer += oprot->writeBinary((*(this->row)));
08796   xfer += oprot->writeFieldEnd();
08797   xfer += oprot->writeFieldBegin("family", ::apache::thrift::protocol::T_STRING, 3);
08798   xfer += oprot->writeBinary((*(this->family)));
08799   xfer += oprot->writeFieldEnd();
08800   xfer += oprot->writeFieldStop();
08801   xfer += oprot->writeStructEnd();
08802   return xfer;
08803 }
08804 
08805 uint32_t Hbase_getRowOrBefore_result::read(::apache::thrift::protocol::TProtocol* iprot) {
08806 
08807   uint32_t xfer = 0;
08808   std::string fname;
08809   ::apache::thrift::protocol::TType ftype;
08810   int16_t fid;
08811 
08812   xfer += iprot->readStructBegin(fname);
08813 
08814   using ::apache::thrift::protocol::TProtocolException;
08815 
08816 
08817   while (true)
08818   {
08819     xfer += iprot->readFieldBegin(fname, ftype, fid);
08820     if (ftype == ::apache::thrift::protocol::T_STOP) {
08821       break;
08822     }
08823     switch (fid)
08824     {
08825       case 0:
08826         if (ftype == ::apache::thrift::protocol::T_LIST) {
08827           {
08828             this->success.clear();
08829             uint32_t _size326;
08830             ::apache::thrift::protocol::TType _etype329;
08831             iprot->readListBegin(_etype329, _size326);
08832             this->success.resize(_size326);
08833             uint32_t _i330;
08834             for (_i330 = 0; _i330 < _size326; ++_i330)
08835             {
08836               xfer += this->success[_i330].read(iprot);
08837             }
08838             iprot->readListEnd();
08839           }
08840           this->__isset.success = true;
08841         } else {
08842           xfer += iprot->skip(ftype);
08843         }
08844         break;
08845       case 1:
08846         if (ftype == ::apache::thrift::protocol::T_STRUCT) {
08847           xfer += this->io.read(iprot);
08848           this->__isset.io = true;
08849         } else {
08850           xfer += iprot->skip(ftype);
08851         }
08852         break;
08853       default:
08854         xfer += iprot->skip(ftype);
08855         break;
08856     }
08857     xfer += iprot->readFieldEnd();
08858   }
08859 
08860   xfer += iprot->readStructEnd();
08861 
08862   return xfer;
08863 }
08864 
08865 uint32_t Hbase_getRowOrBefore_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
08866 
08867   uint32_t xfer = 0;
08868 
08869   xfer += oprot->writeStructBegin("Hbase_getRowOrBefore_result");
08870 
08871   if (this->__isset.success) {
08872     xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0);
08873     {
08874       xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->success.size()));
08875       std::vector<TCell> ::const_iterator _iter331;
08876       for (_iter331 = this->success.begin(); _iter331 != this->success.end(); ++_iter331)
08877       {
08878         xfer += (*_iter331).write(oprot);
08879       }
08880       xfer += oprot->writeListEnd();
08881     }
08882     xfer += oprot->writeFieldEnd();
08883   } else if (this->__isset.io) {
08884     xfer += oprot->writeFieldBegin("io", ::apache::thrift::protocol::T_STRUCT, 1);
08885     xfer += this->io.write(oprot);
08886     xfer += oprot->writeFieldEnd();
08887   }
08888   xfer += oprot->writeFieldStop();
08889   xfer += oprot->writeStructEnd();
08890   return xfer;
08891 }
08892 
08893 uint32_t Hbase_getRowOrBefore_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
08894 
08895   uint32_t xfer = 0;
08896   std::string fname;
08897   ::apache::thrift::protocol::TType ftype;
08898   int16_t fid;
08899 
08900   xfer += iprot->readStructBegin(fname);
08901 
08902   using ::apache::thrift::protocol::TProtocolException;
08903 
08904 
08905   while (true)
08906   {
08907     xfer += iprot->readFieldBegin(fname, ftype, fid);
08908     if (ftype == ::apache::thrift::protocol::T_STOP) {
08909       break;
08910     }
08911     switch (fid)
08912     {
08913       case 0:
08914         if (ftype == ::apache::thrift::protocol::T_LIST) {
08915           {
08916             (*(this->success)).clear();
08917             uint32_t _size332;
08918             ::apache::thrift::protocol::TType _etype335;
08919             iprot->readListBegin(_etype335, _size332);
08920             (*(this->success)).resize(_size332);
08921             uint32_t _i336;
08922             for (_i336 = 0; _i336 < _size332; ++_i336)
08923             {
08924               xfer += (*(this->success))[_i336].read(iprot);
08925             }
08926             iprot->readListEnd();
08927           }
08928           this->__isset.success = true;
08929         } else {
08930           xfer += iprot->skip(ftype);
08931         }
08932         break;
08933       case 1:
08934         if (ftype == ::apache::thrift::protocol::T_STRUCT) {
08935           xfer += this->io.read(iprot);
08936           this->__isset.io = true;
08937         } else {
08938           xfer += iprot->skip(ftype);
08939         }
08940         break;
08941       default:
08942         xfer += iprot->skip(ftype);
08943         break;
08944     }
08945     xfer += iprot->readFieldEnd();
08946   }
08947 
08948   xfer += iprot->readStructEnd();
08949 
08950   return xfer;
08951 }
08952 
08953 uint32_t Hbase_getRegionInfo_args::read(::apache::thrift::protocol::TProtocol* iprot) {
08954 
08955   uint32_t xfer = 0;
08956   std::string fname;
08957   ::apache::thrift::protocol::TType ftype;
08958   int16_t fid;
08959 
08960   xfer += iprot->readStructBegin(fname);
08961 
08962   using ::apache::thrift::protocol::TProtocolException;
08963 
08964 
08965   while (true)
08966   {
08967     xfer += iprot->readFieldBegin(fname, ftype, fid);
08968     if (ftype == ::apache::thrift::protocol::T_STOP) {
08969       break;
08970     }
08971     switch (fid)
08972     {
08973       case 1:
08974         if (ftype == ::apache::thrift::protocol::T_STRING) {
08975           xfer += iprot->readBinary(this->row);
08976           this->__isset.row = true;
08977         } else {
08978           xfer += iprot->skip(ftype);
08979         }
08980         break;
08981       default:
08982         xfer += iprot->skip(ftype);
08983         break;
08984     }
08985     xfer += iprot->readFieldEnd();
08986   }
08987 
08988   xfer += iprot->readStructEnd();
08989 
08990   return xfer;
08991 }
08992 
08993 uint32_t Hbase_getRegionInfo_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
08994   uint32_t xfer = 0;
08995   xfer += oprot->writeStructBegin("Hbase_getRegionInfo_args");
08996   xfer += oprot->writeFieldBegin("row", ::apache::thrift::protocol::T_STRING, 1);
08997   xfer += oprot->writeBinary(this->row);
08998   xfer += oprot->writeFieldEnd();
08999   xfer += oprot->writeFieldStop();
09000   xfer += oprot->writeStructEnd();
09001   return xfer;
09002 }
09003 
09004 uint32_t Hbase_getRegionInfo_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
09005   uint32_t xfer = 0;
09006   xfer += oprot->writeStructBegin("Hbase_getRegionInfo_pargs");
09007   xfer += oprot->writeFieldBegin("row", ::apache::thrift::protocol::T_STRING, 1);
09008   xfer += oprot->writeBinary((*(this->row)));
09009   xfer += oprot->writeFieldEnd();
09010   xfer += oprot->writeFieldStop();
09011   xfer += oprot->writeStructEnd();
09012   return xfer;
09013 }
09014 
09015 uint32_t Hbase_getRegionInfo_result::read(::apache::thrift::protocol::TProtocol* iprot) {
09016 
09017   uint32_t xfer = 0;
09018   std::string fname;
09019   ::apache::thrift::protocol::TType ftype;
09020   int16_t fid;
09021 
09022   xfer += iprot->readStructBegin(fname);
09023 
09024   using ::apache::thrift::protocol::TProtocolException;
09025 
09026 
09027   while (true)
09028   {
09029     xfer += iprot->readFieldBegin(fname, ftype, fid);
09030     if (ftype == ::apache::thrift::protocol::T_STOP) {
09031       break;
09032     }
09033     switch (fid)
09034     {
09035       case 0:
09036         if (ftype == ::apache::thrift::protocol::T_STRUCT) {
09037           xfer += this->success.read(iprot);
09038           this->__isset.success = true;
09039         } else {
09040           xfer += iprot->skip(ftype);
09041         }
09042         break;
09043       case 1:
09044         if (ftype == ::apache::thrift::protocol::T_STRUCT) {
09045           xfer += this->io.read(iprot);
09046           this->__isset.io = true;
09047         } else {
09048           xfer += iprot->skip(ftype);
09049         }
09050         break;
09051       default:
09052         xfer += iprot->skip(ftype);
09053         break;
09054     }
09055     xfer += iprot->readFieldEnd();
09056   }
09057 
09058   xfer += iprot->readStructEnd();
09059 
09060   return xfer;
09061 }
09062 
09063 uint32_t Hbase_getRegionInfo_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
09064 
09065   uint32_t xfer = 0;
09066 
09067   xfer += oprot->writeStructBegin("Hbase_getRegionInfo_result");
09068 
09069   if (this->__isset.success) {
09070     xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0);
09071     xfer += this->success.write(oprot);
09072     xfer += oprot->writeFieldEnd();
09073   } else if (this->__isset.io) {
09074     xfer += oprot->writeFieldBegin("io", ::apache::thrift::protocol::T_STRUCT, 1);
09075     xfer += this->io.write(oprot);
09076     xfer += oprot->writeFieldEnd();
09077   }
09078   xfer += oprot->writeFieldStop();
09079   xfer += oprot->writeStructEnd();
09080   return xfer;
09081 }
09082 
09083 uint32_t Hbase_getRegionInfo_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
09084 
09085   uint32_t xfer = 0;
09086   std::string fname;
09087   ::apache::thrift::protocol::TType ftype;
09088   int16_t fid;
09089 
09090   xfer += iprot->readStructBegin(fname);
09091 
09092   using ::apache::thrift::protocol::TProtocolException;
09093 
09094 
09095   while (true)
09096   {
09097     xfer += iprot->readFieldBegin(fname, ftype, fid);
09098     if (ftype == ::apache::thrift::protocol::T_STOP) {
09099       break;
09100     }
09101     switch (fid)
09102     {
09103       case 0:
09104         if (ftype == ::apache::thrift::protocol::T_STRUCT) {
09105           xfer += (*(this->success)).read(iprot);
09106           this->__isset.success = true;
09107         } else {
09108           xfer += iprot->skip(ftype);
09109         }
09110         break;
09111       case 1:
09112         if (ftype == ::apache::thrift::protocol::T_STRUCT) {
09113           xfer += this->io.read(iprot);
09114           this->__isset.io = true;
09115         } else {
09116           xfer += iprot->skip(ftype);
09117         }
09118         break;
09119       default:
09120         xfer += iprot->skip(ftype);
09121         break;
09122     }
09123     xfer += iprot->readFieldEnd();
09124   }
09125 
09126   xfer += iprot->readStructEnd();
09127 
09128   return xfer;
09129 }
09130 
09131 void HbaseClient::enableTable(const Bytes& tableName)
09132 {
09133   send_enableTable(tableName);
09134   recv_enableTable();
09135 }
09136 
09137 void HbaseClient::send_enableTable(const Bytes& tableName)
09138 {
09139   int32_t cseqid = 0;
09140   oprot_->writeMessageBegin("enableTable", ::apache::thrift::protocol::T_CALL, cseqid);
09141 
09142   Hbase_enableTable_pargs args;
09143   args.tableName = &tableName;
09144   args.write(oprot_);
09145 
09146   oprot_->writeMessageEnd();
09147   oprot_->getTransport()->writeEnd();
09148   oprot_->getTransport()->flush();
09149 }
09150 
09151 void HbaseClient::recv_enableTable()
09152 {
09153 
09154   int32_t rseqid = 0;
09155   std::string fname;
09156   ::apache::thrift::protocol::TMessageType mtype;
09157 
09158   iprot_->readMessageBegin(fname, mtype, rseqid);
09159   if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
09160     ::apache::thrift::TApplicationException x;
09161     x.read(iprot_);
09162     iprot_->readMessageEnd();
09163     iprot_->getTransport()->readEnd();
09164     throw x;
09165   }
09166   if (mtype != ::apache::thrift::protocol::T_REPLY) {
09167     iprot_->skip(::apache::thrift::protocol::T_STRUCT);
09168     iprot_->readMessageEnd();
09169     iprot_->getTransport()->readEnd();
09170   }
09171   if (fname.compare("enableTable") != 0) {
09172     iprot_->skip(::apache::thrift::protocol::T_STRUCT);
09173     iprot_->readMessageEnd();
09174     iprot_->getTransport()->readEnd();
09175   }
09176   Hbase_enableTable_presult result;
09177   result.read(iprot_);
09178   iprot_->readMessageEnd();
09179   iprot_->getTransport()->readEnd();
09180 
09181   if (result.__isset.io) {
09182     throw result.io;
09183   }
09184   return;
09185 }
09186 
09187 void HbaseClient::disableTable(const Bytes& tableName)
09188 {
09189   send_disableTable(tableName);
09190   recv_disableTable();
09191 }
09192 
09193 void HbaseClient::send_disableTable(const Bytes& tableName)
09194 {
09195   int32_t cseqid = 0;
09196   oprot_->writeMessageBegin("disableTable", ::apache::thrift::protocol::T_CALL, cseqid);
09197 
09198   Hbase_disableTable_pargs args;
09199   args.tableName = &tableName;
09200   args.write(oprot_);
09201 
09202   oprot_->writeMessageEnd();
09203   oprot_->getTransport()->writeEnd();
09204   oprot_->getTransport()->flush();
09205 }
09206 
09207 void HbaseClient::recv_disableTable()
09208 {
09209 
09210   int32_t rseqid = 0;
09211   std::string fname;
09212   ::apache::thrift::protocol::TMessageType mtype;
09213 
09214   iprot_->readMessageBegin(fname, mtype, rseqid);
09215   if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
09216     ::apache::thrift::TApplicationException x;
09217     x.read(iprot_);
09218     iprot_->readMessageEnd();
09219     iprot_->getTransport()->readEnd();
09220     throw x;
09221   }
09222   if (mtype != ::apache::thrift::protocol::T_REPLY) {
09223     iprot_->skip(::apache::thrift::protocol::T_STRUCT);
09224     iprot_->readMessageEnd();
09225     iprot_->getTransport()->readEnd();
09226   }
09227   if (fname.compare("disableTable") != 0) {
09228     iprot_->skip(::apache::thrift::protocol::T_STRUCT);
09229     iprot_->readMessageEnd();
09230     iprot_->getTransport()->readEnd();
09231   }
09232   Hbase_disableTable_presult result;
09233   result.read(iprot_);
09234   iprot_->readMessageEnd();
09235   iprot_->getTransport()->readEnd();
09236 
09237   if (result.__isset.io) {
09238     throw result.io;
09239   }
09240   return;
09241 }
09242 
09243 bool HbaseClient::isTableEnabled(const Bytes& tableName)
09244 {
09245   send_isTableEnabled(tableName);
09246   return recv_isTableEnabled();
09247 }
09248 
09249 void HbaseClient::send_isTableEnabled(const Bytes& tableName)
09250 {
09251   int32_t cseqid = 0;
09252   oprot_->writeMessageBegin("isTableEnabled", ::apache::thrift::protocol::T_CALL, cseqid);
09253 
09254   Hbase_isTableEnabled_pargs args;
09255   args.tableName = &tableName;
09256   args.write(oprot_);
09257 
09258   oprot_->writeMessageEnd();
09259   oprot_->getTransport()->writeEnd();
09260   oprot_->getTransport()->flush();
09261 }
09262 
09263 bool HbaseClient::recv_isTableEnabled()
09264 {
09265 
09266   int32_t rseqid = 0;
09267   std::string fname;
09268   ::apache::thrift::protocol::TMessageType mtype;
09269 
09270   iprot_->readMessageBegin(fname, mtype, rseqid);
09271   if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
09272     ::apache::thrift::TApplicationException x;
09273     x.read(iprot_);
09274     iprot_->readMessageEnd();
09275     iprot_->getTransport()->readEnd();
09276     throw x;
09277   }
09278   if (mtype != ::apache::thrift::protocol::T_REPLY) {
09279     iprot_->skip(::apache::thrift::protocol::T_STRUCT);
09280     iprot_->readMessageEnd();
09281     iprot_->getTransport()->readEnd();
09282   }
09283   if (fname.compare("isTableEnabled") != 0) {
09284     iprot_->skip(::apache::thrift::protocol::T_STRUCT);
09285     iprot_->readMessageEnd();
09286     iprot_->getTransport()->readEnd();
09287   }
09288   bool _return;
09289   Hbase_isTableEnabled_presult result;
09290   result.success = &_return;
09291   result.read(iprot_);
09292   iprot_->readMessageEnd();
09293   iprot_->getTransport()->readEnd();
09294 
09295   if (result.__isset.success) {
09296     return _return;
09297   }
09298   if (result.__isset.io) {
09299     throw result.io;
09300   }
09301   throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "isTableEnabled failed: unknown result");
09302 }
09303 
09304 void HbaseClient::compact(const Bytes& tableNameOrRegionName)
09305 {
09306   send_compact(tableNameOrRegionName);
09307   recv_compact();
09308 }
09309 
09310 void HbaseClient::send_compact(const Bytes& tableNameOrRegionName)
09311 {
09312   int32_t cseqid = 0;
09313   oprot_->writeMessageBegin("compact", ::apache::thrift::protocol::T_CALL, cseqid);
09314 
09315   Hbase_compact_pargs args;
09316   args.tableNameOrRegionName = &tableNameOrRegionName;
09317   args.write(oprot_);
09318 
09319   oprot_->writeMessageEnd();
09320   oprot_->getTransport()->writeEnd();
09321   oprot_->getTransport()->flush();
09322 }
09323 
09324 void HbaseClient::recv_compact()
09325 {
09326 
09327   int32_t rseqid = 0;
09328   std::string fname;
09329   ::apache::thrift::protocol::TMessageType mtype;
09330 
09331   iprot_->readMessageBegin(fname, mtype, rseqid);
09332   if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
09333     ::apache::thrift::TApplicationException x;
09334     x.read(iprot_);
09335     iprot_->readMessageEnd();
09336     iprot_->getTransport()->readEnd();
09337     throw x;
09338   }
09339   if (mtype != ::apache::thrift::protocol::T_REPLY) {
09340     iprot_->skip(::apache::thrift::protocol::T_STRUCT);
09341     iprot_->readMessageEnd();
09342     iprot_->getTransport()->readEnd();
09343   }
09344   if (fname.compare("compact") != 0) {
09345     iprot_->skip(::apache::thrift::protocol::T_STRUCT);
09346     iprot_->readMessageEnd();
09347     iprot_->getTransport()->readEnd();
09348   }
09349   Hbase_compact_presult result;
09350   result.read(iprot_);
09351   iprot_->readMessageEnd();
09352   iprot_->getTransport()->readEnd();
09353 
09354   if (result.__isset.io) {
09355     throw result.io;
09356   }
09357   return;
09358 }
09359 
09360 void HbaseClient::majorCompact(const Bytes& tableNameOrRegionName)
09361 {
09362   send_majorCompact(tableNameOrRegionName);
09363   recv_majorCompact();
09364 }
09365 
09366 void HbaseClient::send_majorCompact(const Bytes& tableNameOrRegionName)
09367 {
09368   int32_t cseqid = 0;
09369   oprot_->writeMessageBegin("majorCompact", ::apache::thrift::protocol::T_CALL, cseqid);
09370 
09371   Hbase_majorCompact_pargs args;
09372   args.tableNameOrRegionName = &tableNameOrRegionName;
09373   args.write(oprot_);
09374 
09375   oprot_->writeMessageEnd();
09376   oprot_->getTransport()->writeEnd();
09377   oprot_->getTransport()->flush();
09378 }
09379 
09380 void HbaseClient::recv_majorCompact()
09381 {
09382 
09383   int32_t rseqid = 0;
09384   std::string fname;
09385   ::apache::thrift::protocol::TMessageType mtype;
09386 
09387   iprot_->readMessageBegin(fname, mtype, rseqid);
09388   if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
09389     ::apache::thrift::TApplicationException x;
09390     x.read(iprot_);
09391     iprot_->readMessageEnd();
09392     iprot_->getTransport()->readEnd();
09393     throw x;
09394   }
09395   if (mtype != ::apache::thrift::protocol::T_REPLY) {
09396     iprot_->skip(::apache::thrift::protocol::T_STRUCT);
09397     iprot_->readMessageEnd();
09398     iprot_->getTransport()->readEnd();
09399   }
09400   if (fname.compare("majorCompact") != 0) {
09401     iprot_->skip(::apache::thrift::protocol::T_STRUCT);
09402     iprot_->readMessageEnd();
09403     iprot_->getTransport()->readEnd();
09404   }
09405   Hbase_majorCompact_presult result;
09406   result.read(iprot_);
09407   iprot_->readMessageEnd();
09408   iprot_->getTransport()->readEnd();
09409 
09410   if (result.__isset.io) {
09411     throw result.io;
09412   }
09413   return;
09414 }
09415 
09416 void HbaseClient::getTableNames(std::vector<Text> & _return)
09417 {
09418   send_getTableNames();
09419   recv_getTableNames(_return);
09420 }
09421 
09422 void HbaseClient::send_getTableNames()
09423 {
09424   int32_t cseqid = 0;
09425   oprot_->writeMessageBegin("getTableNames", ::apache::thrift::protocol::T_CALL, cseqid);
09426 
09427   Hbase_getTableNames_pargs args;
09428   args.write(oprot_);
09429 
09430   oprot_->writeMessageEnd();
09431   oprot_->getTransport()->writeEnd();
09432   oprot_->getTransport()->flush();
09433 }
09434 
09435 void HbaseClient::recv_getTableNames(std::vector<Text> & _return)
09436 {
09437 
09438   int32_t rseqid = 0;
09439   std::string fname;
09440   ::apache::thrift::protocol::TMessageType mtype;
09441 
09442   iprot_->readMessageBegin(fname, mtype, rseqid);
09443   if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
09444     ::apache::thrift::TApplicationException x;
09445     x.read(iprot_);
09446     iprot_->readMessageEnd();
09447     iprot_->getTransport()->readEnd();
09448     throw x;
09449   }
09450   if (mtype != ::apache::thrift::protocol::T_REPLY) {
09451     iprot_->skip(::apache::thrift::protocol::T_STRUCT);
09452     iprot_->readMessageEnd();
09453     iprot_->getTransport()->readEnd();
09454   }
09455   if (fname.compare("getTableNames") != 0) {
09456     iprot_->skip(::apache::thrift::protocol::T_STRUCT);
09457     iprot_->readMessageEnd();
09458     iprot_->getTransport()->readEnd();
09459   }
09460   Hbase_getTableNames_presult result;
09461   result.success = &_return;
09462   result.read(iprot_);
09463   iprot_->readMessageEnd();
09464   iprot_->getTransport()->readEnd();
09465 
09466   if (result.__isset.success) {
09467     // _return pointer has now been filled
09468     return;
09469   }
09470   if (result.__isset.io) {
09471     throw result.io;
09472   }
09473   throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getTableNames failed: unknown result");
09474 }
09475 
09476 void HbaseClient::getColumnDescriptors(std::map<Text, ColumnDescriptor> & _return, const Text& tableName)
09477 {
09478   send_getColumnDescriptors(tableName);
09479   recv_getColumnDescriptors(_return);
09480 }
09481 
09482 void HbaseClient::send_getColumnDescriptors(const Text& tableName)
09483 {
09484   int32_t cseqid = 0;
09485   oprot_->writeMessageBegin("getColumnDescriptors", ::apache::thrift::protocol::T_CALL, cseqid);
09486 
09487   Hbase_getColumnDescriptors_pargs args;
09488   args.tableName = &tableName;
09489   args.write(oprot_);
09490 
09491   oprot_->writeMessageEnd();
09492   oprot_->getTransport()->writeEnd();
09493   oprot_->getTransport()->flush();
09494 }
09495 
09496 void HbaseClient::recv_getColumnDescriptors(std::map<Text, ColumnDescriptor> & _return)
09497 {
09498 
09499   int32_t rseqid = 0;
09500   std::string fname;
09501   ::apache::thrift::protocol::TMessageType mtype;
09502 
09503   iprot_->readMessageBegin(fname, mtype, rseqid);
09504   if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
09505     ::apache::thrift::TApplicationException x;
09506     x.read(iprot_);
09507     iprot_->readMessageEnd();
09508     iprot_->getTransport()->readEnd();
09509     throw x;
09510   }
09511   if (mtype != ::apache::thrift::protocol::T_REPLY) {
09512     iprot_->skip(::apache::thrift::protocol::T_STRUCT);
09513     iprot_->readMessageEnd();
09514     iprot_->getTransport()->readEnd();
09515   }
09516   if (fname.compare("getColumnDescriptors") != 0) {
09517     iprot_->skip(::apache::thrift::protocol::T_STRUCT);
09518     iprot_->readMessageEnd();
09519     iprot_->getTransport()->readEnd();
09520   }
09521   Hbase_getColumnDescriptors_presult result;
09522   result.success = &_return;
09523   result.read(iprot_);
09524   iprot_->readMessageEnd();
09525   iprot_->getTransport()->readEnd();
09526 
09527   if (result.__isset.success) {
09528     // _return pointer has now been filled
09529     return;
09530   }
09531   if (result.__isset.io) {
09532     throw result.io;
09533   }
09534   throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getColumnDescriptors failed: unknown result");
09535 }
09536 
09537 void HbaseClient::getTableRegions(std::vector<TRegionInfo> & _return, const Text& tableName)
09538 {
09539   send_getTableRegions(tableName);
09540   recv_getTableRegions(_return);
09541 }
09542 
09543 void HbaseClient::send_getTableRegions(const Text& tableName)
09544 {
09545   int32_t cseqid = 0;
09546   oprot_->writeMessageBegin("getTableRegions", ::apache::thrift::protocol::T_CALL, cseqid);
09547 
09548   Hbase_getTableRegions_pargs args;
09549   args.tableName = &tableName;
09550   args.write(oprot_);
09551 
09552   oprot_->writeMessageEnd();
09553   oprot_->getTransport()->writeEnd();
09554   oprot_->getTransport()->flush();
09555 }
09556 
09557 void HbaseClient::recv_getTableRegions(std::vector<TRegionInfo> & _return)
09558 {
09559 
09560   int32_t rseqid = 0;
09561   std::string fname;
09562   ::apache::thrift::protocol::TMessageType mtype;
09563 
09564   iprot_->readMessageBegin(fname, mtype, rseqid);
09565   if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
09566     ::apache::thrift::TApplicationException x;
09567     x.read(iprot_);
09568     iprot_->readMessageEnd();
09569     iprot_->getTransport()->readEnd();
09570     throw x;
09571   }
09572   if (mtype != ::apache::thrift::protocol::T_REPLY) {
09573     iprot_->skip(::apache::thrift::protocol::T_STRUCT);
09574     iprot_->readMessageEnd();
09575     iprot_->getTransport()->readEnd();
09576   }
09577   if (fname.compare("getTableRegions") != 0) {
09578     iprot_->skip(::apache::thrift::protocol::T_STRUCT);
09579     iprot_->readMessageEnd();
09580     iprot_->getTransport()->readEnd();
09581   }
09582   Hbase_getTableRegions_presult result;
09583   result.success = &_return;
09584   result.read(iprot_);
09585   iprot_->readMessageEnd();
09586   iprot_->getTransport()->readEnd();
09587 
09588   if (result.__isset.success) {
09589     // _return pointer has now been filled
09590     return;
09591   }
09592   if (result.__isset.io) {
09593     throw result.io;
09594   }
09595   throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getTableRegions failed: unknown result");
09596 }
09597 
09598 void HbaseClient::createTable(const Text& tableName, const std::vector<ColumnDescriptor> & columnFamilies)
09599 {
09600   send_createTable(tableName, columnFamilies);
09601   recv_createTable();
09602 }
09603 
09604 void HbaseClient::send_createTable(const Text& tableName, const std::vector<ColumnDescriptor> & columnFamilies)
09605 {
09606   int32_t cseqid = 0;
09607   oprot_->writeMessageBegin("createTable", ::apache::thrift::protocol::T_CALL, cseqid);
09608 
09609   Hbase_createTable_pargs args;
09610   args.tableName = &tableName;
09611   args.columnFamilies = &columnFamilies;
09612   args.write(oprot_);
09613 
09614   oprot_->writeMessageEnd();
09615   oprot_->getTransport()->writeEnd();
09616   oprot_->getTransport()->flush();
09617 }
09618 
09619 void HbaseClient::recv_createTable()
09620 {
09621 
09622   int32_t rseqid = 0;
09623   std::string fname;
09624   ::apache::thrift::protocol::TMessageType mtype;
09625 
09626   iprot_->readMessageBegin(fname, mtype, rseqid);
09627   if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
09628     ::apache::thrift::TApplicationException x;
09629     x.read(iprot_);
09630     iprot_->readMessageEnd();
09631     iprot_->getTransport()->readEnd();
09632     throw x;
09633   }
09634   if (mtype != ::apache::thrift::protocol::T_REPLY) {
09635     iprot_->skip(::apache::thrift::protocol::T_STRUCT);
09636     iprot_->readMessageEnd();
09637     iprot_->getTransport()->readEnd();
09638   }
09639   if (fname.compare("createTable") != 0) {
09640     iprot_->skip(::apache::thrift::protocol::T_STRUCT);
09641     iprot_->readMessageEnd();
09642     iprot_->getTransport()->readEnd();
09643   }
09644   Hbase_createTable_presult result;
09645   result.read(iprot_);
09646   iprot_->readMessageEnd();
09647   iprot_->getTransport()->readEnd();
09648 
09649   if (result.__isset.io) {
09650     throw result.io;
09651   }
09652   if (result.__isset.ia) {
09653     throw result.ia;
09654   }
09655   if (result.__isset.exist) {
09656     throw result.exist;
09657   }
09658   return;
09659 }
09660 
09661 void HbaseClient::deleteTable(const Text& tableName)
09662 {
09663   send_deleteTable(tableName);
09664   recv_deleteTable();
09665 }
09666 
09667 void HbaseClient::send_deleteTable(const Text& tableName)
09668 {
09669   int32_t cseqid = 0;
09670   oprot_->writeMessageBegin("deleteTable", ::apache::thrift::protocol::T_CALL, cseqid);
09671 
09672   Hbase_deleteTable_pargs args;
09673   args.tableName = &tableName;
09674   args.write(oprot_);
09675 
09676   oprot_->writeMessageEnd();
09677   oprot_->getTransport()->writeEnd();
09678   oprot_->getTransport()->flush();
09679 }
09680 
09681 void HbaseClient::recv_deleteTable()
09682 {
09683 
09684   int32_t rseqid = 0;
09685   std::string fname;
09686   ::apache::thrift::protocol::TMessageType mtype;
09687 
09688   iprot_->readMessageBegin(fname, mtype, rseqid);
09689   if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
09690     ::apache::thrift::TApplicationException x;
09691     x.read(iprot_);
09692     iprot_->readMessageEnd();
09693     iprot_->getTransport()->readEnd();
09694     throw x;
09695   }
09696   if (mtype != ::apache::thrift::protocol::T_REPLY) {
09697     iprot_->skip(::apache::thrift::protocol::T_STRUCT);
09698     iprot_->readMessageEnd();
09699     iprot_->getTransport()->readEnd();
09700   }
09701   if (fname.compare("deleteTable") != 0) {
09702     iprot_->skip(::apache::thrift::protocol::T_STRUCT);
09703     iprot_->readMessageEnd();
09704     iprot_->getTransport()->readEnd();
09705   }
09706   Hbase_deleteTable_presult result;
09707   result.read(iprot_);
09708   iprot_->readMessageEnd();
09709   iprot_->getTransport()->readEnd();
09710 
09711   if (result.__isset.io) {
09712     throw result.io;
09713   }
09714   return;
09715 }
09716 
09717 void HbaseClient::get(std::vector<TCell> & _return, const Text& tableName, const Text& row, const Text& column)
09718 {
09719   send_get(tableName, row, column);
09720   recv_get(_return);
09721 }
09722 
09723 void HbaseClient::send_get(const Text& tableName, const Text& row, const Text& column)
09724 {
09725   int32_t cseqid = 0;
09726   oprot_->writeMessageBegin("get", ::apache::thrift::protocol::T_CALL, cseqid);
09727 
09728   Hbase_get_pargs args;
09729   args.tableName = &tableName;
09730   args.row = &row;
09731   args.column = &column;
09732   args.write(oprot_);
09733 
09734   oprot_->writeMessageEnd();
09735   oprot_->getTransport()->writeEnd();
09736   oprot_->getTransport()->flush();
09737 }
09738 
09739 void HbaseClient::recv_get(std::vector<TCell> & _return)
09740 {
09741 
09742   int32_t rseqid = 0;
09743   std::string fname;
09744   ::apache::thrift::protocol::TMessageType mtype;
09745 
09746   iprot_->readMessageBegin(fname, mtype, rseqid);
09747   if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
09748     ::apache::thrift::TApplicationException x;
09749     x.read(iprot_);
09750     iprot_->readMessageEnd();
09751     iprot_->getTransport()->readEnd();
09752     throw x;
09753   }
09754   if (mtype != ::apache::thrift::protocol::T_REPLY) {
09755     iprot_->skip(::apache::thrift::protocol::T_STRUCT);
09756     iprot_->readMessageEnd();
09757     iprot_->getTransport()->readEnd();
09758   }
09759   if (fname.compare("get") != 0) {
09760     iprot_->skip(::apache::thrift::protocol::T_STRUCT);
09761     iprot_->readMessageEnd();
09762     iprot_->getTransport()->readEnd();
09763   }
09764   Hbase_get_presult result;
09765   result.success = &_return;
09766   result.read(iprot_);
09767   iprot_->readMessageEnd();
09768   iprot_->getTransport()->readEnd();
09769 
09770   if (result.__isset.success) {
09771     // _return pointer has now been filled
09772     return;
09773   }
09774   if (result.__isset.io) {
09775     throw result.io;
09776   }
09777   throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get failed: unknown result");
09778 }
09779 
09780 void HbaseClient::getVer(std::vector<TCell> & _return, const Text& tableName, const Text& row, const Text& column, const int32_t numVersions)
09781 {
09782   send_getVer(tableName, row, column, numVersions);
09783   recv_getVer(_return);
09784 }
09785 
09786 void HbaseClient::send_getVer(const Text& tableName, const Text& row, const Text& column, const int32_t numVersions)
09787 {
09788   int32_t cseqid = 0;
09789   oprot_->writeMessageBegin("getVer", ::apache::thrift::protocol::T_CALL, cseqid);
09790 
09791   Hbase_getVer_pargs args;
09792   args.tableName = &tableName;
09793   args.row = &row;
09794   args.column = &column;
09795   args.numVersions = &numVersions;
09796   args.write(oprot_);
09797 
09798   oprot_->writeMessageEnd();
09799   oprot_->getTransport()->writeEnd();
09800   oprot_->getTransport()->flush();
09801 }
09802 
09803 void HbaseClient::recv_getVer(std::vector<TCell> & _return)
09804 {
09805 
09806   int32_t rseqid = 0;
09807   std::string fname;
09808   ::apache::thrift::protocol::TMessageType mtype;
09809 
09810   iprot_->readMessageBegin(fname, mtype, rseqid);
09811   if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
09812     ::apache::thrift::TApplicationException x;
09813     x.read(iprot_);
09814     iprot_->readMessageEnd();
09815     iprot_->getTransport()->readEnd();
09816     throw x;
09817   }
09818   if (mtype != ::apache::thrift::protocol::T_REPLY) {
09819     iprot_->skip(::apache::thrift::protocol::T_STRUCT);
09820     iprot_->readMessageEnd();
09821     iprot_->getTransport()->readEnd();
09822   }
09823   if (fname.compare("getVer") != 0) {
09824     iprot_->skip(::apache::thrift::protocol::T_STRUCT);
09825     iprot_->readMessageEnd();
09826     iprot_->getTransport()->readEnd();
09827   }
09828   Hbase_getVer_presult result;
09829   result.success = &_return;
09830   result.read(iprot_);
09831   iprot_->readMessageEnd();
09832   iprot_->getTransport()->readEnd();
09833 
09834   if (result.__isset.success) {
09835     // _return pointer has now been filled
09836     return;
09837   }
09838   if (result.__isset.io) {
09839     throw result.io;
09840   }
09841   throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getVer failed: unknown result");
09842 }
09843 
09844 void HbaseClient::getVerTs(std::vector<TCell> & _return, const Text& tableName, const Text& row, const Text& column, const int64_t timestamp, const int32_t numVersions)
09845 {
09846   send_getVerTs(tableName, row, column, timestamp, numVersions);
09847   recv_getVerTs(_return);
09848 }
09849 
09850 void HbaseClient::send_getVerTs(const Text& tableName, const Text& row, const Text& column, const int64_t timestamp, const int32_t numVersions)
09851 {
09852   int32_t cseqid = 0;
09853   oprot_->writeMessageBegin("getVerTs", ::apache::thrift::protocol::T_CALL, cseqid);
09854 
09855   Hbase_getVerTs_pargs args;
09856   args.tableName = &tableName;
09857   args.row = &row;
09858   args.column = &column;
09859   args.timestamp = &timestamp;
09860   args.numVersions = &numVersions;
09861   args.write(oprot_);
09862 
09863   oprot_->writeMessageEnd();
09864   oprot_->getTransport()->writeEnd();
09865   oprot_->getTransport()->flush();
09866 }
09867 
09868 void HbaseClient::recv_getVerTs(std::vector<TCell> & _return)
09869 {
09870 
09871   int32_t rseqid = 0;
09872   std::string fname;
09873   ::apache::thrift::protocol::TMessageType mtype;
09874 
09875   iprot_->readMessageBegin(fname, mtype, rseqid);
09876   if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
09877     ::apache::thrift::TApplicationException x;
09878     x.read(iprot_);
09879     iprot_->readMessageEnd();
09880     iprot_->getTransport()->readEnd();
09881     throw x;
09882   }
09883   if (mtype != ::apache::thrift::protocol::T_REPLY) {
09884     iprot_->skip(::apache::thrift::protocol::T_STRUCT);
09885     iprot_->readMessageEnd();
09886     iprot_->getTransport()->readEnd();
09887   }
09888   if (fname.compare("getVerTs") != 0) {
09889     iprot_->skip(::apache::thrift::protocol::T_STRUCT);
09890     iprot_->readMessageEnd();
09891     iprot_->getTransport()->readEnd();
09892   }
09893   Hbase_getVerTs_presult result;
09894   result.success = &_return;
09895   result.read(iprot_);
09896   iprot_->readMessageEnd();
09897   iprot_->getTransport()->readEnd();
09898 
09899   if (result.__isset.success) {
09900     // _return pointer has now been filled
09901     return;
09902   }
09903   if (result.__isset.io) {
09904     throw result.io;
09905   }
09906   throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getVerTs failed: unknown result");
09907 }
09908 
09909 void HbaseClient::getRow(std::vector<TRowResult> & _return, const Text& tableName, const Text& row)
09910 {
09911   send_getRow(tableName, row);
09912   recv_getRow(_return);
09913 }
09914 
09915 void HbaseClient::send_getRow(const Text& tableName, const Text& row)
09916 {
09917   int32_t cseqid = 0;
09918   oprot_->writeMessageBegin("getRow", ::apache::thrift::protocol::T_CALL, cseqid);
09919 
09920   Hbase_getRow_pargs args;
09921   args.tableName = &tableName;
09922   args.row = &row;
09923   args.write(oprot_);
09924 
09925   oprot_->writeMessageEnd();
09926   oprot_->getTransport()->writeEnd();
09927   oprot_->getTransport()->flush();
09928 }
09929 
09930 void HbaseClient::recv_getRow(std::vector<TRowResult> & _return)
09931 {
09932 
09933   int32_t rseqid = 0;
09934   std::string fname;
09935   ::apache::thrift::protocol::TMessageType mtype;
09936 
09937   iprot_->readMessageBegin(fname, mtype, rseqid);
09938   if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
09939     ::apache::thrift::TApplicationException x;
09940     x.read(iprot_);
09941     iprot_->readMessageEnd();
09942     iprot_->getTransport()->readEnd();
09943     throw x;
09944   }
09945   if (mtype != ::apache::thrift::protocol::T_REPLY) {
09946     iprot_->skip(::apache::thrift::protocol::T_STRUCT);
09947     iprot_->readMessageEnd();
09948     iprot_->getTransport()->readEnd();
09949   }
09950   if (fname.compare("getRow") != 0) {
09951     iprot_->skip(::apache::thrift::protocol::T_STRUCT);
09952     iprot_->readMessageEnd();
09953     iprot_->getTransport()->readEnd();
09954   }
09955   Hbase_getRow_presult result;
09956   result.success = &_return;
09957   result.read(iprot_);
09958   iprot_->readMessageEnd();
09959   iprot_->getTransport()->readEnd();
09960 
09961   if (result.__isset.success) {
09962     // _return pointer has now been filled
09963     return;
09964   }
09965   if (result.__isset.io) {
09966     throw result.io;
09967   }
09968   throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getRow failed: unknown result");
09969 }
09970 
09971 void HbaseClient::getRowWithColumns(std::vector<TRowResult> & _return, const Text& tableName, const Text& row, const std::vector<Text> & columns)
09972 {
09973   send_getRowWithColumns(tableName, row, columns);
09974   recv_getRowWithColumns(_return);
09975 }
09976 
09977 void HbaseClient::send_getRowWithColumns(const Text& tableName, const Text& row, const std::vector<Text> & columns)
09978 {
09979   int32_t cseqid = 0;
09980   oprot_->writeMessageBegin("getRowWithColumns", ::apache::thrift::protocol::T_CALL, cseqid);
09981 
09982   Hbase_getRowWithColumns_pargs args;
09983   args.tableName = &tableName;
09984   args.row = &row;
09985   args.columns = &columns;
09986   args.write(oprot_);
09987 
09988   oprot_->writeMessageEnd();
09989   oprot_->getTransport()->writeEnd();
09990   oprot_->getTransport()->flush();
09991 }
09992 
09993 void HbaseClient::recv_getRowWithColumns(std::vector<TRowResult> & _return)
09994 {
09995 
09996   int32_t rseqid = 0;
09997   std::string fname;
09998   ::apache::thrift::protocol::TMessageType mtype;
09999 
10000   iprot_->readMessageBegin(fname, mtype, rseqid);
10001   if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
10002     ::apache::thrift::TApplicationException x;
10003     x.read(iprot_);
10004     iprot_->readMessageEnd();
10005     iprot_->getTransport()->readEnd();
10006     throw x;
10007   }
10008   if (mtype != ::apache::thrift::protocol::T_REPLY) {
10009     iprot_->skip(::apache::thrift::protocol::T_STRUCT);
10010     iprot_->readMessageEnd();
10011     iprot_->getTransport()->readEnd();
10012   }
10013   if (fname.compare("getRowWithColumns") != 0) {
10014     iprot_->skip(::apache::thrift::protocol::T_STRUCT);
10015     iprot_->readMessageEnd();
10016     iprot_->getTransport()->readEnd();
10017   }
10018   Hbase_getRowWithColumns_presult result;
10019   result.success = &_return;
10020   result.read(iprot_);
10021   iprot_->readMessageEnd();
10022   iprot_->getTransport()->readEnd();
10023 
10024   if (result.__isset.success) {
10025     // _return pointer has now been filled
10026     return;
10027   }
10028   if (result.__isset.io) {
10029     throw result.io;
10030   }
10031   throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getRowWithColumns failed: unknown result");
10032 }
10033 
10034 void HbaseClient::getRowTs(std::vector<TRowResult> & _return, const Text& tableName, const Text& row, const int64_t timestamp)
10035 {
10036   send_getRowTs(tableName, row, timestamp);
10037   recv_getRowTs(_return);
10038 }
10039 
10040 void HbaseClient::send_getRowTs(const Text& tableName, const Text& row, const int64_t timestamp)
10041 {
10042   int32_t cseqid = 0;
10043   oprot_->writeMessageBegin("getRowTs", ::apache::thrift::protocol::T_CALL, cseqid);
10044 
10045   Hbase_getRowTs_pargs args;
10046   args.tableName = &tableName;
10047   args.row = &row;
10048   args.timestamp = &timestamp;
10049   args.write(oprot_);
10050 
10051   oprot_->writeMessageEnd();
10052   oprot_->getTransport()->writeEnd();
10053   oprot_->getTransport()->flush();
10054 }
10055 
10056 void HbaseClient::recv_getRowTs(std::vector<TRowResult> & _return)
10057 {
10058 
10059   int32_t rseqid = 0;
10060   std::string fname;
10061   ::apache::thrift::protocol::TMessageType mtype;
10062 
10063   iprot_->readMessageBegin(fname, mtype, rseqid);
10064   if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
10065     ::apache::thrift::TApplicationException x;
10066     x.read(iprot_);
10067     iprot_->readMessageEnd();
10068     iprot_->getTransport()->readEnd();
10069     throw x;
10070   }
10071   if (mtype != ::apache::thrift::protocol::T_REPLY) {
10072     iprot_->skip(::apache::thrift::protocol::T_STRUCT);
10073     iprot_->readMessageEnd();
10074     iprot_->getTransport()->readEnd();
10075   }
10076   if (fname.compare("getRowTs") != 0) {
10077     iprot_->skip(::apache::thrift::protocol::T_STRUCT);
10078     iprot_->readMessageEnd();
10079     iprot_->getTransport()->readEnd();
10080   }
10081   Hbase_getRowTs_presult result;
10082   result.success = &_return;
10083   result.read(iprot_);
10084   iprot_->readMessageEnd();
10085   iprot_->getTransport()->readEnd();
10086 
10087   if (result.__isset.success) {
10088     // _return pointer has now been filled
10089     return;
10090   }
10091   if (result.__isset.io) {
10092     throw result.io;
10093   }
10094   throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getRowTs failed: unknown result");
10095 }
10096 
10097 void HbaseClient::getRowWithColumnsTs(std::vector<TRowResult> & _return, const Text& tableName, const Text& row, const std::vector<Text> & columns, const int64_t timestamp)
10098 {
10099   send_getRowWithColumnsTs(tableName, row, columns, timestamp);
10100   recv_getRowWithColumnsTs(_return);
10101 }
10102 
10103 void HbaseClient::send_getRowWithColumnsTs(const Text& tableName, const Text& row, const std::vector<Text> & columns, const int64_t timestamp)
10104 {
10105   int32_t cseqid = 0;
10106   oprot_->writeMessageBegin("getRowWithColumnsTs", ::apache::thrift::protocol::T_CALL, cseqid);
10107 
10108   Hbase_getRowWithColumnsTs_pargs args;
10109   args.tableName = &tableName;
10110   args.row = &row;
10111   args.columns = &columns;
10112   args.timestamp = &timestamp;
10113   args.write(oprot_);
10114 
10115   oprot_->writeMessageEnd();
10116   oprot_->getTransport()->writeEnd();
10117   oprot_->getTransport()->flush();
10118 }
10119 
10120 void HbaseClient::recv_getRowWithColumnsTs(std::vector<TRowResult> & _return)
10121 {
10122 
10123   int32_t rseqid = 0;
10124   std::string fname;
10125   ::apache::thrift::protocol::TMessageType mtype;
10126 
10127   iprot_->readMessageBegin(fname, mtype, rseqid);
10128   if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
10129     ::apache::thrift::TApplicationException x;
10130     x.read(iprot_);
10131     iprot_->readMessageEnd();
10132     iprot_->getTransport()->readEnd();
10133     throw x;
10134   }
10135   if (mtype != ::apache::thrift::protocol::T_REPLY) {
10136     iprot_->skip(::apache::thrift::protocol::T_STRUCT);
10137     iprot_->readMessageEnd();
10138     iprot_->getTransport()->readEnd();
10139   }
10140   if (fname.compare("getRowWithColumnsTs") != 0) {
10141     iprot_->skip(::apache::thrift::protocol::T_STRUCT);
10142     iprot_->readMessageEnd();
10143     iprot_->getTransport()->readEnd();
10144   }
10145   Hbase_getRowWithColumnsTs_presult result;
10146   result.success = &_return;
10147   result.read(iprot_);
10148   iprot_->readMessageEnd();
10149   iprot_->getTransport()->readEnd();
10150 
10151   if (result.__isset.success) {
10152     // _return pointer has now been filled
10153     return;
10154   }
10155   if (result.__isset.io) {
10156     throw result.io;
10157   }
10158   throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getRowWithColumnsTs failed: unknown result");
10159 }
10160 
10161 void HbaseClient::getRows(std::vector<TRowResult> & _return, const Text& tableName, const std::vector<Text> & rows)
10162 {
10163   send_getRows(tableName, rows);
10164   recv_getRows(_return);
10165 }
10166 
10167 void HbaseClient::send_getRows(const Text& tableName, const std::vector<Text> & rows)
10168 {
10169   int32_t cseqid = 0;
10170   oprot_->writeMessageBegin("getRows", ::apache::thrift::protocol::T_CALL, cseqid);
10171 
10172   Hbase_getRows_pargs args;
10173   args.tableName = &tableName;
10174   args.rows = &rows;
10175   args.write(oprot_);
10176 
10177   oprot_->writeMessageEnd();
10178   oprot_->getTransport()->writeEnd();
10179   oprot_->getTransport()->flush();
10180 }
10181 
10182 void HbaseClient::recv_getRows(std::vector<TRowResult> & _return)
10183 {
10184 
10185   int32_t rseqid = 0;
10186   std::string fname;
10187   ::apache::thrift::protocol::TMessageType mtype;
10188 
10189   iprot_->readMessageBegin(fname, mtype, rseqid);
10190   if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
10191     ::apache::thrift::TApplicationException x;
10192     x.read(iprot_);
10193     iprot_->readMessageEnd();
10194     iprot_->getTransport()->readEnd();
10195     throw x;
10196   }
10197   if (mtype != ::apache::thrift::protocol::T_REPLY) {
10198     iprot_->skip(::apache::thrift::protocol::T_STRUCT);
10199     iprot_->readMessageEnd();
10200     iprot_->getTransport()->readEnd();
10201   }
10202   if (fname.compare("getRows") != 0) {
10203     iprot_->skip(::apache::thrift::protocol::T_STRUCT);
10204     iprot_->readMessageEnd();
10205     iprot_->getTransport()->readEnd();
10206   }
10207   Hbase_getRows_presult result;
10208   result.success = &_return;
10209   result.read(iprot_);
10210   iprot_->readMessageEnd();
10211   iprot_->getTransport()->readEnd();
10212 
10213   if (result.__isset.success) {
10214     // _return pointer has now been filled
10215     return;
10216   }
10217   if (result.__isset.io) {
10218     throw result.io;
10219   }
10220   throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getRows failed: unknown result");
10221 }
10222 
10223 void HbaseClient::getRowsWithColumns(std::vector<TRowResult> & _return, const Text& tableName, const std::vector<Text> & rows, const std::vector<Text> & columns)
10224 {
10225   send_getRowsWithColumns(tableName, rows, columns);
10226   recv_getRowsWithColumns(_return);
10227 }
10228 
10229 void HbaseClient::send_getRowsWithColumns(const Text& tableName, const std::vector<Text> & rows, const std::vector<Text> & columns)
10230 {
10231   int32_t cseqid = 0;
10232   oprot_->writeMessageBegin("getRowsWithColumns", ::apache::thrift::protocol::T_CALL, cseqid);
10233 
10234   Hbase_getRowsWithColumns_pargs args;
10235   args.tableName = &tableName;
10236   args.rows = &rows;
10237   args.columns = &columns;
10238   args.write(oprot_);
10239 
10240   oprot_->writeMessageEnd();
10241   oprot_->getTransport()->writeEnd();
10242   oprot_->getTransport()->flush();
10243 }
10244 
10245 void HbaseClient::recv_getRowsWithColumns(std::vector<TRowResult> & _return)
10246 {
10247 
10248   int32_t rseqid = 0;
10249   std::string fname;
10250   ::apache::thrift::protocol::TMessageType mtype;
10251 
10252   iprot_->readMessageBegin(fname, mtype, rseqid);
10253   if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
10254     ::apache::thrift::TApplicationException x;
10255     x.read(iprot_);
10256     iprot_->readMessageEnd();
10257     iprot_->getTransport()->readEnd();
10258     throw x;
10259   }
10260   if (mtype != ::apache::thrift::protocol::T_REPLY) {
10261     iprot_->skip(::apache::thrift::protocol::T_STRUCT);
10262     iprot_->readMessageEnd();
10263     iprot_->getTransport()->readEnd();
10264   }
10265   if (fname.compare("getRowsWithColumns") != 0) {
10266     iprot_->skip(::apache::thrift::protocol::T_STRUCT);
10267     iprot_->readMessageEnd();
10268     iprot_->getTransport()->readEnd();
10269   }
10270   Hbase_getRowsWithColumns_presult result;
10271   result.success = &_return;
10272   result.read(iprot_);
10273   iprot_->readMessageEnd();
10274   iprot_->getTransport()->readEnd();
10275 
10276   if (result.__isset.success) {
10277     // _return pointer has now been filled
10278     return;
10279   }
10280   if (result.__isset.io) {
10281     throw result.io;
10282   }
10283   throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getRowsWithColumns failed: unknown result");
10284 }
10285 
10286 void HbaseClient::getRowsTs(std::vector<TRowResult> & _return, const Text& tableName, const std::vector<Text> & rows, const int64_t timestamp)
10287 {
10288   send_getRowsTs(tableName, rows, timestamp);
10289   recv_getRowsTs(_return);
10290 }
10291 
10292 void HbaseClient::send_getRowsTs(const Text& tableName, const std::vector<Text> & rows, const int64_t timestamp)
10293 {
10294   int32_t cseqid = 0;
10295   oprot_->writeMessageBegin("getRowsTs", ::apache::thrift::protocol::T_CALL, cseqid);
10296 
10297   Hbase_getRowsTs_pargs args;
10298   args.tableName = &tableName;
10299   args.rows = &rows;
10300   args.timestamp = &timestamp;
10301   args.write(oprot_);
10302 
10303   oprot_->writeMessageEnd();
10304   oprot_->getTransport()->writeEnd();
10305   oprot_->getTransport()->flush();
10306 }
10307 
10308 void HbaseClient::recv_getRowsTs(std::vector<TRowResult> & _return)
10309 {
10310 
10311   int32_t rseqid = 0;
10312   std::string fname;
10313   ::apache::thrift::protocol::TMessageType mtype;
10314 
10315   iprot_->readMessageBegin(fname, mtype, rseqid);
10316   if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
10317     ::apache::thrift::TApplicationException x;
10318     x.read(iprot_);
10319     iprot_->readMessageEnd();
10320     iprot_->getTransport()->readEnd();
10321     throw x;
10322   }
10323   if (mtype != ::apache::thrift::protocol::T_REPLY) {
10324     iprot_->skip(::apache::thrift::protocol::T_STRUCT);
10325     iprot_->readMessageEnd();
10326     iprot_->getTransport()->readEnd();
10327   }
10328   if (fname.compare("getRowsTs") != 0) {
10329     iprot_->skip(::apache::thrift::protocol::T_STRUCT);
10330     iprot_->readMessageEnd();
10331     iprot_->getTransport()->readEnd();
10332   }
10333   Hbase_getRowsTs_presult result;
10334   result.success = &_return;
10335   result.read(iprot_);
10336   iprot_->readMessageEnd();
10337   iprot_->getTransport()->readEnd();
10338 
10339   if (result.__isset.success) {
10340     // _return pointer has now been filled
10341     return;
10342   }
10343   if (result.__isset.io) {
10344     throw result.io;
10345   }
10346   throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getRowsTs failed: unknown result");
10347 }
10348 
10349 void HbaseClient::getRowsWithColumnsTs(std::vector<TRowResult> & _return, const Text& tableName, const std::vector<Text> & rows, const std::vector<Text> & columns, const int64_t timestamp)
10350 {
10351   send_getRowsWithColumnsTs(tableName, rows, columns, timestamp);
10352   recv_getRowsWithColumnsTs(_return);
10353 }
10354 
10355 void HbaseClient::send_getRowsWithColumnsTs(const Text& tableName, const std::vector<Text> & rows, const std::vector<Text> & columns, const int64_t timestamp)
10356 {
10357   int32_t cseqid = 0;
10358   oprot_->writeMessageBegin("getRowsWithColumnsTs", ::apache::thrift::protocol::T_CALL, cseqid);
10359 
10360   Hbase_getRowsWithColumnsTs_pargs args;
10361   args.tableName = &tableName;
10362   args.rows = &rows;
10363   args.columns = &columns;
10364   args.timestamp = &timestamp;
10365   args.write(oprot_);
10366 
10367   oprot_->writeMessageEnd();
10368   oprot_->getTransport()->writeEnd();
10369   oprot_->getTransport()->flush();
10370 }
10371 
10372 void HbaseClient::recv_getRowsWithColumnsTs(std::vector<TRowResult> & _return)
10373 {
10374 
10375   int32_t rseqid = 0;
10376   std::string fname;
10377   ::apache::thrift::protocol::TMessageType mtype;
10378 
10379   iprot_->readMessageBegin(fname, mtype, rseqid);
10380   if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
10381     ::apache::thrift::TApplicationException x;
10382     x.read(iprot_);
10383     iprot_->readMessageEnd();
10384     iprot_->getTransport()->readEnd();
10385     throw x;
10386   }
10387   if (mtype != ::apache::thrift::protocol::T_REPLY) {
10388     iprot_->skip(::apache::thrift::protocol::T_STRUCT);
10389     iprot_->readMessageEnd();
10390     iprot_->getTransport()->readEnd();
10391   }
10392   if (fname.compare("getRowsWithColumnsTs") != 0) {
10393     iprot_->skip(::apache::thrift::protocol::T_STRUCT);
10394     iprot_->readMessageEnd();
10395     iprot_->getTransport()->readEnd();
10396   }
10397   Hbase_getRowsWithColumnsTs_presult result;
10398   result.success = &_return;
10399   result.read(iprot_);
10400   iprot_->readMessageEnd();
10401   iprot_->getTransport()->readEnd();
10402 
10403   if (result.__isset.success) {
10404     // _return pointer has now been filled
10405     return;
10406   }
10407   if (result.__isset.io) {
10408     throw result.io;
10409   }
10410   throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getRowsWithColumnsTs failed: unknown result");
10411 }
10412 
10413 void HbaseClient::mutateRow(const Text& tableName, const Text& row, const std::vector<Mutation> & mutations)
10414 {
10415   send_mutateRow(tableName, row, mutations);
10416   recv_mutateRow();
10417 }
10418 
10419 void HbaseClient::send_mutateRow(const Text& tableName, const Text& row, const std::vector<Mutation> & mutations)
10420 {
10421   int32_t cseqid = 0;
10422   oprot_->writeMessageBegin("mutateRow", ::apache::thrift::protocol::T_CALL, cseqid);
10423 
10424   Hbase_mutateRow_pargs args;
10425   args.tableName = &tableName;
10426   args.row = &row;
10427   args.mutations = &mutations;
10428   args.write(oprot_);
10429 
10430   oprot_->writeMessageEnd();
10431   oprot_->getTransport()->writeEnd();
10432   oprot_->getTransport()->flush();
10433 }
10434 
10435 void HbaseClient::recv_mutateRow()
10436 {
10437 
10438   int32_t rseqid = 0;
10439   std::string fname;
10440   ::apache::thrift::protocol::TMessageType mtype;
10441 
10442   iprot_->readMessageBegin(fname, mtype, rseqid);
10443   if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
10444     ::apache::thrift::TApplicationException x;
10445     x.read(iprot_);
10446     iprot_->readMessageEnd();
10447     iprot_->getTransport()->readEnd();
10448     throw x;
10449   }
10450   if (mtype != ::apache::thrift::protocol::T_REPLY) {
10451     iprot_->skip(::apache::thrift::protocol::T_STRUCT);
10452     iprot_->readMessageEnd();
10453     iprot_->getTransport()->readEnd();
10454   }
10455   if (fname.compare("mutateRow") != 0) {
10456     iprot_->skip(::apache::thrift::protocol::T_STRUCT);
10457     iprot_->readMessageEnd();
10458     iprot_->getTransport()->readEnd();
10459   }
10460   Hbase_mutateRow_presult result;
10461   result.read(iprot_);
10462   iprot_->readMessageEnd();
10463   iprot_->getTransport()->readEnd();
10464 
10465   if (result.__isset.io) {
10466     throw result.io;
10467   }
10468   if (result.__isset.ia) {
10469     throw result.ia;
10470   }
10471   return;
10472 }
10473 
10474 void HbaseClient::mutateRowTs(const Text& tableName, const Text& row, const std::vector<Mutation> & mutations, const int64_t timestamp)
10475 {
10476   send_mutateRowTs(tableName, row, mutations, timestamp);
10477   recv_mutateRowTs();
10478 }
10479 
10480 void HbaseClient::send_mutateRowTs(const Text& tableName, const Text& row, const std::vector<Mutation> & mutations, const int64_t timestamp)
10481 {
10482   int32_t cseqid = 0;
10483   oprot_->writeMessageBegin("mutateRowTs", ::apache::thrift::protocol::T_CALL, cseqid);
10484 
10485   Hbase_mutateRowTs_pargs args;
10486   args.tableName = &tableName;
10487   args.row = &row;
10488   args.mutations = &mutations;
10489   args.timestamp = &timestamp;
10490   args.write(oprot_);
10491 
10492   oprot_->writeMessageEnd();
10493   oprot_->getTransport()->writeEnd();
10494   oprot_->getTransport()->flush();
10495 }
10496 
10497 void HbaseClient::recv_mutateRowTs()
10498 {
10499 
10500   int32_t rseqid = 0;
10501   std::string fname;
10502   ::apache::thrift::protocol::TMessageType mtype;
10503 
10504   iprot_->readMessageBegin(fname, mtype, rseqid);
10505   if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
10506     ::apache::thrift::TApplicationException x;
10507     x.read(iprot_);
10508     iprot_->readMessageEnd();
10509     iprot_->getTransport()->readEnd();
10510     throw x;
10511   }
10512   if (mtype != ::apache::thrift::protocol::T_REPLY) {
10513     iprot_->skip(::apache::thrift::protocol::T_STRUCT);
10514     iprot_->readMessageEnd();
10515     iprot_->getTransport()->readEnd();
10516   }
10517   if (fname.compare("mutateRowTs") != 0) {
10518     iprot_->skip(::apache::thrift::protocol::T_STRUCT);
10519     iprot_->readMessageEnd();
10520     iprot_->getTransport()->readEnd();
10521   }
10522   Hbase_mutateRowTs_presult result;
10523   result.read(iprot_);
10524   iprot_->readMessageEnd();
10525   iprot_->getTransport()->readEnd();
10526 
10527   if (result.__isset.io) {
10528     throw result.io;
10529   }
10530   if (result.__isset.ia) {
10531     throw result.ia;
10532   }
10533   return;
10534 }
10535 
10536 void HbaseClient::mutateRows(const Text& tableName, const std::vector<BatchMutation> & rowBatches)
10537 {
10538   send_mutateRows(tableName, rowBatches);
10539   recv_mutateRows();
10540 }
10541 
10542 void HbaseClient::send_mutateRows(const Text& tableName, const std::vector<BatchMutation> & rowBatches)
10543 {
10544   int32_t cseqid = 0;
10545   oprot_->writeMessageBegin("mutateRows", ::apache::thrift::protocol::T_CALL, cseqid);
10546 
10547   Hbase_mutateRows_pargs args;
10548   args.tableName = &tableName;
10549   args.rowBatches = &rowBatches;
10550   args.write(oprot_);
10551 
10552   oprot_->writeMessageEnd();
10553   oprot_->getTransport()->writeEnd();
10554   oprot_->getTransport()->flush();
10555 }
10556 
10557 void HbaseClient::recv_mutateRows()
10558 {
10559 
10560   int32_t rseqid = 0;
10561   std::string fname;
10562   ::apache::thrift::protocol::TMessageType mtype;
10563 
10564   iprot_->readMessageBegin(fname, mtype, rseqid);
10565   if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
10566     ::apache::thrift::TApplicationException x;
10567     x.read(iprot_);
10568     iprot_->readMessageEnd();
10569     iprot_->getTransport()->readEnd();
10570     throw x;
10571   }
10572   if (mtype != ::apache::thrift::protocol::T_REPLY) {
10573     iprot_->skip(::apache::thrift::protocol::T_STRUCT);
10574     iprot_->readMessageEnd();
10575     iprot_->getTransport()->readEnd();
10576   }
10577   if (fname.compare("mutateRows") != 0) {
10578     iprot_->skip(::apache::thrift::protocol::T_STRUCT);
10579     iprot_->readMessageEnd();
10580     iprot_->getTransport()->readEnd();
10581   }
10582   Hbase_mutateRows_presult result;
10583   result.read(iprot_);
10584   iprot_->readMessageEnd();
10585   iprot_->getTransport()->readEnd();
10586 
10587   if (result.__isset.io) {
10588     throw result.io;
10589   }
10590   if (result.__isset.ia) {
10591     throw result.ia;
10592   }
10593   return;
10594 }
10595 
10596 void HbaseClient::mutateRowsTs(const Text& tableName, const std::vector<BatchMutation> & rowBatches, const int64_t timestamp)
10597 {
10598   send_mutateRowsTs(tableName, rowBatches, timestamp);
10599   recv_mutateRowsTs();
10600 }
10601 
10602 void HbaseClient::send_mutateRowsTs(const Text& tableName, const std::vector<BatchMutation> & rowBatches, const int64_t timestamp)
10603 {
10604   int32_t cseqid = 0;
10605   oprot_->writeMessageBegin("mutateRowsTs", ::apache::thrift::protocol::T_CALL, cseqid);
10606 
10607   Hbase_mutateRowsTs_pargs args;
10608   args.tableName = &tableName;
10609   args.rowBatches = &rowBatches;
10610   args.timestamp = &timestamp;
10611   args.write(oprot_);
10612 
10613   oprot_->writeMessageEnd();
10614   oprot_->getTransport()->writeEnd();
10615   oprot_->getTransport()->flush();
10616 }
10617 
10618 void HbaseClient::recv_mutateRowsTs()
10619 {
10620 
10621   int32_t rseqid = 0;
10622   std::string fname;
10623   ::apache::thrift::protocol::TMessageType mtype;
10624 
10625   iprot_->readMessageBegin(fname, mtype, rseqid);
10626   if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
10627     ::apache::thrift::TApplicationException x;
10628     x.read(iprot_);
10629     iprot_->readMessageEnd();
10630     iprot_->getTransport()->readEnd();
10631     throw x;
10632   }
10633   if (mtype != ::apache::thrift::protocol::T_REPLY) {
10634     iprot_->skip(::apache::thrift::protocol::T_STRUCT);
10635     iprot_->readMessageEnd();
10636     iprot_->getTransport()->readEnd();
10637   }
10638   if (fname.compare("mutateRowsTs") != 0) {
10639     iprot_->skip(::apache::thrift::protocol::T_STRUCT);
10640     iprot_->readMessageEnd();
10641     iprot_->getTransport()->readEnd();
10642   }
10643   Hbase_mutateRowsTs_presult result;
10644   result.read(iprot_);
10645   iprot_->readMessageEnd();
10646   iprot_->getTransport()->readEnd();
10647 
10648   if (result.__isset.io) {
10649     throw result.io;
10650   }
10651   if (result.__isset.ia) {
10652     throw result.ia;
10653   }
10654   return;
10655 }
10656 
10657 int64_t HbaseClient::atomicIncrement(const Text& tableName, const Text& row, const Text& column, const int64_t value)
10658 {
10659   send_atomicIncrement(tableName, row, column, value);
10660   return recv_atomicIncrement();
10661 }
10662 
10663 void HbaseClient::send_atomicIncrement(const Text& tableName, const Text& row, const Text& column, const int64_t value)
10664 {
10665   int32_t cseqid = 0;
10666   oprot_->writeMessageBegin("atomicIncrement", ::apache::thrift::protocol::T_CALL, cseqid);
10667 
10668   Hbase_atomicIncrement_pargs args;
10669   args.tableName = &tableName;
10670   args.row = &row;
10671   args.column = &column;
10672   args.value = &value;
10673   args.write(oprot_);
10674 
10675   oprot_->writeMessageEnd();
10676   oprot_->getTransport()->writeEnd();
10677   oprot_->getTransport()->flush();
10678 }
10679 
10680 int64_t HbaseClient::recv_atomicIncrement()
10681 {
10682 
10683   int32_t rseqid = 0;
10684   std::string fname;
10685   ::apache::thrift::protocol::TMessageType mtype;
10686 
10687   iprot_->readMessageBegin(fname, mtype, rseqid);
10688   if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
10689     ::apache::thrift::TApplicationException x;
10690     x.read(iprot_);
10691     iprot_->readMessageEnd();
10692     iprot_->getTransport()->readEnd();
10693     throw x;
10694   }
10695   if (mtype != ::apache::thrift::protocol::T_REPLY) {
10696     iprot_->skip(::apache::thrift::protocol::T_STRUCT);
10697     iprot_->readMessageEnd();
10698     iprot_->getTransport()->readEnd();
10699   }
10700   if (fname.compare("atomicIncrement") != 0) {
10701     iprot_->skip(::apache::thrift::protocol::T_STRUCT);
10702     iprot_->readMessageEnd();
10703     iprot_->getTransport()->readEnd();
10704   }
10705   int64_t _return;
10706   Hbase_atomicIncrement_presult result;
10707   result.success = &_return;
10708   result.read(iprot_);
10709   iprot_->readMessageEnd();
10710   iprot_->getTransport()->readEnd();
10711 
10712   if (result.__isset.success) {
10713     return _return;
10714   }
10715   if (result.__isset.io) {
10716     throw result.io;
10717   }
10718   if (result.__isset.ia) {
10719     throw result.ia;
10720   }
10721   throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "atomicIncrement failed: unknown result");
10722 }
10723 
10724 void HbaseClient::deleteAll(const Text& tableName, const Text& row, const Text& column)
10725 {
10726   send_deleteAll(tableName, row, column);
10727   recv_deleteAll();
10728 }
10729 
10730 void HbaseClient::send_deleteAll(const Text& tableName, const Text& row, const Text& column)
10731 {
10732   int32_t cseqid = 0;
10733   oprot_->writeMessageBegin("deleteAll", ::apache::thrift::protocol::T_CALL, cseqid);
10734 
10735   Hbase_deleteAll_pargs args;
10736   args.tableName = &tableName;
10737   args.row = &row;
10738   args.column = &column;
10739   args.write(oprot_);
10740 
10741   oprot_->writeMessageEnd();
10742   oprot_->getTransport()->writeEnd();
10743   oprot_->getTransport()->flush();
10744 }
10745 
10746 void HbaseClient::recv_deleteAll()
10747 {
10748 
10749   int32_t rseqid = 0;
10750   std::string fname;
10751   ::apache::thrift::protocol::TMessageType mtype;
10752 
10753   iprot_->readMessageBegin(fname, mtype, rseqid);
10754   if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
10755     ::apache::thrift::TApplicationException x;
10756     x.read(iprot_);
10757     iprot_->readMessageEnd();
10758     iprot_->getTransport()->readEnd();
10759     throw x;
10760   }
10761   if (mtype != ::apache::thrift::protocol::T_REPLY) {
10762     iprot_->skip(::apache::thrift::protocol::T_STRUCT);
10763     iprot_->readMessageEnd();
10764     iprot_->getTransport()->readEnd();
10765   }
10766   if (fname.compare("deleteAll") != 0) {
10767     iprot_->skip(::apache::thrift::protocol::T_STRUCT);
10768     iprot_->readMessageEnd();
10769     iprot_->getTransport()->readEnd();
10770   }
10771   Hbase_deleteAll_presult result;
10772   result.read(iprot_);
10773   iprot_->readMessageEnd();
10774   iprot_->getTransport()->readEnd();
10775 
10776   if (result.__isset.io) {
10777     throw result.io;
10778   }
10779   return;
10780 }
10781 
10782 void HbaseClient::deleteAllTs(const Text& tableName, const Text& row, const Text& column, const int64_t timestamp)
10783 {
10784   send_deleteAllTs(tableName, row, column, timestamp);
10785   recv_deleteAllTs();
10786 }
10787 
10788 void HbaseClient::send_deleteAllTs(const Text& tableName, const Text& row, const Text& column, const int64_t timestamp)
10789 {
10790   int32_t cseqid = 0;
10791   oprot_->writeMessageBegin("deleteAllTs", ::apache::thrift::protocol::T_CALL, cseqid);
10792 
10793   Hbase_deleteAllTs_pargs args;
10794   args.tableName = &tableName;
10795   args.row = &row;
10796   args.column = &column;
10797   args.timestamp = &timestamp;
10798   args.write(oprot_);
10799 
10800   oprot_->writeMessageEnd();
10801   oprot_->getTransport()->writeEnd();
10802   oprot_->getTransport()->flush();
10803 }
10804 
10805 void HbaseClient::recv_deleteAllTs()
10806 {
10807 
10808   int32_t rseqid = 0;
10809   std::string fname;
10810   ::apache::thrift::protocol::TMessageType mtype;
10811 
10812   iprot_->readMessageBegin(fname, mtype, rseqid);
10813   if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
10814     ::apache::thrift::TApplicationException x;
10815     x.read(iprot_);
10816     iprot_->readMessageEnd();
10817     iprot_->getTransport()->readEnd();
10818     throw x;
10819   }
10820   if (mtype != ::apache::thrift::protocol::T_REPLY) {
10821     iprot_->skip(::apache::thrift::protocol::T_STRUCT);
10822     iprot_->readMessageEnd();
10823     iprot_->getTransport()->readEnd();
10824   }
10825   if (fname.compare("deleteAllTs") != 0) {
10826     iprot_->skip(::apache::thrift::protocol::T_STRUCT);
10827     iprot_->readMessageEnd();
10828     iprot_->getTransport()->readEnd();
10829   }
10830   Hbase_deleteAllTs_presult result;
10831   result.read(iprot_);
10832   iprot_->readMessageEnd();
10833   iprot_->getTransport()->readEnd();
10834 
10835   if (result.__isset.io) {
10836     throw result.io;
10837   }
10838   return;
10839 }
10840 
10841 void HbaseClient::deleteAllRow(const Text& tableName, const Text& row)
10842 {
10843   send_deleteAllRow(tableName, row);
10844   recv_deleteAllRow();
10845 }
10846 
10847 void HbaseClient::send_deleteAllRow(const Text& tableName, const Text& row)
10848 {
10849   int32_t cseqid = 0;
10850   oprot_->writeMessageBegin("deleteAllRow", ::apache::thrift::protocol::T_CALL, cseqid);
10851 
10852   Hbase_deleteAllRow_pargs args;
10853   args.tableName = &tableName;
10854   args.row = &row;
10855   args.write(oprot_);
10856 
10857   oprot_->writeMessageEnd();
10858   oprot_->getTransport()->writeEnd();
10859   oprot_->getTransport()->flush();
10860 }
10861 
10862 void HbaseClient::recv_deleteAllRow()
10863 {
10864 
10865   int32_t rseqid = 0;
10866   std::string fname;
10867   ::apache::thrift::protocol::TMessageType mtype;
10868 
10869   iprot_->readMessageBegin(fname, mtype, rseqid);
10870   if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
10871     ::apache::thrift::TApplicationException x;
10872     x.read(iprot_);
10873     iprot_->readMessageEnd();
10874     iprot_->getTransport()->readEnd();
10875     throw x;
10876   }
10877   if (mtype != ::apache::thrift::protocol::T_REPLY) {
10878     iprot_->skip(::apache::thrift::protocol::T_STRUCT);
10879     iprot_->readMessageEnd();
10880     iprot_->getTransport()->readEnd();
10881   }
10882   if (fname.compare("deleteAllRow") != 0) {
10883     iprot_->skip(::apache::thrift::protocol::T_STRUCT);
10884     iprot_->readMessageEnd();
10885     iprot_->getTransport()->readEnd();
10886   }
10887   Hbase_deleteAllRow_presult result;
10888   result.read(iprot_);
10889   iprot_->readMessageEnd();
10890   iprot_->getTransport()->readEnd();
10891 
10892   if (result.__isset.io) {
10893     throw result.io;
10894   }
10895   return;
10896 }
10897 
10898 void HbaseClient::deleteAllRowTs(const Text& tableName, const Text& row, const int64_t timestamp)
10899 {
10900   send_deleteAllRowTs(tableName, row, timestamp);
10901   recv_deleteAllRowTs();
10902 }
10903 
10904 void HbaseClient::send_deleteAllRowTs(const Text& tableName, const Text& row, const int64_t timestamp)
10905 {
10906   int32_t cseqid = 0;
10907   oprot_->writeMessageBegin("deleteAllRowTs", ::apache::thrift::protocol::T_CALL, cseqid);
10908 
10909   Hbase_deleteAllRowTs_pargs args;
10910   args.tableName = &tableName;
10911   args.row = &row;
10912   args.timestamp = &timestamp;
10913   args.write(oprot_);
10914 
10915   oprot_->writeMessageEnd();
10916   oprot_->getTransport()->writeEnd();
10917   oprot_->getTransport()->flush();
10918 }
10919 
10920 void HbaseClient::recv_deleteAllRowTs()
10921 {
10922 
10923   int32_t rseqid = 0;
10924   std::string fname;
10925   ::apache::thrift::protocol::TMessageType mtype;
10926 
10927   iprot_->readMessageBegin(fname, mtype, rseqid);
10928   if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
10929     ::apache::thrift::TApplicationException x;
10930     x.read(iprot_);
10931     iprot_->readMessageEnd();
10932     iprot_->getTransport()->readEnd();
10933     throw x;
10934   }
10935   if (mtype != ::apache::thrift::protocol::T_REPLY) {
10936     iprot_->skip(::apache::thrift::protocol::T_STRUCT);
10937     iprot_->readMessageEnd();
10938     iprot_->getTransport()->readEnd();
10939   }
10940   if (fname.compare("deleteAllRowTs") != 0) {
10941     iprot_->skip(::apache::thrift::protocol::T_STRUCT);
10942     iprot_->readMessageEnd();
10943     iprot_->getTransport()->readEnd();
10944   }
10945   Hbase_deleteAllRowTs_presult result;
10946   result.read(iprot_);
10947   iprot_->readMessageEnd();
10948   iprot_->getTransport()->readEnd();
10949 
10950   if (result.__isset.io) {
10951     throw result.io;
10952   }
10953   return;
10954 }
10955 
10956 ScannerID HbaseClient::scannerOpenWithScan(const Text& tableName, const TScan& scan)
10957 {
10958   send_scannerOpenWithScan(tableName, scan);
10959   return recv_scannerOpenWithScan();
10960 }
10961 
10962 void HbaseClient::send_scannerOpenWithScan(const Text& tableName, const TScan& scan)
10963 {
10964   int32_t cseqid = 0;
10965   oprot_->writeMessageBegin("scannerOpenWithScan", ::apache::thrift::protocol::T_CALL, cseqid);
10966 
10967   Hbase_scannerOpenWithScan_pargs args;
10968   args.tableName = &tableName;
10969   args.scan = &scan;
10970   args.write(oprot_);
10971 
10972   oprot_->writeMessageEnd();
10973   oprot_->getTransport()->writeEnd();
10974   oprot_->getTransport()->flush();
10975 }
10976 
10977 ScannerID HbaseClient::recv_scannerOpenWithScan()
10978 {
10979 
10980   int32_t rseqid = 0;
10981   std::string fname;
10982   ::apache::thrift::protocol::TMessageType mtype;
10983 
10984   iprot_->readMessageBegin(fname, mtype, rseqid);
10985   if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
10986     ::apache::thrift::TApplicationException x;
10987     x.read(iprot_);
10988     iprot_->readMessageEnd();
10989     iprot_->getTransport()->readEnd();
10990     throw x;
10991   }
10992   if (mtype != ::apache::thrift::protocol::T_REPLY) {
10993     iprot_->skip(::apache::thrift::protocol::T_STRUCT);
10994     iprot_->readMessageEnd();
10995     iprot_->getTransport()->readEnd();
10996   }
10997   if (fname.compare("scannerOpenWithScan") != 0) {
10998     iprot_->skip(::apache::thrift::protocol::T_STRUCT);
10999     iprot_->readMessageEnd();
11000     iprot_->getTransport()->readEnd();
11001   }
11002   ScannerID _return;
11003   Hbase_scannerOpenWithScan_presult result;
11004   result.success = &_return;
11005   result.read(iprot_);
11006   iprot_->readMessageEnd();
11007   iprot_->getTransport()->readEnd();
11008 
11009   if (result.__isset.success) {
11010     return _return;
11011   }
11012   if (result.__isset.io) {
11013     throw result.io;
11014   }
11015   throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "scannerOpenWithScan failed: unknown result");
11016 }
11017 
11018 ScannerID HbaseClient::scannerOpen(const Text& tableName, const Text& startRow, const std::vector<Text> & columns)
11019 {
11020   send_scannerOpen(tableName, startRow, columns);
11021   return recv_scannerOpen();
11022 }
11023 
11024 void HbaseClient::send_scannerOpen(const Text& tableName, const Text& startRow, const std::vector<Text> & columns)
11025 {
11026   int32_t cseqid = 0;
11027   oprot_->writeMessageBegin("scannerOpen", ::apache::thrift::protocol::T_CALL, cseqid);
11028 
11029   Hbase_scannerOpen_pargs args;
11030   args.tableName = &tableName;
11031   args.startRow = &startRow;
11032   args.columns = &columns;
11033   args.write(oprot_);
11034 
11035   oprot_->writeMessageEnd();
11036   oprot_->getTransport()->writeEnd();
11037   oprot_->getTransport()->flush();
11038 }
11039 
11040 ScannerID HbaseClient::recv_scannerOpen()
11041 {
11042 
11043   int32_t rseqid = 0;
11044   std::string fname;
11045   ::apache::thrift::protocol::TMessageType mtype;
11046 
11047   iprot_->readMessageBegin(fname, mtype, rseqid);
11048   if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
11049     ::apache::thrift::TApplicationException x;
11050     x.read(iprot_);
11051     iprot_->readMessageEnd();
11052     iprot_->getTransport()->readEnd();
11053     throw x;
11054   }
11055   if (mtype != ::apache::thrift::protocol::T_REPLY) {
11056     iprot_->skip(::apache::thrift::protocol::T_STRUCT);
11057     iprot_->readMessageEnd();
11058     iprot_->getTransport()->readEnd();
11059   }
11060   if (fname.compare("scannerOpen") != 0) {
11061     iprot_->skip(::apache::thrift::protocol::T_STRUCT);
11062     iprot_->readMessageEnd();
11063     iprot_->getTransport()->readEnd();
11064   }
11065   ScannerID _return;
11066   Hbase_scannerOpen_presult result;
11067   result.success = &_return;
11068   result.read(iprot_);
11069   iprot_->readMessageEnd();
11070   iprot_->getTransport()->readEnd();
11071 
11072   if (result.__isset.success) {
11073     return _return;
11074   }
11075   if (result.__isset.io) {
11076     throw result.io;
11077   }
11078   throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "scannerOpen failed: unknown result");
11079 }
11080 
11081 ScannerID HbaseClient::scannerOpenWithStop(const Text& tableName, const Text& startRow, const Text& stopRow, const std::vector<Text> & columns)
11082 {
11083   send_scannerOpenWithStop(tableName, startRow, stopRow, columns);
11084   return recv_scannerOpenWithStop();
11085 }
11086 
11087 void HbaseClient::send_scannerOpenWithStop(const Text& tableName, const Text& startRow, const Text& stopRow, const std::vector<Text> & columns)
11088 {
11089   int32_t cseqid = 0;
11090   oprot_->writeMessageBegin("scannerOpenWithStop", ::apache::thrift::protocol::T_CALL, cseqid);
11091 
11092   Hbase_scannerOpenWithStop_pargs args;
11093   args.tableName = &tableName;
11094   args.startRow = &startRow;
11095   args.stopRow = &stopRow;
11096   args.columns = &columns;
11097   args.write(oprot_);
11098 
11099   oprot_->writeMessageEnd();
11100   oprot_->getTransport()->writeEnd();
11101   oprot_->getTransport()->flush();
11102 }
11103 
11104 ScannerID HbaseClient::recv_scannerOpenWithStop()
11105 {
11106 
11107   int32_t rseqid = 0;
11108   std::string fname;
11109   ::apache::thrift::protocol::TMessageType mtype;
11110 
11111   iprot_->readMessageBegin(fname, mtype, rseqid);
11112   if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
11113     ::apache::thrift::TApplicationException x;
11114     x.read(iprot_);
11115     iprot_->readMessageEnd();
11116     iprot_->getTransport()->readEnd();
11117     throw x;
11118   }
11119   if (mtype != ::apache::thrift::protocol::T_REPLY) {
11120     iprot_->skip(::apache::thrift::protocol::T_STRUCT);
11121     iprot_->readMessageEnd();
11122     iprot_->getTransport()->readEnd();
11123   }
11124   if (fname.compare("scannerOpenWithStop") != 0) {
11125     iprot_->skip(::apache::thrift::protocol::T_STRUCT);
11126     iprot_->readMessageEnd();
11127     iprot_->getTransport()->readEnd();
11128   }
11129   ScannerID _return;
11130   Hbase_scannerOpenWithStop_presult result;
11131   result.success = &_return;
11132   result.read(iprot_);
11133   iprot_->readMessageEnd();
11134   iprot_->getTransport()->readEnd();
11135 
11136   if (result.__isset.success) {
11137     return _return;
11138   }
11139   if (result.__isset.io) {
11140     throw result.io;
11141   }
11142   throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "scannerOpenWithStop failed: unknown result");
11143 }
11144 
11145 ScannerID HbaseClient::scannerOpenWithPrefix(const Text& tableName, const Text& startAndPrefix, const std::vector<Text> & columns)
11146 {
11147   send_scannerOpenWithPrefix(tableName, startAndPrefix, columns);
11148   return recv_scannerOpenWithPrefix();
11149 }
11150 
11151 void HbaseClient::send_scannerOpenWithPrefix(const Text& tableName, const Text& startAndPrefix, const std::vector<Text> & columns)
11152 {
11153   int32_t cseqid = 0;
11154   oprot_->writeMessageBegin("scannerOpenWithPrefix", ::apache::thrift::protocol::T_CALL, cseqid);
11155 
11156   Hbase_scannerOpenWithPrefix_pargs args;
11157   args.tableName = &tableName;
11158   args.startAndPrefix = &startAndPrefix;
11159   args.columns = &columns;
11160   args.write(oprot_);
11161 
11162   oprot_->writeMessageEnd();
11163   oprot_->getTransport()->writeEnd();
11164   oprot_->getTransport()->flush();
11165 }
11166 
11167 ScannerID HbaseClient::recv_scannerOpenWithPrefix()
11168 {
11169 
11170   int32_t rseqid = 0;
11171   std::string fname;
11172   ::apache::thrift::protocol::TMessageType mtype;
11173 
11174   iprot_->readMessageBegin(fname, mtype, rseqid);
11175   if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
11176     ::apache::thrift::TApplicationException x;
11177     x.read(iprot_);
11178     iprot_->readMessageEnd();
11179     iprot_->getTransport()->readEnd();
11180     throw x;
11181   }
11182   if (mtype != ::apache::thrift::protocol::T_REPLY) {
11183     iprot_->skip(::apache::thrift::protocol::T_STRUCT);
11184     iprot_->readMessageEnd();
11185     iprot_->getTransport()->readEnd();
11186   }
11187   if (fname.compare("scannerOpenWithPrefix") != 0) {
11188     iprot_->skip(::apache::thrift::protocol::T_STRUCT);
11189     iprot_->readMessageEnd();
11190     iprot_->getTransport()->readEnd();
11191   }
11192   ScannerID _return;
11193   Hbase_scannerOpenWithPrefix_presult result;
11194   result.success = &_return;
11195   result.read(iprot_);
11196   iprot_->readMessageEnd();
11197   iprot_->getTransport()->readEnd();
11198 
11199   if (result.__isset.success) {
11200     return _return;
11201   }
11202   if (result.__isset.io) {
11203     throw result.io;
11204   }
11205   throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "scannerOpenWithPrefix failed: unknown result");
11206 }
11207 
11208 ScannerID HbaseClient::scannerOpenTs(const Text& tableName, const Text& startRow, const std::vector<Text> & columns, const int64_t timestamp)
11209 {
11210   send_scannerOpenTs(tableName, startRow, columns, timestamp);
11211   return recv_scannerOpenTs();
11212 }
11213 
11214 void HbaseClient::send_scannerOpenTs(const Text& tableName, const Text& startRow, const std::vector<Text> & columns, const int64_t timestamp)
11215 {
11216   int32_t cseqid = 0;
11217   oprot_->writeMessageBegin("scannerOpenTs", ::apache::thrift::protocol::T_CALL, cseqid);
11218 
11219   Hbase_scannerOpenTs_pargs args;
11220   args.tableName = &tableName;
11221   args.startRow = &startRow;
11222   args.columns = &columns;
11223   args.timestamp = &timestamp;
11224   args.write(oprot_);
11225 
11226   oprot_->writeMessageEnd();
11227   oprot_->getTransport()->writeEnd();
11228   oprot_->getTransport()->flush();
11229 }
11230 
11231 ScannerID HbaseClient::recv_scannerOpenTs()
11232 {
11233 
11234   int32_t rseqid = 0;
11235   std::string fname;
11236   ::apache::thrift::protocol::TMessageType mtype;
11237 
11238   iprot_->readMessageBegin(fname, mtype, rseqid);
11239   if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
11240     ::apache::thrift::TApplicationException x;
11241     x.read(iprot_);
11242     iprot_->readMessageEnd();
11243     iprot_->getTransport()->readEnd();
11244     throw x;
11245   }
11246   if (mtype != ::apache::thrift::protocol::T_REPLY) {
11247     iprot_->skip(::apache::thrift::protocol::T_STRUCT);
11248     iprot_->readMessageEnd();
11249     iprot_->getTransport()->readEnd();
11250   }
11251   if (fname.compare("scannerOpenTs") != 0) {
11252     iprot_->skip(::apache::thrift::protocol::T_STRUCT);
11253     iprot_->readMessageEnd();
11254     iprot_->getTransport()->readEnd();
11255   }
11256   ScannerID _return;
11257   Hbase_scannerOpenTs_presult result;
11258   result.success = &_return;
11259   result.read(iprot_);
11260   iprot_->readMessageEnd();
11261   iprot_->getTransport()->readEnd();
11262 
11263   if (result.__isset.success) {
11264     return _return;
11265   }
11266   if (result.__isset.io) {
11267     throw result.io;
11268   }
11269   throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "scannerOpenTs failed: unknown result");
11270 }
11271 
11272 ScannerID HbaseClient::scannerOpenWithStopTs(const Text& tableName, const Text& startRow, const Text& stopRow, const std::vector<Text> & columns, const int64_t timestamp)
11273 {
11274   send_scannerOpenWithStopTs(tableName, startRow, stopRow, columns, timestamp);
11275   return recv_scannerOpenWithStopTs();
11276 }
11277 
11278 void HbaseClient::send_scannerOpenWithStopTs(const Text& tableName, const Text& startRow, const Text& stopRow, const std::vector<Text> & columns, const int64_t timestamp)
11279 {
11280   int32_t cseqid = 0;
11281   oprot_->writeMessageBegin("scannerOpenWithStopTs", ::apache::thrift::protocol::T_CALL, cseqid);
11282 
11283   Hbase_scannerOpenWithStopTs_pargs args;
11284   args.tableName = &tableName;
11285   args.startRow = &startRow;
11286   args.stopRow = &stopRow;
11287   args.columns = &columns;
11288   args.timestamp = &timestamp;
11289   args.write(oprot_);
11290 
11291   oprot_->writeMessageEnd();
11292   oprot_->getTransport()->writeEnd();
11293   oprot_->getTransport()->flush();
11294 }
11295 
11296 ScannerID HbaseClient::recv_scannerOpenWithStopTs()
11297 {
11298 
11299   int32_t rseqid = 0;
11300   std::string fname;
11301   ::apache::thrift::protocol::TMessageType mtype;
11302 
11303   iprot_->readMessageBegin(fname, mtype, rseqid);
11304   if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
11305     ::apache::thrift::TApplicationException x;
11306     x.read(iprot_);
11307     iprot_->readMessageEnd();
11308     iprot_->getTransport()->readEnd();
11309     throw x;
11310   }
11311   if (mtype != ::apache::thrift::protocol::T_REPLY) {
11312     iprot_->skip(::apache::thrift::protocol::T_STRUCT);
11313     iprot_->readMessageEnd();
11314     iprot_->getTransport()->readEnd();
11315   }
11316   if (fname.compare("scannerOpenWithStopTs") != 0) {
11317     iprot_->skip(::apache::thrift::protocol::T_STRUCT);
11318     iprot_->readMessageEnd();
11319     iprot_->getTransport()->readEnd();
11320   }
11321   ScannerID _return;
11322   Hbase_scannerOpenWithStopTs_presult result;
11323   result.success = &_return;
11324   result.read(iprot_);
11325   iprot_->readMessageEnd();
11326   iprot_->getTransport()->readEnd();
11327 
11328   if (result.__isset.success) {
11329     return _return;
11330   }
11331   if (result.__isset.io) {
11332     throw result.io;
11333   }
11334   throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "scannerOpenWithStopTs failed: unknown result");
11335 }
11336 
11337 void HbaseClient::scannerGet(std::vector<TRowResult> & _return, const ScannerID id)
11338 {
11339   send_scannerGet(id);
11340   recv_scannerGet(_return);
11341 }
11342 
11343 void HbaseClient::send_scannerGet(const ScannerID id)
11344 {
11345   int32_t cseqid = 0;
11346   oprot_->writeMessageBegin("scannerGet", ::apache::thrift::protocol::T_CALL, cseqid);
11347 
11348   Hbase_scannerGet_pargs args;
11349   args.id = &id;
11350   args.write(oprot_);
11351 
11352   oprot_->writeMessageEnd();
11353   oprot_->getTransport()->writeEnd();
11354   oprot_->getTransport()->flush();
11355 }
11356 
11357 void HbaseClient::recv_scannerGet(std::vector<TRowResult> & _return)
11358 {
11359 
11360   int32_t rseqid = 0;
11361   std::string fname;
11362   ::apache::thrift::protocol::TMessageType mtype;
11363 
11364   iprot_->readMessageBegin(fname, mtype, rseqid);
11365   if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
11366     ::apache::thrift::TApplicationException x;
11367     x.read(iprot_);
11368     iprot_->readMessageEnd();
11369     iprot_->getTransport()->readEnd();
11370     throw x;
11371   }
11372   if (mtype != ::apache::thrift::protocol::T_REPLY) {
11373     iprot_->skip(::apache::thrift::protocol::T_STRUCT);
11374     iprot_->readMessageEnd();
11375     iprot_->getTransport()->readEnd();
11376   }
11377   if (fname.compare("scannerGet") != 0) {
11378     iprot_->skip(::apache::thrift::protocol::T_STRUCT);
11379     iprot_->readMessageEnd();
11380     iprot_->getTransport()->readEnd();
11381   }
11382   Hbase_scannerGet_presult result;
11383   result.success = &_return;
11384   result.read(iprot_);
11385   iprot_->readMessageEnd();
11386   iprot_->getTransport()->readEnd();
11387 
11388   if (result.__isset.success) {
11389     // _return pointer has now been filled
11390     return;
11391   }
11392   if (result.__isset.io) {
11393     throw result.io;
11394   }
11395   if (result.__isset.ia) {
11396     throw result.ia;
11397   }
11398   throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "scannerGet failed: unknown result");
11399 }
11400 
11401 void HbaseClient::scannerGetList(std::vector<TRowResult> & _return, const ScannerID id, const int32_t nbRows)
11402 {
11403   send_scannerGetList(id, nbRows);
11404   recv_scannerGetList(_return);
11405 }
11406 
11407 void HbaseClient::send_scannerGetList(const ScannerID id, const int32_t nbRows)
11408 {
11409   int32_t cseqid = 0;
11410   oprot_->writeMessageBegin("scannerGetList", ::apache::thrift::protocol::T_CALL, cseqid);
11411 
11412   Hbase_scannerGetList_pargs args;
11413   args.id = &id;
11414   args.nbRows = &nbRows;
11415   args.write(oprot_);
11416 
11417   oprot_->writeMessageEnd();
11418   oprot_->getTransport()->writeEnd();
11419   oprot_->getTransport()->flush();
11420 }
11421 
11422 void HbaseClient::recv_scannerGetList(std::vector<TRowResult> & _return)
11423 {
11424 
11425   int32_t rseqid = 0;
11426   std::string fname;
11427   ::apache::thrift::protocol::TMessageType mtype;
11428 
11429   iprot_->readMessageBegin(fname, mtype, rseqid);
11430   if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
11431     ::apache::thrift::TApplicationException x;
11432     x.read(iprot_);
11433     iprot_->readMessageEnd();
11434     iprot_->getTransport()->readEnd();
11435     throw x;
11436   }
11437   if (mtype != ::apache::thrift::protocol::T_REPLY) {
11438     iprot_->skip(::apache::thrift::protocol::T_STRUCT);
11439     iprot_->readMessageEnd();
11440     iprot_->getTransport()->readEnd();
11441   }
11442   if (fname.compare("scannerGetList") != 0) {
11443     iprot_->skip(::apache::thrift::protocol::T_STRUCT);
11444     iprot_->readMessageEnd();
11445     iprot_->getTransport()->readEnd();
11446   }
11447   Hbase_scannerGetList_presult result;
11448   result.success = &_return;
11449   result.read(iprot_);
11450   iprot_->readMessageEnd();
11451   iprot_->getTransport()->readEnd();
11452 
11453   if (result.__isset.success) {
11454     // _return pointer has now been filled
11455     return;
11456   }
11457   if (result.__isset.io) {
11458     throw result.io;
11459   }
11460   if (result.__isset.ia) {
11461     throw result.ia;
11462   }
11463   throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "scannerGetList failed: unknown result");
11464 }
11465 
11466 void HbaseClient::scannerClose(const ScannerID id)
11467 {
11468   send_scannerClose(id);
11469   recv_scannerClose();
11470 }
11471 
11472 void HbaseClient::send_scannerClose(const ScannerID id)
11473 {
11474   int32_t cseqid = 0;
11475   oprot_->writeMessageBegin("scannerClose", ::apache::thrift::protocol::T_CALL, cseqid);
11476 
11477   Hbase_scannerClose_pargs args;
11478   args.id = &id;
11479   args.write(oprot_);
11480 
11481   oprot_->writeMessageEnd();
11482   oprot_->getTransport()->writeEnd();
11483   oprot_->getTransport()->flush();
11484 }
11485 
11486 void HbaseClient::recv_scannerClose()
11487 {
11488 
11489   int32_t rseqid = 0;
11490   std::string fname;
11491   ::apache::thrift::protocol::TMessageType mtype;
11492 
11493   iprot_->readMessageBegin(fname, mtype, rseqid);
11494   if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
11495     ::apache::thrift::TApplicationException x;
11496     x.read(iprot_);
11497     iprot_->readMessageEnd();
11498     iprot_->getTransport()->readEnd();
11499     throw x;
11500   }
11501   if (mtype != ::apache::thrift::protocol::T_REPLY) {
11502     iprot_->skip(::apache::thrift::protocol::T_STRUCT);
11503     iprot_->readMessageEnd();
11504     iprot_->getTransport()->readEnd();
11505   }
11506   if (fname.compare("scannerClose") != 0) {
11507     iprot_->skip(::apache::thrift::protocol::T_STRUCT);
11508     iprot_->readMessageEnd();
11509     iprot_->getTransport()->readEnd();
11510   }
11511   Hbase_scannerClose_presult result;
11512   result.read(iprot_);
11513   iprot_->readMessageEnd();
11514   iprot_->getTransport()->readEnd();
11515 
11516   if (result.__isset.io) {
11517     throw result.io;
11518   }
11519   if (result.__isset.ia) {
11520     throw result.ia;
11521   }
11522   return;
11523 }
11524 
11525 void HbaseClient::getRowOrBefore(std::vector<TCell> & _return, const Text& tableName, const Text& row, const Text& family)
11526 {
11527   send_getRowOrBefore(tableName, row, family);
11528   recv_getRowOrBefore(_return);
11529 }
11530 
11531 void HbaseClient::send_getRowOrBefore(const Text& tableName, const Text& row, const Text& family)
11532 {
11533   int32_t cseqid = 0;
11534   oprot_->writeMessageBegin("getRowOrBefore", ::apache::thrift::protocol::T_CALL, cseqid);
11535 
11536   Hbase_getRowOrBefore_pargs args;
11537   args.tableName = &tableName;
11538   args.row = &row;
11539   args.family = &family;
11540   args.write(oprot_);
11541 
11542   oprot_->writeMessageEnd();
11543   oprot_->getTransport()->writeEnd();
11544   oprot_->getTransport()->flush();
11545 }
11546 
11547 void HbaseClient::recv_getRowOrBefore(std::vector<TCell> & _return)
11548 {
11549 
11550   int32_t rseqid = 0;
11551   std::string fname;
11552   ::apache::thrift::protocol::TMessageType mtype;
11553 
11554   iprot_->readMessageBegin(fname, mtype, rseqid);
11555   if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
11556     ::apache::thrift::TApplicationException x;
11557     x.read(iprot_);
11558     iprot_->readMessageEnd();
11559     iprot_->getTransport()->readEnd();
11560     throw x;
11561   }
11562   if (mtype != ::apache::thrift::protocol::T_REPLY) {
11563     iprot_->skip(::apache::thrift::protocol::T_STRUCT);
11564     iprot_->readMessageEnd();
11565     iprot_->getTransport()->readEnd();
11566   }
11567   if (fname.compare("getRowOrBefore") != 0) {
11568     iprot_->skip(::apache::thrift::protocol::T_STRUCT);
11569     iprot_->readMessageEnd();
11570     iprot_->getTransport()->readEnd();
11571   }
11572   Hbase_getRowOrBefore_presult result;
11573   result.success = &_return;
11574   result.read(iprot_);
11575   iprot_->readMessageEnd();
11576   iprot_->getTransport()->readEnd();
11577 
11578   if (result.__isset.success) {
11579     // _return pointer has now been filled
11580     return;
11581   }
11582   if (result.__isset.io) {
11583     throw result.io;
11584   }
11585   throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getRowOrBefore failed: unknown result");
11586 }
11587 
11588 void HbaseClient::getRegionInfo(TRegionInfo& _return, const Text& row)
11589 {
11590   send_getRegionInfo(row);
11591   recv_getRegionInfo(_return);
11592 }
11593 
11594 void HbaseClient::send_getRegionInfo(const Text& row)
11595 {
11596   int32_t cseqid = 0;
11597   oprot_->writeMessageBegin("getRegionInfo", ::apache::thrift::protocol::T_CALL, cseqid);
11598 
11599   Hbase_getRegionInfo_pargs args;
11600   args.row = &row;
11601   args.write(oprot_);
11602 
11603   oprot_->writeMessageEnd();
11604   oprot_->getTransport()->writeEnd();
11605   oprot_->getTransport()->flush();
11606 }
11607 
11608 void HbaseClient::recv_getRegionInfo(TRegionInfo& _return)
11609 {
11610 
11611   int32_t rseqid = 0;
11612   std::string fname;
11613   ::apache::thrift::protocol::TMessageType mtype;
11614 
11615   iprot_->readMessageBegin(fname, mtype, rseqid);
11616   if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
11617     ::apache::thrift::TApplicationException x;
11618     x.read(iprot_);
11619     iprot_->readMessageEnd();
11620     iprot_->getTransport()->readEnd();
11621     throw x;
11622   }
11623   if (mtype != ::apache::thrift::protocol::T_REPLY) {
11624     iprot_->skip(::apache::thrift::protocol::T_STRUCT);
11625     iprot_->readMessageEnd();
11626     iprot_->getTransport()->readEnd();
11627   }
11628   if (fname.compare("getRegionInfo") != 0) {
11629     iprot_->skip(::apache::thrift::protocol::T_STRUCT);
11630     iprot_->readMessageEnd();
11631     iprot_->getTransport()->readEnd();
11632   }
11633   Hbase_getRegionInfo_presult result;
11634   result.success = &_return;
11635   result.read(iprot_);
11636   iprot_->readMessageEnd();
11637   iprot_->getTransport()->readEnd();
11638 
11639   if (result.__isset.success) {
11640     // _return pointer has now been filled
11641     return;
11642   }
11643   if (result.__isset.io) {
11644     throw result.io;
11645   }
11646   throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "getRegionInfo failed: unknown result");
11647 }
11648 
11649 bool HbaseProcessor::process(boost::shared_ptr< ::apache::thrift::protocol::TProtocol> piprot, boost::shared_ptr< ::apache::thrift::protocol::TProtocol> poprot, void* callContext) {
11650 
11651   ::apache::thrift::protocol::TProtocol* iprot = piprot.get();
11652   ::apache::thrift::protocol::TProtocol* oprot = poprot.get();
11653   std::string fname;
11654   ::apache::thrift::protocol::TMessageType mtype;
11655   int32_t seqid;
11656 
11657   iprot->readMessageBegin(fname, mtype, seqid);
11658 
11659   if (mtype != ::apache::thrift::protocol::T_CALL && mtype != ::apache::thrift::protocol::T_ONEWAY) {
11660     iprot->skip(::apache::thrift::protocol::T_STRUCT);
11661     iprot->readMessageEnd();
11662     iprot->getTransport()->readEnd();
11663     ::apache::thrift::TApplicationException x(::apache::thrift::TApplicationException::INVALID_MESSAGE_TYPE);
11664     oprot->writeMessageBegin(fname, ::apache::thrift::protocol::T_EXCEPTION, seqid);
11665     x.write(oprot);
11666     oprot->writeMessageEnd();
11667     oprot->getTransport()->writeEnd();
11668     oprot->getTransport()->flush();
11669     return false;
11670   }
11671 
11672   return process_fn(iprot, oprot, fname, seqid, callContext);
11673 }
11674 
11675 bool HbaseProcessor::process_fn(::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, std::string& fname, int32_t seqid, void* callContext) {
11676   std::map<std::string, void (HbaseProcessor::*)(int32_t, ::apache::thrift::protocol::TProtocol*, ::apache::thrift::protocol::TProtocol*, void*)>::iterator pfn;
11677   pfn = processMap_.find(fname);
11678   if (pfn == processMap_.end()) {
11679     iprot->skip(::apache::thrift::protocol::T_STRUCT);
11680     iprot->readMessageEnd();
11681     iprot->getTransport()->readEnd();
11682     ::apache::thrift::TApplicationException x(::apache::thrift::TApplicationException::UNKNOWN_METHOD, "Invalid method name: '"+fname+"'");
11683     oprot->writeMessageBegin(fname, ::apache::thrift::protocol::T_EXCEPTION, seqid);
11684     x.write(oprot);
11685     oprot->writeMessageEnd();
11686     oprot->getTransport()->writeEnd();
11687     oprot->getTransport()->flush();
11688     return false;
11689   }
11690   (this->*(pfn->second))(seqid, iprot, oprot, callContext);
11691   return true;
11692 }
11693 
11694 void HbaseProcessor::process_enableTable(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
11695 {
11696   void* ctx = NULL;
11697   if (eventHandler_.get() != NULL) {
11698     ctx = eventHandler_->getContext("Hbase.enableTable", callContext);
11699   }
11700   ::apache::thrift::TProcessorContextFreer freer(eventHandler_.get(), ctx, "Hbase.enableTable");
11701 
11702   if (eventHandler_.get() != NULL) {
11703     eventHandler_->preRead(ctx, "Hbase.enableTable");
11704   }
11705 
11706   Hbase_enableTable_args args;
11707   args.read(iprot);
11708   iprot->readMessageEnd();
11709   uint32_t bytes = iprot->getTransport()->readEnd();
11710 
11711   if (eventHandler_.get() != NULL) {
11712     eventHandler_->postRead(ctx, "Hbase.enableTable", bytes);
11713   }
11714 
11715   Hbase_enableTable_result result;
11716   try {
11717     iface_->enableTable(args.tableName);
11718   } catch (IOError &io) {
11719     result.io = io;
11720     result.__isset.io = true;
11721   } catch (const std::exception& e) {
11722     if (eventHandler_.get() != NULL) {
11723       eventHandler_->handlerError(ctx, "Hbase.enableTable");
11724     }
11725 
11726     ::apache::thrift::TApplicationException x(e.what());
11727     oprot->writeMessageBegin("enableTable", ::apache::thrift::protocol::T_EXCEPTION, seqid);
11728     x.write(oprot);
11729     oprot->writeMessageEnd();
11730     oprot->getTransport()->writeEnd();
11731     oprot->getTransport()->flush();
11732     return;
11733   }
11734 
11735   if (eventHandler_.get() != NULL) {
11736     eventHandler_->preWrite(ctx, "Hbase.enableTable");
11737   }
11738 
11739   oprot->writeMessageBegin("enableTable", ::apache::thrift::protocol::T_REPLY, seqid);
11740   result.write(oprot);
11741   oprot->writeMessageEnd();
11742   bytes = oprot->getTransport()->writeEnd();
11743   oprot->getTransport()->flush();
11744 
11745   if (eventHandler_.get() != NULL) {
11746     eventHandler_->postWrite(ctx, "Hbase.enableTable", bytes);
11747   }
11748 }
11749 
11750 void HbaseProcessor::process_disableTable(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
11751 {
11752   void* ctx = NULL;
11753   if (eventHandler_.get() != NULL) {
11754     ctx = eventHandler_->getContext("Hbase.disableTable", callContext);
11755   }
11756   ::apache::thrift::TProcessorContextFreer freer(eventHandler_.get(), ctx, "Hbase.disableTable");
11757 
11758   if (eventHandler_.get() != NULL) {
11759     eventHandler_->preRead(ctx, "Hbase.disableTable");
11760   }
11761 
11762   Hbase_disableTable_args args;
11763   args.read(iprot);
11764   iprot->readMessageEnd();
11765   uint32_t bytes = iprot->getTransport()->readEnd();
11766 
11767   if (eventHandler_.get() != NULL) {
11768     eventHandler_->postRead(ctx, "Hbase.disableTable", bytes);
11769   }
11770 
11771   Hbase_disableTable_result result;
11772   try {
11773     iface_->disableTable(args.tableName);
11774   } catch (IOError &io) {
11775     result.io = io;
11776     result.__isset.io = true;
11777   } catch (const std::exception& e) {
11778     if (eventHandler_.get() != NULL) {
11779       eventHandler_->handlerError(ctx, "Hbase.disableTable");
11780     }
11781 
11782     ::apache::thrift::TApplicationException x(e.what());
11783     oprot->writeMessageBegin("disableTable", ::apache::thrift::protocol::T_EXCEPTION, seqid);
11784     x.write(oprot);
11785     oprot->writeMessageEnd();
11786     oprot->getTransport()->writeEnd();
11787     oprot->getTransport()->flush();
11788     return;
11789   }
11790 
11791   if (eventHandler_.get() != NULL) {
11792     eventHandler_->preWrite(ctx, "Hbase.disableTable");
11793   }
11794 
11795   oprot->writeMessageBegin("disableTable", ::apache::thrift::protocol::T_REPLY, seqid);
11796   result.write(oprot);
11797   oprot->writeMessageEnd();
11798   bytes = oprot->getTransport()->writeEnd();
11799   oprot->getTransport()->flush();
11800 
11801   if (eventHandler_.get() != NULL) {
11802     eventHandler_->postWrite(ctx, "Hbase.disableTable", bytes);
11803   }
11804 }
11805 
11806 void HbaseProcessor::process_isTableEnabled(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
11807 {
11808   void* ctx = NULL;
11809   if (eventHandler_.get() != NULL) {
11810     ctx = eventHandler_->getContext("Hbase.isTableEnabled", callContext);
11811   }
11812   ::apache::thrift::TProcessorContextFreer freer(eventHandler_.get(), ctx, "Hbase.isTableEnabled");
11813 
11814   if (eventHandler_.get() != NULL) {
11815     eventHandler_->preRead(ctx, "Hbase.isTableEnabled");
11816   }
11817 
11818   Hbase_isTableEnabled_args args;
11819   args.read(iprot);
11820   iprot->readMessageEnd();
11821   uint32_t bytes = iprot->getTransport()->readEnd();
11822 
11823   if (eventHandler_.get() != NULL) {
11824     eventHandler_->postRead(ctx, "Hbase.isTableEnabled", bytes);
11825   }
11826 
11827   Hbase_isTableEnabled_result result;
11828   try {
11829     result.success = iface_->isTableEnabled(args.tableName);
11830     result.__isset.success = true;
11831   } catch (IOError &io) {
11832     result.io = io;
11833     result.__isset.io = true;
11834   } catch (const std::exception& e) {
11835     if (eventHandler_.get() != NULL) {
11836       eventHandler_->handlerError(ctx, "Hbase.isTableEnabled");
11837     }
11838 
11839     ::apache::thrift::TApplicationException x(e.what());
11840     oprot->writeMessageBegin("isTableEnabled", ::apache::thrift::protocol::T_EXCEPTION, seqid);
11841     x.write(oprot);
11842     oprot->writeMessageEnd();
11843     oprot->getTransport()->writeEnd();
11844     oprot->getTransport()->flush();
11845     return;
11846   }
11847 
11848   if (eventHandler_.get() != NULL) {
11849     eventHandler_->preWrite(ctx, "Hbase.isTableEnabled");
11850   }
11851 
11852   oprot->writeMessageBegin("isTableEnabled", ::apache::thrift::protocol::T_REPLY, seqid);
11853   result.write(oprot);
11854   oprot->writeMessageEnd();
11855   bytes = oprot->getTransport()->writeEnd();
11856   oprot->getTransport()->flush();
11857 
11858   if (eventHandler_.get() != NULL) {
11859     eventHandler_->postWrite(ctx, "Hbase.isTableEnabled", bytes);
11860   }
11861 }
11862 
11863 void HbaseProcessor::process_compact(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
11864 {
11865   void* ctx = NULL;
11866   if (eventHandler_.get() != NULL) {
11867     ctx = eventHandler_->getContext("Hbase.compact", callContext);
11868   }
11869   ::apache::thrift::TProcessorContextFreer freer(eventHandler_.get(), ctx, "Hbase.compact");
11870 
11871   if (eventHandler_.get() != NULL) {
11872     eventHandler_->preRead(ctx, "Hbase.compact");
11873   }
11874 
11875   Hbase_compact_args args;
11876   args.read(iprot);
11877   iprot->readMessageEnd();
11878   uint32_t bytes = iprot->getTransport()->readEnd();
11879 
11880   if (eventHandler_.get() != NULL) {
11881     eventHandler_->postRead(ctx, "Hbase.compact", bytes);
11882   }
11883 
11884   Hbase_compact_result result;
11885   try {
11886     iface_->compact(args.tableNameOrRegionName);
11887   } catch (IOError &io) {
11888     result.io = io;
11889     result.__isset.io = true;
11890   } catch (const std::exception& e) {
11891     if (eventHandler_.get() != NULL) {
11892       eventHandler_->handlerError(ctx, "Hbase.compact");
11893     }
11894 
11895     ::apache::thrift::TApplicationException x(e.what());
11896     oprot->writeMessageBegin("compact", ::apache::thrift::protocol::T_EXCEPTION, seqid);
11897     x.write(oprot);
11898     oprot->writeMessageEnd();
11899     oprot->getTransport()->writeEnd();
11900     oprot->getTransport()->flush();
11901     return;
11902   }
11903 
11904   if (eventHandler_.get() != NULL) {
11905     eventHandler_->preWrite(ctx, "Hbase.compact");
11906   }
11907 
11908   oprot->writeMessageBegin("compact", ::apache::thrift::protocol::T_REPLY, seqid);
11909   result.write(oprot);
11910   oprot->writeMessageEnd();
11911   bytes = oprot->getTransport()->writeEnd();
11912   oprot->getTransport()->flush();
11913 
11914   if (eventHandler_.get() != NULL) {
11915     eventHandler_->postWrite(ctx, "Hbase.compact", bytes);
11916   }
11917 }
11918 
11919 void HbaseProcessor::process_majorCompact(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
11920 {
11921   void* ctx = NULL;
11922   if (eventHandler_.get() != NULL) {
11923     ctx = eventHandler_->getContext("Hbase.majorCompact", callContext);
11924   }
11925   ::apache::thrift::TProcessorContextFreer freer(eventHandler_.get(), ctx, "Hbase.majorCompact");
11926 
11927   if (eventHandler_.get() != NULL) {
11928     eventHandler_->preRead(ctx, "Hbase.majorCompact");
11929   }
11930 
11931   Hbase_majorCompact_args args;
11932   args.read(iprot);
11933   iprot->readMessageEnd();
11934   uint32_t bytes = iprot->getTransport()->readEnd();
11935 
11936   if (eventHandler_.get() != NULL) {
11937     eventHandler_->postRead(ctx, "Hbase.majorCompact", bytes);
11938   }
11939 
11940   Hbase_majorCompact_result result;
11941   try {
11942     iface_->majorCompact(args.tableNameOrRegionName);
11943   } catch (IOError &io) {
11944     result.io = io;
11945     result.__isset.io = true;
11946   } catch (const std::exception& e) {
11947     if (eventHandler_.get() != NULL) {
11948       eventHandler_->handlerError(ctx, "Hbase.majorCompact");
11949     }
11950 
11951     ::apache::thrift::TApplicationException x(e.what());
11952     oprot->writeMessageBegin("majorCompact", ::apache::thrift::protocol::T_EXCEPTION, seqid);
11953     x.write(oprot);
11954     oprot->writeMessageEnd();
11955     oprot->getTransport()->writeEnd();
11956     oprot->getTransport()->flush();
11957     return;
11958   }
11959 
11960   if (eventHandler_.get() != NULL) {
11961     eventHandler_->preWrite(ctx, "Hbase.majorCompact");
11962   }
11963 
11964   oprot->writeMessageBegin("majorCompact", ::apache::thrift::protocol::T_REPLY, seqid);
11965   result.write(oprot);
11966   oprot->writeMessageEnd();
11967   bytes = oprot->getTransport()->writeEnd();
11968   oprot->getTransport()->flush();
11969 
11970   if (eventHandler_.get() != NULL) {
11971     eventHandler_->postWrite(ctx, "Hbase.majorCompact", bytes);
11972   }
11973 }
11974 
11975 void HbaseProcessor::process_getTableNames(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
11976 {
11977   void* ctx = NULL;
11978   if (eventHandler_.get() != NULL) {
11979     ctx = eventHandler_->getContext("Hbase.getTableNames", callContext);
11980   }
11981   ::apache::thrift::TProcessorContextFreer freer(eventHandler_.get(), ctx, "Hbase.getTableNames");
11982 
11983   if (eventHandler_.get() != NULL) {
11984     eventHandler_->preRead(ctx, "Hbase.getTableNames");
11985   }
11986 
11987   Hbase_getTableNames_args args;
11988   args.read(iprot);
11989   iprot->readMessageEnd();
11990   uint32_t bytes = iprot->getTransport()->readEnd();
11991 
11992   if (eventHandler_.get() != NULL) {
11993     eventHandler_->postRead(ctx, "Hbase.getTableNames", bytes);
11994   }
11995 
11996   Hbase_getTableNames_result result;
11997   try {
11998     iface_->getTableNames(result.success);
11999     result.__isset.success = true;
12000   } catch (IOError &io) {
12001     result.io = io;
12002     result.__isset.io = true;
12003   } catch (const std::exception& e) {
12004     if (eventHandler_.get() != NULL) {
12005       eventHandler_->handlerError(ctx, "Hbase.getTableNames");
12006     }
12007 
12008     ::apache::thrift::TApplicationException x(e.what());
12009     oprot->writeMessageBegin("getTableNames", ::apache::thrift::protocol::T_EXCEPTION, seqid);
12010     x.write(oprot);
12011     oprot->writeMessageEnd();
12012     oprot->getTransport()->writeEnd();
12013     oprot->getTransport()->flush();
12014     return;
12015   }
12016 
12017   if (eventHandler_.get() != NULL) {
12018     eventHandler_->preWrite(ctx, "Hbase.getTableNames");
12019   }
12020 
12021   oprot->writeMessageBegin("getTableNames", ::apache::thrift::protocol::T_REPLY, seqid);
12022   result.write(oprot);
12023   oprot->writeMessageEnd();
12024   bytes = oprot->getTransport()->writeEnd();
12025   oprot->getTransport()->flush();
12026 
12027   if (eventHandler_.get() != NULL) {
12028     eventHandler_->postWrite(ctx, "Hbase.getTableNames", bytes);
12029   }
12030 }
12031 
12032 void HbaseProcessor::process_getColumnDescriptors(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
12033 {
12034   void* ctx = NULL;
12035   if (eventHandler_.get() != NULL) {
12036     ctx = eventHandler_->getContext("Hbase.getColumnDescriptors", callContext);
12037   }
12038   ::apache::thrift::TProcessorContextFreer freer(eventHandler_.get(), ctx, "Hbase.getColumnDescriptors");
12039 
12040   if (eventHandler_.get() != NULL) {
12041     eventHandler_->preRead(ctx, "Hbase.getColumnDescriptors");
12042   }
12043 
12044   Hbase_getColumnDescriptors_args args;
12045   args.read(iprot);
12046   iprot->readMessageEnd();
12047   uint32_t bytes = iprot->getTransport()->readEnd();
12048 
12049   if (eventHandler_.get() != NULL) {
12050     eventHandler_->postRead(ctx, "Hbase.getColumnDescriptors", bytes);
12051   }
12052 
12053   Hbase_getColumnDescriptors_result result;
12054   try {
12055     iface_->getColumnDescriptors(result.success, args.tableName);
12056     result.__isset.success = true;
12057   } catch (IOError &io) {
12058     result.io = io;
12059     result.__isset.io = true;
12060   } catch (const std::exception& e) {
12061     if (eventHandler_.get() != NULL) {
12062       eventHandler_->handlerError(ctx, "Hbase.getColumnDescriptors");
12063     }
12064 
12065     ::apache::thrift::TApplicationException x(e.what());
12066     oprot->writeMessageBegin("getColumnDescriptors", ::apache::thrift::protocol::T_EXCEPTION, seqid);
12067     x.write(oprot);
12068     oprot->writeMessageEnd();
12069     oprot->getTransport()->writeEnd();
12070     oprot->getTransport()->flush();
12071     return;
12072   }
12073 
12074   if (eventHandler_.get() != NULL) {
12075     eventHandler_->preWrite(ctx, "Hbase.getColumnDescriptors");
12076   }
12077 
12078   oprot->writeMessageBegin("getColumnDescriptors", ::apache::thrift::protocol::T_REPLY, seqid);
12079   result.write(oprot);
12080   oprot->writeMessageEnd();
12081   bytes = oprot->getTransport()->writeEnd();
12082   oprot->getTransport()->flush();
12083 
12084   if (eventHandler_.get() != NULL) {
12085     eventHandler_->postWrite(ctx, "Hbase.getColumnDescriptors", bytes);
12086   }
12087 }
12088 
12089 void HbaseProcessor::process_getTableRegions(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
12090 {
12091   void* ctx = NULL;
12092   if (eventHandler_.get() != NULL) {
12093     ctx = eventHandler_->getContext("Hbase.getTableRegions", callContext);
12094   }
12095   ::apache::thrift::TProcessorContextFreer freer(eventHandler_.get(), ctx, "Hbase.getTableRegions");
12096 
12097   if (eventHandler_.get() != NULL) {
12098     eventHandler_->preRead(ctx, "Hbase.getTableRegions");
12099   }
12100 
12101   Hbase_getTableRegions_args args;
12102   args.read(iprot);
12103   iprot->readMessageEnd();
12104   uint32_t bytes = iprot->getTransport()->readEnd();
12105 
12106   if (eventHandler_.get() != NULL) {
12107     eventHandler_->postRead(ctx, "Hbase.getTableRegions", bytes);
12108   }
12109 
12110   Hbase_getTableRegions_result result;
12111   try {
12112     iface_->getTableRegions(result.success, args.tableName);
12113     result.__isset.success = true;
12114   } catch (IOError &io) {
12115     result.io = io;
12116     result.__isset.io = true;
12117   } catch (const std::exception& e) {
12118     if (eventHandler_.get() != NULL) {
12119       eventHandler_->handlerError(ctx, "Hbase.getTableRegions");
12120     }
12121 
12122     ::apache::thrift::TApplicationException x(e.what());
12123     oprot->writeMessageBegin("getTableRegions", ::apache::thrift::protocol::T_EXCEPTION, seqid);
12124     x.write(oprot);
12125     oprot->writeMessageEnd();
12126     oprot->getTransport()->writeEnd();
12127     oprot->getTransport()->flush();
12128     return;
12129   }
12130 
12131   if (eventHandler_.get() != NULL) {
12132     eventHandler_->preWrite(ctx, "Hbase.getTableRegions");
12133   }
12134 
12135   oprot->writeMessageBegin("getTableRegions", ::apache::thrift::protocol::T_REPLY, seqid);
12136   result.write(oprot);
12137   oprot->writeMessageEnd();
12138   bytes = oprot->getTransport()->writeEnd();
12139   oprot->getTransport()->flush();
12140 
12141   if (eventHandler_.get() != NULL) {
12142     eventHandler_->postWrite(ctx, "Hbase.getTableRegions", bytes);
12143   }
12144 }
12145 
12146 void HbaseProcessor::process_createTable(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
12147 {
12148   void* ctx = NULL;
12149   if (eventHandler_.get() != NULL) {
12150     ctx = eventHandler_->getContext("Hbase.createTable", callContext);
12151   }
12152   ::apache::thrift::TProcessorContextFreer freer(eventHandler_.get(), ctx, "Hbase.createTable");
12153 
12154   if (eventHandler_.get() != NULL) {
12155     eventHandler_->preRead(ctx, "Hbase.createTable");
12156   }
12157 
12158   Hbase_createTable_args args;
12159   args.read(iprot);
12160   iprot->readMessageEnd();
12161   uint32_t bytes = iprot->getTransport()->readEnd();
12162 
12163   if (eventHandler_.get() != NULL) {
12164     eventHandler_->postRead(ctx, "Hbase.createTable", bytes);
12165   }
12166 
12167   Hbase_createTable_result result;
12168   try {
12169     iface_->createTable(args.tableName, args.columnFamilies);
12170   } catch (IOError &io) {
12171     result.io = io;
12172     result.__isset.io = true;
12173   } catch (IllegalArgument &ia) {
12174     result.ia = ia;
12175     result.__isset.ia = true;
12176   } catch (AlreadyExists &exist) {
12177     result.exist = exist;
12178     result.__isset.exist = true;
12179   } catch (const std::exception& e) {
12180     if (eventHandler_.get() != NULL) {
12181       eventHandler_->handlerError(ctx, "Hbase.createTable");
12182     }
12183 
12184     ::apache::thrift::TApplicationException x(e.what());
12185     oprot->writeMessageBegin("createTable", ::apache::thrift::protocol::T_EXCEPTION, seqid);
12186     x.write(oprot);
12187     oprot->writeMessageEnd();
12188     oprot->getTransport()->writeEnd();
12189     oprot->getTransport()->flush();
12190     return;
12191   }
12192 
12193   if (eventHandler_.get() != NULL) {
12194     eventHandler_->preWrite(ctx, "Hbase.createTable");
12195   }
12196 
12197   oprot->writeMessageBegin("createTable", ::apache::thrift::protocol::T_REPLY, seqid);
12198   result.write(oprot);
12199   oprot->writeMessageEnd();
12200   bytes = oprot->getTransport()->writeEnd();
12201   oprot->getTransport()->flush();
12202 
12203   if (eventHandler_.get() != NULL) {
12204     eventHandler_->postWrite(ctx, "Hbase.createTable", bytes);
12205   }
12206 }
12207 
12208 void HbaseProcessor::process_deleteTable(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
12209 {
12210   void* ctx = NULL;
12211   if (eventHandler_.get() != NULL) {
12212     ctx = eventHandler_->getContext("Hbase.deleteTable", callContext);
12213   }
12214   ::apache::thrift::TProcessorContextFreer freer(eventHandler_.get(), ctx, "Hbase.deleteTable");
12215 
12216   if (eventHandler_.get() != NULL) {
12217     eventHandler_->preRead(ctx, "Hbase.deleteTable");
12218   }
12219 
12220   Hbase_deleteTable_args args;
12221   args.read(iprot);
12222   iprot->readMessageEnd();
12223   uint32_t bytes = iprot->getTransport()->readEnd();
12224 
12225   if (eventHandler_.get() != NULL) {
12226     eventHandler_->postRead(ctx, "Hbase.deleteTable", bytes);
12227   }
12228 
12229   Hbase_deleteTable_result result;
12230   try {
12231     iface_->deleteTable(args.tableName);
12232   } catch (IOError &io) {
12233     result.io = io;
12234     result.__isset.io = true;
12235   } catch (const std::exception& e) {
12236     if (eventHandler_.get() != NULL) {
12237       eventHandler_->handlerError(ctx, "Hbase.deleteTable");
12238     }
12239 
12240     ::apache::thrift::TApplicationException x(e.what());
12241     oprot->writeMessageBegin("deleteTable", ::apache::thrift::protocol::T_EXCEPTION, seqid);
12242     x.write(oprot);
12243     oprot->writeMessageEnd();
12244     oprot->getTransport()->writeEnd();
12245     oprot->getTransport()->flush();
12246     return;
12247   }
12248 
12249   if (eventHandler_.get() != NULL) {
12250     eventHandler_->preWrite(ctx, "Hbase.deleteTable");
12251   }
12252 
12253   oprot->writeMessageBegin("deleteTable", ::apache::thrift::protocol::T_REPLY, seqid);
12254   result.write(oprot);
12255   oprot->writeMessageEnd();
12256   bytes = oprot->getTransport()->writeEnd();
12257   oprot->getTransport()->flush();
12258 
12259   if (eventHandler_.get() != NULL) {
12260     eventHandler_->postWrite(ctx, "Hbase.deleteTable", bytes);
12261   }
12262 }
12263 
12264 void HbaseProcessor::process_get(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
12265 {
12266   void* ctx = NULL;
12267   if (eventHandler_.get() != NULL) {
12268     ctx = eventHandler_->getContext("Hbase.get", callContext);
12269   }
12270   ::apache::thrift::TProcessorContextFreer freer(eventHandler_.get(), ctx, "Hbase.get");
12271 
12272   if (eventHandler_.get() != NULL) {
12273     eventHandler_->preRead(ctx, "Hbase.get");
12274   }
12275 
12276   Hbase_get_args args;
12277   args.read(iprot);
12278   iprot->readMessageEnd();
12279   uint32_t bytes = iprot->getTransport()->readEnd();
12280 
12281   if (eventHandler_.get() != NULL) {
12282     eventHandler_->postRead(ctx, "Hbase.get", bytes);
12283   }
12284 
12285   Hbase_get_result result;
12286   try {
12287     iface_->get(result.success, args.tableName, args.row, args.column);
12288     result.__isset.success = true;
12289   } catch (IOError &io) {
12290     result.io = io;
12291     result.__isset.io = true;
12292   } catch (const std::exception& e) {
12293     if (eventHandler_.get() != NULL) {
12294       eventHandler_->handlerError(ctx, "Hbase.get");
12295     }
12296 
12297     ::apache::thrift::TApplicationException x(e.what());
12298     oprot->writeMessageBegin("get", ::apache::thrift::protocol::T_EXCEPTION, seqid);
12299     x.write(oprot);
12300     oprot->writeMessageEnd();
12301     oprot->getTransport()->writeEnd();
12302     oprot->getTransport()->flush();
12303     return;
12304   }
12305 
12306   if (eventHandler_.get() != NULL) {
12307     eventHandler_->preWrite(ctx, "Hbase.get");
12308   }
12309 
12310   oprot->writeMessageBegin("get", ::apache::thrift::protocol::T_REPLY, seqid);
12311   result.write(oprot);
12312   oprot->writeMessageEnd();
12313   bytes = oprot->getTransport()->writeEnd();
12314   oprot->getTransport()->flush();
12315 
12316   if (eventHandler_.get() != NULL) {
12317     eventHandler_->postWrite(ctx, "Hbase.get", bytes);
12318   }
12319 }
12320 
12321 void HbaseProcessor::process_getVer(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
12322 {
12323   void* ctx = NULL;
12324   if (eventHandler_.get() != NULL) {
12325     ctx = eventHandler_->getContext("Hbase.getVer", callContext);
12326   }
12327   ::apache::thrift::TProcessorContextFreer freer(eventHandler_.get(), ctx, "Hbase.getVer");
12328 
12329   if (eventHandler_.get() != NULL) {
12330     eventHandler_->preRead(ctx, "Hbase.getVer");
12331   }
12332 
12333   Hbase_getVer_args args;
12334   args.read(iprot);
12335   iprot->readMessageEnd();
12336   uint32_t bytes = iprot->getTransport()->readEnd();
12337 
12338   if (eventHandler_.get() != NULL) {
12339     eventHandler_->postRead(ctx, "Hbase.getVer", bytes);
12340   }
12341 
12342   Hbase_getVer_result result;
12343   try {
12344     iface_->getVer(result.success, args.tableName, args.row, args.column, args.numVersions);
12345     result.__isset.success = true;
12346   } catch (IOError &io) {
12347     result.io = io;
12348     result.__isset.io = true;
12349   } catch (const std::exception& e) {
12350     if (eventHandler_.get() != NULL) {
12351       eventHandler_->handlerError(ctx, "Hbase.getVer");
12352     }
12353 
12354     ::apache::thrift::TApplicationException x(e.what());
12355     oprot->writeMessageBegin("getVer", ::apache::thrift::protocol::T_EXCEPTION, seqid);
12356     x.write(oprot);
12357     oprot->writeMessageEnd();
12358     oprot->getTransport()->writeEnd();
12359     oprot->getTransport()->flush();
12360     return;
12361   }
12362 
12363   if (eventHandler_.get() != NULL) {
12364     eventHandler_->preWrite(ctx, "Hbase.getVer");
12365   }
12366 
12367   oprot->writeMessageBegin("getVer", ::apache::thrift::protocol::T_REPLY, seqid);
12368   result.write(oprot);
12369   oprot->writeMessageEnd();
12370   bytes = oprot->getTransport()->writeEnd();
12371   oprot->getTransport()->flush();
12372 
12373   if (eventHandler_.get() != NULL) {
12374     eventHandler_->postWrite(ctx, "Hbase.getVer", bytes);
12375   }
12376 }
12377 
12378 void HbaseProcessor::process_getVerTs(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
12379 {
12380   void* ctx = NULL;
12381   if (eventHandler_.get() != NULL) {
12382     ctx = eventHandler_->getContext("Hbase.getVerTs", callContext);
12383   }
12384   ::apache::thrift::TProcessorContextFreer freer(eventHandler_.get(), ctx, "Hbase.getVerTs");
12385 
12386   if (eventHandler_.get() != NULL) {
12387     eventHandler_->preRead(ctx, "Hbase.getVerTs");
12388   }
12389 
12390   Hbase_getVerTs_args args;
12391   args.read(iprot);
12392   iprot->readMessageEnd();
12393   uint32_t bytes = iprot->getTransport()->readEnd();
12394 
12395   if (eventHandler_.get() != NULL) {
12396     eventHandler_->postRead(ctx, "Hbase.getVerTs", bytes);
12397   }
12398 
12399   Hbase_getVerTs_result result;
12400   try {
12401     iface_->getVerTs(result.success, args.tableName, args.row, args.column, args.timestamp, args.numVersions);
12402     result.__isset.success = true;
12403   } catch (IOError &io) {
12404     result.io = io;
12405     result.__isset.io = true;
12406   } catch (const std::exception& e) {
12407     if (eventHandler_.get() != NULL) {
12408       eventHandler_->handlerError(ctx, "Hbase.getVerTs");
12409     }
12410 
12411     ::apache::thrift::TApplicationException x(e.what());
12412     oprot->writeMessageBegin("getVerTs", ::apache::thrift::protocol::T_EXCEPTION, seqid);
12413     x.write(oprot);
12414     oprot->writeMessageEnd();
12415     oprot->getTransport()->writeEnd();
12416     oprot->getTransport()->flush();
12417     return;
12418   }
12419 
12420   if (eventHandler_.get() != NULL) {
12421     eventHandler_->preWrite(ctx, "Hbase.getVerTs");
12422   }
12423 
12424   oprot->writeMessageBegin("getVerTs", ::apache::thrift::protocol::T_REPLY, seqid);
12425   result.write(oprot);
12426   oprot->writeMessageEnd();
12427   bytes = oprot->getTransport()->writeEnd();
12428   oprot->getTransport()->flush();
12429 
12430   if (eventHandler_.get() != NULL) {
12431     eventHandler_->postWrite(ctx, "Hbase.getVerTs", bytes);
12432   }
12433 }
12434 
12435 void HbaseProcessor::process_getRow(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
12436 {
12437   void* ctx = NULL;
12438   if (eventHandler_.get() != NULL) {
12439     ctx = eventHandler_->getContext("Hbase.getRow", callContext);
12440   }
12441   ::apache::thrift::TProcessorContextFreer freer(eventHandler_.get(), ctx, "Hbase.getRow");
12442 
12443   if (eventHandler_.get() != NULL) {
12444     eventHandler_->preRead(ctx, "Hbase.getRow");
12445   }
12446 
12447   Hbase_getRow_args args;
12448   args.read(iprot);
12449   iprot->readMessageEnd();
12450   uint32_t bytes = iprot->getTransport()->readEnd();
12451 
12452   if (eventHandler_.get() != NULL) {
12453     eventHandler_->postRead(ctx, "Hbase.getRow", bytes);
12454   }
12455 
12456   Hbase_getRow_result result;
12457   try {
12458     iface_->getRow(result.success, args.tableName, args.row);
12459     result.__isset.success = true;
12460   } catch (IOError &io) {
12461     result.io = io;
12462     result.__isset.io = true;
12463   } catch (const std::exception& e) {
12464     if (eventHandler_.get() != NULL) {
12465       eventHandler_->handlerError(ctx, "Hbase.getRow");
12466     }
12467 
12468     ::apache::thrift::TApplicationException x(e.what());
12469     oprot->writeMessageBegin("getRow", ::apache::thrift::protocol::T_EXCEPTION, seqid);
12470     x.write(oprot);
12471     oprot->writeMessageEnd();
12472     oprot->getTransport()->writeEnd();
12473     oprot->getTransport()->flush();
12474     return;
12475   }
12476 
12477   if (eventHandler_.get() != NULL) {
12478     eventHandler_->preWrite(ctx, "Hbase.getRow");
12479   }
12480 
12481   oprot->writeMessageBegin("getRow", ::apache::thrift::protocol::T_REPLY, seqid);
12482   result.write(oprot);
12483   oprot->writeMessageEnd();
12484   bytes = oprot->getTransport()->writeEnd();
12485   oprot->getTransport()->flush();
12486 
12487   if (eventHandler_.get() != NULL) {
12488     eventHandler_->postWrite(ctx, "Hbase.getRow", bytes);
12489   }
12490 }
12491 
12492 void HbaseProcessor::process_getRowWithColumns(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
12493 {
12494   void* ctx = NULL;
12495   if (eventHandler_.get() != NULL) {
12496     ctx = eventHandler_->getContext("Hbase.getRowWithColumns", callContext);
12497   }
12498   ::apache::thrift::TProcessorContextFreer freer(eventHandler_.get(), ctx, "Hbase.getRowWithColumns");
12499 
12500   if (eventHandler_.get() != NULL) {
12501     eventHandler_->preRead(ctx, "Hbase.getRowWithColumns");
12502   }
12503 
12504   Hbase_getRowWithColumns_args args;
12505   args.read(iprot);
12506   iprot->readMessageEnd();
12507   uint32_t bytes = iprot->getTransport()->readEnd();
12508 
12509   if (eventHandler_.get() != NULL) {
12510     eventHandler_->postRead(ctx, "Hbase.getRowWithColumns", bytes);
12511   }
12512 
12513   Hbase_getRowWithColumns_result result;
12514   try {
12515     iface_->getRowWithColumns(result.success, args.tableName, args.row, args.columns);
12516     result.__isset.success = true;
12517   } catch (IOError &io) {
12518     result.io = io;
12519     result.__isset.io = true;
12520   } catch (const std::exception& e) {
12521     if (eventHandler_.get() != NULL) {
12522       eventHandler_->handlerError(ctx, "Hbase.getRowWithColumns");
12523     }
12524 
12525     ::apache::thrift::TApplicationException x(e.what());
12526     oprot->writeMessageBegin("getRowWithColumns", ::apache::thrift::protocol::T_EXCEPTION, seqid);
12527     x.write(oprot);
12528     oprot->writeMessageEnd();
12529     oprot->getTransport()->writeEnd();
12530     oprot->getTransport()->flush();
12531     return;
12532   }
12533 
12534   if (eventHandler_.get() != NULL) {
12535     eventHandler_->preWrite(ctx, "Hbase.getRowWithColumns");
12536   }
12537 
12538   oprot->writeMessageBegin("getRowWithColumns", ::apache::thrift::protocol::T_REPLY, seqid);
12539   result.write(oprot);
12540   oprot->writeMessageEnd();
12541   bytes = oprot->getTransport()->writeEnd();
12542   oprot->getTransport()->flush();
12543 
12544   if (eventHandler_.get() != NULL) {
12545     eventHandler_->postWrite(ctx, "Hbase.getRowWithColumns", bytes);
12546   }
12547 }
12548 
12549 void HbaseProcessor::process_getRowTs(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
12550 {
12551   void* ctx = NULL;
12552   if (eventHandler_.get() != NULL) {
12553     ctx = eventHandler_->getContext("Hbase.getRowTs", callContext);
12554   }
12555   ::apache::thrift::TProcessorContextFreer freer(eventHandler_.get(), ctx, "Hbase.getRowTs");
12556 
12557   if (eventHandler_.get() != NULL) {
12558     eventHandler_->preRead(ctx, "Hbase.getRowTs");
12559   }
12560 
12561   Hbase_getRowTs_args args;
12562   args.read(iprot);
12563   iprot->readMessageEnd();
12564   uint32_t bytes = iprot->getTransport()->readEnd();
12565 
12566   if (eventHandler_.get() != NULL) {
12567     eventHandler_->postRead(ctx, "Hbase.getRowTs", bytes);
12568   }
12569 
12570   Hbase_getRowTs_result result;
12571   try {
12572     iface_->getRowTs(result.success, args.tableName, args.row, args.timestamp);
12573     result.__isset.success = true;
12574   } catch (IOError &io) {
12575     result.io = io;
12576     result.__isset.io = true;
12577   } catch (const std::exception& e) {
12578     if (eventHandler_.get() != NULL) {
12579       eventHandler_->handlerError(ctx, "Hbase.getRowTs");
12580     }
12581 
12582     ::apache::thrift::TApplicationException x(e.what());
12583     oprot->writeMessageBegin("getRowTs", ::apache::thrift::protocol::T_EXCEPTION, seqid);
12584     x.write(oprot);
12585     oprot->writeMessageEnd();
12586     oprot->getTransport()->writeEnd();
12587     oprot->getTransport()->flush();
12588     return;
12589   }
12590 
12591   if (eventHandler_.get() != NULL) {
12592     eventHandler_->preWrite(ctx, "Hbase.getRowTs");
12593   }
12594 
12595   oprot->writeMessageBegin("getRowTs", ::apache::thrift::protocol::T_REPLY, seqid);
12596   result.write(oprot);
12597   oprot->writeMessageEnd();
12598   bytes = oprot->getTransport()->writeEnd();
12599   oprot->getTransport()->flush();
12600 
12601   if (eventHandler_.get() != NULL) {
12602     eventHandler_->postWrite(ctx, "Hbase.getRowTs", bytes);
12603   }
12604 }
12605 
12606 void HbaseProcessor::process_getRowWithColumnsTs(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
12607 {
12608   void* ctx = NULL;
12609   if (eventHandler_.get() != NULL) {
12610     ctx = eventHandler_->getContext("Hbase.getRowWithColumnsTs", callContext);
12611   }
12612   ::apache::thrift::TProcessorContextFreer freer(eventHandler_.get(), ctx, "Hbase.getRowWithColumnsTs");
12613 
12614   if (eventHandler_.get() != NULL) {
12615     eventHandler_->preRead(ctx, "Hbase.getRowWithColumnsTs");
12616   }
12617 
12618   Hbase_getRowWithColumnsTs_args args;
12619   args.read(iprot);
12620   iprot->readMessageEnd();
12621   uint32_t bytes = iprot->getTransport()->readEnd();
12622 
12623   if (eventHandler_.get() != NULL) {
12624     eventHandler_->postRead(ctx, "Hbase.getRowWithColumnsTs", bytes);
12625   }
12626 
12627   Hbase_getRowWithColumnsTs_result result;
12628   try {
12629     iface_->getRowWithColumnsTs(result.success, args.tableName, args.row, args.columns, args.timestamp);
12630     result.__isset.success = true;
12631   } catch (IOError &io) {
12632     result.io = io;
12633     result.__isset.io = true;
12634   } catch (const std::exception& e) {
12635     if (eventHandler_.get() != NULL) {
12636       eventHandler_->handlerError(ctx, "Hbase.getRowWithColumnsTs");
12637     }
12638 
12639     ::apache::thrift::TApplicationException x(e.what());
12640     oprot->writeMessageBegin("getRowWithColumnsTs", ::apache::thrift::protocol::T_EXCEPTION, seqid);
12641     x.write(oprot);
12642     oprot->writeMessageEnd();
12643     oprot->getTransport()->writeEnd();
12644     oprot->getTransport()->flush();
12645     return;
12646   }
12647 
12648   if (eventHandler_.get() != NULL) {
12649     eventHandler_->preWrite(ctx, "Hbase.getRowWithColumnsTs");
12650   }
12651 
12652   oprot->writeMessageBegin("getRowWithColumnsTs", ::apache::thrift::protocol::T_REPLY, seqid);
12653   result.write(oprot);
12654   oprot->writeMessageEnd();
12655   bytes = oprot->getTransport()->writeEnd();
12656   oprot->getTransport()->flush();
12657 
12658   if (eventHandler_.get() != NULL) {
12659     eventHandler_->postWrite(ctx, "Hbase.getRowWithColumnsTs", bytes);
12660   }
12661 }
12662 
12663 void HbaseProcessor::process_getRows(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
12664 {
12665   void* ctx = NULL;
12666   if (eventHandler_.get() != NULL) {
12667     ctx = eventHandler_->getContext("Hbase.getRows", callContext);
12668   }
12669   ::apache::thrift::TProcessorContextFreer freer(eventHandler_.get(), ctx, "Hbase.getRows");
12670 
12671   if (eventHandler_.get() != NULL) {
12672     eventHandler_->preRead(ctx, "Hbase.getRows");
12673   }
12674 
12675   Hbase_getRows_args args;
12676   args.read(iprot);
12677   iprot->readMessageEnd();
12678   uint32_t bytes = iprot->getTransport()->readEnd();
12679 
12680   if (eventHandler_.get() != NULL) {
12681     eventHandler_->postRead(ctx, "Hbase.getRows", bytes);
12682   }
12683 
12684   Hbase_getRows_result result;
12685   try {
12686     iface_->getRows(result.success, args.tableName, args.rows);
12687     result.__isset.success = true;
12688   } catch (IOError &io) {
12689     result.io = io;
12690     result.__isset.io = true;
12691   } catch (const std::exception& e) {
12692     if (eventHandler_.get() != NULL) {
12693       eventHandler_->handlerError(ctx, "Hbase.getRows");
12694     }
12695 
12696     ::apache::thrift::TApplicationException x(e.what());
12697     oprot->writeMessageBegin("getRows", ::apache::thrift::protocol::T_EXCEPTION, seqid);
12698     x.write(oprot);
12699     oprot->writeMessageEnd();
12700     oprot->getTransport()->writeEnd();
12701     oprot->getTransport()->flush();
12702     return;
12703   }
12704 
12705   if (eventHandler_.get() != NULL) {
12706     eventHandler_->preWrite(ctx, "Hbase.getRows");
12707   }
12708 
12709   oprot->writeMessageBegin("getRows", ::apache::thrift::protocol::T_REPLY, seqid);
12710   result.write(oprot);
12711   oprot->writeMessageEnd();
12712   bytes = oprot->getTransport()->writeEnd();
12713   oprot->getTransport()->flush();
12714 
12715   if (eventHandler_.get() != NULL) {
12716     eventHandler_->postWrite(ctx, "Hbase.getRows", bytes);
12717   }
12718 }
12719 
12720 void HbaseProcessor::process_getRowsWithColumns(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
12721 {
12722   void* ctx = NULL;
12723   if (eventHandler_.get() != NULL) {
12724     ctx = eventHandler_->getContext("Hbase.getRowsWithColumns", callContext);
12725   }
12726   ::apache::thrift::TProcessorContextFreer freer(eventHandler_.get(), ctx, "Hbase.getRowsWithColumns");
12727 
12728   if (eventHandler_.get() != NULL) {
12729     eventHandler_->preRead(ctx, "Hbase.getRowsWithColumns");
12730   }
12731 
12732   Hbase_getRowsWithColumns_args args;
12733   args.read(iprot);
12734   iprot->readMessageEnd();
12735   uint32_t bytes = iprot->getTransport()->readEnd();
12736 
12737   if (eventHandler_.get() != NULL) {
12738     eventHandler_->postRead(ctx, "Hbase.getRowsWithColumns", bytes);
12739   }
12740 
12741   Hbase_getRowsWithColumns_result result;
12742   try {
12743     iface_->getRowsWithColumns(result.success, args.tableName, args.rows, args.columns);
12744     result.__isset.success = true;
12745   } catch (IOError &io) {
12746     result.io = io;
12747     result.__isset.io = true;
12748   } catch (const std::exception& e) {
12749     if (eventHandler_.get() != NULL) {
12750       eventHandler_->handlerError(ctx, "Hbase.getRowsWithColumns");
12751     }
12752 
12753     ::apache::thrift::TApplicationException x(e.what());
12754     oprot->writeMessageBegin("getRowsWithColumns", ::apache::thrift::protocol::T_EXCEPTION, seqid);
12755     x.write(oprot);
12756     oprot->writeMessageEnd();
12757     oprot->getTransport()->writeEnd();
12758     oprot->getTransport()->flush();
12759     return;
12760   }
12761 
12762   if (eventHandler_.get() != NULL) {
12763     eventHandler_->preWrite(ctx, "Hbase.getRowsWithColumns");
12764   }
12765 
12766   oprot->writeMessageBegin("getRowsWithColumns", ::apache::thrift::protocol::T_REPLY, seqid);
12767   result.write(oprot);
12768   oprot->writeMessageEnd();
12769   bytes = oprot->getTransport()->writeEnd();
12770   oprot->getTransport()->flush();
12771 
12772   if (eventHandler_.get() != NULL) {
12773     eventHandler_->postWrite(ctx, "Hbase.getRowsWithColumns", bytes);
12774   }
12775 }
12776 
12777 void HbaseProcessor::process_getRowsTs(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
12778 {
12779   void* ctx = NULL;
12780   if (eventHandler_.get() != NULL) {
12781     ctx = eventHandler_->getContext("Hbase.getRowsTs", callContext);
12782   }
12783   ::apache::thrift::TProcessorContextFreer freer(eventHandler_.get(), ctx, "Hbase.getRowsTs");
12784 
12785   if (eventHandler_.get() != NULL) {
12786     eventHandler_->preRead(ctx, "Hbase.getRowsTs");
12787   }
12788 
12789   Hbase_getRowsTs_args args;
12790   args.read(iprot);
12791   iprot->readMessageEnd();
12792   uint32_t bytes = iprot->getTransport()->readEnd();
12793 
12794   if (eventHandler_.get() != NULL) {
12795     eventHandler_->postRead(ctx, "Hbase.getRowsTs", bytes);
12796   }
12797 
12798   Hbase_getRowsTs_result result;
12799   try {
12800     iface_->getRowsTs(result.success, args.tableName, args.rows, args.timestamp);
12801     result.__isset.success = true;
12802   } catch (IOError &io) {
12803     result.io = io;
12804     result.__isset.io = true;
12805   } catch (const std::exception& e) {
12806     if (eventHandler_.get() != NULL) {
12807       eventHandler_->handlerError(ctx, "Hbase.getRowsTs");
12808     }
12809 
12810     ::apache::thrift::TApplicationException x(e.what());
12811     oprot->writeMessageBegin("getRowsTs", ::apache::thrift::protocol::T_EXCEPTION, seqid);
12812     x.write(oprot);
12813     oprot->writeMessageEnd();
12814     oprot->getTransport()->writeEnd();
12815     oprot->getTransport()->flush();
12816     return;
12817   }
12818 
12819   if (eventHandler_.get() != NULL) {
12820     eventHandler_->preWrite(ctx, "Hbase.getRowsTs");
12821   }
12822 
12823   oprot->writeMessageBegin("getRowsTs", ::apache::thrift::protocol::T_REPLY, seqid);
12824   result.write(oprot);
12825   oprot->writeMessageEnd();
12826   bytes = oprot->getTransport()->writeEnd();
12827   oprot->getTransport()->flush();
12828 
12829   if (eventHandler_.get() != NULL) {
12830     eventHandler_->postWrite(ctx, "Hbase.getRowsTs", bytes);
12831   }
12832 }
12833 
12834 void HbaseProcessor::process_getRowsWithColumnsTs(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
12835 {
12836   void* ctx = NULL;
12837   if (eventHandler_.get() != NULL) {
12838     ctx = eventHandler_->getContext("Hbase.getRowsWithColumnsTs", callContext);
12839   }
12840   ::apache::thrift::TProcessorContextFreer freer(eventHandler_.get(), ctx, "Hbase.getRowsWithColumnsTs");
12841 
12842   if (eventHandler_.get() != NULL) {
12843     eventHandler_->preRead(ctx, "Hbase.getRowsWithColumnsTs");
12844   }
12845 
12846   Hbase_getRowsWithColumnsTs_args args;
12847   args.read(iprot);
12848   iprot->readMessageEnd();
12849   uint32_t bytes = iprot->getTransport()->readEnd();
12850 
12851   if (eventHandler_.get() != NULL) {
12852     eventHandler_->postRead(ctx, "Hbase.getRowsWithColumnsTs", bytes);
12853   }
12854 
12855   Hbase_getRowsWithColumnsTs_result result;
12856   try {
12857     iface_->getRowsWithColumnsTs(result.success, args.tableName, args.rows, args.columns, args.timestamp);
12858     result.__isset.success = true;
12859   } catch (IOError &io) {
12860     result.io = io;
12861     result.__isset.io = true;
12862   } catch (const std::exception& e) {
12863     if (eventHandler_.get() != NULL) {
12864       eventHandler_->handlerError(ctx, "Hbase.getRowsWithColumnsTs");
12865     }
12866 
12867     ::apache::thrift::TApplicationException x(e.what());
12868     oprot->writeMessageBegin("getRowsWithColumnsTs", ::apache::thrift::protocol::T_EXCEPTION, seqid);
12869     x.write(oprot);
12870     oprot->writeMessageEnd();
12871     oprot->getTransport()->writeEnd();
12872     oprot->getTransport()->flush();
12873     return;
12874   }
12875 
12876   if (eventHandler_.get() != NULL) {
12877     eventHandler_->preWrite(ctx, "Hbase.getRowsWithColumnsTs");
12878   }
12879 
12880   oprot->writeMessageBegin("getRowsWithColumnsTs", ::apache::thrift::protocol::T_REPLY, seqid);
12881   result.write(oprot);
12882   oprot->writeMessageEnd();
12883   bytes = oprot->getTransport()->writeEnd();
12884   oprot->getTransport()->flush();
12885 
12886   if (eventHandler_.get() != NULL) {
12887     eventHandler_->postWrite(ctx, "Hbase.getRowsWithColumnsTs", bytes);
12888   }
12889 }
12890 
12891 void HbaseProcessor::process_mutateRow(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
12892 {
12893   void* ctx = NULL;
12894   if (eventHandler_.get() != NULL) {
12895     ctx = eventHandler_->getContext("Hbase.mutateRow", callContext);
12896   }
12897   ::apache::thrift::TProcessorContextFreer freer(eventHandler_.get(), ctx, "Hbase.mutateRow");
12898 
12899   if (eventHandler_.get() != NULL) {
12900     eventHandler_->preRead(ctx, "Hbase.mutateRow");
12901   }
12902 
12903   Hbase_mutateRow_args args;
12904   args.read(iprot);
12905   iprot->readMessageEnd();
12906   uint32_t bytes = iprot->getTransport()->readEnd();
12907 
12908   if (eventHandler_.get() != NULL) {
12909     eventHandler_->postRead(ctx, "Hbase.mutateRow", bytes);
12910   }
12911 
12912   Hbase_mutateRow_result result;
12913   try {
12914     iface_->mutateRow(args.tableName, args.row, args.mutations);
12915   } catch (IOError &io) {
12916     result.io = io;
12917     result.__isset.io = true;
12918   } catch (IllegalArgument &ia) {
12919     result.ia = ia;
12920     result.__isset.ia = true;
12921   } catch (const std::exception& e) {
12922     if (eventHandler_.get() != NULL) {
12923       eventHandler_->handlerError(ctx, "Hbase.mutateRow");
12924     }
12925 
12926     ::apache::thrift::TApplicationException x(e.what());
12927     oprot->writeMessageBegin("mutateRow", ::apache::thrift::protocol::T_EXCEPTION, seqid);
12928     x.write(oprot);
12929     oprot->writeMessageEnd();
12930     oprot->getTransport()->writeEnd();
12931     oprot->getTransport()->flush();
12932     return;
12933   }
12934 
12935   if (eventHandler_.get() != NULL) {
12936     eventHandler_->preWrite(ctx, "Hbase.mutateRow");
12937   }
12938 
12939   oprot->writeMessageBegin("mutateRow", ::apache::thrift::protocol::T_REPLY, seqid);
12940   result.write(oprot);
12941   oprot->writeMessageEnd();
12942   bytes = oprot->getTransport()->writeEnd();
12943   oprot->getTransport()->flush();
12944 
12945   if (eventHandler_.get() != NULL) {
12946     eventHandler_->postWrite(ctx, "Hbase.mutateRow", bytes);
12947   }
12948 }
12949 
12950 void HbaseProcessor::process_mutateRowTs(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
12951 {
12952   void* ctx = NULL;
12953   if (eventHandler_.get() != NULL) {
12954     ctx = eventHandler_->getContext("Hbase.mutateRowTs", callContext);
12955   }
12956   ::apache::thrift::TProcessorContextFreer freer(eventHandler_.get(), ctx, "Hbase.mutateRowTs");
12957 
12958   if (eventHandler_.get() != NULL) {
12959     eventHandler_->preRead(ctx, "Hbase.mutateRowTs");
12960   }
12961 
12962   Hbase_mutateRowTs_args args;
12963   args.read(iprot);
12964   iprot->readMessageEnd();
12965   uint32_t bytes = iprot->getTransport()->readEnd();
12966 
12967   if (eventHandler_.get() != NULL) {
12968     eventHandler_->postRead(ctx, "Hbase.mutateRowTs", bytes);
12969   }
12970 
12971   Hbase_mutateRowTs_result result;
12972   try {
12973     iface_->mutateRowTs(args.tableName, args.row, args.mutations, args.timestamp);
12974   } catch (IOError &io) {
12975     result.io = io;
12976     result.__isset.io = true;
12977   } catch (IllegalArgument &ia) {
12978     result.ia = ia;
12979     result.__isset.ia = true;
12980   } catch (const std::exception& e) {
12981     if (eventHandler_.get() != NULL) {
12982       eventHandler_->handlerError(ctx, "Hbase.mutateRowTs");
12983     }
12984 
12985     ::apache::thrift::TApplicationException x(e.what());
12986     oprot->writeMessageBegin("mutateRowTs", ::apache::thrift::protocol::T_EXCEPTION, seqid);
12987     x.write(oprot);
12988     oprot->writeMessageEnd();
12989     oprot->getTransport()->writeEnd();
12990     oprot->getTransport()->flush();
12991     return;
12992   }
12993 
12994   if (eventHandler_.get() != NULL) {
12995     eventHandler_->preWrite(ctx, "Hbase.mutateRowTs");
12996   }
12997 
12998   oprot->writeMessageBegin("mutateRowTs", ::apache::thrift::protocol::T_REPLY, seqid);
12999   result.write(oprot);
13000   oprot->writeMessageEnd();
13001   bytes = oprot->getTransport()->writeEnd();
13002   oprot->getTransport()->flush();
13003 
13004   if (eventHandler_.get() != NULL) {
13005     eventHandler_->postWrite(ctx, "Hbase.mutateRowTs", bytes);
13006   }
13007 }
13008 
13009 void HbaseProcessor::process_mutateRows(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
13010 {
13011   void* ctx = NULL;
13012   if (eventHandler_.get() != NULL) {
13013     ctx = eventHandler_->getContext("Hbase.mutateRows", callContext);
13014   }
13015   ::apache::thrift::TProcessorContextFreer freer(eventHandler_.get(), ctx, "Hbase.mutateRows");
13016 
13017   if (eventHandler_.get() != NULL) {
13018     eventHandler_->preRead(ctx, "Hbase.mutateRows");
13019   }
13020 
13021   Hbase_mutateRows_args args;
13022   args.read(iprot);
13023   iprot->readMessageEnd();
13024   uint32_t bytes = iprot->getTransport()->readEnd();
13025 
13026   if (eventHandler_.get() != NULL) {
13027     eventHandler_->postRead(ctx, "Hbase.mutateRows", bytes);
13028   }
13029 
13030   Hbase_mutateRows_result result;
13031   try {
13032     iface_->mutateRows(args.tableName, args.rowBatches);
13033   } catch (IOError &io) {
13034     result.io = io;
13035     result.__isset.io = true;
13036   } catch (IllegalArgument &ia) {
13037     result.ia = ia;
13038     result.__isset.ia = true;
13039   } catch (const std::exception& e) {
13040     if (eventHandler_.get() != NULL) {
13041       eventHandler_->handlerError(ctx, "Hbase.mutateRows");
13042     }
13043 
13044     ::apache::thrift::TApplicationException x(e.what());
13045     oprot->writeMessageBegin("mutateRows", ::apache::thrift::protocol::T_EXCEPTION, seqid);
13046     x.write(oprot);
13047     oprot->writeMessageEnd();
13048     oprot->getTransport()->writeEnd();
13049     oprot->getTransport()->flush();
13050     return;
13051   }
13052 
13053   if (eventHandler_.get() != NULL) {
13054     eventHandler_->preWrite(ctx, "Hbase.mutateRows");
13055   }
13056 
13057   oprot->writeMessageBegin("mutateRows", ::apache::thrift::protocol::T_REPLY, seqid);
13058   result.write(oprot);
13059   oprot->writeMessageEnd();
13060   bytes = oprot->getTransport()->writeEnd();
13061   oprot->getTransport()->flush();
13062 
13063   if (eventHandler_.get() != NULL) {
13064     eventHandler_->postWrite(ctx, "Hbase.mutateRows", bytes);
13065   }
13066 }
13067 
13068 void HbaseProcessor::process_mutateRowsTs(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
13069 {
13070   void* ctx = NULL;
13071   if (eventHandler_.get() != NULL) {
13072     ctx = eventHandler_->getContext("Hbase.mutateRowsTs", callContext);
13073   }
13074   ::apache::thrift::TProcessorContextFreer freer(eventHandler_.get(), ctx, "Hbase.mutateRowsTs");
13075 
13076   if (eventHandler_.get() != NULL) {
13077     eventHandler_->preRead(ctx, "Hbase.mutateRowsTs");
13078   }
13079 
13080   Hbase_mutateRowsTs_args args;
13081   args.read(iprot);
13082   iprot->readMessageEnd();
13083   uint32_t bytes = iprot->getTransport()->readEnd();
13084 
13085   if (eventHandler_.get() != NULL) {
13086     eventHandler_->postRead(ctx, "Hbase.mutateRowsTs", bytes);
13087   }
13088 
13089   Hbase_mutateRowsTs_result result;
13090   try {
13091     iface_->mutateRowsTs(args.tableName, args.rowBatches, args.timestamp);
13092   } catch (IOError &io) {
13093     result.io = io;
13094     result.__isset.io = true;
13095   } catch (IllegalArgument &ia) {
13096     result.ia = ia;
13097     result.__isset.ia = true;
13098   } catch (const std::exception& e) {
13099     if (eventHandler_.get() != NULL) {
13100       eventHandler_->handlerError(ctx, "Hbase.mutateRowsTs");
13101     }
13102 
13103     ::apache::thrift::TApplicationException x(e.what());
13104     oprot->writeMessageBegin("mutateRowsTs", ::apache::thrift::protocol::T_EXCEPTION, seqid);
13105     x.write(oprot);
13106     oprot->writeMessageEnd();
13107     oprot->getTransport()->writeEnd();
13108     oprot->getTransport()->flush();
13109     return;
13110   }
13111 
13112   if (eventHandler_.get() != NULL) {
13113     eventHandler_->preWrite(ctx, "Hbase.mutateRowsTs");
13114   }
13115 
13116   oprot->writeMessageBegin("mutateRowsTs", ::apache::thrift::protocol::T_REPLY, seqid);
13117   result.write(oprot);
13118   oprot->writeMessageEnd();
13119   bytes = oprot->getTransport()->writeEnd();
13120   oprot->getTransport()->flush();
13121 
13122   if (eventHandler_.get() != NULL) {
13123     eventHandler_->postWrite(ctx, "Hbase.mutateRowsTs", bytes);
13124   }
13125 }
13126 
13127 void HbaseProcessor::process_atomicIncrement(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
13128 {
13129   void* ctx = NULL;
13130   if (eventHandler_.get() != NULL) {
13131     ctx = eventHandler_->getContext("Hbase.atomicIncrement", callContext);
13132   }
13133   ::apache::thrift::TProcessorContextFreer freer(eventHandler_.get(), ctx, "Hbase.atomicIncrement");
13134 
13135   if (eventHandler_.get() != NULL) {
13136     eventHandler_->preRead(ctx, "Hbase.atomicIncrement");
13137   }
13138 
13139   Hbase_atomicIncrement_args args;
13140   args.read(iprot);
13141   iprot->readMessageEnd();
13142   uint32_t bytes = iprot->getTransport()->readEnd();
13143 
13144   if (eventHandler_.get() != NULL) {
13145     eventHandler_->postRead(ctx, "Hbase.atomicIncrement", bytes);
13146   }
13147 
13148   Hbase_atomicIncrement_result result;
13149   try {
13150     result.success = iface_->atomicIncrement(args.tableName, args.row, args.column, args.value);
13151     result.__isset.success = true;
13152   } catch (IOError &io) {
13153     result.io = io;
13154     result.__isset.io = true;
13155   } catch (IllegalArgument &ia) {
13156     result.ia = ia;
13157     result.__isset.ia = true;
13158   } catch (const std::exception& e) {
13159     if (eventHandler_.get() != NULL) {
13160       eventHandler_->handlerError(ctx, "Hbase.atomicIncrement");
13161     }
13162 
13163     ::apache::thrift::TApplicationException x(e.what());
13164     oprot->writeMessageBegin("atomicIncrement", ::apache::thrift::protocol::T_EXCEPTION, seqid);
13165     x.write(oprot);
13166     oprot->writeMessageEnd();
13167     oprot->getTransport()->writeEnd();
13168     oprot->getTransport()->flush();
13169     return;
13170   }
13171 
13172   if (eventHandler_.get() != NULL) {
13173     eventHandler_->preWrite(ctx, "Hbase.atomicIncrement");
13174   }
13175 
13176   oprot->writeMessageBegin("atomicIncrement", ::apache::thrift::protocol::T_REPLY, seqid);
13177   result.write(oprot);
13178   oprot->writeMessageEnd();
13179   bytes = oprot->getTransport()->writeEnd();
13180   oprot->getTransport()->flush();
13181 
13182   if (eventHandler_.get() != NULL) {
13183     eventHandler_->postWrite(ctx, "Hbase.atomicIncrement", bytes);
13184   }
13185 }
13186 
13187 void HbaseProcessor::process_deleteAll(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
13188 {
13189   void* ctx = NULL;
13190   if (eventHandler_.get() != NULL) {
13191     ctx = eventHandler_->getContext("Hbase.deleteAll", callContext);
13192   }
13193   ::apache::thrift::TProcessorContextFreer freer(eventHandler_.get(), ctx, "Hbase.deleteAll");
13194 
13195   if (eventHandler_.get() != NULL) {
13196     eventHandler_->preRead(ctx, "Hbase.deleteAll");
13197   }
13198 
13199   Hbase_deleteAll_args args;
13200   args.read(iprot);
13201   iprot->readMessageEnd();
13202   uint32_t bytes = iprot->getTransport()->readEnd();
13203 
13204   if (eventHandler_.get() != NULL) {
13205     eventHandler_->postRead(ctx, "Hbase.deleteAll", bytes);
13206   }
13207 
13208   Hbase_deleteAll_result result;
13209   try {
13210     iface_->deleteAll(args.tableName, args.row, args.column);
13211   } catch (IOError &io) {
13212     result.io = io;
13213     result.__isset.io = true;
13214   } catch (const std::exception& e) {
13215     if (eventHandler_.get() != NULL) {
13216       eventHandler_->handlerError(ctx, "Hbase.deleteAll");
13217     }
13218 
13219     ::apache::thrift::TApplicationException x(e.what());
13220     oprot->writeMessageBegin("deleteAll", ::apache::thrift::protocol::T_EXCEPTION, seqid);
13221     x.write(oprot);
13222     oprot->writeMessageEnd();
13223     oprot->getTransport()->writeEnd();
13224     oprot->getTransport()->flush();
13225     return;
13226   }
13227 
13228   if (eventHandler_.get() != NULL) {
13229     eventHandler_->preWrite(ctx, "Hbase.deleteAll");
13230   }
13231 
13232   oprot->writeMessageBegin("deleteAll", ::apache::thrift::protocol::T_REPLY, seqid);
13233   result.write(oprot);
13234   oprot->writeMessageEnd();
13235   bytes = oprot->getTransport()->writeEnd();
13236   oprot->getTransport()->flush();
13237 
13238   if (eventHandler_.get() != NULL) {
13239     eventHandler_->postWrite(ctx, "Hbase.deleteAll", bytes);
13240   }
13241 }
13242 
13243 void HbaseProcessor::process_deleteAllTs(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
13244 {
13245   void* ctx = NULL;
13246   if (eventHandler_.get() != NULL) {
13247     ctx = eventHandler_->getContext("Hbase.deleteAllTs", callContext);
13248   }
13249   ::apache::thrift::TProcessorContextFreer freer(eventHandler_.get(), ctx, "Hbase.deleteAllTs");
13250 
13251   if (eventHandler_.get() != NULL) {
13252     eventHandler_->preRead(ctx, "Hbase.deleteAllTs");
13253   }
13254 
13255   Hbase_deleteAllTs_args args;
13256   args.read(iprot);
13257   iprot->readMessageEnd();
13258   uint32_t bytes = iprot->getTransport()->readEnd();
13259 
13260   if (eventHandler_.get() != NULL) {
13261     eventHandler_->postRead(ctx, "Hbase.deleteAllTs", bytes);
13262   }
13263 
13264   Hbase_deleteAllTs_result result;
13265   try {
13266     iface_->deleteAllTs(args.tableName, args.row, args.column, args.timestamp);
13267   } catch (IOError &io) {
13268     result.io = io;
13269     result.__isset.io = true;
13270   } catch (const std::exception& e) {
13271     if (eventHandler_.get() != NULL) {
13272       eventHandler_->handlerError(ctx, "Hbase.deleteAllTs");
13273     }
13274 
13275     ::apache::thrift::TApplicationException x(e.what());
13276     oprot->writeMessageBegin("deleteAllTs", ::apache::thrift::protocol::T_EXCEPTION, seqid);
13277     x.write(oprot);
13278     oprot->writeMessageEnd();
13279     oprot->getTransport()->writeEnd();
13280     oprot->getTransport()->flush();
13281     return;
13282   }
13283 
13284   if (eventHandler_.get() != NULL) {
13285     eventHandler_->preWrite(ctx, "Hbase.deleteAllTs");
13286   }
13287 
13288   oprot->writeMessageBegin("deleteAllTs", ::apache::thrift::protocol::T_REPLY, seqid);
13289   result.write(oprot);
13290   oprot->writeMessageEnd();
13291   bytes = oprot->getTransport()->writeEnd();
13292   oprot->getTransport()->flush();
13293 
13294   if (eventHandler_.get() != NULL) {
13295     eventHandler_->postWrite(ctx, "Hbase.deleteAllTs", bytes);
13296   }
13297 }
13298 
13299 void HbaseProcessor::process_deleteAllRow(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
13300 {
13301   void* ctx = NULL;
13302   if (eventHandler_.get() != NULL) {
13303     ctx = eventHandler_->getContext("Hbase.deleteAllRow", callContext);
13304   }
13305   ::apache::thrift::TProcessorContextFreer freer(eventHandler_.get(), ctx, "Hbase.deleteAllRow");
13306 
13307   if (eventHandler_.get() != NULL) {
13308     eventHandler_->preRead(ctx, "Hbase.deleteAllRow");
13309   }
13310 
13311   Hbase_deleteAllRow_args args;
13312   args.read(iprot);
13313   iprot->readMessageEnd();
13314   uint32_t bytes = iprot->getTransport()->readEnd();
13315 
13316   if (eventHandler_.get() != NULL) {
13317     eventHandler_->postRead(ctx, "Hbase.deleteAllRow", bytes);
13318   }
13319 
13320   Hbase_deleteAllRow_result result;
13321   try {
13322     iface_->deleteAllRow(args.tableName, args.row);
13323   } catch (IOError &io) {
13324     result.io = io;
13325     result.__isset.io = true;
13326   } catch (const std::exception& e) {
13327     if (eventHandler_.get() != NULL) {
13328       eventHandler_->handlerError(ctx, "Hbase.deleteAllRow");
13329     }
13330 
13331     ::apache::thrift::TApplicationException x(e.what());
13332     oprot->writeMessageBegin("deleteAllRow", ::apache::thrift::protocol::T_EXCEPTION, seqid);
13333     x.write(oprot);
13334     oprot->writeMessageEnd();
13335     oprot->getTransport()->writeEnd();
13336     oprot->getTransport()->flush();
13337     return;
13338   }
13339 
13340   if (eventHandler_.get() != NULL) {
13341     eventHandler_->preWrite(ctx, "Hbase.deleteAllRow");
13342   }
13343 
13344   oprot->writeMessageBegin("deleteAllRow", ::apache::thrift::protocol::T_REPLY, seqid);
13345   result.write(oprot);
13346   oprot->writeMessageEnd();
13347   bytes = oprot->getTransport()->writeEnd();
13348   oprot->getTransport()->flush();
13349 
13350   if (eventHandler_.get() != NULL) {
13351     eventHandler_->postWrite(ctx, "Hbase.deleteAllRow", bytes);
13352   }
13353 }
13354 
13355 void HbaseProcessor::process_deleteAllRowTs(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
13356 {
13357   void* ctx = NULL;
13358   if (eventHandler_.get() != NULL) {
13359     ctx = eventHandler_->getContext("Hbase.deleteAllRowTs", callContext);
13360   }
13361   ::apache::thrift::TProcessorContextFreer freer(eventHandler_.get(), ctx, "Hbase.deleteAllRowTs");
13362 
13363   if (eventHandler_.get() != NULL) {
13364     eventHandler_->preRead(ctx, "Hbase.deleteAllRowTs");
13365   }
13366 
13367   Hbase_deleteAllRowTs_args args;
13368   args.read(iprot);
13369   iprot->readMessageEnd();
13370   uint32_t bytes = iprot->getTransport()->readEnd();
13371 
13372   if (eventHandler_.get() != NULL) {
13373     eventHandler_->postRead(ctx, "Hbase.deleteAllRowTs", bytes);
13374   }
13375 
13376   Hbase_deleteAllRowTs_result result;
13377   try {
13378     iface_->deleteAllRowTs(args.tableName, args.row, args.timestamp);
13379   } catch (IOError &io) {
13380     result.io = io;
13381     result.__isset.io = true;
13382   } catch (const std::exception& e) {
13383     if (eventHandler_.get() != NULL) {
13384       eventHandler_->handlerError(ctx, "Hbase.deleteAllRowTs");
13385     }
13386 
13387     ::apache::thrift::TApplicationException x(e.what());
13388     oprot->writeMessageBegin("deleteAllRowTs", ::apache::thrift::protocol::T_EXCEPTION, seqid);
13389     x.write(oprot);
13390     oprot->writeMessageEnd();
13391     oprot->getTransport()->writeEnd();
13392     oprot->getTransport()->flush();
13393     return;
13394   }
13395 
13396   if (eventHandler_.get() != NULL) {
13397     eventHandler_->preWrite(ctx, "Hbase.deleteAllRowTs");
13398   }
13399 
13400   oprot->writeMessageBegin("deleteAllRowTs", ::apache::thrift::protocol::T_REPLY, seqid);
13401   result.write(oprot);
13402   oprot->writeMessageEnd();
13403   bytes = oprot->getTransport()->writeEnd();
13404   oprot->getTransport()->flush();
13405 
13406   if (eventHandler_.get() != NULL) {
13407     eventHandler_->postWrite(ctx, "Hbase.deleteAllRowTs", bytes);
13408   }
13409 }
13410 
13411 void HbaseProcessor::process_scannerOpenWithScan(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
13412 {
13413   void* ctx = NULL;
13414   if (eventHandler_.get() != NULL) {
13415     ctx = eventHandler_->getContext("Hbase.scannerOpenWithScan", callContext);
13416   }
13417   ::apache::thrift::TProcessorContextFreer freer(eventHandler_.get(), ctx, "Hbase.scannerOpenWithScan");
13418 
13419   if (eventHandler_.get() != NULL) {
13420     eventHandler_->preRead(ctx, "Hbase.scannerOpenWithScan");
13421   }
13422 
13423   Hbase_scannerOpenWithScan_args args;
13424   args.read(iprot);
13425   iprot->readMessageEnd();
13426   uint32_t bytes = iprot->getTransport()->readEnd();
13427 
13428   if (eventHandler_.get() != NULL) {
13429     eventHandler_->postRead(ctx, "Hbase.scannerOpenWithScan", bytes);
13430   }
13431 
13432   Hbase_scannerOpenWithScan_result result;
13433   try {
13434     result.success = iface_->scannerOpenWithScan(args.tableName, args.scan);
13435     result.__isset.success = true;
13436   } catch (IOError &io) {
13437     result.io = io;
13438     result.__isset.io = true;
13439   } catch (const std::exception& e) {
13440     if (eventHandler_.get() != NULL) {
13441       eventHandler_->handlerError(ctx, "Hbase.scannerOpenWithScan");
13442     }
13443 
13444     ::apache::thrift::TApplicationException x(e.what());
13445     oprot->writeMessageBegin("scannerOpenWithScan", ::apache::thrift::protocol::T_EXCEPTION, seqid);
13446     x.write(oprot);
13447     oprot->writeMessageEnd();
13448     oprot->getTransport()->writeEnd();
13449     oprot->getTransport()->flush();
13450     return;
13451   }
13452 
13453   if (eventHandler_.get() != NULL) {
13454     eventHandler_->preWrite(ctx, "Hbase.scannerOpenWithScan");
13455   }
13456 
13457   oprot->writeMessageBegin("scannerOpenWithScan", ::apache::thrift::protocol::T_REPLY, seqid);
13458   result.write(oprot);
13459   oprot->writeMessageEnd();
13460   bytes = oprot->getTransport()->writeEnd();
13461   oprot->getTransport()->flush();
13462 
13463   if (eventHandler_.get() != NULL) {
13464     eventHandler_->postWrite(ctx, "Hbase.scannerOpenWithScan", bytes);
13465   }
13466 }
13467 
13468 void HbaseProcessor::process_scannerOpen(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
13469 {
13470   void* ctx = NULL;
13471   if (eventHandler_.get() != NULL) {
13472     ctx = eventHandler_->getContext("Hbase.scannerOpen", callContext);
13473   }
13474   ::apache::thrift::TProcessorContextFreer freer(eventHandler_.get(), ctx, "Hbase.scannerOpen");
13475 
13476   if (eventHandler_.get() != NULL) {
13477     eventHandler_->preRead(ctx, "Hbase.scannerOpen");
13478   }
13479 
13480   Hbase_scannerOpen_args args;
13481   args.read(iprot);
13482   iprot->readMessageEnd();
13483   uint32_t bytes = iprot->getTransport()->readEnd();
13484 
13485   if (eventHandler_.get() != NULL) {
13486     eventHandler_->postRead(ctx, "Hbase.scannerOpen", bytes);
13487   }
13488 
13489   Hbase_scannerOpen_result result;
13490   try {
13491     result.success = iface_->scannerOpen(args.tableName, args.startRow, args.columns);
13492     result.__isset.success = true;
13493   } catch (IOError &io) {
13494     result.io = io;
13495     result.__isset.io = true;
13496   } catch (const std::exception& e) {
13497     if (eventHandler_.get() != NULL) {
13498       eventHandler_->handlerError(ctx, "Hbase.scannerOpen");
13499     }
13500 
13501     ::apache::thrift::TApplicationException x(e.what());
13502     oprot->writeMessageBegin("scannerOpen", ::apache::thrift::protocol::T_EXCEPTION, seqid);
13503     x.write(oprot);
13504     oprot->writeMessageEnd();
13505     oprot->getTransport()->writeEnd();
13506     oprot->getTransport()->flush();
13507     return;
13508   }
13509 
13510   if (eventHandler_.get() != NULL) {
13511     eventHandler_->preWrite(ctx, "Hbase.scannerOpen");
13512   }
13513 
13514   oprot->writeMessageBegin("scannerOpen", ::apache::thrift::protocol::T_REPLY, seqid);
13515   result.write(oprot);
13516   oprot->writeMessageEnd();
13517   bytes = oprot->getTransport()->writeEnd();
13518   oprot->getTransport()->flush();
13519 
13520   if (eventHandler_.get() != NULL) {
13521     eventHandler_->postWrite(ctx, "Hbase.scannerOpen", bytes);
13522   }
13523 }
13524 
13525 void HbaseProcessor::process_scannerOpenWithStop(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
13526 {
13527   void* ctx = NULL;
13528   if (eventHandler_.get() != NULL) {
13529     ctx = eventHandler_->getContext("Hbase.scannerOpenWithStop", callContext);
13530   }
13531   ::apache::thrift::TProcessorContextFreer freer(eventHandler_.get(), ctx, "Hbase.scannerOpenWithStop");
13532 
13533   if (eventHandler_.get() != NULL) {
13534     eventHandler_->preRead(ctx, "Hbase.scannerOpenWithStop");
13535   }
13536 
13537   Hbase_scannerOpenWithStop_args args;
13538   args.read(iprot);
13539   iprot->readMessageEnd();
13540   uint32_t bytes = iprot->getTransport()->readEnd();
13541 
13542   if (eventHandler_.get() != NULL) {
13543     eventHandler_->postRead(ctx, "Hbase.scannerOpenWithStop", bytes);
13544   }
13545 
13546   Hbase_scannerOpenWithStop_result result;
13547   try {
13548     result.success = iface_->scannerOpenWithStop(args.tableName, args.startRow, args.stopRow, args.columns);
13549     result.__isset.success = true;
13550   } catch (IOError &io) {
13551     result.io = io;
13552     result.__isset.io = true;
13553   } catch (const std::exception& e) {
13554     if (eventHandler_.get() != NULL) {
13555       eventHandler_->handlerError(ctx, "Hbase.scannerOpenWithStop");
13556     }
13557 
13558     ::apache::thrift::TApplicationException x(e.what());
13559     oprot->writeMessageBegin("scannerOpenWithStop", ::apache::thrift::protocol::T_EXCEPTION, seqid);
13560     x.write(oprot);
13561     oprot->writeMessageEnd();
13562     oprot->getTransport()->writeEnd();
13563     oprot->getTransport()->flush();
13564     return;
13565   }
13566 
13567   if (eventHandler_.get() != NULL) {
13568     eventHandler_->preWrite(ctx, "Hbase.scannerOpenWithStop");
13569   }
13570 
13571   oprot->writeMessageBegin("scannerOpenWithStop", ::apache::thrift::protocol::T_REPLY, seqid);
13572   result.write(oprot);
13573   oprot->writeMessageEnd();
13574   bytes = oprot->getTransport()->writeEnd();
13575   oprot->getTransport()->flush();
13576 
13577   if (eventHandler_.get() != NULL) {
13578     eventHandler_->postWrite(ctx, "Hbase.scannerOpenWithStop", bytes);
13579   }
13580 }
13581 
13582 void HbaseProcessor::process_scannerOpenWithPrefix(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
13583 {
13584   void* ctx = NULL;
13585   if (eventHandler_.get() != NULL) {
13586     ctx = eventHandler_->getContext("Hbase.scannerOpenWithPrefix", callContext);
13587   }
13588   ::apache::thrift::TProcessorContextFreer freer(eventHandler_.get(), ctx, "Hbase.scannerOpenWithPrefix");
13589 
13590   if (eventHandler_.get() != NULL) {
13591     eventHandler_->preRead(ctx, "Hbase.scannerOpenWithPrefix");
13592   }
13593 
13594   Hbase_scannerOpenWithPrefix_args args;
13595   args.read(iprot);
13596   iprot->readMessageEnd();
13597   uint32_t bytes = iprot->getTransport()->readEnd();
13598 
13599   if (eventHandler_.get() != NULL) {
13600     eventHandler_->postRead(ctx, "Hbase.scannerOpenWithPrefix", bytes);
13601   }
13602 
13603   Hbase_scannerOpenWithPrefix_result result;
13604   try {
13605     result.success = iface_->scannerOpenWithPrefix(args.tableName, args.startAndPrefix, args.columns);
13606     result.__isset.success = true;
13607   } catch (IOError &io) {
13608     result.io = io;
13609     result.__isset.io = true;
13610   } catch (const std::exception& e) {
13611     if (eventHandler_.get() != NULL) {
13612       eventHandler_->handlerError(ctx, "Hbase.scannerOpenWithPrefix");
13613     }
13614 
13615     ::apache::thrift::TApplicationException x(e.what());
13616     oprot->writeMessageBegin("scannerOpenWithPrefix", ::apache::thrift::protocol::T_EXCEPTION, seqid);
13617     x.write(oprot);
13618     oprot->writeMessageEnd();
13619     oprot->getTransport()->writeEnd();
13620     oprot->getTransport()->flush();
13621     return;
13622   }
13623 
13624   if (eventHandler_.get() != NULL) {
13625     eventHandler_->preWrite(ctx, "Hbase.scannerOpenWithPrefix");
13626   }
13627 
13628   oprot->writeMessageBegin("scannerOpenWithPrefix", ::apache::thrift::protocol::T_REPLY, seqid);
13629   result.write(oprot);
13630   oprot->writeMessageEnd();
13631   bytes = oprot->getTransport()->writeEnd();
13632   oprot->getTransport()->flush();
13633 
13634   if (eventHandler_.get() != NULL) {
13635     eventHandler_->postWrite(ctx, "Hbase.scannerOpenWithPrefix", bytes);
13636   }
13637 }
13638 
13639 void HbaseProcessor::process_scannerOpenTs(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
13640 {
13641   void* ctx = NULL;
13642   if (eventHandler_.get() != NULL) {
13643     ctx = eventHandler_->getContext("Hbase.scannerOpenTs", callContext);
13644   }
13645   ::apache::thrift::TProcessorContextFreer freer(eventHandler_.get(), ctx, "Hbase.scannerOpenTs");
13646 
13647   if (eventHandler_.get() != NULL) {
13648     eventHandler_->preRead(ctx, "Hbase.scannerOpenTs");
13649   }
13650 
13651   Hbase_scannerOpenTs_args args;
13652   args.read(iprot);
13653   iprot->readMessageEnd();
13654   uint32_t bytes = iprot->getTransport()->readEnd();
13655 
13656   if (eventHandler_.get() != NULL) {
13657     eventHandler_->postRead(ctx, "Hbase.scannerOpenTs", bytes);
13658   }
13659 
13660   Hbase_scannerOpenTs_result result;
13661   try {
13662     result.success = iface_->scannerOpenTs(args.tableName, args.startRow, args.columns, args.timestamp);
13663     result.__isset.success = true;
13664   } catch (IOError &io) {
13665     result.io = io;
13666     result.__isset.io = true;
13667   } catch (const std::exception& e) {
13668     if (eventHandler_.get() != NULL) {
13669       eventHandler_->handlerError(ctx, "Hbase.scannerOpenTs");
13670     }
13671 
13672     ::apache::thrift::TApplicationException x(e.what());
13673     oprot->writeMessageBegin("scannerOpenTs", ::apache::thrift::protocol::T_EXCEPTION, seqid);
13674     x.write(oprot);
13675     oprot->writeMessageEnd();
13676     oprot->getTransport()->writeEnd();
13677     oprot->getTransport()->flush();
13678     return;
13679   }
13680 
13681   if (eventHandler_.get() != NULL) {
13682     eventHandler_->preWrite(ctx, "Hbase.scannerOpenTs");
13683   }
13684 
13685   oprot->writeMessageBegin("scannerOpenTs", ::apache::thrift::protocol::T_REPLY, seqid);
13686   result.write(oprot);
13687   oprot->writeMessageEnd();
13688   bytes = oprot->getTransport()->writeEnd();
13689   oprot->getTransport()->flush();
13690 
13691   if (eventHandler_.get() != NULL) {
13692     eventHandler_->postWrite(ctx, "Hbase.scannerOpenTs", bytes);
13693   }
13694 }
13695 
13696 void HbaseProcessor::process_scannerOpenWithStopTs(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
13697 {
13698   void* ctx = NULL;
13699   if (eventHandler_.get() != NULL) {
13700     ctx = eventHandler_->getContext("Hbase.scannerOpenWithStopTs", callContext);
13701   }
13702   ::apache::thrift::TProcessorContextFreer freer(eventHandler_.get(), ctx, "Hbase.scannerOpenWithStopTs");
13703 
13704   if (eventHandler_.get() != NULL) {
13705     eventHandler_->preRead(ctx, "Hbase.scannerOpenWithStopTs");
13706   }
13707 
13708   Hbase_scannerOpenWithStopTs_args args;
13709   args.read(iprot);
13710   iprot->readMessageEnd();
13711   uint32_t bytes = iprot->getTransport()->readEnd();
13712 
13713   if (eventHandler_.get() != NULL) {
13714     eventHandler_->postRead(ctx, "Hbase.scannerOpenWithStopTs", bytes);
13715   }
13716 
13717   Hbase_scannerOpenWithStopTs_result result;
13718   try {
13719     result.success = iface_->scannerOpenWithStopTs(args.tableName, args.startRow, args.stopRow, args.columns, args.timestamp);
13720     result.__isset.success = true;
13721   } catch (IOError &io) {
13722     result.io = io;
13723     result.__isset.io = true;
13724   } catch (const std::exception& e) {
13725     if (eventHandler_.get() != NULL) {
13726       eventHandler_->handlerError(ctx, "Hbase.scannerOpenWithStopTs");
13727     }
13728 
13729     ::apache::thrift::TApplicationException x(e.what());
13730     oprot->writeMessageBegin("scannerOpenWithStopTs", ::apache::thrift::protocol::T_EXCEPTION, seqid);
13731     x.write(oprot);
13732     oprot->writeMessageEnd();
13733     oprot->getTransport()->writeEnd();
13734     oprot->getTransport()->flush();
13735     return;
13736   }
13737 
13738   if (eventHandler_.get() != NULL) {
13739     eventHandler_->preWrite(ctx, "Hbase.scannerOpenWithStopTs");
13740   }
13741 
13742   oprot->writeMessageBegin("scannerOpenWithStopTs", ::apache::thrift::protocol::T_REPLY, seqid);
13743   result.write(oprot);
13744   oprot->writeMessageEnd();
13745   bytes = oprot->getTransport()->writeEnd();
13746   oprot->getTransport()->flush();
13747 
13748   if (eventHandler_.get() != NULL) {
13749     eventHandler_->postWrite(ctx, "Hbase.scannerOpenWithStopTs", bytes);
13750   }
13751 }
13752 
13753 void HbaseProcessor::process_scannerGet(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
13754 {
13755   void* ctx = NULL;
13756   if (eventHandler_.get() != NULL) {
13757     ctx = eventHandler_->getContext("Hbase.scannerGet", callContext);
13758   }
13759   ::apache::thrift::TProcessorContextFreer freer(eventHandler_.get(), ctx, "Hbase.scannerGet");
13760 
13761   if (eventHandler_.get() != NULL) {
13762     eventHandler_->preRead(ctx, "Hbase.scannerGet");
13763   }
13764 
13765   Hbase_scannerGet_args args;
13766   args.read(iprot);
13767   iprot->readMessageEnd();
13768   uint32_t bytes = iprot->getTransport()->readEnd();
13769 
13770   if (eventHandler_.get() != NULL) {
13771     eventHandler_->postRead(ctx, "Hbase.scannerGet", bytes);
13772   }
13773 
13774   Hbase_scannerGet_result result;
13775   try {
13776     iface_->scannerGet(result.success, args.id);
13777     result.__isset.success = true;
13778   } catch (IOError &io) {
13779     result.io = io;
13780     result.__isset.io = true;
13781   } catch (IllegalArgument &ia) {
13782     result.ia = ia;
13783     result.__isset.ia = true;
13784   } catch (const std::exception& e) {
13785     if (eventHandler_.get() != NULL) {
13786       eventHandler_->handlerError(ctx, "Hbase.scannerGet");
13787     }
13788 
13789     ::apache::thrift::TApplicationException x(e.what());
13790     oprot->writeMessageBegin("scannerGet", ::apache::thrift::protocol::T_EXCEPTION, seqid);
13791     x.write(oprot);
13792     oprot->writeMessageEnd();
13793     oprot->getTransport()->writeEnd();
13794     oprot->getTransport()->flush();
13795     return;
13796   }
13797 
13798   if (eventHandler_.get() != NULL) {
13799     eventHandler_->preWrite(ctx, "Hbase.scannerGet");
13800   }
13801 
13802   oprot->writeMessageBegin("scannerGet", ::apache::thrift::protocol::T_REPLY, seqid);
13803   result.write(oprot);
13804   oprot->writeMessageEnd();
13805   bytes = oprot->getTransport()->writeEnd();
13806   oprot->getTransport()->flush();
13807 
13808   if (eventHandler_.get() != NULL) {
13809     eventHandler_->postWrite(ctx, "Hbase.scannerGet", bytes);
13810   }
13811 }
13812 
13813 void HbaseProcessor::process_scannerGetList(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
13814 {
13815   void* ctx = NULL;
13816   if (eventHandler_.get() != NULL) {
13817     ctx = eventHandler_->getContext("Hbase.scannerGetList", callContext);
13818   }
13819   ::apache::thrift::TProcessorContextFreer freer(eventHandler_.get(), ctx, "Hbase.scannerGetList");
13820 
13821   if (eventHandler_.get() != NULL) {
13822     eventHandler_->preRead(ctx, "Hbase.scannerGetList");
13823   }
13824 
13825   Hbase_scannerGetList_args args;
13826   args.read(iprot);
13827   iprot->readMessageEnd();
13828   uint32_t bytes = iprot->getTransport()->readEnd();
13829 
13830   if (eventHandler_.get() != NULL) {
13831     eventHandler_->postRead(ctx, "Hbase.scannerGetList", bytes);
13832   }
13833 
13834   Hbase_scannerGetList_result result;
13835   try {
13836     iface_->scannerGetList(result.success, args.id, args.nbRows);
13837     result.__isset.success = true;
13838   } catch (IOError &io) {
13839     result.io = io;
13840     result.__isset.io = true;
13841   } catch (IllegalArgument &ia) {
13842     result.ia = ia;
13843     result.__isset.ia = true;
13844   } catch (const std::exception& e) {
13845     if (eventHandler_.get() != NULL) {
13846       eventHandler_->handlerError(ctx, "Hbase.scannerGetList");
13847     }
13848 
13849     ::apache::thrift::TApplicationException x(e.what());
13850     oprot->writeMessageBegin("scannerGetList", ::apache::thrift::protocol::T_EXCEPTION, seqid);
13851     x.write(oprot);
13852     oprot->writeMessageEnd();
13853     oprot->getTransport()->writeEnd();
13854     oprot->getTransport()->flush();
13855     return;
13856   }
13857 
13858   if (eventHandler_.get() != NULL) {
13859     eventHandler_->preWrite(ctx, "Hbase.scannerGetList");
13860   }
13861 
13862   oprot->writeMessageBegin("scannerGetList", ::apache::thrift::protocol::T_REPLY, seqid);
13863   result.write(oprot);
13864   oprot->writeMessageEnd();
13865   bytes = oprot->getTransport()->writeEnd();
13866   oprot->getTransport()->flush();
13867 
13868   if (eventHandler_.get() != NULL) {
13869     eventHandler_->postWrite(ctx, "Hbase.scannerGetList", bytes);
13870   }
13871 }
13872 
13873 void HbaseProcessor::process_scannerClose(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
13874 {
13875   void* ctx = NULL;
13876   if (eventHandler_.get() != NULL) {
13877     ctx = eventHandler_->getContext("Hbase.scannerClose", callContext);
13878   }
13879   ::apache::thrift::TProcessorContextFreer freer(eventHandler_.get(), ctx, "Hbase.scannerClose");
13880 
13881   if (eventHandler_.get() != NULL) {
13882     eventHandler_->preRead(ctx, "Hbase.scannerClose");
13883   }
13884 
13885   Hbase_scannerClose_args args;
13886   args.read(iprot);
13887   iprot->readMessageEnd();
13888   uint32_t bytes = iprot->getTransport()->readEnd();
13889 
13890   if (eventHandler_.get() != NULL) {
13891     eventHandler_->postRead(ctx, "Hbase.scannerClose", bytes);
13892   }
13893 
13894   Hbase_scannerClose_result result;
13895   try {
13896     iface_->scannerClose(args.id);
13897   } catch (IOError &io) {
13898     result.io = io;
13899     result.__isset.io = true;
13900   } catch (IllegalArgument &ia) {
13901     result.ia = ia;
13902     result.__isset.ia = true;
13903   } catch (const std::exception& e) {
13904     if (eventHandler_.get() != NULL) {
13905       eventHandler_->handlerError(ctx, "Hbase.scannerClose");
13906     }
13907 
13908     ::apache::thrift::TApplicationException x(e.what());
13909     oprot->writeMessageBegin("scannerClose", ::apache::thrift::protocol::T_EXCEPTION, seqid);
13910     x.write(oprot);
13911     oprot->writeMessageEnd();
13912     oprot->getTransport()->writeEnd();
13913     oprot->getTransport()->flush();
13914     return;
13915   }
13916 
13917   if (eventHandler_.get() != NULL) {
13918     eventHandler_->preWrite(ctx, "Hbase.scannerClose");
13919   }
13920 
13921   oprot->writeMessageBegin("scannerClose", ::apache::thrift::protocol::T_REPLY, seqid);
13922   result.write(oprot);
13923   oprot->writeMessageEnd();
13924   bytes = oprot->getTransport()->writeEnd();
13925   oprot->getTransport()->flush();
13926 
13927   if (eventHandler_.get() != NULL) {
13928     eventHandler_->postWrite(ctx, "Hbase.scannerClose", bytes);
13929   }
13930 }
13931 
13932 void HbaseProcessor::process_getRowOrBefore(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
13933 {
13934   void* ctx = NULL;
13935   if (eventHandler_.get() != NULL) {
13936     ctx = eventHandler_->getContext("Hbase.getRowOrBefore", callContext);
13937   }
13938   ::apache::thrift::TProcessorContextFreer freer(eventHandler_.get(), ctx, "Hbase.getRowOrBefore");
13939 
13940   if (eventHandler_.get() != NULL) {
13941     eventHandler_->preRead(ctx, "Hbase.getRowOrBefore");
13942   }
13943 
13944   Hbase_getRowOrBefore_args args;
13945   args.read(iprot);
13946   iprot->readMessageEnd();
13947   uint32_t bytes = iprot->getTransport()->readEnd();
13948 
13949   if (eventHandler_.get() != NULL) {
13950     eventHandler_->postRead(ctx, "Hbase.getRowOrBefore", bytes);
13951   }
13952 
13953   Hbase_getRowOrBefore_result result;
13954   try {
13955     iface_->getRowOrBefore(result.success, args.tableName, args.row, args.family);
13956     result.__isset.success = true;
13957   } catch (IOError &io) {
13958     result.io = io;
13959     result.__isset.io = true;
13960   } catch (const std::exception& e) {
13961     if (eventHandler_.get() != NULL) {
13962       eventHandler_->handlerError(ctx, "Hbase.getRowOrBefore");
13963     }
13964 
13965     ::apache::thrift::TApplicationException x(e.what());
13966     oprot->writeMessageBegin("getRowOrBefore", ::apache::thrift::protocol::T_EXCEPTION, seqid);
13967     x.write(oprot);
13968     oprot->writeMessageEnd();
13969     oprot->getTransport()->writeEnd();
13970     oprot->getTransport()->flush();
13971     return;
13972   }
13973 
13974   if (eventHandler_.get() != NULL) {
13975     eventHandler_->preWrite(ctx, "Hbase.getRowOrBefore");
13976   }
13977 
13978   oprot->writeMessageBegin("getRowOrBefore", ::apache::thrift::protocol::T_REPLY, seqid);
13979   result.write(oprot);
13980   oprot->writeMessageEnd();
13981   bytes = oprot->getTransport()->writeEnd();
13982   oprot->getTransport()->flush();
13983 
13984   if (eventHandler_.get() != NULL) {
13985     eventHandler_->postWrite(ctx, "Hbase.getRowOrBefore", bytes);
13986   }
13987 }
13988 
13989 void HbaseProcessor::process_getRegionInfo(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
13990 {
13991   void* ctx = NULL;
13992   if (eventHandler_.get() != NULL) {
13993     ctx = eventHandler_->getContext("Hbase.getRegionInfo", callContext);
13994   }
13995   ::apache::thrift::TProcessorContextFreer freer(eventHandler_.get(), ctx, "Hbase.getRegionInfo");
13996 
13997   if (eventHandler_.get() != NULL) {
13998     eventHandler_->preRead(ctx, "Hbase.getRegionInfo");
13999   }
14000 
14001   Hbase_getRegionInfo_args args;
14002   args.read(iprot);
14003   iprot->readMessageEnd();
14004   uint32_t bytes = iprot->getTransport()->readEnd();
14005 
14006   if (eventHandler_.get() != NULL) {
14007     eventHandler_->postRead(ctx, "Hbase.getRegionInfo", bytes);
14008   }
14009 
14010   Hbase_getRegionInfo_result result;
14011   try {
14012     iface_->getRegionInfo(result.success, args.row);
14013     result.__isset.success = true;
14014   } catch (IOError &io) {
14015     result.io = io;
14016     result.__isset.io = true;
14017   } catch (const std::exception& e) {
14018     if (eventHandler_.get() != NULL) {
14019       eventHandler_->handlerError(ctx, "Hbase.getRegionInfo");
14020     }
14021 
14022     ::apache::thrift::TApplicationException x(e.what());
14023     oprot->writeMessageBegin("getRegionInfo", ::apache::thrift::protocol::T_EXCEPTION, seqid);
14024     x.write(oprot);
14025     oprot->writeMessageEnd();
14026     oprot->getTransport()->writeEnd();
14027     oprot->getTransport()->flush();
14028     return;
14029   }
14030 
14031   if (eventHandler_.get() != NULL) {
14032     eventHandler_->preWrite(ctx, "Hbase.getRegionInfo");
14033   }
14034 
14035   oprot->writeMessageBegin("getRegionInfo", ::apache::thrift::protocol::T_REPLY, seqid);
14036   result.write(oprot);
14037   oprot->writeMessageEnd();
14038   bytes = oprot->getTransport()->writeEnd();
14039   oprot->getTransport()->flush();
14040 
14041   if (eventHandler_.get() != NULL) {
14042     eventHandler_->postWrite(ctx, "Hbase.getRegionInfo", bytes);
14043   }
14044 }
14045 
14046 }}}} // namespace
14047 


megatree_storage
Author(s): Wim Meeussen
autogenerated on Mon Dec 2 2013 13:01:19