1 /** 2 * Autogenerated by Thrift Compiler (0.8.0) 3 * 4 * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING 5 * @generated 6 */ 7 #ifndef cassandra_TYPES_H 8 #define cassandra_TYPES_H 9 10 #include <inttypes.h> 11 #include <netinet/in.h> 12 13 #include <thrift/Thrift.h> 14 #include <thrift/TApplicationException.h> 15 #include <thrift/protocol/TProtocol.h> 16 #include <thrift/transport/TTransport.h> 17 18 19 20 namespace org { namespace apache { namespace cassandra { 21 22 struct ConsistencyLevel { 23 enum type { 24 ONE = 1, 25 QUORUM = 2, 26 LOCAL_QUORUM = 3, 27 EACH_QUORUM = 4, 28 ALL = 5, 29 ANY = 6, 30 TWO = 7, 31 THREE = 8 32 }; 33 }; 34 35 extern const std::map<int, const char*> _ConsistencyLevel_VALUES_TO_NAMES; 36 37 struct IndexOperator { 38 enum type { 39 EQ = 0, 40 GTE = 1, 41 GT = 2, 42 LTE = 3, 43 LT = 4 44 }; 45 }; 46 47 extern const std::map<int, const char*> _IndexOperator_VALUES_TO_NAMES; 48 49 struct IndexType { 50 enum type { 51 KEYS = 0, 52 CUSTOM = 1 53 }; 54 }; 55 56 extern const std::map<int, const char*> _IndexType_VALUES_TO_NAMES; 57 58 struct Compression { 59 enum type { 60 GZIP = 1, 61 NONE = 2 62 }; 63 }; 64 65 extern const std::map<int, const char*> _Compression_VALUES_TO_NAMES; 66 67 struct CqlResultType { 68 enum type { 69 ROWS = 1, 70 VOID = 2, 71 INT = 3 72 }; 73 }; 74 75 extern const std::map<int, const char*> _CqlResultType_VALUES_TO_NAMES; 76 77 typedef struct _Column__isset { _Column__isset_Column__isset78 _Column__isset() : value(false), timestamp(false), ttl(false) {} 79 bool value; 80 bool timestamp; 81 bool ttl; 82 } _Column__isset; 83 84 class Column { 85 public: 86 87 static const char* ascii_fingerprint; // = "3EE0E1C5C844001B62F08125068292CC"; 88 static const uint8_t binary_fingerprint[16]; // = {0x3E,0xE0,0xE1,0xC5,0xC8,0x44,0x00,0x1B,0x62,0xF0,0x81,0x25,0x06,0x82,0x92,0xCC}; 89 Column()90 Column() : name(""), value(""), timestamp(0), ttl(0) { 91 } 92 ~Column()93 virtual ~Column() throw() {} 94 95 std::string name; 96 std::string value; 97 int64_t timestamp; 98 int32_t ttl; 99 100 _Column__isset __isset; 101 __set_name(const std::string & val)102 void __set_name(const std::string& val) { 103 name = val; 104 } 105 __set_value(const std::string & val)106 void __set_value(const std::string& val) { 107 value = val; 108 __isset.value = true; 109 } 110 __set_timestamp(const int64_t val)111 void __set_timestamp(const int64_t val) { 112 timestamp = val; 113 __isset.timestamp = true; 114 } 115 __set_ttl(const int32_t val)116 void __set_ttl(const int32_t val) { 117 ttl = val; 118 __isset.ttl = true; 119 } 120 121 bool operator == (const Column & rhs) const 122 { 123 if (!(name == rhs.name)) 124 return false; 125 if (__isset.value != rhs.__isset.value) 126 return false; 127 else if (__isset.value && !(value == rhs.value)) 128 return false; 129 if (__isset.timestamp != rhs.__isset.timestamp) 130 return false; 131 else if (__isset.timestamp && !(timestamp == rhs.timestamp)) 132 return false; 133 if (__isset.ttl != rhs.__isset.ttl) 134 return false; 135 else if (__isset.ttl && !(ttl == rhs.ttl)) 136 return false; 137 return true; 138 } 139 bool operator != (const Column &rhs) const { 140 return !(*this == rhs); 141 } 142 143 bool operator < (const Column & ) const; 144 145 uint32_t read(::apache::thrift::protocol::TProtocol* iprot); 146 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; 147 148 }; 149 150 151 class SuperColumn { 152 public: 153 154 static const char* ascii_fingerprint; // = "470EFC558004E98D92D604898305C04E"; 155 static const uint8_t binary_fingerprint[16]; // = {0x47,0x0E,0xFC,0x55,0x80,0x04,0xE9,0x8D,0x92,0xD6,0x04,0x89,0x83,0x05,0xC0,0x4E}; 156 SuperColumn()157 SuperColumn() : name("") { 158 } 159 ~SuperColumn()160 virtual ~SuperColumn() throw() {} 161 162 std::string name; 163 std::vector<Column> columns; 164 __set_name(const std::string & val)165 void __set_name(const std::string& val) { 166 name = val; 167 } 168 __set_columns(const std::vector<Column> & val)169 void __set_columns(const std::vector<Column> & val) { 170 columns = val; 171 } 172 173 bool operator == (const SuperColumn & rhs) const 174 { 175 if (!(name == rhs.name)) 176 return false; 177 if (!(columns == rhs.columns)) 178 return false; 179 return true; 180 } 181 bool operator != (const SuperColumn &rhs) const { 182 return !(*this == rhs); 183 } 184 185 bool operator < (const SuperColumn & ) const; 186 187 uint32_t read(::apache::thrift::protocol::TProtocol* iprot); 188 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; 189 190 }; 191 192 193 class CounterColumn { 194 public: 195 196 static const char* ascii_fingerprint; // = "1CCCF6FC31CFD1D61BBBB1BAF3590620"; 197 static const uint8_t binary_fingerprint[16]; // = {0x1C,0xCC,0xF6,0xFC,0x31,0xCF,0xD1,0xD6,0x1B,0xBB,0xB1,0xBA,0xF3,0x59,0x06,0x20}; 198 CounterColumn()199 CounterColumn() : name(""), value(0) { 200 } 201 ~CounterColumn()202 virtual ~CounterColumn() throw() {} 203 204 std::string name; 205 int64_t value; 206 __set_name(const std::string & val)207 void __set_name(const std::string& val) { 208 name = val; 209 } 210 __set_value(const int64_t val)211 void __set_value(const int64_t val) { 212 value = val; 213 } 214 215 bool operator == (const CounterColumn & rhs) const 216 { 217 if (!(name == rhs.name)) 218 return false; 219 if (!(value == rhs.value)) 220 return false; 221 return true; 222 } 223 bool operator != (const CounterColumn &rhs) const { 224 return !(*this == rhs); 225 } 226 227 bool operator < (const CounterColumn & ) const; 228 229 uint32_t read(::apache::thrift::protocol::TProtocol* iprot); 230 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; 231 232 }; 233 234 235 class CounterSuperColumn { 236 public: 237 238 static const char* ascii_fingerprint; // = "CD4C8C4BF7753E46DE417CDE369343A4"; 239 static const uint8_t binary_fingerprint[16]; // = {0xCD,0x4C,0x8C,0x4B,0xF7,0x75,0x3E,0x46,0xDE,0x41,0x7C,0xDE,0x36,0x93,0x43,0xA4}; 240 CounterSuperColumn()241 CounterSuperColumn() : name("") { 242 } 243 ~CounterSuperColumn()244 virtual ~CounterSuperColumn() throw() {} 245 246 std::string name; 247 std::vector<CounterColumn> columns; 248 __set_name(const std::string & val)249 void __set_name(const std::string& val) { 250 name = val; 251 } 252 __set_columns(const std::vector<CounterColumn> & val)253 void __set_columns(const std::vector<CounterColumn> & val) { 254 columns = val; 255 } 256 257 bool operator == (const CounterSuperColumn & rhs) const 258 { 259 if (!(name == rhs.name)) 260 return false; 261 if (!(columns == rhs.columns)) 262 return false; 263 return true; 264 } 265 bool operator != (const CounterSuperColumn &rhs) const { 266 return !(*this == rhs); 267 } 268 269 bool operator < (const CounterSuperColumn & ) const; 270 271 uint32_t read(::apache::thrift::protocol::TProtocol* iprot); 272 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; 273 274 }; 275 276 typedef struct _ColumnOrSuperColumn__isset { _ColumnOrSuperColumn__isset_ColumnOrSuperColumn__isset277 _ColumnOrSuperColumn__isset() : column(false), super_column(false), counter_column(false), counter_super_column(false) {} 278 bool column; 279 bool super_column; 280 bool counter_column; 281 bool counter_super_column; 282 } _ColumnOrSuperColumn__isset; 283 284 class ColumnOrSuperColumn { 285 public: 286 287 static const char* ascii_fingerprint; // = "2B34AC9E80F1DAA3A2A63B1AB1841E61"; 288 static const uint8_t binary_fingerprint[16]; // = {0x2B,0x34,0xAC,0x9E,0x80,0xF1,0xDA,0xA3,0xA2,0xA6,0x3B,0x1A,0xB1,0x84,0x1E,0x61}; 289 ColumnOrSuperColumn()290 ColumnOrSuperColumn() { 291 } 292 ~ColumnOrSuperColumn()293 virtual ~ColumnOrSuperColumn() throw() {} 294 295 Column column; 296 SuperColumn super_column; 297 CounterColumn counter_column; 298 CounterSuperColumn counter_super_column; 299 300 _ColumnOrSuperColumn__isset __isset; 301 __set_column(const Column & val)302 void __set_column(const Column& val) { 303 column = val; 304 __isset.column = true; 305 } 306 __set_super_column(const SuperColumn & val)307 void __set_super_column(const SuperColumn& val) { 308 super_column = val; 309 __isset.super_column = true; 310 } 311 __set_counter_column(const CounterColumn & val)312 void __set_counter_column(const CounterColumn& val) { 313 counter_column = val; 314 __isset.counter_column = true; 315 } 316 __set_counter_super_column(const CounterSuperColumn & val)317 void __set_counter_super_column(const CounterSuperColumn& val) { 318 counter_super_column = val; 319 __isset.counter_super_column = true; 320 } 321 322 bool operator == (const ColumnOrSuperColumn & rhs) const 323 { 324 if (__isset.column != rhs.__isset.column) 325 return false; 326 else if (__isset.column && !(column == rhs.column)) 327 return false; 328 if (__isset.super_column != rhs.__isset.super_column) 329 return false; 330 else if (__isset.super_column && !(super_column == rhs.super_column)) 331 return false; 332 if (__isset.counter_column != rhs.__isset.counter_column) 333 return false; 334 else if (__isset.counter_column && !(counter_column == rhs.counter_column)) 335 return false; 336 if (__isset.counter_super_column != rhs.__isset.counter_super_column) 337 return false; 338 else if (__isset.counter_super_column && !(counter_super_column == rhs.counter_super_column)) 339 return false; 340 return true; 341 } 342 bool operator != (const ColumnOrSuperColumn &rhs) const { 343 return !(*this == rhs); 344 } 345 346 bool operator < (const ColumnOrSuperColumn & ) const; 347 348 uint32_t read(::apache::thrift::protocol::TProtocol* iprot); 349 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; 350 351 }; 352 353 354 class NotFoundException : public ::apache::thrift::TException { 355 public: 356 357 static const char* ascii_fingerprint; // = "99914B932BD37A50B983C5E7C90AE93B"; 358 static const uint8_t binary_fingerprint[16]; // = {0x99,0x91,0x4B,0x93,0x2B,0xD3,0x7A,0x50,0xB9,0x83,0xC5,0xE7,0xC9,0x0A,0xE9,0x3B}; 359 NotFoundException()360 NotFoundException() { 361 } 362 ~NotFoundException()363 virtual ~NotFoundException() throw() {} 364 365 366 bool operator == (const NotFoundException & /* rhs */) const 367 { 368 return true; 369 } 370 bool operator != (const NotFoundException &rhs) const { 371 return !(*this == rhs); 372 } 373 374 bool operator < (const NotFoundException & ) const; 375 376 uint32_t read(::apache::thrift::protocol::TProtocol* iprot); 377 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; 378 379 }; 380 381 382 class InvalidRequestException : public ::apache::thrift::TException { 383 public: 384 385 static const char* ascii_fingerprint; // = "EFB929595D312AC8F305D5A794CFEDA1"; 386 static const uint8_t binary_fingerprint[16]; // = {0xEF,0xB9,0x29,0x59,0x5D,0x31,0x2A,0xC8,0xF3,0x05,0xD5,0xA7,0x94,0xCF,0xED,0xA1}; 387 InvalidRequestException()388 InvalidRequestException() : why("") { 389 } 390 ~InvalidRequestException()391 virtual ~InvalidRequestException() throw() {} 392 393 std::string why; 394 __set_why(const std::string & val)395 void __set_why(const std::string& val) { 396 why = val; 397 } 398 399 bool operator == (const InvalidRequestException & rhs) const 400 { 401 if (!(why == rhs.why)) 402 return false; 403 return true; 404 } 405 bool operator != (const InvalidRequestException &rhs) const { 406 return !(*this == rhs); 407 } 408 409 bool operator < (const InvalidRequestException & ) const; 410 411 uint32_t read(::apache::thrift::protocol::TProtocol* iprot); 412 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; 413 414 }; 415 416 417 class UnavailableException : public ::apache::thrift::TException { 418 public: 419 420 static const char* ascii_fingerprint; // = "99914B932BD37A50B983C5E7C90AE93B"; 421 static const uint8_t binary_fingerprint[16]; // = {0x99,0x91,0x4B,0x93,0x2B,0xD3,0x7A,0x50,0xB9,0x83,0xC5,0xE7,0xC9,0x0A,0xE9,0x3B}; 422 UnavailableException()423 UnavailableException() { 424 } 425 ~UnavailableException()426 virtual ~UnavailableException() throw() {} 427 428 429 bool operator == (const UnavailableException & /* rhs */) const 430 { 431 return true; 432 } 433 bool operator != (const UnavailableException &rhs) const { 434 return !(*this == rhs); 435 } 436 437 bool operator < (const UnavailableException & ) 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 445 class TimedOutException : public ::apache::thrift::TException { 446 public: 447 448 static const char* ascii_fingerprint; // = "99914B932BD37A50B983C5E7C90AE93B"; 449 static const uint8_t binary_fingerprint[16]; // = {0x99,0x91,0x4B,0x93,0x2B,0xD3,0x7A,0x50,0xB9,0x83,0xC5,0xE7,0xC9,0x0A,0xE9,0x3B}; 450 TimedOutException()451 TimedOutException() { 452 } 453 ~TimedOutException()454 virtual ~TimedOutException() throw() {} 455 456 457 bool operator == (const TimedOutException & /* rhs */) const 458 { 459 return true; 460 } 461 bool operator != (const TimedOutException &rhs) const { 462 return !(*this == rhs); 463 } 464 465 bool operator < (const TimedOutException & ) const; 466 467 uint32_t read(::apache::thrift::protocol::TProtocol* iprot); 468 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; 469 470 }; 471 472 473 class AuthenticationException : public ::apache::thrift::TException { 474 public: 475 476 static const char* ascii_fingerprint; // = "EFB929595D312AC8F305D5A794CFEDA1"; 477 static const uint8_t binary_fingerprint[16]; // = {0xEF,0xB9,0x29,0x59,0x5D,0x31,0x2A,0xC8,0xF3,0x05,0xD5,0xA7,0x94,0xCF,0xED,0xA1}; 478 AuthenticationException()479 AuthenticationException() : why("") { 480 } 481 ~AuthenticationException()482 virtual ~AuthenticationException() throw() {} 483 484 std::string why; 485 __set_why(const std::string & val)486 void __set_why(const std::string& val) { 487 why = val; 488 } 489 490 bool operator == (const AuthenticationException & rhs) const 491 { 492 if (!(why == rhs.why)) 493 return false; 494 return true; 495 } 496 bool operator != (const AuthenticationException &rhs) const { 497 return !(*this == rhs); 498 } 499 500 bool operator < (const AuthenticationException & ) const; 501 502 uint32_t read(::apache::thrift::protocol::TProtocol* iprot); 503 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; 504 505 }; 506 507 508 class AuthorizationException : public ::apache::thrift::TException { 509 public: 510 511 static const char* ascii_fingerprint; // = "EFB929595D312AC8F305D5A794CFEDA1"; 512 static const uint8_t binary_fingerprint[16]; // = {0xEF,0xB9,0x29,0x59,0x5D,0x31,0x2A,0xC8,0xF3,0x05,0xD5,0xA7,0x94,0xCF,0xED,0xA1}; 513 AuthorizationException()514 AuthorizationException() : why("") { 515 } 516 ~AuthorizationException()517 virtual ~AuthorizationException() throw() {} 518 519 std::string why; 520 __set_why(const std::string & val)521 void __set_why(const std::string& val) { 522 why = val; 523 } 524 525 bool operator == (const AuthorizationException & rhs) const 526 { 527 if (!(why == rhs.why)) 528 return false; 529 return true; 530 } 531 bool operator != (const AuthorizationException &rhs) const { 532 return !(*this == rhs); 533 } 534 535 bool operator < (const AuthorizationException & ) const; 536 537 uint32_t read(::apache::thrift::protocol::TProtocol* iprot); 538 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; 539 540 }; 541 542 543 class SchemaDisagreementException : public ::apache::thrift::TException { 544 public: 545 546 static const char* ascii_fingerprint; // = "99914B932BD37A50B983C5E7C90AE93B"; 547 static const uint8_t binary_fingerprint[16]; // = {0x99,0x91,0x4B,0x93,0x2B,0xD3,0x7A,0x50,0xB9,0x83,0xC5,0xE7,0xC9,0x0A,0xE9,0x3B}; 548 SchemaDisagreementException()549 SchemaDisagreementException() { 550 } 551 ~SchemaDisagreementException()552 virtual ~SchemaDisagreementException() throw() {} 553 554 555 bool operator == (const SchemaDisagreementException & /* rhs */) const 556 { 557 return true; 558 } 559 bool operator != (const SchemaDisagreementException &rhs) const { 560 return !(*this == rhs); 561 } 562 563 bool operator < (const SchemaDisagreementException & ) const; 564 565 uint32_t read(::apache::thrift::protocol::TProtocol* iprot); 566 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; 567 568 }; 569 570 typedef struct _ColumnParent__isset { _ColumnParent__isset_ColumnParent__isset571 _ColumnParent__isset() : super_column(false) {} 572 bool super_column; 573 } _ColumnParent__isset; 574 575 class ColumnParent { 576 public: 577 578 static const char* ascii_fingerprint; // = "0A13AE61181713A4100DFFB3EC293822"; 579 static const uint8_t binary_fingerprint[16]; // = {0x0A,0x13,0xAE,0x61,0x18,0x17,0x13,0xA4,0x10,0x0D,0xFF,0xB3,0xEC,0x29,0x38,0x22}; 580 ColumnParent()581 ColumnParent() : column_family(""), super_column("") { 582 } 583 ~ColumnParent()584 virtual ~ColumnParent() throw() {} 585 586 std::string column_family; 587 std::string super_column; 588 589 _ColumnParent__isset __isset; 590 __set_column_family(const std::string & val)591 void __set_column_family(const std::string& val) { 592 column_family = val; 593 } 594 __set_super_column(const std::string & val)595 void __set_super_column(const std::string& val) { 596 super_column = val; 597 __isset.super_column = true; 598 } 599 600 bool operator == (const ColumnParent & rhs) const 601 { 602 if (!(column_family == rhs.column_family)) 603 return false; 604 if (__isset.super_column != rhs.__isset.super_column) 605 return false; 606 else if (__isset.super_column && !(super_column == rhs.super_column)) 607 return false; 608 return true; 609 } 610 bool operator != (const ColumnParent &rhs) const { 611 return !(*this == rhs); 612 } 613 614 bool operator < (const ColumnParent & ) const; 615 616 uint32_t read(::apache::thrift::protocol::TProtocol* iprot); 617 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; 618 619 }; 620 621 typedef struct _ColumnPath__isset { _ColumnPath__isset_ColumnPath__isset622 _ColumnPath__isset() : super_column(false), column(false) {} 623 bool super_column; 624 bool column; 625 } _ColumnPath__isset; 626 627 class ColumnPath { 628 public: 629 630 static const char* ascii_fingerprint; // = "606212895BCF63C757913CF35AEB3462"; 631 static const uint8_t binary_fingerprint[16]; // = {0x60,0x62,0x12,0x89,0x5B,0xCF,0x63,0xC7,0x57,0x91,0x3C,0xF3,0x5A,0xEB,0x34,0x62}; 632 ColumnPath()633 ColumnPath() : column_family(""), super_column(""), column("") { 634 } 635 ~ColumnPath()636 virtual ~ColumnPath() throw() {} 637 638 std::string column_family; 639 std::string super_column; 640 std::string column; 641 642 _ColumnPath__isset __isset; 643 __set_column_family(const std::string & val)644 void __set_column_family(const std::string& val) { 645 column_family = val; 646 } 647 __set_super_column(const std::string & val)648 void __set_super_column(const std::string& val) { 649 super_column = val; 650 __isset.super_column = true; 651 } 652 __set_column(const std::string & val)653 void __set_column(const std::string& val) { 654 column = val; 655 __isset.column = true; 656 } 657 658 bool operator == (const ColumnPath & rhs) const 659 { 660 if (!(column_family == rhs.column_family)) 661 return false; 662 if (__isset.super_column != rhs.__isset.super_column) 663 return false; 664 else if (__isset.super_column && !(super_column == rhs.super_column)) 665 return false; 666 if (__isset.column != rhs.__isset.column) 667 return false; 668 else if (__isset.column && !(column == rhs.column)) 669 return false; 670 return true; 671 } 672 bool operator != (const ColumnPath &rhs) const { 673 return !(*this == rhs); 674 } 675 676 bool operator < (const ColumnPath & ) const; 677 678 uint32_t read(::apache::thrift::protocol::TProtocol* iprot); 679 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; 680 681 }; 682 683 684 class SliceRange { 685 public: 686 687 static const char* ascii_fingerprint; // = "184D24C9A0B8D4415E234DB649CAE740"; 688 static const uint8_t binary_fingerprint[16]; // = {0x18,0x4D,0x24,0xC9,0xA0,0xB8,0xD4,0x41,0x5E,0x23,0x4D,0xB6,0x49,0xCA,0xE7,0x40}; 689 SliceRange()690 SliceRange() : start(""), finish(""), reversed(false), count(100) { 691 } 692 ~SliceRange()693 virtual ~SliceRange() throw() {} 694 695 std::string start; 696 std::string finish; 697 bool reversed; 698 int32_t count; 699 __set_start(const std::string & val)700 void __set_start(const std::string& val) { 701 start = val; 702 } 703 __set_finish(const std::string & val)704 void __set_finish(const std::string& val) { 705 finish = val; 706 } 707 __set_reversed(const bool val)708 void __set_reversed(const bool val) { 709 reversed = val; 710 } 711 __set_count(const int32_t val)712 void __set_count(const int32_t val) { 713 count = val; 714 } 715 716 bool operator == (const SliceRange & rhs) const 717 { 718 if (!(start == rhs.start)) 719 return false; 720 if (!(finish == rhs.finish)) 721 return false; 722 if (!(reversed == rhs.reversed)) 723 return false; 724 if (!(count == rhs.count)) 725 return false; 726 return true; 727 } 728 bool operator != (const SliceRange &rhs) const { 729 return !(*this == rhs); 730 } 731 732 bool operator < (const SliceRange & ) const; 733 734 uint32_t read(::apache::thrift::protocol::TProtocol* iprot); 735 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; 736 737 }; 738 739 typedef struct _SlicePredicate__isset { _SlicePredicate__isset_SlicePredicate__isset740 _SlicePredicate__isset() : column_names(false), slice_range(false) {} 741 bool column_names; 742 bool slice_range; 743 } _SlicePredicate__isset; 744 745 class SlicePredicate { 746 public: 747 748 static const char* ascii_fingerprint; // = "F59D1D81C17DFFAF09988BF1C9CE5E27"; 749 static const uint8_t binary_fingerprint[16]; // = {0xF5,0x9D,0x1D,0x81,0xC1,0x7D,0xFF,0xAF,0x09,0x98,0x8B,0xF1,0xC9,0xCE,0x5E,0x27}; 750 SlicePredicate()751 SlicePredicate() { 752 } 753 ~SlicePredicate()754 virtual ~SlicePredicate() throw() {} 755 756 std::vector<std::string> column_names; 757 SliceRange slice_range; 758 759 _SlicePredicate__isset __isset; 760 __set_column_names(const std::vector<std::string> & val)761 void __set_column_names(const std::vector<std::string> & val) { 762 column_names = val; 763 __isset.column_names = true; 764 } 765 __set_slice_range(const SliceRange & val)766 void __set_slice_range(const SliceRange& val) { 767 slice_range = val; 768 __isset.slice_range = true; 769 } 770 771 bool operator == (const SlicePredicate & rhs) const 772 { 773 if (__isset.column_names != rhs.__isset.column_names) 774 return false; 775 else if (__isset.column_names && !(column_names == rhs.column_names)) 776 return false; 777 if (__isset.slice_range != rhs.__isset.slice_range) 778 return false; 779 else if (__isset.slice_range && !(slice_range == rhs.slice_range)) 780 return false; 781 return true; 782 } 783 bool operator != (const SlicePredicate &rhs) const { 784 return !(*this == rhs); 785 } 786 787 bool operator < (const SlicePredicate & ) const; 788 789 uint32_t read(::apache::thrift::protocol::TProtocol* iprot); 790 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; 791 792 }; 793 794 795 class IndexExpression { 796 public: 797 798 static const char* ascii_fingerprint; // = "D9F4CFE2F293A8B1052FD3031DD2C847"; 799 static const uint8_t binary_fingerprint[16]; // = {0xD9,0xF4,0xCF,0xE2,0xF2,0x93,0xA8,0xB1,0x05,0x2F,0xD3,0x03,0x1D,0xD2,0xC8,0x47}; 800 IndexExpression()801 IndexExpression() : column_name(""), op((IndexOperator::type)0), value("") { 802 } 803 ~IndexExpression()804 virtual ~IndexExpression() throw() {} 805 806 std::string column_name; 807 IndexOperator::type op; 808 std::string value; 809 __set_column_name(const std::string & val)810 void __set_column_name(const std::string& val) { 811 column_name = val; 812 } 813 __set_op(const IndexOperator::type val)814 void __set_op(const IndexOperator::type val) { 815 op = val; 816 } 817 __set_value(const std::string & val)818 void __set_value(const std::string& val) { 819 value = val; 820 } 821 822 bool operator == (const IndexExpression & rhs) const 823 { 824 if (!(column_name == rhs.column_name)) 825 return false; 826 if (!(op == rhs.op)) 827 return false; 828 if (!(value == rhs.value)) 829 return false; 830 return true; 831 } 832 bool operator != (const IndexExpression &rhs) const { 833 return !(*this == rhs); 834 } 835 836 bool operator < (const IndexExpression & ) const; 837 838 uint32_t read(::apache::thrift::protocol::TProtocol* iprot); 839 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; 840 841 }; 842 843 844 class IndexClause { 845 public: 846 847 static const char* ascii_fingerprint; // = "9B551B9AB86120B0EEA9005C77FD3C1F"; 848 static const uint8_t binary_fingerprint[16]; // = {0x9B,0x55,0x1B,0x9A,0xB8,0x61,0x20,0xB0,0xEE,0xA9,0x00,0x5C,0x77,0xFD,0x3C,0x1F}; 849 IndexClause()850 IndexClause() : start_key(""), count(100) { 851 } 852 ~IndexClause()853 virtual ~IndexClause() throw() {} 854 855 std::vector<IndexExpression> expressions; 856 std::string start_key; 857 int32_t count; 858 __set_expressions(const std::vector<IndexExpression> & val)859 void __set_expressions(const std::vector<IndexExpression> & val) { 860 expressions = val; 861 } 862 __set_start_key(const std::string & val)863 void __set_start_key(const std::string& val) { 864 start_key = val; 865 } 866 __set_count(const int32_t val)867 void __set_count(const int32_t val) { 868 count = val; 869 } 870 871 bool operator == (const IndexClause & rhs) const 872 { 873 if (!(expressions == rhs.expressions)) 874 return false; 875 if (!(start_key == rhs.start_key)) 876 return false; 877 if (!(count == rhs.count)) 878 return false; 879 return true; 880 } 881 bool operator != (const IndexClause &rhs) const { 882 return !(*this == rhs); 883 } 884 885 bool operator < (const IndexClause & ) const; 886 887 uint32_t read(::apache::thrift::protocol::TProtocol* iprot); 888 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; 889 890 }; 891 892 typedef struct _KeyRange__isset { _KeyRange__isset_KeyRange__isset893 _KeyRange__isset() : start_key(false), end_key(false), start_token(false), end_token(false), row_filter(false) {} 894 bool start_key; 895 bool end_key; 896 bool start_token; 897 bool end_token; 898 bool row_filter; 899 } _KeyRange__isset; 900 901 class KeyRange { 902 public: 903 904 static const char* ascii_fingerprint; // = "A6EC82FA0980B91C7C8EB013C61CA1B0"; 905 static const uint8_t binary_fingerprint[16]; // = {0xA6,0xEC,0x82,0xFA,0x09,0x80,0xB9,0x1C,0x7C,0x8E,0xB0,0x13,0xC6,0x1C,0xA1,0xB0}; 906 KeyRange()907 KeyRange() : start_key(""), end_key(""), start_token(""), end_token(""), count(100) { 908 } 909 ~KeyRange()910 virtual ~KeyRange() throw() {} 911 912 std::string start_key; 913 std::string end_key; 914 std::string start_token; 915 std::string end_token; 916 std::vector<IndexExpression> row_filter; 917 int32_t count; 918 919 _KeyRange__isset __isset; 920 __set_start_key(const std::string & val)921 void __set_start_key(const std::string& val) { 922 start_key = val; 923 __isset.start_key = true; 924 } 925 __set_end_key(const std::string & val)926 void __set_end_key(const std::string& val) { 927 end_key = val; 928 __isset.end_key = true; 929 } 930 __set_start_token(const std::string & val)931 void __set_start_token(const std::string& val) { 932 start_token = val; 933 __isset.start_token = true; 934 } 935 __set_end_token(const std::string & val)936 void __set_end_token(const std::string& val) { 937 end_token = val; 938 __isset.end_token = true; 939 } 940 __set_row_filter(const std::vector<IndexExpression> & val)941 void __set_row_filter(const std::vector<IndexExpression> & val) { 942 row_filter = val; 943 __isset.row_filter = true; 944 } 945 __set_count(const int32_t val)946 void __set_count(const int32_t val) { 947 count = val; 948 } 949 950 bool operator == (const KeyRange & rhs) const 951 { 952 if (__isset.start_key != rhs.__isset.start_key) 953 return false; 954 else if (__isset.start_key && !(start_key == rhs.start_key)) 955 return false; 956 if (__isset.end_key != rhs.__isset.end_key) 957 return false; 958 else if (__isset.end_key && !(end_key == rhs.end_key)) 959 return false; 960 if (__isset.start_token != rhs.__isset.start_token) 961 return false; 962 else if (__isset.start_token && !(start_token == rhs.start_token)) 963 return false; 964 if (__isset.end_token != rhs.__isset.end_token) 965 return false; 966 else if (__isset.end_token && !(end_token == rhs.end_token)) 967 return false; 968 if (__isset.row_filter != rhs.__isset.row_filter) 969 return false; 970 else if (__isset.row_filter && !(row_filter == rhs.row_filter)) 971 return false; 972 if (!(count == rhs.count)) 973 return false; 974 return true; 975 } 976 bool operator != (const KeyRange &rhs) const { 977 return !(*this == rhs); 978 } 979 980 bool operator < (const KeyRange & ) const; 981 982 uint32_t read(::apache::thrift::protocol::TProtocol* iprot); 983 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; 984 985 }; 986 987 988 class KeySlice { 989 public: 990 991 static const char* ascii_fingerprint; // = "D1568675B0C135C909E3169B72A4DA3D"; 992 static const uint8_t binary_fingerprint[16]; // = {0xD1,0x56,0x86,0x75,0xB0,0xC1,0x35,0xC9,0x09,0xE3,0x16,0x9B,0x72,0xA4,0xDA,0x3D}; 993 KeySlice()994 KeySlice() : key("") { 995 } 996 ~KeySlice()997 virtual ~KeySlice() throw() {} 998 999 std::string key; 1000 std::vector<ColumnOrSuperColumn> columns; 1001 __set_key(const std::string & val)1002 void __set_key(const std::string& val) { 1003 key = val; 1004 } 1005 __set_columns(const std::vector<ColumnOrSuperColumn> & val)1006 void __set_columns(const std::vector<ColumnOrSuperColumn> & val) { 1007 columns = val; 1008 } 1009 1010 bool operator == (const KeySlice & rhs) const 1011 { 1012 if (!(key == rhs.key)) 1013 return false; 1014 if (!(columns == rhs.columns)) 1015 return false; 1016 return true; 1017 } 1018 bool operator != (const KeySlice &rhs) const { 1019 return !(*this == rhs); 1020 } 1021 1022 bool operator < (const KeySlice & ) const; 1023 1024 uint32_t read(::apache::thrift::protocol::TProtocol* iprot); 1025 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; 1026 1027 }; 1028 1029 1030 class KeyCount { 1031 public: 1032 1033 static const char* ascii_fingerprint; // = "EEBC915CE44901401D881E6091423036"; 1034 static const uint8_t binary_fingerprint[16]; // = {0xEE,0xBC,0x91,0x5C,0xE4,0x49,0x01,0x40,0x1D,0x88,0x1E,0x60,0x91,0x42,0x30,0x36}; 1035 KeyCount()1036 KeyCount() : key(""), count(0) { 1037 } 1038 ~KeyCount()1039 virtual ~KeyCount() throw() {} 1040 1041 std::string key; 1042 int32_t count; 1043 __set_key(const std::string & val)1044 void __set_key(const std::string& val) { 1045 key = val; 1046 } 1047 __set_count(const int32_t val)1048 void __set_count(const int32_t val) { 1049 count = val; 1050 } 1051 1052 bool operator == (const KeyCount & rhs) const 1053 { 1054 if (!(key == rhs.key)) 1055 return false; 1056 if (!(count == rhs.count)) 1057 return false; 1058 return true; 1059 } 1060 bool operator != (const KeyCount &rhs) const { 1061 return !(*this == rhs); 1062 } 1063 1064 bool operator < (const KeyCount & ) const; 1065 1066 uint32_t read(::apache::thrift::protocol::TProtocol* iprot); 1067 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; 1068 1069 }; 1070 1071 typedef struct _Deletion__isset { _Deletion__isset_Deletion__isset1072 _Deletion__isset() : timestamp(false), super_column(false), predicate(false) {} 1073 bool timestamp; 1074 bool super_column; 1075 bool predicate; 1076 } _Deletion__isset; 1077 1078 class Deletion { 1079 public: 1080 1081 static const char* ascii_fingerprint; // = "40F33ECF1C932CA77C2414C4E6C60CBE"; 1082 static const uint8_t binary_fingerprint[16]; // = {0x40,0xF3,0x3E,0xCF,0x1C,0x93,0x2C,0xA7,0x7C,0x24,0x14,0xC4,0xE6,0xC6,0x0C,0xBE}; 1083 Deletion()1084 Deletion() : timestamp(0), super_column("") { 1085 } 1086 ~Deletion()1087 virtual ~Deletion() throw() {} 1088 1089 int64_t timestamp; 1090 std::string super_column; 1091 SlicePredicate predicate; 1092 1093 _Deletion__isset __isset; 1094 __set_timestamp(const int64_t val)1095 void __set_timestamp(const int64_t val) { 1096 timestamp = val; 1097 __isset.timestamp = true; 1098 } 1099 __set_super_column(const std::string & val)1100 void __set_super_column(const std::string& val) { 1101 super_column = val; 1102 __isset.super_column = true; 1103 } 1104 __set_predicate(const SlicePredicate & val)1105 void __set_predicate(const SlicePredicate& val) { 1106 predicate = val; 1107 __isset.predicate = true; 1108 } 1109 1110 bool operator == (const Deletion & rhs) const 1111 { 1112 if (__isset.timestamp != rhs.__isset.timestamp) 1113 return false; 1114 else if (__isset.timestamp && !(timestamp == rhs.timestamp)) 1115 return false; 1116 if (__isset.super_column != rhs.__isset.super_column) 1117 return false; 1118 else if (__isset.super_column && !(super_column == rhs.super_column)) 1119 return false; 1120 if (__isset.predicate != rhs.__isset.predicate) 1121 return false; 1122 else if (__isset.predicate && !(predicate == rhs.predicate)) 1123 return false; 1124 return true; 1125 } 1126 bool operator != (const Deletion &rhs) const { 1127 return !(*this == rhs); 1128 } 1129 1130 bool operator < (const Deletion & ) const; 1131 1132 uint32_t read(::apache::thrift::protocol::TProtocol* iprot); 1133 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; 1134 1135 }; 1136 1137 typedef struct _Mutation__isset { _Mutation__isset_Mutation__isset1138 _Mutation__isset() : column_or_supercolumn(false), deletion(false) {} 1139 bool column_or_supercolumn; 1140 bool deletion; 1141 } _Mutation__isset; 1142 1143 class Mutation { 1144 public: 1145 1146 static const char* ascii_fingerprint; // = "E8B65DF3979C6868F80DF81F8E769E63"; 1147 static const uint8_t binary_fingerprint[16]; // = {0xE8,0xB6,0x5D,0xF3,0x97,0x9C,0x68,0x68,0xF8,0x0D,0xF8,0x1F,0x8E,0x76,0x9E,0x63}; 1148 Mutation()1149 Mutation() { 1150 } 1151 ~Mutation()1152 virtual ~Mutation() throw() {} 1153 1154 ColumnOrSuperColumn column_or_supercolumn; 1155 Deletion deletion; 1156 1157 _Mutation__isset __isset; 1158 __set_column_or_supercolumn(const ColumnOrSuperColumn & val)1159 void __set_column_or_supercolumn(const ColumnOrSuperColumn& val) { 1160 column_or_supercolumn = val; 1161 __isset.column_or_supercolumn = true; 1162 } 1163 __set_deletion(const Deletion & val)1164 void __set_deletion(const Deletion& val) { 1165 deletion = val; 1166 __isset.deletion = true; 1167 } 1168 1169 bool operator == (const Mutation & rhs) const 1170 { 1171 if (__isset.column_or_supercolumn != rhs.__isset.column_or_supercolumn) 1172 return false; 1173 else if (__isset.column_or_supercolumn && !(column_or_supercolumn == rhs.column_or_supercolumn)) 1174 return false; 1175 if (__isset.deletion != rhs.__isset.deletion) 1176 return false; 1177 else if (__isset.deletion && !(deletion == rhs.deletion)) 1178 return false; 1179 return true; 1180 } 1181 bool operator != (const Mutation &rhs) const { 1182 return !(*this == rhs); 1183 } 1184 1185 bool operator < (const Mutation & ) const; 1186 1187 uint32_t read(::apache::thrift::protocol::TProtocol* iprot); 1188 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; 1189 1190 }; 1191 1192 typedef struct _EndpointDetails__isset { _EndpointDetails__isset_EndpointDetails__isset1193 _EndpointDetails__isset() : host(false), datacenter(false), rack(false) {} 1194 bool host; 1195 bool datacenter; 1196 bool rack; 1197 } _EndpointDetails__isset; 1198 1199 class EndpointDetails { 1200 public: 1201 1202 static const char* ascii_fingerprint; // = "F4A50F0EC638C7F66026F9B6678FD89B"; 1203 static const uint8_t binary_fingerprint[16]; // = {0xF4,0xA5,0x0F,0x0E,0xC6,0x38,0xC7,0xF6,0x60,0x26,0xF9,0xB6,0x67,0x8F,0xD8,0x9B}; 1204 EndpointDetails()1205 EndpointDetails() : host(""), datacenter(""), rack("") { 1206 } 1207 ~EndpointDetails()1208 virtual ~EndpointDetails() throw() {} 1209 1210 std::string host; 1211 std::string datacenter; 1212 std::string rack; 1213 1214 _EndpointDetails__isset __isset; 1215 __set_host(const std::string & val)1216 void __set_host(const std::string& val) { 1217 host = val; 1218 } 1219 __set_datacenter(const std::string & val)1220 void __set_datacenter(const std::string& val) { 1221 datacenter = val; 1222 } 1223 __set_rack(const std::string & val)1224 void __set_rack(const std::string& val) { 1225 rack = val; 1226 __isset.rack = true; 1227 } 1228 1229 bool operator == (const EndpointDetails & rhs) const 1230 { 1231 if (!(host == rhs.host)) 1232 return false; 1233 if (!(datacenter == rhs.datacenter)) 1234 return false; 1235 if (__isset.rack != rhs.__isset.rack) 1236 return false; 1237 else if (__isset.rack && !(rack == rhs.rack)) 1238 return false; 1239 return true; 1240 } 1241 bool operator != (const EndpointDetails &rhs) const { 1242 return !(*this == rhs); 1243 } 1244 1245 bool operator < (const EndpointDetails & ) const; 1246 1247 uint32_t read(::apache::thrift::protocol::TProtocol* iprot); 1248 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; 1249 1250 }; 1251 1252 typedef struct _TokenRange__isset { _TokenRange__isset_TokenRange__isset1253 _TokenRange__isset() : rpc_endpoints(false), endpoint_details(false) {} 1254 bool rpc_endpoints; 1255 bool endpoint_details; 1256 } _TokenRange__isset; 1257 1258 class TokenRange { 1259 public: 1260 1261 static const char* ascii_fingerprint; // = "832268DC4CD6B17EE8881FC57EA04679"; 1262 static const uint8_t binary_fingerprint[16]; // = {0x83,0x22,0x68,0xDC,0x4C,0xD6,0xB1,0x7E,0xE8,0x88,0x1F,0xC5,0x7E,0xA0,0x46,0x79}; 1263 TokenRange()1264 TokenRange() : start_token(""), end_token("") { 1265 } 1266 ~TokenRange()1267 virtual ~TokenRange() throw() {} 1268 1269 std::string start_token; 1270 std::string end_token; 1271 std::vector<std::string> endpoints; 1272 std::vector<std::string> rpc_endpoints; 1273 std::vector<EndpointDetails> endpoint_details; 1274 1275 _TokenRange__isset __isset; 1276 __set_start_token(const std::string & val)1277 void __set_start_token(const std::string& val) { 1278 start_token = val; 1279 } 1280 __set_end_token(const std::string & val)1281 void __set_end_token(const std::string& val) { 1282 end_token = val; 1283 } 1284 __set_endpoints(const std::vector<std::string> & val)1285 void __set_endpoints(const std::vector<std::string> & val) { 1286 endpoints = val; 1287 } 1288 __set_rpc_endpoints(const std::vector<std::string> & val)1289 void __set_rpc_endpoints(const std::vector<std::string> & val) { 1290 rpc_endpoints = val; 1291 __isset.rpc_endpoints = true; 1292 } 1293 __set_endpoint_details(const std::vector<EndpointDetails> & val)1294 void __set_endpoint_details(const std::vector<EndpointDetails> & val) { 1295 endpoint_details = val; 1296 __isset.endpoint_details = true; 1297 } 1298 1299 bool operator == (const TokenRange & rhs) const 1300 { 1301 if (!(start_token == rhs.start_token)) 1302 return false; 1303 if (!(end_token == rhs.end_token)) 1304 return false; 1305 if (!(endpoints == rhs.endpoints)) 1306 return false; 1307 if (__isset.rpc_endpoints != rhs.__isset.rpc_endpoints) 1308 return false; 1309 else if (__isset.rpc_endpoints && !(rpc_endpoints == rhs.rpc_endpoints)) 1310 return false; 1311 if (__isset.endpoint_details != rhs.__isset.endpoint_details) 1312 return false; 1313 else if (__isset.endpoint_details && !(endpoint_details == rhs.endpoint_details)) 1314 return false; 1315 return true; 1316 } 1317 bool operator != (const TokenRange &rhs) const { 1318 return !(*this == rhs); 1319 } 1320 1321 bool operator < (const TokenRange & ) const; 1322 1323 uint32_t read(::apache::thrift::protocol::TProtocol* iprot); 1324 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; 1325 1326 }; 1327 1328 1329 class AuthenticationRequest { 1330 public: 1331 1332 static const char* ascii_fingerprint; // = "5EA2D527ECA3BA20C77AFC023EE8C05F"; 1333 static const uint8_t binary_fingerprint[16]; // = {0x5E,0xA2,0xD5,0x27,0xEC,0xA3,0xBA,0x20,0xC7,0x7A,0xFC,0x02,0x3E,0xE8,0xC0,0x5F}; 1334 AuthenticationRequest()1335 AuthenticationRequest() { 1336 } 1337 ~AuthenticationRequest()1338 virtual ~AuthenticationRequest() throw() {} 1339 1340 std::map<std::string, std::string> credentials; 1341 __set_credentials(const std::map<std::string,std::string> & val)1342 void __set_credentials(const std::map<std::string, std::string> & val) { 1343 credentials = val; 1344 } 1345 1346 bool operator == (const AuthenticationRequest & rhs) const 1347 { 1348 if (!(credentials == rhs.credentials)) 1349 return false; 1350 return true; 1351 } 1352 bool operator != (const AuthenticationRequest &rhs) const { 1353 return !(*this == rhs); 1354 } 1355 1356 bool operator < (const AuthenticationRequest & ) const; 1357 1358 uint32_t read(::apache::thrift::protocol::TProtocol* iprot); 1359 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; 1360 1361 }; 1362 1363 typedef struct _ColumnDef__isset { _ColumnDef__isset_ColumnDef__isset1364 _ColumnDef__isset() : index_type(false), index_name(false), index_options(false) {} 1365 bool index_type; 1366 bool index_name; 1367 bool index_options; 1368 } _ColumnDef__isset; 1369 1370 class ColumnDef { 1371 public: 1372 1373 static const char* ascii_fingerprint; // = "0D89CE83D7EDAD079AC3213ED1DCAA58"; 1374 static const uint8_t binary_fingerprint[16]; // = {0x0D,0x89,0xCE,0x83,0xD7,0xED,0xAD,0x07,0x9A,0xC3,0x21,0x3E,0xD1,0xDC,0xAA,0x58}; 1375 ColumnDef()1376 ColumnDef() : name(""), validation_class(""), index_type((IndexType::type)0), index_name("") { 1377 } 1378 ~ColumnDef()1379 virtual ~ColumnDef() throw() {} 1380 1381 std::string name; 1382 std::string validation_class; 1383 IndexType::type index_type; 1384 std::string index_name; 1385 std::map<std::string, std::string> index_options; 1386 1387 _ColumnDef__isset __isset; 1388 __set_name(const std::string & val)1389 void __set_name(const std::string& val) { 1390 name = val; 1391 } 1392 __set_validation_class(const std::string & val)1393 void __set_validation_class(const std::string& val) { 1394 validation_class = val; 1395 } 1396 __set_index_type(const IndexType::type val)1397 void __set_index_type(const IndexType::type val) { 1398 index_type = val; 1399 __isset.index_type = true; 1400 } 1401 __set_index_name(const std::string & val)1402 void __set_index_name(const std::string& val) { 1403 index_name = val; 1404 __isset.index_name = true; 1405 } 1406 __set_index_options(const std::map<std::string,std::string> & val)1407 void __set_index_options(const std::map<std::string, std::string> & val) { 1408 index_options = val; 1409 __isset.index_options = true; 1410 } 1411 1412 bool operator == (const ColumnDef & rhs) const 1413 { 1414 if (!(name == rhs.name)) 1415 return false; 1416 if (!(validation_class == rhs.validation_class)) 1417 return false; 1418 if (__isset.index_type != rhs.__isset.index_type) 1419 return false; 1420 else if (__isset.index_type && !(index_type == rhs.index_type)) 1421 return false; 1422 if (__isset.index_name != rhs.__isset.index_name) 1423 return false; 1424 else if (__isset.index_name && !(index_name == rhs.index_name)) 1425 return false; 1426 if (__isset.index_options != rhs.__isset.index_options) 1427 return false; 1428 else if (__isset.index_options && !(index_options == rhs.index_options)) 1429 return false; 1430 return true; 1431 } 1432 bool operator != (const ColumnDef &rhs) const { 1433 return !(*this == rhs); 1434 } 1435 1436 bool operator < (const ColumnDef & ) const; 1437 1438 uint32_t read(::apache::thrift::protocol::TProtocol* iprot); 1439 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; 1440 1441 }; 1442 1443 typedef struct _CfDef__isset { _CfDef__isset_CfDef__isset1444 _CfDef__isset() : column_type(false), comparator_type(false), subcomparator_type(false), comment(false), read_repair_chance(false), column_metadata(false), gc_grace_seconds(false), default_validation_class(false), id(false), min_compaction_threshold(false), max_compaction_threshold(false), replicate_on_write(false), key_validation_class(false), key_alias(false), compaction_strategy(false), compaction_strategy_options(false), compression_options(false), bloom_filter_fp_chance(false), caching(false), dclocal_read_repair_chance(false), row_cache_size(false), key_cache_size(false), row_cache_save_period_in_seconds(false), key_cache_save_period_in_seconds(false), memtable_flush_after_mins(false), memtable_throughput_in_mb(false), memtable_operations_in_millions(false), merge_shards_chance(false), row_cache_provider(false), row_cache_keys_to_save(false) {} 1445 bool column_type; 1446 bool comparator_type; 1447 bool subcomparator_type; 1448 bool comment; 1449 bool read_repair_chance; 1450 bool column_metadata; 1451 bool gc_grace_seconds; 1452 bool default_validation_class; 1453 bool id; 1454 bool min_compaction_threshold; 1455 bool max_compaction_threshold; 1456 bool replicate_on_write; 1457 bool key_validation_class; 1458 bool key_alias; 1459 bool compaction_strategy; 1460 bool compaction_strategy_options; 1461 bool compression_options; 1462 bool bloom_filter_fp_chance; 1463 bool caching; 1464 bool dclocal_read_repair_chance; 1465 bool row_cache_size; 1466 bool key_cache_size; 1467 bool row_cache_save_period_in_seconds; 1468 bool key_cache_save_period_in_seconds; 1469 bool memtable_flush_after_mins; 1470 bool memtable_throughput_in_mb; 1471 bool memtable_operations_in_millions; 1472 bool merge_shards_chance; 1473 bool row_cache_provider; 1474 bool row_cache_keys_to_save; 1475 } _CfDef__isset; 1476 1477 class CfDef { 1478 public: 1479 1480 static const char* ascii_fingerprint; // = "231A260521B5DD99EFBCCBDD8768CA7D"; 1481 static const uint8_t binary_fingerprint[16]; // = {0x23,0x1A,0x26,0x05,0x21,0xB5,0xDD,0x99,0xEF,0xBC,0xCB,0xDD,0x87,0x68,0xCA,0x7D}; 1482 CfDef()1483 CfDef() : keyspace(""), name(""), column_type("Standard"), comparator_type("BytesType"), subcomparator_type(""), comment(""), read_repair_chance(0), gc_grace_seconds(0), default_validation_class(""), id(0), min_compaction_threshold(0), max_compaction_threshold(0), replicate_on_write(0), key_validation_class(""), key_alias(""), compaction_strategy(""), bloom_filter_fp_chance(0), caching("keys_only"), dclocal_read_repair_chance(0), row_cache_size(0), key_cache_size(0), row_cache_save_period_in_seconds(0), key_cache_save_period_in_seconds(0), memtable_flush_after_mins(0), memtable_throughput_in_mb(0), memtable_operations_in_millions(0), merge_shards_chance(0), row_cache_provider(""), row_cache_keys_to_save(0) { 1484 } 1485 ~CfDef()1486 virtual ~CfDef() throw() {} 1487 1488 std::string keyspace; 1489 std::string name; 1490 std::string column_type; 1491 std::string comparator_type; 1492 std::string subcomparator_type; 1493 std::string comment; 1494 double read_repair_chance; 1495 std::vector<ColumnDef> column_metadata; 1496 int32_t gc_grace_seconds; 1497 std::string default_validation_class; 1498 int32_t id; 1499 int32_t min_compaction_threshold; 1500 int32_t max_compaction_threshold; 1501 bool replicate_on_write; 1502 std::string key_validation_class; 1503 std::string key_alias; 1504 std::string compaction_strategy; 1505 std::map<std::string, std::string> compaction_strategy_options; 1506 std::map<std::string, std::string> compression_options; 1507 double bloom_filter_fp_chance; 1508 std::string caching; 1509 double dclocal_read_repair_chance; 1510 double row_cache_size; 1511 double key_cache_size; 1512 int32_t row_cache_save_period_in_seconds; 1513 int32_t key_cache_save_period_in_seconds; 1514 int32_t memtable_flush_after_mins; 1515 int32_t memtable_throughput_in_mb; 1516 double memtable_operations_in_millions; 1517 double merge_shards_chance; 1518 std::string row_cache_provider; 1519 int32_t row_cache_keys_to_save; 1520 1521 _CfDef__isset __isset; 1522 __set_keyspace(const std::string & val)1523 void __set_keyspace(const std::string& val) { 1524 keyspace = val; 1525 } 1526 __set_name(const std::string & val)1527 void __set_name(const std::string& val) { 1528 name = val; 1529 } 1530 __set_column_type(const std::string & val)1531 void __set_column_type(const std::string& val) { 1532 column_type = val; 1533 __isset.column_type = true; 1534 } 1535 __set_comparator_type(const std::string & val)1536 void __set_comparator_type(const std::string& val) { 1537 comparator_type = val; 1538 __isset.comparator_type = true; 1539 } 1540 __set_subcomparator_type(const std::string & val)1541 void __set_subcomparator_type(const std::string& val) { 1542 subcomparator_type = val; 1543 __isset.subcomparator_type = true; 1544 } 1545 __set_comment(const std::string & val)1546 void __set_comment(const std::string& val) { 1547 comment = val; 1548 __isset.comment = true; 1549 } 1550 __set_read_repair_chance(const double val)1551 void __set_read_repair_chance(const double val) { 1552 read_repair_chance = val; 1553 __isset.read_repair_chance = true; 1554 } 1555 __set_column_metadata(const std::vector<ColumnDef> & val)1556 void __set_column_metadata(const std::vector<ColumnDef> & val) { 1557 column_metadata = val; 1558 __isset.column_metadata = true; 1559 } 1560 __set_gc_grace_seconds(const int32_t val)1561 void __set_gc_grace_seconds(const int32_t val) { 1562 gc_grace_seconds = val; 1563 __isset.gc_grace_seconds = true; 1564 } 1565 __set_default_validation_class(const std::string & val)1566 void __set_default_validation_class(const std::string& val) { 1567 default_validation_class = val; 1568 __isset.default_validation_class = true; 1569 } 1570 __set_id(const int32_t val)1571 void __set_id(const int32_t val) { 1572 id = val; 1573 __isset.id = true; 1574 } 1575 __set_min_compaction_threshold(const int32_t val)1576 void __set_min_compaction_threshold(const int32_t val) { 1577 min_compaction_threshold = val; 1578 __isset.min_compaction_threshold = true; 1579 } 1580 __set_max_compaction_threshold(const int32_t val)1581 void __set_max_compaction_threshold(const int32_t val) { 1582 max_compaction_threshold = val; 1583 __isset.max_compaction_threshold = true; 1584 } 1585 __set_replicate_on_write(const bool val)1586 void __set_replicate_on_write(const bool val) { 1587 replicate_on_write = val; 1588 __isset.replicate_on_write = true; 1589 } 1590 __set_key_validation_class(const std::string & val)1591 void __set_key_validation_class(const std::string& val) { 1592 key_validation_class = val; 1593 __isset.key_validation_class = true; 1594 } 1595 __set_key_alias(const std::string & val)1596 void __set_key_alias(const std::string& val) { 1597 key_alias = val; 1598 __isset.key_alias = true; 1599 } 1600 __set_compaction_strategy(const std::string & val)1601 void __set_compaction_strategy(const std::string& val) { 1602 compaction_strategy = val; 1603 __isset.compaction_strategy = true; 1604 } 1605 __set_compaction_strategy_options(const std::map<std::string,std::string> & val)1606 void __set_compaction_strategy_options(const std::map<std::string, std::string> & val) { 1607 compaction_strategy_options = val; 1608 __isset.compaction_strategy_options = true; 1609 } 1610 __set_compression_options(const std::map<std::string,std::string> & val)1611 void __set_compression_options(const std::map<std::string, std::string> & val) { 1612 compression_options = val; 1613 __isset.compression_options = true; 1614 } 1615 __set_bloom_filter_fp_chance(const double val)1616 void __set_bloom_filter_fp_chance(const double val) { 1617 bloom_filter_fp_chance = val; 1618 __isset.bloom_filter_fp_chance = true; 1619 } 1620 __set_caching(const std::string & val)1621 void __set_caching(const std::string& val) { 1622 caching = val; 1623 __isset.caching = true; 1624 } 1625 __set_dclocal_read_repair_chance(const double val)1626 void __set_dclocal_read_repair_chance(const double val) { 1627 dclocal_read_repair_chance = val; 1628 __isset.dclocal_read_repair_chance = true; 1629 } 1630 __set_row_cache_size(const double val)1631 void __set_row_cache_size(const double val) { 1632 row_cache_size = val; 1633 __isset.row_cache_size = true; 1634 } 1635 __set_key_cache_size(const double val)1636 void __set_key_cache_size(const double val) { 1637 key_cache_size = val; 1638 __isset.key_cache_size = true; 1639 } 1640 __set_row_cache_save_period_in_seconds(const int32_t val)1641 void __set_row_cache_save_period_in_seconds(const int32_t val) { 1642 row_cache_save_period_in_seconds = val; 1643 __isset.row_cache_save_period_in_seconds = true; 1644 } 1645 __set_key_cache_save_period_in_seconds(const int32_t val)1646 void __set_key_cache_save_period_in_seconds(const int32_t val) { 1647 key_cache_save_period_in_seconds = val; 1648 __isset.key_cache_save_period_in_seconds = true; 1649 } 1650 __set_memtable_flush_after_mins(const int32_t val)1651 void __set_memtable_flush_after_mins(const int32_t val) { 1652 memtable_flush_after_mins = val; 1653 __isset.memtable_flush_after_mins = true; 1654 } 1655 __set_memtable_throughput_in_mb(const int32_t val)1656 void __set_memtable_throughput_in_mb(const int32_t val) { 1657 memtable_throughput_in_mb = val; 1658 __isset.memtable_throughput_in_mb = true; 1659 } 1660 __set_memtable_operations_in_millions(const double val)1661 void __set_memtable_operations_in_millions(const double val) { 1662 memtable_operations_in_millions = val; 1663 __isset.memtable_operations_in_millions = true; 1664 } 1665 __set_merge_shards_chance(const double val)1666 void __set_merge_shards_chance(const double val) { 1667 merge_shards_chance = val; 1668 __isset.merge_shards_chance = true; 1669 } 1670 __set_row_cache_provider(const std::string & val)1671 void __set_row_cache_provider(const std::string& val) { 1672 row_cache_provider = val; 1673 __isset.row_cache_provider = true; 1674 } 1675 __set_row_cache_keys_to_save(const int32_t val)1676 void __set_row_cache_keys_to_save(const int32_t val) { 1677 row_cache_keys_to_save = val; 1678 __isset.row_cache_keys_to_save = true; 1679 } 1680 1681 bool operator == (const CfDef & rhs) const 1682 { 1683 if (!(keyspace == rhs.keyspace)) 1684 return false; 1685 if (!(name == rhs.name)) 1686 return false; 1687 if (__isset.column_type != rhs.__isset.column_type) 1688 return false; 1689 else if (__isset.column_type && !(column_type == rhs.column_type)) 1690 return false; 1691 if (__isset.comparator_type != rhs.__isset.comparator_type) 1692 return false; 1693 else if (__isset.comparator_type && !(comparator_type == rhs.comparator_type)) 1694 return false; 1695 if (__isset.subcomparator_type != rhs.__isset.subcomparator_type) 1696 return false; 1697 else if (__isset.subcomparator_type && !(subcomparator_type == rhs.subcomparator_type)) 1698 return false; 1699 if (__isset.comment != rhs.__isset.comment) 1700 return false; 1701 else if (__isset.comment && !(comment == rhs.comment)) 1702 return false; 1703 if (__isset.read_repair_chance != rhs.__isset.read_repair_chance) 1704 return false; 1705 else if (__isset.read_repair_chance && !(read_repair_chance == rhs.read_repair_chance)) 1706 return false; 1707 if (__isset.column_metadata != rhs.__isset.column_metadata) 1708 return false; 1709 else if (__isset.column_metadata && !(column_metadata == rhs.column_metadata)) 1710 return false; 1711 if (__isset.gc_grace_seconds != rhs.__isset.gc_grace_seconds) 1712 return false; 1713 else if (__isset.gc_grace_seconds && !(gc_grace_seconds == rhs.gc_grace_seconds)) 1714 return false; 1715 if (__isset.default_validation_class != rhs.__isset.default_validation_class) 1716 return false; 1717 else if (__isset.default_validation_class && !(default_validation_class == rhs.default_validation_class)) 1718 return false; 1719 if (__isset.id != rhs.__isset.id) 1720 return false; 1721 else if (__isset.id && !(id == rhs.id)) 1722 return false; 1723 if (__isset.min_compaction_threshold != rhs.__isset.min_compaction_threshold) 1724 return false; 1725 else if (__isset.min_compaction_threshold && !(min_compaction_threshold == rhs.min_compaction_threshold)) 1726 return false; 1727 if (__isset.max_compaction_threshold != rhs.__isset.max_compaction_threshold) 1728 return false; 1729 else if (__isset.max_compaction_threshold && !(max_compaction_threshold == rhs.max_compaction_threshold)) 1730 return false; 1731 if (__isset.replicate_on_write != rhs.__isset.replicate_on_write) 1732 return false; 1733 else if (__isset.replicate_on_write && !(replicate_on_write == rhs.replicate_on_write)) 1734 return false; 1735 if (__isset.key_validation_class != rhs.__isset.key_validation_class) 1736 return false; 1737 else if (__isset.key_validation_class && !(key_validation_class == rhs.key_validation_class)) 1738 return false; 1739 if (__isset.key_alias != rhs.__isset.key_alias) 1740 return false; 1741 else if (__isset.key_alias && !(key_alias == rhs.key_alias)) 1742 return false; 1743 if (__isset.compaction_strategy != rhs.__isset.compaction_strategy) 1744 return false; 1745 else if (__isset.compaction_strategy && !(compaction_strategy == rhs.compaction_strategy)) 1746 return false; 1747 if (__isset.compaction_strategy_options != rhs.__isset.compaction_strategy_options) 1748 return false; 1749 else if (__isset.compaction_strategy_options && !(compaction_strategy_options == rhs.compaction_strategy_options)) 1750 return false; 1751 if (__isset.compression_options != rhs.__isset.compression_options) 1752 return false; 1753 else if (__isset.compression_options && !(compression_options == rhs.compression_options)) 1754 return false; 1755 if (__isset.bloom_filter_fp_chance != rhs.__isset.bloom_filter_fp_chance) 1756 return false; 1757 else if (__isset.bloom_filter_fp_chance && !(bloom_filter_fp_chance == rhs.bloom_filter_fp_chance)) 1758 return false; 1759 if (__isset.caching != rhs.__isset.caching) 1760 return false; 1761 else if (__isset.caching && !(caching == rhs.caching)) 1762 return false; 1763 if (__isset.dclocal_read_repair_chance != rhs.__isset.dclocal_read_repair_chance) 1764 return false; 1765 else if (__isset.dclocal_read_repair_chance && !(dclocal_read_repair_chance == rhs.dclocal_read_repair_chance)) 1766 return false; 1767 if (__isset.row_cache_size != rhs.__isset.row_cache_size) 1768 return false; 1769 else if (__isset.row_cache_size && !(row_cache_size == rhs.row_cache_size)) 1770 return false; 1771 if (__isset.key_cache_size != rhs.__isset.key_cache_size) 1772 return false; 1773 else if (__isset.key_cache_size && !(key_cache_size == rhs.key_cache_size)) 1774 return false; 1775 if (__isset.row_cache_save_period_in_seconds != rhs.__isset.row_cache_save_period_in_seconds) 1776 return false; 1777 else if (__isset.row_cache_save_period_in_seconds && !(row_cache_save_period_in_seconds == rhs.row_cache_save_period_in_seconds)) 1778 return false; 1779 if (__isset.key_cache_save_period_in_seconds != rhs.__isset.key_cache_save_period_in_seconds) 1780 return false; 1781 else if (__isset.key_cache_save_period_in_seconds && !(key_cache_save_period_in_seconds == rhs.key_cache_save_period_in_seconds)) 1782 return false; 1783 if (__isset.memtable_flush_after_mins != rhs.__isset.memtable_flush_after_mins) 1784 return false; 1785 else if (__isset.memtable_flush_after_mins && !(memtable_flush_after_mins == rhs.memtable_flush_after_mins)) 1786 return false; 1787 if (__isset.memtable_throughput_in_mb != rhs.__isset.memtable_throughput_in_mb) 1788 return false; 1789 else if (__isset.memtable_throughput_in_mb && !(memtable_throughput_in_mb == rhs.memtable_throughput_in_mb)) 1790 return false; 1791 if (__isset.memtable_operations_in_millions != rhs.__isset.memtable_operations_in_millions) 1792 return false; 1793 else if (__isset.memtable_operations_in_millions && !(memtable_operations_in_millions == rhs.memtable_operations_in_millions)) 1794 return false; 1795 if (__isset.merge_shards_chance != rhs.__isset.merge_shards_chance) 1796 return false; 1797 else if (__isset.merge_shards_chance && !(merge_shards_chance == rhs.merge_shards_chance)) 1798 return false; 1799 if (__isset.row_cache_provider != rhs.__isset.row_cache_provider) 1800 return false; 1801 else if (__isset.row_cache_provider && !(row_cache_provider == rhs.row_cache_provider)) 1802 return false; 1803 if (__isset.row_cache_keys_to_save != rhs.__isset.row_cache_keys_to_save) 1804 return false; 1805 else if (__isset.row_cache_keys_to_save && !(row_cache_keys_to_save == rhs.row_cache_keys_to_save)) 1806 return false; 1807 return true; 1808 } 1809 bool operator != (const CfDef &rhs) const { 1810 return !(*this == rhs); 1811 } 1812 1813 bool operator < (const CfDef & ) const; 1814 1815 uint32_t read(::apache::thrift::protocol::TProtocol* iprot); 1816 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; 1817 1818 }; 1819 1820 typedef struct _KsDef__isset { _KsDef__isset_KsDef__isset1821 _KsDef__isset() : strategy_options(false), replication_factor(false), durable_writes(false) {} 1822 bool strategy_options; 1823 bool replication_factor; 1824 bool durable_writes; 1825 } _KsDef__isset; 1826 1827 class KsDef { 1828 public: 1829 1830 static const char* ascii_fingerprint; // = "0767851B6476EB3777A21E59E912E11A"; 1831 static const uint8_t binary_fingerprint[16]; // = {0x07,0x67,0x85,0x1B,0x64,0x76,0xEB,0x37,0x77,0xA2,0x1E,0x59,0xE9,0x12,0xE1,0x1A}; 1832 KsDef()1833 KsDef() : name(""), strategy_class(""), replication_factor(0), durable_writes(true) { 1834 } 1835 ~KsDef()1836 virtual ~KsDef() throw() {} 1837 1838 std::string name; 1839 std::string strategy_class; 1840 std::map<std::string, std::string> strategy_options; 1841 int32_t replication_factor; 1842 std::vector<CfDef> cf_defs; 1843 bool durable_writes; 1844 1845 _KsDef__isset __isset; 1846 __set_name(const std::string & val)1847 void __set_name(const std::string& val) { 1848 name = val; 1849 } 1850 __set_strategy_class(const std::string & val)1851 void __set_strategy_class(const std::string& val) { 1852 strategy_class = val; 1853 } 1854 __set_strategy_options(const std::map<std::string,std::string> & val)1855 void __set_strategy_options(const std::map<std::string, std::string> & val) { 1856 strategy_options = val; 1857 __isset.strategy_options = true; 1858 } 1859 __set_replication_factor(const int32_t val)1860 void __set_replication_factor(const int32_t val) { 1861 replication_factor = val; 1862 __isset.replication_factor = true; 1863 } 1864 __set_cf_defs(const std::vector<CfDef> & val)1865 void __set_cf_defs(const std::vector<CfDef> & val) { 1866 cf_defs = val; 1867 } 1868 __set_durable_writes(const bool val)1869 void __set_durable_writes(const bool val) { 1870 durable_writes = val; 1871 __isset.durable_writes = true; 1872 } 1873 1874 bool operator == (const KsDef & rhs) const 1875 { 1876 if (!(name == rhs.name)) 1877 return false; 1878 if (!(strategy_class == rhs.strategy_class)) 1879 return false; 1880 if (__isset.strategy_options != rhs.__isset.strategy_options) 1881 return false; 1882 else if (__isset.strategy_options && !(strategy_options == rhs.strategy_options)) 1883 return false; 1884 if (__isset.replication_factor != rhs.__isset.replication_factor) 1885 return false; 1886 else if (__isset.replication_factor && !(replication_factor == rhs.replication_factor)) 1887 return false; 1888 if (!(cf_defs == rhs.cf_defs)) 1889 return false; 1890 if (__isset.durable_writes != rhs.__isset.durable_writes) 1891 return false; 1892 else if (__isset.durable_writes && !(durable_writes == rhs.durable_writes)) 1893 return false; 1894 return true; 1895 } 1896 bool operator != (const KsDef &rhs) const { 1897 return !(*this == rhs); 1898 } 1899 1900 bool operator < (const KsDef & ) const; 1901 1902 uint32_t read(::apache::thrift::protocol::TProtocol* iprot); 1903 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; 1904 1905 }; 1906 1907 1908 class CqlRow { 1909 public: 1910 1911 static const char* ascii_fingerprint; // = "470EFC558004E98D92D604898305C04E"; 1912 static const uint8_t binary_fingerprint[16]; // = {0x47,0x0E,0xFC,0x55,0x80,0x04,0xE9,0x8D,0x92,0xD6,0x04,0x89,0x83,0x05,0xC0,0x4E}; 1913 CqlRow()1914 CqlRow() : key("") { 1915 } 1916 ~CqlRow()1917 virtual ~CqlRow() throw() {} 1918 1919 std::string key; 1920 std::vector<Column> columns; 1921 __set_key(const std::string & val)1922 void __set_key(const std::string& val) { 1923 key = val; 1924 } 1925 __set_columns(const std::vector<Column> & val)1926 void __set_columns(const std::vector<Column> & val) { 1927 columns = val; 1928 } 1929 1930 bool operator == (const CqlRow & rhs) const 1931 { 1932 if (!(key == rhs.key)) 1933 return false; 1934 if (!(columns == rhs.columns)) 1935 return false; 1936 return true; 1937 } 1938 bool operator != (const CqlRow &rhs) const { 1939 return !(*this == rhs); 1940 } 1941 1942 bool operator < (const CqlRow & ) const; 1943 1944 uint32_t read(::apache::thrift::protocol::TProtocol* iprot); 1945 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; 1946 1947 }; 1948 1949 1950 class CqlMetadata { 1951 public: 1952 1953 static const char* ascii_fingerprint; // = "B7C5A4AA9652C744A48EBC1C12D531E7"; 1954 static const uint8_t binary_fingerprint[16]; // = {0xB7,0xC5,0xA4,0xAA,0x96,0x52,0xC7,0x44,0xA4,0x8E,0xBC,0x1C,0x12,0xD5,0x31,0xE7}; 1955 CqlMetadata()1956 CqlMetadata() : default_name_type(""), default_value_type("") { 1957 } 1958 ~CqlMetadata()1959 virtual ~CqlMetadata() throw() {} 1960 1961 std::map<std::string, std::string> name_types; 1962 std::map<std::string, std::string> value_types; 1963 std::string default_name_type; 1964 std::string default_value_type; 1965 __set_name_types(const std::map<std::string,std::string> & val)1966 void __set_name_types(const std::map<std::string, std::string> & val) { 1967 name_types = val; 1968 } 1969 __set_value_types(const std::map<std::string,std::string> & val)1970 void __set_value_types(const std::map<std::string, std::string> & val) { 1971 value_types = val; 1972 } 1973 __set_default_name_type(const std::string & val)1974 void __set_default_name_type(const std::string& val) { 1975 default_name_type = val; 1976 } 1977 __set_default_value_type(const std::string & val)1978 void __set_default_value_type(const std::string& val) { 1979 default_value_type = val; 1980 } 1981 1982 bool operator == (const CqlMetadata & rhs) const 1983 { 1984 if (!(name_types == rhs.name_types)) 1985 return false; 1986 if (!(value_types == rhs.value_types)) 1987 return false; 1988 if (!(default_name_type == rhs.default_name_type)) 1989 return false; 1990 if (!(default_value_type == rhs.default_value_type)) 1991 return false; 1992 return true; 1993 } 1994 bool operator != (const CqlMetadata &rhs) const { 1995 return !(*this == rhs); 1996 } 1997 1998 bool operator < (const CqlMetadata & ) const; 1999 2000 uint32_t read(::apache::thrift::protocol::TProtocol* iprot); 2001 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; 2002 2003 }; 2004 2005 typedef struct _CqlResult__isset { _CqlResult__isset_CqlResult__isset2006 _CqlResult__isset() : rows(false), num(false), schema(false) {} 2007 bool rows; 2008 bool num; 2009 bool schema; 2010 } _CqlResult__isset; 2011 2012 class CqlResult { 2013 public: 2014 2015 static const char* ascii_fingerprint; // = "521B9CE5AF77539F7267F6952B609E81"; 2016 static const uint8_t binary_fingerprint[16]; // = {0x52,0x1B,0x9C,0xE5,0xAF,0x77,0x53,0x9F,0x72,0x67,0xF6,0x95,0x2B,0x60,0x9E,0x81}; 2017 CqlResult()2018 CqlResult() : type((CqlResultType::type)0), num(0) { 2019 } 2020 ~CqlResult()2021 virtual ~CqlResult() throw() {} 2022 2023 CqlResultType::type type; 2024 std::vector<CqlRow> rows; 2025 int32_t num; 2026 CqlMetadata schema; 2027 2028 _CqlResult__isset __isset; 2029 __set_type(const CqlResultType::type val)2030 void __set_type(const CqlResultType::type val) { 2031 type = val; 2032 } 2033 __set_rows(const std::vector<CqlRow> & val)2034 void __set_rows(const std::vector<CqlRow> & val) { 2035 rows = val; 2036 __isset.rows = true; 2037 } 2038 __set_num(const int32_t val)2039 void __set_num(const int32_t val) { 2040 num = val; 2041 __isset.num = true; 2042 } 2043 __set_schema(const CqlMetadata & val)2044 void __set_schema(const CqlMetadata& val) { 2045 schema = val; 2046 __isset.schema = true; 2047 } 2048 2049 bool operator == (const CqlResult & rhs) const 2050 { 2051 if (!(type == rhs.type)) 2052 return false; 2053 if (__isset.rows != rhs.__isset.rows) 2054 return false; 2055 else if (__isset.rows && !(rows == rhs.rows)) 2056 return false; 2057 if (__isset.num != rhs.__isset.num) 2058 return false; 2059 else if (__isset.num && !(num == rhs.num)) 2060 return false; 2061 if (__isset.schema != rhs.__isset.schema) 2062 return false; 2063 else if (__isset.schema && !(schema == rhs.schema)) 2064 return false; 2065 return true; 2066 } 2067 bool operator != (const CqlResult &rhs) const { 2068 return !(*this == rhs); 2069 } 2070 2071 bool operator < (const CqlResult & ) const; 2072 2073 uint32_t read(::apache::thrift::protocol::TProtocol* iprot); 2074 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; 2075 2076 }; 2077 2078 typedef struct _CqlPreparedResult__isset { _CqlPreparedResult__isset_CqlPreparedResult__isset2079 _CqlPreparedResult__isset() : variable_types(false), variable_names(false) {} 2080 bool variable_types; 2081 bool variable_names; 2082 } _CqlPreparedResult__isset; 2083 2084 class CqlPreparedResult { 2085 public: 2086 2087 static const char* ascii_fingerprint; // = "7E1663EC688DFDC28722BF36F9F64E6F"; 2088 static const uint8_t binary_fingerprint[16]; // = {0x7E,0x16,0x63,0xEC,0x68,0x8D,0xFD,0xC2,0x87,0x22,0xBF,0x36,0xF9,0xF6,0x4E,0x6F}; 2089 CqlPreparedResult()2090 CqlPreparedResult() : itemId(0), count(0) { 2091 } 2092 ~CqlPreparedResult()2093 virtual ~CqlPreparedResult() throw() {} 2094 2095 int32_t itemId; 2096 int32_t count; 2097 std::vector<std::string> variable_types; 2098 std::vector<std::string> variable_names; 2099 2100 _CqlPreparedResult__isset __isset; 2101 __set_itemId(const int32_t val)2102 void __set_itemId(const int32_t val) { 2103 itemId = val; 2104 } 2105 __set_count(const int32_t val)2106 void __set_count(const int32_t val) { 2107 count = val; 2108 } 2109 __set_variable_types(const std::vector<std::string> & val)2110 void __set_variable_types(const std::vector<std::string> & val) { 2111 variable_types = val; 2112 __isset.variable_types = true; 2113 } 2114 __set_variable_names(const std::vector<std::string> & val)2115 void __set_variable_names(const std::vector<std::string> & val) { 2116 variable_names = val; 2117 __isset.variable_names = true; 2118 } 2119 2120 bool operator == (const CqlPreparedResult & rhs) const 2121 { 2122 if (!(itemId == rhs.itemId)) 2123 return false; 2124 if (!(count == rhs.count)) 2125 return false; 2126 if (__isset.variable_types != rhs.__isset.variable_types) 2127 return false; 2128 else if (__isset.variable_types && !(variable_types == rhs.variable_types)) 2129 return false; 2130 if (__isset.variable_names != rhs.__isset.variable_names) 2131 return false; 2132 else if (__isset.variable_names && !(variable_names == rhs.variable_names)) 2133 return false; 2134 return true; 2135 } 2136 bool operator != (const CqlPreparedResult &rhs) const { 2137 return !(*this == rhs); 2138 } 2139 2140 bool operator < (const CqlPreparedResult & ) const; 2141 2142 uint32_t read(::apache::thrift::protocol::TProtocol* iprot); 2143 uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const; 2144 2145 }; 2146 2147 }}} // namespace 2148 2149 #endif 2150