00001
00006 #include "Cassandra.h"
00007
00008 namespace org { namespace apache { namespace cassandra {
00009
00010 uint32_t Cassandra_login_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 bool isset_auth_request = false;
00022
00023 while (true)
00024 {
00025 xfer += iprot->readFieldBegin(fname, ftype, fid);
00026 if (ftype == ::apache::thrift::protocol::T_STOP) {
00027 break;
00028 }
00029 switch (fid)
00030 {
00031 case 1:
00032 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
00033 xfer += this->auth_request.read(iprot);
00034 isset_auth_request = true;
00035 } else {
00036 xfer += iprot->skip(ftype);
00037 }
00038 break;
00039 default:
00040 xfer += iprot->skip(ftype);
00041 break;
00042 }
00043 xfer += iprot->readFieldEnd();
00044 }
00045
00046 xfer += iprot->readStructEnd();
00047
00048 if (!isset_auth_request)
00049 throw TProtocolException(TProtocolException::INVALID_DATA);
00050 return xfer;
00051 }
00052
00053 uint32_t Cassandra_login_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
00054 uint32_t xfer = 0;
00055 xfer += oprot->writeStructBegin("Cassandra_login_args");
00056 xfer += oprot->writeFieldBegin("auth_request", ::apache::thrift::protocol::T_STRUCT, 1);
00057 xfer += this->auth_request.write(oprot);
00058 xfer += oprot->writeFieldEnd();
00059 xfer += oprot->writeFieldStop();
00060 xfer += oprot->writeStructEnd();
00061 return xfer;
00062 }
00063
00064 uint32_t Cassandra_login_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
00065 uint32_t xfer = 0;
00066 xfer += oprot->writeStructBegin("Cassandra_login_pargs");
00067 xfer += oprot->writeFieldBegin("auth_request", ::apache::thrift::protocol::T_STRUCT, 1);
00068 xfer += (*(this->auth_request)).write(oprot);
00069 xfer += oprot->writeFieldEnd();
00070 xfer += oprot->writeFieldStop();
00071 xfer += oprot->writeStructEnd();
00072 return xfer;
00073 }
00074
00075 uint32_t Cassandra_login_result::read(::apache::thrift::protocol::TProtocol* iprot) {
00076
00077 uint32_t xfer = 0;
00078 std::string fname;
00079 ::apache::thrift::protocol::TType ftype;
00080 int16_t fid;
00081
00082 xfer += iprot->readStructBegin(fname);
00083
00084 using ::apache::thrift::protocol::TProtocolException;
00085
00086
00087 while (true)
00088 {
00089 xfer += iprot->readFieldBegin(fname, ftype, fid);
00090 if (ftype == ::apache::thrift::protocol::T_STOP) {
00091 break;
00092 }
00093 switch (fid)
00094 {
00095 case 1:
00096 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
00097 xfer += this->authnx.read(iprot);
00098 this->__isset.authnx = true;
00099 } else {
00100 xfer += iprot->skip(ftype);
00101 }
00102 break;
00103 case 2:
00104 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
00105 xfer += this->authzx.read(iprot);
00106 this->__isset.authzx = true;
00107 } else {
00108 xfer += iprot->skip(ftype);
00109 }
00110 break;
00111 default:
00112 xfer += iprot->skip(ftype);
00113 break;
00114 }
00115 xfer += iprot->readFieldEnd();
00116 }
00117
00118 xfer += iprot->readStructEnd();
00119
00120 return xfer;
00121 }
00122
00123 uint32_t Cassandra_login_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
00124
00125 uint32_t xfer = 0;
00126
00127 xfer += oprot->writeStructBegin("Cassandra_login_result");
00128
00129 if (this->__isset.authnx) {
00130 xfer += oprot->writeFieldBegin("authnx", ::apache::thrift::protocol::T_STRUCT, 1);
00131 xfer += this->authnx.write(oprot);
00132 xfer += oprot->writeFieldEnd();
00133 } else if (this->__isset.authzx) {
00134 xfer += oprot->writeFieldBegin("authzx", ::apache::thrift::protocol::T_STRUCT, 2);
00135 xfer += this->authzx.write(oprot);
00136 xfer += oprot->writeFieldEnd();
00137 }
00138 xfer += oprot->writeFieldStop();
00139 xfer += oprot->writeStructEnd();
00140 return xfer;
00141 }
00142
00143 uint32_t Cassandra_login_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
00144
00145 uint32_t xfer = 0;
00146 std::string fname;
00147 ::apache::thrift::protocol::TType ftype;
00148 int16_t fid;
00149
00150 xfer += iprot->readStructBegin(fname);
00151
00152 using ::apache::thrift::protocol::TProtocolException;
00153
00154
00155 while (true)
00156 {
00157 xfer += iprot->readFieldBegin(fname, ftype, fid);
00158 if (ftype == ::apache::thrift::protocol::T_STOP) {
00159 break;
00160 }
00161 switch (fid)
00162 {
00163 case 1:
00164 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
00165 xfer += this->authnx.read(iprot);
00166 this->__isset.authnx = true;
00167 } else {
00168 xfer += iprot->skip(ftype);
00169 }
00170 break;
00171 case 2:
00172 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
00173 xfer += this->authzx.read(iprot);
00174 this->__isset.authzx = true;
00175 } else {
00176 xfer += iprot->skip(ftype);
00177 }
00178 break;
00179 default:
00180 xfer += iprot->skip(ftype);
00181 break;
00182 }
00183 xfer += iprot->readFieldEnd();
00184 }
00185
00186 xfer += iprot->readStructEnd();
00187
00188 return xfer;
00189 }
00190
00191 uint32_t Cassandra_set_keyspace_args::read(::apache::thrift::protocol::TProtocol* iprot) {
00192
00193 uint32_t xfer = 0;
00194 std::string fname;
00195 ::apache::thrift::protocol::TType ftype;
00196 int16_t fid;
00197
00198 xfer += iprot->readStructBegin(fname);
00199
00200 using ::apache::thrift::protocol::TProtocolException;
00201
00202 bool isset_keyspace = false;
00203
00204 while (true)
00205 {
00206 xfer += iprot->readFieldBegin(fname, ftype, fid);
00207 if (ftype == ::apache::thrift::protocol::T_STOP) {
00208 break;
00209 }
00210 switch (fid)
00211 {
00212 case 1:
00213 if (ftype == ::apache::thrift::protocol::T_STRING) {
00214 xfer += iprot->readString(this->keyspace);
00215 isset_keyspace = true;
00216 } else {
00217 xfer += iprot->skip(ftype);
00218 }
00219 break;
00220 default:
00221 xfer += iprot->skip(ftype);
00222 break;
00223 }
00224 xfer += iprot->readFieldEnd();
00225 }
00226
00227 xfer += iprot->readStructEnd();
00228
00229 if (!isset_keyspace)
00230 throw TProtocolException(TProtocolException::INVALID_DATA);
00231 return xfer;
00232 }
00233
00234 uint32_t Cassandra_set_keyspace_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
00235 uint32_t xfer = 0;
00236 xfer += oprot->writeStructBegin("Cassandra_set_keyspace_args");
00237 xfer += oprot->writeFieldBegin("keyspace", ::apache::thrift::protocol::T_STRING, 1);
00238 xfer += oprot->writeString(this->keyspace);
00239 xfer += oprot->writeFieldEnd();
00240 xfer += oprot->writeFieldStop();
00241 xfer += oprot->writeStructEnd();
00242 return xfer;
00243 }
00244
00245 uint32_t Cassandra_set_keyspace_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
00246 uint32_t xfer = 0;
00247 xfer += oprot->writeStructBegin("Cassandra_set_keyspace_pargs");
00248 xfer += oprot->writeFieldBegin("keyspace", ::apache::thrift::protocol::T_STRING, 1);
00249 xfer += oprot->writeString((*(this->keyspace)));
00250 xfer += oprot->writeFieldEnd();
00251 xfer += oprot->writeFieldStop();
00252 xfer += oprot->writeStructEnd();
00253 return xfer;
00254 }
00255
00256 uint32_t Cassandra_set_keyspace_result::read(::apache::thrift::protocol::TProtocol* iprot) {
00257
00258 uint32_t xfer = 0;
00259 std::string fname;
00260 ::apache::thrift::protocol::TType ftype;
00261 int16_t fid;
00262
00263 xfer += iprot->readStructBegin(fname);
00264
00265 using ::apache::thrift::protocol::TProtocolException;
00266
00267
00268 while (true)
00269 {
00270 xfer += iprot->readFieldBegin(fname, ftype, fid);
00271 if (ftype == ::apache::thrift::protocol::T_STOP) {
00272 break;
00273 }
00274 switch (fid)
00275 {
00276 case 1:
00277 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
00278 xfer += this->ire.read(iprot);
00279 this->__isset.ire = true;
00280 } else {
00281 xfer += iprot->skip(ftype);
00282 }
00283 break;
00284 default:
00285 xfer += iprot->skip(ftype);
00286 break;
00287 }
00288 xfer += iprot->readFieldEnd();
00289 }
00290
00291 xfer += iprot->readStructEnd();
00292
00293 return xfer;
00294 }
00295
00296 uint32_t Cassandra_set_keyspace_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
00297
00298 uint32_t xfer = 0;
00299
00300 xfer += oprot->writeStructBegin("Cassandra_set_keyspace_result");
00301
00302 if (this->__isset.ire) {
00303 xfer += oprot->writeFieldBegin("ire", ::apache::thrift::protocol::T_STRUCT, 1);
00304 xfer += this->ire.write(oprot);
00305 xfer += oprot->writeFieldEnd();
00306 }
00307 xfer += oprot->writeFieldStop();
00308 xfer += oprot->writeStructEnd();
00309 return xfer;
00310 }
00311
00312 uint32_t Cassandra_set_keyspace_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
00313
00314 uint32_t xfer = 0;
00315 std::string fname;
00316 ::apache::thrift::protocol::TType ftype;
00317 int16_t fid;
00318
00319 xfer += iprot->readStructBegin(fname);
00320
00321 using ::apache::thrift::protocol::TProtocolException;
00322
00323
00324 while (true)
00325 {
00326 xfer += iprot->readFieldBegin(fname, ftype, fid);
00327 if (ftype == ::apache::thrift::protocol::T_STOP) {
00328 break;
00329 }
00330 switch (fid)
00331 {
00332 case 1:
00333 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
00334 xfer += this->ire.read(iprot);
00335 this->__isset.ire = true;
00336 } else {
00337 xfer += iprot->skip(ftype);
00338 }
00339 break;
00340 default:
00341 xfer += iprot->skip(ftype);
00342 break;
00343 }
00344 xfer += iprot->readFieldEnd();
00345 }
00346
00347 xfer += iprot->readStructEnd();
00348
00349 return xfer;
00350 }
00351
00352 uint32_t Cassandra_get_args::read(::apache::thrift::protocol::TProtocol* iprot) {
00353
00354 uint32_t xfer = 0;
00355 std::string fname;
00356 ::apache::thrift::protocol::TType ftype;
00357 int16_t fid;
00358
00359 xfer += iprot->readStructBegin(fname);
00360
00361 using ::apache::thrift::protocol::TProtocolException;
00362
00363 bool isset_key = false;
00364 bool isset_column_path = false;
00365 bool isset_consistency_level = false;
00366
00367 while (true)
00368 {
00369 xfer += iprot->readFieldBegin(fname, ftype, fid);
00370 if (ftype == ::apache::thrift::protocol::T_STOP) {
00371 break;
00372 }
00373 switch (fid)
00374 {
00375 case 1:
00376 if (ftype == ::apache::thrift::protocol::T_STRING) {
00377 xfer += iprot->readBinary(this->key);
00378 isset_key = true;
00379 } else {
00380 xfer += iprot->skip(ftype);
00381 }
00382 break;
00383 case 2:
00384 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
00385 xfer += this->column_path.read(iprot);
00386 isset_column_path = true;
00387 } else {
00388 xfer += iprot->skip(ftype);
00389 }
00390 break;
00391 case 3:
00392 if (ftype == ::apache::thrift::protocol::T_I32) {
00393 int32_t ecast131;
00394 xfer += iprot->readI32(ecast131);
00395 this->consistency_level = (ConsistencyLevel::type)ecast131;
00396 isset_consistency_level = true;
00397 } else {
00398 xfer += iprot->skip(ftype);
00399 }
00400 break;
00401 default:
00402 xfer += iprot->skip(ftype);
00403 break;
00404 }
00405 xfer += iprot->readFieldEnd();
00406 }
00407
00408 xfer += iprot->readStructEnd();
00409
00410 if (!isset_key)
00411 throw TProtocolException(TProtocolException::INVALID_DATA);
00412 if (!isset_column_path)
00413 throw TProtocolException(TProtocolException::INVALID_DATA);
00414 if (!isset_consistency_level)
00415 throw TProtocolException(TProtocolException::INVALID_DATA);
00416 return xfer;
00417 }
00418
00419 uint32_t Cassandra_get_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
00420 uint32_t xfer = 0;
00421 xfer += oprot->writeStructBegin("Cassandra_get_args");
00422 xfer += oprot->writeFieldBegin("key", ::apache::thrift::protocol::T_STRING, 1);
00423 xfer += oprot->writeBinary(this->key);
00424 xfer += oprot->writeFieldEnd();
00425 xfer += oprot->writeFieldBegin("column_path", ::apache::thrift::protocol::T_STRUCT, 2);
00426 xfer += this->column_path.write(oprot);
00427 xfer += oprot->writeFieldEnd();
00428 xfer += oprot->writeFieldBegin("consistency_level", ::apache::thrift::protocol::T_I32, 3);
00429 xfer += oprot->writeI32((int32_t)this->consistency_level);
00430 xfer += oprot->writeFieldEnd();
00431 xfer += oprot->writeFieldStop();
00432 xfer += oprot->writeStructEnd();
00433 return xfer;
00434 }
00435
00436 uint32_t Cassandra_get_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
00437 uint32_t xfer = 0;
00438 xfer += oprot->writeStructBegin("Cassandra_get_pargs");
00439 xfer += oprot->writeFieldBegin("key", ::apache::thrift::protocol::T_STRING, 1);
00440 xfer += oprot->writeBinary((*(this->key)));
00441 xfer += oprot->writeFieldEnd();
00442 xfer += oprot->writeFieldBegin("column_path", ::apache::thrift::protocol::T_STRUCT, 2);
00443 xfer += (*(this->column_path)).write(oprot);
00444 xfer += oprot->writeFieldEnd();
00445 xfer += oprot->writeFieldBegin("consistency_level", ::apache::thrift::protocol::T_I32, 3);
00446 xfer += oprot->writeI32((int32_t)(*(this->consistency_level)));
00447 xfer += oprot->writeFieldEnd();
00448 xfer += oprot->writeFieldStop();
00449 xfer += oprot->writeStructEnd();
00450 return xfer;
00451 }
00452
00453 uint32_t Cassandra_get_result::read(::apache::thrift::protocol::TProtocol* iprot) {
00454
00455 uint32_t xfer = 0;
00456 std::string fname;
00457 ::apache::thrift::protocol::TType ftype;
00458 int16_t fid;
00459
00460 xfer += iprot->readStructBegin(fname);
00461
00462 using ::apache::thrift::protocol::TProtocolException;
00463
00464
00465 while (true)
00466 {
00467 xfer += iprot->readFieldBegin(fname, ftype, fid);
00468 if (ftype == ::apache::thrift::protocol::T_STOP) {
00469 break;
00470 }
00471 switch (fid)
00472 {
00473 case 0:
00474 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
00475 xfer += this->success.read(iprot);
00476 this->__isset.success = true;
00477 } else {
00478 xfer += iprot->skip(ftype);
00479 }
00480 break;
00481 case 1:
00482 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
00483 xfer += this->ire.read(iprot);
00484 this->__isset.ire = true;
00485 } else {
00486 xfer += iprot->skip(ftype);
00487 }
00488 break;
00489 case 2:
00490 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
00491 xfer += this->nfe.read(iprot);
00492 this->__isset.nfe = true;
00493 } else {
00494 xfer += iprot->skip(ftype);
00495 }
00496 break;
00497 case 3:
00498 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
00499 xfer += this->ue.read(iprot);
00500 this->__isset.ue = true;
00501 } else {
00502 xfer += iprot->skip(ftype);
00503 }
00504 break;
00505 case 4:
00506 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
00507 xfer += this->te.read(iprot);
00508 this->__isset.te = true;
00509 } else {
00510 xfer += iprot->skip(ftype);
00511 }
00512 break;
00513 default:
00514 xfer += iprot->skip(ftype);
00515 break;
00516 }
00517 xfer += iprot->readFieldEnd();
00518 }
00519
00520 xfer += iprot->readStructEnd();
00521
00522 return xfer;
00523 }
00524
00525 uint32_t Cassandra_get_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
00526
00527 uint32_t xfer = 0;
00528
00529 xfer += oprot->writeStructBegin("Cassandra_get_result");
00530
00531 if (this->__isset.success) {
00532 xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0);
00533 xfer += this->success.write(oprot);
00534 xfer += oprot->writeFieldEnd();
00535 } else if (this->__isset.ire) {
00536 xfer += oprot->writeFieldBegin("ire", ::apache::thrift::protocol::T_STRUCT, 1);
00537 xfer += this->ire.write(oprot);
00538 xfer += oprot->writeFieldEnd();
00539 } else if (this->__isset.nfe) {
00540 xfer += oprot->writeFieldBegin("nfe", ::apache::thrift::protocol::T_STRUCT, 2);
00541 xfer += this->nfe.write(oprot);
00542 xfer += oprot->writeFieldEnd();
00543 } else if (this->__isset.ue) {
00544 xfer += oprot->writeFieldBegin("ue", ::apache::thrift::protocol::T_STRUCT, 3);
00545 xfer += this->ue.write(oprot);
00546 xfer += oprot->writeFieldEnd();
00547 } else if (this->__isset.te) {
00548 xfer += oprot->writeFieldBegin("te", ::apache::thrift::protocol::T_STRUCT, 4);
00549 xfer += this->te.write(oprot);
00550 xfer += oprot->writeFieldEnd();
00551 }
00552 xfer += oprot->writeFieldStop();
00553 xfer += oprot->writeStructEnd();
00554 return xfer;
00555 }
00556
00557 uint32_t Cassandra_get_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
00558
00559 uint32_t xfer = 0;
00560 std::string fname;
00561 ::apache::thrift::protocol::TType ftype;
00562 int16_t fid;
00563
00564 xfer += iprot->readStructBegin(fname);
00565
00566 using ::apache::thrift::protocol::TProtocolException;
00567
00568
00569 while (true)
00570 {
00571 xfer += iprot->readFieldBegin(fname, ftype, fid);
00572 if (ftype == ::apache::thrift::protocol::T_STOP) {
00573 break;
00574 }
00575 switch (fid)
00576 {
00577 case 0:
00578 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
00579 xfer += (*(this->success)).read(iprot);
00580 this->__isset.success = true;
00581 } else {
00582 xfer += iprot->skip(ftype);
00583 }
00584 break;
00585 case 1:
00586 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
00587 xfer += this->ire.read(iprot);
00588 this->__isset.ire = true;
00589 } else {
00590 xfer += iprot->skip(ftype);
00591 }
00592 break;
00593 case 2:
00594 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
00595 xfer += this->nfe.read(iprot);
00596 this->__isset.nfe = true;
00597 } else {
00598 xfer += iprot->skip(ftype);
00599 }
00600 break;
00601 case 3:
00602 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
00603 xfer += this->ue.read(iprot);
00604 this->__isset.ue = true;
00605 } else {
00606 xfer += iprot->skip(ftype);
00607 }
00608 break;
00609 case 4:
00610 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
00611 xfer += this->te.read(iprot);
00612 this->__isset.te = true;
00613 } else {
00614 xfer += iprot->skip(ftype);
00615 }
00616 break;
00617 default:
00618 xfer += iprot->skip(ftype);
00619 break;
00620 }
00621 xfer += iprot->readFieldEnd();
00622 }
00623
00624 xfer += iprot->readStructEnd();
00625
00626 return xfer;
00627 }
00628
00629 uint32_t Cassandra_get_slice_args::read(::apache::thrift::protocol::TProtocol* iprot) {
00630
00631 uint32_t xfer = 0;
00632 std::string fname;
00633 ::apache::thrift::protocol::TType ftype;
00634 int16_t fid;
00635
00636 xfer += iprot->readStructBegin(fname);
00637
00638 using ::apache::thrift::protocol::TProtocolException;
00639
00640 bool isset_key = false;
00641 bool isset_column_parent = false;
00642 bool isset_predicate = false;
00643 bool isset_consistency_level = false;
00644
00645 while (true)
00646 {
00647 xfer += iprot->readFieldBegin(fname, ftype, fid);
00648 if (ftype == ::apache::thrift::protocol::T_STOP) {
00649 break;
00650 }
00651 switch (fid)
00652 {
00653 case 1:
00654 if (ftype == ::apache::thrift::protocol::T_STRING) {
00655 xfer += iprot->readBinary(this->key);
00656 isset_key = true;
00657 } else {
00658 xfer += iprot->skip(ftype);
00659 }
00660 break;
00661 case 2:
00662 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
00663 xfer += this->column_parent.read(iprot);
00664 isset_column_parent = true;
00665 } else {
00666 xfer += iprot->skip(ftype);
00667 }
00668 break;
00669 case 3:
00670 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
00671 xfer += this->predicate.read(iprot);
00672 isset_predicate = true;
00673 } else {
00674 xfer += iprot->skip(ftype);
00675 }
00676 break;
00677 case 4:
00678 if (ftype == ::apache::thrift::protocol::T_I32) {
00679 int32_t ecast132;
00680 xfer += iprot->readI32(ecast132);
00681 this->consistency_level = (ConsistencyLevel::type)ecast132;
00682 isset_consistency_level = true;
00683 } else {
00684 xfer += iprot->skip(ftype);
00685 }
00686 break;
00687 default:
00688 xfer += iprot->skip(ftype);
00689 break;
00690 }
00691 xfer += iprot->readFieldEnd();
00692 }
00693
00694 xfer += iprot->readStructEnd();
00695
00696 if (!isset_key)
00697 throw TProtocolException(TProtocolException::INVALID_DATA);
00698 if (!isset_column_parent)
00699 throw TProtocolException(TProtocolException::INVALID_DATA);
00700 if (!isset_predicate)
00701 throw TProtocolException(TProtocolException::INVALID_DATA);
00702 if (!isset_consistency_level)
00703 throw TProtocolException(TProtocolException::INVALID_DATA);
00704 return xfer;
00705 }
00706
00707 uint32_t Cassandra_get_slice_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
00708 uint32_t xfer = 0;
00709 xfer += oprot->writeStructBegin("Cassandra_get_slice_args");
00710 xfer += oprot->writeFieldBegin("key", ::apache::thrift::protocol::T_STRING, 1);
00711 xfer += oprot->writeBinary(this->key);
00712 xfer += oprot->writeFieldEnd();
00713 xfer += oprot->writeFieldBegin("column_parent", ::apache::thrift::protocol::T_STRUCT, 2);
00714 xfer += this->column_parent.write(oprot);
00715 xfer += oprot->writeFieldEnd();
00716 xfer += oprot->writeFieldBegin("predicate", ::apache::thrift::protocol::T_STRUCT, 3);
00717 xfer += this->predicate.write(oprot);
00718 xfer += oprot->writeFieldEnd();
00719 xfer += oprot->writeFieldBegin("consistency_level", ::apache::thrift::protocol::T_I32, 4);
00720 xfer += oprot->writeI32((int32_t)this->consistency_level);
00721 xfer += oprot->writeFieldEnd();
00722 xfer += oprot->writeFieldStop();
00723 xfer += oprot->writeStructEnd();
00724 return xfer;
00725 }
00726
00727 uint32_t Cassandra_get_slice_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
00728 uint32_t xfer = 0;
00729 xfer += oprot->writeStructBegin("Cassandra_get_slice_pargs");
00730 xfer += oprot->writeFieldBegin("key", ::apache::thrift::protocol::T_STRING, 1);
00731 xfer += oprot->writeBinary((*(this->key)));
00732 xfer += oprot->writeFieldEnd();
00733 xfer += oprot->writeFieldBegin("column_parent", ::apache::thrift::protocol::T_STRUCT, 2);
00734 xfer += (*(this->column_parent)).write(oprot);
00735 xfer += oprot->writeFieldEnd();
00736 xfer += oprot->writeFieldBegin("predicate", ::apache::thrift::protocol::T_STRUCT, 3);
00737 xfer += (*(this->predicate)).write(oprot);
00738 xfer += oprot->writeFieldEnd();
00739 xfer += oprot->writeFieldBegin("consistency_level", ::apache::thrift::protocol::T_I32, 4);
00740 xfer += oprot->writeI32((int32_t)(*(this->consistency_level)));
00741 xfer += oprot->writeFieldEnd();
00742 xfer += oprot->writeFieldStop();
00743 xfer += oprot->writeStructEnd();
00744 return xfer;
00745 }
00746
00747 uint32_t Cassandra_get_slice_result::read(::apache::thrift::protocol::TProtocol* iprot) {
00748
00749 uint32_t xfer = 0;
00750 std::string fname;
00751 ::apache::thrift::protocol::TType ftype;
00752 int16_t fid;
00753
00754 xfer += iprot->readStructBegin(fname);
00755
00756 using ::apache::thrift::protocol::TProtocolException;
00757
00758
00759 while (true)
00760 {
00761 xfer += iprot->readFieldBegin(fname, ftype, fid);
00762 if (ftype == ::apache::thrift::protocol::T_STOP) {
00763 break;
00764 }
00765 switch (fid)
00766 {
00767 case 0:
00768 if (ftype == ::apache::thrift::protocol::T_LIST) {
00769 {
00770 this->success.clear();
00771 uint32_t _size133;
00772 ::apache::thrift::protocol::TType _etype136;
00773 iprot->readListBegin(_etype136, _size133);
00774 this->success.resize(_size133);
00775 uint32_t _i137;
00776 for (_i137 = 0; _i137 < _size133; ++_i137)
00777 {
00778 xfer += this->success[_i137].read(iprot);
00779 }
00780 iprot->readListEnd();
00781 }
00782 this->__isset.success = true;
00783 } else {
00784 xfer += iprot->skip(ftype);
00785 }
00786 break;
00787 case 1:
00788 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
00789 xfer += this->ire.read(iprot);
00790 this->__isset.ire = true;
00791 } else {
00792 xfer += iprot->skip(ftype);
00793 }
00794 break;
00795 case 2:
00796 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
00797 xfer += this->ue.read(iprot);
00798 this->__isset.ue = true;
00799 } else {
00800 xfer += iprot->skip(ftype);
00801 }
00802 break;
00803 case 3:
00804 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
00805 xfer += this->te.read(iprot);
00806 this->__isset.te = true;
00807 } else {
00808 xfer += iprot->skip(ftype);
00809 }
00810 break;
00811 default:
00812 xfer += iprot->skip(ftype);
00813 break;
00814 }
00815 xfer += iprot->readFieldEnd();
00816 }
00817
00818 xfer += iprot->readStructEnd();
00819
00820 return xfer;
00821 }
00822
00823 uint32_t Cassandra_get_slice_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
00824
00825 uint32_t xfer = 0;
00826
00827 xfer += oprot->writeStructBegin("Cassandra_get_slice_result");
00828
00829 if (this->__isset.success) {
00830 xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0);
00831 {
00832 xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, this->success.size());
00833 std::vector<ColumnOrSuperColumn> ::const_iterator _iter138;
00834 for (_iter138 = this->success.begin(); _iter138 != this->success.end(); ++_iter138)
00835 {
00836 xfer += (*_iter138).write(oprot);
00837 }
00838 xfer += oprot->writeListEnd();
00839 }
00840 xfer += oprot->writeFieldEnd();
00841 } else if (this->__isset.ire) {
00842 xfer += oprot->writeFieldBegin("ire", ::apache::thrift::protocol::T_STRUCT, 1);
00843 xfer += this->ire.write(oprot);
00844 xfer += oprot->writeFieldEnd();
00845 } else if (this->__isset.ue) {
00846 xfer += oprot->writeFieldBegin("ue", ::apache::thrift::protocol::T_STRUCT, 2);
00847 xfer += this->ue.write(oprot);
00848 xfer += oprot->writeFieldEnd();
00849 } else if (this->__isset.te) {
00850 xfer += oprot->writeFieldBegin("te", ::apache::thrift::protocol::T_STRUCT, 3);
00851 xfer += this->te.write(oprot);
00852 xfer += oprot->writeFieldEnd();
00853 }
00854 xfer += oprot->writeFieldStop();
00855 xfer += oprot->writeStructEnd();
00856 return xfer;
00857 }
00858
00859 uint32_t Cassandra_get_slice_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
00860
00861 uint32_t xfer = 0;
00862 std::string fname;
00863 ::apache::thrift::protocol::TType ftype;
00864 int16_t fid;
00865
00866 xfer += iprot->readStructBegin(fname);
00867
00868 using ::apache::thrift::protocol::TProtocolException;
00869
00870
00871 while (true)
00872 {
00873 xfer += iprot->readFieldBegin(fname, ftype, fid);
00874 if (ftype == ::apache::thrift::protocol::T_STOP) {
00875 break;
00876 }
00877 switch (fid)
00878 {
00879 case 0:
00880 if (ftype == ::apache::thrift::protocol::T_LIST) {
00881 {
00882 (*(this->success)).clear();
00883 uint32_t _size139;
00884 ::apache::thrift::protocol::TType _etype142;
00885 iprot->readListBegin(_etype142, _size139);
00886 (*(this->success)).resize(_size139);
00887 uint32_t _i143;
00888 for (_i143 = 0; _i143 < _size139; ++_i143)
00889 {
00890 xfer += (*(this->success))[_i143].read(iprot);
00891 }
00892 iprot->readListEnd();
00893 }
00894 this->__isset.success = true;
00895 } else {
00896 xfer += iprot->skip(ftype);
00897 }
00898 break;
00899 case 1:
00900 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
00901 xfer += this->ire.read(iprot);
00902 this->__isset.ire = true;
00903 } else {
00904 xfer += iprot->skip(ftype);
00905 }
00906 break;
00907 case 2:
00908 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
00909 xfer += this->ue.read(iprot);
00910 this->__isset.ue = true;
00911 } else {
00912 xfer += iprot->skip(ftype);
00913 }
00914 break;
00915 case 3:
00916 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
00917 xfer += this->te.read(iprot);
00918 this->__isset.te = true;
00919 } else {
00920 xfer += iprot->skip(ftype);
00921 }
00922 break;
00923 default:
00924 xfer += iprot->skip(ftype);
00925 break;
00926 }
00927 xfer += iprot->readFieldEnd();
00928 }
00929
00930 xfer += iprot->readStructEnd();
00931
00932 return xfer;
00933 }
00934
00935 uint32_t Cassandra_get_count_args::read(::apache::thrift::protocol::TProtocol* iprot) {
00936
00937 uint32_t xfer = 0;
00938 std::string fname;
00939 ::apache::thrift::protocol::TType ftype;
00940 int16_t fid;
00941
00942 xfer += iprot->readStructBegin(fname);
00943
00944 using ::apache::thrift::protocol::TProtocolException;
00945
00946 bool isset_key = false;
00947 bool isset_column_parent = false;
00948 bool isset_predicate = false;
00949 bool isset_consistency_level = false;
00950
00951 while (true)
00952 {
00953 xfer += iprot->readFieldBegin(fname, ftype, fid);
00954 if (ftype == ::apache::thrift::protocol::T_STOP) {
00955 break;
00956 }
00957 switch (fid)
00958 {
00959 case 1:
00960 if (ftype == ::apache::thrift::protocol::T_STRING) {
00961 xfer += iprot->readBinary(this->key);
00962 isset_key = true;
00963 } else {
00964 xfer += iprot->skip(ftype);
00965 }
00966 break;
00967 case 2:
00968 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
00969 xfer += this->column_parent.read(iprot);
00970 isset_column_parent = true;
00971 } else {
00972 xfer += iprot->skip(ftype);
00973 }
00974 break;
00975 case 3:
00976 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
00977 xfer += this->predicate.read(iprot);
00978 isset_predicate = true;
00979 } else {
00980 xfer += iprot->skip(ftype);
00981 }
00982 break;
00983 case 4:
00984 if (ftype == ::apache::thrift::protocol::T_I32) {
00985 int32_t ecast144;
00986 xfer += iprot->readI32(ecast144);
00987 this->consistency_level = (ConsistencyLevel::type)ecast144;
00988 isset_consistency_level = true;
00989 } else {
00990 xfer += iprot->skip(ftype);
00991 }
00992 break;
00993 default:
00994 xfer += iprot->skip(ftype);
00995 break;
00996 }
00997 xfer += iprot->readFieldEnd();
00998 }
00999
01000 xfer += iprot->readStructEnd();
01001
01002 if (!isset_key)
01003 throw TProtocolException(TProtocolException::INVALID_DATA);
01004 if (!isset_column_parent)
01005 throw TProtocolException(TProtocolException::INVALID_DATA);
01006 if (!isset_predicate)
01007 throw TProtocolException(TProtocolException::INVALID_DATA);
01008 if (!isset_consistency_level)
01009 throw TProtocolException(TProtocolException::INVALID_DATA);
01010 return xfer;
01011 }
01012
01013 uint32_t Cassandra_get_count_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
01014 uint32_t xfer = 0;
01015 xfer += oprot->writeStructBegin("Cassandra_get_count_args");
01016 xfer += oprot->writeFieldBegin("key", ::apache::thrift::protocol::T_STRING, 1);
01017 xfer += oprot->writeBinary(this->key);
01018 xfer += oprot->writeFieldEnd();
01019 xfer += oprot->writeFieldBegin("column_parent", ::apache::thrift::protocol::T_STRUCT, 2);
01020 xfer += this->column_parent.write(oprot);
01021 xfer += oprot->writeFieldEnd();
01022 xfer += oprot->writeFieldBegin("predicate", ::apache::thrift::protocol::T_STRUCT, 3);
01023 xfer += this->predicate.write(oprot);
01024 xfer += oprot->writeFieldEnd();
01025 xfer += oprot->writeFieldBegin("consistency_level", ::apache::thrift::protocol::T_I32, 4);
01026 xfer += oprot->writeI32((int32_t)this->consistency_level);
01027 xfer += oprot->writeFieldEnd();
01028 xfer += oprot->writeFieldStop();
01029 xfer += oprot->writeStructEnd();
01030 return xfer;
01031 }
01032
01033 uint32_t Cassandra_get_count_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
01034 uint32_t xfer = 0;
01035 xfer += oprot->writeStructBegin("Cassandra_get_count_pargs");
01036 xfer += oprot->writeFieldBegin("key", ::apache::thrift::protocol::T_STRING, 1);
01037 xfer += oprot->writeBinary((*(this->key)));
01038 xfer += oprot->writeFieldEnd();
01039 xfer += oprot->writeFieldBegin("column_parent", ::apache::thrift::protocol::T_STRUCT, 2);
01040 xfer += (*(this->column_parent)).write(oprot);
01041 xfer += oprot->writeFieldEnd();
01042 xfer += oprot->writeFieldBegin("predicate", ::apache::thrift::protocol::T_STRUCT, 3);
01043 xfer += (*(this->predicate)).write(oprot);
01044 xfer += oprot->writeFieldEnd();
01045 xfer += oprot->writeFieldBegin("consistency_level", ::apache::thrift::protocol::T_I32, 4);
01046 xfer += oprot->writeI32((int32_t)(*(this->consistency_level)));
01047 xfer += oprot->writeFieldEnd();
01048 xfer += oprot->writeFieldStop();
01049 xfer += oprot->writeStructEnd();
01050 return xfer;
01051 }
01052
01053 uint32_t Cassandra_get_count_result::read(::apache::thrift::protocol::TProtocol* iprot) {
01054
01055 uint32_t xfer = 0;
01056 std::string fname;
01057 ::apache::thrift::protocol::TType ftype;
01058 int16_t fid;
01059
01060 xfer += iprot->readStructBegin(fname);
01061
01062 using ::apache::thrift::protocol::TProtocolException;
01063
01064
01065 while (true)
01066 {
01067 xfer += iprot->readFieldBegin(fname, ftype, fid);
01068 if (ftype == ::apache::thrift::protocol::T_STOP) {
01069 break;
01070 }
01071 switch (fid)
01072 {
01073 case 0:
01074 if (ftype == ::apache::thrift::protocol::T_I32) {
01075 xfer += iprot->readI32(this->success);
01076 this->__isset.success = true;
01077 } else {
01078 xfer += iprot->skip(ftype);
01079 }
01080 break;
01081 case 1:
01082 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
01083 xfer += this->ire.read(iprot);
01084 this->__isset.ire = true;
01085 } else {
01086 xfer += iprot->skip(ftype);
01087 }
01088 break;
01089 case 2:
01090 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
01091 xfer += this->ue.read(iprot);
01092 this->__isset.ue = true;
01093 } else {
01094 xfer += iprot->skip(ftype);
01095 }
01096 break;
01097 case 3:
01098 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
01099 xfer += this->te.read(iprot);
01100 this->__isset.te = true;
01101 } else {
01102 xfer += iprot->skip(ftype);
01103 }
01104 break;
01105 default:
01106 xfer += iprot->skip(ftype);
01107 break;
01108 }
01109 xfer += iprot->readFieldEnd();
01110 }
01111
01112 xfer += iprot->readStructEnd();
01113
01114 return xfer;
01115 }
01116
01117 uint32_t Cassandra_get_count_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
01118
01119 uint32_t xfer = 0;
01120
01121 xfer += oprot->writeStructBegin("Cassandra_get_count_result");
01122
01123 if (this->__isset.success) {
01124 xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_I32, 0);
01125 xfer += oprot->writeI32(this->success);
01126 xfer += oprot->writeFieldEnd();
01127 } else if (this->__isset.ire) {
01128 xfer += oprot->writeFieldBegin("ire", ::apache::thrift::protocol::T_STRUCT, 1);
01129 xfer += this->ire.write(oprot);
01130 xfer += oprot->writeFieldEnd();
01131 } else if (this->__isset.ue) {
01132 xfer += oprot->writeFieldBegin("ue", ::apache::thrift::protocol::T_STRUCT, 2);
01133 xfer += this->ue.write(oprot);
01134 xfer += oprot->writeFieldEnd();
01135 } else if (this->__isset.te) {
01136 xfer += oprot->writeFieldBegin("te", ::apache::thrift::protocol::T_STRUCT, 3);
01137 xfer += this->te.write(oprot);
01138 xfer += oprot->writeFieldEnd();
01139 }
01140 xfer += oprot->writeFieldStop();
01141 xfer += oprot->writeStructEnd();
01142 return xfer;
01143 }
01144
01145 uint32_t Cassandra_get_count_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
01146
01147 uint32_t xfer = 0;
01148 std::string fname;
01149 ::apache::thrift::protocol::TType ftype;
01150 int16_t fid;
01151
01152 xfer += iprot->readStructBegin(fname);
01153
01154 using ::apache::thrift::protocol::TProtocolException;
01155
01156
01157 while (true)
01158 {
01159 xfer += iprot->readFieldBegin(fname, ftype, fid);
01160 if (ftype == ::apache::thrift::protocol::T_STOP) {
01161 break;
01162 }
01163 switch (fid)
01164 {
01165 case 0:
01166 if (ftype == ::apache::thrift::protocol::T_I32) {
01167 xfer += iprot->readI32((*(this->success)));
01168 this->__isset.success = true;
01169 } else {
01170 xfer += iprot->skip(ftype);
01171 }
01172 break;
01173 case 1:
01174 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
01175 xfer += this->ire.read(iprot);
01176 this->__isset.ire = true;
01177 } else {
01178 xfer += iprot->skip(ftype);
01179 }
01180 break;
01181 case 2:
01182 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
01183 xfer += this->ue.read(iprot);
01184 this->__isset.ue = true;
01185 } else {
01186 xfer += iprot->skip(ftype);
01187 }
01188 break;
01189 case 3:
01190 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
01191 xfer += this->te.read(iprot);
01192 this->__isset.te = true;
01193 } else {
01194 xfer += iprot->skip(ftype);
01195 }
01196 break;
01197 default:
01198 xfer += iprot->skip(ftype);
01199 break;
01200 }
01201 xfer += iprot->readFieldEnd();
01202 }
01203
01204 xfer += iprot->readStructEnd();
01205
01206 return xfer;
01207 }
01208
01209 uint32_t Cassandra_multiget_slice_args::read(::apache::thrift::protocol::TProtocol* iprot) {
01210
01211 uint32_t xfer = 0;
01212 std::string fname;
01213 ::apache::thrift::protocol::TType ftype;
01214 int16_t fid;
01215
01216 xfer += iprot->readStructBegin(fname);
01217
01218 using ::apache::thrift::protocol::TProtocolException;
01219
01220 bool isset_keys = false;
01221 bool isset_column_parent = false;
01222 bool isset_predicate = false;
01223 bool isset_consistency_level = false;
01224
01225 while (true)
01226 {
01227 xfer += iprot->readFieldBegin(fname, ftype, fid);
01228 if (ftype == ::apache::thrift::protocol::T_STOP) {
01229 break;
01230 }
01231 switch (fid)
01232 {
01233 case 1:
01234 if (ftype == ::apache::thrift::protocol::T_LIST) {
01235 {
01236 this->keys.clear();
01237 uint32_t _size145;
01238 ::apache::thrift::protocol::TType _etype148;
01239 iprot->readListBegin(_etype148, _size145);
01240 this->keys.resize(_size145);
01241 uint32_t _i149;
01242 for (_i149 = 0; _i149 < _size145; ++_i149)
01243 {
01244 xfer += iprot->readBinary(this->keys[_i149]);
01245 }
01246 iprot->readListEnd();
01247 }
01248 isset_keys = true;
01249 } else {
01250 xfer += iprot->skip(ftype);
01251 }
01252 break;
01253 case 2:
01254 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
01255 xfer += this->column_parent.read(iprot);
01256 isset_column_parent = true;
01257 } else {
01258 xfer += iprot->skip(ftype);
01259 }
01260 break;
01261 case 3:
01262 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
01263 xfer += this->predicate.read(iprot);
01264 isset_predicate = true;
01265 } else {
01266 xfer += iprot->skip(ftype);
01267 }
01268 break;
01269 case 4:
01270 if (ftype == ::apache::thrift::protocol::T_I32) {
01271 int32_t ecast150;
01272 xfer += iprot->readI32(ecast150);
01273 this->consistency_level = (ConsistencyLevel::type)ecast150;
01274 isset_consistency_level = true;
01275 } else {
01276 xfer += iprot->skip(ftype);
01277 }
01278 break;
01279 default:
01280 xfer += iprot->skip(ftype);
01281 break;
01282 }
01283 xfer += iprot->readFieldEnd();
01284 }
01285
01286 xfer += iprot->readStructEnd();
01287
01288 if (!isset_keys)
01289 throw TProtocolException(TProtocolException::INVALID_DATA);
01290 if (!isset_column_parent)
01291 throw TProtocolException(TProtocolException::INVALID_DATA);
01292 if (!isset_predicate)
01293 throw TProtocolException(TProtocolException::INVALID_DATA);
01294 if (!isset_consistency_level)
01295 throw TProtocolException(TProtocolException::INVALID_DATA);
01296 return xfer;
01297 }
01298
01299 uint32_t Cassandra_multiget_slice_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
01300 uint32_t xfer = 0;
01301 xfer += oprot->writeStructBegin("Cassandra_multiget_slice_args");
01302 xfer += oprot->writeFieldBegin("keys", ::apache::thrift::protocol::T_LIST, 1);
01303 {
01304 xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, this->keys.size());
01305 std::vector<std::string> ::const_iterator _iter151;
01306 for (_iter151 = this->keys.begin(); _iter151 != this->keys.end(); ++_iter151)
01307 {
01308 xfer += oprot->writeBinary((*_iter151));
01309 }
01310 xfer += oprot->writeListEnd();
01311 }
01312 xfer += oprot->writeFieldEnd();
01313 xfer += oprot->writeFieldBegin("column_parent", ::apache::thrift::protocol::T_STRUCT, 2);
01314 xfer += this->column_parent.write(oprot);
01315 xfer += oprot->writeFieldEnd();
01316 xfer += oprot->writeFieldBegin("predicate", ::apache::thrift::protocol::T_STRUCT, 3);
01317 xfer += this->predicate.write(oprot);
01318 xfer += oprot->writeFieldEnd();
01319 xfer += oprot->writeFieldBegin("consistency_level", ::apache::thrift::protocol::T_I32, 4);
01320 xfer += oprot->writeI32((int32_t)this->consistency_level);
01321 xfer += oprot->writeFieldEnd();
01322 xfer += oprot->writeFieldStop();
01323 xfer += oprot->writeStructEnd();
01324 return xfer;
01325 }
01326
01327 uint32_t Cassandra_multiget_slice_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
01328 uint32_t xfer = 0;
01329 xfer += oprot->writeStructBegin("Cassandra_multiget_slice_pargs");
01330 xfer += oprot->writeFieldBegin("keys", ::apache::thrift::protocol::T_LIST, 1);
01331 {
01332 xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, (*(this->keys)).size());
01333 std::vector<std::string> ::const_iterator _iter152;
01334 for (_iter152 = (*(this->keys)).begin(); _iter152 != (*(this->keys)).end(); ++_iter152)
01335 {
01336 xfer += oprot->writeBinary((*_iter152));
01337 }
01338 xfer += oprot->writeListEnd();
01339 }
01340 xfer += oprot->writeFieldEnd();
01341 xfer += oprot->writeFieldBegin("column_parent", ::apache::thrift::protocol::T_STRUCT, 2);
01342 xfer += (*(this->column_parent)).write(oprot);
01343 xfer += oprot->writeFieldEnd();
01344 xfer += oprot->writeFieldBegin("predicate", ::apache::thrift::protocol::T_STRUCT, 3);
01345 xfer += (*(this->predicate)).write(oprot);
01346 xfer += oprot->writeFieldEnd();
01347 xfer += oprot->writeFieldBegin("consistency_level", ::apache::thrift::protocol::T_I32, 4);
01348 xfer += oprot->writeI32((int32_t)(*(this->consistency_level)));
01349 xfer += oprot->writeFieldEnd();
01350 xfer += oprot->writeFieldStop();
01351 xfer += oprot->writeStructEnd();
01352 return xfer;
01353 }
01354
01355 uint32_t Cassandra_multiget_slice_result::read(::apache::thrift::protocol::TProtocol* iprot) {
01356
01357 uint32_t xfer = 0;
01358 std::string fname;
01359 ::apache::thrift::protocol::TType ftype;
01360 int16_t fid;
01361
01362 xfer += iprot->readStructBegin(fname);
01363
01364 using ::apache::thrift::protocol::TProtocolException;
01365
01366
01367 while (true)
01368 {
01369 xfer += iprot->readFieldBegin(fname, ftype, fid);
01370 if (ftype == ::apache::thrift::protocol::T_STOP) {
01371 break;
01372 }
01373 switch (fid)
01374 {
01375 case 0:
01376 if (ftype == ::apache::thrift::protocol::T_MAP) {
01377 {
01378 this->success.clear();
01379 uint32_t _size153;
01380 ::apache::thrift::protocol::TType _ktype154;
01381 ::apache::thrift::protocol::TType _vtype155;
01382 iprot->readMapBegin(_ktype154, _vtype155, _size153);
01383 uint32_t _i157;
01384 for (_i157 = 0; _i157 < _size153; ++_i157)
01385 {
01386 std::string _key158;
01387 xfer += iprot->readBinary(_key158);
01388 std::vector<ColumnOrSuperColumn> & _val159 = this->success[_key158];
01389 {
01390 _val159.clear();
01391 uint32_t _size160;
01392 ::apache::thrift::protocol::TType _etype163;
01393 iprot->readListBegin(_etype163, _size160);
01394 _val159.resize(_size160);
01395 uint32_t _i164;
01396 for (_i164 = 0; _i164 < _size160; ++_i164)
01397 {
01398 xfer += _val159[_i164].read(iprot);
01399 }
01400 iprot->readListEnd();
01401 }
01402 }
01403 iprot->readMapEnd();
01404 }
01405 this->__isset.success = true;
01406 } else {
01407 xfer += iprot->skip(ftype);
01408 }
01409 break;
01410 case 1:
01411 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
01412 xfer += this->ire.read(iprot);
01413 this->__isset.ire = true;
01414 } else {
01415 xfer += iprot->skip(ftype);
01416 }
01417 break;
01418 case 2:
01419 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
01420 xfer += this->ue.read(iprot);
01421 this->__isset.ue = true;
01422 } else {
01423 xfer += iprot->skip(ftype);
01424 }
01425 break;
01426 case 3:
01427 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
01428 xfer += this->te.read(iprot);
01429 this->__isset.te = true;
01430 } else {
01431 xfer += iprot->skip(ftype);
01432 }
01433 break;
01434 default:
01435 xfer += iprot->skip(ftype);
01436 break;
01437 }
01438 xfer += iprot->readFieldEnd();
01439 }
01440
01441 xfer += iprot->readStructEnd();
01442
01443 return xfer;
01444 }
01445
01446 uint32_t Cassandra_multiget_slice_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
01447
01448 uint32_t xfer = 0;
01449
01450 xfer += oprot->writeStructBegin("Cassandra_multiget_slice_result");
01451
01452 if (this->__isset.success) {
01453 xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_MAP, 0);
01454 {
01455 xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_LIST, this->success.size());
01456 std::map<std::string, std::vector<ColumnOrSuperColumn> > ::const_iterator _iter165;
01457 for (_iter165 = this->success.begin(); _iter165 != this->success.end(); ++_iter165)
01458 {
01459 xfer += oprot->writeBinary(_iter165->first);
01460 {
01461 xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, _iter165->second.size());
01462 std::vector<ColumnOrSuperColumn> ::const_iterator _iter166;
01463 for (_iter166 = _iter165->second.begin(); _iter166 != _iter165->second.end(); ++_iter166)
01464 {
01465 xfer += (*_iter166).write(oprot);
01466 }
01467 xfer += oprot->writeListEnd();
01468 }
01469 }
01470 xfer += oprot->writeMapEnd();
01471 }
01472 xfer += oprot->writeFieldEnd();
01473 } else if (this->__isset.ire) {
01474 xfer += oprot->writeFieldBegin("ire", ::apache::thrift::protocol::T_STRUCT, 1);
01475 xfer += this->ire.write(oprot);
01476 xfer += oprot->writeFieldEnd();
01477 } else if (this->__isset.ue) {
01478 xfer += oprot->writeFieldBegin("ue", ::apache::thrift::protocol::T_STRUCT, 2);
01479 xfer += this->ue.write(oprot);
01480 xfer += oprot->writeFieldEnd();
01481 } else if (this->__isset.te) {
01482 xfer += oprot->writeFieldBegin("te", ::apache::thrift::protocol::T_STRUCT, 3);
01483 xfer += this->te.write(oprot);
01484 xfer += oprot->writeFieldEnd();
01485 }
01486 xfer += oprot->writeFieldStop();
01487 xfer += oprot->writeStructEnd();
01488 return xfer;
01489 }
01490
01491 uint32_t Cassandra_multiget_slice_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
01492
01493 uint32_t xfer = 0;
01494 std::string fname;
01495 ::apache::thrift::protocol::TType ftype;
01496 int16_t fid;
01497
01498 xfer += iprot->readStructBegin(fname);
01499
01500 using ::apache::thrift::protocol::TProtocolException;
01501
01502
01503 while (true)
01504 {
01505 xfer += iprot->readFieldBegin(fname, ftype, fid);
01506 if (ftype == ::apache::thrift::protocol::T_STOP) {
01507 break;
01508 }
01509 switch (fid)
01510 {
01511 case 0:
01512 if (ftype == ::apache::thrift::protocol::T_MAP) {
01513 {
01514 (*(this->success)).clear();
01515 uint32_t _size167;
01516 ::apache::thrift::protocol::TType _ktype168;
01517 ::apache::thrift::protocol::TType _vtype169;
01518 iprot->readMapBegin(_ktype168, _vtype169, _size167);
01519 uint32_t _i171;
01520 for (_i171 = 0; _i171 < _size167; ++_i171)
01521 {
01522 std::string _key172;
01523 xfer += iprot->readBinary(_key172);
01524 std::vector<ColumnOrSuperColumn> & _val173 = (*(this->success))[_key172];
01525 {
01526 _val173.clear();
01527 uint32_t _size174;
01528 ::apache::thrift::protocol::TType _etype177;
01529 iprot->readListBegin(_etype177, _size174);
01530 _val173.resize(_size174);
01531 uint32_t _i178;
01532 for (_i178 = 0; _i178 < _size174; ++_i178)
01533 {
01534 xfer += _val173[_i178].read(iprot);
01535 }
01536 iprot->readListEnd();
01537 }
01538 }
01539 iprot->readMapEnd();
01540 }
01541 this->__isset.success = true;
01542 } else {
01543 xfer += iprot->skip(ftype);
01544 }
01545 break;
01546 case 1:
01547 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
01548 xfer += this->ire.read(iprot);
01549 this->__isset.ire = true;
01550 } else {
01551 xfer += iprot->skip(ftype);
01552 }
01553 break;
01554 case 2:
01555 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
01556 xfer += this->ue.read(iprot);
01557 this->__isset.ue = true;
01558 } else {
01559 xfer += iprot->skip(ftype);
01560 }
01561 break;
01562 case 3:
01563 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
01564 xfer += this->te.read(iprot);
01565 this->__isset.te = true;
01566 } else {
01567 xfer += iprot->skip(ftype);
01568 }
01569 break;
01570 default:
01571 xfer += iprot->skip(ftype);
01572 break;
01573 }
01574 xfer += iprot->readFieldEnd();
01575 }
01576
01577 xfer += iprot->readStructEnd();
01578
01579 return xfer;
01580 }
01581
01582 uint32_t Cassandra_multiget_count_args::read(::apache::thrift::protocol::TProtocol* iprot) {
01583
01584 uint32_t xfer = 0;
01585 std::string fname;
01586 ::apache::thrift::protocol::TType ftype;
01587 int16_t fid;
01588
01589 xfer += iprot->readStructBegin(fname);
01590
01591 using ::apache::thrift::protocol::TProtocolException;
01592
01593 bool isset_keys = false;
01594 bool isset_column_parent = false;
01595 bool isset_predicate = false;
01596 bool isset_consistency_level = false;
01597
01598 while (true)
01599 {
01600 xfer += iprot->readFieldBegin(fname, ftype, fid);
01601 if (ftype == ::apache::thrift::protocol::T_STOP) {
01602 break;
01603 }
01604 switch (fid)
01605 {
01606 case 1:
01607 if (ftype == ::apache::thrift::protocol::T_LIST) {
01608 {
01609 this->keys.clear();
01610 uint32_t _size179;
01611 ::apache::thrift::protocol::TType _etype182;
01612 iprot->readListBegin(_etype182, _size179);
01613 this->keys.resize(_size179);
01614 uint32_t _i183;
01615 for (_i183 = 0; _i183 < _size179; ++_i183)
01616 {
01617 xfer += iprot->readBinary(this->keys[_i183]);
01618 }
01619 iprot->readListEnd();
01620 }
01621 isset_keys = true;
01622 } else {
01623 xfer += iprot->skip(ftype);
01624 }
01625 break;
01626 case 2:
01627 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
01628 xfer += this->column_parent.read(iprot);
01629 isset_column_parent = true;
01630 } else {
01631 xfer += iprot->skip(ftype);
01632 }
01633 break;
01634 case 3:
01635 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
01636 xfer += this->predicate.read(iprot);
01637 isset_predicate = true;
01638 } else {
01639 xfer += iprot->skip(ftype);
01640 }
01641 break;
01642 case 4:
01643 if (ftype == ::apache::thrift::protocol::T_I32) {
01644 int32_t ecast184;
01645 xfer += iprot->readI32(ecast184);
01646 this->consistency_level = (ConsistencyLevel::type)ecast184;
01647 isset_consistency_level = true;
01648 } else {
01649 xfer += iprot->skip(ftype);
01650 }
01651 break;
01652 default:
01653 xfer += iprot->skip(ftype);
01654 break;
01655 }
01656 xfer += iprot->readFieldEnd();
01657 }
01658
01659 xfer += iprot->readStructEnd();
01660
01661 if (!isset_keys)
01662 throw TProtocolException(TProtocolException::INVALID_DATA);
01663 if (!isset_column_parent)
01664 throw TProtocolException(TProtocolException::INVALID_DATA);
01665 if (!isset_predicate)
01666 throw TProtocolException(TProtocolException::INVALID_DATA);
01667 if (!isset_consistency_level)
01668 throw TProtocolException(TProtocolException::INVALID_DATA);
01669 return xfer;
01670 }
01671
01672 uint32_t Cassandra_multiget_count_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
01673 uint32_t xfer = 0;
01674 xfer += oprot->writeStructBegin("Cassandra_multiget_count_args");
01675 xfer += oprot->writeFieldBegin("keys", ::apache::thrift::protocol::T_LIST, 1);
01676 {
01677 xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, this->keys.size());
01678 std::vector<std::string> ::const_iterator _iter185;
01679 for (_iter185 = this->keys.begin(); _iter185 != this->keys.end(); ++_iter185)
01680 {
01681 xfer += oprot->writeBinary((*_iter185));
01682 }
01683 xfer += oprot->writeListEnd();
01684 }
01685 xfer += oprot->writeFieldEnd();
01686 xfer += oprot->writeFieldBegin("column_parent", ::apache::thrift::protocol::T_STRUCT, 2);
01687 xfer += this->column_parent.write(oprot);
01688 xfer += oprot->writeFieldEnd();
01689 xfer += oprot->writeFieldBegin("predicate", ::apache::thrift::protocol::T_STRUCT, 3);
01690 xfer += this->predicate.write(oprot);
01691 xfer += oprot->writeFieldEnd();
01692 xfer += oprot->writeFieldBegin("consistency_level", ::apache::thrift::protocol::T_I32, 4);
01693 xfer += oprot->writeI32((int32_t)this->consistency_level);
01694 xfer += oprot->writeFieldEnd();
01695 xfer += oprot->writeFieldStop();
01696 xfer += oprot->writeStructEnd();
01697 return xfer;
01698 }
01699
01700 uint32_t Cassandra_multiget_count_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
01701 uint32_t xfer = 0;
01702 xfer += oprot->writeStructBegin("Cassandra_multiget_count_pargs");
01703 xfer += oprot->writeFieldBegin("keys", ::apache::thrift::protocol::T_LIST, 1);
01704 {
01705 xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, (*(this->keys)).size());
01706 std::vector<std::string> ::const_iterator _iter186;
01707 for (_iter186 = (*(this->keys)).begin(); _iter186 != (*(this->keys)).end(); ++_iter186)
01708 {
01709 xfer += oprot->writeBinary((*_iter186));
01710 }
01711 xfer += oprot->writeListEnd();
01712 }
01713 xfer += oprot->writeFieldEnd();
01714 xfer += oprot->writeFieldBegin("column_parent", ::apache::thrift::protocol::T_STRUCT, 2);
01715 xfer += (*(this->column_parent)).write(oprot);
01716 xfer += oprot->writeFieldEnd();
01717 xfer += oprot->writeFieldBegin("predicate", ::apache::thrift::protocol::T_STRUCT, 3);
01718 xfer += (*(this->predicate)).write(oprot);
01719 xfer += oprot->writeFieldEnd();
01720 xfer += oprot->writeFieldBegin("consistency_level", ::apache::thrift::protocol::T_I32, 4);
01721 xfer += oprot->writeI32((int32_t)(*(this->consistency_level)));
01722 xfer += oprot->writeFieldEnd();
01723 xfer += oprot->writeFieldStop();
01724 xfer += oprot->writeStructEnd();
01725 return xfer;
01726 }
01727
01728 uint32_t Cassandra_multiget_count_result::read(::apache::thrift::protocol::TProtocol* iprot) {
01729
01730 uint32_t xfer = 0;
01731 std::string fname;
01732 ::apache::thrift::protocol::TType ftype;
01733 int16_t fid;
01734
01735 xfer += iprot->readStructBegin(fname);
01736
01737 using ::apache::thrift::protocol::TProtocolException;
01738
01739
01740 while (true)
01741 {
01742 xfer += iprot->readFieldBegin(fname, ftype, fid);
01743 if (ftype == ::apache::thrift::protocol::T_STOP) {
01744 break;
01745 }
01746 switch (fid)
01747 {
01748 case 0:
01749 if (ftype == ::apache::thrift::protocol::T_MAP) {
01750 {
01751 this->success.clear();
01752 uint32_t _size187;
01753 ::apache::thrift::protocol::TType _ktype188;
01754 ::apache::thrift::protocol::TType _vtype189;
01755 iprot->readMapBegin(_ktype188, _vtype189, _size187);
01756 uint32_t _i191;
01757 for (_i191 = 0; _i191 < _size187; ++_i191)
01758 {
01759 std::string _key192;
01760 xfer += iprot->readBinary(_key192);
01761 int32_t& _val193 = this->success[_key192];
01762 xfer += iprot->readI32(_val193);
01763 }
01764 iprot->readMapEnd();
01765 }
01766 this->__isset.success = true;
01767 } else {
01768 xfer += iprot->skip(ftype);
01769 }
01770 break;
01771 case 1:
01772 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
01773 xfer += this->ire.read(iprot);
01774 this->__isset.ire = true;
01775 } else {
01776 xfer += iprot->skip(ftype);
01777 }
01778 break;
01779 case 2:
01780 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
01781 xfer += this->ue.read(iprot);
01782 this->__isset.ue = true;
01783 } else {
01784 xfer += iprot->skip(ftype);
01785 }
01786 break;
01787 case 3:
01788 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
01789 xfer += this->te.read(iprot);
01790 this->__isset.te = true;
01791 } else {
01792 xfer += iprot->skip(ftype);
01793 }
01794 break;
01795 default:
01796 xfer += iprot->skip(ftype);
01797 break;
01798 }
01799 xfer += iprot->readFieldEnd();
01800 }
01801
01802 xfer += iprot->readStructEnd();
01803
01804 return xfer;
01805 }
01806
01807 uint32_t Cassandra_multiget_count_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
01808
01809 uint32_t xfer = 0;
01810
01811 xfer += oprot->writeStructBegin("Cassandra_multiget_count_result");
01812
01813 if (this->__isset.success) {
01814 xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_MAP, 0);
01815 {
01816 xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_I32, this->success.size());
01817 std::map<std::string, int32_t> ::const_iterator _iter194;
01818 for (_iter194 = this->success.begin(); _iter194 != this->success.end(); ++_iter194)
01819 {
01820 xfer += oprot->writeBinary(_iter194->first);
01821 xfer += oprot->writeI32(_iter194->second);
01822 }
01823 xfer += oprot->writeMapEnd();
01824 }
01825 xfer += oprot->writeFieldEnd();
01826 } else if (this->__isset.ire) {
01827 xfer += oprot->writeFieldBegin("ire", ::apache::thrift::protocol::T_STRUCT, 1);
01828 xfer += this->ire.write(oprot);
01829 xfer += oprot->writeFieldEnd();
01830 } else if (this->__isset.ue) {
01831 xfer += oprot->writeFieldBegin("ue", ::apache::thrift::protocol::T_STRUCT, 2);
01832 xfer += this->ue.write(oprot);
01833 xfer += oprot->writeFieldEnd();
01834 } else if (this->__isset.te) {
01835 xfer += oprot->writeFieldBegin("te", ::apache::thrift::protocol::T_STRUCT, 3);
01836 xfer += this->te.write(oprot);
01837 xfer += oprot->writeFieldEnd();
01838 }
01839 xfer += oprot->writeFieldStop();
01840 xfer += oprot->writeStructEnd();
01841 return xfer;
01842 }
01843
01844 uint32_t Cassandra_multiget_count_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
01845
01846 uint32_t xfer = 0;
01847 std::string fname;
01848 ::apache::thrift::protocol::TType ftype;
01849 int16_t fid;
01850
01851 xfer += iprot->readStructBegin(fname);
01852
01853 using ::apache::thrift::protocol::TProtocolException;
01854
01855
01856 while (true)
01857 {
01858 xfer += iprot->readFieldBegin(fname, ftype, fid);
01859 if (ftype == ::apache::thrift::protocol::T_STOP) {
01860 break;
01861 }
01862 switch (fid)
01863 {
01864 case 0:
01865 if (ftype == ::apache::thrift::protocol::T_MAP) {
01866 {
01867 (*(this->success)).clear();
01868 uint32_t _size195;
01869 ::apache::thrift::protocol::TType _ktype196;
01870 ::apache::thrift::protocol::TType _vtype197;
01871 iprot->readMapBegin(_ktype196, _vtype197, _size195);
01872 uint32_t _i199;
01873 for (_i199 = 0; _i199 < _size195; ++_i199)
01874 {
01875 std::string _key200;
01876 xfer += iprot->readBinary(_key200);
01877 int32_t& _val201 = (*(this->success))[_key200];
01878 xfer += iprot->readI32(_val201);
01879 }
01880 iprot->readMapEnd();
01881 }
01882 this->__isset.success = true;
01883 } else {
01884 xfer += iprot->skip(ftype);
01885 }
01886 break;
01887 case 1:
01888 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
01889 xfer += this->ire.read(iprot);
01890 this->__isset.ire = true;
01891 } else {
01892 xfer += iprot->skip(ftype);
01893 }
01894 break;
01895 case 2:
01896 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
01897 xfer += this->ue.read(iprot);
01898 this->__isset.ue = true;
01899 } else {
01900 xfer += iprot->skip(ftype);
01901 }
01902 break;
01903 case 3:
01904 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
01905 xfer += this->te.read(iprot);
01906 this->__isset.te = true;
01907 } else {
01908 xfer += iprot->skip(ftype);
01909 }
01910 break;
01911 default:
01912 xfer += iprot->skip(ftype);
01913 break;
01914 }
01915 xfer += iprot->readFieldEnd();
01916 }
01917
01918 xfer += iprot->readStructEnd();
01919
01920 return xfer;
01921 }
01922
01923 uint32_t Cassandra_get_range_slices_args::read(::apache::thrift::protocol::TProtocol* iprot) {
01924
01925 uint32_t xfer = 0;
01926 std::string fname;
01927 ::apache::thrift::protocol::TType ftype;
01928 int16_t fid;
01929
01930 xfer += iprot->readStructBegin(fname);
01931
01932 using ::apache::thrift::protocol::TProtocolException;
01933
01934 bool isset_column_parent = false;
01935 bool isset_predicate = false;
01936 bool isset_range = false;
01937 bool isset_consistency_level = false;
01938
01939 while (true)
01940 {
01941 xfer += iprot->readFieldBegin(fname, ftype, fid);
01942 if (ftype == ::apache::thrift::protocol::T_STOP) {
01943 break;
01944 }
01945 switch (fid)
01946 {
01947 case 1:
01948 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
01949 xfer += this->column_parent.read(iprot);
01950 isset_column_parent = true;
01951 } else {
01952 xfer += iprot->skip(ftype);
01953 }
01954 break;
01955 case 2:
01956 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
01957 xfer += this->predicate.read(iprot);
01958 isset_predicate = true;
01959 } else {
01960 xfer += iprot->skip(ftype);
01961 }
01962 break;
01963 case 3:
01964 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
01965 xfer += this->range.read(iprot);
01966 isset_range = true;
01967 } else {
01968 xfer += iprot->skip(ftype);
01969 }
01970 break;
01971 case 4:
01972 if (ftype == ::apache::thrift::protocol::T_I32) {
01973 int32_t ecast202;
01974 xfer += iprot->readI32(ecast202);
01975 this->consistency_level = (ConsistencyLevel::type)ecast202;
01976 isset_consistency_level = true;
01977 } else {
01978 xfer += iprot->skip(ftype);
01979 }
01980 break;
01981 default:
01982 xfer += iprot->skip(ftype);
01983 break;
01984 }
01985 xfer += iprot->readFieldEnd();
01986 }
01987
01988 xfer += iprot->readStructEnd();
01989
01990 if (!isset_column_parent)
01991 throw TProtocolException(TProtocolException::INVALID_DATA);
01992 if (!isset_predicate)
01993 throw TProtocolException(TProtocolException::INVALID_DATA);
01994 if (!isset_range)
01995 throw TProtocolException(TProtocolException::INVALID_DATA);
01996 if (!isset_consistency_level)
01997 throw TProtocolException(TProtocolException::INVALID_DATA);
01998 return xfer;
01999 }
02000
02001 uint32_t Cassandra_get_range_slices_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
02002 uint32_t xfer = 0;
02003 xfer += oprot->writeStructBegin("Cassandra_get_range_slices_args");
02004 xfer += oprot->writeFieldBegin("column_parent", ::apache::thrift::protocol::T_STRUCT, 1);
02005 xfer += this->column_parent.write(oprot);
02006 xfer += oprot->writeFieldEnd();
02007 xfer += oprot->writeFieldBegin("predicate", ::apache::thrift::protocol::T_STRUCT, 2);
02008 xfer += this->predicate.write(oprot);
02009 xfer += oprot->writeFieldEnd();
02010 xfer += oprot->writeFieldBegin("range", ::apache::thrift::protocol::T_STRUCT, 3);
02011 xfer += this->range.write(oprot);
02012 xfer += oprot->writeFieldEnd();
02013 xfer += oprot->writeFieldBegin("consistency_level", ::apache::thrift::protocol::T_I32, 4);
02014 xfer += oprot->writeI32((int32_t)this->consistency_level);
02015 xfer += oprot->writeFieldEnd();
02016 xfer += oprot->writeFieldStop();
02017 xfer += oprot->writeStructEnd();
02018 return xfer;
02019 }
02020
02021 uint32_t Cassandra_get_range_slices_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
02022 uint32_t xfer = 0;
02023 xfer += oprot->writeStructBegin("Cassandra_get_range_slices_pargs");
02024 xfer += oprot->writeFieldBegin("column_parent", ::apache::thrift::protocol::T_STRUCT, 1);
02025 xfer += (*(this->column_parent)).write(oprot);
02026 xfer += oprot->writeFieldEnd();
02027 xfer += oprot->writeFieldBegin("predicate", ::apache::thrift::protocol::T_STRUCT, 2);
02028 xfer += (*(this->predicate)).write(oprot);
02029 xfer += oprot->writeFieldEnd();
02030 xfer += oprot->writeFieldBegin("range", ::apache::thrift::protocol::T_STRUCT, 3);
02031 xfer += (*(this->range)).write(oprot);
02032 xfer += oprot->writeFieldEnd();
02033 xfer += oprot->writeFieldBegin("consistency_level", ::apache::thrift::protocol::T_I32, 4);
02034 xfer += oprot->writeI32((int32_t)(*(this->consistency_level)));
02035 xfer += oprot->writeFieldEnd();
02036 xfer += oprot->writeFieldStop();
02037 xfer += oprot->writeStructEnd();
02038 return xfer;
02039 }
02040
02041 uint32_t Cassandra_get_range_slices_result::read(::apache::thrift::protocol::TProtocol* iprot) {
02042
02043 uint32_t xfer = 0;
02044 std::string fname;
02045 ::apache::thrift::protocol::TType ftype;
02046 int16_t fid;
02047
02048 xfer += iprot->readStructBegin(fname);
02049
02050 using ::apache::thrift::protocol::TProtocolException;
02051
02052
02053 while (true)
02054 {
02055 xfer += iprot->readFieldBegin(fname, ftype, fid);
02056 if (ftype == ::apache::thrift::protocol::T_STOP) {
02057 break;
02058 }
02059 switch (fid)
02060 {
02061 case 0:
02062 if (ftype == ::apache::thrift::protocol::T_LIST) {
02063 {
02064 this->success.clear();
02065 uint32_t _size203;
02066 ::apache::thrift::protocol::TType _etype206;
02067 iprot->readListBegin(_etype206, _size203);
02068 this->success.resize(_size203);
02069 uint32_t _i207;
02070 for (_i207 = 0; _i207 < _size203; ++_i207)
02071 {
02072 xfer += this->success[_i207].read(iprot);
02073 }
02074 iprot->readListEnd();
02075 }
02076 this->__isset.success = true;
02077 } else {
02078 xfer += iprot->skip(ftype);
02079 }
02080 break;
02081 case 1:
02082 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
02083 xfer += this->ire.read(iprot);
02084 this->__isset.ire = true;
02085 } else {
02086 xfer += iprot->skip(ftype);
02087 }
02088 break;
02089 case 2:
02090 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
02091 xfer += this->ue.read(iprot);
02092 this->__isset.ue = true;
02093 } else {
02094 xfer += iprot->skip(ftype);
02095 }
02096 break;
02097 case 3:
02098 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
02099 xfer += this->te.read(iprot);
02100 this->__isset.te = true;
02101 } else {
02102 xfer += iprot->skip(ftype);
02103 }
02104 break;
02105 default:
02106 xfer += iprot->skip(ftype);
02107 break;
02108 }
02109 xfer += iprot->readFieldEnd();
02110 }
02111
02112 xfer += iprot->readStructEnd();
02113
02114 return xfer;
02115 }
02116
02117 uint32_t Cassandra_get_range_slices_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
02118
02119 uint32_t xfer = 0;
02120
02121 xfer += oprot->writeStructBegin("Cassandra_get_range_slices_result");
02122
02123 if (this->__isset.success) {
02124 xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0);
02125 {
02126 xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, this->success.size());
02127 std::vector<KeySlice> ::const_iterator _iter208;
02128 for (_iter208 = this->success.begin(); _iter208 != this->success.end(); ++_iter208)
02129 {
02130 xfer += (*_iter208).write(oprot);
02131 }
02132 xfer += oprot->writeListEnd();
02133 }
02134 xfer += oprot->writeFieldEnd();
02135 } else if (this->__isset.ire) {
02136 xfer += oprot->writeFieldBegin("ire", ::apache::thrift::protocol::T_STRUCT, 1);
02137 xfer += this->ire.write(oprot);
02138 xfer += oprot->writeFieldEnd();
02139 } else if (this->__isset.ue) {
02140 xfer += oprot->writeFieldBegin("ue", ::apache::thrift::protocol::T_STRUCT, 2);
02141 xfer += this->ue.write(oprot);
02142 xfer += oprot->writeFieldEnd();
02143 } else if (this->__isset.te) {
02144 xfer += oprot->writeFieldBegin("te", ::apache::thrift::protocol::T_STRUCT, 3);
02145 xfer += this->te.write(oprot);
02146 xfer += oprot->writeFieldEnd();
02147 }
02148 xfer += oprot->writeFieldStop();
02149 xfer += oprot->writeStructEnd();
02150 return xfer;
02151 }
02152
02153 uint32_t Cassandra_get_range_slices_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
02154
02155 uint32_t xfer = 0;
02156 std::string fname;
02157 ::apache::thrift::protocol::TType ftype;
02158 int16_t fid;
02159
02160 xfer += iprot->readStructBegin(fname);
02161
02162 using ::apache::thrift::protocol::TProtocolException;
02163
02164
02165 while (true)
02166 {
02167 xfer += iprot->readFieldBegin(fname, ftype, fid);
02168 if (ftype == ::apache::thrift::protocol::T_STOP) {
02169 break;
02170 }
02171 switch (fid)
02172 {
02173 case 0:
02174 if (ftype == ::apache::thrift::protocol::T_LIST) {
02175 {
02176 (*(this->success)).clear();
02177 uint32_t _size209;
02178 ::apache::thrift::protocol::TType _etype212;
02179 iprot->readListBegin(_etype212, _size209);
02180 (*(this->success)).resize(_size209);
02181 uint32_t _i213;
02182 for (_i213 = 0; _i213 < _size209; ++_i213)
02183 {
02184 xfer += (*(this->success))[_i213].read(iprot);
02185 }
02186 iprot->readListEnd();
02187 }
02188 this->__isset.success = true;
02189 } else {
02190 xfer += iprot->skip(ftype);
02191 }
02192 break;
02193 case 1:
02194 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
02195 xfer += this->ire.read(iprot);
02196 this->__isset.ire = true;
02197 } else {
02198 xfer += iprot->skip(ftype);
02199 }
02200 break;
02201 case 2:
02202 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
02203 xfer += this->ue.read(iprot);
02204 this->__isset.ue = true;
02205 } else {
02206 xfer += iprot->skip(ftype);
02207 }
02208 break;
02209 case 3:
02210 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
02211 xfer += this->te.read(iprot);
02212 this->__isset.te = true;
02213 } else {
02214 xfer += iprot->skip(ftype);
02215 }
02216 break;
02217 default:
02218 xfer += iprot->skip(ftype);
02219 break;
02220 }
02221 xfer += iprot->readFieldEnd();
02222 }
02223
02224 xfer += iprot->readStructEnd();
02225
02226 return xfer;
02227 }
02228
02229 uint32_t Cassandra_get_indexed_slices_args::read(::apache::thrift::protocol::TProtocol* iprot) {
02230
02231 uint32_t xfer = 0;
02232 std::string fname;
02233 ::apache::thrift::protocol::TType ftype;
02234 int16_t fid;
02235
02236 xfer += iprot->readStructBegin(fname);
02237
02238 using ::apache::thrift::protocol::TProtocolException;
02239
02240 bool isset_column_parent = false;
02241 bool isset_index_clause = false;
02242 bool isset_column_predicate = false;
02243 bool isset_consistency_level = false;
02244
02245 while (true)
02246 {
02247 xfer += iprot->readFieldBegin(fname, ftype, fid);
02248 if (ftype == ::apache::thrift::protocol::T_STOP) {
02249 break;
02250 }
02251 switch (fid)
02252 {
02253 case 1:
02254 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
02255 xfer += this->column_parent.read(iprot);
02256 isset_column_parent = true;
02257 } else {
02258 xfer += iprot->skip(ftype);
02259 }
02260 break;
02261 case 2:
02262 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
02263 xfer += this->index_clause.read(iprot);
02264 isset_index_clause = true;
02265 } else {
02266 xfer += iprot->skip(ftype);
02267 }
02268 break;
02269 case 3:
02270 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
02271 xfer += this->column_predicate.read(iprot);
02272 isset_column_predicate = true;
02273 } else {
02274 xfer += iprot->skip(ftype);
02275 }
02276 break;
02277 case 4:
02278 if (ftype == ::apache::thrift::protocol::T_I32) {
02279 int32_t ecast214;
02280 xfer += iprot->readI32(ecast214);
02281 this->consistency_level = (ConsistencyLevel::type)ecast214;
02282 isset_consistency_level = true;
02283 } else {
02284 xfer += iprot->skip(ftype);
02285 }
02286 break;
02287 default:
02288 xfer += iprot->skip(ftype);
02289 break;
02290 }
02291 xfer += iprot->readFieldEnd();
02292 }
02293
02294 xfer += iprot->readStructEnd();
02295
02296 if (!isset_column_parent)
02297 throw TProtocolException(TProtocolException::INVALID_DATA);
02298 if (!isset_index_clause)
02299 throw TProtocolException(TProtocolException::INVALID_DATA);
02300 if (!isset_column_predicate)
02301 throw TProtocolException(TProtocolException::INVALID_DATA);
02302 if (!isset_consistency_level)
02303 throw TProtocolException(TProtocolException::INVALID_DATA);
02304 return xfer;
02305 }
02306
02307 uint32_t Cassandra_get_indexed_slices_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
02308 uint32_t xfer = 0;
02309 xfer += oprot->writeStructBegin("Cassandra_get_indexed_slices_args");
02310 xfer += oprot->writeFieldBegin("column_parent", ::apache::thrift::protocol::T_STRUCT, 1);
02311 xfer += this->column_parent.write(oprot);
02312 xfer += oprot->writeFieldEnd();
02313 xfer += oprot->writeFieldBegin("index_clause", ::apache::thrift::protocol::T_STRUCT, 2);
02314 xfer += this->index_clause.write(oprot);
02315 xfer += oprot->writeFieldEnd();
02316 xfer += oprot->writeFieldBegin("column_predicate", ::apache::thrift::protocol::T_STRUCT, 3);
02317 xfer += this->column_predicate.write(oprot);
02318 xfer += oprot->writeFieldEnd();
02319 xfer += oprot->writeFieldBegin("consistency_level", ::apache::thrift::protocol::T_I32, 4);
02320 xfer += oprot->writeI32((int32_t)this->consistency_level);
02321 xfer += oprot->writeFieldEnd();
02322 xfer += oprot->writeFieldStop();
02323 xfer += oprot->writeStructEnd();
02324 return xfer;
02325 }
02326
02327 uint32_t Cassandra_get_indexed_slices_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
02328 uint32_t xfer = 0;
02329 xfer += oprot->writeStructBegin("Cassandra_get_indexed_slices_pargs");
02330 xfer += oprot->writeFieldBegin("column_parent", ::apache::thrift::protocol::T_STRUCT, 1);
02331 xfer += (*(this->column_parent)).write(oprot);
02332 xfer += oprot->writeFieldEnd();
02333 xfer += oprot->writeFieldBegin("index_clause", ::apache::thrift::protocol::T_STRUCT, 2);
02334 xfer += (*(this->index_clause)).write(oprot);
02335 xfer += oprot->writeFieldEnd();
02336 xfer += oprot->writeFieldBegin("column_predicate", ::apache::thrift::protocol::T_STRUCT, 3);
02337 xfer += (*(this->column_predicate)).write(oprot);
02338 xfer += oprot->writeFieldEnd();
02339 xfer += oprot->writeFieldBegin("consistency_level", ::apache::thrift::protocol::T_I32, 4);
02340 xfer += oprot->writeI32((int32_t)(*(this->consistency_level)));
02341 xfer += oprot->writeFieldEnd();
02342 xfer += oprot->writeFieldStop();
02343 xfer += oprot->writeStructEnd();
02344 return xfer;
02345 }
02346
02347 uint32_t Cassandra_get_indexed_slices_result::read(::apache::thrift::protocol::TProtocol* iprot) {
02348
02349 uint32_t xfer = 0;
02350 std::string fname;
02351 ::apache::thrift::protocol::TType ftype;
02352 int16_t fid;
02353
02354 xfer += iprot->readStructBegin(fname);
02355
02356 using ::apache::thrift::protocol::TProtocolException;
02357
02358
02359 while (true)
02360 {
02361 xfer += iprot->readFieldBegin(fname, ftype, fid);
02362 if (ftype == ::apache::thrift::protocol::T_STOP) {
02363 break;
02364 }
02365 switch (fid)
02366 {
02367 case 0:
02368 if (ftype == ::apache::thrift::protocol::T_LIST) {
02369 {
02370 this->success.clear();
02371 uint32_t _size215;
02372 ::apache::thrift::protocol::TType _etype218;
02373 iprot->readListBegin(_etype218, _size215);
02374 this->success.resize(_size215);
02375 uint32_t _i219;
02376 for (_i219 = 0; _i219 < _size215; ++_i219)
02377 {
02378 xfer += this->success[_i219].read(iprot);
02379 }
02380 iprot->readListEnd();
02381 }
02382 this->__isset.success = true;
02383 } else {
02384 xfer += iprot->skip(ftype);
02385 }
02386 break;
02387 case 1:
02388 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
02389 xfer += this->ire.read(iprot);
02390 this->__isset.ire = true;
02391 } else {
02392 xfer += iprot->skip(ftype);
02393 }
02394 break;
02395 case 2:
02396 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
02397 xfer += this->ue.read(iprot);
02398 this->__isset.ue = true;
02399 } else {
02400 xfer += iprot->skip(ftype);
02401 }
02402 break;
02403 case 3:
02404 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
02405 xfer += this->te.read(iprot);
02406 this->__isset.te = true;
02407 } else {
02408 xfer += iprot->skip(ftype);
02409 }
02410 break;
02411 default:
02412 xfer += iprot->skip(ftype);
02413 break;
02414 }
02415 xfer += iprot->readFieldEnd();
02416 }
02417
02418 xfer += iprot->readStructEnd();
02419
02420 return xfer;
02421 }
02422
02423 uint32_t Cassandra_get_indexed_slices_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
02424
02425 uint32_t xfer = 0;
02426
02427 xfer += oprot->writeStructBegin("Cassandra_get_indexed_slices_result");
02428
02429 if (this->__isset.success) {
02430 xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0);
02431 {
02432 xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, this->success.size());
02433 std::vector<KeySlice> ::const_iterator _iter220;
02434 for (_iter220 = this->success.begin(); _iter220 != this->success.end(); ++_iter220)
02435 {
02436 xfer += (*_iter220).write(oprot);
02437 }
02438 xfer += oprot->writeListEnd();
02439 }
02440 xfer += oprot->writeFieldEnd();
02441 } else if (this->__isset.ire) {
02442 xfer += oprot->writeFieldBegin("ire", ::apache::thrift::protocol::T_STRUCT, 1);
02443 xfer += this->ire.write(oprot);
02444 xfer += oprot->writeFieldEnd();
02445 } else if (this->__isset.ue) {
02446 xfer += oprot->writeFieldBegin("ue", ::apache::thrift::protocol::T_STRUCT, 2);
02447 xfer += this->ue.write(oprot);
02448 xfer += oprot->writeFieldEnd();
02449 } else if (this->__isset.te) {
02450 xfer += oprot->writeFieldBegin("te", ::apache::thrift::protocol::T_STRUCT, 3);
02451 xfer += this->te.write(oprot);
02452 xfer += oprot->writeFieldEnd();
02453 }
02454 xfer += oprot->writeFieldStop();
02455 xfer += oprot->writeStructEnd();
02456 return xfer;
02457 }
02458
02459 uint32_t Cassandra_get_indexed_slices_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
02460
02461 uint32_t xfer = 0;
02462 std::string fname;
02463 ::apache::thrift::protocol::TType ftype;
02464 int16_t fid;
02465
02466 xfer += iprot->readStructBegin(fname);
02467
02468 using ::apache::thrift::protocol::TProtocolException;
02469
02470
02471 while (true)
02472 {
02473 xfer += iprot->readFieldBegin(fname, ftype, fid);
02474 if (ftype == ::apache::thrift::protocol::T_STOP) {
02475 break;
02476 }
02477 switch (fid)
02478 {
02479 case 0:
02480 if (ftype == ::apache::thrift::protocol::T_LIST) {
02481 {
02482 (*(this->success)).clear();
02483 uint32_t _size221;
02484 ::apache::thrift::protocol::TType _etype224;
02485 iprot->readListBegin(_etype224, _size221);
02486 (*(this->success)).resize(_size221);
02487 uint32_t _i225;
02488 for (_i225 = 0; _i225 < _size221; ++_i225)
02489 {
02490 xfer += (*(this->success))[_i225].read(iprot);
02491 }
02492 iprot->readListEnd();
02493 }
02494 this->__isset.success = true;
02495 } else {
02496 xfer += iprot->skip(ftype);
02497 }
02498 break;
02499 case 1:
02500 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
02501 xfer += this->ire.read(iprot);
02502 this->__isset.ire = true;
02503 } else {
02504 xfer += iprot->skip(ftype);
02505 }
02506 break;
02507 case 2:
02508 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
02509 xfer += this->ue.read(iprot);
02510 this->__isset.ue = true;
02511 } else {
02512 xfer += iprot->skip(ftype);
02513 }
02514 break;
02515 case 3:
02516 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
02517 xfer += this->te.read(iprot);
02518 this->__isset.te = true;
02519 } else {
02520 xfer += iprot->skip(ftype);
02521 }
02522 break;
02523 default:
02524 xfer += iprot->skip(ftype);
02525 break;
02526 }
02527 xfer += iprot->readFieldEnd();
02528 }
02529
02530 xfer += iprot->readStructEnd();
02531
02532 return xfer;
02533 }
02534
02535 uint32_t Cassandra_insert_args::read(::apache::thrift::protocol::TProtocol* iprot) {
02536
02537 uint32_t xfer = 0;
02538 std::string fname;
02539 ::apache::thrift::protocol::TType ftype;
02540 int16_t fid;
02541
02542 xfer += iprot->readStructBegin(fname);
02543
02544 using ::apache::thrift::protocol::TProtocolException;
02545
02546 bool isset_key = false;
02547 bool isset_column_parent = false;
02548 bool isset_column = false;
02549 bool isset_consistency_level = false;
02550
02551 while (true)
02552 {
02553 xfer += iprot->readFieldBegin(fname, ftype, fid);
02554 if (ftype == ::apache::thrift::protocol::T_STOP) {
02555 break;
02556 }
02557 switch (fid)
02558 {
02559 case 1:
02560 if (ftype == ::apache::thrift::protocol::T_STRING) {
02561 xfer += iprot->readBinary(this->key);
02562 isset_key = true;
02563 } else {
02564 xfer += iprot->skip(ftype);
02565 }
02566 break;
02567 case 2:
02568 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
02569 xfer += this->column_parent.read(iprot);
02570 isset_column_parent = true;
02571 } else {
02572 xfer += iprot->skip(ftype);
02573 }
02574 break;
02575 case 3:
02576 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
02577 xfer += this->column.read(iprot);
02578 isset_column = true;
02579 } else {
02580 xfer += iprot->skip(ftype);
02581 }
02582 break;
02583 case 4:
02584 if (ftype == ::apache::thrift::protocol::T_I32) {
02585 int32_t ecast226;
02586 xfer += iprot->readI32(ecast226);
02587 this->consistency_level = (ConsistencyLevel::type)ecast226;
02588 isset_consistency_level = true;
02589 } else {
02590 xfer += iprot->skip(ftype);
02591 }
02592 break;
02593 default:
02594 xfer += iprot->skip(ftype);
02595 break;
02596 }
02597 xfer += iprot->readFieldEnd();
02598 }
02599
02600 xfer += iprot->readStructEnd();
02601
02602 if (!isset_key)
02603 throw TProtocolException(TProtocolException::INVALID_DATA);
02604 if (!isset_column_parent)
02605 throw TProtocolException(TProtocolException::INVALID_DATA);
02606 if (!isset_column)
02607 throw TProtocolException(TProtocolException::INVALID_DATA);
02608 if (!isset_consistency_level)
02609 throw TProtocolException(TProtocolException::INVALID_DATA);
02610 return xfer;
02611 }
02612
02613 uint32_t Cassandra_insert_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
02614 uint32_t xfer = 0;
02615 xfer += oprot->writeStructBegin("Cassandra_insert_args");
02616 xfer += oprot->writeFieldBegin("key", ::apache::thrift::protocol::T_STRING, 1);
02617 xfer += oprot->writeBinary(this->key);
02618 xfer += oprot->writeFieldEnd();
02619 xfer += oprot->writeFieldBegin("column_parent", ::apache::thrift::protocol::T_STRUCT, 2);
02620 xfer += this->column_parent.write(oprot);
02621 xfer += oprot->writeFieldEnd();
02622 xfer += oprot->writeFieldBegin("column", ::apache::thrift::protocol::T_STRUCT, 3);
02623 xfer += this->column.write(oprot);
02624 xfer += oprot->writeFieldEnd();
02625 xfer += oprot->writeFieldBegin("consistency_level", ::apache::thrift::protocol::T_I32, 4);
02626 xfer += oprot->writeI32((int32_t)this->consistency_level);
02627 xfer += oprot->writeFieldEnd();
02628 xfer += oprot->writeFieldStop();
02629 xfer += oprot->writeStructEnd();
02630 return xfer;
02631 }
02632
02633 uint32_t Cassandra_insert_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
02634 uint32_t xfer = 0;
02635 xfer += oprot->writeStructBegin("Cassandra_insert_pargs");
02636 xfer += oprot->writeFieldBegin("key", ::apache::thrift::protocol::T_STRING, 1);
02637 xfer += oprot->writeBinary((*(this->key)));
02638 xfer += oprot->writeFieldEnd();
02639 xfer += oprot->writeFieldBegin("column_parent", ::apache::thrift::protocol::T_STRUCT, 2);
02640 xfer += (*(this->column_parent)).write(oprot);
02641 xfer += oprot->writeFieldEnd();
02642 xfer += oprot->writeFieldBegin("column", ::apache::thrift::protocol::T_STRUCT, 3);
02643 xfer += (*(this->column)).write(oprot);
02644 xfer += oprot->writeFieldEnd();
02645 xfer += oprot->writeFieldBegin("consistency_level", ::apache::thrift::protocol::T_I32, 4);
02646 xfer += oprot->writeI32((int32_t)(*(this->consistency_level)));
02647 xfer += oprot->writeFieldEnd();
02648 xfer += oprot->writeFieldStop();
02649 xfer += oprot->writeStructEnd();
02650 return xfer;
02651 }
02652
02653 uint32_t Cassandra_insert_result::read(::apache::thrift::protocol::TProtocol* iprot) {
02654
02655 uint32_t xfer = 0;
02656 std::string fname;
02657 ::apache::thrift::protocol::TType ftype;
02658 int16_t fid;
02659
02660 xfer += iprot->readStructBegin(fname);
02661
02662 using ::apache::thrift::protocol::TProtocolException;
02663
02664
02665 while (true)
02666 {
02667 xfer += iprot->readFieldBegin(fname, ftype, fid);
02668 if (ftype == ::apache::thrift::protocol::T_STOP) {
02669 break;
02670 }
02671 switch (fid)
02672 {
02673 case 1:
02674 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
02675 xfer += this->ire.read(iprot);
02676 this->__isset.ire = true;
02677 } else {
02678 xfer += iprot->skip(ftype);
02679 }
02680 break;
02681 case 2:
02682 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
02683 xfer += this->ue.read(iprot);
02684 this->__isset.ue = true;
02685 } else {
02686 xfer += iprot->skip(ftype);
02687 }
02688 break;
02689 case 3:
02690 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
02691 xfer += this->te.read(iprot);
02692 this->__isset.te = true;
02693 } else {
02694 xfer += iprot->skip(ftype);
02695 }
02696 break;
02697 default:
02698 xfer += iprot->skip(ftype);
02699 break;
02700 }
02701 xfer += iprot->readFieldEnd();
02702 }
02703
02704 xfer += iprot->readStructEnd();
02705
02706 return xfer;
02707 }
02708
02709 uint32_t Cassandra_insert_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
02710
02711 uint32_t xfer = 0;
02712
02713 xfer += oprot->writeStructBegin("Cassandra_insert_result");
02714
02715 if (this->__isset.ire) {
02716 xfer += oprot->writeFieldBegin("ire", ::apache::thrift::protocol::T_STRUCT, 1);
02717 xfer += this->ire.write(oprot);
02718 xfer += oprot->writeFieldEnd();
02719 } else if (this->__isset.ue) {
02720 xfer += oprot->writeFieldBegin("ue", ::apache::thrift::protocol::T_STRUCT, 2);
02721 xfer += this->ue.write(oprot);
02722 xfer += oprot->writeFieldEnd();
02723 } else if (this->__isset.te) {
02724 xfer += oprot->writeFieldBegin("te", ::apache::thrift::protocol::T_STRUCT, 3);
02725 xfer += this->te.write(oprot);
02726 xfer += oprot->writeFieldEnd();
02727 }
02728 xfer += oprot->writeFieldStop();
02729 xfer += oprot->writeStructEnd();
02730 return xfer;
02731 }
02732
02733 uint32_t Cassandra_insert_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
02734
02735 uint32_t xfer = 0;
02736 std::string fname;
02737 ::apache::thrift::protocol::TType ftype;
02738 int16_t fid;
02739
02740 xfer += iprot->readStructBegin(fname);
02741
02742 using ::apache::thrift::protocol::TProtocolException;
02743
02744
02745 while (true)
02746 {
02747 xfer += iprot->readFieldBegin(fname, ftype, fid);
02748 if (ftype == ::apache::thrift::protocol::T_STOP) {
02749 break;
02750 }
02751 switch (fid)
02752 {
02753 case 1:
02754 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
02755 xfer += this->ire.read(iprot);
02756 this->__isset.ire = true;
02757 } else {
02758 xfer += iprot->skip(ftype);
02759 }
02760 break;
02761 case 2:
02762 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
02763 xfer += this->ue.read(iprot);
02764 this->__isset.ue = true;
02765 } else {
02766 xfer += iprot->skip(ftype);
02767 }
02768 break;
02769 case 3:
02770 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
02771 xfer += this->te.read(iprot);
02772 this->__isset.te = true;
02773 } else {
02774 xfer += iprot->skip(ftype);
02775 }
02776 break;
02777 default:
02778 xfer += iprot->skip(ftype);
02779 break;
02780 }
02781 xfer += iprot->readFieldEnd();
02782 }
02783
02784 xfer += iprot->readStructEnd();
02785
02786 return xfer;
02787 }
02788
02789 uint32_t Cassandra_add_args::read(::apache::thrift::protocol::TProtocol* iprot) {
02790
02791 uint32_t xfer = 0;
02792 std::string fname;
02793 ::apache::thrift::protocol::TType ftype;
02794 int16_t fid;
02795
02796 xfer += iprot->readStructBegin(fname);
02797
02798 using ::apache::thrift::protocol::TProtocolException;
02799
02800 bool isset_key = false;
02801 bool isset_column_parent = false;
02802 bool isset_column = false;
02803 bool isset_consistency_level = false;
02804
02805 while (true)
02806 {
02807 xfer += iprot->readFieldBegin(fname, ftype, fid);
02808 if (ftype == ::apache::thrift::protocol::T_STOP) {
02809 break;
02810 }
02811 switch (fid)
02812 {
02813 case 1:
02814 if (ftype == ::apache::thrift::protocol::T_STRING) {
02815 xfer += iprot->readBinary(this->key);
02816 isset_key = true;
02817 } else {
02818 xfer += iprot->skip(ftype);
02819 }
02820 break;
02821 case 2:
02822 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
02823 xfer += this->column_parent.read(iprot);
02824 isset_column_parent = true;
02825 } else {
02826 xfer += iprot->skip(ftype);
02827 }
02828 break;
02829 case 3:
02830 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
02831 xfer += this->column.read(iprot);
02832 isset_column = true;
02833 } else {
02834 xfer += iprot->skip(ftype);
02835 }
02836 break;
02837 case 4:
02838 if (ftype == ::apache::thrift::protocol::T_I32) {
02839 int32_t ecast227;
02840 xfer += iprot->readI32(ecast227);
02841 this->consistency_level = (ConsistencyLevel::type)ecast227;
02842 isset_consistency_level = true;
02843 } else {
02844 xfer += iprot->skip(ftype);
02845 }
02846 break;
02847 default:
02848 xfer += iprot->skip(ftype);
02849 break;
02850 }
02851 xfer += iprot->readFieldEnd();
02852 }
02853
02854 xfer += iprot->readStructEnd();
02855
02856 if (!isset_key)
02857 throw TProtocolException(TProtocolException::INVALID_DATA);
02858 if (!isset_column_parent)
02859 throw TProtocolException(TProtocolException::INVALID_DATA);
02860 if (!isset_column)
02861 throw TProtocolException(TProtocolException::INVALID_DATA);
02862 if (!isset_consistency_level)
02863 throw TProtocolException(TProtocolException::INVALID_DATA);
02864 return xfer;
02865 }
02866
02867 uint32_t Cassandra_add_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
02868 uint32_t xfer = 0;
02869 xfer += oprot->writeStructBegin("Cassandra_add_args");
02870 xfer += oprot->writeFieldBegin("key", ::apache::thrift::protocol::T_STRING, 1);
02871 xfer += oprot->writeBinary(this->key);
02872 xfer += oprot->writeFieldEnd();
02873 xfer += oprot->writeFieldBegin("column_parent", ::apache::thrift::protocol::T_STRUCT, 2);
02874 xfer += this->column_parent.write(oprot);
02875 xfer += oprot->writeFieldEnd();
02876 xfer += oprot->writeFieldBegin("column", ::apache::thrift::protocol::T_STRUCT, 3);
02877 xfer += this->column.write(oprot);
02878 xfer += oprot->writeFieldEnd();
02879 xfer += oprot->writeFieldBegin("consistency_level", ::apache::thrift::protocol::T_I32, 4);
02880 xfer += oprot->writeI32((int32_t)this->consistency_level);
02881 xfer += oprot->writeFieldEnd();
02882 xfer += oprot->writeFieldStop();
02883 xfer += oprot->writeStructEnd();
02884 return xfer;
02885 }
02886
02887 uint32_t Cassandra_add_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
02888 uint32_t xfer = 0;
02889 xfer += oprot->writeStructBegin("Cassandra_add_pargs");
02890 xfer += oprot->writeFieldBegin("key", ::apache::thrift::protocol::T_STRING, 1);
02891 xfer += oprot->writeBinary((*(this->key)));
02892 xfer += oprot->writeFieldEnd();
02893 xfer += oprot->writeFieldBegin("column_parent", ::apache::thrift::protocol::T_STRUCT, 2);
02894 xfer += (*(this->column_parent)).write(oprot);
02895 xfer += oprot->writeFieldEnd();
02896 xfer += oprot->writeFieldBegin("column", ::apache::thrift::protocol::T_STRUCT, 3);
02897 xfer += (*(this->column)).write(oprot);
02898 xfer += oprot->writeFieldEnd();
02899 xfer += oprot->writeFieldBegin("consistency_level", ::apache::thrift::protocol::T_I32, 4);
02900 xfer += oprot->writeI32((int32_t)(*(this->consistency_level)));
02901 xfer += oprot->writeFieldEnd();
02902 xfer += oprot->writeFieldStop();
02903 xfer += oprot->writeStructEnd();
02904 return xfer;
02905 }
02906
02907 uint32_t Cassandra_add_result::read(::apache::thrift::protocol::TProtocol* iprot) {
02908
02909 uint32_t xfer = 0;
02910 std::string fname;
02911 ::apache::thrift::protocol::TType ftype;
02912 int16_t fid;
02913
02914 xfer += iprot->readStructBegin(fname);
02915
02916 using ::apache::thrift::protocol::TProtocolException;
02917
02918
02919 while (true)
02920 {
02921 xfer += iprot->readFieldBegin(fname, ftype, fid);
02922 if (ftype == ::apache::thrift::protocol::T_STOP) {
02923 break;
02924 }
02925 switch (fid)
02926 {
02927 case 1:
02928 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
02929 xfer += this->ire.read(iprot);
02930 this->__isset.ire = true;
02931 } else {
02932 xfer += iprot->skip(ftype);
02933 }
02934 break;
02935 case 2:
02936 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
02937 xfer += this->ue.read(iprot);
02938 this->__isset.ue = true;
02939 } else {
02940 xfer += iprot->skip(ftype);
02941 }
02942 break;
02943 case 3:
02944 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
02945 xfer += this->te.read(iprot);
02946 this->__isset.te = true;
02947 } else {
02948 xfer += iprot->skip(ftype);
02949 }
02950 break;
02951 default:
02952 xfer += iprot->skip(ftype);
02953 break;
02954 }
02955 xfer += iprot->readFieldEnd();
02956 }
02957
02958 xfer += iprot->readStructEnd();
02959
02960 return xfer;
02961 }
02962
02963 uint32_t Cassandra_add_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
02964
02965 uint32_t xfer = 0;
02966
02967 xfer += oprot->writeStructBegin("Cassandra_add_result");
02968
02969 if (this->__isset.ire) {
02970 xfer += oprot->writeFieldBegin("ire", ::apache::thrift::protocol::T_STRUCT, 1);
02971 xfer += this->ire.write(oprot);
02972 xfer += oprot->writeFieldEnd();
02973 } else if (this->__isset.ue) {
02974 xfer += oprot->writeFieldBegin("ue", ::apache::thrift::protocol::T_STRUCT, 2);
02975 xfer += this->ue.write(oprot);
02976 xfer += oprot->writeFieldEnd();
02977 } else if (this->__isset.te) {
02978 xfer += oprot->writeFieldBegin("te", ::apache::thrift::protocol::T_STRUCT, 3);
02979 xfer += this->te.write(oprot);
02980 xfer += oprot->writeFieldEnd();
02981 }
02982 xfer += oprot->writeFieldStop();
02983 xfer += oprot->writeStructEnd();
02984 return xfer;
02985 }
02986
02987 uint32_t Cassandra_add_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
02988
02989 uint32_t xfer = 0;
02990 std::string fname;
02991 ::apache::thrift::protocol::TType ftype;
02992 int16_t fid;
02993
02994 xfer += iprot->readStructBegin(fname);
02995
02996 using ::apache::thrift::protocol::TProtocolException;
02997
02998
02999 while (true)
03000 {
03001 xfer += iprot->readFieldBegin(fname, ftype, fid);
03002 if (ftype == ::apache::thrift::protocol::T_STOP) {
03003 break;
03004 }
03005 switch (fid)
03006 {
03007 case 1:
03008 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
03009 xfer += this->ire.read(iprot);
03010 this->__isset.ire = true;
03011 } else {
03012 xfer += iprot->skip(ftype);
03013 }
03014 break;
03015 case 2:
03016 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
03017 xfer += this->ue.read(iprot);
03018 this->__isset.ue = true;
03019 } else {
03020 xfer += iprot->skip(ftype);
03021 }
03022 break;
03023 case 3:
03024 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
03025 xfer += this->te.read(iprot);
03026 this->__isset.te = true;
03027 } else {
03028 xfer += iprot->skip(ftype);
03029 }
03030 break;
03031 default:
03032 xfer += iprot->skip(ftype);
03033 break;
03034 }
03035 xfer += iprot->readFieldEnd();
03036 }
03037
03038 xfer += iprot->readStructEnd();
03039
03040 return xfer;
03041 }
03042
03043 uint32_t Cassandra_remove_args::read(::apache::thrift::protocol::TProtocol* iprot) {
03044
03045 uint32_t xfer = 0;
03046 std::string fname;
03047 ::apache::thrift::protocol::TType ftype;
03048 int16_t fid;
03049
03050 xfer += iprot->readStructBegin(fname);
03051
03052 using ::apache::thrift::protocol::TProtocolException;
03053
03054 bool isset_key = false;
03055 bool isset_column_path = false;
03056 bool isset_timestamp = false;
03057
03058 while (true)
03059 {
03060 xfer += iprot->readFieldBegin(fname, ftype, fid);
03061 if (ftype == ::apache::thrift::protocol::T_STOP) {
03062 break;
03063 }
03064 switch (fid)
03065 {
03066 case 1:
03067 if (ftype == ::apache::thrift::protocol::T_STRING) {
03068 xfer += iprot->readBinary(this->key);
03069 isset_key = true;
03070 } else {
03071 xfer += iprot->skip(ftype);
03072 }
03073 break;
03074 case 2:
03075 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
03076 xfer += this->column_path.read(iprot);
03077 isset_column_path = true;
03078 } else {
03079 xfer += iprot->skip(ftype);
03080 }
03081 break;
03082 case 3:
03083 if (ftype == ::apache::thrift::protocol::T_I64) {
03084 xfer += iprot->readI64(this->timestamp);
03085 isset_timestamp = true;
03086 } else {
03087 xfer += iprot->skip(ftype);
03088 }
03089 break;
03090 case 4:
03091 if (ftype == ::apache::thrift::protocol::T_I32) {
03092 int32_t ecast228;
03093 xfer += iprot->readI32(ecast228);
03094 this->consistency_level = (ConsistencyLevel::type)ecast228;
03095 this->__isset.consistency_level = true;
03096 } else {
03097 xfer += iprot->skip(ftype);
03098 }
03099 break;
03100 default:
03101 xfer += iprot->skip(ftype);
03102 break;
03103 }
03104 xfer += iprot->readFieldEnd();
03105 }
03106
03107 xfer += iprot->readStructEnd();
03108
03109 if (!isset_key)
03110 throw TProtocolException(TProtocolException::INVALID_DATA);
03111 if (!isset_column_path)
03112 throw TProtocolException(TProtocolException::INVALID_DATA);
03113 if (!isset_timestamp)
03114 throw TProtocolException(TProtocolException::INVALID_DATA);
03115 return xfer;
03116 }
03117
03118 uint32_t Cassandra_remove_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
03119 uint32_t xfer = 0;
03120 xfer += oprot->writeStructBegin("Cassandra_remove_args");
03121 xfer += oprot->writeFieldBegin("key", ::apache::thrift::protocol::T_STRING, 1);
03122 xfer += oprot->writeBinary(this->key);
03123 xfer += oprot->writeFieldEnd();
03124 xfer += oprot->writeFieldBegin("column_path", ::apache::thrift::protocol::T_STRUCT, 2);
03125 xfer += this->column_path.write(oprot);
03126 xfer += oprot->writeFieldEnd();
03127 xfer += oprot->writeFieldBegin("timestamp", ::apache::thrift::protocol::T_I64, 3);
03128 xfer += oprot->writeI64(this->timestamp);
03129 xfer += oprot->writeFieldEnd();
03130 xfer += oprot->writeFieldBegin("consistency_level", ::apache::thrift::protocol::T_I32, 4);
03131 xfer += oprot->writeI32((int32_t)this->consistency_level);
03132 xfer += oprot->writeFieldEnd();
03133 xfer += oprot->writeFieldStop();
03134 xfer += oprot->writeStructEnd();
03135 return xfer;
03136 }
03137
03138 uint32_t Cassandra_remove_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
03139 uint32_t xfer = 0;
03140 xfer += oprot->writeStructBegin("Cassandra_remove_pargs");
03141 xfer += oprot->writeFieldBegin("key", ::apache::thrift::protocol::T_STRING, 1);
03142 xfer += oprot->writeBinary((*(this->key)));
03143 xfer += oprot->writeFieldEnd();
03144 xfer += oprot->writeFieldBegin("column_path", ::apache::thrift::protocol::T_STRUCT, 2);
03145 xfer += (*(this->column_path)).write(oprot);
03146 xfer += oprot->writeFieldEnd();
03147 xfer += oprot->writeFieldBegin("timestamp", ::apache::thrift::protocol::T_I64, 3);
03148 xfer += oprot->writeI64((*(this->timestamp)));
03149 xfer += oprot->writeFieldEnd();
03150 xfer += oprot->writeFieldBegin("consistency_level", ::apache::thrift::protocol::T_I32, 4);
03151 xfer += oprot->writeI32((int32_t)(*(this->consistency_level)));
03152 xfer += oprot->writeFieldEnd();
03153 xfer += oprot->writeFieldStop();
03154 xfer += oprot->writeStructEnd();
03155 return xfer;
03156 }
03157
03158 uint32_t Cassandra_remove_result::read(::apache::thrift::protocol::TProtocol* iprot) {
03159
03160 uint32_t xfer = 0;
03161 std::string fname;
03162 ::apache::thrift::protocol::TType ftype;
03163 int16_t fid;
03164
03165 xfer += iprot->readStructBegin(fname);
03166
03167 using ::apache::thrift::protocol::TProtocolException;
03168
03169
03170 while (true)
03171 {
03172 xfer += iprot->readFieldBegin(fname, ftype, fid);
03173 if (ftype == ::apache::thrift::protocol::T_STOP) {
03174 break;
03175 }
03176 switch (fid)
03177 {
03178 case 1:
03179 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
03180 xfer += this->ire.read(iprot);
03181 this->__isset.ire = true;
03182 } else {
03183 xfer += iprot->skip(ftype);
03184 }
03185 break;
03186 case 2:
03187 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
03188 xfer += this->ue.read(iprot);
03189 this->__isset.ue = true;
03190 } else {
03191 xfer += iprot->skip(ftype);
03192 }
03193 break;
03194 case 3:
03195 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
03196 xfer += this->te.read(iprot);
03197 this->__isset.te = true;
03198 } else {
03199 xfer += iprot->skip(ftype);
03200 }
03201 break;
03202 default:
03203 xfer += iprot->skip(ftype);
03204 break;
03205 }
03206 xfer += iprot->readFieldEnd();
03207 }
03208
03209 xfer += iprot->readStructEnd();
03210
03211 return xfer;
03212 }
03213
03214 uint32_t Cassandra_remove_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
03215
03216 uint32_t xfer = 0;
03217
03218 xfer += oprot->writeStructBegin("Cassandra_remove_result");
03219
03220 if (this->__isset.ire) {
03221 xfer += oprot->writeFieldBegin("ire", ::apache::thrift::protocol::T_STRUCT, 1);
03222 xfer += this->ire.write(oprot);
03223 xfer += oprot->writeFieldEnd();
03224 } else if (this->__isset.ue) {
03225 xfer += oprot->writeFieldBegin("ue", ::apache::thrift::protocol::T_STRUCT, 2);
03226 xfer += this->ue.write(oprot);
03227 xfer += oprot->writeFieldEnd();
03228 } else if (this->__isset.te) {
03229 xfer += oprot->writeFieldBegin("te", ::apache::thrift::protocol::T_STRUCT, 3);
03230 xfer += this->te.write(oprot);
03231 xfer += oprot->writeFieldEnd();
03232 }
03233 xfer += oprot->writeFieldStop();
03234 xfer += oprot->writeStructEnd();
03235 return xfer;
03236 }
03237
03238 uint32_t Cassandra_remove_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
03239
03240 uint32_t xfer = 0;
03241 std::string fname;
03242 ::apache::thrift::protocol::TType ftype;
03243 int16_t fid;
03244
03245 xfer += iprot->readStructBegin(fname);
03246
03247 using ::apache::thrift::protocol::TProtocolException;
03248
03249
03250 while (true)
03251 {
03252 xfer += iprot->readFieldBegin(fname, ftype, fid);
03253 if (ftype == ::apache::thrift::protocol::T_STOP) {
03254 break;
03255 }
03256 switch (fid)
03257 {
03258 case 1:
03259 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
03260 xfer += this->ire.read(iprot);
03261 this->__isset.ire = true;
03262 } else {
03263 xfer += iprot->skip(ftype);
03264 }
03265 break;
03266 case 2:
03267 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
03268 xfer += this->ue.read(iprot);
03269 this->__isset.ue = true;
03270 } else {
03271 xfer += iprot->skip(ftype);
03272 }
03273 break;
03274 case 3:
03275 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
03276 xfer += this->te.read(iprot);
03277 this->__isset.te = true;
03278 } else {
03279 xfer += iprot->skip(ftype);
03280 }
03281 break;
03282 default:
03283 xfer += iprot->skip(ftype);
03284 break;
03285 }
03286 xfer += iprot->readFieldEnd();
03287 }
03288
03289 xfer += iprot->readStructEnd();
03290
03291 return xfer;
03292 }
03293
03294 uint32_t Cassandra_remove_counter_args::read(::apache::thrift::protocol::TProtocol* iprot) {
03295
03296 uint32_t xfer = 0;
03297 std::string fname;
03298 ::apache::thrift::protocol::TType ftype;
03299 int16_t fid;
03300
03301 xfer += iprot->readStructBegin(fname);
03302
03303 using ::apache::thrift::protocol::TProtocolException;
03304
03305 bool isset_key = false;
03306 bool isset_path = false;
03307 bool isset_consistency_level = false;
03308
03309 while (true)
03310 {
03311 xfer += iprot->readFieldBegin(fname, ftype, fid);
03312 if (ftype == ::apache::thrift::protocol::T_STOP) {
03313 break;
03314 }
03315 switch (fid)
03316 {
03317 case 1:
03318 if (ftype == ::apache::thrift::protocol::T_STRING) {
03319 xfer += iprot->readBinary(this->key);
03320 isset_key = true;
03321 } else {
03322 xfer += iprot->skip(ftype);
03323 }
03324 break;
03325 case 2:
03326 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
03327 xfer += this->path.read(iprot);
03328 isset_path = true;
03329 } else {
03330 xfer += iprot->skip(ftype);
03331 }
03332 break;
03333 case 3:
03334 if (ftype == ::apache::thrift::protocol::T_I32) {
03335 int32_t ecast229;
03336 xfer += iprot->readI32(ecast229);
03337 this->consistency_level = (ConsistencyLevel::type)ecast229;
03338 isset_consistency_level = true;
03339 } else {
03340 xfer += iprot->skip(ftype);
03341 }
03342 break;
03343 default:
03344 xfer += iprot->skip(ftype);
03345 break;
03346 }
03347 xfer += iprot->readFieldEnd();
03348 }
03349
03350 xfer += iprot->readStructEnd();
03351
03352 if (!isset_key)
03353 throw TProtocolException(TProtocolException::INVALID_DATA);
03354 if (!isset_path)
03355 throw TProtocolException(TProtocolException::INVALID_DATA);
03356 if (!isset_consistency_level)
03357 throw TProtocolException(TProtocolException::INVALID_DATA);
03358 return xfer;
03359 }
03360
03361 uint32_t Cassandra_remove_counter_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
03362 uint32_t xfer = 0;
03363 xfer += oprot->writeStructBegin("Cassandra_remove_counter_args");
03364 xfer += oprot->writeFieldBegin("key", ::apache::thrift::protocol::T_STRING, 1);
03365 xfer += oprot->writeBinary(this->key);
03366 xfer += oprot->writeFieldEnd();
03367 xfer += oprot->writeFieldBegin("path", ::apache::thrift::protocol::T_STRUCT, 2);
03368 xfer += this->path.write(oprot);
03369 xfer += oprot->writeFieldEnd();
03370 xfer += oprot->writeFieldBegin("consistency_level", ::apache::thrift::protocol::T_I32, 3);
03371 xfer += oprot->writeI32((int32_t)this->consistency_level);
03372 xfer += oprot->writeFieldEnd();
03373 xfer += oprot->writeFieldStop();
03374 xfer += oprot->writeStructEnd();
03375 return xfer;
03376 }
03377
03378 uint32_t Cassandra_remove_counter_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
03379 uint32_t xfer = 0;
03380 xfer += oprot->writeStructBegin("Cassandra_remove_counter_pargs");
03381 xfer += oprot->writeFieldBegin("key", ::apache::thrift::protocol::T_STRING, 1);
03382 xfer += oprot->writeBinary((*(this->key)));
03383 xfer += oprot->writeFieldEnd();
03384 xfer += oprot->writeFieldBegin("path", ::apache::thrift::protocol::T_STRUCT, 2);
03385 xfer += (*(this->path)).write(oprot);
03386 xfer += oprot->writeFieldEnd();
03387 xfer += oprot->writeFieldBegin("consistency_level", ::apache::thrift::protocol::T_I32, 3);
03388 xfer += oprot->writeI32((int32_t)(*(this->consistency_level)));
03389 xfer += oprot->writeFieldEnd();
03390 xfer += oprot->writeFieldStop();
03391 xfer += oprot->writeStructEnd();
03392 return xfer;
03393 }
03394
03395 uint32_t Cassandra_remove_counter_result::read(::apache::thrift::protocol::TProtocol* iprot) {
03396
03397 uint32_t xfer = 0;
03398 std::string fname;
03399 ::apache::thrift::protocol::TType ftype;
03400 int16_t fid;
03401
03402 xfer += iprot->readStructBegin(fname);
03403
03404 using ::apache::thrift::protocol::TProtocolException;
03405
03406
03407 while (true)
03408 {
03409 xfer += iprot->readFieldBegin(fname, ftype, fid);
03410 if (ftype == ::apache::thrift::protocol::T_STOP) {
03411 break;
03412 }
03413 switch (fid)
03414 {
03415 case 1:
03416 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
03417 xfer += this->ire.read(iprot);
03418 this->__isset.ire = true;
03419 } else {
03420 xfer += iprot->skip(ftype);
03421 }
03422 break;
03423 case 2:
03424 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
03425 xfer += this->ue.read(iprot);
03426 this->__isset.ue = true;
03427 } else {
03428 xfer += iprot->skip(ftype);
03429 }
03430 break;
03431 case 3:
03432 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
03433 xfer += this->te.read(iprot);
03434 this->__isset.te = true;
03435 } else {
03436 xfer += iprot->skip(ftype);
03437 }
03438 break;
03439 default:
03440 xfer += iprot->skip(ftype);
03441 break;
03442 }
03443 xfer += iprot->readFieldEnd();
03444 }
03445
03446 xfer += iprot->readStructEnd();
03447
03448 return xfer;
03449 }
03450
03451 uint32_t Cassandra_remove_counter_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
03452
03453 uint32_t xfer = 0;
03454
03455 xfer += oprot->writeStructBegin("Cassandra_remove_counter_result");
03456
03457 if (this->__isset.ire) {
03458 xfer += oprot->writeFieldBegin("ire", ::apache::thrift::protocol::T_STRUCT, 1);
03459 xfer += this->ire.write(oprot);
03460 xfer += oprot->writeFieldEnd();
03461 } else if (this->__isset.ue) {
03462 xfer += oprot->writeFieldBegin("ue", ::apache::thrift::protocol::T_STRUCT, 2);
03463 xfer += this->ue.write(oprot);
03464 xfer += oprot->writeFieldEnd();
03465 } else if (this->__isset.te) {
03466 xfer += oprot->writeFieldBegin("te", ::apache::thrift::protocol::T_STRUCT, 3);
03467 xfer += this->te.write(oprot);
03468 xfer += oprot->writeFieldEnd();
03469 }
03470 xfer += oprot->writeFieldStop();
03471 xfer += oprot->writeStructEnd();
03472 return xfer;
03473 }
03474
03475 uint32_t Cassandra_remove_counter_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
03476
03477 uint32_t xfer = 0;
03478 std::string fname;
03479 ::apache::thrift::protocol::TType ftype;
03480 int16_t fid;
03481
03482 xfer += iprot->readStructBegin(fname);
03483
03484 using ::apache::thrift::protocol::TProtocolException;
03485
03486
03487 while (true)
03488 {
03489 xfer += iprot->readFieldBegin(fname, ftype, fid);
03490 if (ftype == ::apache::thrift::protocol::T_STOP) {
03491 break;
03492 }
03493 switch (fid)
03494 {
03495 case 1:
03496 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
03497 xfer += this->ire.read(iprot);
03498 this->__isset.ire = true;
03499 } else {
03500 xfer += iprot->skip(ftype);
03501 }
03502 break;
03503 case 2:
03504 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
03505 xfer += this->ue.read(iprot);
03506 this->__isset.ue = true;
03507 } else {
03508 xfer += iprot->skip(ftype);
03509 }
03510 break;
03511 case 3:
03512 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
03513 xfer += this->te.read(iprot);
03514 this->__isset.te = true;
03515 } else {
03516 xfer += iprot->skip(ftype);
03517 }
03518 break;
03519 default:
03520 xfer += iprot->skip(ftype);
03521 break;
03522 }
03523 xfer += iprot->readFieldEnd();
03524 }
03525
03526 xfer += iprot->readStructEnd();
03527
03528 return xfer;
03529 }
03530
03531 uint32_t Cassandra_batch_mutate_args::read(::apache::thrift::protocol::TProtocol* iprot) {
03532
03533 uint32_t xfer = 0;
03534 std::string fname;
03535 ::apache::thrift::protocol::TType ftype;
03536 int16_t fid;
03537
03538 xfer += iprot->readStructBegin(fname);
03539
03540 using ::apache::thrift::protocol::TProtocolException;
03541
03542 bool isset_mutation_map = false;
03543 bool isset_consistency_level = false;
03544
03545 while (true)
03546 {
03547 xfer += iprot->readFieldBegin(fname, ftype, fid);
03548 if (ftype == ::apache::thrift::protocol::T_STOP) {
03549 break;
03550 }
03551 switch (fid)
03552 {
03553 case 1:
03554 if (ftype == ::apache::thrift::protocol::T_MAP) {
03555 {
03556 this->mutation_map.clear();
03557 uint32_t _size230;
03558 ::apache::thrift::protocol::TType _ktype231;
03559 ::apache::thrift::protocol::TType _vtype232;
03560 iprot->readMapBegin(_ktype231, _vtype232, _size230);
03561 uint32_t _i234;
03562 for (_i234 = 0; _i234 < _size230; ++_i234)
03563 {
03564 std::string _key235;
03565 xfer += iprot->readBinary(_key235);
03566 std::map<std::string, std::vector<Mutation> > & _val236 = this->mutation_map[_key235];
03567 {
03568 _val236.clear();
03569 uint32_t _size237;
03570 ::apache::thrift::protocol::TType _ktype238;
03571 ::apache::thrift::protocol::TType _vtype239;
03572 iprot->readMapBegin(_ktype238, _vtype239, _size237);
03573 uint32_t _i241;
03574 for (_i241 = 0; _i241 < _size237; ++_i241)
03575 {
03576 std::string _key242;
03577 xfer += iprot->readString(_key242);
03578 std::vector<Mutation> & _val243 = _val236[_key242];
03579 {
03580 _val243.clear();
03581 uint32_t _size244;
03582 ::apache::thrift::protocol::TType _etype247;
03583 iprot->readListBegin(_etype247, _size244);
03584 _val243.resize(_size244);
03585 uint32_t _i248;
03586 for (_i248 = 0; _i248 < _size244; ++_i248)
03587 {
03588 xfer += _val243[_i248].read(iprot);
03589 }
03590 iprot->readListEnd();
03591 }
03592 }
03593 iprot->readMapEnd();
03594 }
03595 }
03596 iprot->readMapEnd();
03597 }
03598 isset_mutation_map = true;
03599 } else {
03600 xfer += iprot->skip(ftype);
03601 }
03602 break;
03603 case 2:
03604 if (ftype == ::apache::thrift::protocol::T_I32) {
03605 int32_t ecast249;
03606 xfer += iprot->readI32(ecast249);
03607 this->consistency_level = (ConsistencyLevel::type)ecast249;
03608 isset_consistency_level = true;
03609 } else {
03610 xfer += iprot->skip(ftype);
03611 }
03612 break;
03613 default:
03614 xfer += iprot->skip(ftype);
03615 break;
03616 }
03617 xfer += iprot->readFieldEnd();
03618 }
03619
03620 xfer += iprot->readStructEnd();
03621
03622 if (!isset_mutation_map)
03623 throw TProtocolException(TProtocolException::INVALID_DATA);
03624 if (!isset_consistency_level)
03625 throw TProtocolException(TProtocolException::INVALID_DATA);
03626 return xfer;
03627 }
03628
03629 uint32_t Cassandra_batch_mutate_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
03630 uint32_t xfer = 0;
03631 xfer += oprot->writeStructBegin("Cassandra_batch_mutate_args");
03632 xfer += oprot->writeFieldBegin("mutation_map", ::apache::thrift::protocol::T_MAP, 1);
03633 {
03634 xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_MAP, this->mutation_map.size());
03635 std::map<std::string, std::map<std::string, std::vector<Mutation> > > ::const_iterator _iter250;
03636 for (_iter250 = this->mutation_map.begin(); _iter250 != this->mutation_map.end(); ++_iter250)
03637 {
03638 xfer += oprot->writeBinary(_iter250->first);
03639 {
03640 xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_LIST, _iter250->second.size());
03641 std::map<std::string, std::vector<Mutation> > ::const_iterator _iter251;
03642 for (_iter251 = _iter250->second.begin(); _iter251 != _iter250->second.end(); ++_iter251)
03643 {
03644 xfer += oprot->writeString(_iter251->first);
03645 {
03646 xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, _iter251->second.size());
03647 std::vector<Mutation> ::const_iterator _iter252;
03648 for (_iter252 = _iter251->second.begin(); _iter252 != _iter251->second.end(); ++_iter252)
03649 {
03650 xfer += (*_iter252).write(oprot);
03651 }
03652 xfer += oprot->writeListEnd();
03653 }
03654 }
03655 xfer += oprot->writeMapEnd();
03656 }
03657 }
03658 xfer += oprot->writeMapEnd();
03659 }
03660 xfer += oprot->writeFieldEnd();
03661 xfer += oprot->writeFieldBegin("consistency_level", ::apache::thrift::protocol::T_I32, 2);
03662 xfer += oprot->writeI32((int32_t)this->consistency_level);
03663 xfer += oprot->writeFieldEnd();
03664 xfer += oprot->writeFieldStop();
03665 xfer += oprot->writeStructEnd();
03666 return xfer;
03667 }
03668
03669 uint32_t Cassandra_batch_mutate_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
03670 uint32_t xfer = 0;
03671 xfer += oprot->writeStructBegin("Cassandra_batch_mutate_pargs");
03672 xfer += oprot->writeFieldBegin("mutation_map", ::apache::thrift::protocol::T_MAP, 1);
03673 {
03674 xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_MAP, (*(this->mutation_map)).size());
03675 std::map<std::string, std::map<std::string, std::vector<Mutation> > > ::const_iterator _iter253;
03676 for (_iter253 = (*(this->mutation_map)).begin(); _iter253 != (*(this->mutation_map)).end(); ++_iter253)
03677 {
03678 xfer += oprot->writeBinary(_iter253->first);
03679 {
03680 xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_LIST, _iter253->second.size());
03681 std::map<std::string, std::vector<Mutation> > ::const_iterator _iter254;
03682 for (_iter254 = _iter253->second.begin(); _iter254 != _iter253->second.end(); ++_iter254)
03683 {
03684 xfer += oprot->writeString(_iter254->first);
03685 {
03686 xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, _iter254->second.size());
03687 std::vector<Mutation> ::const_iterator _iter255;
03688 for (_iter255 = _iter254->second.begin(); _iter255 != _iter254->second.end(); ++_iter255)
03689 {
03690 xfer += (*_iter255).write(oprot);
03691 }
03692 xfer += oprot->writeListEnd();
03693 }
03694 }
03695 xfer += oprot->writeMapEnd();
03696 }
03697 }
03698 xfer += oprot->writeMapEnd();
03699 }
03700 xfer += oprot->writeFieldEnd();
03701 xfer += oprot->writeFieldBegin("consistency_level", ::apache::thrift::protocol::T_I32, 2);
03702 xfer += oprot->writeI32((int32_t)(*(this->consistency_level)));
03703 xfer += oprot->writeFieldEnd();
03704 xfer += oprot->writeFieldStop();
03705 xfer += oprot->writeStructEnd();
03706 return xfer;
03707 }
03708
03709 uint32_t Cassandra_batch_mutate_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 1:
03730 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
03731 xfer += this->ire.read(iprot);
03732 this->__isset.ire = true;
03733 } else {
03734 xfer += iprot->skip(ftype);
03735 }
03736 break;
03737 case 2:
03738 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
03739 xfer += this->ue.read(iprot);
03740 this->__isset.ue = true;
03741 } else {
03742 xfer += iprot->skip(ftype);
03743 }
03744 break;
03745 case 3:
03746 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
03747 xfer += this->te.read(iprot);
03748 this->__isset.te = true;
03749 } else {
03750 xfer += iprot->skip(ftype);
03751 }
03752 break;
03753 default:
03754 xfer += iprot->skip(ftype);
03755 break;
03756 }
03757 xfer += iprot->readFieldEnd();
03758 }
03759
03760 xfer += iprot->readStructEnd();
03761
03762 return xfer;
03763 }
03764
03765 uint32_t Cassandra_batch_mutate_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
03766
03767 uint32_t xfer = 0;
03768
03769 xfer += oprot->writeStructBegin("Cassandra_batch_mutate_result");
03770
03771 if (this->__isset.ire) {
03772 xfer += oprot->writeFieldBegin("ire", ::apache::thrift::protocol::T_STRUCT, 1);
03773 xfer += this->ire.write(oprot);
03774 xfer += oprot->writeFieldEnd();
03775 } else if (this->__isset.ue) {
03776 xfer += oprot->writeFieldBegin("ue", ::apache::thrift::protocol::T_STRUCT, 2);
03777 xfer += this->ue.write(oprot);
03778 xfer += oprot->writeFieldEnd();
03779 } else if (this->__isset.te) {
03780 xfer += oprot->writeFieldBegin("te", ::apache::thrift::protocol::T_STRUCT, 3);
03781 xfer += this->te.write(oprot);
03782 xfer += oprot->writeFieldEnd();
03783 }
03784 xfer += oprot->writeFieldStop();
03785 xfer += oprot->writeStructEnd();
03786 return xfer;
03787 }
03788
03789 uint32_t Cassandra_batch_mutate_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
03790
03791 uint32_t xfer = 0;
03792 std::string fname;
03793 ::apache::thrift::protocol::TType ftype;
03794 int16_t fid;
03795
03796 xfer += iprot->readStructBegin(fname);
03797
03798 using ::apache::thrift::protocol::TProtocolException;
03799
03800
03801 while (true)
03802 {
03803 xfer += iprot->readFieldBegin(fname, ftype, fid);
03804 if (ftype == ::apache::thrift::protocol::T_STOP) {
03805 break;
03806 }
03807 switch (fid)
03808 {
03809 case 1:
03810 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
03811 xfer += this->ire.read(iprot);
03812 this->__isset.ire = true;
03813 } else {
03814 xfer += iprot->skip(ftype);
03815 }
03816 break;
03817 case 2:
03818 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
03819 xfer += this->ue.read(iprot);
03820 this->__isset.ue = true;
03821 } else {
03822 xfer += iprot->skip(ftype);
03823 }
03824 break;
03825 case 3:
03826 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
03827 xfer += this->te.read(iprot);
03828 this->__isset.te = true;
03829 } else {
03830 xfer += iprot->skip(ftype);
03831 }
03832 break;
03833 default:
03834 xfer += iprot->skip(ftype);
03835 break;
03836 }
03837 xfer += iprot->readFieldEnd();
03838 }
03839
03840 xfer += iprot->readStructEnd();
03841
03842 return xfer;
03843 }
03844
03845 uint32_t Cassandra_truncate_args::read(::apache::thrift::protocol::TProtocol* iprot) {
03846
03847 uint32_t xfer = 0;
03848 std::string fname;
03849 ::apache::thrift::protocol::TType ftype;
03850 int16_t fid;
03851
03852 xfer += iprot->readStructBegin(fname);
03853
03854 using ::apache::thrift::protocol::TProtocolException;
03855
03856 bool isset_cfname = false;
03857
03858 while (true)
03859 {
03860 xfer += iprot->readFieldBegin(fname, ftype, fid);
03861 if (ftype == ::apache::thrift::protocol::T_STOP) {
03862 break;
03863 }
03864 switch (fid)
03865 {
03866 case 1:
03867 if (ftype == ::apache::thrift::protocol::T_STRING) {
03868 xfer += iprot->readString(this->cfname);
03869 isset_cfname = true;
03870 } else {
03871 xfer += iprot->skip(ftype);
03872 }
03873 break;
03874 default:
03875 xfer += iprot->skip(ftype);
03876 break;
03877 }
03878 xfer += iprot->readFieldEnd();
03879 }
03880
03881 xfer += iprot->readStructEnd();
03882
03883 if (!isset_cfname)
03884 throw TProtocolException(TProtocolException::INVALID_DATA);
03885 return xfer;
03886 }
03887
03888 uint32_t Cassandra_truncate_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
03889 uint32_t xfer = 0;
03890 xfer += oprot->writeStructBegin("Cassandra_truncate_args");
03891 xfer += oprot->writeFieldBegin("cfname", ::apache::thrift::protocol::T_STRING, 1);
03892 xfer += oprot->writeString(this->cfname);
03893 xfer += oprot->writeFieldEnd();
03894 xfer += oprot->writeFieldStop();
03895 xfer += oprot->writeStructEnd();
03896 return xfer;
03897 }
03898
03899 uint32_t Cassandra_truncate_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
03900 uint32_t xfer = 0;
03901 xfer += oprot->writeStructBegin("Cassandra_truncate_pargs");
03902 xfer += oprot->writeFieldBegin("cfname", ::apache::thrift::protocol::T_STRING, 1);
03903 xfer += oprot->writeString((*(this->cfname)));
03904 xfer += oprot->writeFieldEnd();
03905 xfer += oprot->writeFieldStop();
03906 xfer += oprot->writeStructEnd();
03907 return xfer;
03908 }
03909
03910 uint32_t Cassandra_truncate_result::read(::apache::thrift::protocol::TProtocol* iprot) {
03911
03912 uint32_t xfer = 0;
03913 std::string fname;
03914 ::apache::thrift::protocol::TType ftype;
03915 int16_t fid;
03916
03917 xfer += iprot->readStructBegin(fname);
03918
03919 using ::apache::thrift::protocol::TProtocolException;
03920
03921
03922 while (true)
03923 {
03924 xfer += iprot->readFieldBegin(fname, ftype, fid);
03925 if (ftype == ::apache::thrift::protocol::T_STOP) {
03926 break;
03927 }
03928 switch (fid)
03929 {
03930 case 1:
03931 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
03932 xfer += this->ire.read(iprot);
03933 this->__isset.ire = true;
03934 } else {
03935 xfer += iprot->skip(ftype);
03936 }
03937 break;
03938 case 2:
03939 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
03940 xfer += this->ue.read(iprot);
03941 this->__isset.ue = true;
03942 } else {
03943 xfer += iprot->skip(ftype);
03944 }
03945 break;
03946 default:
03947 xfer += iprot->skip(ftype);
03948 break;
03949 }
03950 xfer += iprot->readFieldEnd();
03951 }
03952
03953 xfer += iprot->readStructEnd();
03954
03955 return xfer;
03956 }
03957
03958 uint32_t Cassandra_truncate_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
03959
03960 uint32_t xfer = 0;
03961
03962 xfer += oprot->writeStructBegin("Cassandra_truncate_result");
03963
03964 if (this->__isset.ire) {
03965 xfer += oprot->writeFieldBegin("ire", ::apache::thrift::protocol::T_STRUCT, 1);
03966 xfer += this->ire.write(oprot);
03967 xfer += oprot->writeFieldEnd();
03968 } else if (this->__isset.ue) {
03969 xfer += oprot->writeFieldBegin("ue", ::apache::thrift::protocol::T_STRUCT, 2);
03970 xfer += this->ue.write(oprot);
03971 xfer += oprot->writeFieldEnd();
03972 }
03973 xfer += oprot->writeFieldStop();
03974 xfer += oprot->writeStructEnd();
03975 return xfer;
03976 }
03977
03978 uint32_t Cassandra_truncate_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
03979
03980 uint32_t xfer = 0;
03981 std::string fname;
03982 ::apache::thrift::protocol::TType ftype;
03983 int16_t fid;
03984
03985 xfer += iprot->readStructBegin(fname);
03986
03987 using ::apache::thrift::protocol::TProtocolException;
03988
03989
03990 while (true)
03991 {
03992 xfer += iprot->readFieldBegin(fname, ftype, fid);
03993 if (ftype == ::apache::thrift::protocol::T_STOP) {
03994 break;
03995 }
03996 switch (fid)
03997 {
03998 case 1:
03999 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
04000 xfer += this->ire.read(iprot);
04001 this->__isset.ire = true;
04002 } else {
04003 xfer += iprot->skip(ftype);
04004 }
04005 break;
04006 case 2:
04007 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
04008 xfer += this->ue.read(iprot);
04009 this->__isset.ue = true;
04010 } else {
04011 xfer += iprot->skip(ftype);
04012 }
04013 break;
04014 default:
04015 xfer += iprot->skip(ftype);
04016 break;
04017 }
04018 xfer += iprot->readFieldEnd();
04019 }
04020
04021 xfer += iprot->readStructEnd();
04022
04023 return xfer;
04024 }
04025
04026 uint32_t Cassandra_describe_schema_versions_args::read(::apache::thrift::protocol::TProtocol* iprot) {
04027
04028 uint32_t xfer = 0;
04029 std::string fname;
04030 ::apache::thrift::protocol::TType ftype;
04031 int16_t fid;
04032
04033 xfer += iprot->readStructBegin(fname);
04034
04035 using ::apache::thrift::protocol::TProtocolException;
04036
04037
04038 while (true)
04039 {
04040 xfer += iprot->readFieldBegin(fname, ftype, fid);
04041 if (ftype == ::apache::thrift::protocol::T_STOP) {
04042 break;
04043 }
04044 switch (fid)
04045 {
04046 default:
04047 xfer += iprot->skip(ftype);
04048 break;
04049 }
04050 xfer += iprot->readFieldEnd();
04051 }
04052
04053 xfer += iprot->readStructEnd();
04054
04055 return xfer;
04056 }
04057
04058 uint32_t Cassandra_describe_schema_versions_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
04059 uint32_t xfer = 0;
04060 xfer += oprot->writeStructBegin("Cassandra_describe_schema_versions_args");
04061 xfer += oprot->writeFieldStop();
04062 xfer += oprot->writeStructEnd();
04063 return xfer;
04064 }
04065
04066 uint32_t Cassandra_describe_schema_versions_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
04067 uint32_t xfer = 0;
04068 xfer += oprot->writeStructBegin("Cassandra_describe_schema_versions_pargs");
04069 xfer += oprot->writeFieldStop();
04070 xfer += oprot->writeStructEnd();
04071 return xfer;
04072 }
04073
04074 uint32_t Cassandra_describe_schema_versions_result::read(::apache::thrift::protocol::TProtocol* iprot) {
04075
04076 uint32_t xfer = 0;
04077 std::string fname;
04078 ::apache::thrift::protocol::TType ftype;
04079 int16_t fid;
04080
04081 xfer += iprot->readStructBegin(fname);
04082
04083 using ::apache::thrift::protocol::TProtocolException;
04084
04085
04086 while (true)
04087 {
04088 xfer += iprot->readFieldBegin(fname, ftype, fid);
04089 if (ftype == ::apache::thrift::protocol::T_STOP) {
04090 break;
04091 }
04092 switch (fid)
04093 {
04094 case 0:
04095 if (ftype == ::apache::thrift::protocol::T_MAP) {
04096 {
04097 this->success.clear();
04098 uint32_t _size256;
04099 ::apache::thrift::protocol::TType _ktype257;
04100 ::apache::thrift::protocol::TType _vtype258;
04101 iprot->readMapBegin(_ktype257, _vtype258, _size256);
04102 uint32_t _i260;
04103 for (_i260 = 0; _i260 < _size256; ++_i260)
04104 {
04105 std::string _key261;
04106 xfer += iprot->readString(_key261);
04107 std::vector<std::string> & _val262 = this->success[_key261];
04108 {
04109 _val262.clear();
04110 uint32_t _size263;
04111 ::apache::thrift::protocol::TType _etype266;
04112 iprot->readListBegin(_etype266, _size263);
04113 _val262.resize(_size263);
04114 uint32_t _i267;
04115 for (_i267 = 0; _i267 < _size263; ++_i267)
04116 {
04117 xfer += iprot->readString(_val262[_i267]);
04118 }
04119 iprot->readListEnd();
04120 }
04121 }
04122 iprot->readMapEnd();
04123 }
04124 this->__isset.success = true;
04125 } else {
04126 xfer += iprot->skip(ftype);
04127 }
04128 break;
04129 case 1:
04130 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
04131 xfer += this->ire.read(iprot);
04132 this->__isset.ire = true;
04133 } else {
04134 xfer += iprot->skip(ftype);
04135 }
04136 break;
04137 default:
04138 xfer += iprot->skip(ftype);
04139 break;
04140 }
04141 xfer += iprot->readFieldEnd();
04142 }
04143
04144 xfer += iprot->readStructEnd();
04145
04146 return xfer;
04147 }
04148
04149 uint32_t Cassandra_describe_schema_versions_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
04150
04151 uint32_t xfer = 0;
04152
04153 xfer += oprot->writeStructBegin("Cassandra_describe_schema_versions_result");
04154
04155 if (this->__isset.success) {
04156 xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_MAP, 0);
04157 {
04158 xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_LIST, this->success.size());
04159 std::map<std::string, std::vector<std::string> > ::const_iterator _iter268;
04160 for (_iter268 = this->success.begin(); _iter268 != this->success.end(); ++_iter268)
04161 {
04162 xfer += oprot->writeString(_iter268->first);
04163 {
04164 xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, _iter268->second.size());
04165 std::vector<std::string> ::const_iterator _iter269;
04166 for (_iter269 = _iter268->second.begin(); _iter269 != _iter268->second.end(); ++_iter269)
04167 {
04168 xfer += oprot->writeString((*_iter269));
04169 }
04170 xfer += oprot->writeListEnd();
04171 }
04172 }
04173 xfer += oprot->writeMapEnd();
04174 }
04175 xfer += oprot->writeFieldEnd();
04176 } else if (this->__isset.ire) {
04177 xfer += oprot->writeFieldBegin("ire", ::apache::thrift::protocol::T_STRUCT, 1);
04178 xfer += this->ire.write(oprot);
04179 xfer += oprot->writeFieldEnd();
04180 }
04181 xfer += oprot->writeFieldStop();
04182 xfer += oprot->writeStructEnd();
04183 return xfer;
04184 }
04185
04186 uint32_t Cassandra_describe_schema_versions_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
04187
04188 uint32_t xfer = 0;
04189 std::string fname;
04190 ::apache::thrift::protocol::TType ftype;
04191 int16_t fid;
04192
04193 xfer += iprot->readStructBegin(fname);
04194
04195 using ::apache::thrift::protocol::TProtocolException;
04196
04197
04198 while (true)
04199 {
04200 xfer += iprot->readFieldBegin(fname, ftype, fid);
04201 if (ftype == ::apache::thrift::protocol::T_STOP) {
04202 break;
04203 }
04204 switch (fid)
04205 {
04206 case 0:
04207 if (ftype == ::apache::thrift::protocol::T_MAP) {
04208 {
04209 (*(this->success)).clear();
04210 uint32_t _size270;
04211 ::apache::thrift::protocol::TType _ktype271;
04212 ::apache::thrift::protocol::TType _vtype272;
04213 iprot->readMapBegin(_ktype271, _vtype272, _size270);
04214 uint32_t _i274;
04215 for (_i274 = 0; _i274 < _size270; ++_i274)
04216 {
04217 std::string _key275;
04218 xfer += iprot->readString(_key275);
04219 std::vector<std::string> & _val276 = (*(this->success))[_key275];
04220 {
04221 _val276.clear();
04222 uint32_t _size277;
04223 ::apache::thrift::protocol::TType _etype280;
04224 iprot->readListBegin(_etype280, _size277);
04225 _val276.resize(_size277);
04226 uint32_t _i281;
04227 for (_i281 = 0; _i281 < _size277; ++_i281)
04228 {
04229 xfer += iprot->readString(_val276[_i281]);
04230 }
04231 iprot->readListEnd();
04232 }
04233 }
04234 iprot->readMapEnd();
04235 }
04236 this->__isset.success = true;
04237 } else {
04238 xfer += iprot->skip(ftype);
04239 }
04240 break;
04241 case 1:
04242 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
04243 xfer += this->ire.read(iprot);
04244 this->__isset.ire = true;
04245 } else {
04246 xfer += iprot->skip(ftype);
04247 }
04248 break;
04249 default:
04250 xfer += iprot->skip(ftype);
04251 break;
04252 }
04253 xfer += iprot->readFieldEnd();
04254 }
04255
04256 xfer += iprot->readStructEnd();
04257
04258 return xfer;
04259 }
04260
04261 uint32_t Cassandra_describe_keyspaces_args::read(::apache::thrift::protocol::TProtocol* iprot) {
04262
04263 uint32_t xfer = 0;
04264 std::string fname;
04265 ::apache::thrift::protocol::TType ftype;
04266 int16_t fid;
04267
04268 xfer += iprot->readStructBegin(fname);
04269
04270 using ::apache::thrift::protocol::TProtocolException;
04271
04272
04273 while (true)
04274 {
04275 xfer += iprot->readFieldBegin(fname, ftype, fid);
04276 if (ftype == ::apache::thrift::protocol::T_STOP) {
04277 break;
04278 }
04279 switch (fid)
04280 {
04281 default:
04282 xfer += iprot->skip(ftype);
04283 break;
04284 }
04285 xfer += iprot->readFieldEnd();
04286 }
04287
04288 xfer += iprot->readStructEnd();
04289
04290 return xfer;
04291 }
04292
04293 uint32_t Cassandra_describe_keyspaces_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
04294 uint32_t xfer = 0;
04295 xfer += oprot->writeStructBegin("Cassandra_describe_keyspaces_args");
04296 xfer += oprot->writeFieldStop();
04297 xfer += oprot->writeStructEnd();
04298 return xfer;
04299 }
04300
04301 uint32_t Cassandra_describe_keyspaces_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
04302 uint32_t xfer = 0;
04303 xfer += oprot->writeStructBegin("Cassandra_describe_keyspaces_pargs");
04304 xfer += oprot->writeFieldStop();
04305 xfer += oprot->writeStructEnd();
04306 return xfer;
04307 }
04308
04309 uint32_t Cassandra_describe_keyspaces_result::read(::apache::thrift::protocol::TProtocol* iprot) {
04310
04311 uint32_t xfer = 0;
04312 std::string fname;
04313 ::apache::thrift::protocol::TType ftype;
04314 int16_t fid;
04315
04316 xfer += iprot->readStructBegin(fname);
04317
04318 using ::apache::thrift::protocol::TProtocolException;
04319
04320
04321 while (true)
04322 {
04323 xfer += iprot->readFieldBegin(fname, ftype, fid);
04324 if (ftype == ::apache::thrift::protocol::T_STOP) {
04325 break;
04326 }
04327 switch (fid)
04328 {
04329 case 0:
04330 if (ftype == ::apache::thrift::protocol::T_LIST) {
04331 {
04332 this->success.clear();
04333 uint32_t _size282;
04334 ::apache::thrift::protocol::TType _etype285;
04335 iprot->readListBegin(_etype285, _size282);
04336 this->success.resize(_size282);
04337 uint32_t _i286;
04338 for (_i286 = 0; _i286 < _size282; ++_i286)
04339 {
04340 xfer += this->success[_i286].read(iprot);
04341 }
04342 iprot->readListEnd();
04343 }
04344 this->__isset.success = true;
04345 } else {
04346 xfer += iprot->skip(ftype);
04347 }
04348 break;
04349 case 1:
04350 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
04351 xfer += this->ire.read(iprot);
04352 this->__isset.ire = true;
04353 } else {
04354 xfer += iprot->skip(ftype);
04355 }
04356 break;
04357 default:
04358 xfer += iprot->skip(ftype);
04359 break;
04360 }
04361 xfer += iprot->readFieldEnd();
04362 }
04363
04364 xfer += iprot->readStructEnd();
04365
04366 return xfer;
04367 }
04368
04369 uint32_t Cassandra_describe_keyspaces_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
04370
04371 uint32_t xfer = 0;
04372
04373 xfer += oprot->writeStructBegin("Cassandra_describe_keyspaces_result");
04374
04375 if (this->__isset.success) {
04376 xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0);
04377 {
04378 xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, this->success.size());
04379 std::vector<KsDef> ::const_iterator _iter287;
04380 for (_iter287 = this->success.begin(); _iter287 != this->success.end(); ++_iter287)
04381 {
04382 xfer += (*_iter287).write(oprot);
04383 }
04384 xfer += oprot->writeListEnd();
04385 }
04386 xfer += oprot->writeFieldEnd();
04387 } else if (this->__isset.ire) {
04388 xfer += oprot->writeFieldBegin("ire", ::apache::thrift::protocol::T_STRUCT, 1);
04389 xfer += this->ire.write(oprot);
04390 xfer += oprot->writeFieldEnd();
04391 }
04392 xfer += oprot->writeFieldStop();
04393 xfer += oprot->writeStructEnd();
04394 return xfer;
04395 }
04396
04397 uint32_t Cassandra_describe_keyspaces_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
04398
04399 uint32_t xfer = 0;
04400 std::string fname;
04401 ::apache::thrift::protocol::TType ftype;
04402 int16_t fid;
04403
04404 xfer += iprot->readStructBegin(fname);
04405
04406 using ::apache::thrift::protocol::TProtocolException;
04407
04408
04409 while (true)
04410 {
04411 xfer += iprot->readFieldBegin(fname, ftype, fid);
04412 if (ftype == ::apache::thrift::protocol::T_STOP) {
04413 break;
04414 }
04415 switch (fid)
04416 {
04417 case 0:
04418 if (ftype == ::apache::thrift::protocol::T_LIST) {
04419 {
04420 (*(this->success)).clear();
04421 uint32_t _size288;
04422 ::apache::thrift::protocol::TType _etype291;
04423 iprot->readListBegin(_etype291, _size288);
04424 (*(this->success)).resize(_size288);
04425 uint32_t _i292;
04426 for (_i292 = 0; _i292 < _size288; ++_i292)
04427 {
04428 xfer += (*(this->success))[_i292].read(iprot);
04429 }
04430 iprot->readListEnd();
04431 }
04432 this->__isset.success = true;
04433 } else {
04434 xfer += iprot->skip(ftype);
04435 }
04436 break;
04437 case 1:
04438 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
04439 xfer += this->ire.read(iprot);
04440 this->__isset.ire = true;
04441 } else {
04442 xfer += iprot->skip(ftype);
04443 }
04444 break;
04445 default:
04446 xfer += iprot->skip(ftype);
04447 break;
04448 }
04449 xfer += iprot->readFieldEnd();
04450 }
04451
04452 xfer += iprot->readStructEnd();
04453
04454 return xfer;
04455 }
04456
04457 uint32_t Cassandra_describe_cluster_name_args::read(::apache::thrift::protocol::TProtocol* iprot) {
04458
04459 uint32_t xfer = 0;
04460 std::string fname;
04461 ::apache::thrift::protocol::TType ftype;
04462 int16_t fid;
04463
04464 xfer += iprot->readStructBegin(fname);
04465
04466 using ::apache::thrift::protocol::TProtocolException;
04467
04468
04469 while (true)
04470 {
04471 xfer += iprot->readFieldBegin(fname, ftype, fid);
04472 if (ftype == ::apache::thrift::protocol::T_STOP) {
04473 break;
04474 }
04475 switch (fid)
04476 {
04477 default:
04478 xfer += iprot->skip(ftype);
04479 break;
04480 }
04481 xfer += iprot->readFieldEnd();
04482 }
04483
04484 xfer += iprot->readStructEnd();
04485
04486 return xfer;
04487 }
04488
04489 uint32_t Cassandra_describe_cluster_name_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
04490 uint32_t xfer = 0;
04491 xfer += oprot->writeStructBegin("Cassandra_describe_cluster_name_args");
04492 xfer += oprot->writeFieldStop();
04493 xfer += oprot->writeStructEnd();
04494 return xfer;
04495 }
04496
04497 uint32_t Cassandra_describe_cluster_name_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
04498 uint32_t xfer = 0;
04499 xfer += oprot->writeStructBegin("Cassandra_describe_cluster_name_pargs");
04500 xfer += oprot->writeFieldStop();
04501 xfer += oprot->writeStructEnd();
04502 return xfer;
04503 }
04504
04505 uint32_t Cassandra_describe_cluster_name_result::read(::apache::thrift::protocol::TProtocol* iprot) {
04506
04507 uint32_t xfer = 0;
04508 std::string fname;
04509 ::apache::thrift::protocol::TType ftype;
04510 int16_t fid;
04511
04512 xfer += iprot->readStructBegin(fname);
04513
04514 using ::apache::thrift::protocol::TProtocolException;
04515
04516
04517 while (true)
04518 {
04519 xfer += iprot->readFieldBegin(fname, ftype, fid);
04520 if (ftype == ::apache::thrift::protocol::T_STOP) {
04521 break;
04522 }
04523 switch (fid)
04524 {
04525 case 0:
04526 if (ftype == ::apache::thrift::protocol::T_STRING) {
04527 xfer += iprot->readString(this->success);
04528 this->__isset.success = true;
04529 } else {
04530 xfer += iprot->skip(ftype);
04531 }
04532 break;
04533 default:
04534 xfer += iprot->skip(ftype);
04535 break;
04536 }
04537 xfer += iprot->readFieldEnd();
04538 }
04539
04540 xfer += iprot->readStructEnd();
04541
04542 return xfer;
04543 }
04544
04545 uint32_t Cassandra_describe_cluster_name_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
04546
04547 uint32_t xfer = 0;
04548
04549 xfer += oprot->writeStructBegin("Cassandra_describe_cluster_name_result");
04550
04551 if (this->__isset.success) {
04552 xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRING, 0);
04553 xfer += oprot->writeString(this->success);
04554 xfer += oprot->writeFieldEnd();
04555 }
04556 xfer += oprot->writeFieldStop();
04557 xfer += oprot->writeStructEnd();
04558 return xfer;
04559 }
04560
04561 uint32_t Cassandra_describe_cluster_name_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
04562
04563 uint32_t xfer = 0;
04564 std::string fname;
04565 ::apache::thrift::protocol::TType ftype;
04566 int16_t fid;
04567
04568 xfer += iprot->readStructBegin(fname);
04569
04570 using ::apache::thrift::protocol::TProtocolException;
04571
04572
04573 while (true)
04574 {
04575 xfer += iprot->readFieldBegin(fname, ftype, fid);
04576 if (ftype == ::apache::thrift::protocol::T_STOP) {
04577 break;
04578 }
04579 switch (fid)
04580 {
04581 case 0:
04582 if (ftype == ::apache::thrift::protocol::T_STRING) {
04583 xfer += iprot->readString((*(this->success)));
04584 this->__isset.success = true;
04585 } else {
04586 xfer += iprot->skip(ftype);
04587 }
04588 break;
04589 default:
04590 xfer += iprot->skip(ftype);
04591 break;
04592 }
04593 xfer += iprot->readFieldEnd();
04594 }
04595
04596 xfer += iprot->readStructEnd();
04597
04598 return xfer;
04599 }
04600
04601 uint32_t Cassandra_describe_version_args::read(::apache::thrift::protocol::TProtocol* iprot) {
04602
04603 uint32_t xfer = 0;
04604 std::string fname;
04605 ::apache::thrift::protocol::TType ftype;
04606 int16_t fid;
04607
04608 xfer += iprot->readStructBegin(fname);
04609
04610 using ::apache::thrift::protocol::TProtocolException;
04611
04612
04613 while (true)
04614 {
04615 xfer += iprot->readFieldBegin(fname, ftype, fid);
04616 if (ftype == ::apache::thrift::protocol::T_STOP) {
04617 break;
04618 }
04619 switch (fid)
04620 {
04621 default:
04622 xfer += iprot->skip(ftype);
04623 break;
04624 }
04625 xfer += iprot->readFieldEnd();
04626 }
04627
04628 xfer += iprot->readStructEnd();
04629
04630 return xfer;
04631 }
04632
04633 uint32_t Cassandra_describe_version_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
04634 uint32_t xfer = 0;
04635 xfer += oprot->writeStructBegin("Cassandra_describe_version_args");
04636 xfer += oprot->writeFieldStop();
04637 xfer += oprot->writeStructEnd();
04638 return xfer;
04639 }
04640
04641 uint32_t Cassandra_describe_version_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
04642 uint32_t xfer = 0;
04643 xfer += oprot->writeStructBegin("Cassandra_describe_version_pargs");
04644 xfer += oprot->writeFieldStop();
04645 xfer += oprot->writeStructEnd();
04646 return xfer;
04647 }
04648
04649 uint32_t Cassandra_describe_version_result::read(::apache::thrift::protocol::TProtocol* iprot) {
04650
04651 uint32_t xfer = 0;
04652 std::string fname;
04653 ::apache::thrift::protocol::TType ftype;
04654 int16_t fid;
04655
04656 xfer += iprot->readStructBegin(fname);
04657
04658 using ::apache::thrift::protocol::TProtocolException;
04659
04660
04661 while (true)
04662 {
04663 xfer += iprot->readFieldBegin(fname, ftype, fid);
04664 if (ftype == ::apache::thrift::protocol::T_STOP) {
04665 break;
04666 }
04667 switch (fid)
04668 {
04669 case 0:
04670 if (ftype == ::apache::thrift::protocol::T_STRING) {
04671 xfer += iprot->readString(this->success);
04672 this->__isset.success = true;
04673 } else {
04674 xfer += iprot->skip(ftype);
04675 }
04676 break;
04677 default:
04678 xfer += iprot->skip(ftype);
04679 break;
04680 }
04681 xfer += iprot->readFieldEnd();
04682 }
04683
04684 xfer += iprot->readStructEnd();
04685
04686 return xfer;
04687 }
04688
04689 uint32_t Cassandra_describe_version_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
04690
04691 uint32_t xfer = 0;
04692
04693 xfer += oprot->writeStructBegin("Cassandra_describe_version_result");
04694
04695 if (this->__isset.success) {
04696 xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRING, 0);
04697 xfer += oprot->writeString(this->success);
04698 xfer += oprot->writeFieldEnd();
04699 }
04700 xfer += oprot->writeFieldStop();
04701 xfer += oprot->writeStructEnd();
04702 return xfer;
04703 }
04704
04705 uint32_t Cassandra_describe_version_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
04706
04707 uint32_t xfer = 0;
04708 std::string fname;
04709 ::apache::thrift::protocol::TType ftype;
04710 int16_t fid;
04711
04712 xfer += iprot->readStructBegin(fname);
04713
04714 using ::apache::thrift::protocol::TProtocolException;
04715
04716
04717 while (true)
04718 {
04719 xfer += iprot->readFieldBegin(fname, ftype, fid);
04720 if (ftype == ::apache::thrift::protocol::T_STOP) {
04721 break;
04722 }
04723 switch (fid)
04724 {
04725 case 0:
04726 if (ftype == ::apache::thrift::protocol::T_STRING) {
04727 xfer += iprot->readString((*(this->success)));
04728 this->__isset.success = true;
04729 } else {
04730 xfer += iprot->skip(ftype);
04731 }
04732 break;
04733 default:
04734 xfer += iprot->skip(ftype);
04735 break;
04736 }
04737 xfer += iprot->readFieldEnd();
04738 }
04739
04740 xfer += iprot->readStructEnd();
04741
04742 return xfer;
04743 }
04744
04745 uint32_t Cassandra_describe_ring_args::read(::apache::thrift::protocol::TProtocol* iprot) {
04746
04747 uint32_t xfer = 0;
04748 std::string fname;
04749 ::apache::thrift::protocol::TType ftype;
04750 int16_t fid;
04751
04752 xfer += iprot->readStructBegin(fname);
04753
04754 using ::apache::thrift::protocol::TProtocolException;
04755
04756 bool isset_keyspace = false;
04757
04758 while (true)
04759 {
04760 xfer += iprot->readFieldBegin(fname, ftype, fid);
04761 if (ftype == ::apache::thrift::protocol::T_STOP) {
04762 break;
04763 }
04764 switch (fid)
04765 {
04766 case 1:
04767 if (ftype == ::apache::thrift::protocol::T_STRING) {
04768 xfer += iprot->readString(this->keyspace);
04769 isset_keyspace = true;
04770 } else {
04771 xfer += iprot->skip(ftype);
04772 }
04773 break;
04774 default:
04775 xfer += iprot->skip(ftype);
04776 break;
04777 }
04778 xfer += iprot->readFieldEnd();
04779 }
04780
04781 xfer += iprot->readStructEnd();
04782
04783 if (!isset_keyspace)
04784 throw TProtocolException(TProtocolException::INVALID_DATA);
04785 return xfer;
04786 }
04787
04788 uint32_t Cassandra_describe_ring_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
04789 uint32_t xfer = 0;
04790 xfer += oprot->writeStructBegin("Cassandra_describe_ring_args");
04791 xfer += oprot->writeFieldBegin("keyspace", ::apache::thrift::protocol::T_STRING, 1);
04792 xfer += oprot->writeString(this->keyspace);
04793 xfer += oprot->writeFieldEnd();
04794 xfer += oprot->writeFieldStop();
04795 xfer += oprot->writeStructEnd();
04796 return xfer;
04797 }
04798
04799 uint32_t Cassandra_describe_ring_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
04800 uint32_t xfer = 0;
04801 xfer += oprot->writeStructBegin("Cassandra_describe_ring_pargs");
04802 xfer += oprot->writeFieldBegin("keyspace", ::apache::thrift::protocol::T_STRING, 1);
04803 xfer += oprot->writeString((*(this->keyspace)));
04804 xfer += oprot->writeFieldEnd();
04805 xfer += oprot->writeFieldStop();
04806 xfer += oprot->writeStructEnd();
04807 return xfer;
04808 }
04809
04810 uint32_t Cassandra_describe_ring_result::read(::apache::thrift::protocol::TProtocol* iprot) {
04811
04812 uint32_t xfer = 0;
04813 std::string fname;
04814 ::apache::thrift::protocol::TType ftype;
04815 int16_t fid;
04816
04817 xfer += iprot->readStructBegin(fname);
04818
04819 using ::apache::thrift::protocol::TProtocolException;
04820
04821
04822 while (true)
04823 {
04824 xfer += iprot->readFieldBegin(fname, ftype, fid);
04825 if (ftype == ::apache::thrift::protocol::T_STOP) {
04826 break;
04827 }
04828 switch (fid)
04829 {
04830 case 0:
04831 if (ftype == ::apache::thrift::protocol::T_LIST) {
04832 {
04833 this->success.clear();
04834 uint32_t _size293;
04835 ::apache::thrift::protocol::TType _etype296;
04836 iprot->readListBegin(_etype296, _size293);
04837 this->success.resize(_size293);
04838 uint32_t _i297;
04839 for (_i297 = 0; _i297 < _size293; ++_i297)
04840 {
04841 xfer += this->success[_i297].read(iprot);
04842 }
04843 iprot->readListEnd();
04844 }
04845 this->__isset.success = true;
04846 } else {
04847 xfer += iprot->skip(ftype);
04848 }
04849 break;
04850 case 1:
04851 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
04852 xfer += this->ire.read(iprot);
04853 this->__isset.ire = true;
04854 } else {
04855 xfer += iprot->skip(ftype);
04856 }
04857 break;
04858 default:
04859 xfer += iprot->skip(ftype);
04860 break;
04861 }
04862 xfer += iprot->readFieldEnd();
04863 }
04864
04865 xfer += iprot->readStructEnd();
04866
04867 return xfer;
04868 }
04869
04870 uint32_t Cassandra_describe_ring_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
04871
04872 uint32_t xfer = 0;
04873
04874 xfer += oprot->writeStructBegin("Cassandra_describe_ring_result");
04875
04876 if (this->__isset.success) {
04877 xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0);
04878 {
04879 xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, this->success.size());
04880 std::vector<TokenRange> ::const_iterator _iter298;
04881 for (_iter298 = this->success.begin(); _iter298 != this->success.end(); ++_iter298)
04882 {
04883 xfer += (*_iter298).write(oprot);
04884 }
04885 xfer += oprot->writeListEnd();
04886 }
04887 xfer += oprot->writeFieldEnd();
04888 } else if (this->__isset.ire) {
04889 xfer += oprot->writeFieldBegin("ire", ::apache::thrift::protocol::T_STRUCT, 1);
04890 xfer += this->ire.write(oprot);
04891 xfer += oprot->writeFieldEnd();
04892 }
04893 xfer += oprot->writeFieldStop();
04894 xfer += oprot->writeStructEnd();
04895 return xfer;
04896 }
04897
04898 uint32_t Cassandra_describe_ring_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
04899
04900 uint32_t xfer = 0;
04901 std::string fname;
04902 ::apache::thrift::protocol::TType ftype;
04903 int16_t fid;
04904
04905 xfer += iprot->readStructBegin(fname);
04906
04907 using ::apache::thrift::protocol::TProtocolException;
04908
04909
04910 while (true)
04911 {
04912 xfer += iprot->readFieldBegin(fname, ftype, fid);
04913 if (ftype == ::apache::thrift::protocol::T_STOP) {
04914 break;
04915 }
04916 switch (fid)
04917 {
04918 case 0:
04919 if (ftype == ::apache::thrift::protocol::T_LIST) {
04920 {
04921 (*(this->success)).clear();
04922 uint32_t _size299;
04923 ::apache::thrift::protocol::TType _etype302;
04924 iprot->readListBegin(_etype302, _size299);
04925 (*(this->success)).resize(_size299);
04926 uint32_t _i303;
04927 for (_i303 = 0; _i303 < _size299; ++_i303)
04928 {
04929 xfer += (*(this->success))[_i303].read(iprot);
04930 }
04931 iprot->readListEnd();
04932 }
04933 this->__isset.success = true;
04934 } else {
04935 xfer += iprot->skip(ftype);
04936 }
04937 break;
04938 case 1:
04939 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
04940 xfer += this->ire.read(iprot);
04941 this->__isset.ire = true;
04942 } else {
04943 xfer += iprot->skip(ftype);
04944 }
04945 break;
04946 default:
04947 xfer += iprot->skip(ftype);
04948 break;
04949 }
04950 xfer += iprot->readFieldEnd();
04951 }
04952
04953 xfer += iprot->readStructEnd();
04954
04955 return xfer;
04956 }
04957
04958 uint32_t Cassandra_describe_partitioner_args::read(::apache::thrift::protocol::TProtocol* iprot) {
04959
04960 uint32_t xfer = 0;
04961 std::string fname;
04962 ::apache::thrift::protocol::TType ftype;
04963 int16_t fid;
04964
04965 xfer += iprot->readStructBegin(fname);
04966
04967 using ::apache::thrift::protocol::TProtocolException;
04968
04969
04970 while (true)
04971 {
04972 xfer += iprot->readFieldBegin(fname, ftype, fid);
04973 if (ftype == ::apache::thrift::protocol::T_STOP) {
04974 break;
04975 }
04976 switch (fid)
04977 {
04978 default:
04979 xfer += iprot->skip(ftype);
04980 break;
04981 }
04982 xfer += iprot->readFieldEnd();
04983 }
04984
04985 xfer += iprot->readStructEnd();
04986
04987 return xfer;
04988 }
04989
04990 uint32_t Cassandra_describe_partitioner_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
04991 uint32_t xfer = 0;
04992 xfer += oprot->writeStructBegin("Cassandra_describe_partitioner_args");
04993 xfer += oprot->writeFieldStop();
04994 xfer += oprot->writeStructEnd();
04995 return xfer;
04996 }
04997
04998 uint32_t Cassandra_describe_partitioner_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
04999 uint32_t xfer = 0;
05000 xfer += oprot->writeStructBegin("Cassandra_describe_partitioner_pargs");
05001 xfer += oprot->writeFieldStop();
05002 xfer += oprot->writeStructEnd();
05003 return xfer;
05004 }
05005
05006 uint32_t Cassandra_describe_partitioner_result::read(::apache::thrift::protocol::TProtocol* iprot) {
05007
05008 uint32_t xfer = 0;
05009 std::string fname;
05010 ::apache::thrift::protocol::TType ftype;
05011 int16_t fid;
05012
05013 xfer += iprot->readStructBegin(fname);
05014
05015 using ::apache::thrift::protocol::TProtocolException;
05016
05017
05018 while (true)
05019 {
05020 xfer += iprot->readFieldBegin(fname, ftype, fid);
05021 if (ftype == ::apache::thrift::protocol::T_STOP) {
05022 break;
05023 }
05024 switch (fid)
05025 {
05026 case 0:
05027 if (ftype == ::apache::thrift::protocol::T_STRING) {
05028 xfer += iprot->readString(this->success);
05029 this->__isset.success = true;
05030 } else {
05031 xfer += iprot->skip(ftype);
05032 }
05033 break;
05034 default:
05035 xfer += iprot->skip(ftype);
05036 break;
05037 }
05038 xfer += iprot->readFieldEnd();
05039 }
05040
05041 xfer += iprot->readStructEnd();
05042
05043 return xfer;
05044 }
05045
05046 uint32_t Cassandra_describe_partitioner_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
05047
05048 uint32_t xfer = 0;
05049
05050 xfer += oprot->writeStructBegin("Cassandra_describe_partitioner_result");
05051
05052 if (this->__isset.success) {
05053 xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRING, 0);
05054 xfer += oprot->writeString(this->success);
05055 xfer += oprot->writeFieldEnd();
05056 }
05057 xfer += oprot->writeFieldStop();
05058 xfer += oprot->writeStructEnd();
05059 return xfer;
05060 }
05061
05062 uint32_t Cassandra_describe_partitioner_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
05063
05064 uint32_t xfer = 0;
05065 std::string fname;
05066 ::apache::thrift::protocol::TType ftype;
05067 int16_t fid;
05068
05069 xfer += iprot->readStructBegin(fname);
05070
05071 using ::apache::thrift::protocol::TProtocolException;
05072
05073
05074 while (true)
05075 {
05076 xfer += iprot->readFieldBegin(fname, ftype, fid);
05077 if (ftype == ::apache::thrift::protocol::T_STOP) {
05078 break;
05079 }
05080 switch (fid)
05081 {
05082 case 0:
05083 if (ftype == ::apache::thrift::protocol::T_STRING) {
05084 xfer += iprot->readString((*(this->success)));
05085 this->__isset.success = true;
05086 } else {
05087 xfer += iprot->skip(ftype);
05088 }
05089 break;
05090 default:
05091 xfer += iprot->skip(ftype);
05092 break;
05093 }
05094 xfer += iprot->readFieldEnd();
05095 }
05096
05097 xfer += iprot->readStructEnd();
05098
05099 return xfer;
05100 }
05101
05102 uint32_t Cassandra_describe_snitch_args::read(::apache::thrift::protocol::TProtocol* iprot) {
05103
05104 uint32_t xfer = 0;
05105 std::string fname;
05106 ::apache::thrift::protocol::TType ftype;
05107 int16_t fid;
05108
05109 xfer += iprot->readStructBegin(fname);
05110
05111 using ::apache::thrift::protocol::TProtocolException;
05112
05113
05114 while (true)
05115 {
05116 xfer += iprot->readFieldBegin(fname, ftype, fid);
05117 if (ftype == ::apache::thrift::protocol::T_STOP) {
05118 break;
05119 }
05120 switch (fid)
05121 {
05122 default:
05123 xfer += iprot->skip(ftype);
05124 break;
05125 }
05126 xfer += iprot->readFieldEnd();
05127 }
05128
05129 xfer += iprot->readStructEnd();
05130
05131 return xfer;
05132 }
05133
05134 uint32_t Cassandra_describe_snitch_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
05135 uint32_t xfer = 0;
05136 xfer += oprot->writeStructBegin("Cassandra_describe_snitch_args");
05137 xfer += oprot->writeFieldStop();
05138 xfer += oprot->writeStructEnd();
05139 return xfer;
05140 }
05141
05142 uint32_t Cassandra_describe_snitch_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
05143 uint32_t xfer = 0;
05144 xfer += oprot->writeStructBegin("Cassandra_describe_snitch_pargs");
05145 xfer += oprot->writeFieldStop();
05146 xfer += oprot->writeStructEnd();
05147 return xfer;
05148 }
05149
05150 uint32_t Cassandra_describe_snitch_result::read(::apache::thrift::protocol::TProtocol* iprot) {
05151
05152 uint32_t xfer = 0;
05153 std::string fname;
05154 ::apache::thrift::protocol::TType ftype;
05155 int16_t fid;
05156
05157 xfer += iprot->readStructBegin(fname);
05158
05159 using ::apache::thrift::protocol::TProtocolException;
05160
05161
05162 while (true)
05163 {
05164 xfer += iprot->readFieldBegin(fname, ftype, fid);
05165 if (ftype == ::apache::thrift::protocol::T_STOP) {
05166 break;
05167 }
05168 switch (fid)
05169 {
05170 case 0:
05171 if (ftype == ::apache::thrift::protocol::T_STRING) {
05172 xfer += iprot->readString(this->success);
05173 this->__isset.success = true;
05174 } else {
05175 xfer += iprot->skip(ftype);
05176 }
05177 break;
05178 default:
05179 xfer += iprot->skip(ftype);
05180 break;
05181 }
05182 xfer += iprot->readFieldEnd();
05183 }
05184
05185 xfer += iprot->readStructEnd();
05186
05187 return xfer;
05188 }
05189
05190 uint32_t Cassandra_describe_snitch_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
05191
05192 uint32_t xfer = 0;
05193
05194 xfer += oprot->writeStructBegin("Cassandra_describe_snitch_result");
05195
05196 if (this->__isset.success) {
05197 xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRING, 0);
05198 xfer += oprot->writeString(this->success);
05199 xfer += oprot->writeFieldEnd();
05200 }
05201 xfer += oprot->writeFieldStop();
05202 xfer += oprot->writeStructEnd();
05203 return xfer;
05204 }
05205
05206 uint32_t Cassandra_describe_snitch_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
05207
05208 uint32_t xfer = 0;
05209 std::string fname;
05210 ::apache::thrift::protocol::TType ftype;
05211 int16_t fid;
05212
05213 xfer += iprot->readStructBegin(fname);
05214
05215 using ::apache::thrift::protocol::TProtocolException;
05216
05217
05218 while (true)
05219 {
05220 xfer += iprot->readFieldBegin(fname, ftype, fid);
05221 if (ftype == ::apache::thrift::protocol::T_STOP) {
05222 break;
05223 }
05224 switch (fid)
05225 {
05226 case 0:
05227 if (ftype == ::apache::thrift::protocol::T_STRING) {
05228 xfer += iprot->readString((*(this->success)));
05229 this->__isset.success = true;
05230 } else {
05231 xfer += iprot->skip(ftype);
05232 }
05233 break;
05234 default:
05235 xfer += iprot->skip(ftype);
05236 break;
05237 }
05238 xfer += iprot->readFieldEnd();
05239 }
05240
05241 xfer += iprot->readStructEnd();
05242
05243 return xfer;
05244 }
05245
05246 uint32_t Cassandra_describe_keyspace_args::read(::apache::thrift::protocol::TProtocol* iprot) {
05247
05248 uint32_t xfer = 0;
05249 std::string fname;
05250 ::apache::thrift::protocol::TType ftype;
05251 int16_t fid;
05252
05253 xfer += iprot->readStructBegin(fname);
05254
05255 using ::apache::thrift::protocol::TProtocolException;
05256
05257 bool isset_keyspace = false;
05258
05259 while (true)
05260 {
05261 xfer += iprot->readFieldBegin(fname, ftype, fid);
05262 if (ftype == ::apache::thrift::protocol::T_STOP) {
05263 break;
05264 }
05265 switch (fid)
05266 {
05267 case 1:
05268 if (ftype == ::apache::thrift::protocol::T_STRING) {
05269 xfer += iprot->readString(this->keyspace);
05270 isset_keyspace = true;
05271 } else {
05272 xfer += iprot->skip(ftype);
05273 }
05274 break;
05275 default:
05276 xfer += iprot->skip(ftype);
05277 break;
05278 }
05279 xfer += iprot->readFieldEnd();
05280 }
05281
05282 xfer += iprot->readStructEnd();
05283
05284 if (!isset_keyspace)
05285 throw TProtocolException(TProtocolException::INVALID_DATA);
05286 return xfer;
05287 }
05288
05289 uint32_t Cassandra_describe_keyspace_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
05290 uint32_t xfer = 0;
05291 xfer += oprot->writeStructBegin("Cassandra_describe_keyspace_args");
05292 xfer += oprot->writeFieldBegin("keyspace", ::apache::thrift::protocol::T_STRING, 1);
05293 xfer += oprot->writeString(this->keyspace);
05294 xfer += oprot->writeFieldEnd();
05295 xfer += oprot->writeFieldStop();
05296 xfer += oprot->writeStructEnd();
05297 return xfer;
05298 }
05299
05300 uint32_t Cassandra_describe_keyspace_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
05301 uint32_t xfer = 0;
05302 xfer += oprot->writeStructBegin("Cassandra_describe_keyspace_pargs");
05303 xfer += oprot->writeFieldBegin("keyspace", ::apache::thrift::protocol::T_STRING, 1);
05304 xfer += oprot->writeString((*(this->keyspace)));
05305 xfer += oprot->writeFieldEnd();
05306 xfer += oprot->writeFieldStop();
05307 xfer += oprot->writeStructEnd();
05308 return xfer;
05309 }
05310
05311 uint32_t Cassandra_describe_keyspace_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 0:
05332 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
05333 xfer += this->success.read(iprot);
05334 this->__isset.success = true;
05335 } else {
05336 xfer += iprot->skip(ftype);
05337 }
05338 break;
05339 case 1:
05340 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
05341 xfer += this->nfe.read(iprot);
05342 this->__isset.nfe = true;
05343 } else {
05344 xfer += iprot->skip(ftype);
05345 }
05346 break;
05347 case 2:
05348 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
05349 xfer += this->ire.read(iprot);
05350 this->__isset.ire = true;
05351 } else {
05352 xfer += iprot->skip(ftype);
05353 }
05354 break;
05355 default:
05356 xfer += iprot->skip(ftype);
05357 break;
05358 }
05359 xfer += iprot->readFieldEnd();
05360 }
05361
05362 xfer += iprot->readStructEnd();
05363
05364 return xfer;
05365 }
05366
05367 uint32_t Cassandra_describe_keyspace_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
05368
05369 uint32_t xfer = 0;
05370
05371 xfer += oprot->writeStructBegin("Cassandra_describe_keyspace_result");
05372
05373 if (this->__isset.success) {
05374 xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0);
05375 xfer += this->success.write(oprot);
05376 xfer += oprot->writeFieldEnd();
05377 } else if (this->__isset.nfe) {
05378 xfer += oprot->writeFieldBegin("nfe", ::apache::thrift::protocol::T_STRUCT, 1);
05379 xfer += this->nfe.write(oprot);
05380 xfer += oprot->writeFieldEnd();
05381 } else if (this->__isset.ire) {
05382 xfer += oprot->writeFieldBegin("ire", ::apache::thrift::protocol::T_STRUCT, 2);
05383 xfer += this->ire.write(oprot);
05384 xfer += oprot->writeFieldEnd();
05385 }
05386 xfer += oprot->writeFieldStop();
05387 xfer += oprot->writeStructEnd();
05388 return xfer;
05389 }
05390
05391 uint32_t Cassandra_describe_keyspace_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
05392
05393 uint32_t xfer = 0;
05394 std::string fname;
05395 ::apache::thrift::protocol::TType ftype;
05396 int16_t fid;
05397
05398 xfer += iprot->readStructBegin(fname);
05399
05400 using ::apache::thrift::protocol::TProtocolException;
05401
05402
05403 while (true)
05404 {
05405 xfer += iprot->readFieldBegin(fname, ftype, fid);
05406 if (ftype == ::apache::thrift::protocol::T_STOP) {
05407 break;
05408 }
05409 switch (fid)
05410 {
05411 case 0:
05412 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
05413 xfer += (*(this->success)).read(iprot);
05414 this->__isset.success = true;
05415 } else {
05416 xfer += iprot->skip(ftype);
05417 }
05418 break;
05419 case 1:
05420 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
05421 xfer += this->nfe.read(iprot);
05422 this->__isset.nfe = true;
05423 } else {
05424 xfer += iprot->skip(ftype);
05425 }
05426 break;
05427 case 2:
05428 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
05429 xfer += this->ire.read(iprot);
05430 this->__isset.ire = true;
05431 } else {
05432 xfer += iprot->skip(ftype);
05433 }
05434 break;
05435 default:
05436 xfer += iprot->skip(ftype);
05437 break;
05438 }
05439 xfer += iprot->readFieldEnd();
05440 }
05441
05442 xfer += iprot->readStructEnd();
05443
05444 return xfer;
05445 }
05446
05447 uint32_t Cassandra_describe_splits_args::read(::apache::thrift::protocol::TProtocol* iprot) {
05448
05449 uint32_t xfer = 0;
05450 std::string fname;
05451 ::apache::thrift::protocol::TType ftype;
05452 int16_t fid;
05453
05454 xfer += iprot->readStructBegin(fname);
05455
05456 using ::apache::thrift::protocol::TProtocolException;
05457
05458 bool isset_cfName = false;
05459 bool isset_start_token = false;
05460 bool isset_end_token = false;
05461 bool isset_keys_per_split = false;
05462
05463 while (true)
05464 {
05465 xfer += iprot->readFieldBegin(fname, ftype, fid);
05466 if (ftype == ::apache::thrift::protocol::T_STOP) {
05467 break;
05468 }
05469 switch (fid)
05470 {
05471 case 1:
05472 if (ftype == ::apache::thrift::protocol::T_STRING) {
05473 xfer += iprot->readString(this->cfName);
05474 isset_cfName = true;
05475 } else {
05476 xfer += iprot->skip(ftype);
05477 }
05478 break;
05479 case 2:
05480 if (ftype == ::apache::thrift::protocol::T_STRING) {
05481 xfer += iprot->readString(this->start_token);
05482 isset_start_token = true;
05483 } else {
05484 xfer += iprot->skip(ftype);
05485 }
05486 break;
05487 case 3:
05488 if (ftype == ::apache::thrift::protocol::T_STRING) {
05489 xfer += iprot->readString(this->end_token);
05490 isset_end_token = true;
05491 } else {
05492 xfer += iprot->skip(ftype);
05493 }
05494 break;
05495 case 4:
05496 if (ftype == ::apache::thrift::protocol::T_I32) {
05497 xfer += iprot->readI32(this->keys_per_split);
05498 isset_keys_per_split = true;
05499 } else {
05500 xfer += iprot->skip(ftype);
05501 }
05502 break;
05503 default:
05504 xfer += iprot->skip(ftype);
05505 break;
05506 }
05507 xfer += iprot->readFieldEnd();
05508 }
05509
05510 xfer += iprot->readStructEnd();
05511
05512 if (!isset_cfName)
05513 throw TProtocolException(TProtocolException::INVALID_DATA);
05514 if (!isset_start_token)
05515 throw TProtocolException(TProtocolException::INVALID_DATA);
05516 if (!isset_end_token)
05517 throw TProtocolException(TProtocolException::INVALID_DATA);
05518 if (!isset_keys_per_split)
05519 throw TProtocolException(TProtocolException::INVALID_DATA);
05520 return xfer;
05521 }
05522
05523 uint32_t Cassandra_describe_splits_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
05524 uint32_t xfer = 0;
05525 xfer += oprot->writeStructBegin("Cassandra_describe_splits_args");
05526 xfer += oprot->writeFieldBegin("cfName", ::apache::thrift::protocol::T_STRING, 1);
05527 xfer += oprot->writeString(this->cfName);
05528 xfer += oprot->writeFieldEnd();
05529 xfer += oprot->writeFieldBegin("start_token", ::apache::thrift::protocol::T_STRING, 2);
05530 xfer += oprot->writeString(this->start_token);
05531 xfer += oprot->writeFieldEnd();
05532 xfer += oprot->writeFieldBegin("end_token", ::apache::thrift::protocol::T_STRING, 3);
05533 xfer += oprot->writeString(this->end_token);
05534 xfer += oprot->writeFieldEnd();
05535 xfer += oprot->writeFieldBegin("keys_per_split", ::apache::thrift::protocol::T_I32, 4);
05536 xfer += oprot->writeI32(this->keys_per_split);
05537 xfer += oprot->writeFieldEnd();
05538 xfer += oprot->writeFieldStop();
05539 xfer += oprot->writeStructEnd();
05540 return xfer;
05541 }
05542
05543 uint32_t Cassandra_describe_splits_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
05544 uint32_t xfer = 0;
05545 xfer += oprot->writeStructBegin("Cassandra_describe_splits_pargs");
05546 xfer += oprot->writeFieldBegin("cfName", ::apache::thrift::protocol::T_STRING, 1);
05547 xfer += oprot->writeString((*(this->cfName)));
05548 xfer += oprot->writeFieldEnd();
05549 xfer += oprot->writeFieldBegin("start_token", ::apache::thrift::protocol::T_STRING, 2);
05550 xfer += oprot->writeString((*(this->start_token)));
05551 xfer += oprot->writeFieldEnd();
05552 xfer += oprot->writeFieldBegin("end_token", ::apache::thrift::protocol::T_STRING, 3);
05553 xfer += oprot->writeString((*(this->end_token)));
05554 xfer += oprot->writeFieldEnd();
05555 xfer += oprot->writeFieldBegin("keys_per_split", ::apache::thrift::protocol::T_I32, 4);
05556 xfer += oprot->writeI32((*(this->keys_per_split)));
05557 xfer += oprot->writeFieldEnd();
05558 xfer += oprot->writeFieldStop();
05559 xfer += oprot->writeStructEnd();
05560 return xfer;
05561 }
05562
05563 uint32_t Cassandra_describe_splits_result::read(::apache::thrift::protocol::TProtocol* iprot) {
05564
05565 uint32_t xfer = 0;
05566 std::string fname;
05567 ::apache::thrift::protocol::TType ftype;
05568 int16_t fid;
05569
05570 xfer += iprot->readStructBegin(fname);
05571
05572 using ::apache::thrift::protocol::TProtocolException;
05573
05574
05575 while (true)
05576 {
05577 xfer += iprot->readFieldBegin(fname, ftype, fid);
05578 if (ftype == ::apache::thrift::protocol::T_STOP) {
05579 break;
05580 }
05581 switch (fid)
05582 {
05583 case 0:
05584 if (ftype == ::apache::thrift::protocol::T_LIST) {
05585 {
05586 this->success.clear();
05587 uint32_t _size304;
05588 ::apache::thrift::protocol::TType _etype307;
05589 iprot->readListBegin(_etype307, _size304);
05590 this->success.resize(_size304);
05591 uint32_t _i308;
05592 for (_i308 = 0; _i308 < _size304; ++_i308)
05593 {
05594 xfer += iprot->readString(this->success[_i308]);
05595 }
05596 iprot->readListEnd();
05597 }
05598 this->__isset.success = true;
05599 } else {
05600 xfer += iprot->skip(ftype);
05601 }
05602 break;
05603 case 1:
05604 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
05605 xfer += this->ire.read(iprot);
05606 this->__isset.ire = true;
05607 } else {
05608 xfer += iprot->skip(ftype);
05609 }
05610 break;
05611 default:
05612 xfer += iprot->skip(ftype);
05613 break;
05614 }
05615 xfer += iprot->readFieldEnd();
05616 }
05617
05618 xfer += iprot->readStructEnd();
05619
05620 return xfer;
05621 }
05622
05623 uint32_t Cassandra_describe_splits_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
05624
05625 uint32_t xfer = 0;
05626
05627 xfer += oprot->writeStructBegin("Cassandra_describe_splits_result");
05628
05629 if (this->__isset.success) {
05630 xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0);
05631 {
05632 xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, this->success.size());
05633 std::vector<std::string> ::const_iterator _iter309;
05634 for (_iter309 = this->success.begin(); _iter309 != this->success.end(); ++_iter309)
05635 {
05636 xfer += oprot->writeString((*_iter309));
05637 }
05638 xfer += oprot->writeListEnd();
05639 }
05640 xfer += oprot->writeFieldEnd();
05641 } else if (this->__isset.ire) {
05642 xfer += oprot->writeFieldBegin("ire", ::apache::thrift::protocol::T_STRUCT, 1);
05643 xfer += this->ire.write(oprot);
05644 xfer += oprot->writeFieldEnd();
05645 }
05646 xfer += oprot->writeFieldStop();
05647 xfer += oprot->writeStructEnd();
05648 return xfer;
05649 }
05650
05651 uint32_t Cassandra_describe_splits_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
05652
05653 uint32_t xfer = 0;
05654 std::string fname;
05655 ::apache::thrift::protocol::TType ftype;
05656 int16_t fid;
05657
05658 xfer += iprot->readStructBegin(fname);
05659
05660 using ::apache::thrift::protocol::TProtocolException;
05661
05662
05663 while (true)
05664 {
05665 xfer += iprot->readFieldBegin(fname, ftype, fid);
05666 if (ftype == ::apache::thrift::protocol::T_STOP) {
05667 break;
05668 }
05669 switch (fid)
05670 {
05671 case 0:
05672 if (ftype == ::apache::thrift::protocol::T_LIST) {
05673 {
05674 (*(this->success)).clear();
05675 uint32_t _size310;
05676 ::apache::thrift::protocol::TType _etype313;
05677 iprot->readListBegin(_etype313, _size310);
05678 (*(this->success)).resize(_size310);
05679 uint32_t _i314;
05680 for (_i314 = 0; _i314 < _size310; ++_i314)
05681 {
05682 xfer += iprot->readString((*(this->success))[_i314]);
05683 }
05684 iprot->readListEnd();
05685 }
05686 this->__isset.success = true;
05687 } else {
05688 xfer += iprot->skip(ftype);
05689 }
05690 break;
05691 case 1:
05692 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
05693 xfer += this->ire.read(iprot);
05694 this->__isset.ire = true;
05695 } else {
05696 xfer += iprot->skip(ftype);
05697 }
05698 break;
05699 default:
05700 xfer += iprot->skip(ftype);
05701 break;
05702 }
05703 xfer += iprot->readFieldEnd();
05704 }
05705
05706 xfer += iprot->readStructEnd();
05707
05708 return xfer;
05709 }
05710
05711 uint32_t Cassandra_system_add_column_family_args::read(::apache::thrift::protocol::TProtocol* iprot) {
05712
05713 uint32_t xfer = 0;
05714 std::string fname;
05715 ::apache::thrift::protocol::TType ftype;
05716 int16_t fid;
05717
05718 xfer += iprot->readStructBegin(fname);
05719
05720 using ::apache::thrift::protocol::TProtocolException;
05721
05722 bool isset_cf_def = false;
05723
05724 while (true)
05725 {
05726 xfer += iprot->readFieldBegin(fname, ftype, fid);
05727 if (ftype == ::apache::thrift::protocol::T_STOP) {
05728 break;
05729 }
05730 switch (fid)
05731 {
05732 case 1:
05733 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
05734 xfer += this->cf_def.read(iprot);
05735 isset_cf_def = true;
05736 } else {
05737 xfer += iprot->skip(ftype);
05738 }
05739 break;
05740 default:
05741 xfer += iprot->skip(ftype);
05742 break;
05743 }
05744 xfer += iprot->readFieldEnd();
05745 }
05746
05747 xfer += iprot->readStructEnd();
05748
05749 if (!isset_cf_def)
05750 throw TProtocolException(TProtocolException::INVALID_DATA);
05751 return xfer;
05752 }
05753
05754 uint32_t Cassandra_system_add_column_family_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
05755 uint32_t xfer = 0;
05756 xfer += oprot->writeStructBegin("Cassandra_system_add_column_family_args");
05757 xfer += oprot->writeFieldBegin("cf_def", ::apache::thrift::protocol::T_STRUCT, 1);
05758 xfer += this->cf_def.write(oprot);
05759 xfer += oprot->writeFieldEnd();
05760 xfer += oprot->writeFieldStop();
05761 xfer += oprot->writeStructEnd();
05762 return xfer;
05763 }
05764
05765 uint32_t Cassandra_system_add_column_family_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
05766 uint32_t xfer = 0;
05767 xfer += oprot->writeStructBegin("Cassandra_system_add_column_family_pargs");
05768 xfer += oprot->writeFieldBegin("cf_def", ::apache::thrift::protocol::T_STRUCT, 1);
05769 xfer += (*(this->cf_def)).write(oprot);
05770 xfer += oprot->writeFieldEnd();
05771 xfer += oprot->writeFieldStop();
05772 xfer += oprot->writeStructEnd();
05773 return xfer;
05774 }
05775
05776 uint32_t Cassandra_system_add_column_family_result::read(::apache::thrift::protocol::TProtocol* iprot) {
05777
05778 uint32_t xfer = 0;
05779 std::string fname;
05780 ::apache::thrift::protocol::TType ftype;
05781 int16_t fid;
05782
05783 xfer += iprot->readStructBegin(fname);
05784
05785 using ::apache::thrift::protocol::TProtocolException;
05786
05787
05788 while (true)
05789 {
05790 xfer += iprot->readFieldBegin(fname, ftype, fid);
05791 if (ftype == ::apache::thrift::protocol::T_STOP) {
05792 break;
05793 }
05794 switch (fid)
05795 {
05796 case 0:
05797 if (ftype == ::apache::thrift::protocol::T_STRING) {
05798 xfer += iprot->readString(this->success);
05799 this->__isset.success = true;
05800 } else {
05801 xfer += iprot->skip(ftype);
05802 }
05803 break;
05804 case 1:
05805 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
05806 xfer += this->ire.read(iprot);
05807 this->__isset.ire = true;
05808 } else {
05809 xfer += iprot->skip(ftype);
05810 }
05811 break;
05812 case 2:
05813 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
05814 xfer += this->sde.read(iprot);
05815 this->__isset.sde = true;
05816 } else {
05817 xfer += iprot->skip(ftype);
05818 }
05819 break;
05820 default:
05821 xfer += iprot->skip(ftype);
05822 break;
05823 }
05824 xfer += iprot->readFieldEnd();
05825 }
05826
05827 xfer += iprot->readStructEnd();
05828
05829 return xfer;
05830 }
05831
05832 uint32_t Cassandra_system_add_column_family_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
05833
05834 uint32_t xfer = 0;
05835
05836 xfer += oprot->writeStructBegin("Cassandra_system_add_column_family_result");
05837
05838 if (this->__isset.success) {
05839 xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRING, 0);
05840 xfer += oprot->writeString(this->success);
05841 xfer += oprot->writeFieldEnd();
05842 } else if (this->__isset.ire) {
05843 xfer += oprot->writeFieldBegin("ire", ::apache::thrift::protocol::T_STRUCT, 1);
05844 xfer += this->ire.write(oprot);
05845 xfer += oprot->writeFieldEnd();
05846 } else if (this->__isset.sde) {
05847 xfer += oprot->writeFieldBegin("sde", ::apache::thrift::protocol::T_STRUCT, 2);
05848 xfer += this->sde.write(oprot);
05849 xfer += oprot->writeFieldEnd();
05850 }
05851 xfer += oprot->writeFieldStop();
05852 xfer += oprot->writeStructEnd();
05853 return xfer;
05854 }
05855
05856 uint32_t Cassandra_system_add_column_family_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
05857
05858 uint32_t xfer = 0;
05859 std::string fname;
05860 ::apache::thrift::protocol::TType ftype;
05861 int16_t fid;
05862
05863 xfer += iprot->readStructBegin(fname);
05864
05865 using ::apache::thrift::protocol::TProtocolException;
05866
05867
05868 while (true)
05869 {
05870 xfer += iprot->readFieldBegin(fname, ftype, fid);
05871 if (ftype == ::apache::thrift::protocol::T_STOP) {
05872 break;
05873 }
05874 switch (fid)
05875 {
05876 case 0:
05877 if (ftype == ::apache::thrift::protocol::T_STRING) {
05878 xfer += iprot->readString((*(this->success)));
05879 this->__isset.success = true;
05880 } else {
05881 xfer += iprot->skip(ftype);
05882 }
05883 break;
05884 case 1:
05885 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
05886 xfer += this->ire.read(iprot);
05887 this->__isset.ire = true;
05888 } else {
05889 xfer += iprot->skip(ftype);
05890 }
05891 break;
05892 case 2:
05893 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
05894 xfer += this->sde.read(iprot);
05895 this->__isset.sde = true;
05896 } else {
05897 xfer += iprot->skip(ftype);
05898 }
05899 break;
05900 default:
05901 xfer += iprot->skip(ftype);
05902 break;
05903 }
05904 xfer += iprot->readFieldEnd();
05905 }
05906
05907 xfer += iprot->readStructEnd();
05908
05909 return xfer;
05910 }
05911
05912 uint32_t Cassandra_system_drop_column_family_args::read(::apache::thrift::protocol::TProtocol* iprot) {
05913
05914 uint32_t xfer = 0;
05915 std::string fname;
05916 ::apache::thrift::protocol::TType ftype;
05917 int16_t fid;
05918
05919 xfer += iprot->readStructBegin(fname);
05920
05921 using ::apache::thrift::protocol::TProtocolException;
05922
05923 bool isset_column_family = false;
05924
05925 while (true)
05926 {
05927 xfer += iprot->readFieldBegin(fname, ftype, fid);
05928 if (ftype == ::apache::thrift::protocol::T_STOP) {
05929 break;
05930 }
05931 switch (fid)
05932 {
05933 case 1:
05934 if (ftype == ::apache::thrift::protocol::T_STRING) {
05935 xfer += iprot->readString(this->column_family);
05936 isset_column_family = true;
05937 } else {
05938 xfer += iprot->skip(ftype);
05939 }
05940 break;
05941 default:
05942 xfer += iprot->skip(ftype);
05943 break;
05944 }
05945 xfer += iprot->readFieldEnd();
05946 }
05947
05948 xfer += iprot->readStructEnd();
05949
05950 if (!isset_column_family)
05951 throw TProtocolException(TProtocolException::INVALID_DATA);
05952 return xfer;
05953 }
05954
05955 uint32_t Cassandra_system_drop_column_family_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
05956 uint32_t xfer = 0;
05957 xfer += oprot->writeStructBegin("Cassandra_system_drop_column_family_args");
05958 xfer += oprot->writeFieldBegin("column_family", ::apache::thrift::protocol::T_STRING, 1);
05959 xfer += oprot->writeString(this->column_family);
05960 xfer += oprot->writeFieldEnd();
05961 xfer += oprot->writeFieldStop();
05962 xfer += oprot->writeStructEnd();
05963 return xfer;
05964 }
05965
05966 uint32_t Cassandra_system_drop_column_family_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
05967 uint32_t xfer = 0;
05968 xfer += oprot->writeStructBegin("Cassandra_system_drop_column_family_pargs");
05969 xfer += oprot->writeFieldBegin("column_family", ::apache::thrift::protocol::T_STRING, 1);
05970 xfer += oprot->writeString((*(this->column_family)));
05971 xfer += oprot->writeFieldEnd();
05972 xfer += oprot->writeFieldStop();
05973 xfer += oprot->writeStructEnd();
05974 return xfer;
05975 }
05976
05977 uint32_t Cassandra_system_drop_column_family_result::read(::apache::thrift::protocol::TProtocol* iprot) {
05978
05979 uint32_t xfer = 0;
05980 std::string fname;
05981 ::apache::thrift::protocol::TType ftype;
05982 int16_t fid;
05983
05984 xfer += iprot->readStructBegin(fname);
05985
05986 using ::apache::thrift::protocol::TProtocolException;
05987
05988
05989 while (true)
05990 {
05991 xfer += iprot->readFieldBegin(fname, ftype, fid);
05992 if (ftype == ::apache::thrift::protocol::T_STOP) {
05993 break;
05994 }
05995 switch (fid)
05996 {
05997 case 0:
05998 if (ftype == ::apache::thrift::protocol::T_STRING) {
05999 xfer += iprot->readString(this->success);
06000 this->__isset.success = true;
06001 } else {
06002 xfer += iprot->skip(ftype);
06003 }
06004 break;
06005 case 1:
06006 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
06007 xfer += this->ire.read(iprot);
06008 this->__isset.ire = true;
06009 } else {
06010 xfer += iprot->skip(ftype);
06011 }
06012 break;
06013 case 2:
06014 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
06015 xfer += this->sde.read(iprot);
06016 this->__isset.sde = true;
06017 } else {
06018 xfer += iprot->skip(ftype);
06019 }
06020 break;
06021 default:
06022 xfer += iprot->skip(ftype);
06023 break;
06024 }
06025 xfer += iprot->readFieldEnd();
06026 }
06027
06028 xfer += iprot->readStructEnd();
06029
06030 return xfer;
06031 }
06032
06033 uint32_t Cassandra_system_drop_column_family_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
06034
06035 uint32_t xfer = 0;
06036
06037 xfer += oprot->writeStructBegin("Cassandra_system_drop_column_family_result");
06038
06039 if (this->__isset.success) {
06040 xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRING, 0);
06041 xfer += oprot->writeString(this->success);
06042 xfer += oprot->writeFieldEnd();
06043 } else if (this->__isset.ire) {
06044 xfer += oprot->writeFieldBegin("ire", ::apache::thrift::protocol::T_STRUCT, 1);
06045 xfer += this->ire.write(oprot);
06046 xfer += oprot->writeFieldEnd();
06047 } else if (this->__isset.sde) {
06048 xfer += oprot->writeFieldBegin("sde", ::apache::thrift::protocol::T_STRUCT, 2);
06049 xfer += this->sde.write(oprot);
06050 xfer += oprot->writeFieldEnd();
06051 }
06052 xfer += oprot->writeFieldStop();
06053 xfer += oprot->writeStructEnd();
06054 return xfer;
06055 }
06056
06057 uint32_t Cassandra_system_drop_column_family_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
06058
06059 uint32_t xfer = 0;
06060 std::string fname;
06061 ::apache::thrift::protocol::TType ftype;
06062 int16_t fid;
06063
06064 xfer += iprot->readStructBegin(fname);
06065
06066 using ::apache::thrift::protocol::TProtocolException;
06067
06068
06069 while (true)
06070 {
06071 xfer += iprot->readFieldBegin(fname, ftype, fid);
06072 if (ftype == ::apache::thrift::protocol::T_STOP) {
06073 break;
06074 }
06075 switch (fid)
06076 {
06077 case 0:
06078 if (ftype == ::apache::thrift::protocol::T_STRING) {
06079 xfer += iprot->readString((*(this->success)));
06080 this->__isset.success = true;
06081 } else {
06082 xfer += iprot->skip(ftype);
06083 }
06084 break;
06085 case 1:
06086 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
06087 xfer += this->ire.read(iprot);
06088 this->__isset.ire = true;
06089 } else {
06090 xfer += iprot->skip(ftype);
06091 }
06092 break;
06093 case 2:
06094 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
06095 xfer += this->sde.read(iprot);
06096 this->__isset.sde = true;
06097 } else {
06098 xfer += iprot->skip(ftype);
06099 }
06100 break;
06101 default:
06102 xfer += iprot->skip(ftype);
06103 break;
06104 }
06105 xfer += iprot->readFieldEnd();
06106 }
06107
06108 xfer += iprot->readStructEnd();
06109
06110 return xfer;
06111 }
06112
06113 uint32_t Cassandra_system_add_keyspace_args::read(::apache::thrift::protocol::TProtocol* iprot) {
06114
06115 uint32_t xfer = 0;
06116 std::string fname;
06117 ::apache::thrift::protocol::TType ftype;
06118 int16_t fid;
06119
06120 xfer += iprot->readStructBegin(fname);
06121
06122 using ::apache::thrift::protocol::TProtocolException;
06123
06124 bool isset_ks_def = false;
06125
06126 while (true)
06127 {
06128 xfer += iprot->readFieldBegin(fname, ftype, fid);
06129 if (ftype == ::apache::thrift::protocol::T_STOP) {
06130 break;
06131 }
06132 switch (fid)
06133 {
06134 case 1:
06135 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
06136 xfer += this->ks_def.read(iprot);
06137 isset_ks_def = true;
06138 } else {
06139 xfer += iprot->skip(ftype);
06140 }
06141 break;
06142 default:
06143 xfer += iprot->skip(ftype);
06144 break;
06145 }
06146 xfer += iprot->readFieldEnd();
06147 }
06148
06149 xfer += iprot->readStructEnd();
06150
06151 if (!isset_ks_def)
06152 throw TProtocolException(TProtocolException::INVALID_DATA);
06153 return xfer;
06154 }
06155
06156 uint32_t Cassandra_system_add_keyspace_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
06157 uint32_t xfer = 0;
06158 xfer += oprot->writeStructBegin("Cassandra_system_add_keyspace_args");
06159 xfer += oprot->writeFieldBegin("ks_def", ::apache::thrift::protocol::T_STRUCT, 1);
06160 xfer += this->ks_def.write(oprot);
06161 xfer += oprot->writeFieldEnd();
06162 xfer += oprot->writeFieldStop();
06163 xfer += oprot->writeStructEnd();
06164 return xfer;
06165 }
06166
06167 uint32_t Cassandra_system_add_keyspace_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
06168 uint32_t xfer = 0;
06169 xfer += oprot->writeStructBegin("Cassandra_system_add_keyspace_pargs");
06170 xfer += oprot->writeFieldBegin("ks_def", ::apache::thrift::protocol::T_STRUCT, 1);
06171 xfer += (*(this->ks_def)).write(oprot);
06172 xfer += oprot->writeFieldEnd();
06173 xfer += oprot->writeFieldStop();
06174 xfer += oprot->writeStructEnd();
06175 return xfer;
06176 }
06177
06178 uint32_t Cassandra_system_add_keyspace_result::read(::apache::thrift::protocol::TProtocol* iprot) {
06179
06180 uint32_t xfer = 0;
06181 std::string fname;
06182 ::apache::thrift::protocol::TType ftype;
06183 int16_t fid;
06184
06185 xfer += iprot->readStructBegin(fname);
06186
06187 using ::apache::thrift::protocol::TProtocolException;
06188
06189
06190 while (true)
06191 {
06192 xfer += iprot->readFieldBegin(fname, ftype, fid);
06193 if (ftype == ::apache::thrift::protocol::T_STOP) {
06194 break;
06195 }
06196 switch (fid)
06197 {
06198 case 0:
06199 if (ftype == ::apache::thrift::protocol::T_STRING) {
06200 xfer += iprot->readString(this->success);
06201 this->__isset.success = true;
06202 } else {
06203 xfer += iprot->skip(ftype);
06204 }
06205 break;
06206 case 1:
06207 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
06208 xfer += this->ire.read(iprot);
06209 this->__isset.ire = true;
06210 } else {
06211 xfer += iprot->skip(ftype);
06212 }
06213 break;
06214 case 2:
06215 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
06216 xfer += this->sde.read(iprot);
06217 this->__isset.sde = true;
06218 } else {
06219 xfer += iprot->skip(ftype);
06220 }
06221 break;
06222 default:
06223 xfer += iprot->skip(ftype);
06224 break;
06225 }
06226 xfer += iprot->readFieldEnd();
06227 }
06228
06229 xfer += iprot->readStructEnd();
06230
06231 return xfer;
06232 }
06233
06234 uint32_t Cassandra_system_add_keyspace_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
06235
06236 uint32_t xfer = 0;
06237
06238 xfer += oprot->writeStructBegin("Cassandra_system_add_keyspace_result");
06239
06240 if (this->__isset.success) {
06241 xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRING, 0);
06242 xfer += oprot->writeString(this->success);
06243 xfer += oprot->writeFieldEnd();
06244 } else if (this->__isset.ire) {
06245 xfer += oprot->writeFieldBegin("ire", ::apache::thrift::protocol::T_STRUCT, 1);
06246 xfer += this->ire.write(oprot);
06247 xfer += oprot->writeFieldEnd();
06248 } else if (this->__isset.sde) {
06249 xfer += oprot->writeFieldBegin("sde", ::apache::thrift::protocol::T_STRUCT, 2);
06250 xfer += this->sde.write(oprot);
06251 xfer += oprot->writeFieldEnd();
06252 }
06253 xfer += oprot->writeFieldStop();
06254 xfer += oprot->writeStructEnd();
06255 return xfer;
06256 }
06257
06258 uint32_t Cassandra_system_add_keyspace_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
06259
06260 uint32_t xfer = 0;
06261 std::string fname;
06262 ::apache::thrift::protocol::TType ftype;
06263 int16_t fid;
06264
06265 xfer += iprot->readStructBegin(fname);
06266
06267 using ::apache::thrift::protocol::TProtocolException;
06268
06269
06270 while (true)
06271 {
06272 xfer += iprot->readFieldBegin(fname, ftype, fid);
06273 if (ftype == ::apache::thrift::protocol::T_STOP) {
06274 break;
06275 }
06276 switch (fid)
06277 {
06278 case 0:
06279 if (ftype == ::apache::thrift::protocol::T_STRING) {
06280 xfer += iprot->readString((*(this->success)));
06281 this->__isset.success = true;
06282 } else {
06283 xfer += iprot->skip(ftype);
06284 }
06285 break;
06286 case 1:
06287 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
06288 xfer += this->ire.read(iprot);
06289 this->__isset.ire = true;
06290 } else {
06291 xfer += iprot->skip(ftype);
06292 }
06293 break;
06294 case 2:
06295 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
06296 xfer += this->sde.read(iprot);
06297 this->__isset.sde = true;
06298 } else {
06299 xfer += iprot->skip(ftype);
06300 }
06301 break;
06302 default:
06303 xfer += iprot->skip(ftype);
06304 break;
06305 }
06306 xfer += iprot->readFieldEnd();
06307 }
06308
06309 xfer += iprot->readStructEnd();
06310
06311 return xfer;
06312 }
06313
06314 uint32_t Cassandra_system_drop_keyspace_args::read(::apache::thrift::protocol::TProtocol* iprot) {
06315
06316 uint32_t xfer = 0;
06317 std::string fname;
06318 ::apache::thrift::protocol::TType ftype;
06319 int16_t fid;
06320
06321 xfer += iprot->readStructBegin(fname);
06322
06323 using ::apache::thrift::protocol::TProtocolException;
06324
06325 bool isset_keyspace = false;
06326
06327 while (true)
06328 {
06329 xfer += iprot->readFieldBegin(fname, ftype, fid);
06330 if (ftype == ::apache::thrift::protocol::T_STOP) {
06331 break;
06332 }
06333 switch (fid)
06334 {
06335 case 1:
06336 if (ftype == ::apache::thrift::protocol::T_STRING) {
06337 xfer += iprot->readString(this->keyspace);
06338 isset_keyspace = true;
06339 } else {
06340 xfer += iprot->skip(ftype);
06341 }
06342 break;
06343 default:
06344 xfer += iprot->skip(ftype);
06345 break;
06346 }
06347 xfer += iprot->readFieldEnd();
06348 }
06349
06350 xfer += iprot->readStructEnd();
06351
06352 if (!isset_keyspace)
06353 throw TProtocolException(TProtocolException::INVALID_DATA);
06354 return xfer;
06355 }
06356
06357 uint32_t Cassandra_system_drop_keyspace_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
06358 uint32_t xfer = 0;
06359 xfer += oprot->writeStructBegin("Cassandra_system_drop_keyspace_args");
06360 xfer += oprot->writeFieldBegin("keyspace", ::apache::thrift::protocol::T_STRING, 1);
06361 xfer += oprot->writeString(this->keyspace);
06362 xfer += oprot->writeFieldEnd();
06363 xfer += oprot->writeFieldStop();
06364 xfer += oprot->writeStructEnd();
06365 return xfer;
06366 }
06367
06368 uint32_t Cassandra_system_drop_keyspace_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
06369 uint32_t xfer = 0;
06370 xfer += oprot->writeStructBegin("Cassandra_system_drop_keyspace_pargs");
06371 xfer += oprot->writeFieldBegin("keyspace", ::apache::thrift::protocol::T_STRING, 1);
06372 xfer += oprot->writeString((*(this->keyspace)));
06373 xfer += oprot->writeFieldEnd();
06374 xfer += oprot->writeFieldStop();
06375 xfer += oprot->writeStructEnd();
06376 return xfer;
06377 }
06378
06379 uint32_t Cassandra_system_drop_keyspace_result::read(::apache::thrift::protocol::TProtocol* iprot) {
06380
06381 uint32_t xfer = 0;
06382 std::string fname;
06383 ::apache::thrift::protocol::TType ftype;
06384 int16_t fid;
06385
06386 xfer += iprot->readStructBegin(fname);
06387
06388 using ::apache::thrift::protocol::TProtocolException;
06389
06390
06391 while (true)
06392 {
06393 xfer += iprot->readFieldBegin(fname, ftype, fid);
06394 if (ftype == ::apache::thrift::protocol::T_STOP) {
06395 break;
06396 }
06397 switch (fid)
06398 {
06399 case 0:
06400 if (ftype == ::apache::thrift::protocol::T_STRING) {
06401 xfer += iprot->readString(this->success);
06402 this->__isset.success = true;
06403 } else {
06404 xfer += iprot->skip(ftype);
06405 }
06406 break;
06407 case 1:
06408 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
06409 xfer += this->ire.read(iprot);
06410 this->__isset.ire = true;
06411 } else {
06412 xfer += iprot->skip(ftype);
06413 }
06414 break;
06415 case 2:
06416 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
06417 xfer += this->sde.read(iprot);
06418 this->__isset.sde = true;
06419 } else {
06420 xfer += iprot->skip(ftype);
06421 }
06422 break;
06423 default:
06424 xfer += iprot->skip(ftype);
06425 break;
06426 }
06427 xfer += iprot->readFieldEnd();
06428 }
06429
06430 xfer += iprot->readStructEnd();
06431
06432 return xfer;
06433 }
06434
06435 uint32_t Cassandra_system_drop_keyspace_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
06436
06437 uint32_t xfer = 0;
06438
06439 xfer += oprot->writeStructBegin("Cassandra_system_drop_keyspace_result");
06440
06441 if (this->__isset.success) {
06442 xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRING, 0);
06443 xfer += oprot->writeString(this->success);
06444 xfer += oprot->writeFieldEnd();
06445 } else if (this->__isset.ire) {
06446 xfer += oprot->writeFieldBegin("ire", ::apache::thrift::protocol::T_STRUCT, 1);
06447 xfer += this->ire.write(oprot);
06448 xfer += oprot->writeFieldEnd();
06449 } else if (this->__isset.sde) {
06450 xfer += oprot->writeFieldBegin("sde", ::apache::thrift::protocol::T_STRUCT, 2);
06451 xfer += this->sde.write(oprot);
06452 xfer += oprot->writeFieldEnd();
06453 }
06454 xfer += oprot->writeFieldStop();
06455 xfer += oprot->writeStructEnd();
06456 return xfer;
06457 }
06458
06459 uint32_t Cassandra_system_drop_keyspace_presult::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 0:
06480 if (ftype == ::apache::thrift::protocol::T_STRING) {
06481 xfer += iprot->readString((*(this->success)));
06482 this->__isset.success = true;
06483 } else {
06484 xfer += iprot->skip(ftype);
06485 }
06486 break;
06487 case 1:
06488 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
06489 xfer += this->ire.read(iprot);
06490 this->__isset.ire = true;
06491 } else {
06492 xfer += iprot->skip(ftype);
06493 }
06494 break;
06495 case 2:
06496 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
06497 xfer += this->sde.read(iprot);
06498 this->__isset.sde = 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 Cassandra_system_update_keyspace_args::read(::apache::thrift::protocol::TProtocol* iprot) {
06516
06517 uint32_t xfer = 0;
06518 std::string fname;
06519 ::apache::thrift::protocol::TType ftype;
06520 int16_t fid;
06521
06522 xfer += iprot->readStructBegin(fname);
06523
06524 using ::apache::thrift::protocol::TProtocolException;
06525
06526 bool isset_ks_def = false;
06527
06528 while (true)
06529 {
06530 xfer += iprot->readFieldBegin(fname, ftype, fid);
06531 if (ftype == ::apache::thrift::protocol::T_STOP) {
06532 break;
06533 }
06534 switch (fid)
06535 {
06536 case 1:
06537 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
06538 xfer += this->ks_def.read(iprot);
06539 isset_ks_def = true;
06540 } else {
06541 xfer += iprot->skip(ftype);
06542 }
06543 break;
06544 default:
06545 xfer += iprot->skip(ftype);
06546 break;
06547 }
06548 xfer += iprot->readFieldEnd();
06549 }
06550
06551 xfer += iprot->readStructEnd();
06552
06553 if (!isset_ks_def)
06554 throw TProtocolException(TProtocolException::INVALID_DATA);
06555 return xfer;
06556 }
06557
06558 uint32_t Cassandra_system_update_keyspace_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
06559 uint32_t xfer = 0;
06560 xfer += oprot->writeStructBegin("Cassandra_system_update_keyspace_args");
06561 xfer += oprot->writeFieldBegin("ks_def", ::apache::thrift::protocol::T_STRUCT, 1);
06562 xfer += this->ks_def.write(oprot);
06563 xfer += oprot->writeFieldEnd();
06564 xfer += oprot->writeFieldStop();
06565 xfer += oprot->writeStructEnd();
06566 return xfer;
06567 }
06568
06569 uint32_t Cassandra_system_update_keyspace_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
06570 uint32_t xfer = 0;
06571 xfer += oprot->writeStructBegin("Cassandra_system_update_keyspace_pargs");
06572 xfer += oprot->writeFieldBegin("ks_def", ::apache::thrift::protocol::T_STRUCT, 1);
06573 xfer += (*(this->ks_def)).write(oprot);
06574 xfer += oprot->writeFieldEnd();
06575 xfer += oprot->writeFieldStop();
06576 xfer += oprot->writeStructEnd();
06577 return xfer;
06578 }
06579
06580 uint32_t Cassandra_system_update_keyspace_result::read(::apache::thrift::protocol::TProtocol* iprot) {
06581
06582 uint32_t xfer = 0;
06583 std::string fname;
06584 ::apache::thrift::protocol::TType ftype;
06585 int16_t fid;
06586
06587 xfer += iprot->readStructBegin(fname);
06588
06589 using ::apache::thrift::protocol::TProtocolException;
06590
06591
06592 while (true)
06593 {
06594 xfer += iprot->readFieldBegin(fname, ftype, fid);
06595 if (ftype == ::apache::thrift::protocol::T_STOP) {
06596 break;
06597 }
06598 switch (fid)
06599 {
06600 case 0:
06601 if (ftype == ::apache::thrift::protocol::T_STRING) {
06602 xfer += iprot->readString(this->success);
06603 this->__isset.success = true;
06604 } else {
06605 xfer += iprot->skip(ftype);
06606 }
06607 break;
06608 case 1:
06609 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
06610 xfer += this->ire.read(iprot);
06611 this->__isset.ire = true;
06612 } else {
06613 xfer += iprot->skip(ftype);
06614 }
06615 break;
06616 case 2:
06617 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
06618 xfer += this->sde.read(iprot);
06619 this->__isset.sde = true;
06620 } else {
06621 xfer += iprot->skip(ftype);
06622 }
06623 break;
06624 default:
06625 xfer += iprot->skip(ftype);
06626 break;
06627 }
06628 xfer += iprot->readFieldEnd();
06629 }
06630
06631 xfer += iprot->readStructEnd();
06632
06633 return xfer;
06634 }
06635
06636 uint32_t Cassandra_system_update_keyspace_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
06637
06638 uint32_t xfer = 0;
06639
06640 xfer += oprot->writeStructBegin("Cassandra_system_update_keyspace_result");
06641
06642 if (this->__isset.success) {
06643 xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRING, 0);
06644 xfer += oprot->writeString(this->success);
06645 xfer += oprot->writeFieldEnd();
06646 } else if (this->__isset.ire) {
06647 xfer += oprot->writeFieldBegin("ire", ::apache::thrift::protocol::T_STRUCT, 1);
06648 xfer += this->ire.write(oprot);
06649 xfer += oprot->writeFieldEnd();
06650 } else if (this->__isset.sde) {
06651 xfer += oprot->writeFieldBegin("sde", ::apache::thrift::protocol::T_STRUCT, 2);
06652 xfer += this->sde.write(oprot);
06653 xfer += oprot->writeFieldEnd();
06654 }
06655 xfer += oprot->writeFieldStop();
06656 xfer += oprot->writeStructEnd();
06657 return xfer;
06658 }
06659
06660 uint32_t Cassandra_system_update_keyspace_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
06661
06662 uint32_t xfer = 0;
06663 std::string fname;
06664 ::apache::thrift::protocol::TType ftype;
06665 int16_t fid;
06666
06667 xfer += iprot->readStructBegin(fname);
06668
06669 using ::apache::thrift::protocol::TProtocolException;
06670
06671
06672 while (true)
06673 {
06674 xfer += iprot->readFieldBegin(fname, ftype, fid);
06675 if (ftype == ::apache::thrift::protocol::T_STOP) {
06676 break;
06677 }
06678 switch (fid)
06679 {
06680 case 0:
06681 if (ftype == ::apache::thrift::protocol::T_STRING) {
06682 xfer += iprot->readString((*(this->success)));
06683 this->__isset.success = true;
06684 } else {
06685 xfer += iprot->skip(ftype);
06686 }
06687 break;
06688 case 1:
06689 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
06690 xfer += this->ire.read(iprot);
06691 this->__isset.ire = true;
06692 } else {
06693 xfer += iprot->skip(ftype);
06694 }
06695 break;
06696 case 2:
06697 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
06698 xfer += this->sde.read(iprot);
06699 this->__isset.sde = true;
06700 } else {
06701 xfer += iprot->skip(ftype);
06702 }
06703 break;
06704 default:
06705 xfer += iprot->skip(ftype);
06706 break;
06707 }
06708 xfer += iprot->readFieldEnd();
06709 }
06710
06711 xfer += iprot->readStructEnd();
06712
06713 return xfer;
06714 }
06715
06716 uint32_t Cassandra_system_update_column_family_args::read(::apache::thrift::protocol::TProtocol* iprot) {
06717
06718 uint32_t xfer = 0;
06719 std::string fname;
06720 ::apache::thrift::protocol::TType ftype;
06721 int16_t fid;
06722
06723 xfer += iprot->readStructBegin(fname);
06724
06725 using ::apache::thrift::protocol::TProtocolException;
06726
06727 bool isset_cf_def = false;
06728
06729 while (true)
06730 {
06731 xfer += iprot->readFieldBegin(fname, ftype, fid);
06732 if (ftype == ::apache::thrift::protocol::T_STOP) {
06733 break;
06734 }
06735 switch (fid)
06736 {
06737 case 1:
06738 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
06739 xfer += this->cf_def.read(iprot);
06740 isset_cf_def = true;
06741 } else {
06742 xfer += iprot->skip(ftype);
06743 }
06744 break;
06745 default:
06746 xfer += iprot->skip(ftype);
06747 break;
06748 }
06749 xfer += iprot->readFieldEnd();
06750 }
06751
06752 xfer += iprot->readStructEnd();
06753
06754 if (!isset_cf_def)
06755 throw TProtocolException(TProtocolException::INVALID_DATA);
06756 return xfer;
06757 }
06758
06759 uint32_t Cassandra_system_update_column_family_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
06760 uint32_t xfer = 0;
06761 xfer += oprot->writeStructBegin("Cassandra_system_update_column_family_args");
06762 xfer += oprot->writeFieldBegin("cf_def", ::apache::thrift::protocol::T_STRUCT, 1);
06763 xfer += this->cf_def.write(oprot);
06764 xfer += oprot->writeFieldEnd();
06765 xfer += oprot->writeFieldStop();
06766 xfer += oprot->writeStructEnd();
06767 return xfer;
06768 }
06769
06770 uint32_t Cassandra_system_update_column_family_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
06771 uint32_t xfer = 0;
06772 xfer += oprot->writeStructBegin("Cassandra_system_update_column_family_pargs");
06773 xfer += oprot->writeFieldBegin("cf_def", ::apache::thrift::protocol::T_STRUCT, 1);
06774 xfer += (*(this->cf_def)).write(oprot);
06775 xfer += oprot->writeFieldEnd();
06776 xfer += oprot->writeFieldStop();
06777 xfer += oprot->writeStructEnd();
06778 return xfer;
06779 }
06780
06781 uint32_t Cassandra_system_update_column_family_result::read(::apache::thrift::protocol::TProtocol* iprot) {
06782
06783 uint32_t xfer = 0;
06784 std::string fname;
06785 ::apache::thrift::protocol::TType ftype;
06786 int16_t fid;
06787
06788 xfer += iprot->readStructBegin(fname);
06789
06790 using ::apache::thrift::protocol::TProtocolException;
06791
06792
06793 while (true)
06794 {
06795 xfer += iprot->readFieldBegin(fname, ftype, fid);
06796 if (ftype == ::apache::thrift::protocol::T_STOP) {
06797 break;
06798 }
06799 switch (fid)
06800 {
06801 case 0:
06802 if (ftype == ::apache::thrift::protocol::T_STRING) {
06803 xfer += iprot->readString(this->success);
06804 this->__isset.success = true;
06805 } else {
06806 xfer += iprot->skip(ftype);
06807 }
06808 break;
06809 case 1:
06810 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
06811 xfer += this->ire.read(iprot);
06812 this->__isset.ire = true;
06813 } else {
06814 xfer += iprot->skip(ftype);
06815 }
06816 break;
06817 case 2:
06818 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
06819 xfer += this->sde.read(iprot);
06820 this->__isset.sde = 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 Cassandra_system_update_column_family_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
06838
06839 uint32_t xfer = 0;
06840
06841 xfer += oprot->writeStructBegin("Cassandra_system_update_column_family_result");
06842
06843 if (this->__isset.success) {
06844 xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRING, 0);
06845 xfer += oprot->writeString(this->success);
06846 xfer += oprot->writeFieldEnd();
06847 } else if (this->__isset.ire) {
06848 xfer += oprot->writeFieldBegin("ire", ::apache::thrift::protocol::T_STRUCT, 1);
06849 xfer += this->ire.write(oprot);
06850 xfer += oprot->writeFieldEnd();
06851 } else if (this->__isset.sde) {
06852 xfer += oprot->writeFieldBegin("sde", ::apache::thrift::protocol::T_STRUCT, 2);
06853 xfer += this->sde.write(oprot);
06854 xfer += oprot->writeFieldEnd();
06855 }
06856 xfer += oprot->writeFieldStop();
06857 xfer += oprot->writeStructEnd();
06858 return xfer;
06859 }
06860
06861 uint32_t Cassandra_system_update_column_family_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
06862
06863 uint32_t xfer = 0;
06864 std::string fname;
06865 ::apache::thrift::protocol::TType ftype;
06866 int16_t fid;
06867
06868 xfer += iprot->readStructBegin(fname);
06869
06870 using ::apache::thrift::protocol::TProtocolException;
06871
06872
06873 while (true)
06874 {
06875 xfer += iprot->readFieldBegin(fname, ftype, fid);
06876 if (ftype == ::apache::thrift::protocol::T_STOP) {
06877 break;
06878 }
06879 switch (fid)
06880 {
06881 case 0:
06882 if (ftype == ::apache::thrift::protocol::T_STRING) {
06883 xfer += iprot->readString((*(this->success)));
06884 this->__isset.success = true;
06885 } else {
06886 xfer += iprot->skip(ftype);
06887 }
06888 break;
06889 case 1:
06890 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
06891 xfer += this->ire.read(iprot);
06892 this->__isset.ire = true;
06893 } else {
06894 xfer += iprot->skip(ftype);
06895 }
06896 break;
06897 case 2:
06898 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
06899 xfer += this->sde.read(iprot);
06900 this->__isset.sde = true;
06901 } else {
06902 xfer += iprot->skip(ftype);
06903 }
06904 break;
06905 default:
06906 xfer += iprot->skip(ftype);
06907 break;
06908 }
06909 xfer += iprot->readFieldEnd();
06910 }
06911
06912 xfer += iprot->readStructEnd();
06913
06914 return xfer;
06915 }
06916
06917 uint32_t Cassandra_execute_cql_query_args::read(::apache::thrift::protocol::TProtocol* iprot) {
06918
06919 uint32_t xfer = 0;
06920 std::string fname;
06921 ::apache::thrift::protocol::TType ftype;
06922 int16_t fid;
06923
06924 xfer += iprot->readStructBegin(fname);
06925
06926 using ::apache::thrift::protocol::TProtocolException;
06927
06928 bool isset_query = false;
06929 bool isset_compression = false;
06930
06931 while (true)
06932 {
06933 xfer += iprot->readFieldBegin(fname, ftype, fid);
06934 if (ftype == ::apache::thrift::protocol::T_STOP) {
06935 break;
06936 }
06937 switch (fid)
06938 {
06939 case 1:
06940 if (ftype == ::apache::thrift::protocol::T_STRING) {
06941 xfer += iprot->readBinary(this->query);
06942 isset_query = true;
06943 } else {
06944 xfer += iprot->skip(ftype);
06945 }
06946 break;
06947 case 2:
06948 if (ftype == ::apache::thrift::protocol::T_I32) {
06949 int32_t ecast315;
06950 xfer += iprot->readI32(ecast315);
06951 this->compression = (Compression::type)ecast315;
06952 isset_compression = true;
06953 } else {
06954 xfer += iprot->skip(ftype);
06955 }
06956 break;
06957 default:
06958 xfer += iprot->skip(ftype);
06959 break;
06960 }
06961 xfer += iprot->readFieldEnd();
06962 }
06963
06964 xfer += iprot->readStructEnd();
06965
06966 if (!isset_query)
06967 throw TProtocolException(TProtocolException::INVALID_DATA);
06968 if (!isset_compression)
06969 throw TProtocolException(TProtocolException::INVALID_DATA);
06970 return xfer;
06971 }
06972
06973 uint32_t Cassandra_execute_cql_query_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
06974 uint32_t xfer = 0;
06975 xfer += oprot->writeStructBegin("Cassandra_execute_cql_query_args");
06976 xfer += oprot->writeFieldBegin("query", ::apache::thrift::protocol::T_STRING, 1);
06977 xfer += oprot->writeBinary(this->query);
06978 xfer += oprot->writeFieldEnd();
06979 xfer += oprot->writeFieldBegin("compression", ::apache::thrift::protocol::T_I32, 2);
06980 xfer += oprot->writeI32((int32_t)this->compression);
06981 xfer += oprot->writeFieldEnd();
06982 xfer += oprot->writeFieldStop();
06983 xfer += oprot->writeStructEnd();
06984 return xfer;
06985 }
06986
06987 uint32_t Cassandra_execute_cql_query_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
06988 uint32_t xfer = 0;
06989 xfer += oprot->writeStructBegin("Cassandra_execute_cql_query_pargs");
06990 xfer += oprot->writeFieldBegin("query", ::apache::thrift::protocol::T_STRING, 1);
06991 xfer += oprot->writeBinary((*(this->query)));
06992 xfer += oprot->writeFieldEnd();
06993 xfer += oprot->writeFieldBegin("compression", ::apache::thrift::protocol::T_I32, 2);
06994 xfer += oprot->writeI32((int32_t)(*(this->compression)));
06995 xfer += oprot->writeFieldEnd();
06996 xfer += oprot->writeFieldStop();
06997 xfer += oprot->writeStructEnd();
06998 return xfer;
06999 }
07000
07001 uint32_t Cassandra_execute_cql_query_result::read(::apache::thrift::protocol::TProtocol* iprot) {
07002
07003 uint32_t xfer = 0;
07004 std::string fname;
07005 ::apache::thrift::protocol::TType ftype;
07006 int16_t fid;
07007
07008 xfer += iprot->readStructBegin(fname);
07009
07010 using ::apache::thrift::protocol::TProtocolException;
07011
07012
07013 while (true)
07014 {
07015 xfer += iprot->readFieldBegin(fname, ftype, fid);
07016 if (ftype == ::apache::thrift::protocol::T_STOP) {
07017 break;
07018 }
07019 switch (fid)
07020 {
07021 case 0:
07022 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
07023 xfer += this->success.read(iprot);
07024 this->__isset.success = true;
07025 } else {
07026 xfer += iprot->skip(ftype);
07027 }
07028 break;
07029 case 1:
07030 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
07031 xfer += this->ire.read(iprot);
07032 this->__isset.ire = true;
07033 } else {
07034 xfer += iprot->skip(ftype);
07035 }
07036 break;
07037 case 2:
07038 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
07039 xfer += this->ue.read(iprot);
07040 this->__isset.ue = true;
07041 } else {
07042 xfer += iprot->skip(ftype);
07043 }
07044 break;
07045 case 3:
07046 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
07047 xfer += this->te.read(iprot);
07048 this->__isset.te = true;
07049 } else {
07050 xfer += iprot->skip(ftype);
07051 }
07052 break;
07053 case 4:
07054 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
07055 xfer += this->sde.read(iprot);
07056 this->__isset.sde = true;
07057 } else {
07058 xfer += iprot->skip(ftype);
07059 }
07060 break;
07061 default:
07062 xfer += iprot->skip(ftype);
07063 break;
07064 }
07065 xfer += iprot->readFieldEnd();
07066 }
07067
07068 xfer += iprot->readStructEnd();
07069
07070 return xfer;
07071 }
07072
07073 uint32_t Cassandra_execute_cql_query_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
07074
07075 uint32_t xfer = 0;
07076
07077 xfer += oprot->writeStructBegin("Cassandra_execute_cql_query_result");
07078
07079 if (this->__isset.success) {
07080 xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0);
07081 xfer += this->success.write(oprot);
07082 xfer += oprot->writeFieldEnd();
07083 } else if (this->__isset.ire) {
07084 xfer += oprot->writeFieldBegin("ire", ::apache::thrift::protocol::T_STRUCT, 1);
07085 xfer += this->ire.write(oprot);
07086 xfer += oprot->writeFieldEnd();
07087 } else if (this->__isset.ue) {
07088 xfer += oprot->writeFieldBegin("ue", ::apache::thrift::protocol::T_STRUCT, 2);
07089 xfer += this->ue.write(oprot);
07090 xfer += oprot->writeFieldEnd();
07091 } else if (this->__isset.te) {
07092 xfer += oprot->writeFieldBegin("te", ::apache::thrift::protocol::T_STRUCT, 3);
07093 xfer += this->te.write(oprot);
07094 xfer += oprot->writeFieldEnd();
07095 } else if (this->__isset.sde) {
07096 xfer += oprot->writeFieldBegin("sde", ::apache::thrift::protocol::T_STRUCT, 4);
07097 xfer += this->sde.write(oprot);
07098 xfer += oprot->writeFieldEnd();
07099 }
07100 xfer += oprot->writeFieldStop();
07101 xfer += oprot->writeStructEnd();
07102 return xfer;
07103 }
07104
07105 uint32_t Cassandra_execute_cql_query_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
07106
07107 uint32_t xfer = 0;
07108 std::string fname;
07109 ::apache::thrift::protocol::TType ftype;
07110 int16_t fid;
07111
07112 xfer += iprot->readStructBegin(fname);
07113
07114 using ::apache::thrift::protocol::TProtocolException;
07115
07116
07117 while (true)
07118 {
07119 xfer += iprot->readFieldBegin(fname, ftype, fid);
07120 if (ftype == ::apache::thrift::protocol::T_STOP) {
07121 break;
07122 }
07123 switch (fid)
07124 {
07125 case 0:
07126 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
07127 xfer += (*(this->success)).read(iprot);
07128 this->__isset.success = true;
07129 } else {
07130 xfer += iprot->skip(ftype);
07131 }
07132 break;
07133 case 1:
07134 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
07135 xfer += this->ire.read(iprot);
07136 this->__isset.ire = true;
07137 } else {
07138 xfer += iprot->skip(ftype);
07139 }
07140 break;
07141 case 2:
07142 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
07143 xfer += this->ue.read(iprot);
07144 this->__isset.ue = true;
07145 } else {
07146 xfer += iprot->skip(ftype);
07147 }
07148 break;
07149 case 3:
07150 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
07151 xfer += this->te.read(iprot);
07152 this->__isset.te = true;
07153 } else {
07154 xfer += iprot->skip(ftype);
07155 }
07156 break;
07157 case 4:
07158 if (ftype == ::apache::thrift::protocol::T_STRUCT) {
07159 xfer += this->sde.read(iprot);
07160 this->__isset.sde = true;
07161 } else {
07162 xfer += iprot->skip(ftype);
07163 }
07164 break;
07165 default:
07166 xfer += iprot->skip(ftype);
07167 break;
07168 }
07169 xfer += iprot->readFieldEnd();
07170 }
07171
07172 xfer += iprot->readStructEnd();
07173
07174 return xfer;
07175 }
07176
07177 void CassandraClient::login(const AuthenticationRequest& auth_request)
07178 {
07179 send_login(auth_request);
07180 recv_login();
07181 }
07182
07183 void CassandraClient::send_login(const AuthenticationRequest& auth_request)
07184 {
07185 int32_t cseqid = 0;
07186 oprot_->writeMessageBegin("login", ::apache::thrift::protocol::T_CALL, cseqid);
07187
07188 Cassandra_login_pargs args;
07189 args.auth_request = &auth_request;
07190 args.write(oprot_);
07191
07192 oprot_->writeMessageEnd();
07193 oprot_->getTransport()->writeEnd();
07194 oprot_->getTransport()->flush();
07195 }
07196
07197 void CassandraClient::recv_login()
07198 {
07199
07200 int32_t rseqid = 0;
07201 std::string fname;
07202 ::apache::thrift::protocol::TMessageType mtype;
07203
07204 iprot_->readMessageBegin(fname, mtype, rseqid);
07205 if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
07206 ::apache::thrift::TApplicationException x;
07207 x.read(iprot_);
07208 iprot_->readMessageEnd();
07209 iprot_->getTransport()->readEnd();
07210 throw x;
07211 }
07212 if (mtype != ::apache::thrift::protocol::T_REPLY) {
07213 iprot_->skip(::apache::thrift::protocol::T_STRUCT);
07214 iprot_->readMessageEnd();
07215 iprot_->getTransport()->readEnd();
07216 }
07217 if (fname.compare("login") != 0) {
07218 iprot_->skip(::apache::thrift::protocol::T_STRUCT);
07219 iprot_->readMessageEnd();
07220 iprot_->getTransport()->readEnd();
07221 }
07222 Cassandra_login_presult result;
07223 result.read(iprot_);
07224 iprot_->readMessageEnd();
07225 iprot_->getTransport()->readEnd();
07226
07227 if (result.__isset.authnx) {
07228 throw result.authnx;
07229 }
07230 if (result.__isset.authzx) {
07231 throw result.authzx;
07232 }
07233 return;
07234 }
07235
07236 void CassandraClient::set_keyspace(const std::string& keyspace)
07237 {
07238 send_set_keyspace(keyspace);
07239 recv_set_keyspace();
07240 }
07241
07242 void CassandraClient::send_set_keyspace(const std::string& keyspace)
07243 {
07244 int32_t cseqid = 0;
07245 oprot_->writeMessageBegin("set_keyspace", ::apache::thrift::protocol::T_CALL, cseqid);
07246
07247 Cassandra_set_keyspace_pargs args;
07248 args.keyspace = &keyspace;
07249 args.write(oprot_);
07250
07251 oprot_->writeMessageEnd();
07252 oprot_->getTransport()->writeEnd();
07253 oprot_->getTransport()->flush();
07254 }
07255
07256 void CassandraClient::recv_set_keyspace()
07257 {
07258
07259 int32_t rseqid = 0;
07260 std::string fname;
07261 ::apache::thrift::protocol::TMessageType mtype;
07262
07263 iprot_->readMessageBegin(fname, mtype, rseqid);
07264 if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
07265 ::apache::thrift::TApplicationException x;
07266 x.read(iprot_);
07267 iprot_->readMessageEnd();
07268 iprot_->getTransport()->readEnd();
07269 throw x;
07270 }
07271 if (mtype != ::apache::thrift::protocol::T_REPLY) {
07272 iprot_->skip(::apache::thrift::protocol::T_STRUCT);
07273 iprot_->readMessageEnd();
07274 iprot_->getTransport()->readEnd();
07275 }
07276 if (fname.compare("set_keyspace") != 0) {
07277 iprot_->skip(::apache::thrift::protocol::T_STRUCT);
07278 iprot_->readMessageEnd();
07279 iprot_->getTransport()->readEnd();
07280 }
07281 Cassandra_set_keyspace_presult result;
07282 result.read(iprot_);
07283 iprot_->readMessageEnd();
07284 iprot_->getTransport()->readEnd();
07285
07286 if (result.__isset.ire) {
07287 throw result.ire;
07288 }
07289 return;
07290 }
07291
07292 void CassandraClient::get(ColumnOrSuperColumn& _return, const std::string& key, const ColumnPath& column_path, const ConsistencyLevel::type consistency_level)
07293 {
07294 send_get(key, column_path, consistency_level);
07295 recv_get(_return);
07296 }
07297
07298 void CassandraClient::send_get(const std::string& key, const ColumnPath& column_path, const ConsistencyLevel::type consistency_level)
07299 {
07300 int32_t cseqid = 0;
07301 oprot_->writeMessageBegin("get", ::apache::thrift::protocol::T_CALL, cseqid);
07302
07303 Cassandra_get_pargs args;
07304 args.key = &key;
07305 args.column_path = &column_path;
07306 args.consistency_level = &consistency_level;
07307 args.write(oprot_);
07308
07309 oprot_->writeMessageEnd();
07310 oprot_->getTransport()->writeEnd();
07311 oprot_->getTransport()->flush();
07312 }
07313
07314 void CassandraClient::recv_get(ColumnOrSuperColumn& _return)
07315 {
07316
07317 int32_t rseqid = 0;
07318 std::string fname;
07319 ::apache::thrift::protocol::TMessageType mtype;
07320
07321 iprot_->readMessageBegin(fname, mtype, rseqid);
07322 if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
07323 ::apache::thrift::TApplicationException x;
07324 x.read(iprot_);
07325 iprot_->readMessageEnd();
07326 iprot_->getTransport()->readEnd();
07327 throw x;
07328 }
07329 if (mtype != ::apache::thrift::protocol::T_REPLY) {
07330 iprot_->skip(::apache::thrift::protocol::T_STRUCT);
07331 iprot_->readMessageEnd();
07332 iprot_->getTransport()->readEnd();
07333 }
07334 if (fname.compare("get") != 0) {
07335 iprot_->skip(::apache::thrift::protocol::T_STRUCT);
07336 iprot_->readMessageEnd();
07337 iprot_->getTransport()->readEnd();
07338 }
07339 Cassandra_get_presult result;
07340 result.success = &_return;
07341 result.read(iprot_);
07342 iprot_->readMessageEnd();
07343 iprot_->getTransport()->readEnd();
07344
07345 if (result.__isset.success) {
07346
07347 return;
07348 }
07349 if (result.__isset.ire) {
07350 throw result.ire;
07351 }
07352 if (result.__isset.nfe) {
07353 throw result.nfe;
07354 }
07355 if (result.__isset.ue) {
07356 throw result.ue;
07357 }
07358 if (result.__isset.te) {
07359 throw result.te;
07360 }
07361 throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get failed: unknown result");
07362 }
07363
07364 void CassandraClient::get_slice(std::vector<ColumnOrSuperColumn> & _return, const std::string& key, const ColumnParent& column_parent, const SlicePredicate& predicate, const ConsistencyLevel::type consistency_level)
07365 {
07366 send_get_slice(key, column_parent, predicate, consistency_level);
07367 recv_get_slice(_return);
07368 }
07369
07370 void CassandraClient::send_get_slice(const std::string& key, const ColumnParent& column_parent, const SlicePredicate& predicate, const ConsistencyLevel::type consistency_level)
07371 {
07372 int32_t cseqid = 0;
07373 oprot_->writeMessageBegin("get_slice", ::apache::thrift::protocol::T_CALL, cseqid);
07374
07375 Cassandra_get_slice_pargs args;
07376 args.key = &key;
07377 args.column_parent = &column_parent;
07378 args.predicate = &predicate;
07379 args.consistency_level = &consistency_level;
07380 args.write(oprot_);
07381
07382 oprot_->writeMessageEnd();
07383 oprot_->getTransport()->writeEnd();
07384 oprot_->getTransport()->flush();
07385 }
07386
07387 void CassandraClient::recv_get_slice(std::vector<ColumnOrSuperColumn> & _return)
07388 {
07389
07390 int32_t rseqid = 0;
07391 std::string fname;
07392 ::apache::thrift::protocol::TMessageType mtype;
07393
07394 iprot_->readMessageBegin(fname, mtype, rseqid);
07395 if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
07396 ::apache::thrift::TApplicationException x;
07397 x.read(iprot_);
07398 iprot_->readMessageEnd();
07399 iprot_->getTransport()->readEnd();
07400 throw x;
07401 }
07402 if (mtype != ::apache::thrift::protocol::T_REPLY) {
07403 iprot_->skip(::apache::thrift::protocol::T_STRUCT);
07404 iprot_->readMessageEnd();
07405 iprot_->getTransport()->readEnd();
07406 }
07407 if (fname.compare("get_slice") != 0) {
07408 iprot_->skip(::apache::thrift::protocol::T_STRUCT);
07409 iprot_->readMessageEnd();
07410 iprot_->getTransport()->readEnd();
07411 }
07412 Cassandra_get_slice_presult result;
07413 result.success = &_return;
07414 result.read(iprot_);
07415 iprot_->readMessageEnd();
07416 iprot_->getTransport()->readEnd();
07417
07418 if (result.__isset.success) {
07419
07420 return;
07421 }
07422 if (result.__isset.ire) {
07423 throw result.ire;
07424 }
07425 if (result.__isset.ue) {
07426 throw result.ue;
07427 }
07428 if (result.__isset.te) {
07429 throw result.te;
07430 }
07431 throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_slice failed: unknown result");
07432 }
07433
07434 int32_t CassandraClient::get_count(const std::string& key, const ColumnParent& column_parent, const SlicePredicate& predicate, const ConsistencyLevel::type consistency_level)
07435 {
07436 send_get_count(key, column_parent, predicate, consistency_level);
07437 return recv_get_count();
07438 }
07439
07440 void CassandraClient::send_get_count(const std::string& key, const ColumnParent& column_parent, const SlicePredicate& predicate, const ConsistencyLevel::type consistency_level)
07441 {
07442 int32_t cseqid = 0;
07443 oprot_->writeMessageBegin("get_count", ::apache::thrift::protocol::T_CALL, cseqid);
07444
07445 Cassandra_get_count_pargs args;
07446 args.key = &key;
07447 args.column_parent = &column_parent;
07448 args.predicate = &predicate;
07449 args.consistency_level = &consistency_level;
07450 args.write(oprot_);
07451
07452 oprot_->writeMessageEnd();
07453 oprot_->getTransport()->writeEnd();
07454 oprot_->getTransport()->flush();
07455 }
07456
07457 int32_t CassandraClient::recv_get_count()
07458 {
07459
07460 int32_t rseqid = 0;
07461 std::string fname;
07462 ::apache::thrift::protocol::TMessageType mtype;
07463
07464 iprot_->readMessageBegin(fname, mtype, rseqid);
07465 if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
07466 ::apache::thrift::TApplicationException x;
07467 x.read(iprot_);
07468 iprot_->readMessageEnd();
07469 iprot_->getTransport()->readEnd();
07470 throw x;
07471 }
07472 if (mtype != ::apache::thrift::protocol::T_REPLY) {
07473 iprot_->skip(::apache::thrift::protocol::T_STRUCT);
07474 iprot_->readMessageEnd();
07475 iprot_->getTransport()->readEnd();
07476 }
07477 if (fname.compare("get_count") != 0) {
07478 iprot_->skip(::apache::thrift::protocol::T_STRUCT);
07479 iprot_->readMessageEnd();
07480 iprot_->getTransport()->readEnd();
07481 }
07482 int32_t _return;
07483 Cassandra_get_count_presult result;
07484 result.success = &_return;
07485 result.read(iprot_);
07486 iprot_->readMessageEnd();
07487 iprot_->getTransport()->readEnd();
07488
07489 if (result.__isset.success) {
07490 return _return;
07491 }
07492 if (result.__isset.ire) {
07493 throw result.ire;
07494 }
07495 if (result.__isset.ue) {
07496 throw result.ue;
07497 }
07498 if (result.__isset.te) {
07499 throw result.te;
07500 }
07501 throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_count failed: unknown result");
07502 }
07503
07504 void CassandraClient::multiget_slice(std::map<std::string, std::vector<ColumnOrSuperColumn> > & _return, const std::vector<std::string> & keys, const ColumnParent& column_parent, const SlicePredicate& predicate, const ConsistencyLevel::type consistency_level)
07505 {
07506 send_multiget_slice(keys, column_parent, predicate, consistency_level);
07507 recv_multiget_slice(_return);
07508 }
07509
07510 void CassandraClient::send_multiget_slice(const std::vector<std::string> & keys, const ColumnParent& column_parent, const SlicePredicate& predicate, const ConsistencyLevel::type consistency_level)
07511 {
07512 int32_t cseqid = 0;
07513 oprot_->writeMessageBegin("multiget_slice", ::apache::thrift::protocol::T_CALL, cseqid);
07514
07515 Cassandra_multiget_slice_pargs args;
07516 args.keys = &keys;
07517 args.column_parent = &column_parent;
07518 args.predicate = &predicate;
07519 args.consistency_level = &consistency_level;
07520 args.write(oprot_);
07521
07522 oprot_->writeMessageEnd();
07523 oprot_->getTransport()->writeEnd();
07524 oprot_->getTransport()->flush();
07525 }
07526
07527 void CassandraClient::recv_multiget_slice(std::map<std::string, std::vector<ColumnOrSuperColumn> > & _return)
07528 {
07529
07530 int32_t rseqid = 0;
07531 std::string fname;
07532 ::apache::thrift::protocol::TMessageType mtype;
07533
07534 iprot_->readMessageBegin(fname, mtype, rseqid);
07535 if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
07536 ::apache::thrift::TApplicationException x;
07537 x.read(iprot_);
07538 iprot_->readMessageEnd();
07539 iprot_->getTransport()->readEnd();
07540 throw x;
07541 }
07542 if (mtype != ::apache::thrift::protocol::T_REPLY) {
07543 iprot_->skip(::apache::thrift::protocol::T_STRUCT);
07544 iprot_->readMessageEnd();
07545 iprot_->getTransport()->readEnd();
07546 }
07547 if (fname.compare("multiget_slice") != 0) {
07548 iprot_->skip(::apache::thrift::protocol::T_STRUCT);
07549 iprot_->readMessageEnd();
07550 iprot_->getTransport()->readEnd();
07551 }
07552 Cassandra_multiget_slice_presult result;
07553 result.success = &_return;
07554 result.read(iprot_);
07555 iprot_->readMessageEnd();
07556 iprot_->getTransport()->readEnd();
07557
07558 if (result.__isset.success) {
07559
07560 return;
07561 }
07562 if (result.__isset.ire) {
07563 throw result.ire;
07564 }
07565 if (result.__isset.ue) {
07566 throw result.ue;
07567 }
07568 if (result.__isset.te) {
07569 throw result.te;
07570 }
07571 throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "multiget_slice failed: unknown result");
07572 }
07573
07574 void CassandraClient::multiget_count(std::map<std::string, int32_t> & _return, const std::vector<std::string> & keys, const ColumnParent& column_parent, const SlicePredicate& predicate, const ConsistencyLevel::type consistency_level)
07575 {
07576 send_multiget_count(keys, column_parent, predicate, consistency_level);
07577 recv_multiget_count(_return);
07578 }
07579
07580 void CassandraClient::send_multiget_count(const std::vector<std::string> & keys, const ColumnParent& column_parent, const SlicePredicate& predicate, const ConsistencyLevel::type consistency_level)
07581 {
07582 int32_t cseqid = 0;
07583 oprot_->writeMessageBegin("multiget_count", ::apache::thrift::protocol::T_CALL, cseqid);
07584
07585 Cassandra_multiget_count_pargs args;
07586 args.keys = &keys;
07587 args.column_parent = &column_parent;
07588 args.predicate = &predicate;
07589 args.consistency_level = &consistency_level;
07590 args.write(oprot_);
07591
07592 oprot_->writeMessageEnd();
07593 oprot_->getTransport()->writeEnd();
07594 oprot_->getTransport()->flush();
07595 }
07596
07597 void CassandraClient::recv_multiget_count(std::map<std::string, int32_t> & _return)
07598 {
07599
07600 int32_t rseqid = 0;
07601 std::string fname;
07602 ::apache::thrift::protocol::TMessageType mtype;
07603
07604 iprot_->readMessageBegin(fname, mtype, rseqid);
07605 if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
07606 ::apache::thrift::TApplicationException x;
07607 x.read(iprot_);
07608 iprot_->readMessageEnd();
07609 iprot_->getTransport()->readEnd();
07610 throw x;
07611 }
07612 if (mtype != ::apache::thrift::protocol::T_REPLY) {
07613 iprot_->skip(::apache::thrift::protocol::T_STRUCT);
07614 iprot_->readMessageEnd();
07615 iprot_->getTransport()->readEnd();
07616 }
07617 if (fname.compare("multiget_count") != 0) {
07618 iprot_->skip(::apache::thrift::protocol::T_STRUCT);
07619 iprot_->readMessageEnd();
07620 iprot_->getTransport()->readEnd();
07621 }
07622 Cassandra_multiget_count_presult result;
07623 result.success = &_return;
07624 result.read(iprot_);
07625 iprot_->readMessageEnd();
07626 iprot_->getTransport()->readEnd();
07627
07628 if (result.__isset.success) {
07629
07630 return;
07631 }
07632 if (result.__isset.ire) {
07633 throw result.ire;
07634 }
07635 if (result.__isset.ue) {
07636 throw result.ue;
07637 }
07638 if (result.__isset.te) {
07639 throw result.te;
07640 }
07641 throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "multiget_count failed: unknown result");
07642 }
07643
07644 void CassandraClient::get_range_slices(std::vector<KeySlice> & _return, const ColumnParent& column_parent, const SlicePredicate& predicate, const KeyRange& range, const ConsistencyLevel::type consistency_level)
07645 {
07646 send_get_range_slices(column_parent, predicate, range, consistency_level);
07647 recv_get_range_slices(_return);
07648 }
07649
07650 void CassandraClient::send_get_range_slices(const ColumnParent& column_parent, const SlicePredicate& predicate, const KeyRange& range, const ConsistencyLevel::type consistency_level)
07651 {
07652 int32_t cseqid = 0;
07653 oprot_->writeMessageBegin("get_range_slices", ::apache::thrift::protocol::T_CALL, cseqid);
07654
07655 Cassandra_get_range_slices_pargs args;
07656 args.column_parent = &column_parent;
07657 args.predicate = &predicate;
07658 args.range = ⦥
07659 args.consistency_level = &consistency_level;
07660 args.write(oprot_);
07661
07662 oprot_->writeMessageEnd();
07663 oprot_->getTransport()->writeEnd();
07664 oprot_->getTransport()->flush();
07665 }
07666
07667 void CassandraClient::recv_get_range_slices(std::vector<KeySlice> & _return)
07668 {
07669
07670 int32_t rseqid = 0;
07671 std::string fname;
07672 ::apache::thrift::protocol::TMessageType mtype;
07673
07674 iprot_->readMessageBegin(fname, mtype, rseqid);
07675 if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
07676 ::apache::thrift::TApplicationException x;
07677 x.read(iprot_);
07678 iprot_->readMessageEnd();
07679 iprot_->getTransport()->readEnd();
07680 throw x;
07681 }
07682 if (mtype != ::apache::thrift::protocol::T_REPLY) {
07683 iprot_->skip(::apache::thrift::protocol::T_STRUCT);
07684 iprot_->readMessageEnd();
07685 iprot_->getTransport()->readEnd();
07686 }
07687 if (fname.compare("get_range_slices") != 0) {
07688 iprot_->skip(::apache::thrift::protocol::T_STRUCT);
07689 iprot_->readMessageEnd();
07690 iprot_->getTransport()->readEnd();
07691 }
07692 Cassandra_get_range_slices_presult result;
07693 result.success = &_return;
07694 result.read(iprot_);
07695 iprot_->readMessageEnd();
07696 iprot_->getTransport()->readEnd();
07697
07698 if (result.__isset.success) {
07699
07700 return;
07701 }
07702 if (result.__isset.ire) {
07703 throw result.ire;
07704 }
07705 if (result.__isset.ue) {
07706 throw result.ue;
07707 }
07708 if (result.__isset.te) {
07709 throw result.te;
07710 }
07711 throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_range_slices failed: unknown result");
07712 }
07713
07714 void CassandraClient::get_indexed_slices(std::vector<KeySlice> & _return, const ColumnParent& column_parent, const IndexClause& index_clause, const SlicePredicate& column_predicate, const ConsistencyLevel::type consistency_level)
07715 {
07716 send_get_indexed_slices(column_parent, index_clause, column_predicate, consistency_level);
07717 recv_get_indexed_slices(_return);
07718 }
07719
07720 void CassandraClient::send_get_indexed_slices(const ColumnParent& column_parent, const IndexClause& index_clause, const SlicePredicate& column_predicate, const ConsistencyLevel::type consistency_level)
07721 {
07722 int32_t cseqid = 0;
07723 oprot_->writeMessageBegin("get_indexed_slices", ::apache::thrift::protocol::T_CALL, cseqid);
07724
07725 Cassandra_get_indexed_slices_pargs args;
07726 args.column_parent = &column_parent;
07727 args.index_clause = &index_clause;
07728 args.column_predicate = &column_predicate;
07729 args.consistency_level = &consistency_level;
07730 args.write(oprot_);
07731
07732 oprot_->writeMessageEnd();
07733 oprot_->getTransport()->writeEnd();
07734 oprot_->getTransport()->flush();
07735 }
07736
07737 void CassandraClient::recv_get_indexed_slices(std::vector<KeySlice> & _return)
07738 {
07739
07740 int32_t rseqid = 0;
07741 std::string fname;
07742 ::apache::thrift::protocol::TMessageType mtype;
07743
07744 iprot_->readMessageBegin(fname, mtype, rseqid);
07745 if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
07746 ::apache::thrift::TApplicationException x;
07747 x.read(iprot_);
07748 iprot_->readMessageEnd();
07749 iprot_->getTransport()->readEnd();
07750 throw x;
07751 }
07752 if (mtype != ::apache::thrift::protocol::T_REPLY) {
07753 iprot_->skip(::apache::thrift::protocol::T_STRUCT);
07754 iprot_->readMessageEnd();
07755 iprot_->getTransport()->readEnd();
07756 }
07757 if (fname.compare("get_indexed_slices") != 0) {
07758 iprot_->skip(::apache::thrift::protocol::T_STRUCT);
07759 iprot_->readMessageEnd();
07760 iprot_->getTransport()->readEnd();
07761 }
07762 Cassandra_get_indexed_slices_presult result;
07763 result.success = &_return;
07764 result.read(iprot_);
07765 iprot_->readMessageEnd();
07766 iprot_->getTransport()->readEnd();
07767
07768 if (result.__isset.success) {
07769
07770 return;
07771 }
07772 if (result.__isset.ire) {
07773 throw result.ire;
07774 }
07775 if (result.__isset.ue) {
07776 throw result.ue;
07777 }
07778 if (result.__isset.te) {
07779 throw result.te;
07780 }
07781 throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "get_indexed_slices failed: unknown result");
07782 }
07783
07784 void CassandraClient::insert(const std::string& key, const ColumnParent& column_parent, const Column& column, const ConsistencyLevel::type consistency_level)
07785 {
07786 send_insert(key, column_parent, column, consistency_level);
07787 recv_insert();
07788 }
07789
07790 void CassandraClient::send_insert(const std::string& key, const ColumnParent& column_parent, const Column& column, const ConsistencyLevel::type consistency_level)
07791 {
07792 int32_t cseqid = 0;
07793 oprot_->writeMessageBegin("insert", ::apache::thrift::protocol::T_CALL, cseqid);
07794
07795 Cassandra_insert_pargs args;
07796 args.key = &key;
07797 args.column_parent = &column_parent;
07798 args.column = &column;
07799 args.consistency_level = &consistency_level;
07800 args.write(oprot_);
07801
07802 oprot_->writeMessageEnd();
07803 oprot_->getTransport()->writeEnd();
07804 oprot_->getTransport()->flush();
07805 }
07806
07807 void CassandraClient::recv_insert()
07808 {
07809
07810 int32_t rseqid = 0;
07811 std::string fname;
07812 ::apache::thrift::protocol::TMessageType mtype;
07813
07814 iprot_->readMessageBegin(fname, mtype, rseqid);
07815 if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
07816 ::apache::thrift::TApplicationException x;
07817 x.read(iprot_);
07818 iprot_->readMessageEnd();
07819 iprot_->getTransport()->readEnd();
07820 throw x;
07821 }
07822 if (mtype != ::apache::thrift::protocol::T_REPLY) {
07823 iprot_->skip(::apache::thrift::protocol::T_STRUCT);
07824 iprot_->readMessageEnd();
07825 iprot_->getTransport()->readEnd();
07826 }
07827 if (fname.compare("insert") != 0) {
07828 iprot_->skip(::apache::thrift::protocol::T_STRUCT);
07829 iprot_->readMessageEnd();
07830 iprot_->getTransport()->readEnd();
07831 }
07832 Cassandra_insert_presult result;
07833 result.read(iprot_);
07834 iprot_->readMessageEnd();
07835 iprot_->getTransport()->readEnd();
07836
07837 if (result.__isset.ire) {
07838 throw result.ire;
07839 }
07840 if (result.__isset.ue) {
07841 throw result.ue;
07842 }
07843 if (result.__isset.te) {
07844 throw result.te;
07845 }
07846 return;
07847 }
07848
07849 void CassandraClient::add(const std::string& key, const ColumnParent& column_parent, const CounterColumn& column, const ConsistencyLevel::type consistency_level)
07850 {
07851 send_add(key, column_parent, column, consistency_level);
07852 recv_add();
07853 }
07854
07855 void CassandraClient::send_add(const std::string& key, const ColumnParent& column_parent, const CounterColumn& column, const ConsistencyLevel::type consistency_level)
07856 {
07857 int32_t cseqid = 0;
07858 oprot_->writeMessageBegin("add", ::apache::thrift::protocol::T_CALL, cseqid);
07859
07860 Cassandra_add_pargs args;
07861 args.key = &key;
07862 args.column_parent = &column_parent;
07863 args.column = &column;
07864 args.consistency_level = &consistency_level;
07865 args.write(oprot_);
07866
07867 oprot_->writeMessageEnd();
07868 oprot_->getTransport()->writeEnd();
07869 oprot_->getTransport()->flush();
07870 }
07871
07872 void CassandraClient::recv_add()
07873 {
07874
07875 int32_t rseqid = 0;
07876 std::string fname;
07877 ::apache::thrift::protocol::TMessageType mtype;
07878
07879 iprot_->readMessageBegin(fname, mtype, rseqid);
07880 if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
07881 ::apache::thrift::TApplicationException x;
07882 x.read(iprot_);
07883 iprot_->readMessageEnd();
07884 iprot_->getTransport()->readEnd();
07885 throw x;
07886 }
07887 if (mtype != ::apache::thrift::protocol::T_REPLY) {
07888 iprot_->skip(::apache::thrift::protocol::T_STRUCT);
07889 iprot_->readMessageEnd();
07890 iprot_->getTransport()->readEnd();
07891 }
07892 if (fname.compare("add") != 0) {
07893 iprot_->skip(::apache::thrift::protocol::T_STRUCT);
07894 iprot_->readMessageEnd();
07895 iprot_->getTransport()->readEnd();
07896 }
07897 Cassandra_add_presult result;
07898 result.read(iprot_);
07899 iprot_->readMessageEnd();
07900 iprot_->getTransport()->readEnd();
07901
07902 if (result.__isset.ire) {
07903 throw result.ire;
07904 }
07905 if (result.__isset.ue) {
07906 throw result.ue;
07907 }
07908 if (result.__isset.te) {
07909 throw result.te;
07910 }
07911 return;
07912 }
07913
07914 void CassandraClient::remove(const std::string& key, const ColumnPath& column_path, const int64_t timestamp, const ConsistencyLevel::type consistency_level)
07915 {
07916 send_remove(key, column_path, timestamp, consistency_level);
07917 recv_remove();
07918 }
07919
07920 void CassandraClient::send_remove(const std::string& key, const ColumnPath& column_path, const int64_t timestamp, const ConsistencyLevel::type consistency_level)
07921 {
07922 int32_t cseqid = 0;
07923 oprot_->writeMessageBegin("remove", ::apache::thrift::protocol::T_CALL, cseqid);
07924
07925 Cassandra_remove_pargs args;
07926 args.key = &key;
07927 args.column_path = &column_path;
07928 args.timestamp = ×tamp;
07929 args.consistency_level = &consistency_level;
07930 args.write(oprot_);
07931
07932 oprot_->writeMessageEnd();
07933 oprot_->getTransport()->writeEnd();
07934 oprot_->getTransport()->flush();
07935 }
07936
07937 void CassandraClient::recv_remove()
07938 {
07939
07940 int32_t rseqid = 0;
07941 std::string fname;
07942 ::apache::thrift::protocol::TMessageType mtype;
07943
07944 iprot_->readMessageBegin(fname, mtype, rseqid);
07945 if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
07946 ::apache::thrift::TApplicationException x;
07947 x.read(iprot_);
07948 iprot_->readMessageEnd();
07949 iprot_->getTransport()->readEnd();
07950 throw x;
07951 }
07952 if (mtype != ::apache::thrift::protocol::T_REPLY) {
07953 iprot_->skip(::apache::thrift::protocol::T_STRUCT);
07954 iprot_->readMessageEnd();
07955 iprot_->getTransport()->readEnd();
07956 }
07957 if (fname.compare("remove") != 0) {
07958 iprot_->skip(::apache::thrift::protocol::T_STRUCT);
07959 iprot_->readMessageEnd();
07960 iprot_->getTransport()->readEnd();
07961 }
07962 Cassandra_remove_presult result;
07963 result.read(iprot_);
07964 iprot_->readMessageEnd();
07965 iprot_->getTransport()->readEnd();
07966
07967 if (result.__isset.ire) {
07968 throw result.ire;
07969 }
07970 if (result.__isset.ue) {
07971 throw result.ue;
07972 }
07973 if (result.__isset.te) {
07974 throw result.te;
07975 }
07976 return;
07977 }
07978
07979 void CassandraClient::remove_counter(const std::string& key, const ColumnPath& path, const ConsistencyLevel::type consistency_level)
07980 {
07981 send_remove_counter(key, path, consistency_level);
07982 recv_remove_counter();
07983 }
07984
07985 void CassandraClient::send_remove_counter(const std::string& key, const ColumnPath& path, const ConsistencyLevel::type consistency_level)
07986 {
07987 int32_t cseqid = 0;
07988 oprot_->writeMessageBegin("remove_counter", ::apache::thrift::protocol::T_CALL, cseqid);
07989
07990 Cassandra_remove_counter_pargs args;
07991 args.key = &key;
07992 args.path = &path;
07993 args.consistency_level = &consistency_level;
07994 args.write(oprot_);
07995
07996 oprot_->writeMessageEnd();
07997 oprot_->getTransport()->writeEnd();
07998 oprot_->getTransport()->flush();
07999 }
08000
08001 void CassandraClient::recv_remove_counter()
08002 {
08003
08004 int32_t rseqid = 0;
08005 std::string fname;
08006 ::apache::thrift::protocol::TMessageType mtype;
08007
08008 iprot_->readMessageBegin(fname, mtype, rseqid);
08009 if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
08010 ::apache::thrift::TApplicationException x;
08011 x.read(iprot_);
08012 iprot_->readMessageEnd();
08013 iprot_->getTransport()->readEnd();
08014 throw x;
08015 }
08016 if (mtype != ::apache::thrift::protocol::T_REPLY) {
08017 iprot_->skip(::apache::thrift::protocol::T_STRUCT);
08018 iprot_->readMessageEnd();
08019 iprot_->getTransport()->readEnd();
08020 }
08021 if (fname.compare("remove_counter") != 0) {
08022 iprot_->skip(::apache::thrift::protocol::T_STRUCT);
08023 iprot_->readMessageEnd();
08024 iprot_->getTransport()->readEnd();
08025 }
08026 Cassandra_remove_counter_presult result;
08027 result.read(iprot_);
08028 iprot_->readMessageEnd();
08029 iprot_->getTransport()->readEnd();
08030
08031 if (result.__isset.ire) {
08032 throw result.ire;
08033 }
08034 if (result.__isset.ue) {
08035 throw result.ue;
08036 }
08037 if (result.__isset.te) {
08038 throw result.te;
08039 }
08040 return;
08041 }
08042
08043 void CassandraClient::batch_mutate(const std::map<std::string, std::map<std::string, std::vector<Mutation> > > & mutation_map, const ConsistencyLevel::type consistency_level)
08044 {
08045 send_batch_mutate(mutation_map, consistency_level);
08046 recv_batch_mutate();
08047 }
08048
08049 void CassandraClient::send_batch_mutate(const std::map<std::string, std::map<std::string, std::vector<Mutation> > > & mutation_map, const ConsistencyLevel::type consistency_level)
08050 {
08051 int32_t cseqid = 0;
08052 oprot_->writeMessageBegin("batch_mutate", ::apache::thrift::protocol::T_CALL, cseqid);
08053
08054 Cassandra_batch_mutate_pargs args;
08055 args.mutation_map = &mutation_map;
08056 args.consistency_level = &consistency_level;
08057 args.write(oprot_);
08058
08059 oprot_->writeMessageEnd();
08060 oprot_->getTransport()->writeEnd();
08061 oprot_->getTransport()->flush();
08062 }
08063
08064 void CassandraClient::recv_batch_mutate()
08065 {
08066
08067 int32_t rseqid = 0;
08068 std::string fname;
08069 ::apache::thrift::protocol::TMessageType mtype;
08070
08071 iprot_->readMessageBegin(fname, mtype, rseqid);
08072 if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
08073 ::apache::thrift::TApplicationException x;
08074 x.read(iprot_);
08075 iprot_->readMessageEnd();
08076 iprot_->getTransport()->readEnd();
08077 throw x;
08078 }
08079 if (mtype != ::apache::thrift::protocol::T_REPLY) {
08080 iprot_->skip(::apache::thrift::protocol::T_STRUCT);
08081 iprot_->readMessageEnd();
08082 iprot_->getTransport()->readEnd();
08083 }
08084 if (fname.compare("batch_mutate") != 0) {
08085 iprot_->skip(::apache::thrift::protocol::T_STRUCT);
08086 iprot_->readMessageEnd();
08087 iprot_->getTransport()->readEnd();
08088 }
08089 Cassandra_batch_mutate_presult result;
08090 result.read(iprot_);
08091 iprot_->readMessageEnd();
08092 iprot_->getTransport()->readEnd();
08093
08094 if (result.__isset.ire) {
08095 throw result.ire;
08096 }
08097 if (result.__isset.ue) {
08098 throw result.ue;
08099 }
08100 if (result.__isset.te) {
08101 throw result.te;
08102 }
08103 return;
08104 }
08105
08106 void CassandraClient::truncate(const std::string& cfname)
08107 {
08108 send_truncate(cfname);
08109 recv_truncate();
08110 }
08111
08112 void CassandraClient::send_truncate(const std::string& cfname)
08113 {
08114 int32_t cseqid = 0;
08115 oprot_->writeMessageBegin("truncate", ::apache::thrift::protocol::T_CALL, cseqid);
08116
08117 Cassandra_truncate_pargs args;
08118 args.cfname = &cfname;
08119 args.write(oprot_);
08120
08121 oprot_->writeMessageEnd();
08122 oprot_->getTransport()->writeEnd();
08123 oprot_->getTransport()->flush();
08124 }
08125
08126 void CassandraClient::recv_truncate()
08127 {
08128
08129 int32_t rseqid = 0;
08130 std::string fname;
08131 ::apache::thrift::protocol::TMessageType mtype;
08132
08133 iprot_->readMessageBegin(fname, mtype, rseqid);
08134 if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
08135 ::apache::thrift::TApplicationException x;
08136 x.read(iprot_);
08137 iprot_->readMessageEnd();
08138 iprot_->getTransport()->readEnd();
08139 throw x;
08140 }
08141 if (mtype != ::apache::thrift::protocol::T_REPLY) {
08142 iprot_->skip(::apache::thrift::protocol::T_STRUCT);
08143 iprot_->readMessageEnd();
08144 iprot_->getTransport()->readEnd();
08145 }
08146 if (fname.compare("truncate") != 0) {
08147 iprot_->skip(::apache::thrift::protocol::T_STRUCT);
08148 iprot_->readMessageEnd();
08149 iprot_->getTransport()->readEnd();
08150 }
08151 Cassandra_truncate_presult result;
08152 result.read(iprot_);
08153 iprot_->readMessageEnd();
08154 iprot_->getTransport()->readEnd();
08155
08156 if (result.__isset.ire) {
08157 throw result.ire;
08158 }
08159 if (result.__isset.ue) {
08160 throw result.ue;
08161 }
08162 return;
08163 }
08164
08165 void CassandraClient::describe_schema_versions(std::map<std::string, std::vector<std::string> > & _return)
08166 {
08167 send_describe_schema_versions();
08168 recv_describe_schema_versions(_return);
08169 }
08170
08171 void CassandraClient::send_describe_schema_versions()
08172 {
08173 int32_t cseqid = 0;
08174 oprot_->writeMessageBegin("describe_schema_versions", ::apache::thrift::protocol::T_CALL, cseqid);
08175
08176 Cassandra_describe_schema_versions_pargs args;
08177 args.write(oprot_);
08178
08179 oprot_->writeMessageEnd();
08180 oprot_->getTransport()->writeEnd();
08181 oprot_->getTransport()->flush();
08182 }
08183
08184 void CassandraClient::recv_describe_schema_versions(std::map<std::string, std::vector<std::string> > & _return)
08185 {
08186
08187 int32_t rseqid = 0;
08188 std::string fname;
08189 ::apache::thrift::protocol::TMessageType mtype;
08190
08191 iprot_->readMessageBegin(fname, mtype, rseqid);
08192 if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
08193 ::apache::thrift::TApplicationException x;
08194 x.read(iprot_);
08195 iprot_->readMessageEnd();
08196 iprot_->getTransport()->readEnd();
08197 throw x;
08198 }
08199 if (mtype != ::apache::thrift::protocol::T_REPLY) {
08200 iprot_->skip(::apache::thrift::protocol::T_STRUCT);
08201 iprot_->readMessageEnd();
08202 iprot_->getTransport()->readEnd();
08203 }
08204 if (fname.compare("describe_schema_versions") != 0) {
08205 iprot_->skip(::apache::thrift::protocol::T_STRUCT);
08206 iprot_->readMessageEnd();
08207 iprot_->getTransport()->readEnd();
08208 }
08209 Cassandra_describe_schema_versions_presult result;
08210 result.success = &_return;
08211 result.read(iprot_);
08212 iprot_->readMessageEnd();
08213 iprot_->getTransport()->readEnd();
08214
08215 if (result.__isset.success) {
08216
08217 return;
08218 }
08219 if (result.__isset.ire) {
08220 throw result.ire;
08221 }
08222 throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "describe_schema_versions failed: unknown result");
08223 }
08224
08225 void CassandraClient::describe_keyspaces(std::vector<KsDef> & _return)
08226 {
08227 send_describe_keyspaces();
08228 recv_describe_keyspaces(_return);
08229 }
08230
08231 void CassandraClient::send_describe_keyspaces()
08232 {
08233 int32_t cseqid = 0;
08234 oprot_->writeMessageBegin("describe_keyspaces", ::apache::thrift::protocol::T_CALL, cseqid);
08235
08236 Cassandra_describe_keyspaces_pargs args;
08237 args.write(oprot_);
08238
08239 oprot_->writeMessageEnd();
08240 oprot_->getTransport()->writeEnd();
08241 oprot_->getTransport()->flush();
08242 }
08243
08244 void CassandraClient::recv_describe_keyspaces(std::vector<KsDef> & _return)
08245 {
08246
08247 int32_t rseqid = 0;
08248 std::string fname;
08249 ::apache::thrift::protocol::TMessageType mtype;
08250
08251 iprot_->readMessageBegin(fname, mtype, rseqid);
08252 if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
08253 ::apache::thrift::TApplicationException x;
08254 x.read(iprot_);
08255 iprot_->readMessageEnd();
08256 iprot_->getTransport()->readEnd();
08257 throw x;
08258 }
08259 if (mtype != ::apache::thrift::protocol::T_REPLY) {
08260 iprot_->skip(::apache::thrift::protocol::T_STRUCT);
08261 iprot_->readMessageEnd();
08262 iprot_->getTransport()->readEnd();
08263 }
08264 if (fname.compare("describe_keyspaces") != 0) {
08265 iprot_->skip(::apache::thrift::protocol::T_STRUCT);
08266 iprot_->readMessageEnd();
08267 iprot_->getTransport()->readEnd();
08268 }
08269 Cassandra_describe_keyspaces_presult result;
08270 result.success = &_return;
08271 result.read(iprot_);
08272 iprot_->readMessageEnd();
08273 iprot_->getTransport()->readEnd();
08274
08275 if (result.__isset.success) {
08276
08277 return;
08278 }
08279 if (result.__isset.ire) {
08280 throw result.ire;
08281 }
08282 throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "describe_keyspaces failed: unknown result");
08283 }
08284
08285 void CassandraClient::describe_cluster_name(std::string& _return)
08286 {
08287 send_describe_cluster_name();
08288 recv_describe_cluster_name(_return);
08289 }
08290
08291 void CassandraClient::send_describe_cluster_name()
08292 {
08293 int32_t cseqid = 0;
08294 oprot_->writeMessageBegin("describe_cluster_name", ::apache::thrift::protocol::T_CALL, cseqid);
08295
08296 Cassandra_describe_cluster_name_pargs args;
08297 args.write(oprot_);
08298
08299 oprot_->writeMessageEnd();
08300 oprot_->getTransport()->writeEnd();
08301 oprot_->getTransport()->flush();
08302 }
08303
08304 void CassandraClient::recv_describe_cluster_name(std::string& _return)
08305 {
08306
08307 int32_t rseqid = 0;
08308 std::string fname;
08309 ::apache::thrift::protocol::TMessageType mtype;
08310
08311 iprot_->readMessageBegin(fname, mtype, rseqid);
08312 if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
08313 ::apache::thrift::TApplicationException x;
08314 x.read(iprot_);
08315 iprot_->readMessageEnd();
08316 iprot_->getTransport()->readEnd();
08317 throw x;
08318 }
08319 if (mtype != ::apache::thrift::protocol::T_REPLY) {
08320 iprot_->skip(::apache::thrift::protocol::T_STRUCT);
08321 iprot_->readMessageEnd();
08322 iprot_->getTransport()->readEnd();
08323 }
08324 if (fname.compare("describe_cluster_name") != 0) {
08325 iprot_->skip(::apache::thrift::protocol::T_STRUCT);
08326 iprot_->readMessageEnd();
08327 iprot_->getTransport()->readEnd();
08328 }
08329 Cassandra_describe_cluster_name_presult result;
08330 result.success = &_return;
08331 result.read(iprot_);
08332 iprot_->readMessageEnd();
08333 iprot_->getTransport()->readEnd();
08334
08335 if (result.__isset.success) {
08336
08337 return;
08338 }
08339 throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "describe_cluster_name failed: unknown result");
08340 }
08341
08342 void CassandraClient::describe_version(std::string& _return)
08343 {
08344 send_describe_version();
08345 recv_describe_version(_return);
08346 }
08347
08348 void CassandraClient::send_describe_version()
08349 {
08350 int32_t cseqid = 0;
08351 oprot_->writeMessageBegin("describe_version", ::apache::thrift::protocol::T_CALL, cseqid);
08352
08353 Cassandra_describe_version_pargs args;
08354 args.write(oprot_);
08355
08356 oprot_->writeMessageEnd();
08357 oprot_->getTransport()->writeEnd();
08358 oprot_->getTransport()->flush();
08359 }
08360
08361 void CassandraClient::recv_describe_version(std::string& _return)
08362 {
08363
08364 int32_t rseqid = 0;
08365 std::string fname;
08366 ::apache::thrift::protocol::TMessageType mtype;
08367
08368 iprot_->readMessageBegin(fname, mtype, rseqid);
08369 if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
08370 ::apache::thrift::TApplicationException x;
08371 x.read(iprot_);
08372 iprot_->readMessageEnd();
08373 iprot_->getTransport()->readEnd();
08374 throw x;
08375 }
08376 if (mtype != ::apache::thrift::protocol::T_REPLY) {
08377 iprot_->skip(::apache::thrift::protocol::T_STRUCT);
08378 iprot_->readMessageEnd();
08379 iprot_->getTransport()->readEnd();
08380 }
08381 if (fname.compare("describe_version") != 0) {
08382 iprot_->skip(::apache::thrift::protocol::T_STRUCT);
08383 iprot_->readMessageEnd();
08384 iprot_->getTransport()->readEnd();
08385 }
08386 Cassandra_describe_version_presult result;
08387 result.success = &_return;
08388 result.read(iprot_);
08389 iprot_->readMessageEnd();
08390 iprot_->getTransport()->readEnd();
08391
08392 if (result.__isset.success) {
08393
08394 return;
08395 }
08396 throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "describe_version failed: unknown result");
08397 }
08398
08399 void CassandraClient::describe_ring(std::vector<TokenRange> & _return, const std::string& keyspace)
08400 {
08401 send_describe_ring(keyspace);
08402 recv_describe_ring(_return);
08403 }
08404
08405 void CassandraClient::send_describe_ring(const std::string& keyspace)
08406 {
08407 int32_t cseqid = 0;
08408 oprot_->writeMessageBegin("describe_ring", ::apache::thrift::protocol::T_CALL, cseqid);
08409
08410 Cassandra_describe_ring_pargs args;
08411 args.keyspace = &keyspace;
08412 args.write(oprot_);
08413
08414 oprot_->writeMessageEnd();
08415 oprot_->getTransport()->writeEnd();
08416 oprot_->getTransport()->flush();
08417 }
08418
08419 void CassandraClient::recv_describe_ring(std::vector<TokenRange> & _return)
08420 {
08421
08422 int32_t rseqid = 0;
08423 std::string fname;
08424 ::apache::thrift::protocol::TMessageType mtype;
08425
08426 iprot_->readMessageBegin(fname, mtype, rseqid);
08427 if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
08428 ::apache::thrift::TApplicationException x;
08429 x.read(iprot_);
08430 iprot_->readMessageEnd();
08431 iprot_->getTransport()->readEnd();
08432 throw x;
08433 }
08434 if (mtype != ::apache::thrift::protocol::T_REPLY) {
08435 iprot_->skip(::apache::thrift::protocol::T_STRUCT);
08436 iprot_->readMessageEnd();
08437 iprot_->getTransport()->readEnd();
08438 }
08439 if (fname.compare("describe_ring") != 0) {
08440 iprot_->skip(::apache::thrift::protocol::T_STRUCT);
08441 iprot_->readMessageEnd();
08442 iprot_->getTransport()->readEnd();
08443 }
08444 Cassandra_describe_ring_presult result;
08445 result.success = &_return;
08446 result.read(iprot_);
08447 iprot_->readMessageEnd();
08448 iprot_->getTransport()->readEnd();
08449
08450 if (result.__isset.success) {
08451
08452 return;
08453 }
08454 if (result.__isset.ire) {
08455 throw result.ire;
08456 }
08457 throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "describe_ring failed: unknown result");
08458 }
08459
08460 void CassandraClient::describe_partitioner(std::string& _return)
08461 {
08462 send_describe_partitioner();
08463 recv_describe_partitioner(_return);
08464 }
08465
08466 void CassandraClient::send_describe_partitioner()
08467 {
08468 int32_t cseqid = 0;
08469 oprot_->writeMessageBegin("describe_partitioner", ::apache::thrift::protocol::T_CALL, cseqid);
08470
08471 Cassandra_describe_partitioner_pargs args;
08472 args.write(oprot_);
08473
08474 oprot_->writeMessageEnd();
08475 oprot_->getTransport()->writeEnd();
08476 oprot_->getTransport()->flush();
08477 }
08478
08479 void CassandraClient::recv_describe_partitioner(std::string& _return)
08480 {
08481
08482 int32_t rseqid = 0;
08483 std::string fname;
08484 ::apache::thrift::protocol::TMessageType mtype;
08485
08486 iprot_->readMessageBegin(fname, mtype, rseqid);
08487 if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
08488 ::apache::thrift::TApplicationException x;
08489 x.read(iprot_);
08490 iprot_->readMessageEnd();
08491 iprot_->getTransport()->readEnd();
08492 throw x;
08493 }
08494 if (mtype != ::apache::thrift::protocol::T_REPLY) {
08495 iprot_->skip(::apache::thrift::protocol::T_STRUCT);
08496 iprot_->readMessageEnd();
08497 iprot_->getTransport()->readEnd();
08498 }
08499 if (fname.compare("describe_partitioner") != 0) {
08500 iprot_->skip(::apache::thrift::protocol::T_STRUCT);
08501 iprot_->readMessageEnd();
08502 iprot_->getTransport()->readEnd();
08503 }
08504 Cassandra_describe_partitioner_presult result;
08505 result.success = &_return;
08506 result.read(iprot_);
08507 iprot_->readMessageEnd();
08508 iprot_->getTransport()->readEnd();
08509
08510 if (result.__isset.success) {
08511
08512 return;
08513 }
08514 throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "describe_partitioner failed: unknown result");
08515 }
08516
08517 void CassandraClient::describe_snitch(std::string& _return)
08518 {
08519 send_describe_snitch();
08520 recv_describe_snitch(_return);
08521 }
08522
08523 void CassandraClient::send_describe_snitch()
08524 {
08525 int32_t cseqid = 0;
08526 oprot_->writeMessageBegin("describe_snitch", ::apache::thrift::protocol::T_CALL, cseqid);
08527
08528 Cassandra_describe_snitch_pargs args;
08529 args.write(oprot_);
08530
08531 oprot_->writeMessageEnd();
08532 oprot_->getTransport()->writeEnd();
08533 oprot_->getTransport()->flush();
08534 }
08535
08536 void CassandraClient::recv_describe_snitch(std::string& _return)
08537 {
08538
08539 int32_t rseqid = 0;
08540 std::string fname;
08541 ::apache::thrift::protocol::TMessageType mtype;
08542
08543 iprot_->readMessageBegin(fname, mtype, rseqid);
08544 if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
08545 ::apache::thrift::TApplicationException x;
08546 x.read(iprot_);
08547 iprot_->readMessageEnd();
08548 iprot_->getTransport()->readEnd();
08549 throw x;
08550 }
08551 if (mtype != ::apache::thrift::protocol::T_REPLY) {
08552 iprot_->skip(::apache::thrift::protocol::T_STRUCT);
08553 iprot_->readMessageEnd();
08554 iprot_->getTransport()->readEnd();
08555 }
08556 if (fname.compare("describe_snitch") != 0) {
08557 iprot_->skip(::apache::thrift::protocol::T_STRUCT);
08558 iprot_->readMessageEnd();
08559 iprot_->getTransport()->readEnd();
08560 }
08561 Cassandra_describe_snitch_presult result;
08562 result.success = &_return;
08563 result.read(iprot_);
08564 iprot_->readMessageEnd();
08565 iprot_->getTransport()->readEnd();
08566
08567 if (result.__isset.success) {
08568
08569 return;
08570 }
08571 throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "describe_snitch failed: unknown result");
08572 }
08573
08574 void CassandraClient::describe_keyspace(KsDef& _return, const std::string& keyspace)
08575 {
08576 send_describe_keyspace(keyspace);
08577 recv_describe_keyspace(_return);
08578 }
08579
08580 void CassandraClient::send_describe_keyspace(const std::string& keyspace)
08581 {
08582 int32_t cseqid = 0;
08583 oprot_->writeMessageBegin("describe_keyspace", ::apache::thrift::protocol::T_CALL, cseqid);
08584
08585 Cassandra_describe_keyspace_pargs args;
08586 args.keyspace = &keyspace;
08587 args.write(oprot_);
08588
08589 oprot_->writeMessageEnd();
08590 oprot_->getTransport()->writeEnd();
08591 oprot_->getTransport()->flush();
08592 }
08593
08594 void CassandraClient::recv_describe_keyspace(KsDef& _return)
08595 {
08596
08597 int32_t rseqid = 0;
08598 std::string fname;
08599 ::apache::thrift::protocol::TMessageType mtype;
08600
08601 iprot_->readMessageBegin(fname, mtype, rseqid);
08602 if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
08603 ::apache::thrift::TApplicationException x;
08604 x.read(iprot_);
08605 iprot_->readMessageEnd();
08606 iprot_->getTransport()->readEnd();
08607 throw x;
08608 }
08609 if (mtype != ::apache::thrift::protocol::T_REPLY) {
08610 iprot_->skip(::apache::thrift::protocol::T_STRUCT);
08611 iprot_->readMessageEnd();
08612 iprot_->getTransport()->readEnd();
08613 }
08614 if (fname.compare("describe_keyspace") != 0) {
08615 iprot_->skip(::apache::thrift::protocol::T_STRUCT);
08616 iprot_->readMessageEnd();
08617 iprot_->getTransport()->readEnd();
08618 }
08619 Cassandra_describe_keyspace_presult result;
08620 result.success = &_return;
08621 result.read(iprot_);
08622 iprot_->readMessageEnd();
08623 iprot_->getTransport()->readEnd();
08624
08625 if (result.__isset.success) {
08626
08627 return;
08628 }
08629 if (result.__isset.nfe) {
08630 throw result.nfe;
08631 }
08632 if (result.__isset.ire) {
08633 throw result.ire;
08634 }
08635 throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "describe_keyspace failed: unknown result");
08636 }
08637
08638 void CassandraClient::describe_splits(std::vector<std::string> & _return, const std::string& cfName, const std::string& start_token, const std::string& end_token, const int32_t keys_per_split)
08639 {
08640 send_describe_splits(cfName, start_token, end_token, keys_per_split);
08641 recv_describe_splits(_return);
08642 }
08643
08644 void CassandraClient::send_describe_splits(const std::string& cfName, const std::string& start_token, const std::string& end_token, const int32_t keys_per_split)
08645 {
08646 int32_t cseqid = 0;
08647 oprot_->writeMessageBegin("describe_splits", ::apache::thrift::protocol::T_CALL, cseqid);
08648
08649 Cassandra_describe_splits_pargs args;
08650 args.cfName = &cfName;
08651 args.start_token = &start_token;
08652 args.end_token = &end_token;
08653 args.keys_per_split = &keys_per_split;
08654 args.write(oprot_);
08655
08656 oprot_->writeMessageEnd();
08657 oprot_->getTransport()->writeEnd();
08658 oprot_->getTransport()->flush();
08659 }
08660
08661 void CassandraClient::recv_describe_splits(std::vector<std::string> & _return)
08662 {
08663
08664 int32_t rseqid = 0;
08665 std::string fname;
08666 ::apache::thrift::protocol::TMessageType mtype;
08667
08668 iprot_->readMessageBegin(fname, mtype, rseqid);
08669 if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
08670 ::apache::thrift::TApplicationException x;
08671 x.read(iprot_);
08672 iprot_->readMessageEnd();
08673 iprot_->getTransport()->readEnd();
08674 throw x;
08675 }
08676 if (mtype != ::apache::thrift::protocol::T_REPLY) {
08677 iprot_->skip(::apache::thrift::protocol::T_STRUCT);
08678 iprot_->readMessageEnd();
08679 iprot_->getTransport()->readEnd();
08680 }
08681 if (fname.compare("describe_splits") != 0) {
08682 iprot_->skip(::apache::thrift::protocol::T_STRUCT);
08683 iprot_->readMessageEnd();
08684 iprot_->getTransport()->readEnd();
08685 }
08686 Cassandra_describe_splits_presult result;
08687 result.success = &_return;
08688 result.read(iprot_);
08689 iprot_->readMessageEnd();
08690 iprot_->getTransport()->readEnd();
08691
08692 if (result.__isset.success) {
08693
08694 return;
08695 }
08696 if (result.__isset.ire) {
08697 throw result.ire;
08698 }
08699 throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "describe_splits failed: unknown result");
08700 }
08701
08702 void CassandraClient::system_add_column_family(std::string& _return, const CfDef& cf_def)
08703 {
08704 send_system_add_column_family(cf_def);
08705 recv_system_add_column_family(_return);
08706 }
08707
08708 void CassandraClient::send_system_add_column_family(const CfDef& cf_def)
08709 {
08710 int32_t cseqid = 0;
08711 oprot_->writeMessageBegin("system_add_column_family", ::apache::thrift::protocol::T_CALL, cseqid);
08712
08713 Cassandra_system_add_column_family_pargs args;
08714 args.cf_def = &cf_def;
08715 args.write(oprot_);
08716
08717 oprot_->writeMessageEnd();
08718 oprot_->getTransport()->writeEnd();
08719 oprot_->getTransport()->flush();
08720 }
08721
08722 void CassandraClient::recv_system_add_column_family(std::string& _return)
08723 {
08724
08725 int32_t rseqid = 0;
08726 std::string fname;
08727 ::apache::thrift::protocol::TMessageType mtype;
08728
08729 iprot_->readMessageBegin(fname, mtype, rseqid);
08730 if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
08731 ::apache::thrift::TApplicationException x;
08732 x.read(iprot_);
08733 iprot_->readMessageEnd();
08734 iprot_->getTransport()->readEnd();
08735 throw x;
08736 }
08737 if (mtype != ::apache::thrift::protocol::T_REPLY) {
08738 iprot_->skip(::apache::thrift::protocol::T_STRUCT);
08739 iprot_->readMessageEnd();
08740 iprot_->getTransport()->readEnd();
08741 }
08742 if (fname.compare("system_add_column_family") != 0) {
08743 iprot_->skip(::apache::thrift::protocol::T_STRUCT);
08744 iprot_->readMessageEnd();
08745 iprot_->getTransport()->readEnd();
08746 }
08747 Cassandra_system_add_column_family_presult result;
08748 result.success = &_return;
08749 result.read(iprot_);
08750 iprot_->readMessageEnd();
08751 iprot_->getTransport()->readEnd();
08752
08753 if (result.__isset.success) {
08754
08755 return;
08756 }
08757 if (result.__isset.ire) {
08758 throw result.ire;
08759 }
08760 if (result.__isset.sde) {
08761 throw result.sde;
08762 }
08763 throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "system_add_column_family failed: unknown result");
08764 }
08765
08766 void CassandraClient::system_drop_column_family(std::string& _return, const std::string& column_family)
08767 {
08768 send_system_drop_column_family(column_family);
08769 recv_system_drop_column_family(_return);
08770 }
08771
08772 void CassandraClient::send_system_drop_column_family(const std::string& column_family)
08773 {
08774 int32_t cseqid = 0;
08775 oprot_->writeMessageBegin("system_drop_column_family", ::apache::thrift::protocol::T_CALL, cseqid);
08776
08777 Cassandra_system_drop_column_family_pargs args;
08778 args.column_family = &column_family;
08779 args.write(oprot_);
08780
08781 oprot_->writeMessageEnd();
08782 oprot_->getTransport()->writeEnd();
08783 oprot_->getTransport()->flush();
08784 }
08785
08786 void CassandraClient::recv_system_drop_column_family(std::string& _return)
08787 {
08788
08789 int32_t rseqid = 0;
08790 std::string fname;
08791 ::apache::thrift::protocol::TMessageType mtype;
08792
08793 iprot_->readMessageBegin(fname, mtype, rseqid);
08794 if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
08795 ::apache::thrift::TApplicationException x;
08796 x.read(iprot_);
08797 iprot_->readMessageEnd();
08798 iprot_->getTransport()->readEnd();
08799 throw x;
08800 }
08801 if (mtype != ::apache::thrift::protocol::T_REPLY) {
08802 iprot_->skip(::apache::thrift::protocol::T_STRUCT);
08803 iprot_->readMessageEnd();
08804 iprot_->getTransport()->readEnd();
08805 }
08806 if (fname.compare("system_drop_column_family") != 0) {
08807 iprot_->skip(::apache::thrift::protocol::T_STRUCT);
08808 iprot_->readMessageEnd();
08809 iprot_->getTransport()->readEnd();
08810 }
08811 Cassandra_system_drop_column_family_presult result;
08812 result.success = &_return;
08813 result.read(iprot_);
08814 iprot_->readMessageEnd();
08815 iprot_->getTransport()->readEnd();
08816
08817 if (result.__isset.success) {
08818
08819 return;
08820 }
08821 if (result.__isset.ire) {
08822 throw result.ire;
08823 }
08824 if (result.__isset.sde) {
08825 throw result.sde;
08826 }
08827 throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "system_drop_column_family failed: unknown result");
08828 }
08829
08830 void CassandraClient::system_add_keyspace(std::string& _return, const KsDef& ks_def)
08831 {
08832 send_system_add_keyspace(ks_def);
08833 recv_system_add_keyspace(_return);
08834 }
08835
08836 void CassandraClient::send_system_add_keyspace(const KsDef& ks_def)
08837 {
08838 int32_t cseqid = 0;
08839 oprot_->writeMessageBegin("system_add_keyspace", ::apache::thrift::protocol::T_CALL, cseqid);
08840
08841 Cassandra_system_add_keyspace_pargs args;
08842 args.ks_def = &ks_def;
08843 args.write(oprot_);
08844
08845 oprot_->writeMessageEnd();
08846 oprot_->getTransport()->writeEnd();
08847 oprot_->getTransport()->flush();
08848 }
08849
08850 void CassandraClient::recv_system_add_keyspace(std::string& _return)
08851 {
08852
08853 int32_t rseqid = 0;
08854 std::string fname;
08855 ::apache::thrift::protocol::TMessageType mtype;
08856
08857 iprot_->readMessageBegin(fname, mtype, rseqid);
08858 if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
08859 ::apache::thrift::TApplicationException x;
08860 x.read(iprot_);
08861 iprot_->readMessageEnd();
08862 iprot_->getTransport()->readEnd();
08863 throw x;
08864 }
08865 if (mtype != ::apache::thrift::protocol::T_REPLY) {
08866 iprot_->skip(::apache::thrift::protocol::T_STRUCT);
08867 iprot_->readMessageEnd();
08868 iprot_->getTransport()->readEnd();
08869 }
08870 if (fname.compare("system_add_keyspace") != 0) {
08871 iprot_->skip(::apache::thrift::protocol::T_STRUCT);
08872 iprot_->readMessageEnd();
08873 iprot_->getTransport()->readEnd();
08874 }
08875 Cassandra_system_add_keyspace_presult result;
08876 result.success = &_return;
08877 result.read(iprot_);
08878 iprot_->readMessageEnd();
08879 iprot_->getTransport()->readEnd();
08880
08881 if (result.__isset.success) {
08882
08883 return;
08884 }
08885 if (result.__isset.ire) {
08886 throw result.ire;
08887 }
08888 if (result.__isset.sde) {
08889 throw result.sde;
08890 }
08891 throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "system_add_keyspace failed: unknown result");
08892 }
08893
08894 void CassandraClient::system_drop_keyspace(std::string& _return, const std::string& keyspace)
08895 {
08896 send_system_drop_keyspace(keyspace);
08897 recv_system_drop_keyspace(_return);
08898 }
08899
08900 void CassandraClient::send_system_drop_keyspace(const std::string& keyspace)
08901 {
08902 int32_t cseqid = 0;
08903 oprot_->writeMessageBegin("system_drop_keyspace", ::apache::thrift::protocol::T_CALL, cseqid);
08904
08905 Cassandra_system_drop_keyspace_pargs args;
08906 args.keyspace = &keyspace;
08907 args.write(oprot_);
08908
08909 oprot_->writeMessageEnd();
08910 oprot_->getTransport()->writeEnd();
08911 oprot_->getTransport()->flush();
08912 }
08913
08914 void CassandraClient::recv_system_drop_keyspace(std::string& _return)
08915 {
08916
08917 int32_t rseqid = 0;
08918 std::string fname;
08919 ::apache::thrift::protocol::TMessageType mtype;
08920
08921 iprot_->readMessageBegin(fname, mtype, rseqid);
08922 if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
08923 ::apache::thrift::TApplicationException x;
08924 x.read(iprot_);
08925 iprot_->readMessageEnd();
08926 iprot_->getTransport()->readEnd();
08927 throw x;
08928 }
08929 if (mtype != ::apache::thrift::protocol::T_REPLY) {
08930 iprot_->skip(::apache::thrift::protocol::T_STRUCT);
08931 iprot_->readMessageEnd();
08932 iprot_->getTransport()->readEnd();
08933 }
08934 if (fname.compare("system_drop_keyspace") != 0) {
08935 iprot_->skip(::apache::thrift::protocol::T_STRUCT);
08936 iprot_->readMessageEnd();
08937 iprot_->getTransport()->readEnd();
08938 }
08939 Cassandra_system_drop_keyspace_presult result;
08940 result.success = &_return;
08941 result.read(iprot_);
08942 iprot_->readMessageEnd();
08943 iprot_->getTransport()->readEnd();
08944
08945 if (result.__isset.success) {
08946
08947 return;
08948 }
08949 if (result.__isset.ire) {
08950 throw result.ire;
08951 }
08952 if (result.__isset.sde) {
08953 throw result.sde;
08954 }
08955 throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "system_drop_keyspace failed: unknown result");
08956 }
08957
08958 void CassandraClient::system_update_keyspace(std::string& _return, const KsDef& ks_def)
08959 {
08960 send_system_update_keyspace(ks_def);
08961 recv_system_update_keyspace(_return);
08962 }
08963
08964 void CassandraClient::send_system_update_keyspace(const KsDef& ks_def)
08965 {
08966 int32_t cseqid = 0;
08967 oprot_->writeMessageBegin("system_update_keyspace", ::apache::thrift::protocol::T_CALL, cseqid);
08968
08969 Cassandra_system_update_keyspace_pargs args;
08970 args.ks_def = &ks_def;
08971 args.write(oprot_);
08972
08973 oprot_->writeMessageEnd();
08974 oprot_->getTransport()->writeEnd();
08975 oprot_->getTransport()->flush();
08976 }
08977
08978 void CassandraClient::recv_system_update_keyspace(std::string& _return)
08979 {
08980
08981 int32_t rseqid = 0;
08982 std::string fname;
08983 ::apache::thrift::protocol::TMessageType mtype;
08984
08985 iprot_->readMessageBegin(fname, mtype, rseqid);
08986 if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
08987 ::apache::thrift::TApplicationException x;
08988 x.read(iprot_);
08989 iprot_->readMessageEnd();
08990 iprot_->getTransport()->readEnd();
08991 throw x;
08992 }
08993 if (mtype != ::apache::thrift::protocol::T_REPLY) {
08994 iprot_->skip(::apache::thrift::protocol::T_STRUCT);
08995 iprot_->readMessageEnd();
08996 iprot_->getTransport()->readEnd();
08997 }
08998 if (fname.compare("system_update_keyspace") != 0) {
08999 iprot_->skip(::apache::thrift::protocol::T_STRUCT);
09000 iprot_->readMessageEnd();
09001 iprot_->getTransport()->readEnd();
09002 }
09003 Cassandra_system_update_keyspace_presult result;
09004 result.success = &_return;
09005 result.read(iprot_);
09006 iprot_->readMessageEnd();
09007 iprot_->getTransport()->readEnd();
09008
09009 if (result.__isset.success) {
09010
09011 return;
09012 }
09013 if (result.__isset.ire) {
09014 throw result.ire;
09015 }
09016 if (result.__isset.sde) {
09017 throw result.sde;
09018 }
09019 throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "system_update_keyspace failed: unknown result");
09020 }
09021
09022 void CassandraClient::system_update_column_family(std::string& _return, const CfDef& cf_def)
09023 {
09024 send_system_update_column_family(cf_def);
09025 recv_system_update_column_family(_return);
09026 }
09027
09028 void CassandraClient::send_system_update_column_family(const CfDef& cf_def)
09029 {
09030 int32_t cseqid = 0;
09031 oprot_->writeMessageBegin("system_update_column_family", ::apache::thrift::protocol::T_CALL, cseqid);
09032
09033 Cassandra_system_update_column_family_pargs args;
09034 args.cf_def = &cf_def;
09035 args.write(oprot_);
09036
09037 oprot_->writeMessageEnd();
09038 oprot_->getTransport()->writeEnd();
09039 oprot_->getTransport()->flush();
09040 }
09041
09042 void CassandraClient::recv_system_update_column_family(std::string& _return)
09043 {
09044
09045 int32_t rseqid = 0;
09046 std::string fname;
09047 ::apache::thrift::protocol::TMessageType mtype;
09048
09049 iprot_->readMessageBegin(fname, mtype, rseqid);
09050 if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
09051 ::apache::thrift::TApplicationException x;
09052 x.read(iprot_);
09053 iprot_->readMessageEnd();
09054 iprot_->getTransport()->readEnd();
09055 throw x;
09056 }
09057 if (mtype != ::apache::thrift::protocol::T_REPLY) {
09058 iprot_->skip(::apache::thrift::protocol::T_STRUCT);
09059 iprot_->readMessageEnd();
09060 iprot_->getTransport()->readEnd();
09061 }
09062 if (fname.compare("system_update_column_family") != 0) {
09063 iprot_->skip(::apache::thrift::protocol::T_STRUCT);
09064 iprot_->readMessageEnd();
09065 iprot_->getTransport()->readEnd();
09066 }
09067 Cassandra_system_update_column_family_presult result;
09068 result.success = &_return;
09069 result.read(iprot_);
09070 iprot_->readMessageEnd();
09071 iprot_->getTransport()->readEnd();
09072
09073 if (result.__isset.success) {
09074
09075 return;
09076 }
09077 if (result.__isset.ire) {
09078 throw result.ire;
09079 }
09080 if (result.__isset.sde) {
09081 throw result.sde;
09082 }
09083 throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "system_update_column_family failed: unknown result");
09084 }
09085
09086 void CassandraClient::execute_cql_query(CqlResult& _return, const std::string& query, const Compression::type compression)
09087 {
09088 send_execute_cql_query(query, compression);
09089 recv_execute_cql_query(_return);
09090 }
09091
09092 void CassandraClient::send_execute_cql_query(const std::string& query, const Compression::type compression)
09093 {
09094 int32_t cseqid = 0;
09095 oprot_->writeMessageBegin("execute_cql_query", ::apache::thrift::protocol::T_CALL, cseqid);
09096
09097 Cassandra_execute_cql_query_pargs args;
09098 args.query = &query;
09099 args.compression = &compression;
09100 args.write(oprot_);
09101
09102 oprot_->writeMessageEnd();
09103 oprot_->getTransport()->writeEnd();
09104 oprot_->getTransport()->flush();
09105 }
09106
09107 void CassandraClient::recv_execute_cql_query(CqlResult& _return)
09108 {
09109
09110 int32_t rseqid = 0;
09111 std::string fname;
09112 ::apache::thrift::protocol::TMessageType mtype;
09113
09114 iprot_->readMessageBegin(fname, mtype, rseqid);
09115 if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
09116 ::apache::thrift::TApplicationException x;
09117 x.read(iprot_);
09118 iprot_->readMessageEnd();
09119 iprot_->getTransport()->readEnd();
09120 throw x;
09121 }
09122 if (mtype != ::apache::thrift::protocol::T_REPLY) {
09123 iprot_->skip(::apache::thrift::protocol::T_STRUCT);
09124 iprot_->readMessageEnd();
09125 iprot_->getTransport()->readEnd();
09126 }
09127 if (fname.compare("execute_cql_query") != 0) {
09128 iprot_->skip(::apache::thrift::protocol::T_STRUCT);
09129 iprot_->readMessageEnd();
09130 iprot_->getTransport()->readEnd();
09131 }
09132 Cassandra_execute_cql_query_presult result;
09133 result.success = &_return;
09134 result.read(iprot_);
09135 iprot_->readMessageEnd();
09136 iprot_->getTransport()->readEnd();
09137
09138 if (result.__isset.success) {
09139
09140 return;
09141 }
09142 if (result.__isset.ire) {
09143 throw result.ire;
09144 }
09145 if (result.__isset.ue) {
09146 throw result.ue;
09147 }
09148 if (result.__isset.te) {
09149 throw result.te;
09150 }
09151 if (result.__isset.sde) {
09152 throw result.sde;
09153 }
09154 throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "execute_cql_query failed: unknown result");
09155 }
09156
09157 bool CassandraProcessor::process(boost::shared_ptr< ::apache::thrift::protocol::TProtocol> piprot, boost::shared_ptr< ::apache::thrift::protocol::TProtocol> poprot, void* callContext) {
09158
09159 ::apache::thrift::protocol::TProtocol* iprot = piprot.get();
09160 ::apache::thrift::protocol::TProtocol* oprot = poprot.get();
09161 std::string fname;
09162 ::apache::thrift::protocol::TMessageType mtype;
09163 int32_t seqid;
09164
09165 iprot->readMessageBegin(fname, mtype, seqid);
09166
09167 if (mtype != ::apache::thrift::protocol::T_CALL && mtype != ::apache::thrift::protocol::T_ONEWAY) {
09168 iprot->skip(::apache::thrift::protocol::T_STRUCT);
09169 iprot->readMessageEnd();
09170 iprot->getTransport()->readEnd();
09171 ::apache::thrift::TApplicationException x(::apache::thrift::TApplicationException::INVALID_MESSAGE_TYPE);
09172 oprot->writeMessageBegin(fname, ::apache::thrift::protocol::T_EXCEPTION, seqid);
09173 x.write(oprot);
09174 oprot->writeMessageEnd();
09175 oprot->getTransport()->writeEnd();
09176 oprot->getTransport()->flush();
09177 return true;
09178 }
09179
09180 return process_fn(iprot, oprot, fname, seqid, callContext);
09181 }
09182
09183 bool CassandraProcessor::process_fn(::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, std::string& fname, int32_t seqid, void* callContext) {
09184 std::map<std::string, void (CassandraProcessor::*)(int32_t, ::apache::thrift::protocol::TProtocol*, ::apache::thrift::protocol::TProtocol*, void*)>::iterator pfn;
09185 pfn = processMap_.find(fname);
09186 if (pfn == processMap_.end()) {
09187 iprot->skip(::apache::thrift::protocol::T_STRUCT);
09188 iprot->readMessageEnd();
09189 iprot->getTransport()->readEnd();
09190 ::apache::thrift::TApplicationException x(::apache::thrift::TApplicationException::UNKNOWN_METHOD, "Invalid method name: '"+fname+"'");
09191 oprot->writeMessageBegin(fname, ::apache::thrift::protocol::T_EXCEPTION, seqid);
09192 x.write(oprot);
09193 oprot->writeMessageEnd();
09194 oprot->getTransport()->writeEnd();
09195 oprot->getTransport()->flush();
09196 return true;
09197 }
09198 (this->*(pfn->second))(seqid, iprot, oprot, callContext);
09199 return true;
09200 }
09201
09202 void CassandraProcessor::process_login(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
09203 {
09204 void* ctx = NULL;
09205 if (eventHandler_.get() != NULL) {
09206 ctx = eventHandler_->getContext("Cassandra.login", callContext);
09207 }
09208 ::apache::thrift::TProcessorContextFreer freer(eventHandler_.get(), ctx, "Cassandra.login");
09209
09210 if (eventHandler_.get() != NULL) {
09211 eventHandler_->preRead(ctx, "Cassandra.login");
09212 }
09213
09214 Cassandra_login_args args;
09215 args.read(iprot);
09216 iprot->readMessageEnd();
09217 uint32_t bytes = iprot->getTransport()->readEnd();
09218
09219 if (eventHandler_.get() != NULL) {
09220 eventHandler_->postRead(ctx, "Cassandra.login", bytes);
09221 }
09222
09223 Cassandra_login_result result;
09224 try {
09225 iface_->login(args.auth_request);
09226 } catch (AuthenticationException &authnx) {
09227 result.authnx = authnx;
09228 result.__isset.authnx = true;
09229 } catch (AuthorizationException &authzx) {
09230 result.authzx = authzx;
09231 result.__isset.authzx = true;
09232 } catch (const std::exception& e) {
09233 if (eventHandler_.get() != NULL) {
09234 eventHandler_->handlerError(ctx, "Cassandra.login");
09235 }
09236
09237 ::apache::thrift::TApplicationException x(e.what());
09238 oprot->writeMessageBegin("login", ::apache::thrift::protocol::T_EXCEPTION, seqid);
09239 x.write(oprot);
09240 oprot->writeMessageEnd();
09241 oprot->getTransport()->writeEnd();
09242 oprot->getTransport()->flush();
09243 return;
09244 }
09245
09246 if (eventHandler_.get() != NULL) {
09247 eventHandler_->preWrite(ctx, "Cassandra.login");
09248 }
09249
09250 oprot->writeMessageBegin("login", ::apache::thrift::protocol::T_REPLY, seqid);
09251 result.write(oprot);
09252 oprot->writeMessageEnd();
09253 bytes = oprot->getTransport()->writeEnd();
09254 oprot->getTransport()->flush();
09255
09256 if (eventHandler_.get() != NULL) {
09257 eventHandler_->postWrite(ctx, "Cassandra.login", bytes);
09258 }
09259 }
09260
09261 void CassandraProcessor::process_set_keyspace(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
09262 {
09263 void* ctx = NULL;
09264 if (eventHandler_.get() != NULL) {
09265 ctx = eventHandler_->getContext("Cassandra.set_keyspace", callContext);
09266 }
09267 ::apache::thrift::TProcessorContextFreer freer(eventHandler_.get(), ctx, "Cassandra.set_keyspace");
09268
09269 if (eventHandler_.get() != NULL) {
09270 eventHandler_->preRead(ctx, "Cassandra.set_keyspace");
09271 }
09272
09273 Cassandra_set_keyspace_args args;
09274 args.read(iprot);
09275 iprot->readMessageEnd();
09276 uint32_t bytes = iprot->getTransport()->readEnd();
09277
09278 if (eventHandler_.get() != NULL) {
09279 eventHandler_->postRead(ctx, "Cassandra.set_keyspace", bytes);
09280 }
09281
09282 Cassandra_set_keyspace_result result;
09283 try {
09284 iface_->set_keyspace(args.keyspace);
09285 } catch (InvalidRequestException &ire) {
09286 result.ire = ire;
09287 result.__isset.ire = true;
09288 } catch (const std::exception& e) {
09289 if (eventHandler_.get() != NULL) {
09290 eventHandler_->handlerError(ctx, "Cassandra.set_keyspace");
09291 }
09292
09293 ::apache::thrift::TApplicationException x(e.what());
09294 oprot->writeMessageBegin("set_keyspace", ::apache::thrift::protocol::T_EXCEPTION, seqid);
09295 x.write(oprot);
09296 oprot->writeMessageEnd();
09297 oprot->getTransport()->writeEnd();
09298 oprot->getTransport()->flush();
09299 return;
09300 }
09301
09302 if (eventHandler_.get() != NULL) {
09303 eventHandler_->preWrite(ctx, "Cassandra.set_keyspace");
09304 }
09305
09306 oprot->writeMessageBegin("set_keyspace", ::apache::thrift::protocol::T_REPLY, seqid);
09307 result.write(oprot);
09308 oprot->writeMessageEnd();
09309 bytes = oprot->getTransport()->writeEnd();
09310 oprot->getTransport()->flush();
09311
09312 if (eventHandler_.get() != NULL) {
09313 eventHandler_->postWrite(ctx, "Cassandra.set_keyspace", bytes);
09314 }
09315 }
09316
09317 void CassandraProcessor::process_get(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
09318 {
09319 void* ctx = NULL;
09320 if (eventHandler_.get() != NULL) {
09321 ctx = eventHandler_->getContext("Cassandra.get", callContext);
09322 }
09323 ::apache::thrift::TProcessorContextFreer freer(eventHandler_.get(), ctx, "Cassandra.get");
09324
09325 if (eventHandler_.get() != NULL) {
09326 eventHandler_->preRead(ctx, "Cassandra.get");
09327 }
09328
09329 Cassandra_get_args args;
09330 args.read(iprot);
09331 iprot->readMessageEnd();
09332 uint32_t bytes = iprot->getTransport()->readEnd();
09333
09334 if (eventHandler_.get() != NULL) {
09335 eventHandler_->postRead(ctx, "Cassandra.get", bytes);
09336 }
09337
09338 Cassandra_get_result result;
09339 try {
09340 iface_->get(result.success, args.key, args.column_path, args.consistency_level);
09341 result.__isset.success = true;
09342 } catch (InvalidRequestException &ire) {
09343 result.ire = ire;
09344 result.__isset.ire = true;
09345 } catch (NotFoundException &nfe) {
09346 result.nfe = nfe;
09347 result.__isset.nfe = true;
09348 } catch (UnavailableException &ue) {
09349 result.ue = ue;
09350 result.__isset.ue = true;
09351 } catch (TimedOutException &te) {
09352 result.te = te;
09353 result.__isset.te = true;
09354 } catch (const std::exception& e) {
09355 if (eventHandler_.get() != NULL) {
09356 eventHandler_->handlerError(ctx, "Cassandra.get");
09357 }
09358
09359 ::apache::thrift::TApplicationException x(e.what());
09360 oprot->writeMessageBegin("get", ::apache::thrift::protocol::T_EXCEPTION, seqid);
09361 x.write(oprot);
09362 oprot->writeMessageEnd();
09363 oprot->getTransport()->writeEnd();
09364 oprot->getTransport()->flush();
09365 return;
09366 }
09367
09368 if (eventHandler_.get() != NULL) {
09369 eventHandler_->preWrite(ctx, "Cassandra.get");
09370 }
09371
09372 oprot->writeMessageBegin("get", ::apache::thrift::protocol::T_REPLY, seqid);
09373 result.write(oprot);
09374 oprot->writeMessageEnd();
09375 bytes = oprot->getTransport()->writeEnd();
09376 oprot->getTransport()->flush();
09377
09378 if (eventHandler_.get() != NULL) {
09379 eventHandler_->postWrite(ctx, "Cassandra.get", bytes);
09380 }
09381 }
09382
09383 void CassandraProcessor::process_get_slice(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
09384 {
09385 void* ctx = NULL;
09386 if (eventHandler_.get() != NULL) {
09387 ctx = eventHandler_->getContext("Cassandra.get_slice", callContext);
09388 }
09389 ::apache::thrift::TProcessorContextFreer freer(eventHandler_.get(), ctx, "Cassandra.get_slice");
09390
09391 if (eventHandler_.get() != NULL) {
09392 eventHandler_->preRead(ctx, "Cassandra.get_slice");
09393 }
09394
09395 Cassandra_get_slice_args args;
09396 args.read(iprot);
09397 iprot->readMessageEnd();
09398 uint32_t bytes = iprot->getTransport()->readEnd();
09399
09400 if (eventHandler_.get() != NULL) {
09401 eventHandler_->postRead(ctx, "Cassandra.get_slice", bytes);
09402 }
09403
09404 Cassandra_get_slice_result result;
09405 try {
09406 iface_->get_slice(result.success, args.key, args.column_parent, args.predicate, args.consistency_level);
09407 result.__isset.success = true;
09408 } catch (InvalidRequestException &ire) {
09409 result.ire = ire;
09410 result.__isset.ire = true;
09411 } catch (UnavailableException &ue) {
09412 result.ue = ue;
09413 result.__isset.ue = true;
09414 } catch (TimedOutException &te) {
09415 result.te = te;
09416 result.__isset.te = true;
09417 } catch (const std::exception& e) {
09418 if (eventHandler_.get() != NULL) {
09419 eventHandler_->handlerError(ctx, "Cassandra.get_slice");
09420 }
09421
09422 ::apache::thrift::TApplicationException x(e.what());
09423 oprot->writeMessageBegin("get_slice", ::apache::thrift::protocol::T_EXCEPTION, seqid);
09424 x.write(oprot);
09425 oprot->writeMessageEnd();
09426 oprot->getTransport()->writeEnd();
09427 oprot->getTransport()->flush();
09428 return;
09429 }
09430
09431 if (eventHandler_.get() != NULL) {
09432 eventHandler_->preWrite(ctx, "Cassandra.get_slice");
09433 }
09434
09435 oprot->writeMessageBegin("get_slice", ::apache::thrift::protocol::T_REPLY, seqid);
09436 result.write(oprot);
09437 oprot->writeMessageEnd();
09438 bytes = oprot->getTransport()->writeEnd();
09439 oprot->getTransport()->flush();
09440
09441 if (eventHandler_.get() != NULL) {
09442 eventHandler_->postWrite(ctx, "Cassandra.get_slice", bytes);
09443 }
09444 }
09445
09446 void CassandraProcessor::process_get_count(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
09447 {
09448 void* ctx = NULL;
09449 if (eventHandler_.get() != NULL) {
09450 ctx = eventHandler_->getContext("Cassandra.get_count", callContext);
09451 }
09452 ::apache::thrift::TProcessorContextFreer freer(eventHandler_.get(), ctx, "Cassandra.get_count");
09453
09454 if (eventHandler_.get() != NULL) {
09455 eventHandler_->preRead(ctx, "Cassandra.get_count");
09456 }
09457
09458 Cassandra_get_count_args args;
09459 args.read(iprot);
09460 iprot->readMessageEnd();
09461 uint32_t bytes = iprot->getTransport()->readEnd();
09462
09463 if (eventHandler_.get() != NULL) {
09464 eventHandler_->postRead(ctx, "Cassandra.get_count", bytes);
09465 }
09466
09467 Cassandra_get_count_result result;
09468 try {
09469 result.success = iface_->get_count(args.key, args.column_parent, args.predicate, args.consistency_level);
09470 result.__isset.success = true;
09471 } catch (InvalidRequestException &ire) {
09472 result.ire = ire;
09473 result.__isset.ire = true;
09474 } catch (UnavailableException &ue) {
09475 result.ue = ue;
09476 result.__isset.ue = true;
09477 } catch (TimedOutException &te) {
09478 result.te = te;
09479 result.__isset.te = true;
09480 } catch (const std::exception& e) {
09481 if (eventHandler_.get() != NULL) {
09482 eventHandler_->handlerError(ctx, "Cassandra.get_count");
09483 }
09484
09485 ::apache::thrift::TApplicationException x(e.what());
09486 oprot->writeMessageBegin("get_count", ::apache::thrift::protocol::T_EXCEPTION, seqid);
09487 x.write(oprot);
09488 oprot->writeMessageEnd();
09489 oprot->getTransport()->writeEnd();
09490 oprot->getTransport()->flush();
09491 return;
09492 }
09493
09494 if (eventHandler_.get() != NULL) {
09495 eventHandler_->preWrite(ctx, "Cassandra.get_count");
09496 }
09497
09498 oprot->writeMessageBegin("get_count", ::apache::thrift::protocol::T_REPLY, seqid);
09499 result.write(oprot);
09500 oprot->writeMessageEnd();
09501 bytes = oprot->getTransport()->writeEnd();
09502 oprot->getTransport()->flush();
09503
09504 if (eventHandler_.get() != NULL) {
09505 eventHandler_->postWrite(ctx, "Cassandra.get_count", bytes);
09506 }
09507 }
09508
09509 void CassandraProcessor::process_multiget_slice(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
09510 {
09511 void* ctx = NULL;
09512 if (eventHandler_.get() != NULL) {
09513 ctx = eventHandler_->getContext("Cassandra.multiget_slice", callContext);
09514 }
09515 ::apache::thrift::TProcessorContextFreer freer(eventHandler_.get(), ctx, "Cassandra.multiget_slice");
09516
09517 if (eventHandler_.get() != NULL) {
09518 eventHandler_->preRead(ctx, "Cassandra.multiget_slice");
09519 }
09520
09521 Cassandra_multiget_slice_args args;
09522 args.read(iprot);
09523 iprot->readMessageEnd();
09524 uint32_t bytes = iprot->getTransport()->readEnd();
09525
09526 if (eventHandler_.get() != NULL) {
09527 eventHandler_->postRead(ctx, "Cassandra.multiget_slice", bytes);
09528 }
09529
09530 Cassandra_multiget_slice_result result;
09531 try {
09532 iface_->multiget_slice(result.success, args.keys, args.column_parent, args.predicate, args.consistency_level);
09533 result.__isset.success = true;
09534 } catch (InvalidRequestException &ire) {
09535 result.ire = ire;
09536 result.__isset.ire = true;
09537 } catch (UnavailableException &ue) {
09538 result.ue = ue;
09539 result.__isset.ue = true;
09540 } catch (TimedOutException &te) {
09541 result.te = te;
09542 result.__isset.te = true;
09543 } catch (const std::exception& e) {
09544 if (eventHandler_.get() != NULL) {
09545 eventHandler_->handlerError(ctx, "Cassandra.multiget_slice");
09546 }
09547
09548 ::apache::thrift::TApplicationException x(e.what());
09549 oprot->writeMessageBegin("multiget_slice", ::apache::thrift::protocol::T_EXCEPTION, seqid);
09550 x.write(oprot);
09551 oprot->writeMessageEnd();
09552 oprot->getTransport()->writeEnd();
09553 oprot->getTransport()->flush();
09554 return;
09555 }
09556
09557 if (eventHandler_.get() != NULL) {
09558 eventHandler_->preWrite(ctx, "Cassandra.multiget_slice");
09559 }
09560
09561 oprot->writeMessageBegin("multiget_slice", ::apache::thrift::protocol::T_REPLY, seqid);
09562 result.write(oprot);
09563 oprot->writeMessageEnd();
09564 bytes = oprot->getTransport()->writeEnd();
09565 oprot->getTransport()->flush();
09566
09567 if (eventHandler_.get() != NULL) {
09568 eventHandler_->postWrite(ctx, "Cassandra.multiget_slice", bytes);
09569 }
09570 }
09571
09572 void CassandraProcessor::process_multiget_count(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
09573 {
09574 void* ctx = NULL;
09575 if (eventHandler_.get() != NULL) {
09576 ctx = eventHandler_->getContext("Cassandra.multiget_count", callContext);
09577 }
09578 ::apache::thrift::TProcessorContextFreer freer(eventHandler_.get(), ctx, "Cassandra.multiget_count");
09579
09580 if (eventHandler_.get() != NULL) {
09581 eventHandler_->preRead(ctx, "Cassandra.multiget_count");
09582 }
09583
09584 Cassandra_multiget_count_args args;
09585 args.read(iprot);
09586 iprot->readMessageEnd();
09587 uint32_t bytes = iprot->getTransport()->readEnd();
09588
09589 if (eventHandler_.get() != NULL) {
09590 eventHandler_->postRead(ctx, "Cassandra.multiget_count", bytes);
09591 }
09592
09593 Cassandra_multiget_count_result result;
09594 try {
09595 iface_->multiget_count(result.success, args.keys, args.column_parent, args.predicate, args.consistency_level);
09596 result.__isset.success = true;
09597 } catch (InvalidRequestException &ire) {
09598 result.ire = ire;
09599 result.__isset.ire = true;
09600 } catch (UnavailableException &ue) {
09601 result.ue = ue;
09602 result.__isset.ue = true;
09603 } catch (TimedOutException &te) {
09604 result.te = te;
09605 result.__isset.te = true;
09606 } catch (const std::exception& e) {
09607 if (eventHandler_.get() != NULL) {
09608 eventHandler_->handlerError(ctx, "Cassandra.multiget_count");
09609 }
09610
09611 ::apache::thrift::TApplicationException x(e.what());
09612 oprot->writeMessageBegin("multiget_count", ::apache::thrift::protocol::T_EXCEPTION, seqid);
09613 x.write(oprot);
09614 oprot->writeMessageEnd();
09615 oprot->getTransport()->writeEnd();
09616 oprot->getTransport()->flush();
09617 return;
09618 }
09619
09620 if (eventHandler_.get() != NULL) {
09621 eventHandler_->preWrite(ctx, "Cassandra.multiget_count");
09622 }
09623
09624 oprot->writeMessageBegin("multiget_count", ::apache::thrift::protocol::T_REPLY, seqid);
09625 result.write(oprot);
09626 oprot->writeMessageEnd();
09627 bytes = oprot->getTransport()->writeEnd();
09628 oprot->getTransport()->flush();
09629
09630 if (eventHandler_.get() != NULL) {
09631 eventHandler_->postWrite(ctx, "Cassandra.multiget_count", bytes);
09632 }
09633 }
09634
09635 void CassandraProcessor::process_get_range_slices(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
09636 {
09637 void* ctx = NULL;
09638 if (eventHandler_.get() != NULL) {
09639 ctx = eventHandler_->getContext("Cassandra.get_range_slices", callContext);
09640 }
09641 ::apache::thrift::TProcessorContextFreer freer(eventHandler_.get(), ctx, "Cassandra.get_range_slices");
09642
09643 if (eventHandler_.get() != NULL) {
09644 eventHandler_->preRead(ctx, "Cassandra.get_range_slices");
09645 }
09646
09647 Cassandra_get_range_slices_args args;
09648 args.read(iprot);
09649 iprot->readMessageEnd();
09650 uint32_t bytes = iprot->getTransport()->readEnd();
09651
09652 if (eventHandler_.get() != NULL) {
09653 eventHandler_->postRead(ctx, "Cassandra.get_range_slices", bytes);
09654 }
09655
09656 Cassandra_get_range_slices_result result;
09657 try {
09658 iface_->get_range_slices(result.success, args.column_parent, args.predicate, args.range, args.consistency_level);
09659 result.__isset.success = true;
09660 } catch (InvalidRequestException &ire) {
09661 result.ire = ire;
09662 result.__isset.ire = true;
09663 } catch (UnavailableException &ue) {
09664 result.ue = ue;
09665 result.__isset.ue = true;
09666 } catch (TimedOutException &te) {
09667 result.te = te;
09668 result.__isset.te = true;
09669 } catch (const std::exception& e) {
09670 if (eventHandler_.get() != NULL) {
09671 eventHandler_->handlerError(ctx, "Cassandra.get_range_slices");
09672 }
09673
09674 ::apache::thrift::TApplicationException x(e.what());
09675 oprot->writeMessageBegin("get_range_slices", ::apache::thrift::protocol::T_EXCEPTION, seqid);
09676 x.write(oprot);
09677 oprot->writeMessageEnd();
09678 oprot->getTransport()->writeEnd();
09679 oprot->getTransport()->flush();
09680 return;
09681 }
09682
09683 if (eventHandler_.get() != NULL) {
09684 eventHandler_->preWrite(ctx, "Cassandra.get_range_slices");
09685 }
09686
09687 oprot->writeMessageBegin("get_range_slices", ::apache::thrift::protocol::T_REPLY, seqid);
09688 result.write(oprot);
09689 oprot->writeMessageEnd();
09690 bytes = oprot->getTransport()->writeEnd();
09691 oprot->getTransport()->flush();
09692
09693 if (eventHandler_.get() != NULL) {
09694 eventHandler_->postWrite(ctx, "Cassandra.get_range_slices", bytes);
09695 }
09696 }
09697
09698 void CassandraProcessor::process_get_indexed_slices(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
09699 {
09700 void* ctx = NULL;
09701 if (eventHandler_.get() != NULL) {
09702 ctx = eventHandler_->getContext("Cassandra.get_indexed_slices", callContext);
09703 }
09704 ::apache::thrift::TProcessorContextFreer freer(eventHandler_.get(), ctx, "Cassandra.get_indexed_slices");
09705
09706 if (eventHandler_.get() != NULL) {
09707 eventHandler_->preRead(ctx, "Cassandra.get_indexed_slices");
09708 }
09709
09710 Cassandra_get_indexed_slices_args args;
09711 args.read(iprot);
09712 iprot->readMessageEnd();
09713 uint32_t bytes = iprot->getTransport()->readEnd();
09714
09715 if (eventHandler_.get() != NULL) {
09716 eventHandler_->postRead(ctx, "Cassandra.get_indexed_slices", bytes);
09717 }
09718
09719 Cassandra_get_indexed_slices_result result;
09720 try {
09721 iface_->get_indexed_slices(result.success, args.column_parent, args.index_clause, args.column_predicate, args.consistency_level);
09722 result.__isset.success = true;
09723 } catch (InvalidRequestException &ire) {
09724 result.ire = ire;
09725 result.__isset.ire = true;
09726 } catch (UnavailableException &ue) {
09727 result.ue = ue;
09728 result.__isset.ue = true;
09729 } catch (TimedOutException &te) {
09730 result.te = te;
09731 result.__isset.te = true;
09732 } catch (const std::exception& e) {
09733 if (eventHandler_.get() != NULL) {
09734 eventHandler_->handlerError(ctx, "Cassandra.get_indexed_slices");
09735 }
09736
09737 ::apache::thrift::TApplicationException x(e.what());
09738 oprot->writeMessageBegin("get_indexed_slices", ::apache::thrift::protocol::T_EXCEPTION, seqid);
09739 x.write(oprot);
09740 oprot->writeMessageEnd();
09741 oprot->getTransport()->writeEnd();
09742 oprot->getTransport()->flush();
09743 return;
09744 }
09745
09746 if (eventHandler_.get() != NULL) {
09747 eventHandler_->preWrite(ctx, "Cassandra.get_indexed_slices");
09748 }
09749
09750 oprot->writeMessageBegin("get_indexed_slices", ::apache::thrift::protocol::T_REPLY, seqid);
09751 result.write(oprot);
09752 oprot->writeMessageEnd();
09753 bytes = oprot->getTransport()->writeEnd();
09754 oprot->getTransport()->flush();
09755
09756 if (eventHandler_.get() != NULL) {
09757 eventHandler_->postWrite(ctx, "Cassandra.get_indexed_slices", bytes);
09758 }
09759 }
09760
09761 void CassandraProcessor::process_insert(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
09762 {
09763 void* ctx = NULL;
09764 if (eventHandler_.get() != NULL) {
09765 ctx = eventHandler_->getContext("Cassandra.insert", callContext);
09766 }
09767 ::apache::thrift::TProcessorContextFreer freer(eventHandler_.get(), ctx, "Cassandra.insert");
09768
09769 if (eventHandler_.get() != NULL) {
09770 eventHandler_->preRead(ctx, "Cassandra.insert");
09771 }
09772
09773 Cassandra_insert_args args;
09774 args.read(iprot);
09775 iprot->readMessageEnd();
09776 uint32_t bytes = iprot->getTransport()->readEnd();
09777
09778 if (eventHandler_.get() != NULL) {
09779 eventHandler_->postRead(ctx, "Cassandra.insert", bytes);
09780 }
09781
09782 Cassandra_insert_result result;
09783 try {
09784 iface_->insert(args.key, args.column_parent, args.column, args.consistency_level);
09785 } catch (InvalidRequestException &ire) {
09786 result.ire = ire;
09787 result.__isset.ire = true;
09788 } catch (UnavailableException &ue) {
09789 result.ue = ue;
09790 result.__isset.ue = true;
09791 } catch (TimedOutException &te) {
09792 result.te = te;
09793 result.__isset.te = true;
09794 } catch (const std::exception& e) {
09795 if (eventHandler_.get() != NULL) {
09796 eventHandler_->handlerError(ctx, "Cassandra.insert");
09797 }
09798
09799 ::apache::thrift::TApplicationException x(e.what());
09800 oprot->writeMessageBegin("insert", ::apache::thrift::protocol::T_EXCEPTION, seqid);
09801 x.write(oprot);
09802 oprot->writeMessageEnd();
09803 oprot->getTransport()->writeEnd();
09804 oprot->getTransport()->flush();
09805 return;
09806 }
09807
09808 if (eventHandler_.get() != NULL) {
09809 eventHandler_->preWrite(ctx, "Cassandra.insert");
09810 }
09811
09812 oprot->writeMessageBegin("insert", ::apache::thrift::protocol::T_REPLY, seqid);
09813 result.write(oprot);
09814 oprot->writeMessageEnd();
09815 bytes = oprot->getTransport()->writeEnd();
09816 oprot->getTransport()->flush();
09817
09818 if (eventHandler_.get() != NULL) {
09819 eventHandler_->postWrite(ctx, "Cassandra.insert", bytes);
09820 }
09821 }
09822
09823 void CassandraProcessor::process_add(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
09824 {
09825 void* ctx = NULL;
09826 if (eventHandler_.get() != NULL) {
09827 ctx = eventHandler_->getContext("Cassandra.add", callContext);
09828 }
09829 ::apache::thrift::TProcessorContextFreer freer(eventHandler_.get(), ctx, "Cassandra.add");
09830
09831 if (eventHandler_.get() != NULL) {
09832 eventHandler_->preRead(ctx, "Cassandra.add");
09833 }
09834
09835 Cassandra_add_args args;
09836 args.read(iprot);
09837 iprot->readMessageEnd();
09838 uint32_t bytes = iprot->getTransport()->readEnd();
09839
09840 if (eventHandler_.get() != NULL) {
09841 eventHandler_->postRead(ctx, "Cassandra.add", bytes);
09842 }
09843
09844 Cassandra_add_result result;
09845 try {
09846 iface_->add(args.key, args.column_parent, args.column, args.consistency_level);
09847 } catch (InvalidRequestException &ire) {
09848 result.ire = ire;
09849 result.__isset.ire = true;
09850 } catch (UnavailableException &ue) {
09851 result.ue = ue;
09852 result.__isset.ue = true;
09853 } catch (TimedOutException &te) {
09854 result.te = te;
09855 result.__isset.te = true;
09856 } catch (const std::exception& e) {
09857 if (eventHandler_.get() != NULL) {
09858 eventHandler_->handlerError(ctx, "Cassandra.add");
09859 }
09860
09861 ::apache::thrift::TApplicationException x(e.what());
09862 oprot->writeMessageBegin("add", ::apache::thrift::protocol::T_EXCEPTION, seqid);
09863 x.write(oprot);
09864 oprot->writeMessageEnd();
09865 oprot->getTransport()->writeEnd();
09866 oprot->getTransport()->flush();
09867 return;
09868 }
09869
09870 if (eventHandler_.get() != NULL) {
09871 eventHandler_->preWrite(ctx, "Cassandra.add");
09872 }
09873
09874 oprot->writeMessageBegin("add", ::apache::thrift::protocol::T_REPLY, seqid);
09875 result.write(oprot);
09876 oprot->writeMessageEnd();
09877 bytes = oprot->getTransport()->writeEnd();
09878 oprot->getTransport()->flush();
09879
09880 if (eventHandler_.get() != NULL) {
09881 eventHandler_->postWrite(ctx, "Cassandra.add", bytes);
09882 }
09883 }
09884
09885 void CassandraProcessor::process_remove(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
09886 {
09887 void* ctx = NULL;
09888 if (eventHandler_.get() != NULL) {
09889 ctx = eventHandler_->getContext("Cassandra.remove", callContext);
09890 }
09891 ::apache::thrift::TProcessorContextFreer freer(eventHandler_.get(), ctx, "Cassandra.remove");
09892
09893 if (eventHandler_.get() != NULL) {
09894 eventHandler_->preRead(ctx, "Cassandra.remove");
09895 }
09896
09897 Cassandra_remove_args args;
09898 args.read(iprot);
09899 iprot->readMessageEnd();
09900 uint32_t bytes = iprot->getTransport()->readEnd();
09901
09902 if (eventHandler_.get() != NULL) {
09903 eventHandler_->postRead(ctx, "Cassandra.remove", bytes);
09904 }
09905
09906 Cassandra_remove_result result;
09907 try {
09908 iface_->remove(args.key, args.column_path, args.timestamp, args.consistency_level);
09909 } catch (InvalidRequestException &ire) {
09910 result.ire = ire;
09911 result.__isset.ire = true;
09912 } catch (UnavailableException &ue) {
09913 result.ue = ue;
09914 result.__isset.ue = true;
09915 } catch (TimedOutException &te) {
09916 result.te = te;
09917 result.__isset.te = true;
09918 } catch (const std::exception& e) {
09919 if (eventHandler_.get() != NULL) {
09920 eventHandler_->handlerError(ctx, "Cassandra.remove");
09921 }
09922
09923 ::apache::thrift::TApplicationException x(e.what());
09924 oprot->writeMessageBegin("remove", ::apache::thrift::protocol::T_EXCEPTION, seqid);
09925 x.write(oprot);
09926 oprot->writeMessageEnd();
09927 oprot->getTransport()->writeEnd();
09928 oprot->getTransport()->flush();
09929 return;
09930 }
09931
09932 if (eventHandler_.get() != NULL) {
09933 eventHandler_->preWrite(ctx, "Cassandra.remove");
09934 }
09935
09936 oprot->writeMessageBegin("remove", ::apache::thrift::protocol::T_REPLY, seqid);
09937 result.write(oprot);
09938 oprot->writeMessageEnd();
09939 bytes = oprot->getTransport()->writeEnd();
09940 oprot->getTransport()->flush();
09941
09942 if (eventHandler_.get() != NULL) {
09943 eventHandler_->postWrite(ctx, "Cassandra.remove", bytes);
09944 }
09945 }
09946
09947 void CassandraProcessor::process_remove_counter(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
09948 {
09949 void* ctx = NULL;
09950 if (eventHandler_.get() != NULL) {
09951 ctx = eventHandler_->getContext("Cassandra.remove_counter", callContext);
09952 }
09953 ::apache::thrift::TProcessorContextFreer freer(eventHandler_.get(), ctx, "Cassandra.remove_counter");
09954
09955 if (eventHandler_.get() != NULL) {
09956 eventHandler_->preRead(ctx, "Cassandra.remove_counter");
09957 }
09958
09959 Cassandra_remove_counter_args args;
09960 args.read(iprot);
09961 iprot->readMessageEnd();
09962 uint32_t bytes = iprot->getTransport()->readEnd();
09963
09964 if (eventHandler_.get() != NULL) {
09965 eventHandler_->postRead(ctx, "Cassandra.remove_counter", bytes);
09966 }
09967
09968 Cassandra_remove_counter_result result;
09969 try {
09970 iface_->remove_counter(args.key, args.path, args.consistency_level);
09971 } catch (InvalidRequestException &ire) {
09972 result.ire = ire;
09973 result.__isset.ire = true;
09974 } catch (UnavailableException &ue) {
09975 result.ue = ue;
09976 result.__isset.ue = true;
09977 } catch (TimedOutException &te) {
09978 result.te = te;
09979 result.__isset.te = true;
09980 } catch (const std::exception& e) {
09981 if (eventHandler_.get() != NULL) {
09982 eventHandler_->handlerError(ctx, "Cassandra.remove_counter");
09983 }
09984
09985 ::apache::thrift::TApplicationException x(e.what());
09986 oprot->writeMessageBegin("remove_counter", ::apache::thrift::protocol::T_EXCEPTION, seqid);
09987 x.write(oprot);
09988 oprot->writeMessageEnd();
09989 oprot->getTransport()->writeEnd();
09990 oprot->getTransport()->flush();
09991 return;
09992 }
09993
09994 if (eventHandler_.get() != NULL) {
09995 eventHandler_->preWrite(ctx, "Cassandra.remove_counter");
09996 }
09997
09998 oprot->writeMessageBegin("remove_counter", ::apache::thrift::protocol::T_REPLY, seqid);
09999 result.write(oprot);
10000 oprot->writeMessageEnd();
10001 bytes = oprot->getTransport()->writeEnd();
10002 oprot->getTransport()->flush();
10003
10004 if (eventHandler_.get() != NULL) {
10005 eventHandler_->postWrite(ctx, "Cassandra.remove_counter", bytes);
10006 }
10007 }
10008
10009 void CassandraProcessor::process_batch_mutate(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
10010 {
10011 void* ctx = NULL;
10012 if (eventHandler_.get() != NULL) {
10013 ctx = eventHandler_->getContext("Cassandra.batch_mutate", callContext);
10014 }
10015 ::apache::thrift::TProcessorContextFreer freer(eventHandler_.get(), ctx, "Cassandra.batch_mutate");
10016
10017 if (eventHandler_.get() != NULL) {
10018 eventHandler_->preRead(ctx, "Cassandra.batch_mutate");
10019 }
10020
10021 Cassandra_batch_mutate_args args;
10022 args.read(iprot);
10023 iprot->readMessageEnd();
10024 uint32_t bytes = iprot->getTransport()->readEnd();
10025
10026 if (eventHandler_.get() != NULL) {
10027 eventHandler_->postRead(ctx, "Cassandra.batch_mutate", bytes);
10028 }
10029
10030 Cassandra_batch_mutate_result result;
10031 try {
10032 iface_->batch_mutate(args.mutation_map, args.consistency_level);
10033 } catch (InvalidRequestException &ire) {
10034 result.ire = ire;
10035 result.__isset.ire = true;
10036 } catch (UnavailableException &ue) {
10037 result.ue = ue;
10038 result.__isset.ue = true;
10039 } catch (TimedOutException &te) {
10040 result.te = te;
10041 result.__isset.te = true;
10042 } catch (const std::exception& e) {
10043 if (eventHandler_.get() != NULL) {
10044 eventHandler_->handlerError(ctx, "Cassandra.batch_mutate");
10045 }
10046
10047 ::apache::thrift::TApplicationException x(e.what());
10048 oprot->writeMessageBegin("batch_mutate", ::apache::thrift::protocol::T_EXCEPTION, seqid);
10049 x.write(oprot);
10050 oprot->writeMessageEnd();
10051 oprot->getTransport()->writeEnd();
10052 oprot->getTransport()->flush();
10053 return;
10054 }
10055
10056 if (eventHandler_.get() != NULL) {
10057 eventHandler_->preWrite(ctx, "Cassandra.batch_mutate");
10058 }
10059
10060 oprot->writeMessageBegin("batch_mutate", ::apache::thrift::protocol::T_REPLY, seqid);
10061 result.write(oprot);
10062 oprot->writeMessageEnd();
10063 bytes = oprot->getTransport()->writeEnd();
10064 oprot->getTransport()->flush();
10065
10066 if (eventHandler_.get() != NULL) {
10067 eventHandler_->postWrite(ctx, "Cassandra.batch_mutate", bytes);
10068 }
10069 }
10070
10071 void CassandraProcessor::process_truncate(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
10072 {
10073 void* ctx = NULL;
10074 if (eventHandler_.get() != NULL) {
10075 ctx = eventHandler_->getContext("Cassandra.truncate", callContext);
10076 }
10077 ::apache::thrift::TProcessorContextFreer freer(eventHandler_.get(), ctx, "Cassandra.truncate");
10078
10079 if (eventHandler_.get() != NULL) {
10080 eventHandler_->preRead(ctx, "Cassandra.truncate");
10081 }
10082
10083 Cassandra_truncate_args args;
10084 args.read(iprot);
10085 iprot->readMessageEnd();
10086 uint32_t bytes = iprot->getTransport()->readEnd();
10087
10088 if (eventHandler_.get() != NULL) {
10089 eventHandler_->postRead(ctx, "Cassandra.truncate", bytes);
10090 }
10091
10092 Cassandra_truncate_result result;
10093 try {
10094 iface_->truncate(args.cfname);
10095 } catch (InvalidRequestException &ire) {
10096 result.ire = ire;
10097 result.__isset.ire = true;
10098 } catch (UnavailableException &ue) {
10099 result.ue = ue;
10100 result.__isset.ue = true;
10101 } catch (const std::exception& e) {
10102 if (eventHandler_.get() != NULL) {
10103 eventHandler_->handlerError(ctx, "Cassandra.truncate");
10104 }
10105
10106 ::apache::thrift::TApplicationException x(e.what());
10107 oprot->writeMessageBegin("truncate", ::apache::thrift::protocol::T_EXCEPTION, seqid);
10108 x.write(oprot);
10109 oprot->writeMessageEnd();
10110 oprot->getTransport()->writeEnd();
10111 oprot->getTransport()->flush();
10112 return;
10113 }
10114
10115 if (eventHandler_.get() != NULL) {
10116 eventHandler_->preWrite(ctx, "Cassandra.truncate");
10117 }
10118
10119 oprot->writeMessageBegin("truncate", ::apache::thrift::protocol::T_REPLY, seqid);
10120 result.write(oprot);
10121 oprot->writeMessageEnd();
10122 bytes = oprot->getTransport()->writeEnd();
10123 oprot->getTransport()->flush();
10124
10125 if (eventHandler_.get() != NULL) {
10126 eventHandler_->postWrite(ctx, "Cassandra.truncate", bytes);
10127 }
10128 }
10129
10130 void CassandraProcessor::process_describe_schema_versions(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
10131 {
10132 void* ctx = NULL;
10133 if (eventHandler_.get() != NULL) {
10134 ctx = eventHandler_->getContext("Cassandra.describe_schema_versions", callContext);
10135 }
10136 ::apache::thrift::TProcessorContextFreer freer(eventHandler_.get(), ctx, "Cassandra.describe_schema_versions");
10137
10138 if (eventHandler_.get() != NULL) {
10139 eventHandler_->preRead(ctx, "Cassandra.describe_schema_versions");
10140 }
10141
10142 Cassandra_describe_schema_versions_args args;
10143 args.read(iprot);
10144 iprot->readMessageEnd();
10145 uint32_t bytes = iprot->getTransport()->readEnd();
10146
10147 if (eventHandler_.get() != NULL) {
10148 eventHandler_->postRead(ctx, "Cassandra.describe_schema_versions", bytes);
10149 }
10150
10151 Cassandra_describe_schema_versions_result result;
10152 try {
10153 iface_->describe_schema_versions(result.success);
10154 result.__isset.success = true;
10155 } catch (InvalidRequestException &ire) {
10156 result.ire = ire;
10157 result.__isset.ire = true;
10158 } catch (const std::exception& e) {
10159 if (eventHandler_.get() != NULL) {
10160 eventHandler_->handlerError(ctx, "Cassandra.describe_schema_versions");
10161 }
10162
10163 ::apache::thrift::TApplicationException x(e.what());
10164 oprot->writeMessageBegin("describe_schema_versions", ::apache::thrift::protocol::T_EXCEPTION, seqid);
10165 x.write(oprot);
10166 oprot->writeMessageEnd();
10167 oprot->getTransport()->writeEnd();
10168 oprot->getTransport()->flush();
10169 return;
10170 }
10171
10172 if (eventHandler_.get() != NULL) {
10173 eventHandler_->preWrite(ctx, "Cassandra.describe_schema_versions");
10174 }
10175
10176 oprot->writeMessageBegin("describe_schema_versions", ::apache::thrift::protocol::T_REPLY, seqid);
10177 result.write(oprot);
10178 oprot->writeMessageEnd();
10179 bytes = oprot->getTransport()->writeEnd();
10180 oprot->getTransport()->flush();
10181
10182 if (eventHandler_.get() != NULL) {
10183 eventHandler_->postWrite(ctx, "Cassandra.describe_schema_versions", bytes);
10184 }
10185 }
10186
10187 void CassandraProcessor::process_describe_keyspaces(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
10188 {
10189 void* ctx = NULL;
10190 if (eventHandler_.get() != NULL) {
10191 ctx = eventHandler_->getContext("Cassandra.describe_keyspaces", callContext);
10192 }
10193 ::apache::thrift::TProcessorContextFreer freer(eventHandler_.get(), ctx, "Cassandra.describe_keyspaces");
10194
10195 if (eventHandler_.get() != NULL) {
10196 eventHandler_->preRead(ctx, "Cassandra.describe_keyspaces");
10197 }
10198
10199 Cassandra_describe_keyspaces_args args;
10200 args.read(iprot);
10201 iprot->readMessageEnd();
10202 uint32_t bytes = iprot->getTransport()->readEnd();
10203
10204 if (eventHandler_.get() != NULL) {
10205 eventHandler_->postRead(ctx, "Cassandra.describe_keyspaces", bytes);
10206 }
10207
10208 Cassandra_describe_keyspaces_result result;
10209 try {
10210 iface_->describe_keyspaces(result.success);
10211 result.__isset.success = true;
10212 } catch (InvalidRequestException &ire) {
10213 result.ire = ire;
10214 result.__isset.ire = true;
10215 } catch (const std::exception& e) {
10216 if (eventHandler_.get() != NULL) {
10217 eventHandler_->handlerError(ctx, "Cassandra.describe_keyspaces");
10218 }
10219
10220 ::apache::thrift::TApplicationException x(e.what());
10221 oprot->writeMessageBegin("describe_keyspaces", ::apache::thrift::protocol::T_EXCEPTION, seqid);
10222 x.write(oprot);
10223 oprot->writeMessageEnd();
10224 oprot->getTransport()->writeEnd();
10225 oprot->getTransport()->flush();
10226 return;
10227 }
10228
10229 if (eventHandler_.get() != NULL) {
10230 eventHandler_->preWrite(ctx, "Cassandra.describe_keyspaces");
10231 }
10232
10233 oprot->writeMessageBegin("describe_keyspaces", ::apache::thrift::protocol::T_REPLY, seqid);
10234 result.write(oprot);
10235 oprot->writeMessageEnd();
10236 bytes = oprot->getTransport()->writeEnd();
10237 oprot->getTransport()->flush();
10238
10239 if (eventHandler_.get() != NULL) {
10240 eventHandler_->postWrite(ctx, "Cassandra.describe_keyspaces", bytes);
10241 }
10242 }
10243
10244 void CassandraProcessor::process_describe_cluster_name(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
10245 {
10246 void* ctx = NULL;
10247 if (eventHandler_.get() != NULL) {
10248 ctx = eventHandler_->getContext("Cassandra.describe_cluster_name", callContext);
10249 }
10250 ::apache::thrift::TProcessorContextFreer freer(eventHandler_.get(), ctx, "Cassandra.describe_cluster_name");
10251
10252 if (eventHandler_.get() != NULL) {
10253 eventHandler_->preRead(ctx, "Cassandra.describe_cluster_name");
10254 }
10255
10256 Cassandra_describe_cluster_name_args args;
10257 args.read(iprot);
10258 iprot->readMessageEnd();
10259 uint32_t bytes = iprot->getTransport()->readEnd();
10260
10261 if (eventHandler_.get() != NULL) {
10262 eventHandler_->postRead(ctx, "Cassandra.describe_cluster_name", bytes);
10263 }
10264
10265 Cassandra_describe_cluster_name_result result;
10266 try {
10267 iface_->describe_cluster_name(result.success);
10268 result.__isset.success = true;
10269 } catch (const std::exception& e) {
10270 if (eventHandler_.get() != NULL) {
10271 eventHandler_->handlerError(ctx, "Cassandra.describe_cluster_name");
10272 }
10273
10274 ::apache::thrift::TApplicationException x(e.what());
10275 oprot->writeMessageBegin("describe_cluster_name", ::apache::thrift::protocol::T_EXCEPTION, seqid);
10276 x.write(oprot);
10277 oprot->writeMessageEnd();
10278 oprot->getTransport()->writeEnd();
10279 oprot->getTransport()->flush();
10280 return;
10281 }
10282
10283 if (eventHandler_.get() != NULL) {
10284 eventHandler_->preWrite(ctx, "Cassandra.describe_cluster_name");
10285 }
10286
10287 oprot->writeMessageBegin("describe_cluster_name", ::apache::thrift::protocol::T_REPLY, seqid);
10288 result.write(oprot);
10289 oprot->writeMessageEnd();
10290 bytes = oprot->getTransport()->writeEnd();
10291 oprot->getTransport()->flush();
10292
10293 if (eventHandler_.get() != NULL) {
10294 eventHandler_->postWrite(ctx, "Cassandra.describe_cluster_name", bytes);
10295 }
10296 }
10297
10298 void CassandraProcessor::process_describe_version(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
10299 {
10300 void* ctx = NULL;
10301 if (eventHandler_.get() != NULL) {
10302 ctx = eventHandler_->getContext("Cassandra.describe_version", callContext);
10303 }
10304 ::apache::thrift::TProcessorContextFreer freer(eventHandler_.get(), ctx, "Cassandra.describe_version");
10305
10306 if (eventHandler_.get() != NULL) {
10307 eventHandler_->preRead(ctx, "Cassandra.describe_version");
10308 }
10309
10310 Cassandra_describe_version_args args;
10311 args.read(iprot);
10312 iprot->readMessageEnd();
10313 uint32_t bytes = iprot->getTransport()->readEnd();
10314
10315 if (eventHandler_.get() != NULL) {
10316 eventHandler_->postRead(ctx, "Cassandra.describe_version", bytes);
10317 }
10318
10319 Cassandra_describe_version_result result;
10320 try {
10321 iface_->describe_version(result.success);
10322 result.__isset.success = true;
10323 } catch (const std::exception& e) {
10324 if (eventHandler_.get() != NULL) {
10325 eventHandler_->handlerError(ctx, "Cassandra.describe_version");
10326 }
10327
10328 ::apache::thrift::TApplicationException x(e.what());
10329 oprot->writeMessageBegin("describe_version", ::apache::thrift::protocol::T_EXCEPTION, seqid);
10330 x.write(oprot);
10331 oprot->writeMessageEnd();
10332 oprot->getTransport()->writeEnd();
10333 oprot->getTransport()->flush();
10334 return;
10335 }
10336
10337 if (eventHandler_.get() != NULL) {
10338 eventHandler_->preWrite(ctx, "Cassandra.describe_version");
10339 }
10340
10341 oprot->writeMessageBegin("describe_version", ::apache::thrift::protocol::T_REPLY, seqid);
10342 result.write(oprot);
10343 oprot->writeMessageEnd();
10344 bytes = oprot->getTransport()->writeEnd();
10345 oprot->getTransport()->flush();
10346
10347 if (eventHandler_.get() != NULL) {
10348 eventHandler_->postWrite(ctx, "Cassandra.describe_version", bytes);
10349 }
10350 }
10351
10352 void CassandraProcessor::process_describe_ring(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
10353 {
10354 void* ctx = NULL;
10355 if (eventHandler_.get() != NULL) {
10356 ctx = eventHandler_->getContext("Cassandra.describe_ring", callContext);
10357 }
10358 ::apache::thrift::TProcessorContextFreer freer(eventHandler_.get(), ctx, "Cassandra.describe_ring");
10359
10360 if (eventHandler_.get() != NULL) {
10361 eventHandler_->preRead(ctx, "Cassandra.describe_ring");
10362 }
10363
10364 Cassandra_describe_ring_args args;
10365 args.read(iprot);
10366 iprot->readMessageEnd();
10367 uint32_t bytes = iprot->getTransport()->readEnd();
10368
10369 if (eventHandler_.get() != NULL) {
10370 eventHandler_->postRead(ctx, "Cassandra.describe_ring", bytes);
10371 }
10372
10373 Cassandra_describe_ring_result result;
10374 try {
10375 iface_->describe_ring(result.success, args.keyspace);
10376 result.__isset.success = true;
10377 } catch (InvalidRequestException &ire) {
10378 result.ire = ire;
10379 result.__isset.ire = true;
10380 } catch (const std::exception& e) {
10381 if (eventHandler_.get() != NULL) {
10382 eventHandler_->handlerError(ctx, "Cassandra.describe_ring");
10383 }
10384
10385 ::apache::thrift::TApplicationException x(e.what());
10386 oprot->writeMessageBegin("describe_ring", ::apache::thrift::protocol::T_EXCEPTION, seqid);
10387 x.write(oprot);
10388 oprot->writeMessageEnd();
10389 oprot->getTransport()->writeEnd();
10390 oprot->getTransport()->flush();
10391 return;
10392 }
10393
10394 if (eventHandler_.get() != NULL) {
10395 eventHandler_->preWrite(ctx, "Cassandra.describe_ring");
10396 }
10397
10398 oprot->writeMessageBegin("describe_ring", ::apache::thrift::protocol::T_REPLY, seqid);
10399 result.write(oprot);
10400 oprot->writeMessageEnd();
10401 bytes = oprot->getTransport()->writeEnd();
10402 oprot->getTransport()->flush();
10403
10404 if (eventHandler_.get() != NULL) {
10405 eventHandler_->postWrite(ctx, "Cassandra.describe_ring", bytes);
10406 }
10407 }
10408
10409 void CassandraProcessor::process_describe_partitioner(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
10410 {
10411 void* ctx = NULL;
10412 if (eventHandler_.get() != NULL) {
10413 ctx = eventHandler_->getContext("Cassandra.describe_partitioner", callContext);
10414 }
10415 ::apache::thrift::TProcessorContextFreer freer(eventHandler_.get(), ctx, "Cassandra.describe_partitioner");
10416
10417 if (eventHandler_.get() != NULL) {
10418 eventHandler_->preRead(ctx, "Cassandra.describe_partitioner");
10419 }
10420
10421 Cassandra_describe_partitioner_args args;
10422 args.read(iprot);
10423 iprot->readMessageEnd();
10424 uint32_t bytes = iprot->getTransport()->readEnd();
10425
10426 if (eventHandler_.get() != NULL) {
10427 eventHandler_->postRead(ctx, "Cassandra.describe_partitioner", bytes);
10428 }
10429
10430 Cassandra_describe_partitioner_result result;
10431 try {
10432 iface_->describe_partitioner(result.success);
10433 result.__isset.success = true;
10434 } catch (const std::exception& e) {
10435 if (eventHandler_.get() != NULL) {
10436 eventHandler_->handlerError(ctx, "Cassandra.describe_partitioner");
10437 }
10438
10439 ::apache::thrift::TApplicationException x(e.what());
10440 oprot->writeMessageBegin("describe_partitioner", ::apache::thrift::protocol::T_EXCEPTION, seqid);
10441 x.write(oprot);
10442 oprot->writeMessageEnd();
10443 oprot->getTransport()->writeEnd();
10444 oprot->getTransport()->flush();
10445 return;
10446 }
10447
10448 if (eventHandler_.get() != NULL) {
10449 eventHandler_->preWrite(ctx, "Cassandra.describe_partitioner");
10450 }
10451
10452 oprot->writeMessageBegin("describe_partitioner", ::apache::thrift::protocol::T_REPLY, seqid);
10453 result.write(oprot);
10454 oprot->writeMessageEnd();
10455 bytes = oprot->getTransport()->writeEnd();
10456 oprot->getTransport()->flush();
10457
10458 if (eventHandler_.get() != NULL) {
10459 eventHandler_->postWrite(ctx, "Cassandra.describe_partitioner", bytes);
10460 }
10461 }
10462
10463 void CassandraProcessor::process_describe_snitch(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
10464 {
10465 void* ctx = NULL;
10466 if (eventHandler_.get() != NULL) {
10467 ctx = eventHandler_->getContext("Cassandra.describe_snitch", callContext);
10468 }
10469 ::apache::thrift::TProcessorContextFreer freer(eventHandler_.get(), ctx, "Cassandra.describe_snitch");
10470
10471 if (eventHandler_.get() != NULL) {
10472 eventHandler_->preRead(ctx, "Cassandra.describe_snitch");
10473 }
10474
10475 Cassandra_describe_snitch_args args;
10476 args.read(iprot);
10477 iprot->readMessageEnd();
10478 uint32_t bytes = iprot->getTransport()->readEnd();
10479
10480 if (eventHandler_.get() != NULL) {
10481 eventHandler_->postRead(ctx, "Cassandra.describe_snitch", bytes);
10482 }
10483
10484 Cassandra_describe_snitch_result result;
10485 try {
10486 iface_->describe_snitch(result.success);
10487 result.__isset.success = true;
10488 } catch (const std::exception& e) {
10489 if (eventHandler_.get() != NULL) {
10490 eventHandler_->handlerError(ctx, "Cassandra.describe_snitch");
10491 }
10492
10493 ::apache::thrift::TApplicationException x(e.what());
10494 oprot->writeMessageBegin("describe_snitch", ::apache::thrift::protocol::T_EXCEPTION, seqid);
10495 x.write(oprot);
10496 oprot->writeMessageEnd();
10497 oprot->getTransport()->writeEnd();
10498 oprot->getTransport()->flush();
10499 return;
10500 }
10501
10502 if (eventHandler_.get() != NULL) {
10503 eventHandler_->preWrite(ctx, "Cassandra.describe_snitch");
10504 }
10505
10506 oprot->writeMessageBegin("describe_snitch", ::apache::thrift::protocol::T_REPLY, seqid);
10507 result.write(oprot);
10508 oprot->writeMessageEnd();
10509 bytes = oprot->getTransport()->writeEnd();
10510 oprot->getTransport()->flush();
10511
10512 if (eventHandler_.get() != NULL) {
10513 eventHandler_->postWrite(ctx, "Cassandra.describe_snitch", bytes);
10514 }
10515 }
10516
10517 void CassandraProcessor::process_describe_keyspace(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
10518 {
10519 void* ctx = NULL;
10520 if (eventHandler_.get() != NULL) {
10521 ctx = eventHandler_->getContext("Cassandra.describe_keyspace", callContext);
10522 }
10523 ::apache::thrift::TProcessorContextFreer freer(eventHandler_.get(), ctx, "Cassandra.describe_keyspace");
10524
10525 if (eventHandler_.get() != NULL) {
10526 eventHandler_->preRead(ctx, "Cassandra.describe_keyspace");
10527 }
10528
10529 Cassandra_describe_keyspace_args args;
10530 args.read(iprot);
10531 iprot->readMessageEnd();
10532 uint32_t bytes = iprot->getTransport()->readEnd();
10533
10534 if (eventHandler_.get() != NULL) {
10535 eventHandler_->postRead(ctx, "Cassandra.describe_keyspace", bytes);
10536 }
10537
10538 Cassandra_describe_keyspace_result result;
10539 try {
10540 iface_->describe_keyspace(result.success, args.keyspace);
10541 result.__isset.success = true;
10542 } catch (NotFoundException &nfe) {
10543 result.nfe = nfe;
10544 result.__isset.nfe = true;
10545 } catch (InvalidRequestException &ire) {
10546 result.ire = ire;
10547 result.__isset.ire = true;
10548 } catch (const std::exception& e) {
10549 if (eventHandler_.get() != NULL) {
10550 eventHandler_->handlerError(ctx, "Cassandra.describe_keyspace");
10551 }
10552
10553 ::apache::thrift::TApplicationException x(e.what());
10554 oprot->writeMessageBegin("describe_keyspace", ::apache::thrift::protocol::T_EXCEPTION, seqid);
10555 x.write(oprot);
10556 oprot->writeMessageEnd();
10557 oprot->getTransport()->writeEnd();
10558 oprot->getTransport()->flush();
10559 return;
10560 }
10561
10562 if (eventHandler_.get() != NULL) {
10563 eventHandler_->preWrite(ctx, "Cassandra.describe_keyspace");
10564 }
10565
10566 oprot->writeMessageBegin("describe_keyspace", ::apache::thrift::protocol::T_REPLY, seqid);
10567 result.write(oprot);
10568 oprot->writeMessageEnd();
10569 bytes = oprot->getTransport()->writeEnd();
10570 oprot->getTransport()->flush();
10571
10572 if (eventHandler_.get() != NULL) {
10573 eventHandler_->postWrite(ctx, "Cassandra.describe_keyspace", bytes);
10574 }
10575 }
10576
10577 void CassandraProcessor::process_describe_splits(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
10578 {
10579 void* ctx = NULL;
10580 if (eventHandler_.get() != NULL) {
10581 ctx = eventHandler_->getContext("Cassandra.describe_splits", callContext);
10582 }
10583 ::apache::thrift::TProcessorContextFreer freer(eventHandler_.get(), ctx, "Cassandra.describe_splits");
10584
10585 if (eventHandler_.get() != NULL) {
10586 eventHandler_->preRead(ctx, "Cassandra.describe_splits");
10587 }
10588
10589 Cassandra_describe_splits_args args;
10590 args.read(iprot);
10591 iprot->readMessageEnd();
10592 uint32_t bytes = iprot->getTransport()->readEnd();
10593
10594 if (eventHandler_.get() != NULL) {
10595 eventHandler_->postRead(ctx, "Cassandra.describe_splits", bytes);
10596 }
10597
10598 Cassandra_describe_splits_result result;
10599 try {
10600 iface_->describe_splits(result.success, args.cfName, args.start_token, args.end_token, args.keys_per_split);
10601 result.__isset.success = true;
10602 } catch (InvalidRequestException &ire) {
10603 result.ire = ire;
10604 result.__isset.ire = true;
10605 } catch (const std::exception& e) {
10606 if (eventHandler_.get() != NULL) {
10607 eventHandler_->handlerError(ctx, "Cassandra.describe_splits");
10608 }
10609
10610 ::apache::thrift::TApplicationException x(e.what());
10611 oprot->writeMessageBegin("describe_splits", ::apache::thrift::protocol::T_EXCEPTION, seqid);
10612 x.write(oprot);
10613 oprot->writeMessageEnd();
10614 oprot->getTransport()->writeEnd();
10615 oprot->getTransport()->flush();
10616 return;
10617 }
10618
10619 if (eventHandler_.get() != NULL) {
10620 eventHandler_->preWrite(ctx, "Cassandra.describe_splits");
10621 }
10622
10623 oprot->writeMessageBegin("describe_splits", ::apache::thrift::protocol::T_REPLY, seqid);
10624 result.write(oprot);
10625 oprot->writeMessageEnd();
10626 bytes = oprot->getTransport()->writeEnd();
10627 oprot->getTransport()->flush();
10628
10629 if (eventHandler_.get() != NULL) {
10630 eventHandler_->postWrite(ctx, "Cassandra.describe_splits", bytes);
10631 }
10632 }
10633
10634 void CassandraProcessor::process_system_add_column_family(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
10635 {
10636 void* ctx = NULL;
10637 if (eventHandler_.get() != NULL) {
10638 ctx = eventHandler_->getContext("Cassandra.system_add_column_family", callContext);
10639 }
10640 ::apache::thrift::TProcessorContextFreer freer(eventHandler_.get(), ctx, "Cassandra.system_add_column_family");
10641
10642 if (eventHandler_.get() != NULL) {
10643 eventHandler_->preRead(ctx, "Cassandra.system_add_column_family");
10644 }
10645
10646 Cassandra_system_add_column_family_args args;
10647 args.read(iprot);
10648 iprot->readMessageEnd();
10649 uint32_t bytes = iprot->getTransport()->readEnd();
10650
10651 if (eventHandler_.get() != NULL) {
10652 eventHandler_->postRead(ctx, "Cassandra.system_add_column_family", bytes);
10653 }
10654
10655 Cassandra_system_add_column_family_result result;
10656 try {
10657 iface_->system_add_column_family(result.success, args.cf_def);
10658 result.__isset.success = true;
10659 } catch (InvalidRequestException &ire) {
10660 result.ire = ire;
10661 result.__isset.ire = true;
10662 } catch (SchemaDisagreementException &sde) {
10663 result.sde = sde;
10664 result.__isset.sde = true;
10665 } catch (const std::exception& e) {
10666 if (eventHandler_.get() != NULL) {
10667 eventHandler_->handlerError(ctx, "Cassandra.system_add_column_family");
10668 }
10669
10670 ::apache::thrift::TApplicationException x(e.what());
10671 oprot->writeMessageBegin("system_add_column_family", ::apache::thrift::protocol::T_EXCEPTION, seqid);
10672 x.write(oprot);
10673 oprot->writeMessageEnd();
10674 oprot->getTransport()->writeEnd();
10675 oprot->getTransport()->flush();
10676 return;
10677 }
10678
10679 if (eventHandler_.get() != NULL) {
10680 eventHandler_->preWrite(ctx, "Cassandra.system_add_column_family");
10681 }
10682
10683 oprot->writeMessageBegin("system_add_column_family", ::apache::thrift::protocol::T_REPLY, seqid);
10684 result.write(oprot);
10685 oprot->writeMessageEnd();
10686 bytes = oprot->getTransport()->writeEnd();
10687 oprot->getTransport()->flush();
10688
10689 if (eventHandler_.get() != NULL) {
10690 eventHandler_->postWrite(ctx, "Cassandra.system_add_column_family", bytes);
10691 }
10692 }
10693
10694 void CassandraProcessor::process_system_drop_column_family(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
10695 {
10696 void* ctx = NULL;
10697 if (eventHandler_.get() != NULL) {
10698 ctx = eventHandler_->getContext("Cassandra.system_drop_column_family", callContext);
10699 }
10700 ::apache::thrift::TProcessorContextFreer freer(eventHandler_.get(), ctx, "Cassandra.system_drop_column_family");
10701
10702 if (eventHandler_.get() != NULL) {
10703 eventHandler_->preRead(ctx, "Cassandra.system_drop_column_family");
10704 }
10705
10706 Cassandra_system_drop_column_family_args args;
10707 args.read(iprot);
10708 iprot->readMessageEnd();
10709 uint32_t bytes = iprot->getTransport()->readEnd();
10710
10711 if (eventHandler_.get() != NULL) {
10712 eventHandler_->postRead(ctx, "Cassandra.system_drop_column_family", bytes);
10713 }
10714
10715 Cassandra_system_drop_column_family_result result;
10716 try {
10717 iface_->system_drop_column_family(result.success, args.column_family);
10718 result.__isset.success = true;
10719 } catch (InvalidRequestException &ire) {
10720 result.ire = ire;
10721 result.__isset.ire = true;
10722 } catch (SchemaDisagreementException &sde) {
10723 result.sde = sde;
10724 result.__isset.sde = true;
10725 } catch (const std::exception& e) {
10726 if (eventHandler_.get() != NULL) {
10727 eventHandler_->handlerError(ctx, "Cassandra.system_drop_column_family");
10728 }
10729
10730 ::apache::thrift::TApplicationException x(e.what());
10731 oprot->writeMessageBegin("system_drop_column_family", ::apache::thrift::protocol::T_EXCEPTION, seqid);
10732 x.write(oprot);
10733 oprot->writeMessageEnd();
10734 oprot->getTransport()->writeEnd();
10735 oprot->getTransport()->flush();
10736 return;
10737 }
10738
10739 if (eventHandler_.get() != NULL) {
10740 eventHandler_->preWrite(ctx, "Cassandra.system_drop_column_family");
10741 }
10742
10743 oprot->writeMessageBegin("system_drop_column_family", ::apache::thrift::protocol::T_REPLY, seqid);
10744 result.write(oprot);
10745 oprot->writeMessageEnd();
10746 bytes = oprot->getTransport()->writeEnd();
10747 oprot->getTransport()->flush();
10748
10749 if (eventHandler_.get() != NULL) {
10750 eventHandler_->postWrite(ctx, "Cassandra.system_drop_column_family", bytes);
10751 }
10752 }
10753
10754 void CassandraProcessor::process_system_add_keyspace(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
10755 {
10756 void* ctx = NULL;
10757 if (eventHandler_.get() != NULL) {
10758 ctx = eventHandler_->getContext("Cassandra.system_add_keyspace", callContext);
10759 }
10760 ::apache::thrift::TProcessorContextFreer freer(eventHandler_.get(), ctx, "Cassandra.system_add_keyspace");
10761
10762 if (eventHandler_.get() != NULL) {
10763 eventHandler_->preRead(ctx, "Cassandra.system_add_keyspace");
10764 }
10765
10766 Cassandra_system_add_keyspace_args args;
10767 args.read(iprot);
10768 iprot->readMessageEnd();
10769 uint32_t bytes = iprot->getTransport()->readEnd();
10770
10771 if (eventHandler_.get() != NULL) {
10772 eventHandler_->postRead(ctx, "Cassandra.system_add_keyspace", bytes);
10773 }
10774
10775 Cassandra_system_add_keyspace_result result;
10776 try {
10777 iface_->system_add_keyspace(result.success, args.ks_def);
10778 result.__isset.success = true;
10779 } catch (InvalidRequestException &ire) {
10780 result.ire = ire;
10781 result.__isset.ire = true;
10782 } catch (SchemaDisagreementException &sde) {
10783 result.sde = sde;
10784 result.__isset.sde = true;
10785 } catch (const std::exception& e) {
10786 if (eventHandler_.get() != NULL) {
10787 eventHandler_->handlerError(ctx, "Cassandra.system_add_keyspace");
10788 }
10789
10790 ::apache::thrift::TApplicationException x(e.what());
10791 oprot->writeMessageBegin("system_add_keyspace", ::apache::thrift::protocol::T_EXCEPTION, seqid);
10792 x.write(oprot);
10793 oprot->writeMessageEnd();
10794 oprot->getTransport()->writeEnd();
10795 oprot->getTransport()->flush();
10796 return;
10797 }
10798
10799 if (eventHandler_.get() != NULL) {
10800 eventHandler_->preWrite(ctx, "Cassandra.system_add_keyspace");
10801 }
10802
10803 oprot->writeMessageBegin("system_add_keyspace", ::apache::thrift::protocol::T_REPLY, seqid);
10804 result.write(oprot);
10805 oprot->writeMessageEnd();
10806 bytes = oprot->getTransport()->writeEnd();
10807 oprot->getTransport()->flush();
10808
10809 if (eventHandler_.get() != NULL) {
10810 eventHandler_->postWrite(ctx, "Cassandra.system_add_keyspace", bytes);
10811 }
10812 }
10813
10814 void CassandraProcessor::process_system_drop_keyspace(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
10815 {
10816 void* ctx = NULL;
10817 if (eventHandler_.get() != NULL) {
10818 ctx = eventHandler_->getContext("Cassandra.system_drop_keyspace", callContext);
10819 }
10820 ::apache::thrift::TProcessorContextFreer freer(eventHandler_.get(), ctx, "Cassandra.system_drop_keyspace");
10821
10822 if (eventHandler_.get() != NULL) {
10823 eventHandler_->preRead(ctx, "Cassandra.system_drop_keyspace");
10824 }
10825
10826 Cassandra_system_drop_keyspace_args args;
10827 args.read(iprot);
10828 iprot->readMessageEnd();
10829 uint32_t bytes = iprot->getTransport()->readEnd();
10830
10831 if (eventHandler_.get() != NULL) {
10832 eventHandler_->postRead(ctx, "Cassandra.system_drop_keyspace", bytes);
10833 }
10834
10835 Cassandra_system_drop_keyspace_result result;
10836 try {
10837 iface_->system_drop_keyspace(result.success, args.keyspace);
10838 result.__isset.success = true;
10839 } catch (InvalidRequestException &ire) {
10840 result.ire = ire;
10841 result.__isset.ire = true;
10842 } catch (SchemaDisagreementException &sde) {
10843 result.sde = sde;
10844 result.__isset.sde = true;
10845 } catch (const std::exception& e) {
10846 if (eventHandler_.get() != NULL) {
10847 eventHandler_->handlerError(ctx, "Cassandra.system_drop_keyspace");
10848 }
10849
10850 ::apache::thrift::TApplicationException x(e.what());
10851 oprot->writeMessageBegin("system_drop_keyspace", ::apache::thrift::protocol::T_EXCEPTION, seqid);
10852 x.write(oprot);
10853 oprot->writeMessageEnd();
10854 oprot->getTransport()->writeEnd();
10855 oprot->getTransport()->flush();
10856 return;
10857 }
10858
10859 if (eventHandler_.get() != NULL) {
10860 eventHandler_->preWrite(ctx, "Cassandra.system_drop_keyspace");
10861 }
10862
10863 oprot->writeMessageBegin("system_drop_keyspace", ::apache::thrift::protocol::T_REPLY, seqid);
10864 result.write(oprot);
10865 oprot->writeMessageEnd();
10866 bytes = oprot->getTransport()->writeEnd();
10867 oprot->getTransport()->flush();
10868
10869 if (eventHandler_.get() != NULL) {
10870 eventHandler_->postWrite(ctx, "Cassandra.system_drop_keyspace", bytes);
10871 }
10872 }
10873
10874 void CassandraProcessor::process_system_update_keyspace(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
10875 {
10876 void* ctx = NULL;
10877 if (eventHandler_.get() != NULL) {
10878 ctx = eventHandler_->getContext("Cassandra.system_update_keyspace", callContext);
10879 }
10880 ::apache::thrift::TProcessorContextFreer freer(eventHandler_.get(), ctx, "Cassandra.system_update_keyspace");
10881
10882 if (eventHandler_.get() != NULL) {
10883 eventHandler_->preRead(ctx, "Cassandra.system_update_keyspace");
10884 }
10885
10886 Cassandra_system_update_keyspace_args args;
10887 args.read(iprot);
10888 iprot->readMessageEnd();
10889 uint32_t bytes = iprot->getTransport()->readEnd();
10890
10891 if (eventHandler_.get() != NULL) {
10892 eventHandler_->postRead(ctx, "Cassandra.system_update_keyspace", bytes);
10893 }
10894
10895 Cassandra_system_update_keyspace_result result;
10896 try {
10897 iface_->system_update_keyspace(result.success, args.ks_def);
10898 result.__isset.success = true;
10899 } catch (InvalidRequestException &ire) {
10900 result.ire = ire;
10901 result.__isset.ire = true;
10902 } catch (SchemaDisagreementException &sde) {
10903 result.sde = sde;
10904 result.__isset.sde = true;
10905 } catch (const std::exception& e) {
10906 if (eventHandler_.get() != NULL) {
10907 eventHandler_->handlerError(ctx, "Cassandra.system_update_keyspace");
10908 }
10909
10910 ::apache::thrift::TApplicationException x(e.what());
10911 oprot->writeMessageBegin("system_update_keyspace", ::apache::thrift::protocol::T_EXCEPTION, seqid);
10912 x.write(oprot);
10913 oprot->writeMessageEnd();
10914 oprot->getTransport()->writeEnd();
10915 oprot->getTransport()->flush();
10916 return;
10917 }
10918
10919 if (eventHandler_.get() != NULL) {
10920 eventHandler_->preWrite(ctx, "Cassandra.system_update_keyspace");
10921 }
10922
10923 oprot->writeMessageBegin("system_update_keyspace", ::apache::thrift::protocol::T_REPLY, seqid);
10924 result.write(oprot);
10925 oprot->writeMessageEnd();
10926 bytes = oprot->getTransport()->writeEnd();
10927 oprot->getTransport()->flush();
10928
10929 if (eventHandler_.get() != NULL) {
10930 eventHandler_->postWrite(ctx, "Cassandra.system_update_keyspace", bytes);
10931 }
10932 }
10933
10934 void CassandraProcessor::process_system_update_column_family(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
10935 {
10936 void* ctx = NULL;
10937 if (eventHandler_.get() != NULL) {
10938 ctx = eventHandler_->getContext("Cassandra.system_update_column_family", callContext);
10939 }
10940 ::apache::thrift::TProcessorContextFreer freer(eventHandler_.get(), ctx, "Cassandra.system_update_column_family");
10941
10942 if (eventHandler_.get() != NULL) {
10943 eventHandler_->preRead(ctx, "Cassandra.system_update_column_family");
10944 }
10945
10946 Cassandra_system_update_column_family_args args;
10947 args.read(iprot);
10948 iprot->readMessageEnd();
10949 uint32_t bytes = iprot->getTransport()->readEnd();
10950
10951 if (eventHandler_.get() != NULL) {
10952 eventHandler_->postRead(ctx, "Cassandra.system_update_column_family", bytes);
10953 }
10954
10955 Cassandra_system_update_column_family_result result;
10956 try {
10957 iface_->system_update_column_family(result.success, args.cf_def);
10958 result.__isset.success = true;
10959 } catch (InvalidRequestException &ire) {
10960 result.ire = ire;
10961 result.__isset.ire = true;
10962 } catch (SchemaDisagreementException &sde) {
10963 result.sde = sde;
10964 result.__isset.sde = true;
10965 } catch (const std::exception& e) {
10966 if (eventHandler_.get() != NULL) {
10967 eventHandler_->handlerError(ctx, "Cassandra.system_update_column_family");
10968 }
10969
10970 ::apache::thrift::TApplicationException x(e.what());
10971 oprot->writeMessageBegin("system_update_column_family", ::apache::thrift::protocol::T_EXCEPTION, seqid);
10972 x.write(oprot);
10973 oprot->writeMessageEnd();
10974 oprot->getTransport()->writeEnd();
10975 oprot->getTransport()->flush();
10976 return;
10977 }
10978
10979 if (eventHandler_.get() != NULL) {
10980 eventHandler_->preWrite(ctx, "Cassandra.system_update_column_family");
10981 }
10982
10983 oprot->writeMessageBegin("system_update_column_family", ::apache::thrift::protocol::T_REPLY, seqid);
10984 result.write(oprot);
10985 oprot->writeMessageEnd();
10986 bytes = oprot->getTransport()->writeEnd();
10987 oprot->getTransport()->flush();
10988
10989 if (eventHandler_.get() != NULL) {
10990 eventHandler_->postWrite(ctx, "Cassandra.system_update_column_family", bytes);
10991 }
10992 }
10993
10994 void CassandraProcessor::process_execute_cql_query(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
10995 {
10996 void* ctx = NULL;
10997 if (eventHandler_.get() != NULL) {
10998 ctx = eventHandler_->getContext("Cassandra.execute_cql_query", callContext);
10999 }
11000 ::apache::thrift::TProcessorContextFreer freer(eventHandler_.get(), ctx, "Cassandra.execute_cql_query");
11001
11002 if (eventHandler_.get() != NULL) {
11003 eventHandler_->preRead(ctx, "Cassandra.execute_cql_query");
11004 }
11005
11006 Cassandra_execute_cql_query_args args;
11007 args.read(iprot);
11008 iprot->readMessageEnd();
11009 uint32_t bytes = iprot->getTransport()->readEnd();
11010
11011 if (eventHandler_.get() != NULL) {
11012 eventHandler_->postRead(ctx, "Cassandra.execute_cql_query", bytes);
11013 }
11014
11015 Cassandra_execute_cql_query_result result;
11016 try {
11017 iface_->execute_cql_query(result.success, args.query, args.compression);
11018 result.__isset.success = true;
11019 } catch (InvalidRequestException &ire) {
11020 result.ire = ire;
11021 result.__isset.ire = true;
11022 } catch (UnavailableException &ue) {
11023 result.ue = ue;
11024 result.__isset.ue = true;
11025 } catch (TimedOutException &te) {
11026 result.te = te;
11027 result.__isset.te = true;
11028 } catch (SchemaDisagreementException &sde) {
11029 result.sde = sde;
11030 result.__isset.sde = true;
11031 } catch (const std::exception& e) {
11032 if (eventHandler_.get() != NULL) {
11033 eventHandler_->handlerError(ctx, "Cassandra.execute_cql_query");
11034 }
11035
11036 ::apache::thrift::TApplicationException x(e.what());
11037 oprot->writeMessageBegin("execute_cql_query", ::apache::thrift::protocol::T_EXCEPTION, seqid);
11038 x.write(oprot);
11039 oprot->writeMessageEnd();
11040 oprot->getTransport()->writeEnd();
11041 oprot->getTransport()->flush();
11042 return;
11043 }
11044
11045 if (eventHandler_.get() != NULL) {
11046 eventHandler_->preWrite(ctx, "Cassandra.execute_cql_query");
11047 }
11048
11049 oprot->writeMessageBegin("execute_cql_query", ::apache::thrift::protocol::T_REPLY, seqid);
11050 result.write(oprot);
11051 oprot->writeMessageEnd();
11052 bytes = oprot->getTransport()->writeEnd();
11053 oprot->getTransport()->flush();
11054
11055 if (eventHandler_.get() != NULL) {
11056 eventHandler_->postWrite(ctx, "Cassandra.execute_cql_query", bytes);
11057 }
11058 }
11059
11060 }}}
11061
