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