00001
00006 #include "Hbase_types.h"
00007
00008 namespace apache { namespace hadoop { namespace hbase { namespace thrift {
00009
00010 const char* TCell::ascii_fingerprint = "1CCCF6FC31CFD1D61BBBB1BAF3590620";
00011 const uint8_t TCell::binary_fingerprint[16] = {0x1C,0xCC,0xF6,0xFC,0x31,0xCF,0xD1,0xD6,0x1B,0xBB,0xB1,0xBA,0xF3,0x59,0x06,0x20};
00012
00013 uint32_t TCell::read(::apache::thrift::protocol::TProtocol* iprot) {
00014
00015 uint32_t xfer = 0;
00016 std::string fname;
00017 ::apache::thrift::protocol::TType ftype;
00018 int16_t fid;
00019
00020 xfer += iprot->readStructBegin(fname);
00021
00022 using ::apache::thrift::protocol::TProtocolException;
00023
00024
00025 while (true)
00026 {
00027 xfer += iprot->readFieldBegin(fname, ftype, fid);
00028 if (ftype == ::apache::thrift::protocol::T_STOP) {
00029 break;
00030 }
00031 switch (fid)
00032 {
00033 case 1:
00034 if (ftype == ::apache::thrift::protocol::T_STRING) {
00035 xfer += iprot->readBinary(this->value);
00036 this->__isset.value = true;
00037 } else {
00038 xfer += iprot->skip(ftype);
00039 }
00040 break;
00041 case 2:
00042 if (ftype == ::apache::thrift::protocol::T_I64) {
00043 xfer += iprot->readI64(this->timestamp);
00044 this->__isset.timestamp = true;
00045 } else {
00046 xfer += iprot->skip(ftype);
00047 }
00048 break;
00049 default:
00050 xfer += iprot->skip(ftype);
00051 break;
00052 }
00053 xfer += iprot->readFieldEnd();
00054 }
00055
00056 xfer += iprot->readStructEnd();
00057
00058 return xfer;
00059 }
00060
00061 uint32_t TCell::write(::apache::thrift::protocol::TProtocol* oprot) const {
00062 uint32_t xfer = 0;
00063 xfer += oprot->writeStructBegin("TCell");
00064 xfer += oprot->writeFieldBegin("value", ::apache::thrift::protocol::T_STRING, 1);
00065 xfer += oprot->writeBinary(this->value);
00066 xfer += oprot->writeFieldEnd();
00067 xfer += oprot->writeFieldBegin("timestamp", ::apache::thrift::protocol::T_I64, 2);
00068 xfer += oprot->writeI64(this->timestamp);
00069 xfer += oprot->writeFieldEnd();
00070 xfer += oprot->writeFieldStop();
00071 xfer += oprot->writeStructEnd();
00072 return xfer;
00073 }
00074
00075 const char* ColumnDescriptor::ascii_fingerprint = "3B18638852FDF9DD911BC1174265F92E";
00076 const uint8_t ColumnDescriptor::binary_fingerprint[16] = {0x3B,0x18,0x63,0x88,0x52,0xFD,0xF9,0xDD,0x91,0x1B,0xC1,0x17,0x42,0x65,0xF9,0x2E};
00077
00078 uint32_t ColumnDescriptor::read(::apache::thrift::protocol::TProtocol* iprot) {
00079
00080 uint32_t xfer = 0;
00081 std::string fname;
00082 ::apache::thrift::protocol::TType ftype;
00083 int16_t fid;
00084
00085 xfer += iprot->readStructBegin(fname);
00086
00087 using ::apache::thrift::protocol::TProtocolException;
00088
00089
00090 while (true)
00091 {
00092 xfer += iprot->readFieldBegin(fname, ftype, fid);
00093 if (ftype == ::apache::thrift::protocol::T_STOP) {
00094 break;
00095 }
00096 switch (fid)
00097 {
00098 case 1:
00099 if (ftype == ::apache::thrift::protocol::T_STRING) {
00100 xfer += iprot->readBinary(this->name);
00101 this->__isset.name = true;
00102 } else {
00103 xfer += iprot->skip(ftype);
00104 }
00105 break;
00106 case 2:
00107 if (ftype == ::apache::thrift::protocol::T_I32) {
00108 xfer += iprot->readI32(this->maxVersions);
00109 this->__isset.maxVersions = true;
00110 } else {
00111 xfer += iprot->skip(ftype);
00112 }
00113 break;
00114 case 3:
00115 if (ftype == ::apache::thrift::protocol::T_STRING) {
00116 xfer += iprot->readString(this->compression);
00117 this->__isset.compression = true;
00118 } else {
00119 xfer += iprot->skip(ftype);
00120 }
00121 break;
00122 case 4:
00123 if (ftype == ::apache::thrift::protocol::T_BOOL) {
00124 xfer += iprot->readBool(this->inMemory);
00125 this->__isset.inMemory = true;
00126 } else {
00127 xfer += iprot->skip(ftype);
00128 }
00129 break;
00130 case 5:
00131 if (ftype == ::apache::thrift::protocol::T_STRING) {
00132 xfer += iprot->readString(this->bloomFilterType);
00133 this->__isset.bloomFilterType = true;
00134 } else {
00135 xfer += iprot->skip(ftype);
00136 }
00137 break;
00138 case 6:
00139 if (ftype == ::apache::thrift::protocol::T_I32) {
00140 xfer += iprot->readI32(this->bloomFilterVectorSize);
00141 this->__isset.bloomFilterVectorSize = true;
00142 } else {
00143 xfer += iprot->skip(ftype);
00144 }
00145 break;
00146 case 7:
00147 if (ftype == ::apache::thrift::protocol::T_I32) {
00148 xfer += iprot->readI32(this->bloomFilterNbHashes);
00149 this->__isset.bloomFilterNbHashes = true;
00150 } else {
00151 xfer += iprot->skip(ftype);
00152 }
00153 break;
00154 case 8:
00155 if (ftype == ::apache::thrift::protocol::T_BOOL) {
00156 xfer += iprot->readBool(this->blockCacheEnabled);
00157 this->__isset.blockCacheEnabled = true;
00158 } else {
00159 xfer += iprot->skip(ftype);
00160 }
00161 break;
00162 case 9:
00163 if (ftype == ::apache::thrift::protocol::T_I32) {
00164 xfer += iprot->readI32(this->timeToLive);
00165 this->__isset.timeToLive = true;
00166 } else {
00167 xfer += iprot->skip(ftype);
00168 }
00169 break;
00170 default:
00171 xfer += iprot->skip(ftype);
00172 break;
00173 }
00174 xfer += iprot->readFieldEnd();
00175 }
00176
00177 xfer += iprot->readStructEnd();
00178
00179 return xfer;
00180 }
00181
00182 uint32_t ColumnDescriptor::write(::apache::thrift::protocol::TProtocol* oprot) const {
00183 uint32_t xfer = 0;
00184 xfer += oprot->writeStructBegin("ColumnDescriptor");
00185 xfer += oprot->writeFieldBegin("name", ::apache::thrift::protocol::T_STRING, 1);
00186 xfer += oprot->writeBinary(this->name);
00187 xfer += oprot->writeFieldEnd();
00188 xfer += oprot->writeFieldBegin("maxVersions", ::apache::thrift::protocol::T_I32, 2);
00189 xfer += oprot->writeI32(this->maxVersions);
00190 xfer += oprot->writeFieldEnd();
00191 xfer += oprot->writeFieldBegin("compression", ::apache::thrift::protocol::T_STRING, 3);
00192 xfer += oprot->writeString(this->compression);
00193 xfer += oprot->writeFieldEnd();
00194 xfer += oprot->writeFieldBegin("inMemory", ::apache::thrift::protocol::T_BOOL, 4);
00195 xfer += oprot->writeBool(this->inMemory);
00196 xfer += oprot->writeFieldEnd();
00197 xfer += oprot->writeFieldBegin("bloomFilterType", ::apache::thrift::protocol::T_STRING, 5);
00198 xfer += oprot->writeString(this->bloomFilterType);
00199 xfer += oprot->writeFieldEnd();
00200 xfer += oprot->writeFieldBegin("bloomFilterVectorSize", ::apache::thrift::protocol::T_I32, 6);
00201 xfer += oprot->writeI32(this->bloomFilterVectorSize);
00202 xfer += oprot->writeFieldEnd();
00203 xfer += oprot->writeFieldBegin("bloomFilterNbHashes", ::apache::thrift::protocol::T_I32, 7);
00204 xfer += oprot->writeI32(this->bloomFilterNbHashes);
00205 xfer += oprot->writeFieldEnd();
00206 xfer += oprot->writeFieldBegin("blockCacheEnabled", ::apache::thrift::protocol::T_BOOL, 8);
00207 xfer += oprot->writeBool(this->blockCacheEnabled);
00208 xfer += oprot->writeFieldEnd();
00209 xfer += oprot->writeFieldBegin("timeToLive", ::apache::thrift::protocol::T_I32, 9);
00210 xfer += oprot->writeI32(this->timeToLive);
00211 xfer += oprot->writeFieldEnd();
00212 xfer += oprot->writeFieldStop();
00213 xfer += oprot->writeStructEnd();
00214 return xfer;
00215 }
00216
00217 const char* TRegionInfo::ascii_fingerprint = "B58AB7A239831F8614F7B6709C89DC7B";
00218 const uint8_t TRegionInfo::binary_fingerprint[16] = {0xB5,0x8A,0xB7,0xA2,0x39,0x83,0x1F,0x86,0x14,0xF7,0xB6,0x70,0x9C,0x89,0xDC,0x7B};
00219
00220 uint32_t TRegionInfo::read(::apache::thrift::protocol::TProtocol* iprot) {
00221
00222 uint32_t xfer = 0;
00223 std::string fname;
00224 ::apache::thrift::protocol::TType ftype;
00225 int16_t fid;
00226
00227 xfer += iprot->readStructBegin(fname);
00228
00229 using ::apache::thrift::protocol::TProtocolException;
00230
00231
00232 while (true)
00233 {
00234 xfer += iprot->readFieldBegin(fname, ftype, fid);
00235 if (ftype == ::apache::thrift::protocol::T_STOP) {
00236 break;
00237 }
00238 switch (fid)
00239 {
00240 case 1:
00241 if (ftype == ::apache::thrift::protocol::T_STRING) {
00242 xfer += iprot->readBinary(this->startKey);
00243 this->__isset.startKey = true;
00244 } else {
00245 xfer += iprot->skip(ftype);
00246 }
00247 break;
00248 case 2:
00249 if (ftype == ::apache::thrift::protocol::T_STRING) {
00250 xfer += iprot->readBinary(this->endKey);
00251 this->__isset.endKey = true;
00252 } else {
00253 xfer += iprot->skip(ftype);
00254 }
00255 break;
00256 case 3:
00257 if (ftype == ::apache::thrift::protocol::T_I64) {
00258 xfer += iprot->readI64(this->id);
00259 this->__isset.id = true;
00260 } else {
00261 xfer += iprot->skip(ftype);
00262 }
00263 break;
00264 case 4:
00265 if (ftype == ::apache::thrift::protocol::T_STRING) {
00266 xfer += iprot->readBinary(this->name);
00267 this->__isset.name = true;
00268 } else {
00269 xfer += iprot->skip(ftype);
00270 }
00271 break;
00272 case 5:
00273 if (ftype == ::apache::thrift::protocol::T_BYTE) {
00274 xfer += iprot->readByte(this->version);
00275 this->__isset.version = true;
00276 } else {
00277 xfer += iprot->skip(ftype);
00278 }
00279 break;
00280 case 6:
00281 if (ftype == ::apache::thrift::protocol::T_STRING) {
00282 xfer += iprot->readBinary(this->serverName);
00283 this->__isset.serverName = true;
00284 } else {
00285 xfer += iprot->skip(ftype);
00286 }
00287 break;
00288 case 7:
00289 if (ftype == ::apache::thrift::protocol::T_I32) {
00290 xfer += iprot->readI32(this->port);
00291 this->__isset.port = true;
00292 } else {
00293 xfer += iprot->skip(ftype);
00294 }
00295 break;
00296 default:
00297 xfer += iprot->skip(ftype);
00298 break;
00299 }
00300 xfer += iprot->readFieldEnd();
00301 }
00302
00303 xfer += iprot->readStructEnd();
00304
00305 return xfer;
00306 }
00307
00308 uint32_t TRegionInfo::write(::apache::thrift::protocol::TProtocol* oprot) const {
00309 uint32_t xfer = 0;
00310 xfer += oprot->writeStructBegin("TRegionInfo");
00311 xfer += oprot->writeFieldBegin("startKey", ::apache::thrift::protocol::T_STRING, 1);
00312 xfer += oprot->writeBinary(this->startKey);
00313 xfer += oprot->writeFieldEnd();
00314 xfer += oprot->writeFieldBegin("endKey", ::apache::thrift::protocol::T_STRING, 2);
00315 xfer += oprot->writeBinary(this->endKey);
00316 xfer += oprot->writeFieldEnd();
00317 xfer += oprot->writeFieldBegin("id", ::apache::thrift::protocol::T_I64, 3);
00318 xfer += oprot->writeI64(this->id);
00319 xfer += oprot->writeFieldEnd();
00320 xfer += oprot->writeFieldBegin("name", ::apache::thrift::protocol::T_STRING, 4);
00321 xfer += oprot->writeBinary(this->name);
00322 xfer += oprot->writeFieldEnd();
00323 xfer += oprot->writeFieldBegin("version", ::apache::thrift::protocol::T_BYTE, 5);
00324 xfer += oprot->writeByte(this->version);
00325 xfer += oprot->writeFieldEnd();
00326 xfer += oprot->writeFieldBegin("serverName", ::apache::thrift::protocol::T_STRING, 6);
00327 xfer += oprot->writeBinary(this->serverName);
00328 xfer += oprot->writeFieldEnd();
00329 xfer += oprot->writeFieldBegin("port", ::apache::thrift::protocol::T_I32, 7);
00330 xfer += oprot->writeI32(this->port);
00331 xfer += oprot->writeFieldEnd();
00332 xfer += oprot->writeFieldStop();
00333 xfer += oprot->writeStructEnd();
00334 return xfer;
00335 }
00336
00337 const char* Mutation::ascii_fingerprint = "DC8F62AF23854A1A6849A2A157CCCA65";
00338 const uint8_t Mutation::binary_fingerprint[16] = {0xDC,0x8F,0x62,0xAF,0x23,0x85,0x4A,0x1A,0x68,0x49,0xA2,0xA1,0x57,0xCC,0xCA,0x65};
00339
00340 uint32_t Mutation::read(::apache::thrift::protocol::TProtocol* iprot) {
00341
00342 uint32_t xfer = 0;
00343 std::string fname;
00344 ::apache::thrift::protocol::TType ftype;
00345 int16_t fid;
00346
00347 xfer += iprot->readStructBegin(fname);
00348
00349 using ::apache::thrift::protocol::TProtocolException;
00350
00351
00352 while (true)
00353 {
00354 xfer += iprot->readFieldBegin(fname, ftype, fid);
00355 if (ftype == ::apache::thrift::protocol::T_STOP) {
00356 break;
00357 }
00358 switch (fid)
00359 {
00360 case 1:
00361 if (ftype == ::apache::thrift::protocol::T_BOOL) {
00362 xfer += iprot->readBool(this->isDelete);
00363 this->__isset.isDelete = true;
00364 } else {
00365 xfer += iprot->skip(ftype);
00366 }
00367 break;
00368 case 2:
00369 if (ftype == ::apache::thrift::protocol::T_STRING) {
00370 xfer += iprot->readBinary(this->column);
00371 this->__isset.column = true;
00372 } else {
00373 xfer += iprot->skip(ftype);
00374 }
00375 break;
00376 case 3:
00377 if (ftype == ::apache::thrift::protocol::T_STRING) {
00378 xfer += iprot->readBinary(this->value);
00379 this->__isset.value = true;
00380 } else {
00381 xfer += iprot->skip(ftype);
00382 }
00383 break;
00384 default:
00385 xfer += iprot->skip(ftype);
00386 break;
00387 }
00388 xfer += iprot->readFieldEnd();
00389 }
00390
00391 xfer += iprot->readStructEnd();
00392
00393 return xfer;
00394 }
00395
00396 uint32_t Mutation::write(::apache::thrift::protocol::TProtocol* oprot) const {
00397 uint32_t xfer = 0;
00398 xfer += oprot->writeStructBegin("Mutation");
00399 xfer += oprot->writeFieldBegin("isDelete", ::apache::thrift::protocol::T_BOOL, 1);
00400 xfer += oprot->writeBool(this->isDelete);
00401 xfer += oprot->writeFieldEnd();
00402 xfer += oprot->writeFieldBegin("column", ::apache::thrift::protocol::T_STRING, 2);
00403 xfer += oprot->writeBinary(this->column);
00404 xfer += oprot->writeFieldEnd();
00405 xfer += oprot->writeFieldBegin("value", ::apache::thrift::protocol::T_STRING, 3);
00406 xfer += oprot->writeBinary(this->value);
00407 xfer += oprot->writeFieldEnd();
00408 xfer += oprot->writeFieldStop();
00409 xfer += oprot->writeStructEnd();
00410 return xfer;
00411 }
00412
00413 const char* BatchMutation::ascii_fingerprint = "7849EEBF8BB50169F3D2F0DD635BD8ED";
00414 const uint8_t BatchMutation::binary_fingerprint[16] = {0x78,0x49,0xEE,0xBF,0x8B,0xB5,0x01,0x69,0xF3,0xD2,0xF0,0xDD,0x63,0x5B,0xD8,0xED};
00415
00416 uint32_t BatchMutation::read(::apache::thrift::protocol::TProtocol* iprot) {
00417
00418 uint32_t xfer = 0;
00419 std::string fname;
00420 ::apache::thrift::protocol::TType ftype;
00421 int16_t fid;
00422
00423 xfer += iprot->readStructBegin(fname);
00424
00425 using ::apache::thrift::protocol::TProtocolException;
00426
00427
00428 while (true)
00429 {
00430 xfer += iprot->readFieldBegin(fname, ftype, fid);
00431 if (ftype == ::apache::thrift::protocol::T_STOP) {
00432 break;
00433 }
00434 switch (fid)
00435 {
00436 case 1:
00437 if (ftype == ::apache::thrift::protocol::T_STRING) {
00438 xfer += iprot->readBinary(this->row);
00439 this->__isset.row = true;
00440 } else {
00441 xfer += iprot->skip(ftype);
00442 }
00443 break;
00444 case 2:
00445 if (ftype == ::apache::thrift::protocol::T_LIST) {
00446 {
00447 this->mutations.clear();
00448 uint32_t _size0;
00449 ::apache::thrift::protocol::TType _etype3;
00450 iprot->readListBegin(_etype3, _size0);
00451 this->mutations.resize(_size0);
00452 uint32_t _i4;
00453 for (_i4 = 0; _i4 < _size0; ++_i4)
00454 {
00455 xfer += this->mutations[_i4].read(iprot);
00456 }
00457 iprot->readListEnd();
00458 }
00459 this->__isset.mutations = true;
00460 } else {
00461 xfer += iprot->skip(ftype);
00462 }
00463 break;
00464 default:
00465 xfer += iprot->skip(ftype);
00466 break;
00467 }
00468 xfer += iprot->readFieldEnd();
00469 }
00470
00471 xfer += iprot->readStructEnd();
00472
00473 return xfer;
00474 }
00475
00476 uint32_t BatchMutation::write(::apache::thrift::protocol::TProtocol* oprot) const {
00477 uint32_t xfer = 0;
00478 xfer += oprot->writeStructBegin("BatchMutation");
00479 xfer += oprot->writeFieldBegin("row", ::apache::thrift::protocol::T_STRING, 1);
00480 xfer += oprot->writeBinary(this->row);
00481 xfer += oprot->writeFieldEnd();
00482 xfer += oprot->writeFieldBegin("mutations", ::apache::thrift::protocol::T_LIST, 2);
00483 {
00484 xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->mutations.size()));
00485 std::vector<Mutation> ::const_iterator _iter5;
00486 for (_iter5 = this->mutations.begin(); _iter5 != this->mutations.end(); ++_iter5)
00487 {
00488 xfer += (*_iter5).write(oprot);
00489 }
00490 xfer += oprot->writeListEnd();
00491 }
00492 xfer += oprot->writeFieldEnd();
00493 xfer += oprot->writeFieldStop();
00494 xfer += oprot->writeStructEnd();
00495 return xfer;
00496 }
00497
00498 const char* TRowResult::ascii_fingerprint = "AE98EA4F344566FAFE04FA5E5823D1ED";
00499 const uint8_t TRowResult::binary_fingerprint[16] = {0xAE,0x98,0xEA,0x4F,0x34,0x45,0x66,0xFA,0xFE,0x04,0xFA,0x5E,0x58,0x23,0xD1,0xED};
00500
00501 uint32_t TRowResult::read(::apache::thrift::protocol::TProtocol* iprot) {
00502
00503 uint32_t xfer = 0;
00504 std::string fname;
00505 ::apache::thrift::protocol::TType ftype;
00506 int16_t fid;
00507
00508 xfer += iprot->readStructBegin(fname);
00509
00510 using ::apache::thrift::protocol::TProtocolException;
00511
00512
00513 while (true)
00514 {
00515 xfer += iprot->readFieldBegin(fname, ftype, fid);
00516 if (ftype == ::apache::thrift::protocol::T_STOP) {
00517 break;
00518 }
00519 switch (fid)
00520 {
00521 case 1:
00522 if (ftype == ::apache::thrift::protocol::T_STRING) {
00523 xfer += iprot->readBinary(this->row);
00524 this->__isset.row = true;
00525 } else {
00526 xfer += iprot->skip(ftype);
00527 }
00528 break;
00529 case 2:
00530 if (ftype == ::apache::thrift::protocol::T_MAP) {
00531 {
00532 this->columns.clear();
00533 uint32_t _size6;
00534 ::apache::thrift::protocol::TType _ktype7;
00535 ::apache::thrift::protocol::TType _vtype8;
00536 iprot->readMapBegin(_ktype7, _vtype8, _size6);
00537 uint32_t _i10;
00538 for (_i10 = 0; _i10 < _size6; ++_i10)
00539 {
00540 Text _key11;
00541 xfer += iprot->readBinary(_key11);
00542 TCell& _val12 = this->columns[_key11];
00543 xfer += _val12.read(iprot);
00544 }
00545 iprot->readMapEnd();
00546 }
00547 this->__isset.columns = true;
00548 } else {
00549 xfer += iprot->skip(ftype);
00550 }
00551 break;
00552 default:
00553 xfer += iprot->skip(ftype);
00554 break;
00555 }
00556 xfer += iprot->readFieldEnd();
00557 }
00558
00559 xfer += iprot->readStructEnd();
00560
00561 return xfer;
00562 }
00563
00564 uint32_t TRowResult::write(::apache::thrift::protocol::TProtocol* oprot) const {
00565 uint32_t xfer = 0;
00566 xfer += oprot->writeStructBegin("TRowResult");
00567 xfer += oprot->writeFieldBegin("row", ::apache::thrift::protocol::T_STRING, 1);
00568 xfer += oprot->writeBinary(this->row);
00569 xfer += oprot->writeFieldEnd();
00570 xfer += oprot->writeFieldBegin("columns", ::apache::thrift::protocol::T_MAP, 2);
00571 {
00572 xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->columns.size()));
00573 std::map<Text, TCell> ::const_iterator _iter13;
00574 for (_iter13 = this->columns.begin(); _iter13 != this->columns.end(); ++_iter13)
00575 {
00576 xfer += oprot->writeBinary(_iter13->first);
00577 xfer += _iter13->second.write(oprot);
00578 }
00579 xfer += oprot->writeMapEnd();
00580 }
00581 xfer += oprot->writeFieldEnd();
00582 xfer += oprot->writeFieldStop();
00583 xfer += oprot->writeStructEnd();
00584 return xfer;
00585 }
00586
00587 const char* TScan::ascii_fingerprint = "2C111FDF8CD162886ECCCBB9C9051083";
00588 const uint8_t TScan::binary_fingerprint[16] = {0x2C,0x11,0x1F,0xDF,0x8C,0xD1,0x62,0x88,0x6E,0xCC,0xCB,0xB9,0xC9,0x05,0x10,0x83};
00589
00590 uint32_t TScan::read(::apache::thrift::protocol::TProtocol* iprot) {
00591
00592 uint32_t xfer = 0;
00593 std::string fname;
00594 ::apache::thrift::protocol::TType ftype;
00595 int16_t fid;
00596
00597 xfer += iprot->readStructBegin(fname);
00598
00599 using ::apache::thrift::protocol::TProtocolException;
00600
00601
00602 while (true)
00603 {
00604 xfer += iprot->readFieldBegin(fname, ftype, fid);
00605 if (ftype == ::apache::thrift::protocol::T_STOP) {
00606 break;
00607 }
00608 switch (fid)
00609 {
00610 case 1:
00611 if (ftype == ::apache::thrift::protocol::T_STRING) {
00612 xfer += iprot->readBinary(this->startRow);
00613 this->__isset.startRow = true;
00614 } else {
00615 xfer += iprot->skip(ftype);
00616 }
00617 break;
00618 case 2:
00619 if (ftype == ::apache::thrift::protocol::T_STRING) {
00620 xfer += iprot->readBinary(this->stopRow);
00621 this->__isset.stopRow = true;
00622 } else {
00623 xfer += iprot->skip(ftype);
00624 }
00625 break;
00626 case 3:
00627 if (ftype == ::apache::thrift::protocol::T_I64) {
00628 xfer += iprot->readI64(this->timestamp);
00629 this->__isset.timestamp = true;
00630 } else {
00631 xfer += iprot->skip(ftype);
00632 }
00633 break;
00634 case 4:
00635 if (ftype == ::apache::thrift::protocol::T_LIST) {
00636 {
00637 this->columns.clear();
00638 uint32_t _size14;
00639 ::apache::thrift::protocol::TType _etype17;
00640 iprot->readListBegin(_etype17, _size14);
00641 this->columns.resize(_size14);
00642 uint32_t _i18;
00643 for (_i18 = 0; _i18 < _size14; ++_i18)
00644 {
00645 xfer += iprot->readBinary(this->columns[_i18]);
00646 }
00647 iprot->readListEnd();
00648 }
00649 this->__isset.columns = true;
00650 } else {
00651 xfer += iprot->skip(ftype);
00652 }
00653 break;
00654 case 5:
00655 if (ftype == ::apache::thrift::protocol::T_I32) {
00656 xfer += iprot->readI32(this->caching);
00657 this->__isset.caching = true;
00658 } else {
00659 xfer += iprot->skip(ftype);
00660 }
00661 break;
00662 case 6:
00663 if (ftype == ::apache::thrift::protocol::T_STRING) {
00664 xfer += iprot->readBinary(this->filterString);
00665 this->__isset.filterString = true;
00666 } else {
00667 xfer += iprot->skip(ftype);
00668 }
00669 break;
00670 default:
00671 xfer += iprot->skip(ftype);
00672 break;
00673 }
00674 xfer += iprot->readFieldEnd();
00675 }
00676
00677 xfer += iprot->readStructEnd();
00678
00679 return xfer;
00680 }
00681
00682 uint32_t TScan::write(::apache::thrift::protocol::TProtocol* oprot) const {
00683 uint32_t xfer = 0;
00684 xfer += oprot->writeStructBegin("TScan");
00685 if (this->__isset.startRow) {
00686 xfer += oprot->writeFieldBegin("startRow", ::apache::thrift::protocol::T_STRING, 1);
00687 xfer += oprot->writeBinary(this->startRow);
00688 xfer += oprot->writeFieldEnd();
00689 }
00690 if (this->__isset.stopRow) {
00691 xfer += oprot->writeFieldBegin("stopRow", ::apache::thrift::protocol::T_STRING, 2);
00692 xfer += oprot->writeBinary(this->stopRow);
00693 xfer += oprot->writeFieldEnd();
00694 }
00695 if (this->__isset.timestamp) {
00696 xfer += oprot->writeFieldBegin("timestamp", ::apache::thrift::protocol::T_I64, 3);
00697 xfer += oprot->writeI64(this->timestamp);
00698 xfer += oprot->writeFieldEnd();
00699 }
00700 if (this->__isset.columns) {
00701 xfer += oprot->writeFieldBegin("columns", ::apache::thrift::protocol::T_LIST, 4);
00702 {
00703 xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->columns.size()));
00704 std::vector<Text> ::const_iterator _iter19;
00705 for (_iter19 = this->columns.begin(); _iter19 != this->columns.end(); ++_iter19)
00706 {
00707 xfer += oprot->writeBinary((*_iter19));
00708 }
00709 xfer += oprot->writeListEnd();
00710 }
00711 xfer += oprot->writeFieldEnd();
00712 }
00713 if (this->__isset.caching) {
00714 xfer += oprot->writeFieldBegin("caching", ::apache::thrift::protocol::T_I32, 5);
00715 xfer += oprot->writeI32(this->caching);
00716 xfer += oprot->writeFieldEnd();
00717 }
00718 if (this->__isset.filterString) {
00719 xfer += oprot->writeFieldBegin("filterString", ::apache::thrift::protocol::T_STRING, 6);
00720 xfer += oprot->writeBinary(this->filterString);
00721 xfer += oprot->writeFieldEnd();
00722 }
00723 xfer += oprot->writeFieldStop();
00724 xfer += oprot->writeStructEnd();
00725 return xfer;
00726 }
00727
00728 const char* IOError::ascii_fingerprint = "EFB929595D312AC8F305D5A794CFEDA1";
00729 const uint8_t IOError::binary_fingerprint[16] = {0xEF,0xB9,0x29,0x59,0x5D,0x31,0x2A,0xC8,0xF3,0x05,0xD5,0xA7,0x94,0xCF,0xED,0xA1};
00730
00731 uint32_t IOError::read(::apache::thrift::protocol::TProtocol* iprot) {
00732
00733 uint32_t xfer = 0;
00734 std::string fname;
00735 ::apache::thrift::protocol::TType ftype;
00736 int16_t fid;
00737
00738 xfer += iprot->readStructBegin(fname);
00739
00740 using ::apache::thrift::protocol::TProtocolException;
00741
00742
00743 while (true)
00744 {
00745 xfer += iprot->readFieldBegin(fname, ftype, fid);
00746 if (ftype == ::apache::thrift::protocol::T_STOP) {
00747 break;
00748 }
00749 switch (fid)
00750 {
00751 case 1:
00752 if (ftype == ::apache::thrift::protocol::T_STRING) {
00753 xfer += iprot->readString(this->message);
00754 this->__isset.message = true;
00755 } else {
00756 xfer += iprot->skip(ftype);
00757 }
00758 break;
00759 default:
00760 xfer += iprot->skip(ftype);
00761 break;
00762 }
00763 xfer += iprot->readFieldEnd();
00764 }
00765
00766 xfer += iprot->readStructEnd();
00767
00768 return xfer;
00769 }
00770
00771 uint32_t IOError::write(::apache::thrift::protocol::TProtocol* oprot) const {
00772 uint32_t xfer = 0;
00773 xfer += oprot->writeStructBegin("IOError");
00774 xfer += oprot->writeFieldBegin("message", ::apache::thrift::protocol::T_STRING, 1);
00775 xfer += oprot->writeString(this->message);
00776 xfer += oprot->writeFieldEnd();
00777 xfer += oprot->writeFieldStop();
00778 xfer += oprot->writeStructEnd();
00779 return xfer;
00780 }
00781
00782 const char* IllegalArgument::ascii_fingerprint = "EFB929595D312AC8F305D5A794CFEDA1";
00783 const uint8_t IllegalArgument::binary_fingerprint[16] = {0xEF,0xB9,0x29,0x59,0x5D,0x31,0x2A,0xC8,0xF3,0x05,0xD5,0xA7,0x94,0xCF,0xED,0xA1};
00784
00785 uint32_t IllegalArgument::read(::apache::thrift::protocol::TProtocol* iprot) {
00786
00787 uint32_t xfer = 0;
00788 std::string fname;
00789 ::apache::thrift::protocol::TType ftype;
00790 int16_t fid;
00791
00792 xfer += iprot->readStructBegin(fname);
00793
00794 using ::apache::thrift::protocol::TProtocolException;
00795
00796
00797 while (true)
00798 {
00799 xfer += iprot->readFieldBegin(fname, ftype, fid);
00800 if (ftype == ::apache::thrift::protocol::T_STOP) {
00801 break;
00802 }
00803 switch (fid)
00804 {
00805 case 1:
00806 if (ftype == ::apache::thrift::protocol::T_STRING) {
00807 xfer += iprot->readString(this->message);
00808 this->__isset.message = true;
00809 } else {
00810 xfer += iprot->skip(ftype);
00811 }
00812 break;
00813 default:
00814 xfer += iprot->skip(ftype);
00815 break;
00816 }
00817 xfer += iprot->readFieldEnd();
00818 }
00819
00820 xfer += iprot->readStructEnd();
00821
00822 return xfer;
00823 }
00824
00825 uint32_t IllegalArgument::write(::apache::thrift::protocol::TProtocol* oprot) const {
00826 uint32_t xfer = 0;
00827 xfer += oprot->writeStructBegin("IllegalArgument");
00828 xfer += oprot->writeFieldBegin("message", ::apache::thrift::protocol::T_STRING, 1);
00829 xfer += oprot->writeString(this->message);
00830 xfer += oprot->writeFieldEnd();
00831 xfer += oprot->writeFieldStop();
00832 xfer += oprot->writeStructEnd();
00833 return xfer;
00834 }
00835
00836 const char* AlreadyExists::ascii_fingerprint = "EFB929595D312AC8F305D5A794CFEDA1";
00837 const uint8_t AlreadyExists::binary_fingerprint[16] = {0xEF,0xB9,0x29,0x59,0x5D,0x31,0x2A,0xC8,0xF3,0x05,0xD5,0xA7,0x94,0xCF,0xED,0xA1};
00838
00839 uint32_t AlreadyExists::read(::apache::thrift::protocol::TProtocol* iprot) {
00840
00841 uint32_t xfer = 0;
00842 std::string fname;
00843 ::apache::thrift::protocol::TType ftype;
00844 int16_t fid;
00845
00846 xfer += iprot->readStructBegin(fname);
00847
00848 using ::apache::thrift::protocol::TProtocolException;
00849
00850
00851 while (true)
00852 {
00853 xfer += iprot->readFieldBegin(fname, ftype, fid);
00854 if (ftype == ::apache::thrift::protocol::T_STOP) {
00855 break;
00856 }
00857 switch (fid)
00858 {
00859 case 1:
00860 if (ftype == ::apache::thrift::protocol::T_STRING) {
00861 xfer += iprot->readString(this->message);
00862 this->__isset.message = true;
00863 } else {
00864 xfer += iprot->skip(ftype);
00865 }
00866 break;
00867 default:
00868 xfer += iprot->skip(ftype);
00869 break;
00870 }
00871 xfer += iprot->readFieldEnd();
00872 }
00873
00874 xfer += iprot->readStructEnd();
00875
00876 return xfer;
00877 }
00878
00879 uint32_t AlreadyExists::write(::apache::thrift::protocol::TProtocol* oprot) const {
00880 uint32_t xfer = 0;
00881 xfer += oprot->writeStructBegin("AlreadyExists");
00882 xfer += oprot->writeFieldBegin("message", ::apache::thrift::protocol::T_STRING, 1);
00883 xfer += oprot->writeString(this->message);
00884 xfer += oprot->writeFieldEnd();
00885 xfer += oprot->writeFieldStop();
00886 xfer += oprot->writeStructEnd();
00887 return xfer;
00888 }
00889
00890 }}}}