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