00001
00006 #ifndef Cassandra_H
00007 #define Cassandra_H
00008
00009 #include <TProcessor.h>
00010 #include "cassandra_types.h"
00011
00012 namespace org { namespace apache { namespace cassandra {
00013
00014 class CassandraIf {
00015 public:
00016 virtual ~CassandraIf() {}
00017 virtual void login(const AuthenticationRequest& auth_request) = 0;
00018 virtual void set_keyspace(const std::string& keyspace) = 0;
00019 virtual void get(ColumnOrSuperColumn& _return, const std::string& key, const ColumnPath& column_path, const ConsistencyLevel::type consistency_level) = 0;
00020 virtual void get_slice(std::vector<ColumnOrSuperColumn> & _return, const std::string& key, const ColumnParent& column_parent, const SlicePredicate& predicate, const ConsistencyLevel::type consistency_level) = 0;
00021 virtual int32_t get_count(const std::string& key, const ColumnParent& column_parent, const SlicePredicate& predicate, const ConsistencyLevel::type consistency_level) = 0;
00022 virtual void 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) = 0;
00023 virtual void 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) = 0;
00024 virtual void get_range_slices(std::vector<KeySlice> & _return, const ColumnParent& column_parent, const SlicePredicate& predicate, const KeyRange& range, const ConsistencyLevel::type consistency_level) = 0;
00025 virtual void get_indexed_slices(std::vector<KeySlice> & _return, const ColumnParent& column_parent, const IndexClause& index_clause, const SlicePredicate& column_predicate, const ConsistencyLevel::type consistency_level) = 0;
00026 virtual void insert(const std::string& key, const ColumnParent& column_parent, const Column& column, const ConsistencyLevel::type consistency_level) = 0;
00027 virtual void add(const std::string& key, const ColumnParent& column_parent, const CounterColumn& column, const ConsistencyLevel::type consistency_level) = 0;
00028 virtual void remove(const std::string& key, const ColumnPath& column_path, const int64_t timestamp, const ConsistencyLevel::type consistency_level) = 0;
00029 virtual void remove_counter(const std::string& key, const ColumnPath& path, const ConsistencyLevel::type consistency_level) = 0;
00030 virtual void batch_mutate(const std::map<std::string, std::map<std::string, std::vector<Mutation> > > & mutation_map, const ConsistencyLevel::type consistency_level) = 0;
00031 virtual void truncate(const std::string& cfname) = 0;
00032 virtual void describe_schema_versions(std::map<std::string, std::vector<std::string> > & _return) = 0;
00033 virtual void describe_keyspaces(std::vector<KsDef> & _return) = 0;
00034 virtual void describe_cluster_name(std::string& _return) = 0;
00035 virtual void describe_version(std::string& _return) = 0;
00036 virtual void describe_ring(std::vector<TokenRange> & _return, const std::string& keyspace) = 0;
00037 virtual void describe_partitioner(std::string& _return) = 0;
00038 virtual void describe_snitch(std::string& _return) = 0;
00039 virtual void describe_keyspace(KsDef& _return, const std::string& keyspace) = 0;
00040 virtual void 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) = 0;
00041 virtual void system_add_column_family(std::string& _return, const CfDef& cf_def) = 0;
00042 virtual void system_drop_column_family(std::string& _return, const std::string& column_family) = 0;
00043 virtual void system_add_keyspace(std::string& _return, const KsDef& ks_def) = 0;
00044 virtual void system_drop_keyspace(std::string& _return, const std::string& keyspace) = 0;
00045 virtual void system_update_keyspace(std::string& _return, const KsDef& ks_def) = 0;
00046 virtual void system_update_column_family(std::string& _return, const CfDef& cf_def) = 0;
00047 virtual void execute_cql_query(CqlResult& _return, const std::string& query, const Compression::type compression) = 0;
00048 };
00049
00050 class CassandraNull : virtual public CassandraIf {
00051 public:
00052 virtual ~CassandraNull() {}
00053 void login(const AuthenticationRequest& ) {
00054 return;
00055 }
00056 void set_keyspace(const std::string& ) {
00057 return;
00058 }
00059 void get(ColumnOrSuperColumn& , const std::string& , const ColumnPath& , const ConsistencyLevel::type ) {
00060 return;
00061 }
00062 void get_slice(std::vector<ColumnOrSuperColumn> & , const std::string& , const ColumnParent& , const SlicePredicate& , const ConsistencyLevel::type ) {
00063 return;
00064 }
00065 int32_t get_count(const std::string& , const ColumnParent& , const SlicePredicate& , const ConsistencyLevel::type ) {
00066 int32_t _return = 0;
00067 return _return;
00068 }
00069 void multiget_slice(std::map<std::string, std::vector<ColumnOrSuperColumn> > & , const std::vector<std::string> & , const ColumnParent& , const SlicePredicate& , const ConsistencyLevel::type ) {
00070 return;
00071 }
00072 void multiget_count(std::map<std::string, int32_t> & , const std::vector<std::string> & , const ColumnParent& , const SlicePredicate& , const ConsistencyLevel::type ) {
00073 return;
00074 }
00075 void get_range_slices(std::vector<KeySlice> & , const ColumnParent& , const SlicePredicate& , const KeyRange& , const ConsistencyLevel::type ) {
00076 return;
00077 }
00078 void get_indexed_slices(std::vector<KeySlice> & , const ColumnParent& , const IndexClause& , const SlicePredicate& , const ConsistencyLevel::type ) {
00079 return;
00080 }
00081 void insert(const std::string& , const ColumnParent& , const Column& , const ConsistencyLevel::type ) {
00082 return;
00083 }
00084 void add(const std::string& , const ColumnParent& , const CounterColumn& , const ConsistencyLevel::type ) {
00085 return;
00086 }
00087 void remove(const std::string& , const ColumnPath& , const int64_t , const ConsistencyLevel::type ) {
00088 return;
00089 }
00090 void remove_counter(const std::string& , const ColumnPath& , const ConsistencyLevel::type ) {
00091 return;
00092 }
00093 void batch_mutate(const std::map<std::string, std::map<std::string, std::vector<Mutation> > > & , const ConsistencyLevel::type ) {
00094 return;
00095 }
00096 void truncate(const std::string& ) {
00097 return;
00098 }
00099 void describe_schema_versions(std::map<std::string, std::vector<std::string> > & ) {
00100 return;
00101 }
00102 void describe_keyspaces(std::vector<KsDef> & ) {
00103 return;
00104 }
00105 void describe_cluster_name(std::string& ) {
00106 return;
00107 }
00108 void describe_version(std::string& ) {
00109 return;
00110 }
00111 void describe_ring(std::vector<TokenRange> & , const std::string& ) {
00112 return;
00113 }
00114 void describe_partitioner(std::string& ) {
00115 return;
00116 }
00117 void describe_snitch(std::string& ) {
00118 return;
00119 }
00120 void describe_keyspace(KsDef& , const std::string& ) {
00121 return;
00122 }
00123 void describe_splits(std::vector<std::string> & , const std::string& , const std::string& , const std::string& , const int32_t ) {
00124 return;
00125 }
00126 void system_add_column_family(std::string& , const CfDef& ) {
00127 return;
00128 }
00129 void system_drop_column_family(std::string& , const std::string& ) {
00130 return;
00131 }
00132 void system_add_keyspace(std::string& , const KsDef& ) {
00133 return;
00134 }
00135 void system_drop_keyspace(std::string& , const std::string& ) {
00136 return;
00137 }
00138 void system_update_keyspace(std::string& , const KsDef& ) {
00139 return;
00140 }
00141 void system_update_column_family(std::string& , const CfDef& ) {
00142 return;
00143 }
00144 void execute_cql_query(CqlResult& , const std::string& , const Compression::type ) {
00145 return;
00146 }
00147 };
00148
00149
00150 class Cassandra_login_args {
00151 public:
00152
00153 Cassandra_login_args() {
00154 }
00155
00156 virtual ~Cassandra_login_args() throw() {}
00157
00158 AuthenticationRequest auth_request;
00159
00160 bool operator == (const Cassandra_login_args & rhs) const
00161 {
00162 if (!(auth_request == rhs.auth_request))
00163 return false;
00164 return true;
00165 }
00166 bool operator != (const Cassandra_login_args &rhs) const {
00167 return !(*this == rhs);
00168 }
00169
00170 bool operator < (const Cassandra_login_args & ) const;
00171
00172 uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
00173 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
00174
00175 };
00176
00177
00178 class Cassandra_login_pargs {
00179 public:
00180
00181
00182 virtual ~Cassandra_login_pargs() throw() {}
00183
00184 const AuthenticationRequest* auth_request;
00185
00186 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
00187
00188 };
00189
00190 typedef struct _Cassandra_login_result__isset {
00191 _Cassandra_login_result__isset() : authnx(false), authzx(false) {}
00192 bool authnx;
00193 bool authzx;
00194 } _Cassandra_login_result__isset;
00195
00196 class Cassandra_login_result {
00197 public:
00198
00199 Cassandra_login_result() {
00200 }
00201
00202 virtual ~Cassandra_login_result() throw() {}
00203
00204 AuthenticationException authnx;
00205 AuthorizationException authzx;
00206
00207 _Cassandra_login_result__isset __isset;
00208
00209 bool operator == (const Cassandra_login_result & rhs) const
00210 {
00211 if (!(authnx == rhs.authnx))
00212 return false;
00213 if (!(authzx == rhs.authzx))
00214 return false;
00215 return true;
00216 }
00217 bool operator != (const Cassandra_login_result &rhs) const {
00218 return !(*this == rhs);
00219 }
00220
00221 bool operator < (const Cassandra_login_result & ) const;
00222
00223 uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
00224 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
00225
00226 };
00227
00228 typedef struct _Cassandra_login_presult__isset {
00229 _Cassandra_login_presult__isset() : authnx(false), authzx(false) {}
00230 bool authnx;
00231 bool authzx;
00232 } _Cassandra_login_presult__isset;
00233
00234 class Cassandra_login_presult {
00235 public:
00236
00237
00238 virtual ~Cassandra_login_presult() throw() {}
00239
00240 AuthenticationException authnx;
00241 AuthorizationException authzx;
00242
00243 _Cassandra_login_presult__isset __isset;
00244
00245 uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
00246
00247 };
00248
00249
00250 class Cassandra_set_keyspace_args {
00251 public:
00252
00253 Cassandra_set_keyspace_args() : keyspace("") {
00254 }
00255
00256 virtual ~Cassandra_set_keyspace_args() throw() {}
00257
00258 std::string keyspace;
00259
00260 bool operator == (const Cassandra_set_keyspace_args & rhs) const
00261 {
00262 if (!(keyspace == rhs.keyspace))
00263 return false;
00264 return true;
00265 }
00266 bool operator != (const Cassandra_set_keyspace_args &rhs) const {
00267 return !(*this == rhs);
00268 }
00269
00270 bool operator < (const Cassandra_set_keyspace_args & ) const;
00271
00272 uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
00273 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
00274
00275 };
00276
00277
00278 class Cassandra_set_keyspace_pargs {
00279 public:
00280
00281
00282 virtual ~Cassandra_set_keyspace_pargs() throw() {}
00283
00284 const std::string* keyspace;
00285
00286 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
00287
00288 };
00289
00290 typedef struct _Cassandra_set_keyspace_result__isset {
00291 _Cassandra_set_keyspace_result__isset() : ire(false) {}
00292 bool ire;
00293 } _Cassandra_set_keyspace_result__isset;
00294
00295 class Cassandra_set_keyspace_result {
00296 public:
00297
00298 Cassandra_set_keyspace_result() {
00299 }
00300
00301 virtual ~Cassandra_set_keyspace_result() throw() {}
00302
00303 InvalidRequestException ire;
00304
00305 _Cassandra_set_keyspace_result__isset __isset;
00306
00307 bool operator == (const Cassandra_set_keyspace_result & rhs) const
00308 {
00309 if (!(ire == rhs.ire))
00310 return false;
00311 return true;
00312 }
00313 bool operator != (const Cassandra_set_keyspace_result &rhs) const {
00314 return !(*this == rhs);
00315 }
00316
00317 bool operator < (const Cassandra_set_keyspace_result & ) const;
00318
00319 uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
00320 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
00321
00322 };
00323
00324 typedef struct _Cassandra_set_keyspace_presult__isset {
00325 _Cassandra_set_keyspace_presult__isset() : ire(false) {}
00326 bool ire;
00327 } _Cassandra_set_keyspace_presult__isset;
00328
00329 class Cassandra_set_keyspace_presult {
00330 public:
00331
00332
00333 virtual ~Cassandra_set_keyspace_presult() throw() {}
00334
00335 InvalidRequestException ire;
00336
00337 _Cassandra_set_keyspace_presult__isset __isset;
00338
00339 uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
00340
00341 };
00342
00343
00344 class Cassandra_get_args {
00345 public:
00346
00347 Cassandra_get_args() : key("") {
00348 consistency_level = (ConsistencyLevel::type)1;
00349
00350 }
00351
00352 virtual ~Cassandra_get_args() throw() {}
00353
00354 std::string key;
00355 ColumnPath column_path;
00356 ConsistencyLevel::type consistency_level;
00357
00358 bool operator == (const Cassandra_get_args & rhs) const
00359 {
00360 if (!(key == rhs.key))
00361 return false;
00362 if (!(column_path == rhs.column_path))
00363 return false;
00364 if (!(consistency_level == rhs.consistency_level))
00365 return false;
00366 return true;
00367 }
00368 bool operator != (const Cassandra_get_args &rhs) const {
00369 return !(*this == rhs);
00370 }
00371
00372 bool operator < (const Cassandra_get_args & ) const;
00373
00374 uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
00375 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
00376
00377 };
00378
00379
00380 class Cassandra_get_pargs {
00381 public:
00382
00383
00384 virtual ~Cassandra_get_pargs() throw() {}
00385
00386 const std::string* key;
00387 const ColumnPath* column_path;
00388 const ConsistencyLevel::type* consistency_level;
00389
00390 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
00391
00392 };
00393
00394 typedef struct _Cassandra_get_result__isset {
00395 _Cassandra_get_result__isset() : success(false), ire(false), nfe(false), ue(false), te(false) {}
00396 bool success;
00397 bool ire;
00398 bool nfe;
00399 bool ue;
00400 bool te;
00401 } _Cassandra_get_result__isset;
00402
00403 class Cassandra_get_result {
00404 public:
00405
00406 Cassandra_get_result() {
00407 }
00408
00409 virtual ~Cassandra_get_result() throw() {}
00410
00411 ColumnOrSuperColumn success;
00412 InvalidRequestException ire;
00413 NotFoundException nfe;
00414 UnavailableException ue;
00415 TimedOutException te;
00416
00417 _Cassandra_get_result__isset __isset;
00418
00419 bool operator == (const Cassandra_get_result & rhs) const
00420 {
00421 if (!(success == rhs.success))
00422 return false;
00423 if (!(ire == rhs.ire))
00424 return false;
00425 if (!(nfe == rhs.nfe))
00426 return false;
00427 if (!(ue == rhs.ue))
00428 return false;
00429 if (!(te == rhs.te))
00430 return false;
00431 return true;
00432 }
00433 bool operator != (const Cassandra_get_result &rhs) const {
00434 return !(*this == rhs);
00435 }
00436
00437 bool operator < (const Cassandra_get_result & ) const;
00438
00439 uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
00440 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
00441
00442 };
00443
00444 typedef struct _Cassandra_get_presult__isset {
00445 _Cassandra_get_presult__isset() : success(false), ire(false), nfe(false), ue(false), te(false) {}
00446 bool success;
00447 bool ire;
00448 bool nfe;
00449 bool ue;
00450 bool te;
00451 } _Cassandra_get_presult__isset;
00452
00453 class Cassandra_get_presult {
00454 public:
00455
00456
00457 virtual ~Cassandra_get_presult() throw() {}
00458
00459 ColumnOrSuperColumn* success;
00460 InvalidRequestException ire;
00461 NotFoundException nfe;
00462 UnavailableException ue;
00463 TimedOutException te;
00464
00465 _Cassandra_get_presult__isset __isset;
00466
00467 uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
00468
00469 };
00470
00471
00472 class Cassandra_get_slice_args {
00473 public:
00474
00475 Cassandra_get_slice_args() : key("") {
00476 consistency_level = (ConsistencyLevel::type)1;
00477
00478 }
00479
00480 virtual ~Cassandra_get_slice_args() throw() {}
00481
00482 std::string key;
00483 ColumnParent column_parent;
00484 SlicePredicate predicate;
00485 ConsistencyLevel::type consistency_level;
00486
00487 bool operator == (const Cassandra_get_slice_args & rhs) const
00488 {
00489 if (!(key == rhs.key))
00490 return false;
00491 if (!(column_parent == rhs.column_parent))
00492 return false;
00493 if (!(predicate == rhs.predicate))
00494 return false;
00495 if (!(consistency_level == rhs.consistency_level))
00496 return false;
00497 return true;
00498 }
00499 bool operator != (const Cassandra_get_slice_args &rhs) const {
00500 return !(*this == rhs);
00501 }
00502
00503 bool operator < (const Cassandra_get_slice_args & ) const;
00504
00505 uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
00506 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
00507
00508 };
00509
00510
00511 class Cassandra_get_slice_pargs {
00512 public:
00513
00514
00515 virtual ~Cassandra_get_slice_pargs() throw() {}
00516
00517 const std::string* key;
00518 const ColumnParent* column_parent;
00519 const SlicePredicate* predicate;
00520 const ConsistencyLevel::type* consistency_level;
00521
00522 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
00523
00524 };
00525
00526 typedef struct _Cassandra_get_slice_result__isset {
00527 _Cassandra_get_slice_result__isset() : success(false), ire(false), ue(false), te(false) {}
00528 bool success;
00529 bool ire;
00530 bool ue;
00531 bool te;
00532 } _Cassandra_get_slice_result__isset;
00533
00534 class Cassandra_get_slice_result {
00535 public:
00536
00537 Cassandra_get_slice_result() {
00538 }
00539
00540 virtual ~Cassandra_get_slice_result() throw() {}
00541
00542 std::vector<ColumnOrSuperColumn> success;
00543 InvalidRequestException ire;
00544 UnavailableException ue;
00545 TimedOutException te;
00546
00547 _Cassandra_get_slice_result__isset __isset;
00548
00549 bool operator == (const Cassandra_get_slice_result & rhs) const
00550 {
00551 if (!(success == rhs.success))
00552 return false;
00553 if (!(ire == rhs.ire))
00554 return false;
00555 if (!(ue == rhs.ue))
00556 return false;
00557 if (!(te == rhs.te))
00558 return false;
00559 return true;
00560 }
00561 bool operator != (const Cassandra_get_slice_result &rhs) const {
00562 return !(*this == rhs);
00563 }
00564
00565 bool operator < (const Cassandra_get_slice_result & ) const;
00566
00567 uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
00568 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
00569
00570 };
00571
00572 typedef struct _Cassandra_get_slice_presult__isset {
00573 _Cassandra_get_slice_presult__isset() : success(false), ire(false), ue(false), te(false) {}
00574 bool success;
00575 bool ire;
00576 bool ue;
00577 bool te;
00578 } _Cassandra_get_slice_presult__isset;
00579
00580 class Cassandra_get_slice_presult {
00581 public:
00582
00583
00584 virtual ~Cassandra_get_slice_presult() throw() {}
00585
00586 std::vector<ColumnOrSuperColumn> * success;
00587 InvalidRequestException ire;
00588 UnavailableException ue;
00589 TimedOutException te;
00590
00591 _Cassandra_get_slice_presult__isset __isset;
00592
00593 uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
00594
00595 };
00596
00597
00598 class Cassandra_get_count_args {
00599 public:
00600
00601 Cassandra_get_count_args() : key("") {
00602 consistency_level = (ConsistencyLevel::type)1;
00603
00604 }
00605
00606 virtual ~Cassandra_get_count_args() throw() {}
00607
00608 std::string key;
00609 ColumnParent column_parent;
00610 SlicePredicate predicate;
00611 ConsistencyLevel::type consistency_level;
00612
00613 bool operator == (const Cassandra_get_count_args & rhs) const
00614 {
00615 if (!(key == rhs.key))
00616 return false;
00617 if (!(column_parent == rhs.column_parent))
00618 return false;
00619 if (!(predicate == rhs.predicate))
00620 return false;
00621 if (!(consistency_level == rhs.consistency_level))
00622 return false;
00623 return true;
00624 }
00625 bool operator != (const Cassandra_get_count_args &rhs) const {
00626 return !(*this == rhs);
00627 }
00628
00629 bool operator < (const Cassandra_get_count_args & ) const;
00630
00631 uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
00632 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
00633
00634 };
00635
00636
00637 class Cassandra_get_count_pargs {
00638 public:
00639
00640
00641 virtual ~Cassandra_get_count_pargs() throw() {}
00642
00643 const std::string* key;
00644 const ColumnParent* column_parent;
00645 const SlicePredicate* predicate;
00646 const ConsistencyLevel::type* consistency_level;
00647
00648 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
00649
00650 };
00651
00652 typedef struct _Cassandra_get_count_result__isset {
00653 _Cassandra_get_count_result__isset() : success(false), ire(false), ue(false), te(false) {}
00654 bool success;
00655 bool ire;
00656 bool ue;
00657 bool te;
00658 } _Cassandra_get_count_result__isset;
00659
00660 class Cassandra_get_count_result {
00661 public:
00662
00663 Cassandra_get_count_result() : success(0) {
00664 }
00665
00666 virtual ~Cassandra_get_count_result() throw() {}
00667
00668 int32_t success;
00669 InvalidRequestException ire;
00670 UnavailableException ue;
00671 TimedOutException te;
00672
00673 _Cassandra_get_count_result__isset __isset;
00674
00675 bool operator == (const Cassandra_get_count_result & rhs) const
00676 {
00677 if (!(success == rhs.success))
00678 return false;
00679 if (!(ire == rhs.ire))
00680 return false;
00681 if (!(ue == rhs.ue))
00682 return false;
00683 if (!(te == rhs.te))
00684 return false;
00685 return true;
00686 }
00687 bool operator != (const Cassandra_get_count_result &rhs) const {
00688 return !(*this == rhs);
00689 }
00690
00691 bool operator < (const Cassandra_get_count_result & ) const;
00692
00693 uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
00694 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
00695
00696 };
00697
00698 typedef struct _Cassandra_get_count_presult__isset {
00699 _Cassandra_get_count_presult__isset() : success(false), ire(false), ue(false), te(false) {}
00700 bool success;
00701 bool ire;
00702 bool ue;
00703 bool te;
00704 } _Cassandra_get_count_presult__isset;
00705
00706 class Cassandra_get_count_presult {
00707 public:
00708
00709
00710 virtual ~Cassandra_get_count_presult() throw() {}
00711
00712 int32_t* success;
00713 InvalidRequestException ire;
00714 UnavailableException ue;
00715 TimedOutException te;
00716
00717 _Cassandra_get_count_presult__isset __isset;
00718
00719 uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
00720
00721 };
00722
00723
00724 class Cassandra_multiget_slice_args {
00725 public:
00726
00727 Cassandra_multiget_slice_args() {
00728 consistency_level = (ConsistencyLevel::type)1;
00729
00730 }
00731
00732 virtual ~Cassandra_multiget_slice_args() throw() {}
00733
00734 std::vector<std::string> keys;
00735 ColumnParent column_parent;
00736 SlicePredicate predicate;
00737 ConsistencyLevel::type consistency_level;
00738
00739 bool operator == (const Cassandra_multiget_slice_args & rhs) const
00740 {
00741 if (!(keys == rhs.keys))
00742 return false;
00743 if (!(column_parent == rhs.column_parent))
00744 return false;
00745 if (!(predicate == rhs.predicate))
00746 return false;
00747 if (!(consistency_level == rhs.consistency_level))
00748 return false;
00749 return true;
00750 }
00751 bool operator != (const Cassandra_multiget_slice_args &rhs) const {
00752 return !(*this == rhs);
00753 }
00754
00755 bool operator < (const Cassandra_multiget_slice_args & ) const;
00756
00757 uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
00758 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
00759
00760 };
00761
00762
00763 class Cassandra_multiget_slice_pargs {
00764 public:
00765
00766
00767 virtual ~Cassandra_multiget_slice_pargs() throw() {}
00768
00769 const std::vector<std::string> * keys;
00770 const ColumnParent* column_parent;
00771 const SlicePredicate* predicate;
00772 const ConsistencyLevel::type* consistency_level;
00773
00774 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
00775
00776 };
00777
00778 typedef struct _Cassandra_multiget_slice_result__isset {
00779 _Cassandra_multiget_slice_result__isset() : success(false), ire(false), ue(false), te(false) {}
00780 bool success;
00781 bool ire;
00782 bool ue;
00783 bool te;
00784 } _Cassandra_multiget_slice_result__isset;
00785
00786 class Cassandra_multiget_slice_result {
00787 public:
00788
00789 Cassandra_multiget_slice_result() {
00790 }
00791
00792 virtual ~Cassandra_multiget_slice_result() throw() {}
00793
00794 std::map<std::string, std::vector<ColumnOrSuperColumn> > success;
00795 InvalidRequestException ire;
00796 UnavailableException ue;
00797 TimedOutException te;
00798
00799 _Cassandra_multiget_slice_result__isset __isset;
00800
00801 bool operator == (const Cassandra_multiget_slice_result & rhs) const
00802 {
00803 if (!(success == rhs.success))
00804 return false;
00805 if (!(ire == rhs.ire))
00806 return false;
00807 if (!(ue == rhs.ue))
00808 return false;
00809 if (!(te == rhs.te))
00810 return false;
00811 return true;
00812 }
00813 bool operator != (const Cassandra_multiget_slice_result &rhs) const {
00814 return !(*this == rhs);
00815 }
00816
00817 bool operator < (const Cassandra_multiget_slice_result & ) const;
00818
00819 uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
00820 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
00821
00822 };
00823
00824 typedef struct _Cassandra_multiget_slice_presult__isset {
00825 _Cassandra_multiget_slice_presult__isset() : success(false), ire(false), ue(false), te(false) {}
00826 bool success;
00827 bool ire;
00828 bool ue;
00829 bool te;
00830 } _Cassandra_multiget_slice_presult__isset;
00831
00832 class Cassandra_multiget_slice_presult {
00833 public:
00834
00835
00836 virtual ~Cassandra_multiget_slice_presult() throw() {}
00837
00838 std::map<std::string, std::vector<ColumnOrSuperColumn> > * success;
00839 InvalidRequestException ire;
00840 UnavailableException ue;
00841 TimedOutException te;
00842
00843 _Cassandra_multiget_slice_presult__isset __isset;
00844
00845 uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
00846
00847 };
00848
00849
00850 class Cassandra_multiget_count_args {
00851 public:
00852
00853 Cassandra_multiget_count_args() {
00854 consistency_level = (ConsistencyLevel::type)1;
00855
00856 }
00857
00858 virtual ~Cassandra_multiget_count_args() throw() {}
00859
00860 std::vector<std::string> keys;
00861 ColumnParent column_parent;
00862 SlicePredicate predicate;
00863 ConsistencyLevel::type consistency_level;
00864
00865 bool operator == (const Cassandra_multiget_count_args & rhs) const
00866 {
00867 if (!(keys == rhs.keys))
00868 return false;
00869 if (!(column_parent == rhs.column_parent))
00870 return false;
00871 if (!(predicate == rhs.predicate))
00872 return false;
00873 if (!(consistency_level == rhs.consistency_level))
00874 return false;
00875 return true;
00876 }
00877 bool operator != (const Cassandra_multiget_count_args &rhs) const {
00878 return !(*this == rhs);
00879 }
00880
00881 bool operator < (const Cassandra_multiget_count_args & ) const;
00882
00883 uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
00884 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
00885
00886 };
00887
00888
00889 class Cassandra_multiget_count_pargs {
00890 public:
00891
00892
00893 virtual ~Cassandra_multiget_count_pargs() throw() {}
00894
00895 const std::vector<std::string> * keys;
00896 const ColumnParent* column_parent;
00897 const SlicePredicate* predicate;
00898 const ConsistencyLevel::type* consistency_level;
00899
00900 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
00901
00902 };
00903
00904 typedef struct _Cassandra_multiget_count_result__isset {
00905 _Cassandra_multiget_count_result__isset() : success(false), ire(false), ue(false), te(false) {}
00906 bool success;
00907 bool ire;
00908 bool ue;
00909 bool te;
00910 } _Cassandra_multiget_count_result__isset;
00911
00912 class Cassandra_multiget_count_result {
00913 public:
00914
00915 Cassandra_multiget_count_result() {
00916 }
00917
00918 virtual ~Cassandra_multiget_count_result() throw() {}
00919
00920 std::map<std::string, int32_t> success;
00921 InvalidRequestException ire;
00922 UnavailableException ue;
00923 TimedOutException te;
00924
00925 _Cassandra_multiget_count_result__isset __isset;
00926
00927 bool operator == (const Cassandra_multiget_count_result & rhs) const
00928 {
00929 if (!(success == rhs.success))
00930 return false;
00931 if (!(ire == rhs.ire))
00932 return false;
00933 if (!(ue == rhs.ue))
00934 return false;
00935 if (!(te == rhs.te))
00936 return false;
00937 return true;
00938 }
00939 bool operator != (const Cassandra_multiget_count_result &rhs) const {
00940 return !(*this == rhs);
00941 }
00942
00943 bool operator < (const Cassandra_multiget_count_result & ) const;
00944
00945 uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
00946 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
00947
00948 };
00949
00950 typedef struct _Cassandra_multiget_count_presult__isset {
00951 _Cassandra_multiget_count_presult__isset() : success(false), ire(false), ue(false), te(false) {}
00952 bool success;
00953 bool ire;
00954 bool ue;
00955 bool te;
00956 } _Cassandra_multiget_count_presult__isset;
00957
00958 class Cassandra_multiget_count_presult {
00959 public:
00960
00961
00962 virtual ~Cassandra_multiget_count_presult() throw() {}
00963
00964 std::map<std::string, int32_t> * success;
00965 InvalidRequestException ire;
00966 UnavailableException ue;
00967 TimedOutException te;
00968
00969 _Cassandra_multiget_count_presult__isset __isset;
00970
00971 uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
00972
00973 };
00974
00975
00976 class Cassandra_get_range_slices_args {
00977 public:
00978
00979 Cassandra_get_range_slices_args() {
00980 consistency_level = (ConsistencyLevel::type)1;
00981
00982 }
00983
00984 virtual ~Cassandra_get_range_slices_args() throw() {}
00985
00986 ColumnParent column_parent;
00987 SlicePredicate predicate;
00988 KeyRange range;
00989 ConsistencyLevel::type consistency_level;
00990
00991 bool operator == (const Cassandra_get_range_slices_args & rhs) const
00992 {
00993 if (!(column_parent == rhs.column_parent))
00994 return false;
00995 if (!(predicate == rhs.predicate))
00996 return false;
00997 if (!(range == rhs.range))
00998 return false;
00999 if (!(consistency_level == rhs.consistency_level))
01000 return false;
01001 return true;
01002 }
01003 bool operator != (const Cassandra_get_range_slices_args &rhs) const {
01004 return !(*this == rhs);
01005 }
01006
01007 bool operator < (const Cassandra_get_range_slices_args & ) const;
01008
01009 uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
01010 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
01011
01012 };
01013
01014
01015 class Cassandra_get_range_slices_pargs {
01016 public:
01017
01018
01019 virtual ~Cassandra_get_range_slices_pargs() throw() {}
01020
01021 const ColumnParent* column_parent;
01022 const SlicePredicate* predicate;
01023 const KeyRange* range;
01024 const ConsistencyLevel::type* consistency_level;
01025
01026 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
01027
01028 };
01029
01030 typedef struct _Cassandra_get_range_slices_result__isset {
01031 _Cassandra_get_range_slices_result__isset() : success(false), ire(false), ue(false), te(false) {}
01032 bool success;
01033 bool ire;
01034 bool ue;
01035 bool te;
01036 } _Cassandra_get_range_slices_result__isset;
01037
01038 class Cassandra_get_range_slices_result {
01039 public:
01040
01041 Cassandra_get_range_slices_result() {
01042 }
01043
01044 virtual ~Cassandra_get_range_slices_result() throw() {}
01045
01046 std::vector<KeySlice> success;
01047 InvalidRequestException ire;
01048 UnavailableException ue;
01049 TimedOutException te;
01050
01051 _Cassandra_get_range_slices_result__isset __isset;
01052
01053 bool operator == (const Cassandra_get_range_slices_result & rhs) const
01054 {
01055 if (!(success == rhs.success))
01056 return false;
01057 if (!(ire == rhs.ire))
01058 return false;
01059 if (!(ue == rhs.ue))
01060 return false;
01061 if (!(te == rhs.te))
01062 return false;
01063 return true;
01064 }
01065 bool operator != (const Cassandra_get_range_slices_result &rhs) const {
01066 return !(*this == rhs);
01067 }
01068
01069 bool operator < (const Cassandra_get_range_slices_result & ) const;
01070
01071 uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
01072 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
01073
01074 };
01075
01076 typedef struct _Cassandra_get_range_slices_presult__isset {
01077 _Cassandra_get_range_slices_presult__isset() : success(false), ire(false), ue(false), te(false) {}
01078 bool success;
01079 bool ire;
01080 bool ue;
01081 bool te;
01082 } _Cassandra_get_range_slices_presult__isset;
01083
01084 class Cassandra_get_range_slices_presult {
01085 public:
01086
01087
01088 virtual ~Cassandra_get_range_slices_presult() throw() {}
01089
01090 std::vector<KeySlice> * success;
01091 InvalidRequestException ire;
01092 UnavailableException ue;
01093 TimedOutException te;
01094
01095 _Cassandra_get_range_slices_presult__isset __isset;
01096
01097 uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
01098
01099 };
01100
01101
01102 class Cassandra_get_indexed_slices_args {
01103 public:
01104
01105 Cassandra_get_indexed_slices_args() {
01106 consistency_level = (ConsistencyLevel::type)1;
01107
01108 }
01109
01110 virtual ~Cassandra_get_indexed_slices_args() throw() {}
01111
01112 ColumnParent column_parent;
01113 IndexClause index_clause;
01114 SlicePredicate column_predicate;
01115 ConsistencyLevel::type consistency_level;
01116
01117 bool operator == (const Cassandra_get_indexed_slices_args & rhs) const
01118 {
01119 if (!(column_parent == rhs.column_parent))
01120 return false;
01121 if (!(index_clause == rhs.index_clause))
01122 return false;
01123 if (!(column_predicate == rhs.column_predicate))
01124 return false;
01125 if (!(consistency_level == rhs.consistency_level))
01126 return false;
01127 return true;
01128 }
01129 bool operator != (const Cassandra_get_indexed_slices_args &rhs) const {
01130 return !(*this == rhs);
01131 }
01132
01133 bool operator < (const Cassandra_get_indexed_slices_args & ) const;
01134
01135 uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
01136 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
01137
01138 };
01139
01140
01141 class Cassandra_get_indexed_slices_pargs {
01142 public:
01143
01144
01145 virtual ~Cassandra_get_indexed_slices_pargs() throw() {}
01146
01147 const ColumnParent* column_parent;
01148 const IndexClause* index_clause;
01149 const SlicePredicate* column_predicate;
01150 const ConsistencyLevel::type* consistency_level;
01151
01152 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
01153
01154 };
01155
01156 typedef struct _Cassandra_get_indexed_slices_result__isset {
01157 _Cassandra_get_indexed_slices_result__isset() : success(false), ire(false), ue(false), te(false) {}
01158 bool success;
01159 bool ire;
01160 bool ue;
01161 bool te;
01162 } _Cassandra_get_indexed_slices_result__isset;
01163
01164 class Cassandra_get_indexed_slices_result {
01165 public:
01166
01167 Cassandra_get_indexed_slices_result() {
01168 }
01169
01170 virtual ~Cassandra_get_indexed_slices_result() throw() {}
01171
01172 std::vector<KeySlice> success;
01173 InvalidRequestException ire;
01174 UnavailableException ue;
01175 TimedOutException te;
01176
01177 _Cassandra_get_indexed_slices_result__isset __isset;
01178
01179 bool operator == (const Cassandra_get_indexed_slices_result & rhs) const
01180 {
01181 if (!(success == rhs.success))
01182 return false;
01183 if (!(ire == rhs.ire))
01184 return false;
01185 if (!(ue == rhs.ue))
01186 return false;
01187 if (!(te == rhs.te))
01188 return false;
01189 return true;
01190 }
01191 bool operator != (const Cassandra_get_indexed_slices_result &rhs) const {
01192 return !(*this == rhs);
01193 }
01194
01195 bool operator < (const Cassandra_get_indexed_slices_result & ) const;
01196
01197 uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
01198 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
01199
01200 };
01201
01202 typedef struct _Cassandra_get_indexed_slices_presult__isset {
01203 _Cassandra_get_indexed_slices_presult__isset() : success(false), ire(false), ue(false), te(false) {}
01204 bool success;
01205 bool ire;
01206 bool ue;
01207 bool te;
01208 } _Cassandra_get_indexed_slices_presult__isset;
01209
01210 class Cassandra_get_indexed_slices_presult {
01211 public:
01212
01213
01214 virtual ~Cassandra_get_indexed_slices_presult() throw() {}
01215
01216 std::vector<KeySlice> * success;
01217 InvalidRequestException ire;
01218 UnavailableException ue;
01219 TimedOutException te;
01220
01221 _Cassandra_get_indexed_slices_presult__isset __isset;
01222
01223 uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
01224
01225 };
01226
01227
01228 class Cassandra_insert_args {
01229 public:
01230
01231 Cassandra_insert_args() : key("") {
01232 consistency_level = (ConsistencyLevel::type)1;
01233
01234 }
01235
01236 virtual ~Cassandra_insert_args() throw() {}
01237
01238 std::string key;
01239 ColumnParent column_parent;
01240 Column column;
01241 ConsistencyLevel::type consistency_level;
01242
01243 bool operator == (const Cassandra_insert_args & rhs) const
01244 {
01245 if (!(key == rhs.key))
01246 return false;
01247 if (!(column_parent == rhs.column_parent))
01248 return false;
01249 if (!(column == rhs.column))
01250 return false;
01251 if (!(consistency_level == rhs.consistency_level))
01252 return false;
01253 return true;
01254 }
01255 bool operator != (const Cassandra_insert_args &rhs) const {
01256 return !(*this == rhs);
01257 }
01258
01259 bool operator < (const Cassandra_insert_args & ) const;
01260
01261 uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
01262 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
01263
01264 };
01265
01266
01267 class Cassandra_insert_pargs {
01268 public:
01269
01270
01271 virtual ~Cassandra_insert_pargs() throw() {}
01272
01273 const std::string* key;
01274 const ColumnParent* column_parent;
01275 const Column* column;
01276 const ConsistencyLevel::type* consistency_level;
01277
01278 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
01279
01280 };
01281
01282 typedef struct _Cassandra_insert_result__isset {
01283 _Cassandra_insert_result__isset() : ire(false), ue(false), te(false) {}
01284 bool ire;
01285 bool ue;
01286 bool te;
01287 } _Cassandra_insert_result__isset;
01288
01289 class Cassandra_insert_result {
01290 public:
01291
01292 Cassandra_insert_result() {
01293 }
01294
01295 virtual ~Cassandra_insert_result() throw() {}
01296
01297 InvalidRequestException ire;
01298 UnavailableException ue;
01299 TimedOutException te;
01300
01301 _Cassandra_insert_result__isset __isset;
01302
01303 bool operator == (const Cassandra_insert_result & rhs) const
01304 {
01305 if (!(ire == rhs.ire))
01306 return false;
01307 if (!(ue == rhs.ue))
01308 return false;
01309 if (!(te == rhs.te))
01310 return false;
01311 return true;
01312 }
01313 bool operator != (const Cassandra_insert_result &rhs) const {
01314 return !(*this == rhs);
01315 }
01316
01317 bool operator < (const Cassandra_insert_result & ) const;
01318
01319 uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
01320 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
01321
01322 };
01323
01324 typedef struct _Cassandra_insert_presult__isset {
01325 _Cassandra_insert_presult__isset() : ire(false), ue(false), te(false) {}
01326 bool ire;
01327 bool ue;
01328 bool te;
01329 } _Cassandra_insert_presult__isset;
01330
01331 class Cassandra_insert_presult {
01332 public:
01333
01334
01335 virtual ~Cassandra_insert_presult() throw() {}
01336
01337 InvalidRequestException ire;
01338 UnavailableException ue;
01339 TimedOutException te;
01340
01341 _Cassandra_insert_presult__isset __isset;
01342
01343 uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
01344
01345 };
01346
01347
01348 class Cassandra_add_args {
01349 public:
01350
01351 Cassandra_add_args() : key("") {
01352 consistency_level = (ConsistencyLevel::type)1;
01353
01354 }
01355
01356 virtual ~Cassandra_add_args() throw() {}
01357
01358 std::string key;
01359 ColumnParent column_parent;
01360 CounterColumn column;
01361 ConsistencyLevel::type consistency_level;
01362
01363 bool operator == (const Cassandra_add_args & rhs) const
01364 {
01365 if (!(key == rhs.key))
01366 return false;
01367 if (!(column_parent == rhs.column_parent))
01368 return false;
01369 if (!(column == rhs.column))
01370 return false;
01371 if (!(consistency_level == rhs.consistency_level))
01372 return false;
01373 return true;
01374 }
01375 bool operator != (const Cassandra_add_args &rhs) const {
01376 return !(*this == rhs);
01377 }
01378
01379 bool operator < (const Cassandra_add_args & ) const;
01380
01381 uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
01382 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
01383
01384 };
01385
01386
01387 class Cassandra_add_pargs {
01388 public:
01389
01390
01391 virtual ~Cassandra_add_pargs() throw() {}
01392
01393 const std::string* key;
01394 const ColumnParent* column_parent;
01395 const CounterColumn* column;
01396 const ConsistencyLevel::type* consistency_level;
01397
01398 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
01399
01400 };
01401
01402 typedef struct _Cassandra_add_result__isset {
01403 _Cassandra_add_result__isset() : ire(false), ue(false), te(false) {}
01404 bool ire;
01405 bool ue;
01406 bool te;
01407 } _Cassandra_add_result__isset;
01408
01409 class Cassandra_add_result {
01410 public:
01411
01412 Cassandra_add_result() {
01413 }
01414
01415 virtual ~Cassandra_add_result() throw() {}
01416
01417 InvalidRequestException ire;
01418 UnavailableException ue;
01419 TimedOutException te;
01420
01421 _Cassandra_add_result__isset __isset;
01422
01423 bool operator == (const Cassandra_add_result & rhs) const
01424 {
01425 if (!(ire == rhs.ire))
01426 return false;
01427 if (!(ue == rhs.ue))
01428 return false;
01429 if (!(te == rhs.te))
01430 return false;
01431 return true;
01432 }
01433 bool operator != (const Cassandra_add_result &rhs) const {
01434 return !(*this == rhs);
01435 }
01436
01437 bool operator < (const Cassandra_add_result & ) const;
01438
01439 uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
01440 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
01441
01442 };
01443
01444 typedef struct _Cassandra_add_presult__isset {
01445 _Cassandra_add_presult__isset() : ire(false), ue(false), te(false) {}
01446 bool ire;
01447 bool ue;
01448 bool te;
01449 } _Cassandra_add_presult__isset;
01450
01451 class Cassandra_add_presult {
01452 public:
01453
01454
01455 virtual ~Cassandra_add_presult() throw() {}
01456
01457 InvalidRequestException ire;
01458 UnavailableException ue;
01459 TimedOutException te;
01460
01461 _Cassandra_add_presult__isset __isset;
01462
01463 uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
01464
01465 };
01466
01467 typedef struct _Cassandra_remove_args__isset {
01468 _Cassandra_remove_args__isset() : consistency_level(false) {}
01469 bool consistency_level;
01470 } _Cassandra_remove_args__isset;
01471
01472 class Cassandra_remove_args {
01473 public:
01474
01475 Cassandra_remove_args() : key(""), timestamp(0) {
01476 consistency_level = (ConsistencyLevel::type)1;
01477
01478 }
01479
01480 virtual ~Cassandra_remove_args() throw() {}
01481
01482 std::string key;
01483 ColumnPath column_path;
01484 int64_t timestamp;
01485 ConsistencyLevel::type consistency_level;
01486
01487 _Cassandra_remove_args__isset __isset;
01488
01489 bool operator == (const Cassandra_remove_args & rhs) const
01490 {
01491 if (!(key == rhs.key))
01492 return false;
01493 if (!(column_path == rhs.column_path))
01494 return false;
01495 if (!(timestamp == rhs.timestamp))
01496 return false;
01497 if (!(consistency_level == rhs.consistency_level))
01498 return false;
01499 return true;
01500 }
01501 bool operator != (const Cassandra_remove_args &rhs) const {
01502 return !(*this == rhs);
01503 }
01504
01505 bool operator < (const Cassandra_remove_args & ) const;
01506
01507 uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
01508 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
01509
01510 };
01511
01512
01513 class Cassandra_remove_pargs {
01514 public:
01515
01516
01517 virtual ~Cassandra_remove_pargs() throw() {}
01518
01519 const std::string* key;
01520 const ColumnPath* column_path;
01521 const int64_t* timestamp;
01522 const ConsistencyLevel::type* consistency_level;
01523
01524 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
01525
01526 };
01527
01528 typedef struct _Cassandra_remove_result__isset {
01529 _Cassandra_remove_result__isset() : ire(false), ue(false), te(false) {}
01530 bool ire;
01531 bool ue;
01532 bool te;
01533 } _Cassandra_remove_result__isset;
01534
01535 class Cassandra_remove_result {
01536 public:
01537
01538 Cassandra_remove_result() {
01539 }
01540
01541 virtual ~Cassandra_remove_result() throw() {}
01542
01543 InvalidRequestException ire;
01544 UnavailableException ue;
01545 TimedOutException te;
01546
01547 _Cassandra_remove_result__isset __isset;
01548
01549 bool operator == (const Cassandra_remove_result & rhs) const
01550 {
01551 if (!(ire == rhs.ire))
01552 return false;
01553 if (!(ue == rhs.ue))
01554 return false;
01555 if (!(te == rhs.te))
01556 return false;
01557 return true;
01558 }
01559 bool operator != (const Cassandra_remove_result &rhs) const {
01560 return !(*this == rhs);
01561 }
01562
01563 bool operator < (const Cassandra_remove_result & ) const;
01564
01565 uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
01566 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
01567
01568 };
01569
01570 typedef struct _Cassandra_remove_presult__isset {
01571 _Cassandra_remove_presult__isset() : ire(false), ue(false), te(false) {}
01572 bool ire;
01573 bool ue;
01574 bool te;
01575 } _Cassandra_remove_presult__isset;
01576
01577 class Cassandra_remove_presult {
01578 public:
01579
01580
01581 virtual ~Cassandra_remove_presult() throw() {}
01582
01583 InvalidRequestException ire;
01584 UnavailableException ue;
01585 TimedOutException te;
01586
01587 _Cassandra_remove_presult__isset __isset;
01588
01589 uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
01590
01591 };
01592
01593
01594 class Cassandra_remove_counter_args {
01595 public:
01596
01597 Cassandra_remove_counter_args() : key("") {
01598 consistency_level = (ConsistencyLevel::type)1;
01599
01600 }
01601
01602 virtual ~Cassandra_remove_counter_args() throw() {}
01603
01604 std::string key;
01605 ColumnPath path;
01606 ConsistencyLevel::type consistency_level;
01607
01608 bool operator == (const Cassandra_remove_counter_args & rhs) const
01609 {
01610 if (!(key == rhs.key))
01611 return false;
01612 if (!(path == rhs.path))
01613 return false;
01614 if (!(consistency_level == rhs.consistency_level))
01615 return false;
01616 return true;
01617 }
01618 bool operator != (const Cassandra_remove_counter_args &rhs) const {
01619 return !(*this == rhs);
01620 }
01621
01622 bool operator < (const Cassandra_remove_counter_args & ) const;
01623
01624 uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
01625 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
01626
01627 };
01628
01629
01630 class Cassandra_remove_counter_pargs {
01631 public:
01632
01633
01634 virtual ~Cassandra_remove_counter_pargs() throw() {}
01635
01636 const std::string* key;
01637 const ColumnPath* path;
01638 const ConsistencyLevel::type* consistency_level;
01639
01640 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
01641
01642 };
01643
01644 typedef struct _Cassandra_remove_counter_result__isset {
01645 _Cassandra_remove_counter_result__isset() : ire(false), ue(false), te(false) {}
01646 bool ire;
01647 bool ue;
01648 bool te;
01649 } _Cassandra_remove_counter_result__isset;
01650
01651 class Cassandra_remove_counter_result {
01652 public:
01653
01654 Cassandra_remove_counter_result() {
01655 }
01656
01657 virtual ~Cassandra_remove_counter_result() throw() {}
01658
01659 InvalidRequestException ire;
01660 UnavailableException ue;
01661 TimedOutException te;
01662
01663 _Cassandra_remove_counter_result__isset __isset;
01664
01665 bool operator == (const Cassandra_remove_counter_result & rhs) const
01666 {
01667 if (!(ire == rhs.ire))
01668 return false;
01669 if (!(ue == rhs.ue))
01670 return false;
01671 if (!(te == rhs.te))
01672 return false;
01673 return true;
01674 }
01675 bool operator != (const Cassandra_remove_counter_result &rhs) const {
01676 return !(*this == rhs);
01677 }
01678
01679 bool operator < (const Cassandra_remove_counter_result & ) const;
01680
01681 uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
01682 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
01683
01684 };
01685
01686 typedef struct _Cassandra_remove_counter_presult__isset {
01687 _Cassandra_remove_counter_presult__isset() : ire(false), ue(false), te(false) {}
01688 bool ire;
01689 bool ue;
01690 bool te;
01691 } _Cassandra_remove_counter_presult__isset;
01692
01693 class Cassandra_remove_counter_presult {
01694 public:
01695
01696
01697 virtual ~Cassandra_remove_counter_presult() throw() {}
01698
01699 InvalidRequestException ire;
01700 UnavailableException ue;
01701 TimedOutException te;
01702
01703 _Cassandra_remove_counter_presult__isset __isset;
01704
01705 uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
01706
01707 };
01708
01709
01710 class Cassandra_batch_mutate_args {
01711 public:
01712
01713 Cassandra_batch_mutate_args() {
01714 consistency_level = (ConsistencyLevel::type)1;
01715
01716 }
01717
01718 virtual ~Cassandra_batch_mutate_args() throw() {}
01719
01720 std::map<std::string, std::map<std::string, std::vector<Mutation> > > mutation_map;
01721 ConsistencyLevel::type consistency_level;
01722
01723 bool operator == (const Cassandra_batch_mutate_args & rhs) const
01724 {
01725 if (!(mutation_map == rhs.mutation_map))
01726 return false;
01727 if (!(consistency_level == rhs.consistency_level))
01728 return false;
01729 return true;
01730 }
01731 bool operator != (const Cassandra_batch_mutate_args &rhs) const {
01732 return !(*this == rhs);
01733 }
01734
01735 bool operator < (const Cassandra_batch_mutate_args & ) const;
01736
01737 uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
01738 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
01739
01740 };
01741
01742
01743 class Cassandra_batch_mutate_pargs {
01744 public:
01745
01746
01747 virtual ~Cassandra_batch_mutate_pargs() throw() {}
01748
01749 const std::map<std::string, std::map<std::string, std::vector<Mutation> > > * mutation_map;
01750 const ConsistencyLevel::type* consistency_level;
01751
01752 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
01753
01754 };
01755
01756 typedef struct _Cassandra_batch_mutate_result__isset {
01757 _Cassandra_batch_mutate_result__isset() : ire(false), ue(false), te(false) {}
01758 bool ire;
01759 bool ue;
01760 bool te;
01761 } _Cassandra_batch_mutate_result__isset;
01762
01763 class Cassandra_batch_mutate_result {
01764 public:
01765
01766 Cassandra_batch_mutate_result() {
01767 }
01768
01769 virtual ~Cassandra_batch_mutate_result() throw() {}
01770
01771 InvalidRequestException ire;
01772 UnavailableException ue;
01773 TimedOutException te;
01774
01775 _Cassandra_batch_mutate_result__isset __isset;
01776
01777 bool operator == (const Cassandra_batch_mutate_result & rhs) const
01778 {
01779 if (!(ire == rhs.ire))
01780 return false;
01781 if (!(ue == rhs.ue))
01782 return false;
01783 if (!(te == rhs.te))
01784 return false;
01785 return true;
01786 }
01787 bool operator != (const Cassandra_batch_mutate_result &rhs) const {
01788 return !(*this == rhs);
01789 }
01790
01791 bool operator < (const Cassandra_batch_mutate_result & ) const;
01792
01793 uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
01794 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
01795
01796 };
01797
01798 typedef struct _Cassandra_batch_mutate_presult__isset {
01799 _Cassandra_batch_mutate_presult__isset() : ire(false), ue(false), te(false) {}
01800 bool ire;
01801 bool ue;
01802 bool te;
01803 } _Cassandra_batch_mutate_presult__isset;
01804
01805 class Cassandra_batch_mutate_presult {
01806 public:
01807
01808
01809 virtual ~Cassandra_batch_mutate_presult() throw() {}
01810
01811 InvalidRequestException ire;
01812 UnavailableException ue;
01813 TimedOutException te;
01814
01815 _Cassandra_batch_mutate_presult__isset __isset;
01816
01817 uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
01818
01819 };
01820
01821
01822 class Cassandra_truncate_args {
01823 public:
01824
01825 Cassandra_truncate_args() : cfname("") {
01826 }
01827
01828 virtual ~Cassandra_truncate_args() throw() {}
01829
01830 std::string cfname;
01831
01832 bool operator == (const Cassandra_truncate_args & rhs) const
01833 {
01834 if (!(cfname == rhs.cfname))
01835 return false;
01836 return true;
01837 }
01838 bool operator != (const Cassandra_truncate_args &rhs) const {
01839 return !(*this == rhs);
01840 }
01841
01842 bool operator < (const Cassandra_truncate_args & ) const;
01843
01844 uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
01845 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
01846
01847 };
01848
01849
01850 class Cassandra_truncate_pargs {
01851 public:
01852
01853
01854 virtual ~Cassandra_truncate_pargs() throw() {}
01855
01856 const std::string* cfname;
01857
01858 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
01859
01860 };
01861
01862 typedef struct _Cassandra_truncate_result__isset {
01863 _Cassandra_truncate_result__isset() : ire(false), ue(false) {}
01864 bool ire;
01865 bool ue;
01866 } _Cassandra_truncate_result__isset;
01867
01868 class Cassandra_truncate_result {
01869 public:
01870
01871 Cassandra_truncate_result() {
01872 }
01873
01874 virtual ~Cassandra_truncate_result() throw() {}
01875
01876 InvalidRequestException ire;
01877 UnavailableException ue;
01878
01879 _Cassandra_truncate_result__isset __isset;
01880
01881 bool operator == (const Cassandra_truncate_result & rhs) const
01882 {
01883 if (!(ire == rhs.ire))
01884 return false;
01885 if (!(ue == rhs.ue))
01886 return false;
01887 return true;
01888 }
01889 bool operator != (const Cassandra_truncate_result &rhs) const {
01890 return !(*this == rhs);
01891 }
01892
01893 bool operator < (const Cassandra_truncate_result & ) const;
01894
01895 uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
01896 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
01897
01898 };
01899
01900 typedef struct _Cassandra_truncate_presult__isset {
01901 _Cassandra_truncate_presult__isset() : ire(false), ue(false) {}
01902 bool ire;
01903 bool ue;
01904 } _Cassandra_truncate_presult__isset;
01905
01906 class Cassandra_truncate_presult {
01907 public:
01908
01909
01910 virtual ~Cassandra_truncate_presult() throw() {}
01911
01912 InvalidRequestException ire;
01913 UnavailableException ue;
01914
01915 _Cassandra_truncate_presult__isset __isset;
01916
01917 uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
01918
01919 };
01920
01921
01922 class Cassandra_describe_schema_versions_args {
01923 public:
01924
01925 Cassandra_describe_schema_versions_args() {
01926 }
01927
01928 virtual ~Cassandra_describe_schema_versions_args() throw() {}
01929
01930
01931 bool operator == (const Cassandra_describe_schema_versions_args & ) const
01932 {
01933 return true;
01934 }
01935 bool operator != (const Cassandra_describe_schema_versions_args &rhs) const {
01936 return !(*this == rhs);
01937 }
01938
01939 bool operator < (const Cassandra_describe_schema_versions_args & ) const;
01940
01941 uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
01942 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
01943
01944 };
01945
01946
01947 class Cassandra_describe_schema_versions_pargs {
01948 public:
01949
01950
01951 virtual ~Cassandra_describe_schema_versions_pargs() throw() {}
01952
01953
01954 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
01955
01956 };
01957
01958 typedef struct _Cassandra_describe_schema_versions_result__isset {
01959 _Cassandra_describe_schema_versions_result__isset() : success(false), ire(false) {}
01960 bool success;
01961 bool ire;
01962 } _Cassandra_describe_schema_versions_result__isset;
01963
01964 class Cassandra_describe_schema_versions_result {
01965 public:
01966
01967 Cassandra_describe_schema_versions_result() {
01968 }
01969
01970 virtual ~Cassandra_describe_schema_versions_result() throw() {}
01971
01972 std::map<std::string, std::vector<std::string> > success;
01973 InvalidRequestException ire;
01974
01975 _Cassandra_describe_schema_versions_result__isset __isset;
01976
01977 bool operator == (const Cassandra_describe_schema_versions_result & rhs) const
01978 {
01979 if (!(success == rhs.success))
01980 return false;
01981 if (!(ire == rhs.ire))
01982 return false;
01983 return true;
01984 }
01985 bool operator != (const Cassandra_describe_schema_versions_result &rhs) const {
01986 return !(*this == rhs);
01987 }
01988
01989 bool operator < (const Cassandra_describe_schema_versions_result & ) const;
01990
01991 uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
01992 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
01993
01994 };
01995
01996 typedef struct _Cassandra_describe_schema_versions_presult__isset {
01997 _Cassandra_describe_schema_versions_presult__isset() : success(false), ire(false) {}
01998 bool success;
01999 bool ire;
02000 } _Cassandra_describe_schema_versions_presult__isset;
02001
02002 class Cassandra_describe_schema_versions_presult {
02003 public:
02004
02005
02006 virtual ~Cassandra_describe_schema_versions_presult() throw() {}
02007
02008 std::map<std::string, std::vector<std::string> > * success;
02009 InvalidRequestException ire;
02010
02011 _Cassandra_describe_schema_versions_presult__isset __isset;
02012
02013 uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
02014
02015 };
02016
02017
02018 class Cassandra_describe_keyspaces_args {
02019 public:
02020
02021 Cassandra_describe_keyspaces_args() {
02022 }
02023
02024 virtual ~Cassandra_describe_keyspaces_args() throw() {}
02025
02026
02027 bool operator == (const Cassandra_describe_keyspaces_args & ) const
02028 {
02029 return true;
02030 }
02031 bool operator != (const Cassandra_describe_keyspaces_args &rhs) const {
02032 return !(*this == rhs);
02033 }
02034
02035 bool operator < (const Cassandra_describe_keyspaces_args & ) const;
02036
02037 uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
02038 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
02039
02040 };
02041
02042
02043 class Cassandra_describe_keyspaces_pargs {
02044 public:
02045
02046
02047 virtual ~Cassandra_describe_keyspaces_pargs() throw() {}
02048
02049
02050 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
02051
02052 };
02053
02054 typedef struct _Cassandra_describe_keyspaces_result__isset {
02055 _Cassandra_describe_keyspaces_result__isset() : success(false), ire(false) {}
02056 bool success;
02057 bool ire;
02058 } _Cassandra_describe_keyspaces_result__isset;
02059
02060 class Cassandra_describe_keyspaces_result {
02061 public:
02062
02063 Cassandra_describe_keyspaces_result() {
02064 }
02065
02066 virtual ~Cassandra_describe_keyspaces_result() throw() {}
02067
02068 std::vector<KsDef> success;
02069 InvalidRequestException ire;
02070
02071 _Cassandra_describe_keyspaces_result__isset __isset;
02072
02073 bool operator == (const Cassandra_describe_keyspaces_result & rhs) const
02074 {
02075 if (!(success == rhs.success))
02076 return false;
02077 if (!(ire == rhs.ire))
02078 return false;
02079 return true;
02080 }
02081 bool operator != (const Cassandra_describe_keyspaces_result &rhs) const {
02082 return !(*this == rhs);
02083 }
02084
02085 bool operator < (const Cassandra_describe_keyspaces_result & ) const;
02086
02087 uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
02088 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
02089
02090 };
02091
02092 typedef struct _Cassandra_describe_keyspaces_presult__isset {
02093 _Cassandra_describe_keyspaces_presult__isset() : success(false), ire(false) {}
02094 bool success;
02095 bool ire;
02096 } _Cassandra_describe_keyspaces_presult__isset;
02097
02098 class Cassandra_describe_keyspaces_presult {
02099 public:
02100
02101
02102 virtual ~Cassandra_describe_keyspaces_presult() throw() {}
02103
02104 std::vector<KsDef> * success;
02105 InvalidRequestException ire;
02106
02107 _Cassandra_describe_keyspaces_presult__isset __isset;
02108
02109 uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
02110
02111 };
02112
02113
02114 class Cassandra_describe_cluster_name_args {
02115 public:
02116
02117 Cassandra_describe_cluster_name_args() {
02118 }
02119
02120 virtual ~Cassandra_describe_cluster_name_args() throw() {}
02121
02122
02123 bool operator == (const Cassandra_describe_cluster_name_args & ) const
02124 {
02125 return true;
02126 }
02127 bool operator != (const Cassandra_describe_cluster_name_args &rhs) const {
02128 return !(*this == rhs);
02129 }
02130
02131 bool operator < (const Cassandra_describe_cluster_name_args & ) const;
02132
02133 uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
02134 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
02135
02136 };
02137
02138
02139 class Cassandra_describe_cluster_name_pargs {
02140 public:
02141
02142
02143 virtual ~Cassandra_describe_cluster_name_pargs() throw() {}
02144
02145
02146 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
02147
02148 };
02149
02150 typedef struct _Cassandra_describe_cluster_name_result__isset {
02151 _Cassandra_describe_cluster_name_result__isset() : success(false) {}
02152 bool success;
02153 } _Cassandra_describe_cluster_name_result__isset;
02154
02155 class Cassandra_describe_cluster_name_result {
02156 public:
02157
02158 Cassandra_describe_cluster_name_result() : success("") {
02159 }
02160
02161 virtual ~Cassandra_describe_cluster_name_result() throw() {}
02162
02163 std::string success;
02164
02165 _Cassandra_describe_cluster_name_result__isset __isset;
02166
02167 bool operator == (const Cassandra_describe_cluster_name_result & rhs) const
02168 {
02169 if (!(success == rhs.success))
02170 return false;
02171 return true;
02172 }
02173 bool operator != (const Cassandra_describe_cluster_name_result &rhs) const {
02174 return !(*this == rhs);
02175 }
02176
02177 bool operator < (const Cassandra_describe_cluster_name_result & ) const;
02178
02179 uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
02180 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
02181
02182 };
02183
02184 typedef struct _Cassandra_describe_cluster_name_presult__isset {
02185 _Cassandra_describe_cluster_name_presult__isset() : success(false) {}
02186 bool success;
02187 } _Cassandra_describe_cluster_name_presult__isset;
02188
02189 class Cassandra_describe_cluster_name_presult {
02190 public:
02191
02192
02193 virtual ~Cassandra_describe_cluster_name_presult() throw() {}
02194
02195 std::string* success;
02196
02197 _Cassandra_describe_cluster_name_presult__isset __isset;
02198
02199 uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
02200
02201 };
02202
02203
02204 class Cassandra_describe_version_args {
02205 public:
02206
02207 Cassandra_describe_version_args() {
02208 }
02209
02210 virtual ~Cassandra_describe_version_args() throw() {}
02211
02212
02213 bool operator == (const Cassandra_describe_version_args & ) const
02214 {
02215 return true;
02216 }
02217 bool operator != (const Cassandra_describe_version_args &rhs) const {
02218 return !(*this == rhs);
02219 }
02220
02221 bool operator < (const Cassandra_describe_version_args & ) const;
02222
02223 uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
02224 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
02225
02226 };
02227
02228
02229 class Cassandra_describe_version_pargs {
02230 public:
02231
02232
02233 virtual ~Cassandra_describe_version_pargs() throw() {}
02234
02235
02236 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
02237
02238 };
02239
02240 typedef struct _Cassandra_describe_version_result__isset {
02241 _Cassandra_describe_version_result__isset() : success(false) {}
02242 bool success;
02243 } _Cassandra_describe_version_result__isset;
02244
02245 class Cassandra_describe_version_result {
02246 public:
02247
02248 Cassandra_describe_version_result() : success("") {
02249 }
02250
02251 virtual ~Cassandra_describe_version_result() throw() {}
02252
02253 std::string success;
02254
02255 _Cassandra_describe_version_result__isset __isset;
02256
02257 bool operator == (const Cassandra_describe_version_result & rhs) const
02258 {
02259 if (!(success == rhs.success))
02260 return false;
02261 return true;
02262 }
02263 bool operator != (const Cassandra_describe_version_result &rhs) const {
02264 return !(*this == rhs);
02265 }
02266
02267 bool operator < (const Cassandra_describe_version_result & ) const;
02268
02269 uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
02270 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
02271
02272 };
02273
02274 typedef struct _Cassandra_describe_version_presult__isset {
02275 _Cassandra_describe_version_presult__isset() : success(false) {}
02276 bool success;
02277 } _Cassandra_describe_version_presult__isset;
02278
02279 class Cassandra_describe_version_presult {
02280 public:
02281
02282
02283 virtual ~Cassandra_describe_version_presult() throw() {}
02284
02285 std::string* success;
02286
02287 _Cassandra_describe_version_presult__isset __isset;
02288
02289 uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
02290
02291 };
02292
02293
02294 class Cassandra_describe_ring_args {
02295 public:
02296
02297 Cassandra_describe_ring_args() : keyspace("") {
02298 }
02299
02300 virtual ~Cassandra_describe_ring_args() throw() {}
02301
02302 std::string keyspace;
02303
02304 bool operator == (const Cassandra_describe_ring_args & rhs) const
02305 {
02306 if (!(keyspace == rhs.keyspace))
02307 return false;
02308 return true;
02309 }
02310 bool operator != (const Cassandra_describe_ring_args &rhs) const {
02311 return !(*this == rhs);
02312 }
02313
02314 bool operator < (const Cassandra_describe_ring_args & ) const;
02315
02316 uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
02317 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
02318
02319 };
02320
02321
02322 class Cassandra_describe_ring_pargs {
02323 public:
02324
02325
02326 virtual ~Cassandra_describe_ring_pargs() throw() {}
02327
02328 const std::string* keyspace;
02329
02330 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
02331
02332 };
02333
02334 typedef struct _Cassandra_describe_ring_result__isset {
02335 _Cassandra_describe_ring_result__isset() : success(false), ire(false) {}
02336 bool success;
02337 bool ire;
02338 } _Cassandra_describe_ring_result__isset;
02339
02340 class Cassandra_describe_ring_result {
02341 public:
02342
02343 Cassandra_describe_ring_result() {
02344 }
02345
02346 virtual ~Cassandra_describe_ring_result() throw() {}
02347
02348 std::vector<TokenRange> success;
02349 InvalidRequestException ire;
02350
02351 _Cassandra_describe_ring_result__isset __isset;
02352
02353 bool operator == (const Cassandra_describe_ring_result & rhs) const
02354 {
02355 if (!(success == rhs.success))
02356 return false;
02357 if (!(ire == rhs.ire))
02358 return false;
02359 return true;
02360 }
02361 bool operator != (const Cassandra_describe_ring_result &rhs) const {
02362 return !(*this == rhs);
02363 }
02364
02365 bool operator < (const Cassandra_describe_ring_result & ) const;
02366
02367 uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
02368 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
02369
02370 };
02371
02372 typedef struct _Cassandra_describe_ring_presult__isset {
02373 _Cassandra_describe_ring_presult__isset() : success(false), ire(false) {}
02374 bool success;
02375 bool ire;
02376 } _Cassandra_describe_ring_presult__isset;
02377
02378 class Cassandra_describe_ring_presult {
02379 public:
02380
02381
02382 virtual ~Cassandra_describe_ring_presult() throw() {}
02383
02384 std::vector<TokenRange> * success;
02385 InvalidRequestException ire;
02386
02387 _Cassandra_describe_ring_presult__isset __isset;
02388
02389 uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
02390
02391 };
02392
02393
02394 class Cassandra_describe_partitioner_args {
02395 public:
02396
02397 Cassandra_describe_partitioner_args() {
02398 }
02399
02400 virtual ~Cassandra_describe_partitioner_args() throw() {}
02401
02402
02403 bool operator == (const Cassandra_describe_partitioner_args & ) const
02404 {
02405 return true;
02406 }
02407 bool operator != (const Cassandra_describe_partitioner_args &rhs) const {
02408 return !(*this == rhs);
02409 }
02410
02411 bool operator < (const Cassandra_describe_partitioner_args & ) const;
02412
02413 uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
02414 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
02415
02416 };
02417
02418
02419 class Cassandra_describe_partitioner_pargs {
02420 public:
02421
02422
02423 virtual ~Cassandra_describe_partitioner_pargs() throw() {}
02424
02425
02426 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
02427
02428 };
02429
02430 typedef struct _Cassandra_describe_partitioner_result__isset {
02431 _Cassandra_describe_partitioner_result__isset() : success(false) {}
02432 bool success;
02433 } _Cassandra_describe_partitioner_result__isset;
02434
02435 class Cassandra_describe_partitioner_result {
02436 public:
02437
02438 Cassandra_describe_partitioner_result() : success("") {
02439 }
02440
02441 virtual ~Cassandra_describe_partitioner_result() throw() {}
02442
02443 std::string success;
02444
02445 _Cassandra_describe_partitioner_result__isset __isset;
02446
02447 bool operator == (const Cassandra_describe_partitioner_result & rhs) const
02448 {
02449 if (!(success == rhs.success))
02450 return false;
02451 return true;
02452 }
02453 bool operator != (const Cassandra_describe_partitioner_result &rhs) const {
02454 return !(*this == rhs);
02455 }
02456
02457 bool operator < (const Cassandra_describe_partitioner_result & ) const;
02458
02459 uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
02460 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
02461
02462 };
02463
02464 typedef struct _Cassandra_describe_partitioner_presult__isset {
02465 _Cassandra_describe_partitioner_presult__isset() : success(false) {}
02466 bool success;
02467 } _Cassandra_describe_partitioner_presult__isset;
02468
02469 class Cassandra_describe_partitioner_presult {
02470 public:
02471
02472
02473 virtual ~Cassandra_describe_partitioner_presult() throw() {}
02474
02475 std::string* success;
02476
02477 _Cassandra_describe_partitioner_presult__isset __isset;
02478
02479 uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
02480
02481 };
02482
02483
02484 class Cassandra_describe_snitch_args {
02485 public:
02486
02487 Cassandra_describe_snitch_args() {
02488 }
02489
02490 virtual ~Cassandra_describe_snitch_args() throw() {}
02491
02492
02493 bool operator == (const Cassandra_describe_snitch_args & ) const
02494 {
02495 return true;
02496 }
02497 bool operator != (const Cassandra_describe_snitch_args &rhs) const {
02498 return !(*this == rhs);
02499 }
02500
02501 bool operator < (const Cassandra_describe_snitch_args & ) const;
02502
02503 uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
02504 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
02505
02506 };
02507
02508
02509 class Cassandra_describe_snitch_pargs {
02510 public:
02511
02512
02513 virtual ~Cassandra_describe_snitch_pargs() throw() {}
02514
02515
02516 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
02517
02518 };
02519
02520 typedef struct _Cassandra_describe_snitch_result__isset {
02521 _Cassandra_describe_snitch_result__isset() : success(false) {}
02522 bool success;
02523 } _Cassandra_describe_snitch_result__isset;
02524
02525 class Cassandra_describe_snitch_result {
02526 public:
02527
02528 Cassandra_describe_snitch_result() : success("") {
02529 }
02530
02531 virtual ~Cassandra_describe_snitch_result() throw() {}
02532
02533 std::string success;
02534
02535 _Cassandra_describe_snitch_result__isset __isset;
02536
02537 bool operator == (const Cassandra_describe_snitch_result & rhs) const
02538 {
02539 if (!(success == rhs.success))
02540 return false;
02541 return true;
02542 }
02543 bool operator != (const Cassandra_describe_snitch_result &rhs) const {
02544 return !(*this == rhs);
02545 }
02546
02547 bool operator < (const Cassandra_describe_snitch_result & ) const;
02548
02549 uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
02550 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
02551
02552 };
02553
02554 typedef struct _Cassandra_describe_snitch_presult__isset {
02555 _Cassandra_describe_snitch_presult__isset() : success(false) {}
02556 bool success;
02557 } _Cassandra_describe_snitch_presult__isset;
02558
02559 class Cassandra_describe_snitch_presult {
02560 public:
02561
02562
02563 virtual ~Cassandra_describe_snitch_presult() throw() {}
02564
02565 std::string* success;
02566
02567 _Cassandra_describe_snitch_presult__isset __isset;
02568
02569 uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
02570
02571 };
02572
02573
02574 class Cassandra_describe_keyspace_args {
02575 public:
02576
02577 Cassandra_describe_keyspace_args() : keyspace("") {
02578 }
02579
02580 virtual ~Cassandra_describe_keyspace_args() throw() {}
02581
02582 std::string keyspace;
02583
02584 bool operator == (const Cassandra_describe_keyspace_args & rhs) const
02585 {
02586 if (!(keyspace == rhs.keyspace))
02587 return false;
02588 return true;
02589 }
02590 bool operator != (const Cassandra_describe_keyspace_args &rhs) const {
02591 return !(*this == rhs);
02592 }
02593
02594 bool operator < (const Cassandra_describe_keyspace_args & ) const;
02595
02596 uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
02597 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
02598
02599 };
02600
02601
02602 class Cassandra_describe_keyspace_pargs {
02603 public:
02604
02605
02606 virtual ~Cassandra_describe_keyspace_pargs() throw() {}
02607
02608 const std::string* keyspace;
02609
02610 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
02611
02612 };
02613
02614 typedef struct _Cassandra_describe_keyspace_result__isset {
02615 _Cassandra_describe_keyspace_result__isset() : success(false), nfe(false), ire(false) {}
02616 bool success;
02617 bool nfe;
02618 bool ire;
02619 } _Cassandra_describe_keyspace_result__isset;
02620
02621 class Cassandra_describe_keyspace_result {
02622 public:
02623
02624 Cassandra_describe_keyspace_result() {
02625 }
02626
02627 virtual ~Cassandra_describe_keyspace_result() throw() {}
02628
02629 KsDef success;
02630 NotFoundException nfe;
02631 InvalidRequestException ire;
02632
02633 _Cassandra_describe_keyspace_result__isset __isset;
02634
02635 bool operator == (const Cassandra_describe_keyspace_result & rhs) const
02636 {
02637 if (!(success == rhs.success))
02638 return false;
02639 if (!(nfe == rhs.nfe))
02640 return false;
02641 if (!(ire == rhs.ire))
02642 return false;
02643 return true;
02644 }
02645 bool operator != (const Cassandra_describe_keyspace_result &rhs) const {
02646 return !(*this == rhs);
02647 }
02648
02649 bool operator < (const Cassandra_describe_keyspace_result & ) const;
02650
02651 uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
02652 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
02653
02654 };
02655
02656 typedef struct _Cassandra_describe_keyspace_presult__isset {
02657 _Cassandra_describe_keyspace_presult__isset() : success(false), nfe(false), ire(false) {}
02658 bool success;
02659 bool nfe;
02660 bool ire;
02661 } _Cassandra_describe_keyspace_presult__isset;
02662
02663 class Cassandra_describe_keyspace_presult {
02664 public:
02665
02666
02667 virtual ~Cassandra_describe_keyspace_presult() throw() {}
02668
02669 KsDef* success;
02670 NotFoundException nfe;
02671 InvalidRequestException ire;
02672
02673 _Cassandra_describe_keyspace_presult__isset __isset;
02674
02675 uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
02676
02677 };
02678
02679
02680 class Cassandra_describe_splits_args {
02681 public:
02682
02683 Cassandra_describe_splits_args() : cfName(""), start_token(""), end_token(""), keys_per_split(0) {
02684 }
02685
02686 virtual ~Cassandra_describe_splits_args() throw() {}
02687
02688 std::string cfName;
02689 std::string start_token;
02690 std::string end_token;
02691 int32_t keys_per_split;
02692
02693 bool operator == (const Cassandra_describe_splits_args & rhs) const
02694 {
02695 if (!(cfName == rhs.cfName))
02696 return false;
02697 if (!(start_token == rhs.start_token))
02698 return false;
02699 if (!(end_token == rhs.end_token))
02700 return false;
02701 if (!(keys_per_split == rhs.keys_per_split))
02702 return false;
02703 return true;
02704 }
02705 bool operator != (const Cassandra_describe_splits_args &rhs) const {
02706 return !(*this == rhs);
02707 }
02708
02709 bool operator < (const Cassandra_describe_splits_args & ) const;
02710
02711 uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
02712 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
02713
02714 };
02715
02716
02717 class Cassandra_describe_splits_pargs {
02718 public:
02719
02720
02721 virtual ~Cassandra_describe_splits_pargs() throw() {}
02722
02723 const std::string* cfName;
02724 const std::string* start_token;
02725 const std::string* end_token;
02726 const int32_t* keys_per_split;
02727
02728 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
02729
02730 };
02731
02732 typedef struct _Cassandra_describe_splits_result__isset {
02733 _Cassandra_describe_splits_result__isset() : success(false), ire(false) {}
02734 bool success;
02735 bool ire;
02736 } _Cassandra_describe_splits_result__isset;
02737
02738 class Cassandra_describe_splits_result {
02739 public:
02740
02741 Cassandra_describe_splits_result() {
02742 }
02743
02744 virtual ~Cassandra_describe_splits_result() throw() {}
02745
02746 std::vector<std::string> success;
02747 InvalidRequestException ire;
02748
02749 _Cassandra_describe_splits_result__isset __isset;
02750
02751 bool operator == (const Cassandra_describe_splits_result & rhs) const
02752 {
02753 if (!(success == rhs.success))
02754 return false;
02755 if (!(ire == rhs.ire))
02756 return false;
02757 return true;
02758 }
02759 bool operator != (const Cassandra_describe_splits_result &rhs) const {
02760 return !(*this == rhs);
02761 }
02762
02763 bool operator < (const Cassandra_describe_splits_result & ) const;
02764
02765 uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
02766 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
02767
02768 };
02769
02770 typedef struct _Cassandra_describe_splits_presult__isset {
02771 _Cassandra_describe_splits_presult__isset() : success(false), ire(false) {}
02772 bool success;
02773 bool ire;
02774 } _Cassandra_describe_splits_presult__isset;
02775
02776 class Cassandra_describe_splits_presult {
02777 public:
02778
02779
02780 virtual ~Cassandra_describe_splits_presult() throw() {}
02781
02782 std::vector<std::string> * success;
02783 InvalidRequestException ire;
02784
02785 _Cassandra_describe_splits_presult__isset __isset;
02786
02787 uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
02788
02789 };
02790
02791
02792 class Cassandra_system_add_column_family_args {
02793 public:
02794
02795 Cassandra_system_add_column_family_args() {
02796 }
02797
02798 virtual ~Cassandra_system_add_column_family_args() throw() {}
02799
02800 CfDef cf_def;
02801
02802 bool operator == (const Cassandra_system_add_column_family_args & rhs) const
02803 {
02804 if (!(cf_def == rhs.cf_def))
02805 return false;
02806 return true;
02807 }
02808 bool operator != (const Cassandra_system_add_column_family_args &rhs) const {
02809 return !(*this == rhs);
02810 }
02811
02812 bool operator < (const Cassandra_system_add_column_family_args & ) const;
02813
02814 uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
02815 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
02816
02817 };
02818
02819
02820 class Cassandra_system_add_column_family_pargs {
02821 public:
02822
02823
02824 virtual ~Cassandra_system_add_column_family_pargs() throw() {}
02825
02826 const CfDef* cf_def;
02827
02828 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
02829
02830 };
02831
02832 typedef struct _Cassandra_system_add_column_family_result__isset {
02833 _Cassandra_system_add_column_family_result__isset() : success(false), ire(false), sde(false) {}
02834 bool success;
02835 bool ire;
02836 bool sde;
02837 } _Cassandra_system_add_column_family_result__isset;
02838
02839 class Cassandra_system_add_column_family_result {
02840 public:
02841
02842 Cassandra_system_add_column_family_result() : success("") {
02843 }
02844
02845 virtual ~Cassandra_system_add_column_family_result() throw() {}
02846
02847 std::string success;
02848 InvalidRequestException ire;
02849 SchemaDisagreementException sde;
02850
02851 _Cassandra_system_add_column_family_result__isset __isset;
02852
02853 bool operator == (const Cassandra_system_add_column_family_result & rhs) const
02854 {
02855 if (!(success == rhs.success))
02856 return false;
02857 if (!(ire == rhs.ire))
02858 return false;
02859 if (!(sde == rhs.sde))
02860 return false;
02861 return true;
02862 }
02863 bool operator != (const Cassandra_system_add_column_family_result &rhs) const {
02864 return !(*this == rhs);
02865 }
02866
02867 bool operator < (const Cassandra_system_add_column_family_result & ) const;
02868
02869 uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
02870 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
02871
02872 };
02873
02874 typedef struct _Cassandra_system_add_column_family_presult__isset {
02875 _Cassandra_system_add_column_family_presult__isset() : success(false), ire(false), sde(false) {}
02876 bool success;
02877 bool ire;
02878 bool sde;
02879 } _Cassandra_system_add_column_family_presult__isset;
02880
02881 class Cassandra_system_add_column_family_presult {
02882 public:
02883
02884
02885 virtual ~Cassandra_system_add_column_family_presult() throw() {}
02886
02887 std::string* success;
02888 InvalidRequestException ire;
02889 SchemaDisagreementException sde;
02890
02891 _Cassandra_system_add_column_family_presult__isset __isset;
02892
02893 uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
02894
02895 };
02896
02897
02898 class Cassandra_system_drop_column_family_args {
02899 public:
02900
02901 Cassandra_system_drop_column_family_args() : column_family("") {
02902 }
02903
02904 virtual ~Cassandra_system_drop_column_family_args() throw() {}
02905
02906 std::string column_family;
02907
02908 bool operator == (const Cassandra_system_drop_column_family_args & rhs) const
02909 {
02910 if (!(column_family == rhs.column_family))
02911 return false;
02912 return true;
02913 }
02914 bool operator != (const Cassandra_system_drop_column_family_args &rhs) const {
02915 return !(*this == rhs);
02916 }
02917
02918 bool operator < (const Cassandra_system_drop_column_family_args & ) const;
02919
02920 uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
02921 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
02922
02923 };
02924
02925
02926 class Cassandra_system_drop_column_family_pargs {
02927 public:
02928
02929
02930 virtual ~Cassandra_system_drop_column_family_pargs() throw() {}
02931
02932 const std::string* column_family;
02933
02934 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
02935
02936 };
02937
02938 typedef struct _Cassandra_system_drop_column_family_result__isset {
02939 _Cassandra_system_drop_column_family_result__isset() : success(false), ire(false), sde(false) {}
02940 bool success;
02941 bool ire;
02942 bool sde;
02943 } _Cassandra_system_drop_column_family_result__isset;
02944
02945 class Cassandra_system_drop_column_family_result {
02946 public:
02947
02948 Cassandra_system_drop_column_family_result() : success("") {
02949 }
02950
02951 virtual ~Cassandra_system_drop_column_family_result() throw() {}
02952
02953 std::string success;
02954 InvalidRequestException ire;
02955 SchemaDisagreementException sde;
02956
02957 _Cassandra_system_drop_column_family_result__isset __isset;
02958
02959 bool operator == (const Cassandra_system_drop_column_family_result & rhs) const
02960 {
02961 if (!(success == rhs.success))
02962 return false;
02963 if (!(ire == rhs.ire))
02964 return false;
02965 if (!(sde == rhs.sde))
02966 return false;
02967 return true;
02968 }
02969 bool operator != (const Cassandra_system_drop_column_family_result &rhs) const {
02970 return !(*this == rhs);
02971 }
02972
02973 bool operator < (const Cassandra_system_drop_column_family_result & ) const;
02974
02975 uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
02976 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
02977
02978 };
02979
02980 typedef struct _Cassandra_system_drop_column_family_presult__isset {
02981 _Cassandra_system_drop_column_family_presult__isset() : success(false), ire(false), sde(false) {}
02982 bool success;
02983 bool ire;
02984 bool sde;
02985 } _Cassandra_system_drop_column_family_presult__isset;
02986
02987 class Cassandra_system_drop_column_family_presult {
02988 public:
02989
02990
02991 virtual ~Cassandra_system_drop_column_family_presult() throw() {}
02992
02993 std::string* success;
02994 InvalidRequestException ire;
02995 SchemaDisagreementException sde;
02996
02997 _Cassandra_system_drop_column_family_presult__isset __isset;
02998
02999 uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
03000
03001 };
03002
03003
03004 class Cassandra_system_add_keyspace_args {
03005 public:
03006
03007 Cassandra_system_add_keyspace_args() {
03008 }
03009
03010 virtual ~Cassandra_system_add_keyspace_args() throw() {}
03011
03012 KsDef ks_def;
03013
03014 bool operator == (const Cassandra_system_add_keyspace_args & rhs) const
03015 {
03016 if (!(ks_def == rhs.ks_def))
03017 return false;
03018 return true;
03019 }
03020 bool operator != (const Cassandra_system_add_keyspace_args &rhs) const {
03021 return !(*this == rhs);
03022 }
03023
03024 bool operator < (const Cassandra_system_add_keyspace_args & ) const;
03025
03026 uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
03027 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
03028
03029 };
03030
03031
03032 class Cassandra_system_add_keyspace_pargs {
03033 public:
03034
03035
03036 virtual ~Cassandra_system_add_keyspace_pargs() throw() {}
03037
03038 const KsDef* ks_def;
03039
03040 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
03041
03042 };
03043
03044 typedef struct _Cassandra_system_add_keyspace_result__isset {
03045 _Cassandra_system_add_keyspace_result__isset() : success(false), ire(false), sde(false) {}
03046 bool success;
03047 bool ire;
03048 bool sde;
03049 } _Cassandra_system_add_keyspace_result__isset;
03050
03051 class Cassandra_system_add_keyspace_result {
03052 public:
03053
03054 Cassandra_system_add_keyspace_result() : success("") {
03055 }
03056
03057 virtual ~Cassandra_system_add_keyspace_result() throw() {}
03058
03059 std::string success;
03060 InvalidRequestException ire;
03061 SchemaDisagreementException sde;
03062
03063 _Cassandra_system_add_keyspace_result__isset __isset;
03064
03065 bool operator == (const Cassandra_system_add_keyspace_result & rhs) const
03066 {
03067 if (!(success == rhs.success))
03068 return false;
03069 if (!(ire == rhs.ire))
03070 return false;
03071 if (!(sde == rhs.sde))
03072 return false;
03073 return true;
03074 }
03075 bool operator != (const Cassandra_system_add_keyspace_result &rhs) const {
03076 return !(*this == rhs);
03077 }
03078
03079 bool operator < (const Cassandra_system_add_keyspace_result & ) const;
03080
03081 uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
03082 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
03083
03084 };
03085
03086 typedef struct _Cassandra_system_add_keyspace_presult__isset {
03087 _Cassandra_system_add_keyspace_presult__isset() : success(false), ire(false), sde(false) {}
03088 bool success;
03089 bool ire;
03090 bool sde;
03091 } _Cassandra_system_add_keyspace_presult__isset;
03092
03093 class Cassandra_system_add_keyspace_presult {
03094 public:
03095
03096
03097 virtual ~Cassandra_system_add_keyspace_presult() throw() {}
03098
03099 std::string* success;
03100 InvalidRequestException ire;
03101 SchemaDisagreementException sde;
03102
03103 _Cassandra_system_add_keyspace_presult__isset __isset;
03104
03105 uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
03106
03107 };
03108
03109
03110 class Cassandra_system_drop_keyspace_args {
03111 public:
03112
03113 Cassandra_system_drop_keyspace_args() : keyspace("") {
03114 }
03115
03116 virtual ~Cassandra_system_drop_keyspace_args() throw() {}
03117
03118 std::string keyspace;
03119
03120 bool operator == (const Cassandra_system_drop_keyspace_args & rhs) const
03121 {
03122 if (!(keyspace == rhs.keyspace))
03123 return false;
03124 return true;
03125 }
03126 bool operator != (const Cassandra_system_drop_keyspace_args &rhs) const {
03127 return !(*this == rhs);
03128 }
03129
03130 bool operator < (const Cassandra_system_drop_keyspace_args & ) const;
03131
03132 uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
03133 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
03134
03135 };
03136
03137
03138 class Cassandra_system_drop_keyspace_pargs {
03139 public:
03140
03141
03142 virtual ~Cassandra_system_drop_keyspace_pargs() throw() {}
03143
03144 const std::string* keyspace;
03145
03146 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
03147
03148 };
03149
03150 typedef struct _Cassandra_system_drop_keyspace_result__isset {
03151 _Cassandra_system_drop_keyspace_result__isset() : success(false), ire(false), sde(false) {}
03152 bool success;
03153 bool ire;
03154 bool sde;
03155 } _Cassandra_system_drop_keyspace_result__isset;
03156
03157 class Cassandra_system_drop_keyspace_result {
03158 public:
03159
03160 Cassandra_system_drop_keyspace_result() : success("") {
03161 }
03162
03163 virtual ~Cassandra_system_drop_keyspace_result() throw() {}
03164
03165 std::string success;
03166 InvalidRequestException ire;
03167 SchemaDisagreementException sde;
03168
03169 _Cassandra_system_drop_keyspace_result__isset __isset;
03170
03171 bool operator == (const Cassandra_system_drop_keyspace_result & rhs) const
03172 {
03173 if (!(success == rhs.success))
03174 return false;
03175 if (!(ire == rhs.ire))
03176 return false;
03177 if (!(sde == rhs.sde))
03178 return false;
03179 return true;
03180 }
03181 bool operator != (const Cassandra_system_drop_keyspace_result &rhs) const {
03182 return !(*this == rhs);
03183 }
03184
03185 bool operator < (const Cassandra_system_drop_keyspace_result & ) const;
03186
03187 uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
03188 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
03189
03190 };
03191
03192 typedef struct _Cassandra_system_drop_keyspace_presult__isset {
03193 _Cassandra_system_drop_keyspace_presult__isset() : success(false), ire(false), sde(false) {}
03194 bool success;
03195 bool ire;
03196 bool sde;
03197 } _Cassandra_system_drop_keyspace_presult__isset;
03198
03199 class Cassandra_system_drop_keyspace_presult {
03200 public:
03201
03202
03203 virtual ~Cassandra_system_drop_keyspace_presult() throw() {}
03204
03205 std::string* success;
03206 InvalidRequestException ire;
03207 SchemaDisagreementException sde;
03208
03209 _Cassandra_system_drop_keyspace_presult__isset __isset;
03210
03211 uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
03212
03213 };
03214
03215
03216 class Cassandra_system_update_keyspace_args {
03217 public:
03218
03219 Cassandra_system_update_keyspace_args() {
03220 }
03221
03222 virtual ~Cassandra_system_update_keyspace_args() throw() {}
03223
03224 KsDef ks_def;
03225
03226 bool operator == (const Cassandra_system_update_keyspace_args & rhs) const
03227 {
03228 if (!(ks_def == rhs.ks_def))
03229 return false;
03230 return true;
03231 }
03232 bool operator != (const Cassandra_system_update_keyspace_args &rhs) const {
03233 return !(*this == rhs);
03234 }
03235
03236 bool operator < (const Cassandra_system_update_keyspace_args & ) const;
03237
03238 uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
03239 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
03240
03241 };
03242
03243
03244 class Cassandra_system_update_keyspace_pargs {
03245 public:
03246
03247
03248 virtual ~Cassandra_system_update_keyspace_pargs() throw() {}
03249
03250 const KsDef* ks_def;
03251
03252 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
03253
03254 };
03255
03256 typedef struct _Cassandra_system_update_keyspace_result__isset {
03257 _Cassandra_system_update_keyspace_result__isset() : success(false), ire(false), sde(false) {}
03258 bool success;
03259 bool ire;
03260 bool sde;
03261 } _Cassandra_system_update_keyspace_result__isset;
03262
03263 class Cassandra_system_update_keyspace_result {
03264 public:
03265
03266 Cassandra_system_update_keyspace_result() : success("") {
03267 }
03268
03269 virtual ~Cassandra_system_update_keyspace_result() throw() {}
03270
03271 std::string success;
03272 InvalidRequestException ire;
03273 SchemaDisagreementException sde;
03274
03275 _Cassandra_system_update_keyspace_result__isset __isset;
03276
03277 bool operator == (const Cassandra_system_update_keyspace_result & rhs) const
03278 {
03279 if (!(success == rhs.success))
03280 return false;
03281 if (!(ire == rhs.ire))
03282 return false;
03283 if (!(sde == rhs.sde))
03284 return false;
03285 return true;
03286 }
03287 bool operator != (const Cassandra_system_update_keyspace_result &rhs) const {
03288 return !(*this == rhs);
03289 }
03290
03291 bool operator < (const Cassandra_system_update_keyspace_result & ) const;
03292
03293 uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
03294 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
03295
03296 };
03297
03298 typedef struct _Cassandra_system_update_keyspace_presult__isset {
03299 _Cassandra_system_update_keyspace_presult__isset() : success(false), ire(false), sde(false) {}
03300 bool success;
03301 bool ire;
03302 bool sde;
03303 } _Cassandra_system_update_keyspace_presult__isset;
03304
03305 class Cassandra_system_update_keyspace_presult {
03306 public:
03307
03308
03309 virtual ~Cassandra_system_update_keyspace_presult() throw() {}
03310
03311 std::string* success;
03312 InvalidRequestException ire;
03313 SchemaDisagreementException sde;
03314
03315 _Cassandra_system_update_keyspace_presult__isset __isset;
03316
03317 uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
03318
03319 };
03320
03321
03322 class Cassandra_system_update_column_family_args {
03323 public:
03324
03325 Cassandra_system_update_column_family_args() {
03326 }
03327
03328 virtual ~Cassandra_system_update_column_family_args() throw() {}
03329
03330 CfDef cf_def;
03331
03332 bool operator == (const Cassandra_system_update_column_family_args & rhs) const
03333 {
03334 if (!(cf_def == rhs.cf_def))
03335 return false;
03336 return true;
03337 }
03338 bool operator != (const Cassandra_system_update_column_family_args &rhs) const {
03339 return !(*this == rhs);
03340 }
03341
03342 bool operator < (const Cassandra_system_update_column_family_args & ) const;
03343
03344 uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
03345 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
03346
03347 };
03348
03349
03350 class Cassandra_system_update_column_family_pargs {
03351 public:
03352
03353
03354 virtual ~Cassandra_system_update_column_family_pargs() throw() {}
03355
03356 const CfDef* cf_def;
03357
03358 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
03359
03360 };
03361
03362 typedef struct _Cassandra_system_update_column_family_result__isset {
03363 _Cassandra_system_update_column_family_result__isset() : success(false), ire(false), sde(false) {}
03364 bool success;
03365 bool ire;
03366 bool sde;
03367 } _Cassandra_system_update_column_family_result__isset;
03368
03369 class Cassandra_system_update_column_family_result {
03370 public:
03371
03372 Cassandra_system_update_column_family_result() : success("") {
03373 }
03374
03375 virtual ~Cassandra_system_update_column_family_result() throw() {}
03376
03377 std::string success;
03378 InvalidRequestException ire;
03379 SchemaDisagreementException sde;
03380
03381 _Cassandra_system_update_column_family_result__isset __isset;
03382
03383 bool operator == (const Cassandra_system_update_column_family_result & rhs) const
03384 {
03385 if (!(success == rhs.success))
03386 return false;
03387 if (!(ire == rhs.ire))
03388 return false;
03389 if (!(sde == rhs.sde))
03390 return false;
03391 return true;
03392 }
03393 bool operator != (const Cassandra_system_update_column_family_result &rhs) const {
03394 return !(*this == rhs);
03395 }
03396
03397 bool operator < (const Cassandra_system_update_column_family_result & ) const;
03398
03399 uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
03400 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
03401
03402 };
03403
03404 typedef struct _Cassandra_system_update_column_family_presult__isset {
03405 _Cassandra_system_update_column_family_presult__isset() : success(false), ire(false), sde(false) {}
03406 bool success;
03407 bool ire;
03408 bool sde;
03409 } _Cassandra_system_update_column_family_presult__isset;
03410
03411 class Cassandra_system_update_column_family_presult {
03412 public:
03413
03414
03415 virtual ~Cassandra_system_update_column_family_presult() throw() {}
03416
03417 std::string* success;
03418 InvalidRequestException ire;
03419 SchemaDisagreementException sde;
03420
03421 _Cassandra_system_update_column_family_presult__isset __isset;
03422
03423 uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
03424
03425 };
03426
03427
03428 class Cassandra_execute_cql_query_args {
03429 public:
03430
03431 Cassandra_execute_cql_query_args() : query("") {
03432 }
03433
03434 virtual ~Cassandra_execute_cql_query_args() throw() {}
03435
03436 std::string query;
03437 Compression::type compression;
03438
03439 bool operator == (const Cassandra_execute_cql_query_args & rhs) const
03440 {
03441 if (!(query == rhs.query))
03442 return false;
03443 if (!(compression == rhs.compression))
03444 return false;
03445 return true;
03446 }
03447 bool operator != (const Cassandra_execute_cql_query_args &rhs) const {
03448 return !(*this == rhs);
03449 }
03450
03451 bool operator < (const Cassandra_execute_cql_query_args & ) const;
03452
03453 uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
03454 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
03455
03456 };
03457
03458
03459 class Cassandra_execute_cql_query_pargs {
03460 public:
03461
03462
03463 virtual ~Cassandra_execute_cql_query_pargs() throw() {}
03464
03465 const std::string* query;
03466 const Compression::type* compression;
03467
03468 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
03469
03470 };
03471
03472 typedef struct _Cassandra_execute_cql_query_result__isset {
03473 _Cassandra_execute_cql_query_result__isset() : success(false), ire(false), ue(false), te(false), sde(false) {}
03474 bool success;
03475 bool ire;
03476 bool ue;
03477 bool te;
03478 bool sde;
03479 } _Cassandra_execute_cql_query_result__isset;
03480
03481 class Cassandra_execute_cql_query_result {
03482 public:
03483
03484 Cassandra_execute_cql_query_result() {
03485 }
03486
03487 virtual ~Cassandra_execute_cql_query_result() throw() {}
03488
03489 CqlResult success;
03490 InvalidRequestException ire;
03491 UnavailableException ue;
03492 TimedOutException te;
03493 SchemaDisagreementException sde;
03494
03495 _Cassandra_execute_cql_query_result__isset __isset;
03496
03497 bool operator == (const Cassandra_execute_cql_query_result & rhs) const
03498 {
03499 if (!(success == rhs.success))
03500 return false;
03501 if (!(ire == rhs.ire))
03502 return false;
03503 if (!(ue == rhs.ue))
03504 return false;
03505 if (!(te == rhs.te))
03506 return false;
03507 if (!(sde == rhs.sde))
03508 return false;
03509 return true;
03510 }
03511 bool operator != (const Cassandra_execute_cql_query_result &rhs) const {
03512 return !(*this == rhs);
03513 }
03514
03515 bool operator < (const Cassandra_execute_cql_query_result & ) const;
03516
03517 uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
03518 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
03519
03520 };
03521
03522 typedef struct _Cassandra_execute_cql_query_presult__isset {
03523 _Cassandra_execute_cql_query_presult__isset() : success(false), ire(false), ue(false), te(false), sde(false) {}
03524 bool success;
03525 bool ire;
03526 bool ue;
03527 bool te;
03528 bool sde;
03529 } _Cassandra_execute_cql_query_presult__isset;
03530
03531 class Cassandra_execute_cql_query_presult {
03532 public:
03533
03534
03535 virtual ~Cassandra_execute_cql_query_presult() throw() {}
03536
03537 CqlResult* success;
03538 InvalidRequestException ire;
03539 UnavailableException ue;
03540 TimedOutException te;
03541 SchemaDisagreementException sde;
03542
03543 _Cassandra_execute_cql_query_presult__isset __isset;
03544
03545 uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
03546
03547 };
03548
03549 class CassandraClient : virtual public CassandraIf {
03550 public:
03551 CassandraClient(boost::shared_ptr< ::apache::thrift::protocol::TProtocol> prot) :
03552 piprot_(prot),
03553 poprot_(prot) {
03554 iprot_ = prot.get();
03555 oprot_ = prot.get();
03556 }
03557 CassandraClient(boost::shared_ptr< ::apache::thrift::protocol::TProtocol> iprot, boost::shared_ptr< ::apache::thrift::protocol::TProtocol> oprot) :
03558 piprot_(iprot),
03559 poprot_(oprot) {
03560 iprot_ = iprot.get();
03561 oprot_ = oprot.get();
03562 }
03563 boost::shared_ptr< ::apache::thrift::protocol::TProtocol> getInputProtocol() {
03564 return piprot_;
03565 }
03566 boost::shared_ptr< ::apache::thrift::protocol::TProtocol> getOutputProtocol() {
03567 return poprot_;
03568 }
03569 void login(const AuthenticationRequest& auth_request);
03570 void send_login(const AuthenticationRequest& auth_request);
03571 void recv_login();
03572 void set_keyspace(const std::string& keyspace);
03573 void send_set_keyspace(const std::string& keyspace);
03574 void recv_set_keyspace();
03575 void get(ColumnOrSuperColumn& _return, const std::string& key, const ColumnPath& column_path, const ConsistencyLevel::type consistency_level);
03576 void send_get(const std::string& key, const ColumnPath& column_path, const ConsistencyLevel::type consistency_level);
03577 void recv_get(ColumnOrSuperColumn& _return);
03578 void get_slice(std::vector<ColumnOrSuperColumn> & _return, const std::string& key, const ColumnParent& column_parent, const SlicePredicate& predicate, const ConsistencyLevel::type consistency_level);
03579 void send_get_slice(const std::string& key, const ColumnParent& column_parent, const SlicePredicate& predicate, const ConsistencyLevel::type consistency_level);
03580 void recv_get_slice(std::vector<ColumnOrSuperColumn> & _return);
03581 int32_t get_count(const std::string& key, const ColumnParent& column_parent, const SlicePredicate& predicate, const ConsistencyLevel::type consistency_level);
03582 void send_get_count(const std::string& key, const ColumnParent& column_parent, const SlicePredicate& predicate, const ConsistencyLevel::type consistency_level);
03583 int32_t recv_get_count();
03584 void 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);
03585 void send_multiget_slice(const std::vector<std::string> & keys, const ColumnParent& column_parent, const SlicePredicate& predicate, const ConsistencyLevel::type consistency_level);
03586 void recv_multiget_slice(std::map<std::string, std::vector<ColumnOrSuperColumn> > & _return);
03587 void 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);
03588 void send_multiget_count(const std::vector<std::string> & keys, const ColumnParent& column_parent, const SlicePredicate& predicate, const ConsistencyLevel::type consistency_level);
03589 void recv_multiget_count(std::map<std::string, int32_t> & _return);
03590 void get_range_slices(std::vector<KeySlice> & _return, const ColumnParent& column_parent, const SlicePredicate& predicate, const KeyRange& range, const ConsistencyLevel::type consistency_level);
03591 void send_get_range_slices(const ColumnParent& column_parent, const SlicePredicate& predicate, const KeyRange& range, const ConsistencyLevel::type consistency_level);
03592 void recv_get_range_slices(std::vector<KeySlice> & _return);
03593 void get_indexed_slices(std::vector<KeySlice> & _return, const ColumnParent& column_parent, const IndexClause& index_clause, const SlicePredicate& column_predicate, const ConsistencyLevel::type consistency_level);
03594 void send_get_indexed_slices(const ColumnParent& column_parent, const IndexClause& index_clause, const SlicePredicate& column_predicate, const ConsistencyLevel::type consistency_level);
03595 void recv_get_indexed_slices(std::vector<KeySlice> & _return);
03596 void insert(const std::string& key, const ColumnParent& column_parent, const Column& column, const ConsistencyLevel::type consistency_level);
03597 void send_insert(const std::string& key, const ColumnParent& column_parent, const Column& column, const ConsistencyLevel::type consistency_level);
03598 void recv_insert();
03599 void add(const std::string& key, const ColumnParent& column_parent, const CounterColumn& column, const ConsistencyLevel::type consistency_level);
03600 void send_add(const std::string& key, const ColumnParent& column_parent, const CounterColumn& column, const ConsistencyLevel::type consistency_level);
03601 void recv_add();
03602 void remove(const std::string& key, const ColumnPath& column_path, const int64_t timestamp, const ConsistencyLevel::type consistency_level);
03603 void send_remove(const std::string& key, const ColumnPath& column_path, const int64_t timestamp, const ConsistencyLevel::type consistency_level);
03604 void recv_remove();
03605 void remove_counter(const std::string& key, const ColumnPath& path, const ConsistencyLevel::type consistency_level);
03606 void send_remove_counter(const std::string& key, const ColumnPath& path, const ConsistencyLevel::type consistency_level);
03607 void recv_remove_counter();
03608 void batch_mutate(const std::map<std::string, std::map<std::string, std::vector<Mutation> > > & mutation_map, const ConsistencyLevel::type consistency_level);
03609 void send_batch_mutate(const std::map<std::string, std::map<std::string, std::vector<Mutation> > > & mutation_map, const ConsistencyLevel::type consistency_level);
03610 void recv_batch_mutate();
03611 void truncate(const std::string& cfname);
03612 void send_truncate(const std::string& cfname);
03613 void recv_truncate();
03614 void describe_schema_versions(std::map<std::string, std::vector<std::string> > & _return);
03615 void send_describe_schema_versions();
03616 void recv_describe_schema_versions(std::map<std::string, std::vector<std::string> > & _return);
03617 void describe_keyspaces(std::vector<KsDef> & _return);
03618 void send_describe_keyspaces();
03619 void recv_describe_keyspaces(std::vector<KsDef> & _return);
03620 void describe_cluster_name(std::string& _return);
03621 void send_describe_cluster_name();
03622 void recv_describe_cluster_name(std::string& _return);
03623 void describe_version(std::string& _return);
03624 void send_describe_version();
03625 void recv_describe_version(std::string& _return);
03626 void describe_ring(std::vector<TokenRange> & _return, const std::string& keyspace);
03627 void send_describe_ring(const std::string& keyspace);
03628 void recv_describe_ring(std::vector<TokenRange> & _return);
03629 void describe_partitioner(std::string& _return);
03630 void send_describe_partitioner();
03631 void recv_describe_partitioner(std::string& _return);
03632 void describe_snitch(std::string& _return);
03633 void send_describe_snitch();
03634 void recv_describe_snitch(std::string& _return);
03635 void describe_keyspace(KsDef& _return, const std::string& keyspace);
03636 void send_describe_keyspace(const std::string& keyspace);
03637 void recv_describe_keyspace(KsDef& _return);
03638 void 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);
03639 void send_describe_splits(const std::string& cfName, const std::string& start_token, const std::string& end_token, const int32_t keys_per_split);
03640 void recv_describe_splits(std::vector<std::string> & _return);
03641 void system_add_column_family(std::string& _return, const CfDef& cf_def);
03642 void send_system_add_column_family(const CfDef& cf_def);
03643 void recv_system_add_column_family(std::string& _return);
03644 void system_drop_column_family(std::string& _return, const std::string& column_family);
03645 void send_system_drop_column_family(const std::string& column_family);
03646 void recv_system_drop_column_family(std::string& _return);
03647 void system_add_keyspace(std::string& _return, const KsDef& ks_def);
03648 void send_system_add_keyspace(const KsDef& ks_def);
03649 void recv_system_add_keyspace(std::string& _return);
03650 void system_drop_keyspace(std::string& _return, const std::string& keyspace);
03651 void send_system_drop_keyspace(const std::string& keyspace);
03652 void recv_system_drop_keyspace(std::string& _return);
03653 void system_update_keyspace(std::string& _return, const KsDef& ks_def);
03654 void send_system_update_keyspace(const KsDef& ks_def);
03655 void recv_system_update_keyspace(std::string& _return);
03656 void system_update_column_family(std::string& _return, const CfDef& cf_def);
03657 void send_system_update_column_family(const CfDef& cf_def);
03658 void recv_system_update_column_family(std::string& _return);
03659 void execute_cql_query(CqlResult& _return, const std::string& query, const Compression::type compression);
03660 void send_execute_cql_query(const std::string& query, const Compression::type compression);
03661 void recv_execute_cql_query(CqlResult& _return);
03662 protected:
03663 boost::shared_ptr< ::apache::thrift::protocol::TProtocol> piprot_;
03664 boost::shared_ptr< ::apache::thrift::protocol::TProtocol> poprot_;
03665 ::apache::thrift::protocol::TProtocol* iprot_;
03666 ::apache::thrift::protocol::TProtocol* oprot_;
03667 };
03668
03669 class CassandraProcessor : virtual public ::apache::thrift::TProcessor {
03670 protected:
03671 boost::shared_ptr<CassandraIf> iface_;
03672 virtual bool process_fn(::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, std::string& fname, int32_t seqid, void* callContext);
03673 private:
03674 std::map<std::string, void (CassandraProcessor::*)(int32_t, ::apache::thrift::protocol::TProtocol*, ::apache::thrift::protocol::TProtocol*, void*)> processMap_;
03675 void process_login(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
03676 void process_set_keyspace(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
03677 void process_get(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
03678 void process_get_slice(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
03679 void process_get_count(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
03680 void process_multiget_slice(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
03681 void process_multiget_count(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
03682 void process_get_range_slices(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
03683 void process_get_indexed_slices(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
03684 void process_insert(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
03685 void process_add(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
03686 void process_remove(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
03687 void process_remove_counter(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
03688 void process_batch_mutate(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
03689 void process_truncate(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
03690 void process_describe_schema_versions(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
03691 void process_describe_keyspaces(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
03692 void process_describe_cluster_name(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
03693 void process_describe_version(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
03694 void process_describe_ring(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
03695 void process_describe_partitioner(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
03696 void process_describe_snitch(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
03697 void process_describe_keyspace(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
03698 void process_describe_splits(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
03699 void process_system_add_column_family(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
03700 void process_system_drop_column_family(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
03701 void process_system_add_keyspace(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
03702 void process_system_drop_keyspace(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
03703 void process_system_update_keyspace(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
03704 void process_system_update_column_family(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
03705 void process_execute_cql_query(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
03706 public:
03707 CassandraProcessor(boost::shared_ptr<CassandraIf> iface) :
03708 iface_(iface) {
03709 processMap_["login"] = &CassandraProcessor::process_login;
03710 processMap_["set_keyspace"] = &CassandraProcessor::process_set_keyspace;
03711 processMap_["get"] = &CassandraProcessor::process_get;
03712 processMap_["get_slice"] = &CassandraProcessor::process_get_slice;
03713 processMap_["get_count"] = &CassandraProcessor::process_get_count;
03714 processMap_["multiget_slice"] = &CassandraProcessor::process_multiget_slice;
03715 processMap_["multiget_count"] = &CassandraProcessor::process_multiget_count;
03716 processMap_["get_range_slices"] = &CassandraProcessor::process_get_range_slices;
03717 processMap_["get_indexed_slices"] = &CassandraProcessor::process_get_indexed_slices;
03718 processMap_["insert"] = &CassandraProcessor::process_insert;
03719 processMap_["add"] = &CassandraProcessor::process_add;
03720 processMap_["remove"] = &CassandraProcessor::process_remove;
03721 processMap_["remove_counter"] = &CassandraProcessor::process_remove_counter;
03722 processMap_["batch_mutate"] = &CassandraProcessor::process_batch_mutate;
03723 processMap_["truncate"] = &CassandraProcessor::process_truncate;
03724 processMap_["describe_schema_versions"] = &CassandraProcessor::process_describe_schema_versions;
03725 processMap_["describe_keyspaces"] = &CassandraProcessor::process_describe_keyspaces;
03726 processMap_["describe_cluster_name"] = &CassandraProcessor::process_describe_cluster_name;
03727 processMap_["describe_version"] = &CassandraProcessor::process_describe_version;
03728 processMap_["describe_ring"] = &CassandraProcessor::process_describe_ring;
03729 processMap_["describe_partitioner"] = &CassandraProcessor::process_describe_partitioner;
03730 processMap_["describe_snitch"] = &CassandraProcessor::process_describe_snitch;
03731 processMap_["describe_keyspace"] = &CassandraProcessor::process_describe_keyspace;
03732 processMap_["describe_splits"] = &CassandraProcessor::process_describe_splits;
03733 processMap_["system_add_column_family"] = &CassandraProcessor::process_system_add_column_family;
03734 processMap_["system_drop_column_family"] = &CassandraProcessor::process_system_drop_column_family;
03735 processMap_["system_add_keyspace"] = &CassandraProcessor::process_system_add_keyspace;
03736 processMap_["system_drop_keyspace"] = &CassandraProcessor::process_system_drop_keyspace;
03737 processMap_["system_update_keyspace"] = &CassandraProcessor::process_system_update_keyspace;
03738 processMap_["system_update_column_family"] = &CassandraProcessor::process_system_update_column_family;
03739 processMap_["execute_cql_query"] = &CassandraProcessor::process_execute_cql_query;
03740 }
03741
03742 virtual bool process(boost::shared_ptr< ::apache::thrift::protocol::TProtocol> piprot, boost::shared_ptr< ::apache::thrift::protocol::TProtocol> poprot, void* callContext);
03743 virtual ~CassandraProcessor() {}
03744 };
03745
03746 class CassandraMultiface : virtual public CassandraIf {
03747 public:
03748 CassandraMultiface(std::vector<boost::shared_ptr<CassandraIf> >& ifaces) : ifaces_(ifaces) {
03749 }
03750 virtual ~CassandraMultiface() {}
03751 protected:
03752 std::vector<boost::shared_ptr<CassandraIf> > ifaces_;
03753 CassandraMultiface() {}
03754 void add(boost::shared_ptr<CassandraIf> iface) {
03755 ifaces_.push_back(iface);
03756 }
03757 public:
03758 void login(const AuthenticationRequest& auth_request) {
03759 uint32_t sz = ifaces_.size();
03760 for (uint32_t i = 0; i < sz; ++i) {
03761 ifaces_[i]->login(auth_request);
03762 }
03763 }
03764
03765 void set_keyspace(const std::string& keyspace) {
03766 uint32_t sz = ifaces_.size();
03767 for (uint32_t i = 0; i < sz; ++i) {
03768 ifaces_[i]->set_keyspace(keyspace);
03769 }
03770 }
03771
03772 void get(ColumnOrSuperColumn& _return, const std::string& key, const ColumnPath& column_path, const ConsistencyLevel::type consistency_level) {
03773 uint32_t sz = ifaces_.size();
03774 for (uint32_t i = 0; i < sz; ++i) {
03775 if (i == sz - 1) {
03776 ifaces_[i]->get(_return, key, column_path, consistency_level);
03777 return;
03778 } else {
03779 ifaces_[i]->get(_return, key, column_path, consistency_level);
03780 }
03781 }
03782 }
03783
03784 void get_slice(std::vector<ColumnOrSuperColumn> & _return, const std::string& key, const ColumnParent& column_parent, const SlicePredicate& predicate, const ConsistencyLevel::type consistency_level) {
03785 uint32_t sz = ifaces_.size();
03786 for (uint32_t i = 0; i < sz; ++i) {
03787 if (i == sz - 1) {
03788 ifaces_[i]->get_slice(_return, key, column_parent, predicate, consistency_level);
03789 return;
03790 } else {
03791 ifaces_[i]->get_slice(_return, key, column_parent, predicate, consistency_level);
03792 }
03793 }
03794 }
03795
03796 int32_t get_count(const std::string& key, const ColumnParent& column_parent, const SlicePredicate& predicate, const ConsistencyLevel::type consistency_level) {
03797 uint32_t sz = ifaces_.size();
03798 for (uint32_t i = 0; i < sz; ++i) {
03799 if (i == sz - 1) {
03800 return ifaces_[i]->get_count(key, column_parent, predicate, consistency_level);
03801 } else {
03802 ifaces_[i]->get_count(key, column_parent, predicate, consistency_level);
03803 }
03804 }
03805 }
03806
03807 void 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) {
03808 uint32_t sz = ifaces_.size();
03809 for (uint32_t i = 0; i < sz; ++i) {
03810 if (i == sz - 1) {
03811 ifaces_[i]->multiget_slice(_return, keys, column_parent, predicate, consistency_level);
03812 return;
03813 } else {
03814 ifaces_[i]->multiget_slice(_return, keys, column_parent, predicate, consistency_level);
03815 }
03816 }
03817 }
03818
03819 void 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) {
03820 uint32_t sz = ifaces_.size();
03821 for (uint32_t i = 0; i < sz; ++i) {
03822 if (i == sz - 1) {
03823 ifaces_[i]->multiget_count(_return, keys, column_parent, predicate, consistency_level);
03824 return;
03825 } else {
03826 ifaces_[i]->multiget_count(_return, keys, column_parent, predicate, consistency_level);
03827 }
03828 }
03829 }
03830
03831 void get_range_slices(std::vector<KeySlice> & _return, const ColumnParent& column_parent, const SlicePredicate& predicate, const KeyRange& range, const ConsistencyLevel::type consistency_level) {
03832 uint32_t sz = ifaces_.size();
03833 for (uint32_t i = 0; i < sz; ++i) {
03834 if (i == sz - 1) {
03835 ifaces_[i]->get_range_slices(_return, column_parent, predicate, range, consistency_level);
03836 return;
03837 } else {
03838 ifaces_[i]->get_range_slices(_return, column_parent, predicate, range, consistency_level);
03839 }
03840 }
03841 }
03842
03843 void get_indexed_slices(std::vector<KeySlice> & _return, const ColumnParent& column_parent, const IndexClause& index_clause, const SlicePredicate& column_predicate, const ConsistencyLevel::type consistency_level) {
03844 uint32_t sz = ifaces_.size();
03845 for (uint32_t i = 0; i < sz; ++i) {
03846 if (i == sz - 1) {
03847 ifaces_[i]->get_indexed_slices(_return, column_parent, index_clause, column_predicate, consistency_level);
03848 return;
03849 } else {
03850 ifaces_[i]->get_indexed_slices(_return, column_parent, index_clause, column_predicate, consistency_level);
03851 }
03852 }
03853 }
03854
03855 void insert(const std::string& key, const ColumnParent& column_parent, const Column& column, const ConsistencyLevel::type consistency_level) {
03856 uint32_t sz = ifaces_.size();
03857 for (uint32_t i = 0; i < sz; ++i) {
03858 ifaces_[i]->insert(key, column_parent, column, consistency_level);
03859 }
03860 }
03861
03862 void add(const std::string& key, const ColumnParent& column_parent, const CounterColumn& column, const ConsistencyLevel::type consistency_level) {
03863 uint32_t sz = ifaces_.size();
03864 for (uint32_t i = 0; i < sz; ++i) {
03865 ifaces_[i]->add(key, column_parent, column, consistency_level);
03866 }
03867 }
03868
03869 void remove(const std::string& key, const ColumnPath& column_path, const int64_t timestamp, const ConsistencyLevel::type consistency_level) {
03870 uint32_t sz = ifaces_.size();
03871 for (uint32_t i = 0; i < sz; ++i) {
03872 ifaces_[i]->remove(key, column_path, timestamp, consistency_level);
03873 }
03874 }
03875
03876 void remove_counter(const std::string& key, const ColumnPath& path, const ConsistencyLevel::type consistency_level) {
03877 uint32_t sz = ifaces_.size();
03878 for (uint32_t i = 0; i < sz; ++i) {
03879 ifaces_[i]->remove_counter(key, path, consistency_level);
03880 }
03881 }
03882
03883 void batch_mutate(const std::map<std::string, std::map<std::string, std::vector<Mutation> > > & mutation_map, const ConsistencyLevel::type consistency_level) {
03884 uint32_t sz = ifaces_.size();
03885 for (uint32_t i = 0; i < sz; ++i) {
03886 ifaces_[i]->batch_mutate(mutation_map, consistency_level);
03887 }
03888 }
03889
03890 void truncate(const std::string& cfname) {
03891 uint32_t sz = ifaces_.size();
03892 for (uint32_t i = 0; i < sz; ++i) {
03893 ifaces_[i]->truncate(cfname);
03894 }
03895 }
03896
03897 void describe_schema_versions(std::map<std::string, std::vector<std::string> > & _return) {
03898 uint32_t sz = ifaces_.size();
03899 for (uint32_t i = 0; i < sz; ++i) {
03900 if (i == sz - 1) {
03901 ifaces_[i]->describe_schema_versions(_return);
03902 return;
03903 } else {
03904 ifaces_[i]->describe_schema_versions(_return);
03905 }
03906 }
03907 }
03908
03909 void describe_keyspaces(std::vector<KsDef> & _return) {
03910 uint32_t sz = ifaces_.size();
03911 for (uint32_t i = 0; i < sz; ++i) {
03912 if (i == sz - 1) {
03913 ifaces_[i]->describe_keyspaces(_return);
03914 return;
03915 } else {
03916 ifaces_[i]->describe_keyspaces(_return);
03917 }
03918 }
03919 }
03920
03921 void describe_cluster_name(std::string& _return) {
03922 uint32_t sz = ifaces_.size();
03923 for (uint32_t i = 0; i < sz; ++i) {
03924 if (i == sz - 1) {
03925 ifaces_[i]->describe_cluster_name(_return);
03926 return;
03927 } else {
03928 ifaces_[i]->describe_cluster_name(_return);
03929 }
03930 }
03931 }
03932
03933 void describe_version(std::string& _return) {
03934 uint32_t sz = ifaces_.size();
03935 for (uint32_t i = 0; i < sz; ++i) {
03936 if (i == sz - 1) {
03937 ifaces_[i]->describe_version(_return);
03938 return;
03939 } else {
03940 ifaces_[i]->describe_version(_return);
03941 }
03942 }
03943 }
03944
03945 void describe_ring(std::vector<TokenRange> & _return, const std::string& keyspace) {
03946 uint32_t sz = ifaces_.size();
03947 for (uint32_t i = 0; i < sz; ++i) {
03948 if (i == sz - 1) {
03949 ifaces_[i]->describe_ring(_return, keyspace);
03950 return;
03951 } else {
03952 ifaces_[i]->describe_ring(_return, keyspace);
03953 }
03954 }
03955 }
03956
03957 void describe_partitioner(std::string& _return) {
03958 uint32_t sz = ifaces_.size();
03959 for (uint32_t i = 0; i < sz; ++i) {
03960 if (i == sz - 1) {
03961 ifaces_[i]->describe_partitioner(_return);
03962 return;
03963 } else {
03964 ifaces_[i]->describe_partitioner(_return);
03965 }
03966 }
03967 }
03968
03969 void describe_snitch(std::string& _return) {
03970 uint32_t sz = ifaces_.size();
03971 for (uint32_t i = 0; i < sz; ++i) {
03972 if (i == sz - 1) {
03973 ifaces_[i]->describe_snitch(_return);
03974 return;
03975 } else {
03976 ifaces_[i]->describe_snitch(_return);
03977 }
03978 }
03979 }
03980
03981 void describe_keyspace(KsDef& _return, const std::string& keyspace) {
03982 uint32_t sz = ifaces_.size();
03983 for (uint32_t i = 0; i < sz; ++i) {
03984 if (i == sz - 1) {
03985 ifaces_[i]->describe_keyspace(_return, keyspace);
03986 return;
03987 } else {
03988 ifaces_[i]->describe_keyspace(_return, keyspace);
03989 }
03990 }
03991 }
03992
03993 void 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) {
03994 uint32_t sz = ifaces_.size();
03995 for (uint32_t i = 0; i < sz; ++i) {
03996 if (i == sz - 1) {
03997 ifaces_[i]->describe_splits(_return, cfName, start_token, end_token, keys_per_split);
03998 return;
03999 } else {
04000 ifaces_[i]->describe_splits(_return, cfName, start_token, end_token, keys_per_split);
04001 }
04002 }
04003 }
04004
04005 void system_add_column_family(std::string& _return, const CfDef& cf_def) {
04006 uint32_t sz = ifaces_.size();
04007 for (uint32_t i = 0; i < sz; ++i) {
04008 if (i == sz - 1) {
04009 ifaces_[i]->system_add_column_family(_return, cf_def);
04010 return;
04011 } else {
04012 ifaces_[i]->system_add_column_family(_return, cf_def);
04013 }
04014 }
04015 }
04016
04017 void system_drop_column_family(std::string& _return, const std::string& column_family) {
04018 uint32_t sz = ifaces_.size();
04019 for (uint32_t i = 0; i < sz; ++i) {
04020 if (i == sz - 1) {
04021 ifaces_[i]->system_drop_column_family(_return, column_family);
04022 return;
04023 } else {
04024 ifaces_[i]->system_drop_column_family(_return, column_family);
04025 }
04026 }
04027 }
04028
04029 void system_add_keyspace(std::string& _return, const KsDef& ks_def) {
04030 uint32_t sz = ifaces_.size();
04031 for (uint32_t i = 0; i < sz; ++i) {
04032 if (i == sz - 1) {
04033 ifaces_[i]->system_add_keyspace(_return, ks_def);
04034 return;
04035 } else {
04036 ifaces_[i]->system_add_keyspace(_return, ks_def);
04037 }
04038 }
04039 }
04040
04041 void system_drop_keyspace(std::string& _return, const std::string& keyspace) {
04042 uint32_t sz = ifaces_.size();
04043 for (uint32_t i = 0; i < sz; ++i) {
04044 if (i == sz - 1) {
04045 ifaces_[i]->system_drop_keyspace(_return, keyspace);
04046 return;
04047 } else {
04048 ifaces_[i]->system_drop_keyspace(_return, keyspace);
04049 }
04050 }
04051 }
04052
04053 void system_update_keyspace(std::string& _return, const KsDef& ks_def) {
04054 uint32_t sz = ifaces_.size();
04055 for (uint32_t i = 0; i < sz; ++i) {
04056 if (i == sz - 1) {
04057 ifaces_[i]->system_update_keyspace(_return, ks_def);
04058 return;
04059 } else {
04060 ifaces_[i]->system_update_keyspace(_return, ks_def);
04061 }
04062 }
04063 }
04064
04065 void system_update_column_family(std::string& _return, const CfDef& cf_def) {
04066 uint32_t sz = ifaces_.size();
04067 for (uint32_t i = 0; i < sz; ++i) {
04068 if (i == sz - 1) {
04069 ifaces_[i]->system_update_column_family(_return, cf_def);
04070 return;
04071 } else {
04072 ifaces_[i]->system_update_column_family(_return, cf_def);
04073 }
04074 }
04075 }
04076
04077 void execute_cql_query(CqlResult& _return, const std::string& query, const Compression::type compression) {
04078 uint32_t sz = ifaces_.size();
04079 for (uint32_t i = 0; i < sz; ++i) {
04080 if (i == sz - 1) {
04081 ifaces_[i]->execute_cql_query(_return, query, compression);
04082 return;
04083 } else {
04084 ifaces_[i]->execute_cql_query(_return, query, compression);
04085 }
04086 }
04087 }
04088
04089 };
04090
04091 }}}
04092
04093 #endif
