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
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
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
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
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
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 = ×tamp;
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
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
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
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 = ×tamp;
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
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 = ×tamp;
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
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
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
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 = ×tamp;
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
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 = ×tamp;
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
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 = ×tamp;
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 = ×tamp;
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 = ×tamp;
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 = ×tamp;
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 = ×tamp;
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 = ×tamp;
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
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
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
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
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 }}}}
14047