1 /** 2 * Autogenerated by Thrift Compiler (0.8.0) 3 * 4 * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING 5 * @generated 6 */ 7 #ifndef Cassandra_H 8 #define Cassandra_H 9 10 #include <thrift/TProcessor.h> 11 #include "cassandra_types.h" 12 13 namespace org { namespace apache { namespace cassandra { 14 15 class CassandraIf { 16 public: 17 virtual ~CassandraIf() {} 18 virtual void login(const AuthenticationRequest& auth_request) = 0; 19 virtual void set_keyspace(const std::string& keyspace) = 0; 20 virtual void get(ColumnOrSuperColumn& _return, const std::string& key, const ColumnPath& column_path, const ConsistencyLevel::type consistency_level) = 0; 21 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; 22 virtual int32_t get_count(const std::string& key, const ColumnParent& column_parent, const SlicePredicate& predicate, const ConsistencyLevel::type consistency_level) = 0; 23 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; 24 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; 25 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; 26 virtual void get_paged_slice(std::vector<KeySlice> & _return, const std::string& column_family, const KeyRange& range, const std::string& start_column, const ConsistencyLevel::type consistency_level) = 0; 27 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; 28 virtual void insert(const std::string& key, const ColumnParent& column_parent, const Column& column, const ConsistencyLevel::type consistency_level) = 0; 29 virtual void add(const std::string& key, const ColumnParent& column_parent, const CounterColumn& column, const ConsistencyLevel::type consistency_level) = 0; 30 virtual void remove(const std::string& key, const ColumnPath& column_path, const int64_t timestamp, const ConsistencyLevel::type consistency_level) = 0; 31 virtual void remove_counter(const std::string& key, const ColumnPath& path, const ConsistencyLevel::type consistency_level) = 0; 32 virtual void batch_mutate(const std::map<std::string, std::map<std::string, std::vector<Mutation> > > & mutation_map, const ConsistencyLevel::type consistency_level) = 0; 33 virtual void truncate(const std::string& cfname) = 0; 34 virtual void describe_schema_versions(std::map<std::string, std::vector<std::string> > & _return) = 0; 35 virtual void describe_keyspaces(std::vector<KsDef> & _return) = 0; 36 virtual void describe_cluster_name(std::string& _return) = 0; 37 virtual void describe_version(std::string& _return) = 0; 38 virtual void describe_ring(std::vector<TokenRange> & _return, const std::string& keyspace) = 0; 39 virtual void describe_token_map(std::map<std::string, std::string> & _return) = 0; 40 virtual void describe_partitioner(std::string& _return) = 0; 41 virtual void describe_snitch(std::string& _return) = 0; 42 virtual void describe_keyspace(KsDef& _return, const std::string& keyspace) = 0; 43 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; 44 virtual void system_add_column_family(std::string& _return, const CfDef& cf_def) = 0; 45 virtual void system_drop_column_family(std::string& _return, const std::string& column_family) = 0; 46 virtual void system_add_keyspace(std::string& _return, const KsDef& ks_def) = 0; 47 virtual void system_drop_keyspace(std::string& _return, const std::string& keyspace) = 0; 48 virtual void system_update_keyspace(std::string& _return, const KsDef& ks_def) = 0; 49 virtual void system_update_column_family(std::string& _return, const CfDef& cf_def) = 0; 50 virtual void execute_cql_query(CqlResult& _return, const std::string& query, const Compression::type compression) = 0; 51 virtual void prepare_cql_query(CqlPreparedResult& _return, const std::string& query, const Compression::type compression) = 0; 52 virtual void execute_prepared_cql_query(CqlResult& _return, const int32_t itemId, const std::vector<std::string> & values) = 0; 53 virtual void set_cql_version(const std::string& version) = 0; 54 }; 55 56 class CassandraIfFactory { 57 public: 58 typedef CassandraIf Handler; 59 60 virtual ~CassandraIfFactory() {} 61 62 virtual CassandraIf* getHandler(const ::apache::thrift::TConnectionInfo& connInfo) = 0; 63 virtual void releaseHandler(CassandraIf* /* handler */) = 0; 64 }; 65 66 class CassandraIfSingletonFactory : virtual public CassandraIfFactory { 67 public: 68 CassandraIfSingletonFactory(const boost::shared_ptr<CassandraIf>& iface) : iface_(iface) {} 69 virtual ~CassandraIfSingletonFactory() {} 70 71 virtual CassandraIf* getHandler(const ::apache::thrift::TConnectionInfo&) { 72 return iface_.get(); 73 } 74 virtual void releaseHandler(CassandraIf* /* handler */) {} 75 76 protected: 77 boost::shared_ptr<CassandraIf> iface_; 78 }; 79 80 class CassandraNull : virtual public CassandraIf { 81 public: 82 virtual ~CassandraNull() {} 83 void login(const AuthenticationRequest& /* auth_request */) { 84 return; 85 } 86 void set_keyspace(const std::string& /* keyspace */) { 87 return; 88 } 89 void get(ColumnOrSuperColumn& /* _return */, const std::string& /* key */, const ColumnPath& /* column_path */, const ConsistencyLevel::type /* consistency_level */) { 90 return; 91 } 92 void get_slice(std::vector<ColumnOrSuperColumn> & /* _return */, const std::string& /* key */, const ColumnParent& /* column_parent */, const SlicePredicate& /* predicate */, const ConsistencyLevel::type /* consistency_level */) { 93 return; 94 } 95 int32_t get_count(const std::string& /* key */, const ColumnParent& /* column_parent */, const SlicePredicate& /* predicate */, const ConsistencyLevel::type /* consistency_level */) { 96 int32_t _return = 0; 97 return _return; 98 } 99 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 */) { 100 return; 101 } 102 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 */) { 103 return; 104 } 105 void get_range_slices(std::vector<KeySlice> & /* _return */, const ColumnParent& /* column_parent */, const SlicePredicate& /* predicate */, const KeyRange& /* range */, const ConsistencyLevel::type /* consistency_level */) { 106 return; 107 } 108 void get_paged_slice(std::vector<KeySlice> & /* _return */, const std::string& /* column_family */, const KeyRange& /* range */, const std::string& /* start_column */, const ConsistencyLevel::type /* consistency_level */) { 109 return; 110 } 111 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 */) { 112 return; 113 } 114 void insert(const std::string& /* key */, const ColumnParent& /* column_parent */, const Column& /* column */, const ConsistencyLevel::type /* consistency_level */) { 115 return; 116 } 117 void add(const std::string& /* key */, const ColumnParent& /* column_parent */, const CounterColumn& /* column */, const ConsistencyLevel::type /* consistency_level */) { 118 return; 119 } 120 void remove(const std::string& /* key */, const ColumnPath& /* column_path */, const int64_t /* timestamp */, const ConsistencyLevel::type /* consistency_level */) { 121 return; 122 } 123 void remove_counter(const std::string& /* key */, const ColumnPath& /* path */, const ConsistencyLevel::type /* consistency_level */) { 124 return; 125 } 126 void batch_mutate(const std::map<std::string, std::map<std::string, std::vector<Mutation> > > & /* mutation_map */, const ConsistencyLevel::type /* consistency_level */) { 127 return; 128 } 129 void truncate(const std::string& /* cfname */) { 130 return; 131 } 132 void describe_schema_versions(std::map<std::string, std::vector<std::string> > & /* _return */) { 133 return; 134 } 135 void describe_keyspaces(std::vector<KsDef> & /* _return */) { 136 return; 137 } 138 void describe_cluster_name(std::string& /* _return */) { 139 return; 140 } 141 void describe_version(std::string& /* _return */) { 142 return; 143 } 144 void describe_ring(std::vector<TokenRange> & /* _return */, const std::string& /* keyspace */) { 145 return; 146 } 147 void describe_token_map(std::map<std::string, std::string> & /* _return */) { 148 return; 149 } 150 void describe_partitioner(std::string& /* _return */) { 151 return; 152 } 153 void describe_snitch(std::string& /* _return */) { 154 return; 155 } 156 void describe_keyspace(KsDef& /* _return */, const std::string& /* keyspace */) { 157 return; 158 } 159 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 */) { 160 return; 161 } 162 void system_add_column_family(std::string& /* _return */, const CfDef& /* cf_def */) { 163 return; 164 } 165 void system_drop_column_family(std::string& /* _return */, const std::string& /* column_family */) { 166 return; 167 } 168 void system_add_keyspace(std::string& /* _return */, const KsDef& /* ks_def */) { 169 return; 170 } 171 void system_drop_keyspace(std::string& /* _return */, const std::string& /* keyspace */) { 172 return; 173 } 174 void system_update_keyspace(std::string& /* _return */, const KsDef& /* ks_def */) { 175 return; 176 } 177 void system_update_column_family(std::string& /* _return */, const CfDef& /* cf_def */) { 178 return; 179 } 180 void execute_cql_query(CqlResult& /* _return */, const std::string& /* query */, const Compression::type /* compression */) { 181 return; 182 } 183 void prepare_cql_query(CqlPreparedResult& /* _return */, const std::string& /* query */, const Compression::type /* compression */) { 184 return; 185 } 186 void execute_prepared_cql_query(CqlResult& /* _return */, const int32_t /* itemId */, const std::vector<std::string> & /* values */) { 187 return; 188 } 189 void set_cql_version(const std::string& /* version */) { 190 return; 191 } 192 }; 193 194 195 class Cassandra_login_args { 196 public: 197 198 Cassandra_login_args() { 199 } 200 201 virtual ~Cassandra_login_args() throw() {} 202 203 AuthenticationRequest auth_request; 204 205 void __set_auth_request(const AuthenticationRequest& val) { 206 auth_request = val; 207 } 208 209 bool operator == (const Cassandra_login_args & rhs) const 210 { 211 if (!(auth_request == rhs.auth_request)) 212 return false; 213 return true; 214 } 215 bool operator != (const Cassandra_login_args &rhs) const { 216 return !(*this == rhs); 217 } 218 219 bool operator < (const Cassandra_login_args & ) const; 220 221 uint32_t read(::apache::thrift::protocol::TProtocol* iprot); 222 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; 223 224 }; 225 226 227 class Cassandra_login_pargs { 228 public: 229 230 231 virtual ~Cassandra_login_pargs() throw() {} 232 233 const AuthenticationRequest* auth_request; 234 235 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; 236 237 }; 238 239 typedef struct _Cassandra_login_result__isset { 240 _Cassandra_login_result__isset() : authnx(false), authzx(false) {} 241 bool authnx; 242 bool authzx; 243 } _Cassandra_login_result__isset; 244 245 class Cassandra_login_result { 246 public: 247 248 Cassandra_login_result() { 249 } 250 251 virtual ~Cassandra_login_result() throw() {} 252 253 AuthenticationException authnx; 254 AuthorizationException authzx; 255 256 _Cassandra_login_result__isset __isset; 257 258 void __set_authnx(const AuthenticationException& val) { 259 authnx = val; 260 } 261 262 void __set_authzx(const AuthorizationException& val) { 263 authzx = val; 264 } 265 266 bool operator == (const Cassandra_login_result & rhs) const 267 { 268 if (!(authnx == rhs.authnx)) 269 return false; 270 if (!(authzx == rhs.authzx)) 271 return false; 272 return true; 273 } 274 bool operator != (const Cassandra_login_result &rhs) const { 275 return !(*this == rhs); 276 } 277 278 bool operator < (const Cassandra_login_result & ) const; 279 280 uint32_t read(::apache::thrift::protocol::TProtocol* iprot); 281 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; 282 283 }; 284 285 typedef struct _Cassandra_login_presult__isset { 286 _Cassandra_login_presult__isset() : authnx(false), authzx(false) {} 287 bool authnx; 288 bool authzx; 289 } _Cassandra_login_presult__isset; 290 291 class Cassandra_login_presult { 292 public: 293 294 295 virtual ~Cassandra_login_presult() throw() {} 296 297 AuthenticationException authnx; 298 AuthorizationException authzx; 299 300 _Cassandra_login_presult__isset __isset; 301 302 uint32_t read(::apache::thrift::protocol::TProtocol* iprot); 303 304 }; 305 306 307 class Cassandra_set_keyspace_args { 308 public: 309 310 Cassandra_set_keyspace_args() : keyspace("") { 311 } 312 313 virtual ~Cassandra_set_keyspace_args() throw() {} 314 315 std::string keyspace; 316 317 void __set_keyspace(const std::string& val) { 318 keyspace = val; 319 } 320 321 bool operator == (const Cassandra_set_keyspace_args & rhs) const 322 { 323 if (!(keyspace == rhs.keyspace)) 324 return false; 325 return true; 326 } 327 bool operator != (const Cassandra_set_keyspace_args &rhs) const { 328 return !(*this == rhs); 329 } 330 331 bool operator < (const Cassandra_set_keyspace_args & ) const; 332 333 uint32_t read(::apache::thrift::protocol::TProtocol* iprot); 334 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; 335 336 }; 337 338 339 class Cassandra_set_keyspace_pargs { 340 public: 341 342 343 virtual ~Cassandra_set_keyspace_pargs() throw() {} 344 345 const std::string* keyspace; 346 347 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; 348 349 }; 350 351 typedef struct _Cassandra_set_keyspace_result__isset { 352 _Cassandra_set_keyspace_result__isset() : ire(false) {} 353 bool ire; 354 } _Cassandra_set_keyspace_result__isset; 355 356 class Cassandra_set_keyspace_result { 357 public: 358 359 Cassandra_set_keyspace_result() { 360 } 361 362 virtual ~Cassandra_set_keyspace_result() throw() {} 363 364 InvalidRequestException ire; 365 366 _Cassandra_set_keyspace_result__isset __isset; 367 368 void __set_ire(const InvalidRequestException& val) { 369 ire = val; 370 } 371 372 bool operator == (const Cassandra_set_keyspace_result & rhs) const 373 { 374 if (!(ire == rhs.ire)) 375 return false; 376 return true; 377 } 378 bool operator != (const Cassandra_set_keyspace_result &rhs) const { 379 return !(*this == rhs); 380 } 381 382 bool operator < (const Cassandra_set_keyspace_result & ) const; 383 384 uint32_t read(::apache::thrift::protocol::TProtocol* iprot); 385 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; 386 387 }; 388 389 typedef struct _Cassandra_set_keyspace_presult__isset { 390 _Cassandra_set_keyspace_presult__isset() : ire(false) {} 391 bool ire; 392 } _Cassandra_set_keyspace_presult__isset; 393 394 class Cassandra_set_keyspace_presult { 395 public: 396 397 398 virtual ~Cassandra_set_keyspace_presult() throw() {} 399 400 InvalidRequestException ire; 401 402 _Cassandra_set_keyspace_presult__isset __isset; 403 404 uint32_t read(::apache::thrift::protocol::TProtocol* iprot); 405 406 }; 407 408 409 class Cassandra_get_args { 410 public: 411 412 Cassandra_get_args() : key(""), consistency_level((ConsistencyLevel::type)1) { 413 consistency_level = (ConsistencyLevel::type)1; 414 415 } 416 417 virtual ~Cassandra_get_args() throw() {} 418 419 std::string key; 420 ColumnPath column_path; 421 ConsistencyLevel::type consistency_level; 422 423 void __set_key(const std::string& val) { 424 key = val; 425 } 426 427 void __set_column_path(const ColumnPath& val) { 428 column_path = val; 429 } 430 431 void __set_consistency_level(const ConsistencyLevel::type val) { 432 consistency_level = val; 433 } 434 435 bool operator == (const Cassandra_get_args & rhs) const 436 { 437 if (!(key == rhs.key)) 438 return false; 439 if (!(column_path == rhs.column_path)) 440 return false; 441 if (!(consistency_level == rhs.consistency_level)) 442 return false; 443 return true; 444 } 445 bool operator != (const Cassandra_get_args &rhs) const { 446 return !(*this == rhs); 447 } 448 449 bool operator < (const Cassandra_get_args & ) const; 450 451 uint32_t read(::apache::thrift::protocol::TProtocol* iprot); 452 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; 453 454 }; 455 456 457 class Cassandra_get_pargs { 458 public: 459 460 461 virtual ~Cassandra_get_pargs() throw() {} 462 463 const std::string* key; 464 const ColumnPath* column_path; 465 const ConsistencyLevel::type* consistency_level; 466 467 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; 468 469 }; 470 471 typedef struct _Cassandra_get_result__isset { 472 _Cassandra_get_result__isset() : success(false), ire(false), nfe(false), ue(false), te(false) {} 473 bool success; 474 bool ire; 475 bool nfe; 476 bool ue; 477 bool te; 478 } _Cassandra_get_result__isset; 479 480 class Cassandra_get_result { 481 public: 482 483 Cassandra_get_result() { 484 } 485 486 virtual ~Cassandra_get_result() throw() {} 487 488 ColumnOrSuperColumn success; 489 InvalidRequestException ire; 490 NotFoundException nfe; 491 UnavailableException ue; 492 TimedOutException te; 493 494 _Cassandra_get_result__isset __isset; 495 496 void __set_success(const ColumnOrSuperColumn& val) { 497 success = val; 498 } 499 500 void __set_ire(const InvalidRequestException& val) { 501 ire = val; 502 } 503 504 void __set_nfe(const NotFoundException& val) { 505 nfe = val; 506 } 507 508 void __set_ue(const UnavailableException& val) { 509 ue = val; 510 } 511 512 void __set_te(const TimedOutException& val) { 513 te = val; 514 } 515 516 bool operator == (const Cassandra_get_result & rhs) const 517 { 518 if (!(success == rhs.success)) 519 return false; 520 if (!(ire == rhs.ire)) 521 return false; 522 if (!(nfe == rhs.nfe)) 523 return false; 524 if (!(ue == rhs.ue)) 525 return false; 526 if (!(te == rhs.te)) 527 return false; 528 return true; 529 } 530 bool operator != (const Cassandra_get_result &rhs) const { 531 return !(*this == rhs); 532 } 533 534 bool operator < (const Cassandra_get_result & ) const; 535 536 uint32_t read(::apache::thrift::protocol::TProtocol* iprot); 537 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; 538 539 }; 540 541 typedef struct _Cassandra_get_presult__isset { 542 _Cassandra_get_presult__isset() : success(false), ire(false), nfe(false), ue(false), te(false) {} 543 bool success; 544 bool ire; 545 bool nfe; 546 bool ue; 547 bool te; 548 } _Cassandra_get_presult__isset; 549 550 class Cassandra_get_presult { 551 public: 552 553 554 virtual ~Cassandra_get_presult() throw() {} 555 556 ColumnOrSuperColumn* success; 557 InvalidRequestException ire; 558 NotFoundException nfe; 559 UnavailableException ue; 560 TimedOutException te; 561 562 _Cassandra_get_presult__isset __isset; 563 564 uint32_t read(::apache::thrift::protocol::TProtocol* iprot); 565 566 }; 567 568 569 class Cassandra_get_slice_args { 570 public: 571 572 Cassandra_get_slice_args() : key(""), consistency_level((ConsistencyLevel::type)1) { 573 consistency_level = (ConsistencyLevel::type)1; 574 575 } 576 577 virtual ~Cassandra_get_slice_args() throw() {} 578 579 std::string key; 580 ColumnParent column_parent; 581 SlicePredicate predicate; 582 ConsistencyLevel::type consistency_level; 583 584 void __set_key(const std::string& val) { 585 key = val; 586 } 587 588 void __set_column_parent(const ColumnParent& val) { 589 column_parent = val; 590 } 591 592 void __set_predicate(const SlicePredicate& val) { 593 predicate = val; 594 } 595 596 void __set_consistency_level(const ConsistencyLevel::type val) { 597 consistency_level = val; 598 } 599 600 bool operator == (const Cassandra_get_slice_args & rhs) const 601 { 602 if (!(key == rhs.key)) 603 return false; 604 if (!(column_parent == rhs.column_parent)) 605 return false; 606 if (!(predicate == rhs.predicate)) 607 return false; 608 if (!(consistency_level == rhs.consistency_level)) 609 return false; 610 return true; 611 } 612 bool operator != (const Cassandra_get_slice_args &rhs) const { 613 return !(*this == rhs); 614 } 615 616 bool operator < (const Cassandra_get_slice_args & ) const; 617 618 uint32_t read(::apache::thrift::protocol::TProtocol* iprot); 619 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; 620 621 }; 622 623 624 class Cassandra_get_slice_pargs { 625 public: 626 627 628 virtual ~Cassandra_get_slice_pargs() throw() {} 629 630 const std::string* key; 631 const ColumnParent* column_parent; 632 const SlicePredicate* predicate; 633 const ConsistencyLevel::type* consistency_level; 634 635 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; 636 637 }; 638 639 typedef struct _Cassandra_get_slice_result__isset { 640 _Cassandra_get_slice_result__isset() : success(false), ire(false), ue(false), te(false) {} 641 bool success; 642 bool ire; 643 bool ue; 644 bool te; 645 } _Cassandra_get_slice_result__isset; 646 647 class Cassandra_get_slice_result { 648 public: 649 650 Cassandra_get_slice_result() { 651 } 652 653 virtual ~Cassandra_get_slice_result() throw() {} 654 655 std::vector<ColumnOrSuperColumn> success; 656 InvalidRequestException ire; 657 UnavailableException ue; 658 TimedOutException te; 659 660 _Cassandra_get_slice_result__isset __isset; 661 662 void __set_success(const std::vector<ColumnOrSuperColumn> & val) { 663 success = val; 664 } 665 666 void __set_ire(const InvalidRequestException& val) { 667 ire = val; 668 } 669 670 void __set_ue(const UnavailableException& val) { 671 ue = val; 672 } 673 674 void __set_te(const TimedOutException& val) { 675 te = val; 676 } 677 678 bool operator == (const Cassandra_get_slice_result & rhs) const 679 { 680 if (!(success == rhs.success)) 681 return false; 682 if (!(ire == rhs.ire)) 683 return false; 684 if (!(ue == rhs.ue)) 685 return false; 686 if (!(te == rhs.te)) 687 return false; 688 return true; 689 } 690 bool operator != (const Cassandra_get_slice_result &rhs) const { 691 return !(*this == rhs); 692 } 693 694 bool operator < (const Cassandra_get_slice_result & ) const; 695 696 uint32_t read(::apache::thrift::protocol::TProtocol* iprot); 697 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; 698 699 }; 700 701 typedef struct _Cassandra_get_slice_presult__isset { 702 _Cassandra_get_slice_presult__isset() : success(false), ire(false), ue(false), te(false) {} 703 bool success; 704 bool ire; 705 bool ue; 706 bool te; 707 } _Cassandra_get_slice_presult__isset; 708 709 class Cassandra_get_slice_presult { 710 public: 711 712 713 virtual ~Cassandra_get_slice_presult() throw() {} 714 715 std::vector<ColumnOrSuperColumn> * success; 716 InvalidRequestException ire; 717 UnavailableException ue; 718 TimedOutException te; 719 720 _Cassandra_get_slice_presult__isset __isset; 721 722 uint32_t read(::apache::thrift::protocol::TProtocol* iprot); 723 724 }; 725 726 727 class Cassandra_get_count_args { 728 public: 729 730 Cassandra_get_count_args() : key(""), consistency_level((ConsistencyLevel::type)1) { 731 consistency_level = (ConsistencyLevel::type)1; 732 733 } 734 735 virtual ~Cassandra_get_count_args() throw() {} 736 737 std::string key; 738 ColumnParent column_parent; 739 SlicePredicate predicate; 740 ConsistencyLevel::type consistency_level; 741 742 void __set_key(const std::string& val) { 743 key = val; 744 } 745 746 void __set_column_parent(const ColumnParent& val) { 747 column_parent = val; 748 } 749 750 void __set_predicate(const SlicePredicate& val) { 751 predicate = val; 752 } 753 754 void __set_consistency_level(const ConsistencyLevel::type val) { 755 consistency_level = val; 756 } 757 758 bool operator == (const Cassandra_get_count_args & rhs) const 759 { 760 if (!(key == rhs.key)) 761 return false; 762 if (!(column_parent == rhs.column_parent)) 763 return false; 764 if (!(predicate == rhs.predicate)) 765 return false; 766 if (!(consistency_level == rhs.consistency_level)) 767 return false; 768 return true; 769 } 770 bool operator != (const Cassandra_get_count_args &rhs) const { 771 return !(*this == rhs); 772 } 773 774 bool operator < (const Cassandra_get_count_args & ) const; 775 776 uint32_t read(::apache::thrift::protocol::TProtocol* iprot); 777 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; 778 779 }; 780 781 782 class Cassandra_get_count_pargs { 783 public: 784 785 786 virtual ~Cassandra_get_count_pargs() throw() {} 787 788 const std::string* key; 789 const ColumnParent* column_parent; 790 const SlicePredicate* predicate; 791 const ConsistencyLevel::type* consistency_level; 792 793 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; 794 795 }; 796 797 typedef struct _Cassandra_get_count_result__isset { 798 _Cassandra_get_count_result__isset() : success(false), ire(false), ue(false), te(false) {} 799 bool success; 800 bool ire; 801 bool ue; 802 bool te; 803 } _Cassandra_get_count_result__isset; 804 805 class Cassandra_get_count_result { 806 public: 807 808 Cassandra_get_count_result() : success(0) { 809 } 810 811 virtual ~Cassandra_get_count_result() throw() {} 812 813 int32_t success; 814 InvalidRequestException ire; 815 UnavailableException ue; 816 TimedOutException te; 817 818 _Cassandra_get_count_result__isset __isset; 819 820 void __set_success(const int32_t val) { 821 success = val; 822 } 823 824 void __set_ire(const InvalidRequestException& val) { 825 ire = val; 826 } 827 828 void __set_ue(const UnavailableException& val) { 829 ue = val; 830 } 831 832 void __set_te(const TimedOutException& val) { 833 te = val; 834 } 835 836 bool operator == (const Cassandra_get_count_result & rhs) const 837 { 838 if (!(success == rhs.success)) 839 return false; 840 if (!(ire == rhs.ire)) 841 return false; 842 if (!(ue == rhs.ue)) 843 return false; 844 if (!(te == rhs.te)) 845 return false; 846 return true; 847 } 848 bool operator != (const Cassandra_get_count_result &rhs) const { 849 return !(*this == rhs); 850 } 851 852 bool operator < (const Cassandra_get_count_result & ) const; 853 854 uint32_t read(::apache::thrift::protocol::TProtocol* iprot); 855 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; 856 857 }; 858 859 typedef struct _Cassandra_get_count_presult__isset { 860 _Cassandra_get_count_presult__isset() : success(false), ire(false), ue(false), te(false) {} 861 bool success; 862 bool ire; 863 bool ue; 864 bool te; 865 } _Cassandra_get_count_presult__isset; 866 867 class Cassandra_get_count_presult { 868 public: 869 870 871 virtual ~Cassandra_get_count_presult() throw() {} 872 873 int32_t* success; 874 InvalidRequestException ire; 875 UnavailableException ue; 876 TimedOutException te; 877 878 _Cassandra_get_count_presult__isset __isset; 879 880 uint32_t read(::apache::thrift::protocol::TProtocol* iprot); 881 882 }; 883 884 885 class Cassandra_multiget_slice_args { 886 public: 887 888 Cassandra_multiget_slice_args() : consistency_level((ConsistencyLevel::type)1) { 889 consistency_level = (ConsistencyLevel::type)1; 890 891 } 892 893 virtual ~Cassandra_multiget_slice_args() throw() {} 894 895 std::vector<std::string> keys; 896 ColumnParent column_parent; 897 SlicePredicate predicate; 898 ConsistencyLevel::type consistency_level; 899 900 void __set_keys(const std::vector<std::string> & val) { 901 keys = val; 902 } 903 904 void __set_column_parent(const ColumnParent& val) { 905 column_parent = val; 906 } 907 908 void __set_predicate(const SlicePredicate& val) { 909 predicate = val; 910 } 911 912 void __set_consistency_level(const ConsistencyLevel::type val) { 913 consistency_level = val; 914 } 915 916 bool operator == (const Cassandra_multiget_slice_args & rhs) const 917 { 918 if (!(keys == rhs.keys)) 919 return false; 920 if (!(column_parent == rhs.column_parent)) 921 return false; 922 if (!(predicate == rhs.predicate)) 923 return false; 924 if (!(consistency_level == rhs.consistency_level)) 925 return false; 926 return true; 927 } 928 bool operator != (const Cassandra_multiget_slice_args &rhs) const { 929 return !(*this == rhs); 930 } 931 932 bool operator < (const Cassandra_multiget_slice_args & ) const; 933 934 uint32_t read(::apache::thrift::protocol::TProtocol* iprot); 935 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; 936 937 }; 938 939 940 class Cassandra_multiget_slice_pargs { 941 public: 942 943 944 virtual ~Cassandra_multiget_slice_pargs() throw() {} 945 946 const std::vector<std::string> * keys; 947 const ColumnParent* column_parent; 948 const SlicePredicate* predicate; 949 const ConsistencyLevel::type* consistency_level; 950 951 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; 952 953 }; 954 955 typedef struct _Cassandra_multiget_slice_result__isset { 956 _Cassandra_multiget_slice_result__isset() : success(false), ire(false), ue(false), te(false) {} 957 bool success; 958 bool ire; 959 bool ue; 960 bool te; 961 } _Cassandra_multiget_slice_result__isset; 962 963 class Cassandra_multiget_slice_result { 964 public: 965 966 Cassandra_multiget_slice_result() { 967 } 968 969 virtual ~Cassandra_multiget_slice_result() throw() {} 970 971 std::map<std::string, std::vector<ColumnOrSuperColumn> > success; 972 InvalidRequestException ire; 973 UnavailableException ue; 974 TimedOutException te; 975 976 _Cassandra_multiget_slice_result__isset __isset; 977 978 void __set_success(const std::map<std::string, std::vector<ColumnOrSuperColumn> > & val) { 979 success = val; 980 } 981 982 void __set_ire(const InvalidRequestException& val) { 983 ire = val; 984 } 985 986 void __set_ue(const UnavailableException& val) { 987 ue = val; 988 } 989 990 void __set_te(const TimedOutException& val) { 991 te = val; 992 } 993 994 bool operator == (const Cassandra_multiget_slice_result & rhs) const 995 { 996 if (!(success == rhs.success)) 997 return false; 998 if (!(ire == rhs.ire)) 999 return false; 1000 if (!(ue == rhs.ue)) 1001 return false; 1002 if (!(te == rhs.te)) 1003 return false; 1004 return true; 1005 } 1006 bool operator != (const Cassandra_multiget_slice_result &rhs) const { 1007 return !(*this == rhs); 1008 } 1009 1010 bool operator < (const Cassandra_multiget_slice_result & ) const; 1011 1012 uint32_t read(::apache::thrift::protocol::TProtocol* iprot); 1013 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; 1014 1015 }; 1016 1017 typedef struct _Cassandra_multiget_slice_presult__isset { 1018 _Cassandra_multiget_slice_presult__isset() : success(false), ire(false), ue(false), te(false) {} 1019 bool success; 1020 bool ire; 1021 bool ue; 1022 bool te; 1023 } _Cassandra_multiget_slice_presult__isset; 1024 1025 class Cassandra_multiget_slice_presult { 1026 public: 1027 1028 1029 virtual ~Cassandra_multiget_slice_presult() throw() {} 1030 1031 std::map<std::string, std::vector<ColumnOrSuperColumn> > * success; 1032 InvalidRequestException ire; 1033 UnavailableException ue; 1034 TimedOutException te; 1035 1036 _Cassandra_multiget_slice_presult__isset __isset; 1037 1038 uint32_t read(::apache::thrift::protocol::TProtocol* iprot); 1039 1040 }; 1041 1042 1043 class Cassandra_multiget_count_args { 1044 public: 1045 1046 Cassandra_multiget_count_args() : consistency_level((ConsistencyLevel::type)1) { 1047 consistency_level = (ConsistencyLevel::type)1; 1048 1049 } 1050 1051 virtual ~Cassandra_multiget_count_args() throw() {} 1052 1053 std::vector<std::string> keys; 1054 ColumnParent column_parent; 1055 SlicePredicate predicate; 1056 ConsistencyLevel::type consistency_level; 1057 1058 void __set_keys(const std::vector<std::string> & val) { 1059 keys = val; 1060 } 1061 1062 void __set_column_parent(const ColumnParent& val) { 1063 column_parent = val; 1064 } 1065 1066 void __set_predicate(const SlicePredicate& val) { 1067 predicate = val; 1068 } 1069 1070 void __set_consistency_level(const ConsistencyLevel::type val) { 1071 consistency_level = val; 1072 } 1073 1074 bool operator == (const Cassandra_multiget_count_args & rhs) const 1075 { 1076 if (!(keys == rhs.keys)) 1077 return false; 1078 if (!(column_parent == rhs.column_parent)) 1079 return false; 1080 if (!(predicate == rhs.predicate)) 1081 return false; 1082 if (!(consistency_level == rhs.consistency_level)) 1083 return false; 1084 return true; 1085 } 1086 bool operator != (const Cassandra_multiget_count_args &rhs) const { 1087 return !(*this == rhs); 1088 } 1089 1090 bool operator < (const Cassandra_multiget_count_args & ) const; 1091 1092 uint32_t read(::apache::thrift::protocol::TProtocol* iprot); 1093 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; 1094 1095 }; 1096 1097 1098 class Cassandra_multiget_count_pargs { 1099 public: 1100 1101 1102 virtual ~Cassandra_multiget_count_pargs() throw() {} 1103 1104 const std::vector<std::string> * keys; 1105 const ColumnParent* column_parent; 1106 const SlicePredicate* predicate; 1107 const ConsistencyLevel::type* consistency_level; 1108 1109 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; 1110 1111 }; 1112 1113 typedef struct _Cassandra_multiget_count_result__isset { 1114 _Cassandra_multiget_count_result__isset() : success(false), ire(false), ue(false), te(false) {} 1115 bool success; 1116 bool ire; 1117 bool ue; 1118 bool te; 1119 } _Cassandra_multiget_count_result__isset; 1120 1121 class Cassandra_multiget_count_result { 1122 public: 1123 1124 Cassandra_multiget_count_result() { 1125 } 1126 1127 virtual ~Cassandra_multiget_count_result() throw() {} 1128 1129 std::map<std::string, int32_t> success; 1130 InvalidRequestException ire; 1131 UnavailableException ue; 1132 TimedOutException te; 1133 1134 _Cassandra_multiget_count_result__isset __isset; 1135 1136 void __set_success(const std::map<std::string, int32_t> & val) { 1137 success = val; 1138 } 1139 1140 void __set_ire(const InvalidRequestException& val) { 1141 ire = val; 1142 } 1143 1144 void __set_ue(const UnavailableException& val) { 1145 ue = val; 1146 } 1147 1148 void __set_te(const TimedOutException& val) { 1149 te = val; 1150 } 1151 1152 bool operator == (const Cassandra_multiget_count_result & rhs) const 1153 { 1154 if (!(success == rhs.success)) 1155 return false; 1156 if (!(ire == rhs.ire)) 1157 return false; 1158 if (!(ue == rhs.ue)) 1159 return false; 1160 if (!(te == rhs.te)) 1161 return false; 1162 return true; 1163 } 1164 bool operator != (const Cassandra_multiget_count_result &rhs) const { 1165 return !(*this == rhs); 1166 } 1167 1168 bool operator < (const Cassandra_multiget_count_result & ) const; 1169 1170 uint32_t read(::apache::thrift::protocol::TProtocol* iprot); 1171 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; 1172 1173 }; 1174 1175 typedef struct _Cassandra_multiget_count_presult__isset { 1176 _Cassandra_multiget_count_presult__isset() : success(false), ire(false), ue(false), te(false) {} 1177 bool success; 1178 bool ire; 1179 bool ue; 1180 bool te; 1181 } _Cassandra_multiget_count_presult__isset; 1182 1183 class Cassandra_multiget_count_presult { 1184 public: 1185 1186 1187 virtual ~Cassandra_multiget_count_presult() throw() {} 1188 1189 std::map<std::string, int32_t> * success; 1190 InvalidRequestException ire; 1191 UnavailableException ue; 1192 TimedOutException te; 1193 1194 _Cassandra_multiget_count_presult__isset __isset; 1195 1196 uint32_t read(::apache::thrift::protocol::TProtocol* iprot); 1197 1198 }; 1199 1200 1201 class Cassandra_get_range_slices_args { 1202 public: 1203 1204 Cassandra_get_range_slices_args() : consistency_level((ConsistencyLevel::type)1) { 1205 consistency_level = (ConsistencyLevel::type)1; 1206 1207 } 1208 1209 virtual ~Cassandra_get_range_slices_args() throw() {} 1210 1211 ColumnParent column_parent; 1212 SlicePredicate predicate; 1213 KeyRange range; 1214 ConsistencyLevel::type consistency_level; 1215 1216 void __set_column_parent(const ColumnParent& val) { 1217 column_parent = val; 1218 } 1219 1220 void __set_predicate(const SlicePredicate& val) { 1221 predicate = val; 1222 } 1223 1224 void __set_range(const KeyRange& val) { 1225 range = val; 1226 } 1227 1228 void __set_consistency_level(const ConsistencyLevel::type val) { 1229 consistency_level = val; 1230 } 1231 1232 bool operator == (const Cassandra_get_range_slices_args & rhs) const 1233 { 1234 if (!(column_parent == rhs.column_parent)) 1235 return false; 1236 if (!(predicate == rhs.predicate)) 1237 return false; 1238 if (!(range == rhs.range)) 1239 return false; 1240 if (!(consistency_level == rhs.consistency_level)) 1241 return false; 1242 return true; 1243 } 1244 bool operator != (const Cassandra_get_range_slices_args &rhs) const { 1245 return !(*this == rhs); 1246 } 1247 1248 bool operator < (const Cassandra_get_range_slices_args & ) const; 1249 1250 uint32_t read(::apache::thrift::protocol::TProtocol* iprot); 1251 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; 1252 1253 }; 1254 1255 1256 class Cassandra_get_range_slices_pargs { 1257 public: 1258 1259 1260 virtual ~Cassandra_get_range_slices_pargs() throw() {} 1261 1262 const ColumnParent* column_parent; 1263 const SlicePredicate* predicate; 1264 const KeyRange* range; 1265 const ConsistencyLevel::type* consistency_level; 1266 1267 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; 1268 1269 }; 1270 1271 typedef struct _Cassandra_get_range_slices_result__isset { 1272 _Cassandra_get_range_slices_result__isset() : success(false), ire(false), ue(false), te(false) {} 1273 bool success; 1274 bool ire; 1275 bool ue; 1276 bool te; 1277 } _Cassandra_get_range_slices_result__isset; 1278 1279 class Cassandra_get_range_slices_result { 1280 public: 1281 1282 Cassandra_get_range_slices_result() { 1283 } 1284 1285 virtual ~Cassandra_get_range_slices_result() throw() {} 1286 1287 std::vector<KeySlice> success; 1288 InvalidRequestException ire; 1289 UnavailableException ue; 1290 TimedOutException te; 1291 1292 _Cassandra_get_range_slices_result__isset __isset; 1293 1294 void __set_success(const std::vector<KeySlice> & val) { 1295 success = val; 1296 } 1297 1298 void __set_ire(const InvalidRequestException& val) { 1299 ire = val; 1300 } 1301 1302 void __set_ue(const UnavailableException& val) { 1303 ue = val; 1304 } 1305 1306 void __set_te(const TimedOutException& val) { 1307 te = val; 1308 } 1309 1310 bool operator == (const Cassandra_get_range_slices_result & rhs) const 1311 { 1312 if (!(success == rhs.success)) 1313 return false; 1314 if (!(ire == rhs.ire)) 1315 return false; 1316 if (!(ue == rhs.ue)) 1317 return false; 1318 if (!(te == rhs.te)) 1319 return false; 1320 return true; 1321 } 1322 bool operator != (const Cassandra_get_range_slices_result &rhs) const { 1323 return !(*this == rhs); 1324 } 1325 1326 bool operator < (const Cassandra_get_range_slices_result & ) const; 1327 1328 uint32_t read(::apache::thrift::protocol::TProtocol* iprot); 1329 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; 1330 1331 }; 1332 1333 typedef struct _Cassandra_get_range_slices_presult__isset { 1334 _Cassandra_get_range_slices_presult__isset() : success(false), ire(false), ue(false), te(false) {} 1335 bool success; 1336 bool ire; 1337 bool ue; 1338 bool te; 1339 } _Cassandra_get_range_slices_presult__isset; 1340 1341 class Cassandra_get_range_slices_presult { 1342 public: 1343 1344 1345 virtual ~Cassandra_get_range_slices_presult() throw() {} 1346 1347 std::vector<KeySlice> * success; 1348 InvalidRequestException ire; 1349 UnavailableException ue; 1350 TimedOutException te; 1351 1352 _Cassandra_get_range_slices_presult__isset __isset; 1353 1354 uint32_t read(::apache::thrift::protocol::TProtocol* iprot); 1355 1356 }; 1357 1358 1359 class Cassandra_get_paged_slice_args { 1360 public: 1361 1362 Cassandra_get_paged_slice_args() : column_family(""), start_column(""), consistency_level((ConsistencyLevel::type)1) { 1363 consistency_level = (ConsistencyLevel::type)1; 1364 1365 } 1366 1367 virtual ~Cassandra_get_paged_slice_args() throw() {} 1368 1369 std::string column_family; 1370 KeyRange range; 1371 std::string start_column; 1372 ConsistencyLevel::type consistency_level; 1373 1374 void __set_column_family(const std::string& val) { 1375 column_family = val; 1376 } 1377 1378 void __set_range(const KeyRange& val) { 1379 range = val; 1380 } 1381 1382 void __set_start_column(const std::string& val) { 1383 start_column = val; 1384 } 1385 1386 void __set_consistency_level(const ConsistencyLevel::type val) { 1387 consistency_level = val; 1388 } 1389 1390 bool operator == (const Cassandra_get_paged_slice_args & rhs) const 1391 { 1392 if (!(column_family == rhs.column_family)) 1393 return false; 1394 if (!(range == rhs.range)) 1395 return false; 1396 if (!(start_column == rhs.start_column)) 1397 return false; 1398 if (!(consistency_level == rhs.consistency_level)) 1399 return false; 1400 return true; 1401 } 1402 bool operator != (const Cassandra_get_paged_slice_args &rhs) const { 1403 return !(*this == rhs); 1404 } 1405 1406 bool operator < (const Cassandra_get_paged_slice_args & ) const; 1407 1408 uint32_t read(::apache::thrift::protocol::TProtocol* iprot); 1409 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; 1410 1411 }; 1412 1413 1414 class Cassandra_get_paged_slice_pargs { 1415 public: 1416 1417 1418 virtual ~Cassandra_get_paged_slice_pargs() throw() {} 1419 1420 const std::string* column_family; 1421 const KeyRange* range; 1422 const std::string* start_column; 1423 const ConsistencyLevel::type* consistency_level; 1424 1425 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; 1426 1427 }; 1428 1429 typedef struct _Cassandra_get_paged_slice_result__isset { 1430 _Cassandra_get_paged_slice_result__isset() : success(false), ire(false), ue(false), te(false) {} 1431 bool success; 1432 bool ire; 1433 bool ue; 1434 bool te; 1435 } _Cassandra_get_paged_slice_result__isset; 1436 1437 class Cassandra_get_paged_slice_result { 1438 public: 1439 1440 Cassandra_get_paged_slice_result() { 1441 } 1442 1443 virtual ~Cassandra_get_paged_slice_result() throw() {} 1444 1445 std::vector<KeySlice> success; 1446 InvalidRequestException ire; 1447 UnavailableException ue; 1448 TimedOutException te; 1449 1450 _Cassandra_get_paged_slice_result__isset __isset; 1451 1452 void __set_success(const std::vector<KeySlice> & val) { 1453 success = val; 1454 } 1455 1456 void __set_ire(const InvalidRequestException& val) { 1457 ire = val; 1458 } 1459 1460 void __set_ue(const UnavailableException& val) { 1461 ue = val; 1462 } 1463 1464 void __set_te(const TimedOutException& val) { 1465 te = val; 1466 } 1467 1468 bool operator == (const Cassandra_get_paged_slice_result & rhs) const 1469 { 1470 if (!(success == rhs.success)) 1471 return false; 1472 if (!(ire == rhs.ire)) 1473 return false; 1474 if (!(ue == rhs.ue)) 1475 return false; 1476 if (!(te == rhs.te)) 1477 return false; 1478 return true; 1479 } 1480 bool operator != (const Cassandra_get_paged_slice_result &rhs) const { 1481 return !(*this == rhs); 1482 } 1483 1484 bool operator < (const Cassandra_get_paged_slice_result & ) const; 1485 1486 uint32_t read(::apache::thrift::protocol::TProtocol* iprot); 1487 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; 1488 1489 }; 1490 1491 typedef struct _Cassandra_get_paged_slice_presult__isset { 1492 _Cassandra_get_paged_slice_presult__isset() : success(false), ire(false), ue(false), te(false) {} 1493 bool success; 1494 bool ire; 1495 bool ue; 1496 bool te; 1497 } _Cassandra_get_paged_slice_presult__isset; 1498 1499 class Cassandra_get_paged_slice_presult { 1500 public: 1501 1502 1503 virtual ~Cassandra_get_paged_slice_presult() throw() {} 1504 1505 std::vector<KeySlice> * success; 1506 InvalidRequestException ire; 1507 UnavailableException ue; 1508 TimedOutException te; 1509 1510 _Cassandra_get_paged_slice_presult__isset __isset; 1511 1512 uint32_t read(::apache::thrift::protocol::TProtocol* iprot); 1513 1514 }; 1515 1516 1517 class Cassandra_get_indexed_slices_args { 1518 public: 1519 1520 Cassandra_get_indexed_slices_args() : consistency_level((ConsistencyLevel::type)1) { 1521 consistency_level = (ConsistencyLevel::type)1; 1522 1523 } 1524 1525 virtual ~Cassandra_get_indexed_slices_args() throw() {} 1526 1527 ColumnParent column_parent; 1528 IndexClause index_clause; 1529 SlicePredicate column_predicate; 1530 ConsistencyLevel::type consistency_level; 1531 1532 void __set_column_parent(const ColumnParent& val) { 1533 column_parent = val; 1534 } 1535 1536 void __set_index_clause(const IndexClause& val) { 1537 index_clause = val; 1538 } 1539 1540 void __set_column_predicate(const SlicePredicate& val) { 1541 column_predicate = val; 1542 } 1543 1544 void __set_consistency_level(const ConsistencyLevel::type val) { 1545 consistency_level = val; 1546 } 1547 1548 bool operator == (const Cassandra_get_indexed_slices_args & rhs) const 1549 { 1550 if (!(column_parent == rhs.column_parent)) 1551 return false; 1552 if (!(index_clause == rhs.index_clause)) 1553 return false; 1554 if (!(column_predicate == rhs.column_predicate)) 1555 return false; 1556 if (!(consistency_level == rhs.consistency_level)) 1557 return false; 1558 return true; 1559 } 1560 bool operator != (const Cassandra_get_indexed_slices_args &rhs) const { 1561 return !(*this == rhs); 1562 } 1563 1564 bool operator < (const Cassandra_get_indexed_slices_args & ) const; 1565 1566 uint32_t read(::apache::thrift::protocol::TProtocol* iprot); 1567 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; 1568 1569 }; 1570 1571 1572 class Cassandra_get_indexed_slices_pargs { 1573 public: 1574 1575 1576 virtual ~Cassandra_get_indexed_slices_pargs() throw() {} 1577 1578 const ColumnParent* column_parent; 1579 const IndexClause* index_clause; 1580 const SlicePredicate* column_predicate; 1581 const ConsistencyLevel::type* consistency_level; 1582 1583 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; 1584 1585 }; 1586 1587 typedef struct _Cassandra_get_indexed_slices_result__isset { 1588 _Cassandra_get_indexed_slices_result__isset() : success(false), ire(false), ue(false), te(false) {} 1589 bool success; 1590 bool ire; 1591 bool ue; 1592 bool te; 1593 } _Cassandra_get_indexed_slices_result__isset; 1594 1595 class Cassandra_get_indexed_slices_result { 1596 public: 1597 1598 Cassandra_get_indexed_slices_result() { 1599 } 1600 1601 virtual ~Cassandra_get_indexed_slices_result() throw() {} 1602 1603 std::vector<KeySlice> success; 1604 InvalidRequestException ire; 1605 UnavailableException ue; 1606 TimedOutException te; 1607 1608 _Cassandra_get_indexed_slices_result__isset __isset; 1609 1610 void __set_success(const std::vector<KeySlice> & val) { 1611 success = val; 1612 } 1613 1614 void __set_ire(const InvalidRequestException& val) { 1615 ire = val; 1616 } 1617 1618 void __set_ue(const UnavailableException& val) { 1619 ue = val; 1620 } 1621 1622 void __set_te(const TimedOutException& val) { 1623 te = val; 1624 } 1625 1626 bool operator == (const Cassandra_get_indexed_slices_result & rhs) const 1627 { 1628 if (!(success == rhs.success)) 1629 return false; 1630 if (!(ire == rhs.ire)) 1631 return false; 1632 if (!(ue == rhs.ue)) 1633 return false; 1634 if (!(te == rhs.te)) 1635 return false; 1636 return true; 1637 } 1638 bool operator != (const Cassandra_get_indexed_slices_result &rhs) const { 1639 return !(*this == rhs); 1640 } 1641 1642 bool operator < (const Cassandra_get_indexed_slices_result & ) const; 1643 1644 uint32_t read(::apache::thrift::protocol::TProtocol* iprot); 1645 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; 1646 1647 }; 1648 1649 typedef struct _Cassandra_get_indexed_slices_presult__isset { 1650 _Cassandra_get_indexed_slices_presult__isset() : success(false), ire(false), ue(false), te(false) {} 1651 bool success; 1652 bool ire; 1653 bool ue; 1654 bool te; 1655 } _Cassandra_get_indexed_slices_presult__isset; 1656 1657 class Cassandra_get_indexed_slices_presult { 1658 public: 1659 1660 1661 virtual ~Cassandra_get_indexed_slices_presult() throw() {} 1662 1663 std::vector<KeySlice> * success; 1664 InvalidRequestException ire; 1665 UnavailableException ue; 1666 TimedOutException te; 1667 1668 _Cassandra_get_indexed_slices_presult__isset __isset; 1669 1670 uint32_t read(::apache::thrift::protocol::TProtocol* iprot); 1671 1672 }; 1673 1674 1675 class Cassandra_insert_args { 1676 public: 1677 1678 Cassandra_insert_args() : key(""), consistency_level((ConsistencyLevel::type)1) { 1679 consistency_level = (ConsistencyLevel::type)1; 1680 1681 } 1682 1683 virtual ~Cassandra_insert_args() throw() {} 1684 1685 std::string key; 1686 ColumnParent column_parent; 1687 Column column; 1688 ConsistencyLevel::type consistency_level; 1689 1690 void __set_key(const std::string& val) { 1691 key = val; 1692 } 1693 1694 void __set_column_parent(const ColumnParent& val) { 1695 column_parent = val; 1696 } 1697 1698 void __set_column(const Column& val) { 1699 column = val; 1700 } 1701 1702 void __set_consistency_level(const ConsistencyLevel::type val) { 1703 consistency_level = val; 1704 } 1705 1706 bool operator == (const Cassandra_insert_args & rhs) const 1707 { 1708 if (!(key == rhs.key)) 1709 return false; 1710 if (!(column_parent == rhs.column_parent)) 1711 return false; 1712 if (!(column == rhs.column)) 1713 return false; 1714 if (!(consistency_level == rhs.consistency_level)) 1715 return false; 1716 return true; 1717 } 1718 bool operator != (const Cassandra_insert_args &rhs) const { 1719 return !(*this == rhs); 1720 } 1721 1722 bool operator < (const Cassandra_insert_args & ) const; 1723 1724 uint32_t read(::apache::thrift::protocol::TProtocol* iprot); 1725 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; 1726 1727 }; 1728 1729 1730 class Cassandra_insert_pargs { 1731 public: 1732 1733 1734 virtual ~Cassandra_insert_pargs() throw() {} 1735 1736 const std::string* key; 1737 const ColumnParent* column_parent; 1738 const Column* column; 1739 const ConsistencyLevel::type* consistency_level; 1740 1741 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; 1742 1743 }; 1744 1745 typedef struct _Cassandra_insert_result__isset { 1746 _Cassandra_insert_result__isset() : ire(false), ue(false), te(false) {} 1747 bool ire; 1748 bool ue; 1749 bool te; 1750 } _Cassandra_insert_result__isset; 1751 1752 class Cassandra_insert_result { 1753 public: 1754 1755 Cassandra_insert_result() { 1756 } 1757 1758 virtual ~Cassandra_insert_result() throw() {} 1759 1760 InvalidRequestException ire; 1761 UnavailableException ue; 1762 TimedOutException te; 1763 1764 _Cassandra_insert_result__isset __isset; 1765 1766 void __set_ire(const InvalidRequestException& val) { 1767 ire = val; 1768 } 1769 1770 void __set_ue(const UnavailableException& val) { 1771 ue = val; 1772 } 1773 1774 void __set_te(const TimedOutException& val) { 1775 te = val; 1776 } 1777 1778 bool operator == (const Cassandra_insert_result & rhs) const 1779 { 1780 if (!(ire == rhs.ire)) 1781 return false; 1782 if (!(ue == rhs.ue)) 1783 return false; 1784 if (!(te == rhs.te)) 1785 return false; 1786 return true; 1787 } 1788 bool operator != (const Cassandra_insert_result &rhs) const { 1789 return !(*this == rhs); 1790 } 1791 1792 bool operator < (const Cassandra_insert_result & ) const; 1793 1794 uint32_t read(::apache::thrift::protocol::TProtocol* iprot); 1795 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; 1796 1797 }; 1798 1799 typedef struct _Cassandra_insert_presult__isset { 1800 _Cassandra_insert_presult__isset() : ire(false), ue(false), te(false) {} 1801 bool ire; 1802 bool ue; 1803 bool te; 1804 } _Cassandra_insert_presult__isset; 1805 1806 class Cassandra_insert_presult { 1807 public: 1808 1809 1810 virtual ~Cassandra_insert_presult() throw() {} 1811 1812 InvalidRequestException ire; 1813 UnavailableException ue; 1814 TimedOutException te; 1815 1816 _Cassandra_insert_presult__isset __isset; 1817 1818 uint32_t read(::apache::thrift::protocol::TProtocol* iprot); 1819 1820 }; 1821 1822 1823 class Cassandra_add_args { 1824 public: 1825 1826 Cassandra_add_args() : key(""), consistency_level((ConsistencyLevel::type)1) { 1827 consistency_level = (ConsistencyLevel::type)1; 1828 1829 } 1830 1831 virtual ~Cassandra_add_args() throw() {} 1832 1833 std::string key; 1834 ColumnParent column_parent; 1835 CounterColumn column; 1836 ConsistencyLevel::type consistency_level; 1837 1838 void __set_key(const std::string& val) { 1839 key = val; 1840 } 1841 1842 void __set_column_parent(const ColumnParent& val) { 1843 column_parent = val; 1844 } 1845 1846 void __set_column(const CounterColumn& val) { 1847 column = val; 1848 } 1849 1850 void __set_consistency_level(const ConsistencyLevel::type val) { 1851 consistency_level = val; 1852 } 1853 1854 bool operator == (const Cassandra_add_args & rhs) const 1855 { 1856 if (!(key == rhs.key)) 1857 return false; 1858 if (!(column_parent == rhs.column_parent)) 1859 return false; 1860 if (!(column == rhs.column)) 1861 return false; 1862 if (!(consistency_level == rhs.consistency_level)) 1863 return false; 1864 return true; 1865 } 1866 bool operator != (const Cassandra_add_args &rhs) const { 1867 return !(*this == rhs); 1868 } 1869 1870 bool operator < (const Cassandra_add_args & ) const; 1871 1872 uint32_t read(::apache::thrift::protocol::TProtocol* iprot); 1873 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; 1874 1875 }; 1876 1877 1878 class Cassandra_add_pargs { 1879 public: 1880 1881 1882 virtual ~Cassandra_add_pargs() throw() {} 1883 1884 const std::string* key; 1885 const ColumnParent* column_parent; 1886 const CounterColumn* column; 1887 const ConsistencyLevel::type* consistency_level; 1888 1889 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; 1890 1891 }; 1892 1893 typedef struct _Cassandra_add_result__isset { 1894 _Cassandra_add_result__isset() : ire(false), ue(false), te(false) {} 1895 bool ire; 1896 bool ue; 1897 bool te; 1898 } _Cassandra_add_result__isset; 1899 1900 class Cassandra_add_result { 1901 public: 1902 1903 Cassandra_add_result() { 1904 } 1905 1906 virtual ~Cassandra_add_result() throw() {} 1907 1908 InvalidRequestException ire; 1909 UnavailableException ue; 1910 TimedOutException te; 1911 1912 _Cassandra_add_result__isset __isset; 1913 1914 void __set_ire(const InvalidRequestException& val) { 1915 ire = val; 1916 } 1917 1918 void __set_ue(const UnavailableException& val) { 1919 ue = val; 1920 } 1921 1922 void __set_te(const TimedOutException& val) { 1923 te = val; 1924 } 1925 1926 bool operator == (const Cassandra_add_result & rhs) const 1927 { 1928 if (!(ire == rhs.ire)) 1929 return false; 1930 if (!(ue == rhs.ue)) 1931 return false; 1932 if (!(te == rhs.te)) 1933 return false; 1934 return true; 1935 } 1936 bool operator != (const Cassandra_add_result &rhs) const { 1937 return !(*this == rhs); 1938 } 1939 1940 bool operator < (const Cassandra_add_result & ) const; 1941 1942 uint32_t read(::apache::thrift::protocol::TProtocol* iprot); 1943 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; 1944 1945 }; 1946 1947 typedef struct _Cassandra_add_presult__isset { 1948 _Cassandra_add_presult__isset() : ire(false), ue(false), te(false) {} 1949 bool ire; 1950 bool ue; 1951 bool te; 1952 } _Cassandra_add_presult__isset; 1953 1954 class Cassandra_add_presult { 1955 public: 1956 1957 1958 virtual ~Cassandra_add_presult() throw() {} 1959 1960 InvalidRequestException ire; 1961 UnavailableException ue; 1962 TimedOutException te; 1963 1964 _Cassandra_add_presult__isset __isset; 1965 1966 uint32_t read(::apache::thrift::protocol::TProtocol* iprot); 1967 1968 }; 1969 1970 typedef struct _Cassandra_remove_args__isset { 1971 _Cassandra_remove_args__isset() : consistency_level(false) {} 1972 bool consistency_level; 1973 } _Cassandra_remove_args__isset; 1974 1975 class Cassandra_remove_args { 1976 public: 1977 1978 Cassandra_remove_args() : key(""), timestamp(0), consistency_level((ConsistencyLevel::type)1) { 1979 consistency_level = (ConsistencyLevel::type)1; 1980 1981 } 1982 1983 virtual ~Cassandra_remove_args() throw() {} 1984 1985 std::string key; 1986 ColumnPath column_path; 1987 int64_t timestamp; 1988 ConsistencyLevel::type consistency_level; 1989 1990 _Cassandra_remove_args__isset __isset; 1991 1992 void __set_key(const std::string& val) { 1993 key = val; 1994 } 1995 1996 void __set_column_path(const ColumnPath& val) { 1997 column_path = val; 1998 } 1999 2000 void __set_timestamp(const int64_t val) { 2001 timestamp = val; 2002 } 2003 2004 void __set_consistency_level(const ConsistencyLevel::type val) { 2005 consistency_level = val; 2006 } 2007 2008 bool operator == (const Cassandra_remove_args & rhs) const 2009 { 2010 if (!(key == rhs.key)) 2011 return false; 2012 if (!(column_path == rhs.column_path)) 2013 return false; 2014 if (!(timestamp == rhs.timestamp)) 2015 return false; 2016 if (!(consistency_level == rhs.consistency_level)) 2017 return false; 2018 return true; 2019 } 2020 bool operator != (const Cassandra_remove_args &rhs) const { 2021 return !(*this == rhs); 2022 } 2023 2024 bool operator < (const Cassandra_remove_args & ) const; 2025 2026 uint32_t read(::apache::thrift::protocol::TProtocol* iprot); 2027 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; 2028 2029 }; 2030 2031 2032 class Cassandra_remove_pargs { 2033 public: 2034 2035 2036 virtual ~Cassandra_remove_pargs() throw() {} 2037 2038 const std::string* key; 2039 const ColumnPath* column_path; 2040 const int64_t* timestamp; 2041 const ConsistencyLevel::type* consistency_level; 2042 2043 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; 2044 2045 }; 2046 2047 typedef struct _Cassandra_remove_result__isset { 2048 _Cassandra_remove_result__isset() : ire(false), ue(false), te(false) {} 2049 bool ire; 2050 bool ue; 2051 bool te; 2052 } _Cassandra_remove_result__isset; 2053 2054 class Cassandra_remove_result { 2055 public: 2056 2057 Cassandra_remove_result() { 2058 } 2059 2060 virtual ~Cassandra_remove_result() throw() {} 2061 2062 InvalidRequestException ire; 2063 UnavailableException ue; 2064 TimedOutException te; 2065 2066 _Cassandra_remove_result__isset __isset; 2067 2068 void __set_ire(const InvalidRequestException& val) { 2069 ire = val; 2070 } 2071 2072 void __set_ue(const UnavailableException& val) { 2073 ue = val; 2074 } 2075 2076 void __set_te(const TimedOutException& val) { 2077 te = val; 2078 } 2079 2080 bool operator == (const Cassandra_remove_result & rhs) const 2081 { 2082 if (!(ire == rhs.ire)) 2083 return false; 2084 if (!(ue == rhs.ue)) 2085 return false; 2086 if (!(te == rhs.te)) 2087 return false; 2088 return true; 2089 } 2090 bool operator != (const Cassandra_remove_result &rhs) const { 2091 return !(*this == rhs); 2092 } 2093 2094 bool operator < (const Cassandra_remove_result & ) const; 2095 2096 uint32_t read(::apache::thrift::protocol::TProtocol* iprot); 2097 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; 2098 2099 }; 2100 2101 typedef struct _Cassandra_remove_presult__isset { 2102 _Cassandra_remove_presult__isset() : ire(false), ue(false), te(false) {} 2103 bool ire; 2104 bool ue; 2105 bool te; 2106 } _Cassandra_remove_presult__isset; 2107 2108 class Cassandra_remove_presult { 2109 public: 2110 2111 2112 virtual ~Cassandra_remove_presult() throw() {} 2113 2114 InvalidRequestException ire; 2115 UnavailableException ue; 2116 TimedOutException te; 2117 2118 _Cassandra_remove_presult__isset __isset; 2119 2120 uint32_t read(::apache::thrift::protocol::TProtocol* iprot); 2121 2122 }; 2123 2124 2125 class Cassandra_remove_counter_args { 2126 public: 2127 2128 Cassandra_remove_counter_args() : key(""), consistency_level((ConsistencyLevel::type)1) { 2129 consistency_level = (ConsistencyLevel::type)1; 2130 2131 } 2132 2133 virtual ~Cassandra_remove_counter_args() throw() {} 2134 2135 std::string key; 2136 ColumnPath path; 2137 ConsistencyLevel::type consistency_level; 2138 2139 void __set_key(const std::string& val) { 2140 key = val; 2141 } 2142 2143 void __set_path(const ColumnPath& val) { 2144 path = val; 2145 } 2146 2147 void __set_consistency_level(const ConsistencyLevel::type val) { 2148 consistency_level = val; 2149 } 2150 2151 bool operator == (const Cassandra_remove_counter_args & rhs) const 2152 { 2153 if (!(key == rhs.key)) 2154 return false; 2155 if (!(path == rhs.path)) 2156 return false; 2157 if (!(consistency_level == rhs.consistency_level)) 2158 return false; 2159 return true; 2160 } 2161 bool operator != (const Cassandra_remove_counter_args &rhs) const { 2162 return !(*this == rhs); 2163 } 2164 2165 bool operator < (const Cassandra_remove_counter_args & ) const; 2166 2167 uint32_t read(::apache::thrift::protocol::TProtocol* iprot); 2168 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; 2169 2170 }; 2171 2172 2173 class Cassandra_remove_counter_pargs { 2174 public: 2175 2176 2177 virtual ~Cassandra_remove_counter_pargs() throw() {} 2178 2179 const std::string* key; 2180 const ColumnPath* path; 2181 const ConsistencyLevel::type* consistency_level; 2182 2183 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; 2184 2185 }; 2186 2187 typedef struct _Cassandra_remove_counter_result__isset { 2188 _Cassandra_remove_counter_result__isset() : ire(false), ue(false), te(false) {} 2189 bool ire; 2190 bool ue; 2191 bool te; 2192 } _Cassandra_remove_counter_result__isset; 2193 2194 class Cassandra_remove_counter_result { 2195 public: 2196 2197 Cassandra_remove_counter_result() { 2198 } 2199 2200 virtual ~Cassandra_remove_counter_result() throw() {} 2201 2202 InvalidRequestException ire; 2203 UnavailableException ue; 2204 TimedOutException te; 2205 2206 _Cassandra_remove_counter_result__isset __isset; 2207 2208 void __set_ire(const InvalidRequestException& val) { 2209 ire = val; 2210 } 2211 2212 void __set_ue(const UnavailableException& val) { 2213 ue = val; 2214 } 2215 2216 void __set_te(const TimedOutException& val) { 2217 te = val; 2218 } 2219 2220 bool operator == (const Cassandra_remove_counter_result & rhs) const 2221 { 2222 if (!(ire == rhs.ire)) 2223 return false; 2224 if (!(ue == rhs.ue)) 2225 return false; 2226 if (!(te == rhs.te)) 2227 return false; 2228 return true; 2229 } 2230 bool operator != (const Cassandra_remove_counter_result &rhs) const { 2231 return !(*this == rhs); 2232 } 2233 2234 bool operator < (const Cassandra_remove_counter_result & ) const; 2235 2236 uint32_t read(::apache::thrift::protocol::TProtocol* iprot); 2237 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; 2238 2239 }; 2240 2241 typedef struct _Cassandra_remove_counter_presult__isset { 2242 _Cassandra_remove_counter_presult__isset() : ire(false), ue(false), te(false) {} 2243 bool ire; 2244 bool ue; 2245 bool te; 2246 } _Cassandra_remove_counter_presult__isset; 2247 2248 class Cassandra_remove_counter_presult { 2249 public: 2250 2251 2252 virtual ~Cassandra_remove_counter_presult() throw() {} 2253 2254 InvalidRequestException ire; 2255 UnavailableException ue; 2256 TimedOutException te; 2257 2258 _Cassandra_remove_counter_presult__isset __isset; 2259 2260 uint32_t read(::apache::thrift::protocol::TProtocol* iprot); 2261 2262 }; 2263 2264 2265 class Cassandra_batch_mutate_args { 2266 public: 2267 2268 Cassandra_batch_mutate_args() : consistency_level((ConsistencyLevel::type)1) { 2269 consistency_level = (ConsistencyLevel::type)1; 2270 2271 } 2272 2273 virtual ~Cassandra_batch_mutate_args() throw() {} 2274 2275 std::map<std::string, std::map<std::string, std::vector<Mutation> > > mutation_map; 2276 ConsistencyLevel::type consistency_level; 2277 2278 void __set_mutation_map(const std::map<std::string, std::map<std::string, std::vector<Mutation> > > & val) { 2279 mutation_map = val; 2280 } 2281 2282 void __set_consistency_level(const ConsistencyLevel::type val) { 2283 consistency_level = val; 2284 } 2285 2286 bool operator == (const Cassandra_batch_mutate_args & rhs) const 2287 { 2288 if (!(mutation_map == rhs.mutation_map)) 2289 return false; 2290 if (!(consistency_level == rhs.consistency_level)) 2291 return false; 2292 return true; 2293 } 2294 bool operator != (const Cassandra_batch_mutate_args &rhs) const { 2295 return !(*this == rhs); 2296 } 2297 2298 bool operator < (const Cassandra_batch_mutate_args & ) const; 2299 2300 uint32_t read(::apache::thrift::protocol::TProtocol* iprot); 2301 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; 2302 2303 }; 2304 2305 2306 class Cassandra_batch_mutate_pargs { 2307 public: 2308 2309 2310 virtual ~Cassandra_batch_mutate_pargs() throw() {} 2311 2312 const std::map<std::string, std::map<std::string, std::vector<Mutation> > > * mutation_map; 2313 const ConsistencyLevel::type* consistency_level; 2314 2315 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; 2316 2317 }; 2318 2319 typedef struct _Cassandra_batch_mutate_result__isset { 2320 _Cassandra_batch_mutate_result__isset() : ire(false), ue(false), te(false) {} 2321 bool ire; 2322 bool ue; 2323 bool te; 2324 } _Cassandra_batch_mutate_result__isset; 2325 2326 class Cassandra_batch_mutate_result { 2327 public: 2328 2329 Cassandra_batch_mutate_result() { 2330 } 2331 2332 virtual ~Cassandra_batch_mutate_result() throw() {} 2333 2334 InvalidRequestException ire; 2335 UnavailableException ue; 2336 TimedOutException te; 2337 2338 _Cassandra_batch_mutate_result__isset __isset; 2339 2340 void __set_ire(const InvalidRequestException& val) { 2341 ire = val; 2342 } 2343 2344 void __set_ue(const UnavailableException& val) { 2345 ue = val; 2346 } 2347 2348 void __set_te(const TimedOutException& val) { 2349 te = val; 2350 } 2351 2352 bool operator == (const Cassandra_batch_mutate_result & rhs) const 2353 { 2354 if (!(ire == rhs.ire)) 2355 return false; 2356 if (!(ue == rhs.ue)) 2357 return false; 2358 if (!(te == rhs.te)) 2359 return false; 2360 return true; 2361 } 2362 bool operator != (const Cassandra_batch_mutate_result &rhs) const { 2363 return !(*this == rhs); 2364 } 2365 2366 bool operator < (const Cassandra_batch_mutate_result & ) const; 2367 2368 uint32_t read(::apache::thrift::protocol::TProtocol* iprot); 2369 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; 2370 2371 }; 2372 2373 typedef struct _Cassandra_batch_mutate_presult__isset { 2374 _Cassandra_batch_mutate_presult__isset() : ire(false), ue(false), te(false) {} 2375 bool ire; 2376 bool ue; 2377 bool te; 2378 } _Cassandra_batch_mutate_presult__isset; 2379 2380 class Cassandra_batch_mutate_presult { 2381 public: 2382 2383 2384 virtual ~Cassandra_batch_mutate_presult() throw() {} 2385 2386 InvalidRequestException ire; 2387 UnavailableException ue; 2388 TimedOutException te; 2389 2390 _Cassandra_batch_mutate_presult__isset __isset; 2391 2392 uint32_t read(::apache::thrift::protocol::TProtocol* iprot); 2393 2394 }; 2395 2396 2397 class Cassandra_truncate_args { 2398 public: 2399 2400 Cassandra_truncate_args() : cfname("") { 2401 } 2402 2403 virtual ~Cassandra_truncate_args() throw() {} 2404 2405 std::string cfname; 2406 2407 void __set_cfname(const std::string& val) { 2408 cfname = val; 2409 } 2410 2411 bool operator == (const Cassandra_truncate_args & rhs) const 2412 { 2413 if (!(cfname == rhs.cfname)) 2414 return false; 2415 return true; 2416 } 2417 bool operator != (const Cassandra_truncate_args &rhs) const { 2418 return !(*this == rhs); 2419 } 2420 2421 bool operator < (const Cassandra_truncate_args & ) const; 2422 2423 uint32_t read(::apache::thrift::protocol::TProtocol* iprot); 2424 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; 2425 2426 }; 2427 2428 2429 class Cassandra_truncate_pargs { 2430 public: 2431 2432 2433 virtual ~Cassandra_truncate_pargs() throw() {} 2434 2435 const std::string* cfname; 2436 2437 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; 2438 2439 }; 2440 2441 typedef struct _Cassandra_truncate_result__isset { 2442 _Cassandra_truncate_result__isset() : ire(false), ue(false), te(false) {} 2443 bool ire; 2444 bool ue; 2445 bool te; 2446 } _Cassandra_truncate_result__isset; 2447 2448 class Cassandra_truncate_result { 2449 public: 2450 2451 Cassandra_truncate_result() { 2452 } 2453 2454 virtual ~Cassandra_truncate_result() throw() {} 2455 2456 InvalidRequestException ire; 2457 UnavailableException ue; 2458 TimedOutException te; 2459 2460 _Cassandra_truncate_result__isset __isset; 2461 2462 void __set_ire(const InvalidRequestException& val) { 2463 ire = val; 2464 } 2465 2466 void __set_ue(const UnavailableException& val) { 2467 ue = val; 2468 } 2469 2470 void __set_te(const TimedOutException& val) { 2471 te = val; 2472 } 2473 2474 bool operator == (const Cassandra_truncate_result & rhs) const 2475 { 2476 if (!(ire == rhs.ire)) 2477 return false; 2478 if (!(ue == rhs.ue)) 2479 return false; 2480 if (!(te == rhs.te)) 2481 return false; 2482 return true; 2483 } 2484 bool operator != (const Cassandra_truncate_result &rhs) const { 2485 return !(*this == rhs); 2486 } 2487 2488 bool operator < (const Cassandra_truncate_result & ) const; 2489 2490 uint32_t read(::apache::thrift::protocol::TProtocol* iprot); 2491 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; 2492 2493 }; 2494 2495 typedef struct _Cassandra_truncate_presult__isset { 2496 _Cassandra_truncate_presult__isset() : ire(false), ue(false), te(false) {} 2497 bool ire; 2498 bool ue; 2499 bool te; 2500 } _Cassandra_truncate_presult__isset; 2501 2502 class Cassandra_truncate_presult { 2503 public: 2504 2505 2506 virtual ~Cassandra_truncate_presult() throw() {} 2507 2508 InvalidRequestException ire; 2509 UnavailableException ue; 2510 TimedOutException te; 2511 2512 _Cassandra_truncate_presult__isset __isset; 2513 2514 uint32_t read(::apache::thrift::protocol::TProtocol* iprot); 2515 2516 }; 2517 2518 2519 class Cassandra_describe_schema_versions_args { 2520 public: 2521 2522 Cassandra_describe_schema_versions_args() { 2523 } 2524 2525 virtual ~Cassandra_describe_schema_versions_args() throw() {} 2526 2527 2528 bool operator == (const Cassandra_describe_schema_versions_args & /* rhs */) const 2529 { 2530 return true; 2531 } 2532 bool operator != (const Cassandra_describe_schema_versions_args &rhs) const { 2533 return !(*this == rhs); 2534 } 2535 2536 bool operator < (const Cassandra_describe_schema_versions_args & ) const; 2537 2538 uint32_t read(::apache::thrift::protocol::TProtocol* iprot); 2539 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; 2540 2541 }; 2542 2543 2544 class Cassandra_describe_schema_versions_pargs { 2545 public: 2546 2547 2548 virtual ~Cassandra_describe_schema_versions_pargs() throw() {} 2549 2550 2551 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; 2552 2553 }; 2554 2555 typedef struct _Cassandra_describe_schema_versions_result__isset { 2556 _Cassandra_describe_schema_versions_result__isset() : success(false), ire(false) {} 2557 bool success; 2558 bool ire; 2559 } _Cassandra_describe_schema_versions_result__isset; 2560 2561 class Cassandra_describe_schema_versions_result { 2562 public: 2563 2564 Cassandra_describe_schema_versions_result() { 2565 } 2566 2567 virtual ~Cassandra_describe_schema_versions_result() throw() {} 2568 2569 std::map<std::string, std::vector<std::string> > success; 2570 InvalidRequestException ire; 2571 2572 _Cassandra_describe_schema_versions_result__isset __isset; 2573 2574 void __set_success(const std::map<std::string, std::vector<std::string> > & val) { 2575 success = val; 2576 } 2577 2578 void __set_ire(const InvalidRequestException& val) { 2579 ire = val; 2580 } 2581 2582 bool operator == (const Cassandra_describe_schema_versions_result & rhs) const 2583 { 2584 if (!(success == rhs.success)) 2585 return false; 2586 if (!(ire == rhs.ire)) 2587 return false; 2588 return true; 2589 } 2590 bool operator != (const Cassandra_describe_schema_versions_result &rhs) const { 2591 return !(*this == rhs); 2592 } 2593 2594 bool operator < (const Cassandra_describe_schema_versions_result & ) const; 2595 2596 uint32_t read(::apache::thrift::protocol::TProtocol* iprot); 2597 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; 2598 2599 }; 2600 2601 typedef struct _Cassandra_describe_schema_versions_presult__isset { 2602 _Cassandra_describe_schema_versions_presult__isset() : success(false), ire(false) {} 2603 bool success; 2604 bool ire; 2605 } _Cassandra_describe_schema_versions_presult__isset; 2606 2607 class Cassandra_describe_schema_versions_presult { 2608 public: 2609 2610 2611 virtual ~Cassandra_describe_schema_versions_presult() throw() {} 2612 2613 std::map<std::string, std::vector<std::string> > * success; 2614 InvalidRequestException ire; 2615 2616 _Cassandra_describe_schema_versions_presult__isset __isset; 2617 2618 uint32_t read(::apache::thrift::protocol::TProtocol* iprot); 2619 2620 }; 2621 2622 2623 class Cassandra_describe_keyspaces_args { 2624 public: 2625 2626 Cassandra_describe_keyspaces_args() { 2627 } 2628 2629 virtual ~Cassandra_describe_keyspaces_args() throw() {} 2630 2631 2632 bool operator == (const Cassandra_describe_keyspaces_args & /* rhs */) const 2633 { 2634 return true; 2635 } 2636 bool operator != (const Cassandra_describe_keyspaces_args &rhs) const { 2637 return !(*this == rhs); 2638 } 2639 2640 bool operator < (const Cassandra_describe_keyspaces_args & ) const; 2641 2642 uint32_t read(::apache::thrift::protocol::TProtocol* iprot); 2643 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; 2644 2645 }; 2646 2647 2648 class Cassandra_describe_keyspaces_pargs { 2649 public: 2650 2651 2652 virtual ~Cassandra_describe_keyspaces_pargs() throw() {} 2653 2654 2655 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; 2656 2657 }; 2658 2659 typedef struct _Cassandra_describe_keyspaces_result__isset { 2660 _Cassandra_describe_keyspaces_result__isset() : success(false), ire(false) {} 2661 bool success; 2662 bool ire; 2663 } _Cassandra_describe_keyspaces_result__isset; 2664 2665 class Cassandra_describe_keyspaces_result { 2666 public: 2667 2668 Cassandra_describe_keyspaces_result() { 2669 } 2670 2671 virtual ~Cassandra_describe_keyspaces_result() throw() {} 2672 2673 std::vector<KsDef> success; 2674 InvalidRequestException ire; 2675 2676 _Cassandra_describe_keyspaces_result__isset __isset; 2677 2678 void __set_success(const std::vector<KsDef> & val) { 2679 success = val; 2680 } 2681 2682 void __set_ire(const InvalidRequestException& val) { 2683 ire = val; 2684 } 2685 2686 bool operator == (const Cassandra_describe_keyspaces_result & rhs) const 2687 { 2688 if (!(success == rhs.success)) 2689 return false; 2690 if (!(ire == rhs.ire)) 2691 return false; 2692 return true; 2693 } 2694 bool operator != (const Cassandra_describe_keyspaces_result &rhs) const { 2695 return !(*this == rhs); 2696 } 2697 2698 bool operator < (const Cassandra_describe_keyspaces_result & ) const; 2699 2700 uint32_t read(::apache::thrift::protocol::TProtocol* iprot); 2701 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; 2702 2703 }; 2704 2705 typedef struct _Cassandra_describe_keyspaces_presult__isset { 2706 _Cassandra_describe_keyspaces_presult__isset() : success(false), ire(false) {} 2707 bool success; 2708 bool ire; 2709 } _Cassandra_describe_keyspaces_presult__isset; 2710 2711 class Cassandra_describe_keyspaces_presult { 2712 public: 2713 2714 2715 virtual ~Cassandra_describe_keyspaces_presult() throw() {} 2716 2717 std::vector<KsDef> * success; 2718 InvalidRequestException ire; 2719 2720 _Cassandra_describe_keyspaces_presult__isset __isset; 2721 2722 uint32_t read(::apache::thrift::protocol::TProtocol* iprot); 2723 2724 }; 2725 2726 2727 class Cassandra_describe_cluster_name_args { 2728 public: 2729 2730 Cassandra_describe_cluster_name_args() { 2731 } 2732 2733 virtual ~Cassandra_describe_cluster_name_args() throw() {} 2734 2735 2736 bool operator == (const Cassandra_describe_cluster_name_args & /* rhs */) const 2737 { 2738 return true; 2739 } 2740 bool operator != (const Cassandra_describe_cluster_name_args &rhs) const { 2741 return !(*this == rhs); 2742 } 2743 2744 bool operator < (const Cassandra_describe_cluster_name_args & ) const; 2745 2746 uint32_t read(::apache::thrift::protocol::TProtocol* iprot); 2747 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; 2748 2749 }; 2750 2751 2752 class Cassandra_describe_cluster_name_pargs { 2753 public: 2754 2755 2756 virtual ~Cassandra_describe_cluster_name_pargs() throw() {} 2757 2758 2759 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; 2760 2761 }; 2762 2763 typedef struct _Cassandra_describe_cluster_name_result__isset { 2764 _Cassandra_describe_cluster_name_result__isset() : success(false) {} 2765 bool success; 2766 } _Cassandra_describe_cluster_name_result__isset; 2767 2768 class Cassandra_describe_cluster_name_result { 2769 public: 2770 2771 Cassandra_describe_cluster_name_result() : success("") { 2772 } 2773 2774 virtual ~Cassandra_describe_cluster_name_result() throw() {} 2775 2776 std::string success; 2777 2778 _Cassandra_describe_cluster_name_result__isset __isset; 2779 2780 void __set_success(const std::string& val) { 2781 success = val; 2782 } 2783 2784 bool operator == (const Cassandra_describe_cluster_name_result & rhs) const 2785 { 2786 if (!(success == rhs.success)) 2787 return false; 2788 return true; 2789 } 2790 bool operator != (const Cassandra_describe_cluster_name_result &rhs) const { 2791 return !(*this == rhs); 2792 } 2793 2794 bool operator < (const Cassandra_describe_cluster_name_result & ) const; 2795 2796 uint32_t read(::apache::thrift::protocol::TProtocol* iprot); 2797 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; 2798 2799 }; 2800 2801 typedef struct _Cassandra_describe_cluster_name_presult__isset { 2802 _Cassandra_describe_cluster_name_presult__isset() : success(false) {} 2803 bool success; 2804 } _Cassandra_describe_cluster_name_presult__isset; 2805 2806 class Cassandra_describe_cluster_name_presult { 2807 public: 2808 2809 2810 virtual ~Cassandra_describe_cluster_name_presult() throw() {} 2811 2812 std::string* success; 2813 2814 _Cassandra_describe_cluster_name_presult__isset __isset; 2815 2816 uint32_t read(::apache::thrift::protocol::TProtocol* iprot); 2817 2818 }; 2819 2820 2821 class Cassandra_describe_version_args { 2822 public: 2823 2824 Cassandra_describe_version_args() { 2825 } 2826 2827 virtual ~Cassandra_describe_version_args() throw() {} 2828 2829 2830 bool operator == (const Cassandra_describe_version_args & /* rhs */) const 2831 { 2832 return true; 2833 } 2834 bool operator != (const Cassandra_describe_version_args &rhs) const { 2835 return !(*this == rhs); 2836 } 2837 2838 bool operator < (const Cassandra_describe_version_args & ) const; 2839 2840 uint32_t read(::apache::thrift::protocol::TProtocol* iprot); 2841 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; 2842 2843 }; 2844 2845 2846 class Cassandra_describe_version_pargs { 2847 public: 2848 2849 2850 virtual ~Cassandra_describe_version_pargs() throw() {} 2851 2852 2853 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; 2854 2855 }; 2856 2857 typedef struct _Cassandra_describe_version_result__isset { 2858 _Cassandra_describe_version_result__isset() : success(false) {} 2859 bool success; 2860 } _Cassandra_describe_version_result__isset; 2861 2862 class Cassandra_describe_version_result { 2863 public: 2864 2865 Cassandra_describe_version_result() : success("") { 2866 } 2867 2868 virtual ~Cassandra_describe_version_result() throw() {} 2869 2870 std::string success; 2871 2872 _Cassandra_describe_version_result__isset __isset; 2873 2874 void __set_success(const std::string& val) { 2875 success = val; 2876 } 2877 2878 bool operator == (const Cassandra_describe_version_result & rhs) const 2879 { 2880 if (!(success == rhs.success)) 2881 return false; 2882 return true; 2883 } 2884 bool operator != (const Cassandra_describe_version_result &rhs) const { 2885 return !(*this == rhs); 2886 } 2887 2888 bool operator < (const Cassandra_describe_version_result & ) const; 2889 2890 uint32_t read(::apache::thrift::protocol::TProtocol* iprot); 2891 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; 2892 2893 }; 2894 2895 typedef struct _Cassandra_describe_version_presult__isset { 2896 _Cassandra_describe_version_presult__isset() : success(false) {} 2897 bool success; 2898 } _Cassandra_describe_version_presult__isset; 2899 2900 class Cassandra_describe_version_presult { 2901 public: 2902 2903 2904 virtual ~Cassandra_describe_version_presult() throw() {} 2905 2906 std::string* success; 2907 2908 _Cassandra_describe_version_presult__isset __isset; 2909 2910 uint32_t read(::apache::thrift::protocol::TProtocol* iprot); 2911 2912 }; 2913 2914 2915 class Cassandra_describe_ring_args { 2916 public: 2917 2918 Cassandra_describe_ring_args() : keyspace("") { 2919 } 2920 2921 virtual ~Cassandra_describe_ring_args() throw() {} 2922 2923 std::string keyspace; 2924 2925 void __set_keyspace(const std::string& val) { 2926 keyspace = val; 2927 } 2928 2929 bool operator == (const Cassandra_describe_ring_args & rhs) const 2930 { 2931 if (!(keyspace == rhs.keyspace)) 2932 return false; 2933 return true; 2934 } 2935 bool operator != (const Cassandra_describe_ring_args &rhs) const { 2936 return !(*this == rhs); 2937 } 2938 2939 bool operator < (const Cassandra_describe_ring_args & ) const; 2940 2941 uint32_t read(::apache::thrift::protocol::TProtocol* iprot); 2942 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; 2943 2944 }; 2945 2946 2947 class Cassandra_describe_ring_pargs { 2948 public: 2949 2950 2951 virtual ~Cassandra_describe_ring_pargs() throw() {} 2952 2953 const std::string* keyspace; 2954 2955 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; 2956 2957 }; 2958 2959 typedef struct _Cassandra_describe_ring_result__isset { 2960 _Cassandra_describe_ring_result__isset() : success(false), ire(false) {} 2961 bool success; 2962 bool ire; 2963 } _Cassandra_describe_ring_result__isset; 2964 2965 class Cassandra_describe_ring_result { 2966 public: 2967 2968 Cassandra_describe_ring_result() { 2969 } 2970 2971 virtual ~Cassandra_describe_ring_result() throw() {} 2972 2973 std::vector<TokenRange> success; 2974 InvalidRequestException ire; 2975 2976 _Cassandra_describe_ring_result__isset __isset; 2977 2978 void __set_success(const std::vector<TokenRange> & val) { 2979 success = val; 2980 } 2981 2982 void __set_ire(const InvalidRequestException& val) { 2983 ire = val; 2984 } 2985 2986 bool operator == (const Cassandra_describe_ring_result & rhs) const 2987 { 2988 if (!(success == rhs.success)) 2989 return false; 2990 if (!(ire == rhs.ire)) 2991 return false; 2992 return true; 2993 } 2994 bool operator != (const Cassandra_describe_ring_result &rhs) const { 2995 return !(*this == rhs); 2996 } 2997 2998 bool operator < (const Cassandra_describe_ring_result & ) const; 2999 3000 uint32_t read(::apache::thrift::protocol::TProtocol* iprot); 3001 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; 3002 3003 }; 3004 3005 typedef struct _Cassandra_describe_ring_presult__isset { 3006 _Cassandra_describe_ring_presult__isset() : success(false), ire(false) {} 3007 bool success; 3008 bool ire; 3009 } _Cassandra_describe_ring_presult__isset; 3010 3011 class Cassandra_describe_ring_presult { 3012 public: 3013 3014 3015 virtual ~Cassandra_describe_ring_presult() throw() {} 3016 3017 std::vector<TokenRange> * success; 3018 InvalidRequestException ire; 3019 3020 _Cassandra_describe_ring_presult__isset __isset; 3021 3022 uint32_t read(::apache::thrift::protocol::TProtocol* iprot); 3023 3024 }; 3025 3026 3027 class Cassandra_describe_token_map_args { 3028 public: 3029 3030 Cassandra_describe_token_map_args() { 3031 } 3032 3033 virtual ~Cassandra_describe_token_map_args() throw() {} 3034 3035 3036 bool operator == (const Cassandra_describe_token_map_args & /* rhs */) const 3037 { 3038 return true; 3039 } 3040 bool operator != (const Cassandra_describe_token_map_args &rhs) const { 3041 return !(*this == rhs); 3042 } 3043 3044 bool operator < (const Cassandra_describe_token_map_args & ) const; 3045 3046 uint32_t read(::apache::thrift::protocol::TProtocol* iprot); 3047 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; 3048 3049 }; 3050 3051 3052 class Cassandra_describe_token_map_pargs { 3053 public: 3054 3055 3056 virtual ~Cassandra_describe_token_map_pargs() throw() {} 3057 3058 3059 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; 3060 3061 }; 3062 3063 typedef struct _Cassandra_describe_token_map_result__isset { 3064 _Cassandra_describe_token_map_result__isset() : success(false), ire(false) {} 3065 bool success; 3066 bool ire; 3067 } _Cassandra_describe_token_map_result__isset; 3068 3069 class Cassandra_describe_token_map_result { 3070 public: 3071 3072 Cassandra_describe_token_map_result() { 3073 } 3074 3075 virtual ~Cassandra_describe_token_map_result() throw() {} 3076 3077 std::map<std::string, std::string> success; 3078 InvalidRequestException ire; 3079 3080 _Cassandra_describe_token_map_result__isset __isset; 3081 3082 void __set_success(const std::map<std::string, std::string> & val) { 3083 success = val; 3084 } 3085 3086 void __set_ire(const InvalidRequestException& val) { 3087 ire = val; 3088 } 3089 3090 bool operator == (const Cassandra_describe_token_map_result & rhs) const 3091 { 3092 if (!(success == rhs.success)) 3093 return false; 3094 if (!(ire == rhs.ire)) 3095 return false; 3096 return true; 3097 } 3098 bool operator != (const Cassandra_describe_token_map_result &rhs) const { 3099 return !(*this == rhs); 3100 } 3101 3102 bool operator < (const Cassandra_describe_token_map_result & ) const; 3103 3104 uint32_t read(::apache::thrift::protocol::TProtocol* iprot); 3105 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; 3106 3107 }; 3108 3109 typedef struct _Cassandra_describe_token_map_presult__isset { 3110 _Cassandra_describe_token_map_presult__isset() : success(false), ire(false) {} 3111 bool success; 3112 bool ire; 3113 } _Cassandra_describe_token_map_presult__isset; 3114 3115 class Cassandra_describe_token_map_presult { 3116 public: 3117 3118 3119 virtual ~Cassandra_describe_token_map_presult() throw() {} 3120 3121 std::map<std::string, std::string> * success; 3122 InvalidRequestException ire; 3123 3124 _Cassandra_describe_token_map_presult__isset __isset; 3125 3126 uint32_t read(::apache::thrift::protocol::TProtocol* iprot); 3127 3128 }; 3129 3130 3131 class Cassandra_describe_partitioner_args { 3132 public: 3133 3134 Cassandra_describe_partitioner_args() { 3135 } 3136 3137 virtual ~Cassandra_describe_partitioner_args() throw() {} 3138 3139 3140 bool operator == (const Cassandra_describe_partitioner_args & /* rhs */) const 3141 { 3142 return true; 3143 } 3144 bool operator != (const Cassandra_describe_partitioner_args &rhs) const { 3145 return !(*this == rhs); 3146 } 3147 3148 bool operator < (const Cassandra_describe_partitioner_args & ) const; 3149 3150 uint32_t read(::apache::thrift::protocol::TProtocol* iprot); 3151 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; 3152 3153 }; 3154 3155 3156 class Cassandra_describe_partitioner_pargs { 3157 public: 3158 3159 3160 virtual ~Cassandra_describe_partitioner_pargs() throw() {} 3161 3162 3163 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; 3164 3165 }; 3166 3167 typedef struct _Cassandra_describe_partitioner_result__isset { 3168 _Cassandra_describe_partitioner_result__isset() : success(false) {} 3169 bool success; 3170 } _Cassandra_describe_partitioner_result__isset; 3171 3172 class Cassandra_describe_partitioner_result { 3173 public: 3174 3175 Cassandra_describe_partitioner_result() : success("") { 3176 } 3177 3178 virtual ~Cassandra_describe_partitioner_result() throw() {} 3179 3180 std::string success; 3181 3182 _Cassandra_describe_partitioner_result__isset __isset; 3183 3184 void __set_success(const std::string& val) { 3185 success = val; 3186 } 3187 3188 bool operator == (const Cassandra_describe_partitioner_result & rhs) const 3189 { 3190 if (!(success == rhs.success)) 3191 return false; 3192 return true; 3193 } 3194 bool operator != (const Cassandra_describe_partitioner_result &rhs) const { 3195 return !(*this == rhs); 3196 } 3197 3198 bool operator < (const Cassandra_describe_partitioner_result & ) const; 3199 3200 uint32_t read(::apache::thrift::protocol::TProtocol* iprot); 3201 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; 3202 3203 }; 3204 3205 typedef struct _Cassandra_describe_partitioner_presult__isset { 3206 _Cassandra_describe_partitioner_presult__isset() : success(false) {} 3207 bool success; 3208 } _Cassandra_describe_partitioner_presult__isset; 3209 3210 class Cassandra_describe_partitioner_presult { 3211 public: 3212 3213 3214 virtual ~Cassandra_describe_partitioner_presult() throw() {} 3215 3216 std::string* success; 3217 3218 _Cassandra_describe_partitioner_presult__isset __isset; 3219 3220 uint32_t read(::apache::thrift::protocol::TProtocol* iprot); 3221 3222 }; 3223 3224 3225 class Cassandra_describe_snitch_args { 3226 public: 3227 3228 Cassandra_describe_snitch_args() { 3229 } 3230 3231 virtual ~Cassandra_describe_snitch_args() throw() {} 3232 3233 3234 bool operator == (const Cassandra_describe_snitch_args & /* rhs */) const 3235 { 3236 return true; 3237 } 3238 bool operator != (const Cassandra_describe_snitch_args &rhs) const { 3239 return !(*this == rhs); 3240 } 3241 3242 bool operator < (const Cassandra_describe_snitch_args & ) const; 3243 3244 uint32_t read(::apache::thrift::protocol::TProtocol* iprot); 3245 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; 3246 3247 }; 3248 3249 3250 class Cassandra_describe_snitch_pargs { 3251 public: 3252 3253 3254 virtual ~Cassandra_describe_snitch_pargs() throw() {} 3255 3256 3257 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; 3258 3259 }; 3260 3261 typedef struct _Cassandra_describe_snitch_result__isset { 3262 _Cassandra_describe_snitch_result__isset() : success(false) {} 3263 bool success; 3264 } _Cassandra_describe_snitch_result__isset; 3265 3266 class Cassandra_describe_snitch_result { 3267 public: 3268 3269 Cassandra_describe_snitch_result() : success("") { 3270 } 3271 3272 virtual ~Cassandra_describe_snitch_result() throw() {} 3273 3274 std::string success; 3275 3276 _Cassandra_describe_snitch_result__isset __isset; 3277 3278 void __set_success(const std::string& val) { 3279 success = val; 3280 } 3281 3282 bool operator == (const Cassandra_describe_snitch_result & rhs) const 3283 { 3284 if (!(success == rhs.success)) 3285 return false; 3286 return true; 3287 } 3288 bool operator != (const Cassandra_describe_snitch_result &rhs) const { 3289 return !(*this == rhs); 3290 } 3291 3292 bool operator < (const Cassandra_describe_snitch_result & ) const; 3293 3294 uint32_t read(::apache::thrift::protocol::TProtocol* iprot); 3295 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; 3296 3297 }; 3298 3299 typedef struct _Cassandra_describe_snitch_presult__isset { 3300 _Cassandra_describe_snitch_presult__isset() : success(false) {} 3301 bool success; 3302 } _Cassandra_describe_snitch_presult__isset; 3303 3304 class Cassandra_describe_snitch_presult { 3305 public: 3306 3307 3308 virtual ~Cassandra_describe_snitch_presult() throw() {} 3309 3310 std::string* success; 3311 3312 _Cassandra_describe_snitch_presult__isset __isset; 3313 3314 uint32_t read(::apache::thrift::protocol::TProtocol* iprot); 3315 3316 }; 3317 3318 3319 class Cassandra_describe_keyspace_args { 3320 public: 3321 3322 Cassandra_describe_keyspace_args() : keyspace("") { 3323 } 3324 3325 virtual ~Cassandra_describe_keyspace_args() throw() {} 3326 3327 std::string keyspace; 3328 3329 void __set_keyspace(const std::string& val) { 3330 keyspace = val; 3331 } 3332 3333 bool operator == (const Cassandra_describe_keyspace_args & rhs) const 3334 { 3335 if (!(keyspace == rhs.keyspace)) 3336 return false; 3337 return true; 3338 } 3339 bool operator != (const Cassandra_describe_keyspace_args &rhs) const { 3340 return !(*this == rhs); 3341 } 3342 3343 bool operator < (const Cassandra_describe_keyspace_args & ) const; 3344 3345 uint32_t read(::apache::thrift::protocol::TProtocol* iprot); 3346 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; 3347 3348 }; 3349 3350 3351 class Cassandra_describe_keyspace_pargs { 3352 public: 3353 3354 3355 virtual ~Cassandra_describe_keyspace_pargs() throw() {} 3356 3357 const std::string* keyspace; 3358 3359 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; 3360 3361 }; 3362 3363 typedef struct _Cassandra_describe_keyspace_result__isset { 3364 _Cassandra_describe_keyspace_result__isset() : success(false), nfe(false), ire(false) {} 3365 bool success; 3366 bool nfe; 3367 bool ire; 3368 } _Cassandra_describe_keyspace_result__isset; 3369 3370 class Cassandra_describe_keyspace_result { 3371 public: 3372 3373 Cassandra_describe_keyspace_result() { 3374 } 3375 3376 virtual ~Cassandra_describe_keyspace_result() throw() {} 3377 3378 KsDef success; 3379 NotFoundException nfe; 3380 InvalidRequestException ire; 3381 3382 _Cassandra_describe_keyspace_result__isset __isset; 3383 3384 void __set_success(const KsDef& val) { 3385 success = val; 3386 } 3387 3388 void __set_nfe(const NotFoundException& val) { 3389 nfe = val; 3390 } 3391 3392 void __set_ire(const InvalidRequestException& val) { 3393 ire = val; 3394 } 3395 3396 bool operator == (const Cassandra_describe_keyspace_result & rhs) const 3397 { 3398 if (!(success == rhs.success)) 3399 return false; 3400 if (!(nfe == rhs.nfe)) 3401 return false; 3402 if (!(ire == rhs.ire)) 3403 return false; 3404 return true; 3405 } 3406 bool operator != (const Cassandra_describe_keyspace_result &rhs) const { 3407 return !(*this == rhs); 3408 } 3409 3410 bool operator < (const Cassandra_describe_keyspace_result & ) const; 3411 3412 uint32_t read(::apache::thrift::protocol::TProtocol* iprot); 3413 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; 3414 3415 }; 3416 3417 typedef struct _Cassandra_describe_keyspace_presult__isset { 3418 _Cassandra_describe_keyspace_presult__isset() : success(false), nfe(false), ire(false) {} 3419 bool success; 3420 bool nfe; 3421 bool ire; 3422 } _Cassandra_describe_keyspace_presult__isset; 3423 3424 class Cassandra_describe_keyspace_presult { 3425 public: 3426 3427 3428 virtual ~Cassandra_describe_keyspace_presult() throw() {} 3429 3430 KsDef* success; 3431 NotFoundException nfe; 3432 InvalidRequestException ire; 3433 3434 _Cassandra_describe_keyspace_presult__isset __isset; 3435 3436 uint32_t read(::apache::thrift::protocol::TProtocol* iprot); 3437 3438 }; 3439 3440 3441 class Cassandra_describe_splits_args { 3442 public: 3443 3444 Cassandra_describe_splits_args() : cfName(""), start_token(""), end_token(""), keys_per_split(0) { 3445 } 3446 3447 virtual ~Cassandra_describe_splits_args() throw() {} 3448 3449 std::string cfName; 3450 std::string start_token; 3451 std::string end_token; 3452 int32_t keys_per_split; 3453 3454 void __set_cfName(const std::string& val) { 3455 cfName = val; 3456 } 3457 3458 void __set_start_token(const std::string& val) { 3459 start_token = val; 3460 } 3461 3462 void __set_end_token(const std::string& val) { 3463 end_token = val; 3464 } 3465 3466 void __set_keys_per_split(const int32_t val) { 3467 keys_per_split = val; 3468 } 3469 3470 bool operator == (const Cassandra_describe_splits_args & rhs) const 3471 { 3472 if (!(cfName == rhs.cfName)) 3473 return false; 3474 if (!(start_token == rhs.start_token)) 3475 return false; 3476 if (!(end_token == rhs.end_token)) 3477 return false; 3478 if (!(keys_per_split == rhs.keys_per_split)) 3479 return false; 3480 return true; 3481 } 3482 bool operator != (const Cassandra_describe_splits_args &rhs) const { 3483 return !(*this == rhs); 3484 } 3485 3486 bool operator < (const Cassandra_describe_splits_args & ) const; 3487 3488 uint32_t read(::apache::thrift::protocol::TProtocol* iprot); 3489 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; 3490 3491 }; 3492 3493 3494 class Cassandra_describe_splits_pargs { 3495 public: 3496 3497 3498 virtual ~Cassandra_describe_splits_pargs() throw() {} 3499 3500 const std::string* cfName; 3501 const std::string* start_token; 3502 const std::string* end_token; 3503 const int32_t* keys_per_split; 3504 3505 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; 3506 3507 }; 3508 3509 typedef struct _Cassandra_describe_splits_result__isset { 3510 _Cassandra_describe_splits_result__isset() : success(false), ire(false) {} 3511 bool success; 3512 bool ire; 3513 } _Cassandra_describe_splits_result__isset; 3514 3515 class Cassandra_describe_splits_result { 3516 public: 3517 3518 Cassandra_describe_splits_result() { 3519 } 3520 3521 virtual ~Cassandra_describe_splits_result() throw() {} 3522 3523 std::vector<std::string> success; 3524 InvalidRequestException ire; 3525 3526 _Cassandra_describe_splits_result__isset __isset; 3527 3528 void __set_success(const std::vector<std::string> & val) { 3529 success = val; 3530 } 3531 3532 void __set_ire(const InvalidRequestException& val) { 3533 ire = val; 3534 } 3535 3536 bool operator == (const Cassandra_describe_splits_result & rhs) const 3537 { 3538 if (!(success == rhs.success)) 3539 return false; 3540 if (!(ire == rhs.ire)) 3541 return false; 3542 return true; 3543 } 3544 bool operator != (const Cassandra_describe_splits_result &rhs) const { 3545 return !(*this == rhs); 3546 } 3547 3548 bool operator < (const Cassandra_describe_splits_result & ) const; 3549 3550 uint32_t read(::apache::thrift::protocol::TProtocol* iprot); 3551 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; 3552 3553 }; 3554 3555 typedef struct _Cassandra_describe_splits_presult__isset { 3556 _Cassandra_describe_splits_presult__isset() : success(false), ire(false) {} 3557 bool success; 3558 bool ire; 3559 } _Cassandra_describe_splits_presult__isset; 3560 3561 class Cassandra_describe_splits_presult { 3562 public: 3563 3564 3565 virtual ~Cassandra_describe_splits_presult() throw() {} 3566 3567 std::vector<std::string> * success; 3568 InvalidRequestException ire; 3569 3570 _Cassandra_describe_splits_presult__isset __isset; 3571 3572 uint32_t read(::apache::thrift::protocol::TProtocol* iprot); 3573 3574 }; 3575 3576 3577 class Cassandra_system_add_column_family_args { 3578 public: 3579 3580 Cassandra_system_add_column_family_args() { 3581 } 3582 3583 virtual ~Cassandra_system_add_column_family_args() throw() {} 3584 3585 CfDef cf_def; 3586 3587 void __set_cf_def(const CfDef& val) { 3588 cf_def = val; 3589 } 3590 3591 bool operator == (const Cassandra_system_add_column_family_args & rhs) const 3592 { 3593 if (!(cf_def == rhs.cf_def)) 3594 return false; 3595 return true; 3596 } 3597 bool operator != (const Cassandra_system_add_column_family_args &rhs) const { 3598 return !(*this == rhs); 3599 } 3600 3601 bool operator < (const Cassandra_system_add_column_family_args & ) const; 3602 3603 uint32_t read(::apache::thrift::protocol::TProtocol* iprot); 3604 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; 3605 3606 }; 3607 3608 3609 class Cassandra_system_add_column_family_pargs { 3610 public: 3611 3612 3613 virtual ~Cassandra_system_add_column_family_pargs() throw() {} 3614 3615 const CfDef* cf_def; 3616 3617 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; 3618 3619 }; 3620 3621 typedef struct _Cassandra_system_add_column_family_result__isset { 3622 _Cassandra_system_add_column_family_result__isset() : success(false), ire(false), sde(false) {} 3623 bool success; 3624 bool ire; 3625 bool sde; 3626 } _Cassandra_system_add_column_family_result__isset; 3627 3628 class Cassandra_system_add_column_family_result { 3629 public: 3630 3631 Cassandra_system_add_column_family_result() : success("") { 3632 } 3633 3634 virtual ~Cassandra_system_add_column_family_result() throw() {} 3635 3636 std::string success; 3637 InvalidRequestException ire; 3638 SchemaDisagreementException sde; 3639 3640 _Cassandra_system_add_column_family_result__isset __isset; 3641 3642 void __set_success(const std::string& val) { 3643 success = val; 3644 } 3645 3646 void __set_ire(const InvalidRequestException& val) { 3647 ire = val; 3648 } 3649 3650 void __set_sde(const SchemaDisagreementException& val) { 3651 sde = val; 3652 } 3653 3654 bool operator == (const Cassandra_system_add_column_family_result & rhs) const 3655 { 3656 if (!(success == rhs.success)) 3657 return false; 3658 if (!(ire == rhs.ire)) 3659 return false; 3660 if (!(sde == rhs.sde)) 3661 return false; 3662 return true; 3663 } 3664 bool operator != (const Cassandra_system_add_column_family_result &rhs) const { 3665 return !(*this == rhs); 3666 } 3667 3668 bool operator < (const Cassandra_system_add_column_family_result & ) const; 3669 3670 uint32_t read(::apache::thrift::protocol::TProtocol* iprot); 3671 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; 3672 3673 }; 3674 3675 typedef struct _Cassandra_system_add_column_family_presult__isset { 3676 _Cassandra_system_add_column_family_presult__isset() : success(false), ire(false), sde(false) {} 3677 bool success; 3678 bool ire; 3679 bool sde; 3680 } _Cassandra_system_add_column_family_presult__isset; 3681 3682 class Cassandra_system_add_column_family_presult { 3683 public: 3684 3685 3686 virtual ~Cassandra_system_add_column_family_presult() throw() {} 3687 3688 std::string* success; 3689 InvalidRequestException ire; 3690 SchemaDisagreementException sde; 3691 3692 _Cassandra_system_add_column_family_presult__isset __isset; 3693 3694 uint32_t read(::apache::thrift::protocol::TProtocol* iprot); 3695 3696 }; 3697 3698 3699 class Cassandra_system_drop_column_family_args { 3700 public: 3701 3702 Cassandra_system_drop_column_family_args() : column_family("") { 3703 } 3704 3705 virtual ~Cassandra_system_drop_column_family_args() throw() {} 3706 3707 std::string column_family; 3708 3709 void __set_column_family(const std::string& val) { 3710 column_family = val; 3711 } 3712 3713 bool operator == (const Cassandra_system_drop_column_family_args & rhs) const 3714 { 3715 if (!(column_family == rhs.column_family)) 3716 return false; 3717 return true; 3718 } 3719 bool operator != (const Cassandra_system_drop_column_family_args &rhs) const { 3720 return !(*this == rhs); 3721 } 3722 3723 bool operator < (const Cassandra_system_drop_column_family_args & ) const; 3724 3725 uint32_t read(::apache::thrift::protocol::TProtocol* iprot); 3726 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; 3727 3728 }; 3729 3730 3731 class Cassandra_system_drop_column_family_pargs { 3732 public: 3733 3734 3735 virtual ~Cassandra_system_drop_column_family_pargs() throw() {} 3736 3737 const std::string* column_family; 3738 3739 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; 3740 3741 }; 3742 3743 typedef struct _Cassandra_system_drop_column_family_result__isset { 3744 _Cassandra_system_drop_column_family_result__isset() : success(false), ire(false), sde(false) {} 3745 bool success; 3746 bool ire; 3747 bool sde; 3748 } _Cassandra_system_drop_column_family_result__isset; 3749 3750 class Cassandra_system_drop_column_family_result { 3751 public: 3752 3753 Cassandra_system_drop_column_family_result() : success("") { 3754 } 3755 3756 virtual ~Cassandra_system_drop_column_family_result() throw() {} 3757 3758 std::string success; 3759 InvalidRequestException ire; 3760 SchemaDisagreementException sde; 3761 3762 _Cassandra_system_drop_column_family_result__isset __isset; 3763 3764 void __set_success(const std::string& val) { 3765 success = val; 3766 } 3767 3768 void __set_ire(const InvalidRequestException& val) { 3769 ire = val; 3770 } 3771 3772 void __set_sde(const SchemaDisagreementException& val) { 3773 sde = val; 3774 } 3775 3776 bool operator == (const Cassandra_system_drop_column_family_result & rhs) const 3777 { 3778 if (!(success == rhs.success)) 3779 return false; 3780 if (!(ire == rhs.ire)) 3781 return false; 3782 if (!(sde == rhs.sde)) 3783 return false; 3784 return true; 3785 } 3786 bool operator != (const Cassandra_system_drop_column_family_result &rhs) const { 3787 return !(*this == rhs); 3788 } 3789 3790 bool operator < (const Cassandra_system_drop_column_family_result & ) const; 3791 3792 uint32_t read(::apache::thrift::protocol::TProtocol* iprot); 3793 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; 3794 3795 }; 3796 3797 typedef struct _Cassandra_system_drop_column_family_presult__isset { 3798 _Cassandra_system_drop_column_family_presult__isset() : success(false), ire(false), sde(false) {} 3799 bool success; 3800 bool ire; 3801 bool sde; 3802 } _Cassandra_system_drop_column_family_presult__isset; 3803 3804 class Cassandra_system_drop_column_family_presult { 3805 public: 3806 3807 3808 virtual ~Cassandra_system_drop_column_family_presult() throw() {} 3809 3810 std::string* success; 3811 InvalidRequestException ire; 3812 SchemaDisagreementException sde; 3813 3814 _Cassandra_system_drop_column_family_presult__isset __isset; 3815 3816 uint32_t read(::apache::thrift::protocol::TProtocol* iprot); 3817 3818 }; 3819 3820 3821 class Cassandra_system_add_keyspace_args { 3822 public: 3823 3824 Cassandra_system_add_keyspace_args() { 3825 } 3826 3827 virtual ~Cassandra_system_add_keyspace_args() throw() {} 3828 3829 KsDef ks_def; 3830 3831 void __set_ks_def(const KsDef& val) { 3832 ks_def = val; 3833 } 3834 3835 bool operator == (const Cassandra_system_add_keyspace_args & rhs) const 3836 { 3837 if (!(ks_def == rhs.ks_def)) 3838 return false; 3839 return true; 3840 } 3841 bool operator != (const Cassandra_system_add_keyspace_args &rhs) const { 3842 return !(*this == rhs); 3843 } 3844 3845 bool operator < (const Cassandra_system_add_keyspace_args & ) const; 3846 3847 uint32_t read(::apache::thrift::protocol::TProtocol* iprot); 3848 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; 3849 3850 }; 3851 3852 3853 class Cassandra_system_add_keyspace_pargs { 3854 public: 3855 3856 3857 virtual ~Cassandra_system_add_keyspace_pargs() throw() {} 3858 3859 const KsDef* ks_def; 3860 3861 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; 3862 3863 }; 3864 3865 typedef struct _Cassandra_system_add_keyspace_result__isset { 3866 _Cassandra_system_add_keyspace_result__isset() : success(false), ire(false), sde(false) {} 3867 bool success; 3868 bool ire; 3869 bool sde; 3870 } _Cassandra_system_add_keyspace_result__isset; 3871 3872 class Cassandra_system_add_keyspace_result { 3873 public: 3874 3875 Cassandra_system_add_keyspace_result() : success("") { 3876 } 3877 3878 virtual ~Cassandra_system_add_keyspace_result() throw() {} 3879 3880 std::string success; 3881 InvalidRequestException ire; 3882 SchemaDisagreementException sde; 3883 3884 _Cassandra_system_add_keyspace_result__isset __isset; 3885 3886 void __set_success(const std::string& val) { 3887 success = val; 3888 } 3889 3890 void __set_ire(const InvalidRequestException& val) { 3891 ire = val; 3892 } 3893 3894 void __set_sde(const SchemaDisagreementException& val) { 3895 sde = val; 3896 } 3897 3898 bool operator == (const Cassandra_system_add_keyspace_result & rhs) const 3899 { 3900 if (!(success == rhs.success)) 3901 return false; 3902 if (!(ire == rhs.ire)) 3903 return false; 3904 if (!(sde == rhs.sde)) 3905 return false; 3906 return true; 3907 } 3908 bool operator != (const Cassandra_system_add_keyspace_result &rhs) const { 3909 return !(*this == rhs); 3910 } 3911 3912 bool operator < (const Cassandra_system_add_keyspace_result & ) const; 3913 3914 uint32_t read(::apache::thrift::protocol::TProtocol* iprot); 3915 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; 3916 3917 }; 3918 3919 typedef struct _Cassandra_system_add_keyspace_presult__isset { 3920 _Cassandra_system_add_keyspace_presult__isset() : success(false), ire(false), sde(false) {} 3921 bool success; 3922 bool ire; 3923 bool sde; 3924 } _Cassandra_system_add_keyspace_presult__isset; 3925 3926 class Cassandra_system_add_keyspace_presult { 3927 public: 3928 3929 3930 virtual ~Cassandra_system_add_keyspace_presult() throw() {} 3931 3932 std::string* success; 3933 InvalidRequestException ire; 3934 SchemaDisagreementException sde; 3935 3936 _Cassandra_system_add_keyspace_presult__isset __isset; 3937 3938 uint32_t read(::apache::thrift::protocol::TProtocol* iprot); 3939 3940 }; 3941 3942 3943 class Cassandra_system_drop_keyspace_args { 3944 public: 3945 3946 Cassandra_system_drop_keyspace_args() : keyspace("") { 3947 } 3948 3949 virtual ~Cassandra_system_drop_keyspace_args() throw() {} 3950 3951 std::string keyspace; 3952 3953 void __set_keyspace(const std::string& val) { 3954 keyspace = val; 3955 } 3956 3957 bool operator == (const Cassandra_system_drop_keyspace_args & rhs) const 3958 { 3959 if (!(keyspace == rhs.keyspace)) 3960 return false; 3961 return true; 3962 } 3963 bool operator != (const Cassandra_system_drop_keyspace_args &rhs) const { 3964 return !(*this == rhs); 3965 } 3966 3967 bool operator < (const Cassandra_system_drop_keyspace_args & ) const; 3968 3969 uint32_t read(::apache::thrift::protocol::TProtocol* iprot); 3970 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; 3971 3972 }; 3973 3974 3975 class Cassandra_system_drop_keyspace_pargs { 3976 public: 3977 3978 3979 virtual ~Cassandra_system_drop_keyspace_pargs() throw() {} 3980 3981 const std::string* keyspace; 3982 3983 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; 3984 3985 }; 3986 3987 typedef struct _Cassandra_system_drop_keyspace_result__isset { 3988 _Cassandra_system_drop_keyspace_result__isset() : success(false), ire(false), sde(false) {} 3989 bool success; 3990 bool ire; 3991 bool sde; 3992 } _Cassandra_system_drop_keyspace_result__isset; 3993 3994 class Cassandra_system_drop_keyspace_result { 3995 public: 3996 3997 Cassandra_system_drop_keyspace_result() : success("") { 3998 } 3999 4000 virtual ~Cassandra_system_drop_keyspace_result() throw() {} 4001 4002 std::string success; 4003 InvalidRequestException ire; 4004 SchemaDisagreementException sde; 4005 4006 _Cassandra_system_drop_keyspace_result__isset __isset; 4007 4008 void __set_success(const std::string& val) { 4009 success = val; 4010 } 4011 4012 void __set_ire(const InvalidRequestException& val) { 4013 ire = val; 4014 } 4015 4016 void __set_sde(const SchemaDisagreementException& val) { 4017 sde = val; 4018 } 4019 4020 bool operator == (const Cassandra_system_drop_keyspace_result & rhs) const 4021 { 4022 if (!(success == rhs.success)) 4023 return false; 4024 if (!(ire == rhs.ire)) 4025 return false; 4026 if (!(sde == rhs.sde)) 4027 return false; 4028 return true; 4029 } 4030 bool operator != (const Cassandra_system_drop_keyspace_result &rhs) const { 4031 return !(*this == rhs); 4032 } 4033 4034 bool operator < (const Cassandra_system_drop_keyspace_result & ) const; 4035 4036 uint32_t read(::apache::thrift::protocol::TProtocol* iprot); 4037 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; 4038 4039 }; 4040 4041 typedef struct _Cassandra_system_drop_keyspace_presult__isset { 4042 _Cassandra_system_drop_keyspace_presult__isset() : success(false), ire(false), sde(false) {} 4043 bool success; 4044 bool ire; 4045 bool sde; 4046 } _Cassandra_system_drop_keyspace_presult__isset; 4047 4048 class Cassandra_system_drop_keyspace_presult { 4049 public: 4050 4051 4052 virtual ~Cassandra_system_drop_keyspace_presult() throw() {} 4053 4054 std::string* success; 4055 InvalidRequestException ire; 4056 SchemaDisagreementException sde; 4057 4058 _Cassandra_system_drop_keyspace_presult__isset __isset; 4059 4060 uint32_t read(::apache::thrift::protocol::TProtocol* iprot); 4061 4062 }; 4063 4064 4065 class Cassandra_system_update_keyspace_args { 4066 public: 4067 4068 Cassandra_system_update_keyspace_args() { 4069 } 4070 4071 virtual ~Cassandra_system_update_keyspace_args() throw() {} 4072 4073 KsDef ks_def; 4074 4075 void __set_ks_def(const KsDef& val) { 4076 ks_def = val; 4077 } 4078 4079 bool operator == (const Cassandra_system_update_keyspace_args & rhs) const 4080 { 4081 if (!(ks_def == rhs.ks_def)) 4082 return false; 4083 return true; 4084 } 4085 bool operator != (const Cassandra_system_update_keyspace_args &rhs) const { 4086 return !(*this == rhs); 4087 } 4088 4089 bool operator < (const Cassandra_system_update_keyspace_args & ) const; 4090 4091 uint32_t read(::apache::thrift::protocol::TProtocol* iprot); 4092 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; 4093 4094 }; 4095 4096 4097 class Cassandra_system_update_keyspace_pargs { 4098 public: 4099 4100 4101 virtual ~Cassandra_system_update_keyspace_pargs() throw() {} 4102 4103 const KsDef* ks_def; 4104 4105 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; 4106 4107 }; 4108 4109 typedef struct _Cassandra_system_update_keyspace_result__isset { 4110 _Cassandra_system_update_keyspace_result__isset() : success(false), ire(false), sde(false) {} 4111 bool success; 4112 bool ire; 4113 bool sde; 4114 } _Cassandra_system_update_keyspace_result__isset; 4115 4116 class Cassandra_system_update_keyspace_result { 4117 public: 4118 4119 Cassandra_system_update_keyspace_result() : success("") { 4120 } 4121 4122 virtual ~Cassandra_system_update_keyspace_result() throw() {} 4123 4124 std::string success; 4125 InvalidRequestException ire; 4126 SchemaDisagreementException sde; 4127 4128 _Cassandra_system_update_keyspace_result__isset __isset; 4129 4130 void __set_success(const std::string& val) { 4131 success = val; 4132 } 4133 4134 void __set_ire(const InvalidRequestException& val) { 4135 ire = val; 4136 } 4137 4138 void __set_sde(const SchemaDisagreementException& val) { 4139 sde = val; 4140 } 4141 4142 bool operator == (const Cassandra_system_update_keyspace_result & rhs) const 4143 { 4144 if (!(success == rhs.success)) 4145 return false; 4146 if (!(ire == rhs.ire)) 4147 return false; 4148 if (!(sde == rhs.sde)) 4149 return false; 4150 return true; 4151 } 4152 bool operator != (const Cassandra_system_update_keyspace_result &rhs) const { 4153 return !(*this == rhs); 4154 } 4155 4156 bool operator < (const Cassandra_system_update_keyspace_result & ) const; 4157 4158 uint32_t read(::apache::thrift::protocol::TProtocol* iprot); 4159 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; 4160 4161 }; 4162 4163 typedef struct _Cassandra_system_update_keyspace_presult__isset { 4164 _Cassandra_system_update_keyspace_presult__isset() : success(false), ire(false), sde(false) {} 4165 bool success; 4166 bool ire; 4167 bool sde; 4168 } _Cassandra_system_update_keyspace_presult__isset; 4169 4170 class Cassandra_system_update_keyspace_presult { 4171 public: 4172 4173 4174 virtual ~Cassandra_system_update_keyspace_presult() throw() {} 4175 4176 std::string* success; 4177 InvalidRequestException ire; 4178 SchemaDisagreementException sde; 4179 4180 _Cassandra_system_update_keyspace_presult__isset __isset; 4181 4182 uint32_t read(::apache::thrift::protocol::TProtocol* iprot); 4183 4184 }; 4185 4186 4187 class Cassandra_system_update_column_family_args { 4188 public: 4189 4190 Cassandra_system_update_column_family_args() { 4191 } 4192 4193 virtual ~Cassandra_system_update_column_family_args() throw() {} 4194 4195 CfDef cf_def; 4196 4197 void __set_cf_def(const CfDef& val) { 4198 cf_def = val; 4199 } 4200 4201 bool operator == (const Cassandra_system_update_column_family_args & rhs) const 4202 { 4203 if (!(cf_def == rhs.cf_def)) 4204 return false; 4205 return true; 4206 } 4207 bool operator != (const Cassandra_system_update_column_family_args &rhs) const { 4208 return !(*this == rhs); 4209 } 4210 4211 bool operator < (const Cassandra_system_update_column_family_args & ) const; 4212 4213 uint32_t read(::apache::thrift::protocol::TProtocol* iprot); 4214 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; 4215 4216 }; 4217 4218 4219 class Cassandra_system_update_column_family_pargs { 4220 public: 4221 4222 4223 virtual ~Cassandra_system_update_column_family_pargs() throw() {} 4224 4225 const CfDef* cf_def; 4226 4227 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; 4228 4229 }; 4230 4231 typedef struct _Cassandra_system_update_column_family_result__isset { 4232 _Cassandra_system_update_column_family_result__isset() : success(false), ire(false), sde(false) {} 4233 bool success; 4234 bool ire; 4235 bool sde; 4236 } _Cassandra_system_update_column_family_result__isset; 4237 4238 class Cassandra_system_update_column_family_result { 4239 public: 4240 4241 Cassandra_system_update_column_family_result() : success("") { 4242 } 4243 4244 virtual ~Cassandra_system_update_column_family_result() throw() {} 4245 4246 std::string success; 4247 InvalidRequestException ire; 4248 SchemaDisagreementException sde; 4249 4250 _Cassandra_system_update_column_family_result__isset __isset; 4251 4252 void __set_success(const std::string& val) { 4253 success = val; 4254 } 4255 4256 void __set_ire(const InvalidRequestException& val) { 4257 ire = val; 4258 } 4259 4260 void __set_sde(const SchemaDisagreementException& val) { 4261 sde = val; 4262 } 4263 4264 bool operator == (const Cassandra_system_update_column_family_result & rhs) const 4265 { 4266 if (!(success == rhs.success)) 4267 return false; 4268 if (!(ire == rhs.ire)) 4269 return false; 4270 if (!(sde == rhs.sde)) 4271 return false; 4272 return true; 4273 } 4274 bool operator != (const Cassandra_system_update_column_family_result &rhs) const { 4275 return !(*this == rhs); 4276 } 4277 4278 bool operator < (const Cassandra_system_update_column_family_result & ) const; 4279 4280 uint32_t read(::apache::thrift::protocol::TProtocol* iprot); 4281 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; 4282 4283 }; 4284 4285 typedef struct _Cassandra_system_update_column_family_presult__isset { 4286 _Cassandra_system_update_column_family_presult__isset() : success(false), ire(false), sde(false) {} 4287 bool success; 4288 bool ire; 4289 bool sde; 4290 } _Cassandra_system_update_column_family_presult__isset; 4291 4292 class Cassandra_system_update_column_family_presult { 4293 public: 4294 4295 4296 virtual ~Cassandra_system_update_column_family_presult() throw() {} 4297 4298 std::string* success; 4299 InvalidRequestException ire; 4300 SchemaDisagreementException sde; 4301 4302 _Cassandra_system_update_column_family_presult__isset __isset; 4303 4304 uint32_t read(::apache::thrift::protocol::TProtocol* iprot); 4305 4306 }; 4307 4308 4309 class Cassandra_execute_cql_query_args { 4310 public: 4311 4312 Cassandra_execute_cql_query_args() : query(""), compression((Compression::type)0) { 4313 } 4314 4315 virtual ~Cassandra_execute_cql_query_args() throw() {} 4316 4317 std::string query; 4318 Compression::type compression; 4319 4320 void __set_query(const std::string& val) { 4321 query = val; 4322 } 4323 4324 void __set_compression(const Compression::type val) { 4325 compression = val; 4326 } 4327 4328 bool operator == (const Cassandra_execute_cql_query_args & rhs) const 4329 { 4330 if (!(query == rhs.query)) 4331 return false; 4332 if (!(compression == rhs.compression)) 4333 return false; 4334 return true; 4335 } 4336 bool operator != (const Cassandra_execute_cql_query_args &rhs) const { 4337 return !(*this == rhs); 4338 } 4339 4340 bool operator < (const Cassandra_execute_cql_query_args & ) const; 4341 4342 uint32_t read(::apache::thrift::protocol::TProtocol* iprot); 4343 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; 4344 4345 }; 4346 4347 4348 class Cassandra_execute_cql_query_pargs { 4349 public: 4350 4351 4352 virtual ~Cassandra_execute_cql_query_pargs() throw() {} 4353 4354 const std::string* query; 4355 const Compression::type* compression; 4356 4357 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; 4358 4359 }; 4360 4361 typedef struct _Cassandra_execute_cql_query_result__isset { 4362 _Cassandra_execute_cql_query_result__isset() : success(false), ire(false), ue(false), te(false), sde(false) {} 4363 bool success; 4364 bool ire; 4365 bool ue; 4366 bool te; 4367 bool sde; 4368 } _Cassandra_execute_cql_query_result__isset; 4369 4370 class Cassandra_execute_cql_query_result { 4371 public: 4372 4373 Cassandra_execute_cql_query_result() { 4374 } 4375 4376 virtual ~Cassandra_execute_cql_query_result() throw() {} 4377 4378 CqlResult success; 4379 InvalidRequestException ire; 4380 UnavailableException ue; 4381 TimedOutException te; 4382 SchemaDisagreementException sde; 4383 4384 _Cassandra_execute_cql_query_result__isset __isset; 4385 4386 void __set_success(const CqlResult& val) { 4387 success = val; 4388 } 4389 4390 void __set_ire(const InvalidRequestException& val) { 4391 ire = val; 4392 } 4393 4394 void __set_ue(const UnavailableException& val) { 4395 ue = val; 4396 } 4397 4398 void __set_te(const TimedOutException& val) { 4399 te = val; 4400 } 4401 4402 void __set_sde(const SchemaDisagreementException& val) { 4403 sde = val; 4404 } 4405 4406 bool operator == (const Cassandra_execute_cql_query_result & rhs) const 4407 { 4408 if (!(success == rhs.success)) 4409 return false; 4410 if (!(ire == rhs.ire)) 4411 return false; 4412 if (!(ue == rhs.ue)) 4413 return false; 4414 if (!(te == rhs.te)) 4415 return false; 4416 if (!(sde == rhs.sde)) 4417 return false; 4418 return true; 4419 } 4420 bool operator != (const Cassandra_execute_cql_query_result &rhs) const { 4421 return !(*this == rhs); 4422 } 4423 4424 bool operator < (const Cassandra_execute_cql_query_result & ) const; 4425 4426 uint32_t read(::apache::thrift::protocol::TProtocol* iprot); 4427 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; 4428 4429 }; 4430 4431 typedef struct _Cassandra_execute_cql_query_presult__isset { 4432 _Cassandra_execute_cql_query_presult__isset() : success(false), ire(false), ue(false), te(false), sde(false) {} 4433 bool success; 4434 bool ire; 4435 bool ue; 4436 bool te; 4437 bool sde; 4438 } _Cassandra_execute_cql_query_presult__isset; 4439 4440 class Cassandra_execute_cql_query_presult { 4441 public: 4442 4443 4444 virtual ~Cassandra_execute_cql_query_presult() throw() {} 4445 4446 CqlResult* success; 4447 InvalidRequestException ire; 4448 UnavailableException ue; 4449 TimedOutException te; 4450 SchemaDisagreementException sde; 4451 4452 _Cassandra_execute_cql_query_presult__isset __isset; 4453 4454 uint32_t read(::apache::thrift::protocol::TProtocol* iprot); 4455 4456 }; 4457 4458 4459 class Cassandra_prepare_cql_query_args { 4460 public: 4461 4462 Cassandra_prepare_cql_query_args() : query(""), compression((Compression::type)0) { 4463 } 4464 4465 virtual ~Cassandra_prepare_cql_query_args() throw() {} 4466 4467 std::string query; 4468 Compression::type compression; 4469 4470 void __set_query(const std::string& val) { 4471 query = val; 4472 } 4473 4474 void __set_compression(const Compression::type val) { 4475 compression = val; 4476 } 4477 4478 bool operator == (const Cassandra_prepare_cql_query_args & rhs) const 4479 { 4480 if (!(query == rhs.query)) 4481 return false; 4482 if (!(compression == rhs.compression)) 4483 return false; 4484 return true; 4485 } 4486 bool operator != (const Cassandra_prepare_cql_query_args &rhs) const { 4487 return !(*this == rhs); 4488 } 4489 4490 bool operator < (const Cassandra_prepare_cql_query_args & ) const; 4491 4492 uint32_t read(::apache::thrift::protocol::TProtocol* iprot); 4493 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; 4494 4495 }; 4496 4497 4498 class Cassandra_prepare_cql_query_pargs { 4499 public: 4500 4501 4502 virtual ~Cassandra_prepare_cql_query_pargs() throw() {} 4503 4504 const std::string* query; 4505 const Compression::type* compression; 4506 4507 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; 4508 4509 }; 4510 4511 typedef struct _Cassandra_prepare_cql_query_result__isset { 4512 _Cassandra_prepare_cql_query_result__isset() : success(false), ire(false) {} 4513 bool success; 4514 bool ire; 4515 } _Cassandra_prepare_cql_query_result__isset; 4516 4517 class Cassandra_prepare_cql_query_result { 4518 public: 4519 4520 Cassandra_prepare_cql_query_result() { 4521 } 4522 4523 virtual ~Cassandra_prepare_cql_query_result() throw() {} 4524 4525 CqlPreparedResult success; 4526 InvalidRequestException ire; 4527 4528 _Cassandra_prepare_cql_query_result__isset __isset; 4529 4530 void __set_success(const CqlPreparedResult& val) { 4531 success = val; 4532 } 4533 4534 void __set_ire(const InvalidRequestException& val) { 4535 ire = val; 4536 } 4537 4538 bool operator == (const Cassandra_prepare_cql_query_result & rhs) const 4539 { 4540 if (!(success == rhs.success)) 4541 return false; 4542 if (!(ire == rhs.ire)) 4543 return false; 4544 return true; 4545 } 4546 bool operator != (const Cassandra_prepare_cql_query_result &rhs) const { 4547 return !(*this == rhs); 4548 } 4549 4550 bool operator < (const Cassandra_prepare_cql_query_result & ) const; 4551 4552 uint32_t read(::apache::thrift::protocol::TProtocol* iprot); 4553 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; 4554 4555 }; 4556 4557 typedef struct _Cassandra_prepare_cql_query_presult__isset { 4558 _Cassandra_prepare_cql_query_presult__isset() : success(false), ire(false) {} 4559 bool success; 4560 bool ire; 4561 } _Cassandra_prepare_cql_query_presult__isset; 4562 4563 class Cassandra_prepare_cql_query_presult { 4564 public: 4565 4566 4567 virtual ~Cassandra_prepare_cql_query_presult() throw() {} 4568 4569 CqlPreparedResult* success; 4570 InvalidRequestException ire; 4571 4572 _Cassandra_prepare_cql_query_presult__isset __isset; 4573 4574 uint32_t read(::apache::thrift::protocol::TProtocol* iprot); 4575 4576 }; 4577 4578 4579 class Cassandra_execute_prepared_cql_query_args { 4580 public: 4581 4582 Cassandra_execute_prepared_cql_query_args() : itemId(0) { 4583 } 4584 4585 virtual ~Cassandra_execute_prepared_cql_query_args() throw() {} 4586 4587 int32_t itemId; 4588 std::vector<std::string> values; 4589 4590 void __set_itemId(const int32_t val) { 4591 itemId = val; 4592 } 4593 4594 void __set_values(const std::vector<std::string> & val) { 4595 values = val; 4596 } 4597 4598 bool operator == (const Cassandra_execute_prepared_cql_query_args & rhs) const 4599 { 4600 if (!(itemId == rhs.itemId)) 4601 return false; 4602 if (!(values == rhs.values)) 4603 return false; 4604 return true; 4605 } 4606 bool operator != (const Cassandra_execute_prepared_cql_query_args &rhs) const { 4607 return !(*this == rhs); 4608 } 4609 4610 bool operator < (const Cassandra_execute_prepared_cql_query_args & ) const; 4611 4612 uint32_t read(::apache::thrift::protocol::TProtocol* iprot); 4613 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; 4614 4615 }; 4616 4617 4618 class Cassandra_execute_prepared_cql_query_pargs { 4619 public: 4620 4621 4622 virtual ~Cassandra_execute_prepared_cql_query_pargs() throw() {} 4623 4624 const int32_t* itemId; 4625 const std::vector<std::string> * values; 4626 4627 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; 4628 4629 }; 4630 4631 typedef struct _Cassandra_execute_prepared_cql_query_result__isset { 4632 _Cassandra_execute_prepared_cql_query_result__isset() : success(false), ire(false), ue(false), te(false), sde(false) {} 4633 bool success; 4634 bool ire; 4635 bool ue; 4636 bool te; 4637 bool sde; 4638 } _Cassandra_execute_prepared_cql_query_result__isset; 4639 4640 class Cassandra_execute_prepared_cql_query_result { 4641 public: 4642 4643 Cassandra_execute_prepared_cql_query_result() { 4644 } 4645 4646 virtual ~Cassandra_execute_prepared_cql_query_result() throw() {} 4647 4648 CqlResult success; 4649 InvalidRequestException ire; 4650 UnavailableException ue; 4651 TimedOutException te; 4652 SchemaDisagreementException sde; 4653 4654 _Cassandra_execute_prepared_cql_query_result__isset __isset; 4655 4656 void __set_success(const CqlResult& val) { 4657 success = val; 4658 } 4659 4660 void __set_ire(const InvalidRequestException& val) { 4661 ire = val; 4662 } 4663 4664 void __set_ue(const UnavailableException& val) { 4665 ue = val; 4666 } 4667 4668 void __set_te(const TimedOutException& val) { 4669 te = val; 4670 } 4671 4672 void __set_sde(const SchemaDisagreementException& val) { 4673 sde = val; 4674 } 4675 4676 bool operator == (const Cassandra_execute_prepared_cql_query_result & rhs) const 4677 { 4678 if (!(success == rhs.success)) 4679 return false; 4680 if (!(ire == rhs.ire)) 4681 return false; 4682 if (!(ue == rhs.ue)) 4683 return false; 4684 if (!(te == rhs.te)) 4685 return false; 4686 if (!(sde == rhs.sde)) 4687 return false; 4688 return true; 4689 } 4690 bool operator != (const Cassandra_execute_prepared_cql_query_result &rhs) const { 4691 return !(*this == rhs); 4692 } 4693 4694 bool operator < (const Cassandra_execute_prepared_cql_query_result & ) const; 4695 4696 uint32_t read(::apache::thrift::protocol::TProtocol* iprot); 4697 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; 4698 4699 }; 4700 4701 typedef struct _Cassandra_execute_prepared_cql_query_presult__isset { 4702 _Cassandra_execute_prepared_cql_query_presult__isset() : success(false), ire(false), ue(false), te(false), sde(false) {} 4703 bool success; 4704 bool ire; 4705 bool ue; 4706 bool te; 4707 bool sde; 4708 } _Cassandra_execute_prepared_cql_query_presult__isset; 4709 4710 class Cassandra_execute_prepared_cql_query_presult { 4711 public: 4712 4713 4714 virtual ~Cassandra_execute_prepared_cql_query_presult() throw() {} 4715 4716 CqlResult* success; 4717 InvalidRequestException ire; 4718 UnavailableException ue; 4719 TimedOutException te; 4720 SchemaDisagreementException sde; 4721 4722 _Cassandra_execute_prepared_cql_query_presult__isset __isset; 4723 4724 uint32_t read(::apache::thrift::protocol::TProtocol* iprot); 4725 4726 }; 4727 4728 4729 class Cassandra_set_cql_version_args { 4730 public: 4731 4732 Cassandra_set_cql_version_args() : version("") { 4733 } 4734 4735 virtual ~Cassandra_set_cql_version_args() throw() {} 4736 4737 std::string version; 4738 4739 void __set_version(const std::string& val) { 4740 version = val; 4741 } 4742 4743 bool operator == (const Cassandra_set_cql_version_args & rhs) const 4744 { 4745 if (!(version == rhs.version)) 4746 return false; 4747 return true; 4748 } 4749 bool operator != (const Cassandra_set_cql_version_args &rhs) const { 4750 return !(*this == rhs); 4751 } 4752 4753 bool operator < (const Cassandra_set_cql_version_args & ) const; 4754 4755 uint32_t read(::apache::thrift::protocol::TProtocol* iprot); 4756 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; 4757 4758 }; 4759 4760 4761 class Cassandra_set_cql_version_pargs { 4762 public: 4763 4764 4765 virtual ~Cassandra_set_cql_version_pargs() throw() {} 4766 4767 const std::string* version; 4768 4769 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; 4770 4771 }; 4772 4773 typedef struct _Cassandra_set_cql_version_result__isset { 4774 _Cassandra_set_cql_version_result__isset() : ire(false) {} 4775 bool ire; 4776 } _Cassandra_set_cql_version_result__isset; 4777 4778 class Cassandra_set_cql_version_result { 4779 public: 4780 4781 Cassandra_set_cql_version_result() { 4782 } 4783 4784 virtual ~Cassandra_set_cql_version_result() throw() {} 4785 4786 InvalidRequestException ire; 4787 4788 _Cassandra_set_cql_version_result__isset __isset; 4789 4790 void __set_ire(const InvalidRequestException& val) { 4791 ire = val; 4792 } 4793 4794 bool operator == (const Cassandra_set_cql_version_result & rhs) const 4795 { 4796 if (!(ire == rhs.ire)) 4797 return false; 4798 return true; 4799 } 4800 bool operator != (const Cassandra_set_cql_version_result &rhs) const { 4801 return !(*this == rhs); 4802 } 4803 4804 bool operator < (const Cassandra_set_cql_version_result & ) const; 4805 4806 uint32_t read(::apache::thrift::protocol::TProtocol* iprot); 4807 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; 4808 4809 }; 4810 4811 typedef struct _Cassandra_set_cql_version_presult__isset { 4812 _Cassandra_set_cql_version_presult__isset() : ire(false) {} 4813 bool ire; 4814 } _Cassandra_set_cql_version_presult__isset; 4815 4816 class Cassandra_set_cql_version_presult { 4817 public: 4818 4819 4820 virtual ~Cassandra_set_cql_version_presult() throw() {} 4821 4822 InvalidRequestException ire; 4823 4824 _Cassandra_set_cql_version_presult__isset __isset; 4825 4826 uint32_t read(::apache::thrift::protocol::TProtocol* iprot); 4827 4828 }; 4829 4830 class CassandraClient : virtual public CassandraIf { 4831 public: 4832 CassandraClient(boost::shared_ptr< ::apache::thrift::protocol::TProtocol> prot) : 4833 piprot_(prot), 4834 poprot_(prot) { 4835 iprot_ = prot.get(); 4836 oprot_ = prot.get(); 4837 } 4838 CassandraClient(boost::shared_ptr< ::apache::thrift::protocol::TProtocol> iprot, boost::shared_ptr< ::apache::thrift::protocol::TProtocol> oprot) : 4839 piprot_(iprot), 4840 poprot_(oprot) { 4841 iprot_ = iprot.get(); 4842 oprot_ = oprot.get(); 4843 } 4844 boost::shared_ptr< ::apache::thrift::protocol::TProtocol> getInputProtocol() { 4845 return piprot_; 4846 } 4847 boost::shared_ptr< ::apache::thrift::protocol::TProtocol> getOutputProtocol() { 4848 return poprot_; 4849 } 4850 void login(const AuthenticationRequest& auth_request); 4851 void send_login(const AuthenticationRequest& auth_request); 4852 void recv_login(); 4853 void set_keyspace(const std::string& keyspace); 4854 void send_set_keyspace(const std::string& keyspace); 4855 void recv_set_keyspace(); 4856 void get(ColumnOrSuperColumn& _return, const std::string& key, const ColumnPath& column_path, const ConsistencyLevel::type consistency_level); 4857 void send_get(const std::string& key, const ColumnPath& column_path, const ConsistencyLevel::type consistency_level); 4858 void recv_get(ColumnOrSuperColumn& _return); 4859 void get_slice(std::vector<ColumnOrSuperColumn> & _return, const std::string& key, const ColumnParent& column_parent, const SlicePredicate& predicate, const ConsistencyLevel::type consistency_level); 4860 void send_get_slice(const std::string& key, const ColumnParent& column_parent, const SlicePredicate& predicate, const ConsistencyLevel::type consistency_level); 4861 void recv_get_slice(std::vector<ColumnOrSuperColumn> & _return); 4862 int32_t get_count(const std::string& key, const ColumnParent& column_parent, const SlicePredicate& predicate, const ConsistencyLevel::type consistency_level); 4863 void send_get_count(const std::string& key, const ColumnParent& column_parent, const SlicePredicate& predicate, const ConsistencyLevel::type consistency_level); 4864 int32_t recv_get_count(); 4865 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); 4866 void send_multiget_slice(const std::vector<std::string> & keys, const ColumnParent& column_parent, const SlicePredicate& predicate, const ConsistencyLevel::type consistency_level); 4867 void recv_multiget_slice(std::map<std::string, std::vector<ColumnOrSuperColumn> > & _return); 4868 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); 4869 void send_multiget_count(const std::vector<std::string> & keys, const ColumnParent& column_parent, const SlicePredicate& predicate, const ConsistencyLevel::type consistency_level); 4870 void recv_multiget_count(std::map<std::string, int32_t> & _return); 4871 void get_range_slices(std::vector<KeySlice> & _return, const ColumnParent& column_parent, const SlicePredicate& predicate, const KeyRange& range, const ConsistencyLevel::type consistency_level); 4872 void send_get_range_slices(const ColumnParent& column_parent, const SlicePredicate& predicate, const KeyRange& range, const ConsistencyLevel::type consistency_level); 4873 void recv_get_range_slices(std::vector<KeySlice> & _return); 4874 void get_paged_slice(std::vector<KeySlice> & _return, const std::string& column_family, const KeyRange& range, const std::string& start_column, const ConsistencyLevel::type consistency_level); 4875 void send_get_paged_slice(const std::string& column_family, const KeyRange& range, const std::string& start_column, const ConsistencyLevel::type consistency_level); 4876 void recv_get_paged_slice(std::vector<KeySlice> & _return); 4877 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); 4878 void send_get_indexed_slices(const ColumnParent& column_parent, const IndexClause& index_clause, const SlicePredicate& column_predicate, const ConsistencyLevel::type consistency_level); 4879 void recv_get_indexed_slices(std::vector<KeySlice> & _return); 4880 void insert(const std::string& key, const ColumnParent& column_parent, const Column& column, const ConsistencyLevel::type consistency_level); 4881 void send_insert(const std::string& key, const ColumnParent& column_parent, const Column& column, const ConsistencyLevel::type consistency_level); 4882 void recv_insert(); 4883 void add(const std::string& key, const ColumnParent& column_parent, const CounterColumn& column, const ConsistencyLevel::type consistency_level); 4884 void send_add(const std::string& key, const ColumnParent& column_parent, const CounterColumn& column, const ConsistencyLevel::type consistency_level); 4885 void recv_add(); 4886 void remove(const std::string& key, const ColumnPath& column_path, const int64_t timestamp, const ConsistencyLevel::type consistency_level); 4887 void send_remove(const std::string& key, const ColumnPath& column_path, const int64_t timestamp, const ConsistencyLevel::type consistency_level); 4888 void recv_remove(); 4889 void remove_counter(const std::string& key, const ColumnPath& path, const ConsistencyLevel::type consistency_level); 4890 void send_remove_counter(const std::string& key, const ColumnPath& path, const ConsistencyLevel::type consistency_level); 4891 void recv_remove_counter(); 4892 void batch_mutate(const std::map<std::string, std::map<std::string, std::vector<Mutation> > > & mutation_map, const ConsistencyLevel::type consistency_level); 4893 void send_batch_mutate(const std::map<std::string, std::map<std::string, std::vector<Mutation> > > & mutation_map, const ConsistencyLevel::type consistency_level); 4894 void recv_batch_mutate(); 4895 void truncate(const std::string& cfname); 4896 void send_truncate(const std::string& cfname); 4897 void recv_truncate(); 4898 void describe_schema_versions(std::map<std::string, std::vector<std::string> > & _return); 4899 void send_describe_schema_versions(); 4900 void recv_describe_schema_versions(std::map<std::string, std::vector<std::string> > & _return); 4901 void describe_keyspaces(std::vector<KsDef> & _return); 4902 void send_describe_keyspaces(); 4903 void recv_describe_keyspaces(std::vector<KsDef> & _return); 4904 void describe_cluster_name(std::string& _return); 4905 void send_describe_cluster_name(); 4906 void recv_describe_cluster_name(std::string& _return); 4907 void describe_version(std::string& _return); 4908 void send_describe_version(); 4909 void recv_describe_version(std::string& _return); 4910 void describe_ring(std::vector<TokenRange> & _return, const std::string& keyspace); 4911 void send_describe_ring(const std::string& keyspace); 4912 void recv_describe_ring(std::vector<TokenRange> & _return); 4913 void describe_token_map(std::map<std::string, std::string> & _return); 4914 void send_describe_token_map(); 4915 void recv_describe_token_map(std::map<std::string, std::string> & _return); 4916 void describe_partitioner(std::string& _return); 4917 void send_describe_partitioner(); 4918 void recv_describe_partitioner(std::string& _return); 4919 void describe_snitch(std::string& _return); 4920 void send_describe_snitch(); 4921 void recv_describe_snitch(std::string& _return); 4922 void describe_keyspace(KsDef& _return, const std::string& keyspace); 4923 void send_describe_keyspace(const std::string& keyspace); 4924 void recv_describe_keyspace(KsDef& _return); 4925 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); 4926 void send_describe_splits(const std::string& cfName, const std::string& start_token, const std::string& end_token, const int32_t keys_per_split); 4927 void recv_describe_splits(std::vector<std::string> & _return); 4928 void system_add_column_family(std::string& _return, const CfDef& cf_def); 4929 void send_system_add_column_family(const CfDef& cf_def); 4930 void recv_system_add_column_family(std::string& _return); 4931 void system_drop_column_family(std::string& _return, const std::string& column_family); 4932 void send_system_drop_column_family(const std::string& column_family); 4933 void recv_system_drop_column_family(std::string& _return); 4934 void system_add_keyspace(std::string& _return, const KsDef& ks_def); 4935 void send_system_add_keyspace(const KsDef& ks_def); 4936 void recv_system_add_keyspace(std::string& _return); 4937 void system_drop_keyspace(std::string& _return, const std::string& keyspace); 4938 void send_system_drop_keyspace(const std::string& keyspace); 4939 void recv_system_drop_keyspace(std::string& _return); 4940 void system_update_keyspace(std::string& _return, const KsDef& ks_def); 4941 void send_system_update_keyspace(const KsDef& ks_def); 4942 void recv_system_update_keyspace(std::string& _return); 4943 void system_update_column_family(std::string& _return, const CfDef& cf_def); 4944 void send_system_update_column_family(const CfDef& cf_def); 4945 void recv_system_update_column_family(std::string& _return); 4946 void execute_cql_query(CqlResult& _return, const std::string& query, const Compression::type compression); 4947 void send_execute_cql_query(const std::string& query, const Compression::type compression); 4948 void recv_execute_cql_query(CqlResult& _return); 4949 void prepare_cql_query(CqlPreparedResult& _return, const std::string& query, const Compression::type compression); 4950 void send_prepare_cql_query(const std::string& query, const Compression::type compression); 4951 void recv_prepare_cql_query(CqlPreparedResult& _return); 4952 void execute_prepared_cql_query(CqlResult& _return, const int32_t itemId, const std::vector<std::string> & values); 4953 void send_execute_prepared_cql_query(const int32_t itemId, const std::vector<std::string> & values); 4954 void recv_execute_prepared_cql_query(CqlResult& _return); 4955 void set_cql_version(const std::string& version); 4956 void send_set_cql_version(const std::string& version); 4957 void recv_set_cql_version(); 4958 protected: 4959 boost::shared_ptr< ::apache::thrift::protocol::TProtocol> piprot_; 4960 boost::shared_ptr< ::apache::thrift::protocol::TProtocol> poprot_; 4961 ::apache::thrift::protocol::TProtocol* iprot_; 4962 ::apache::thrift::protocol::TProtocol* oprot_; 4963 }; 4964 4965 class CassandraProcessor : public ::apache::thrift::TProcessor { 4966 protected: 4967 boost::shared_ptr<CassandraIf> iface_; 4968 virtual bool process_fn(::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, std::string& fname, int32_t seqid, void* callContext); 4969 private: 4970 std::map<std::string, void (CassandraProcessor::*)(int32_t, ::apache::thrift::protocol::TProtocol*, ::apache::thrift::protocol::TProtocol*, void*)> processMap_; 4971 void process_login(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); 4972 void process_set_keyspace(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); 4973 void process_get(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); 4974 void process_get_slice(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); 4975 void process_get_count(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); 4976 void process_multiget_slice(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); 4977 void process_multiget_count(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); 4978 void process_get_range_slices(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); 4979 void process_get_paged_slice(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); 4980 void process_get_indexed_slices(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); 4981 void process_insert(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); 4982 void process_add(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); 4983 void process_remove(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); 4984 void process_remove_counter(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); 4985 void process_batch_mutate(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); 4986 void process_truncate(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); 4987 void process_describe_schema_versions(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); 4988 void process_describe_keyspaces(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); 4989 void process_describe_cluster_name(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); 4990 void process_describe_version(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); 4991 void process_describe_ring(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); 4992 void process_describe_token_map(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); 4993 void process_describe_partitioner(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); 4994 void process_describe_snitch(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); 4995 void process_describe_keyspace(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); 4996 void process_describe_splits(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); 4997 void process_system_add_column_family(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); 4998 void process_system_drop_column_family(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); 4999 void process_system_add_keyspace(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); 5000 void process_system_drop_keyspace(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); 5001 void process_system_update_keyspace(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); 5002 void process_system_update_column_family(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); 5003 void process_execute_cql_query(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); 5004 void process_prepare_cql_query(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); 5005 void process_execute_prepared_cql_query(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); 5006 void process_set_cql_version(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext); 5007 public: 5008 CassandraProcessor(boost::shared_ptr<CassandraIf> iface) : 5009 iface_(iface) { 5010 processMap_["login"] = &CassandraProcessor::process_login; 5011 processMap_["set_keyspace"] = &CassandraProcessor::process_set_keyspace; 5012 processMap_["get"] = &CassandraProcessor::process_get; 5013 processMap_["get_slice"] = &CassandraProcessor::process_get_slice; 5014 processMap_["get_count"] = &CassandraProcessor::process_get_count; 5015 processMap_["multiget_slice"] = &CassandraProcessor::process_multiget_slice; 5016 processMap_["multiget_count"] = &CassandraProcessor::process_multiget_count; 5017 processMap_["get_range_slices"] = &CassandraProcessor::process_get_range_slices; 5018 processMap_["get_paged_slice"] = &CassandraProcessor::process_get_paged_slice; 5019 processMap_["get_indexed_slices"] = &CassandraProcessor::process_get_indexed_slices; 5020 processMap_["insert"] = &CassandraProcessor::process_insert; 5021 processMap_["add"] = &CassandraProcessor::process_add; 5022 processMap_["remove"] = &CassandraProcessor::process_remove; 5023 processMap_["remove_counter"] = &CassandraProcessor::process_remove_counter; 5024 processMap_["batch_mutate"] = &CassandraProcessor::process_batch_mutate; 5025 processMap_["truncate"] = &CassandraProcessor::process_truncate; 5026 processMap_["describe_schema_versions"] = &CassandraProcessor::process_describe_schema_versions; 5027 processMap_["describe_keyspaces"] = &CassandraProcessor::process_describe_keyspaces; 5028 processMap_["describe_cluster_name"] = &CassandraProcessor::process_describe_cluster_name; 5029 processMap_["describe_version"] = &CassandraProcessor::process_describe_version; 5030 processMap_["describe_ring"] = &CassandraProcessor::process_describe_ring; 5031 processMap_["describe_token_map"] = &CassandraProcessor::process_describe_token_map; 5032 processMap_["describe_partitioner"] = &CassandraProcessor::process_describe_partitioner; 5033 processMap_["describe_snitch"] = &CassandraProcessor::process_describe_snitch; 5034 processMap_["describe_keyspace"] = &CassandraProcessor::process_describe_keyspace; 5035 processMap_["describe_splits"] = &CassandraProcessor::process_describe_splits; 5036 processMap_["system_add_column_family"] = &CassandraProcessor::process_system_add_column_family; 5037 processMap_["system_drop_column_family"] = &CassandraProcessor::process_system_drop_column_family; 5038 processMap_["system_add_keyspace"] = &CassandraProcessor::process_system_add_keyspace; 5039 processMap_["system_drop_keyspace"] = &CassandraProcessor::process_system_drop_keyspace; 5040 processMap_["system_update_keyspace"] = &CassandraProcessor::process_system_update_keyspace; 5041 processMap_["system_update_column_family"] = &CassandraProcessor::process_system_update_column_family; 5042 processMap_["execute_cql_query"] = &CassandraProcessor::process_execute_cql_query; 5043 processMap_["prepare_cql_query"] = &CassandraProcessor::process_prepare_cql_query; 5044 processMap_["execute_prepared_cql_query"] = &CassandraProcessor::process_execute_prepared_cql_query; 5045 processMap_["set_cql_version"] = &CassandraProcessor::process_set_cql_version; 5046 } 5047 5048 virtual bool process(boost::shared_ptr< ::apache::thrift::protocol::TProtocol> piprot, boost::shared_ptr< ::apache::thrift::protocol::TProtocol> poprot, void* callContext); 5049 virtual ~CassandraProcessor() {} 5050 }; 5051 5052 class CassandraProcessorFactory : public ::apache::thrift::TProcessorFactory { 5053 public: 5054 CassandraProcessorFactory(const ::boost::shared_ptr< CassandraIfFactory >& handlerFactory) : 5055 handlerFactory_(handlerFactory) {} 5056 5057 ::boost::shared_ptr< ::apache::thrift::TProcessor > getProcessor(const ::apache::thrift::TConnectionInfo& connInfo); 5058 5059 protected: 5060 ::boost::shared_ptr< CassandraIfFactory > handlerFactory_; 5061 }; 5062 5063 class CassandraMultiface : virtual public CassandraIf { 5064 public: 5065 CassandraMultiface(std::vector<boost::shared_ptr<CassandraIf> >& ifaces) : ifaces_(ifaces) { 5066 } 5067 virtual ~CassandraMultiface() {} 5068 protected: 5069 std::vector<boost::shared_ptr<CassandraIf> > ifaces_; 5070 CassandraMultiface() {} 5071 void add(boost::shared_ptr<CassandraIf> iface) { 5072 ifaces_.push_back(iface); 5073 } 5074 public: 5075 void login(const AuthenticationRequest& auth_request) { 5076 size_t sz = ifaces_.size(); 5077 for (size_t i = 0; i < sz; ++i) { 5078 ifaces_[i]->login(auth_request); 5079 } 5080 } 5081 5082 void set_keyspace(const std::string& keyspace) { 5083 size_t sz = ifaces_.size(); 5084 for (size_t i = 0; i < sz; ++i) { 5085 ifaces_[i]->set_keyspace(keyspace); 5086 } 5087 } 5088 5089 void get(ColumnOrSuperColumn& _return, const std::string& key, const ColumnPath& column_path, const ConsistencyLevel::type consistency_level) { 5090 size_t sz = ifaces_.size(); 5091 for (size_t i = 0; i < sz; ++i) { 5092 if (i == sz - 1) { 5093 ifaces_[i]->get(_return, key, column_path, consistency_level); 5094 return; 5095 } else { 5096 ifaces_[i]->get(_return, key, column_path, consistency_level); 5097 } 5098 } 5099 } 5100 5101 void get_slice(std::vector<ColumnOrSuperColumn> & _return, const std::string& key, const ColumnParent& column_parent, const SlicePredicate& predicate, const ConsistencyLevel::type consistency_level) { 5102 size_t sz = ifaces_.size(); 5103 for (size_t i = 0; i < sz; ++i) { 5104 if (i == sz - 1) { 5105 ifaces_[i]->get_slice(_return, key, column_parent, predicate, consistency_level); 5106 return; 5107 } else { 5108 ifaces_[i]->get_slice(_return, key, column_parent, predicate, consistency_level); 5109 } 5110 } 5111 } 5112 5113 int32_t get_count(const std::string& key, const ColumnParent& column_parent, const SlicePredicate& predicate, const ConsistencyLevel::type consistency_level) { 5114 size_t sz = ifaces_.size(); 5115 for (size_t i = 0; i < sz; ++i) { 5116 if (i == sz - 1) { 5117 return ifaces_[i]->get_count(key, column_parent, predicate, consistency_level); 5118 } else { 5119 ifaces_[i]->get_count(key, column_parent, predicate, consistency_level); 5120 } 5121 } 5122 return 0xDEADBEEF; //psergey: shut up the compiler 5123 } 5124 5125 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) { 5126 size_t sz = ifaces_.size(); 5127 for (size_t i = 0; i < sz; ++i) { 5128 if (i == sz - 1) { 5129 ifaces_[i]->multiget_slice(_return, keys, column_parent, predicate, consistency_level); 5130 return; 5131 } else { 5132 ifaces_[i]->multiget_slice(_return, keys, column_parent, predicate, consistency_level); 5133 } 5134 } 5135 } 5136 5137 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) { 5138 size_t sz = ifaces_.size(); 5139 for (size_t i = 0; i < sz; ++i) { 5140 if (i == sz - 1) { 5141 ifaces_[i]->multiget_count(_return, keys, column_parent, predicate, consistency_level); 5142 return; 5143 } else { 5144 ifaces_[i]->multiget_count(_return, keys, column_parent, predicate, consistency_level); 5145 } 5146 } 5147 } 5148 5149 void get_range_slices(std::vector<KeySlice> & _return, const ColumnParent& column_parent, const SlicePredicate& predicate, const KeyRange& range, const ConsistencyLevel::type consistency_level) { 5150 size_t sz = ifaces_.size(); 5151 for (size_t i = 0; i < sz; ++i) { 5152 if (i == sz - 1) { 5153 ifaces_[i]->get_range_slices(_return, column_parent, predicate, range, consistency_level); 5154 return; 5155 } else { 5156 ifaces_[i]->get_range_slices(_return, column_parent, predicate, range, consistency_level); 5157 } 5158 } 5159 } 5160 5161 void get_paged_slice(std::vector<KeySlice> & _return, const std::string& column_family, const KeyRange& range, const std::string& start_column, const ConsistencyLevel::type consistency_level) { 5162 size_t sz = ifaces_.size(); 5163 for (size_t i = 0; i < sz; ++i) { 5164 if (i == sz - 1) { 5165 ifaces_[i]->get_paged_slice(_return, column_family, range, start_column, consistency_level); 5166 return; 5167 } else { 5168 ifaces_[i]->get_paged_slice(_return, column_family, range, start_column, consistency_level); 5169 } 5170 } 5171 } 5172 5173 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) { 5174 size_t sz = ifaces_.size(); 5175 for (size_t i = 0; i < sz; ++i) { 5176 if (i == sz - 1) { 5177 ifaces_[i]->get_indexed_slices(_return, column_parent, index_clause, column_predicate, consistency_level); 5178 return; 5179 } else { 5180 ifaces_[i]->get_indexed_slices(_return, column_parent, index_clause, column_predicate, consistency_level); 5181 } 5182 } 5183 } 5184 5185 void insert(const std::string& key, const ColumnParent& column_parent, const Column& column, const ConsistencyLevel::type consistency_level) { 5186 size_t sz = ifaces_.size(); 5187 for (size_t i = 0; i < sz; ++i) { 5188 ifaces_[i]->insert(key, column_parent, column, consistency_level); 5189 } 5190 } 5191 5192 void add(const std::string& key, const ColumnParent& column_parent, const CounterColumn& column, const ConsistencyLevel::type consistency_level) { 5193 size_t sz = ifaces_.size(); 5194 for (size_t i = 0; i < sz; ++i) { 5195 ifaces_[i]->add(key, column_parent, column, consistency_level); 5196 } 5197 } 5198 5199 void remove(const std::string& key, const ColumnPath& column_path, const int64_t timestamp, const ConsistencyLevel::type consistency_level) { 5200 size_t sz = ifaces_.size(); 5201 for (size_t i = 0; i < sz; ++i) { 5202 ifaces_[i]->remove(key, column_path, timestamp, consistency_level); 5203 } 5204 } 5205 5206 void remove_counter(const std::string& key, const ColumnPath& path, const ConsistencyLevel::type consistency_level) { 5207 size_t sz = ifaces_.size(); 5208 for (size_t i = 0; i < sz; ++i) { 5209 ifaces_[i]->remove_counter(key, path, consistency_level); 5210 } 5211 } 5212 5213 void batch_mutate(const std::map<std::string, std::map<std::string, std::vector<Mutation> > > & mutation_map, const ConsistencyLevel::type consistency_level) { 5214 size_t sz = ifaces_.size(); 5215 for (size_t i = 0; i < sz; ++i) { 5216 ifaces_[i]->batch_mutate(mutation_map, consistency_level); 5217 } 5218 } 5219 5220 void truncate(const std::string& cfname) { 5221 size_t sz = ifaces_.size(); 5222 for (size_t i = 0; i < sz; ++i) { 5223 ifaces_[i]->truncate(cfname); 5224 } 5225 } 5226 5227 void describe_schema_versions(std::map<std::string, std::vector<std::string> > & _return) { 5228 size_t sz = ifaces_.size(); 5229 for (size_t i = 0; i < sz; ++i) { 5230 if (i == sz - 1) { 5231 ifaces_[i]->describe_schema_versions(_return); 5232 return; 5233 } else { 5234 ifaces_[i]->describe_schema_versions(_return); 5235 } 5236 } 5237 } 5238 5239 void describe_keyspaces(std::vector<KsDef> & _return) { 5240 size_t sz = ifaces_.size(); 5241 for (size_t i = 0; i < sz; ++i) { 5242 if (i == sz - 1) { 5243 ifaces_[i]->describe_keyspaces(_return); 5244 return; 5245 } else { 5246 ifaces_[i]->describe_keyspaces(_return); 5247 } 5248 } 5249 } 5250 5251 void describe_cluster_name(std::string& _return) { 5252 size_t sz = ifaces_.size(); 5253 for (size_t i = 0; i < sz; ++i) { 5254 if (i == sz - 1) { 5255 ifaces_[i]->describe_cluster_name(_return); 5256 return; 5257 } else { 5258 ifaces_[i]->describe_cluster_name(_return); 5259 } 5260 } 5261 } 5262 5263 void describe_version(std::string& _return) { 5264 size_t sz = ifaces_.size(); 5265 for (size_t i = 0; i < sz; ++i) { 5266 if (i == sz - 1) { 5267 ifaces_[i]->describe_version(_return); 5268 return; 5269 } else { 5270 ifaces_[i]->describe_version(_return); 5271 } 5272 } 5273 } 5274 5275 void describe_ring(std::vector<TokenRange> & _return, const std::string& keyspace) { 5276 size_t sz = ifaces_.size(); 5277 for (size_t i = 0; i < sz; ++i) { 5278 if (i == sz - 1) { 5279 ifaces_[i]->describe_ring(_return, keyspace); 5280 return; 5281 } else { 5282 ifaces_[i]->describe_ring(_return, keyspace); 5283 } 5284 } 5285 } 5286 5287 void describe_token_map(std::map<std::string, std::string> & _return) { 5288 size_t sz = ifaces_.size(); 5289 for (size_t i = 0; i < sz; ++i) { 5290 if (i == sz - 1) { 5291 ifaces_[i]->describe_token_map(_return); 5292 return; 5293 } else { 5294 ifaces_[i]->describe_token_map(_return); 5295 } 5296 } 5297 } 5298 5299 void describe_partitioner(std::string& _return) { 5300 size_t sz = ifaces_.size(); 5301 for (size_t i = 0; i < sz; ++i) { 5302 if (i == sz - 1) { 5303 ifaces_[i]->describe_partitioner(_return); 5304 return; 5305 } else { 5306 ifaces_[i]->describe_partitioner(_return); 5307 } 5308 } 5309 } 5310 5311 void describe_snitch(std::string& _return) { 5312 size_t sz = ifaces_.size(); 5313 for (size_t i = 0; i < sz; ++i) { 5314 if (i == sz - 1) { 5315 ifaces_[i]->describe_snitch(_return); 5316 return; 5317 } else { 5318 ifaces_[i]->describe_snitch(_return); 5319 } 5320 } 5321 } 5322 5323 void describe_keyspace(KsDef& _return, const std::string& keyspace) { 5324 size_t sz = ifaces_.size(); 5325 for (size_t i = 0; i < sz; ++i) { 5326 if (i == sz - 1) { 5327 ifaces_[i]->describe_keyspace(_return, keyspace); 5328 return; 5329 } else { 5330 ifaces_[i]->describe_keyspace(_return, keyspace); 5331 } 5332 } 5333 } 5334 5335 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) { 5336 size_t sz = ifaces_.size(); 5337 for (size_t i = 0; i < sz; ++i) { 5338 if (i == sz - 1) { 5339 ifaces_[i]->describe_splits(_return, cfName, start_token, end_token, keys_per_split); 5340 return; 5341 } else { 5342 ifaces_[i]->describe_splits(_return, cfName, start_token, end_token, keys_per_split); 5343 } 5344 } 5345 } 5346 5347 void system_add_column_family(std::string& _return, const CfDef& cf_def) { 5348 size_t sz = ifaces_.size(); 5349 for (size_t i = 0; i < sz; ++i) { 5350 if (i == sz - 1) { 5351 ifaces_[i]->system_add_column_family(_return, cf_def); 5352 return; 5353 } else { 5354 ifaces_[i]->system_add_column_family(_return, cf_def); 5355 } 5356 } 5357 } 5358 5359 void system_drop_column_family(std::string& _return, const std::string& column_family) { 5360 size_t sz = ifaces_.size(); 5361 for (size_t i = 0; i < sz; ++i) { 5362 if (i == sz - 1) { 5363 ifaces_[i]->system_drop_column_family(_return, column_family); 5364 return; 5365 } else { 5366 ifaces_[i]->system_drop_column_family(_return, column_family); 5367 } 5368 } 5369 } 5370 5371 void system_add_keyspace(std::string& _return, const KsDef& ks_def) { 5372 size_t sz = ifaces_.size(); 5373 for (size_t i = 0; i < sz; ++i) { 5374 if (i == sz - 1) { 5375 ifaces_[i]->system_add_keyspace(_return, ks_def); 5376 return; 5377 } else { 5378 ifaces_[i]->system_add_keyspace(_return, ks_def); 5379 } 5380 } 5381 } 5382 5383 void system_drop_keyspace(std::string& _return, const std::string& keyspace) { 5384 size_t sz = ifaces_.size(); 5385 for (size_t i = 0; i < sz; ++i) { 5386 if (i == sz - 1) { 5387 ifaces_[i]->system_drop_keyspace(_return, keyspace); 5388 return; 5389 } else { 5390 ifaces_[i]->system_drop_keyspace(_return, keyspace); 5391 } 5392 } 5393 } 5394 5395 void system_update_keyspace(std::string& _return, const KsDef& ks_def) { 5396 size_t sz = ifaces_.size(); 5397 for (size_t i = 0; i < sz; ++i) { 5398 if (i == sz - 1) { 5399 ifaces_[i]->system_update_keyspace(_return, ks_def); 5400 return; 5401 } else { 5402 ifaces_[i]->system_update_keyspace(_return, ks_def); 5403 } 5404 } 5405 } 5406 5407 void system_update_column_family(std::string& _return, const CfDef& cf_def) { 5408 size_t sz = ifaces_.size(); 5409 for (size_t i = 0; i < sz; ++i) { 5410 if (i == sz - 1) { 5411 ifaces_[i]->system_update_column_family(_return, cf_def); 5412 return; 5413 } else { 5414 ifaces_[i]->system_update_column_family(_return, cf_def); 5415 } 5416 } 5417 } 5418 5419 void execute_cql_query(CqlResult& _return, const std::string& query, const Compression::type compression) { 5420 size_t sz = ifaces_.size(); 5421 for (size_t i = 0; i < sz; ++i) { 5422 if (i == sz - 1) { 5423 ifaces_[i]->execute_cql_query(_return, query, compression); 5424 return; 5425 } else { 5426 ifaces_[i]->execute_cql_query(_return, query, compression); 5427 } 5428 } 5429 } 5430 5431 void prepare_cql_query(CqlPreparedResult& _return, const std::string& query, const Compression::type compression) { 5432 size_t sz = ifaces_.size(); 5433 for (size_t i = 0; i < sz; ++i) { 5434 if (i == sz - 1) { 5435 ifaces_[i]->prepare_cql_query(_return, query, compression); 5436 return; 5437 } else { 5438 ifaces_[i]->prepare_cql_query(_return, query, compression); 5439 } 5440 } 5441 } 5442 5443 void execute_prepared_cql_query(CqlResult& _return, const int32_t itemId, const std::vector<std::string> & values) { 5444 size_t sz = ifaces_.size(); 5445 for (size_t i = 0; i < sz; ++i) { 5446 if (i == sz - 1) { 5447 ifaces_[i]->execute_prepared_cql_query(_return, itemId, values); 5448 return; 5449 } else { 5450 ifaces_[i]->execute_prepared_cql_query(_return, itemId, values); 5451 } 5452 } 5453 } 5454 5455 void set_cql_version(const std::string& version) { 5456 size_t sz = ifaces_.size(); 5457 for (size_t i = 0; i < sz; ++i) { 5458 ifaces_[i]->set_cql_version(version); 5459 } 5460 } 5461 5462 }; 5463 5464 }}} // namespace 5465 5466 #endif 5467