1# 2# Autogenerated by Thrift 3# 4# DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING 5# 6require 5.6.0; 7use strict; 8use warnings; 9use Net::GenThrift::Thrift; 10 11package Net::GenCassandra::ConsistencyLevel; 12use constant ZERO => 0; 13use constant ONE => 1; 14use constant QUORUM => 2; 15use constant DCQUORUM => 3; 16use constant DCQUORUMSYNC => 4; 17use constant ALL => 5; 18use constant ANY => 6; 19package Net::GenCassandra::AccessLevel; 20use constant NONE => 0; 21use constant READONLY => 16; 22use constant READWRITE => 32; 23use constant FULL => 64; 24package Net::GenCassandra::Column; 25use base qw(Class::Accessor); 26Net::GenCassandra::Column->mk_accessors( qw( name value timestamp ttl ) ); 27 28sub new { 29 my $classname = shift; 30 my $self = {}; 31 my $vals = shift || {}; 32 $self->{name} = undef; 33 $self->{value} = undef; 34 $self->{timestamp} = undef; 35 $self->{ttl} = undef; 36 if (UNIVERSAL::isa($vals,'HASH')) { 37 if (defined $vals->{name}) { 38 $self->{name} = $vals->{name}; 39 } 40 if (defined $vals->{value}) { 41 $self->{value} = $vals->{value}; 42 } 43 if (defined $vals->{timestamp}) { 44 $self->{timestamp} = $vals->{timestamp}; 45 } 46 if (defined $vals->{ttl}) { 47 $self->{ttl} = $vals->{ttl}; 48 } 49 } 50 return bless ($self, $classname); 51} 52 53sub getName { 54 return 'Column'; 55} 56 57sub read { 58 my ($self, $input) = @_; 59 my $xfer = 0; 60 my $fname; 61 my $ftype = 0; 62 my $fid = 0; 63 $xfer += $input->readStructBegin(\$fname); 64 while (1) 65 { 66 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid); 67 if ($ftype == TType::STOP) { 68 last; 69 } 70 SWITCH: for($fid) 71 { 72 /^1$/ && do{ if ($ftype == TType::STRING) { 73 $xfer += $input->readString(\$self->{name}); 74 } else { 75 $xfer += $input->skip($ftype); 76 } 77 last; }; 78 /^2$/ && do{ if ($ftype == TType::STRING) { 79 $xfer += $input->readString(\$self->{value}); 80 } else { 81 $xfer += $input->skip($ftype); 82 } 83 last; }; 84 /^3$/ && do{ if ($ftype == TType::I64) { 85 $xfer += $input->readI64(\$self->{timestamp}); 86 } else { 87 $xfer += $input->skip($ftype); 88 } 89 last; }; 90 /^4$/ && do{ if ($ftype == TType::I32) { 91 $xfer += $input->readI32(\$self->{ttl}); 92 } else { 93 $xfer += $input->skip($ftype); 94 } 95 last; }; 96 $xfer += $input->skip($ftype); 97 } 98 $xfer += $input->readFieldEnd(); 99 } 100 $xfer += $input->readStructEnd(); 101 return $xfer; 102} 103 104sub write { 105 my ($self, $output) = @_; 106 my $xfer = 0; 107 $xfer += $output->writeStructBegin('Column'); 108 if (defined $self->{name}) { 109 $xfer += $output->writeFieldBegin('name', TType::STRING, 1); 110 $xfer += $output->writeString($self->{name}); 111 $xfer += $output->writeFieldEnd(); 112 } 113 if (defined $self->{value}) { 114 $xfer += $output->writeFieldBegin('value', TType::STRING, 2); 115 $xfer += $output->writeString($self->{value}); 116 $xfer += $output->writeFieldEnd(); 117 } 118 if (defined $self->{timestamp}) { 119 $xfer += $output->writeFieldBegin('timestamp', TType::I64, 3); 120 $xfer += $output->writeI64($self->{timestamp}); 121 $xfer += $output->writeFieldEnd(); 122 } 123 if (defined $self->{ttl}) { 124 $xfer += $output->writeFieldBegin('ttl', TType::I32, 4); 125 $xfer += $output->writeI32($self->{ttl}); 126 $xfer += $output->writeFieldEnd(); 127 } 128 $xfer += $output->writeFieldStop(); 129 $xfer += $output->writeStructEnd(); 130 return $xfer; 131} 132 133package Net::GenCassandra::SuperColumn; 134use base qw(Class::Accessor); 135Net::GenCassandra::SuperColumn->mk_accessors( qw( name columns ) ); 136 137sub new { 138 my $classname = shift; 139 my $self = {}; 140 my $vals = shift || {}; 141 $self->{name} = undef; 142 $self->{columns} = undef; 143 if (UNIVERSAL::isa($vals,'HASH')) { 144 if (defined $vals->{name}) { 145 $self->{name} = $vals->{name}; 146 } 147 if (defined $vals->{columns}) { 148 $self->{columns} = $vals->{columns}; 149 } 150 } 151 return bless ($self, $classname); 152} 153 154sub getName { 155 return 'SuperColumn'; 156} 157 158sub read { 159 my ($self, $input) = @_; 160 my $xfer = 0; 161 my $fname; 162 my $ftype = 0; 163 my $fid = 0; 164 $xfer += $input->readStructBegin(\$fname); 165 while (1) 166 { 167 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid); 168 if ($ftype == TType::STOP) { 169 last; 170 } 171 SWITCH: for($fid) 172 { 173 /^1$/ && do{ if ($ftype == TType::STRING) { 174 $xfer += $input->readString(\$self->{name}); 175 } else { 176 $xfer += $input->skip($ftype); 177 } 178 last; }; 179 /^2$/ && do{ if ($ftype == TType::LIST) { 180 { 181 my $_size0 = 0; 182 $self->{columns} = []; 183 my $_etype3 = 0; 184 $xfer += $input->readListBegin(\$_etype3, \$_size0); 185 for (my $_i4 = 0; $_i4 < $_size0; ++$_i4) 186 { 187 my $elem5 = undef; 188 $elem5 = new Net::GenCassandra::Column(); 189 $xfer += $elem5->read($input); 190 push(@{$self->{columns}},$elem5); 191 } 192 $xfer += $input->readListEnd(); 193 } 194 } else { 195 $xfer += $input->skip($ftype); 196 } 197 last; }; 198 $xfer += $input->skip($ftype); 199 } 200 $xfer += $input->readFieldEnd(); 201 } 202 $xfer += $input->readStructEnd(); 203 return $xfer; 204} 205 206sub write { 207 my ($self, $output) = @_; 208 my $xfer = 0; 209 $xfer += $output->writeStructBegin('SuperColumn'); 210 if (defined $self->{name}) { 211 $xfer += $output->writeFieldBegin('name', TType::STRING, 1); 212 $xfer += $output->writeString($self->{name}); 213 $xfer += $output->writeFieldEnd(); 214 } 215 if (defined $self->{columns}) { 216 $xfer += $output->writeFieldBegin('columns', TType::LIST, 2); 217 { 218 $output->writeListBegin(TType::STRUCT, scalar(@{$self->{columns}})); 219 { 220 foreach my $iter6 (@{$self->{columns}}) 221 { 222 $xfer += ${iter6}->write($output); 223 } 224 } 225 $output->writeListEnd(); 226 } 227 $xfer += $output->writeFieldEnd(); 228 } 229 $xfer += $output->writeFieldStop(); 230 $xfer += $output->writeStructEnd(); 231 return $xfer; 232} 233 234package Net::GenCassandra::ColumnOrSuperColumn; 235use base qw(Class::Accessor); 236Net::GenCassandra::ColumnOrSuperColumn->mk_accessors( qw( column super_column ) ); 237 238sub new { 239 my $classname = shift; 240 my $self = {}; 241 my $vals = shift || {}; 242 $self->{column} = undef; 243 $self->{super_column} = undef; 244 if (UNIVERSAL::isa($vals,'HASH')) { 245 if (defined $vals->{column}) { 246 $self->{column} = $vals->{column}; 247 } 248 if (defined $vals->{super_column}) { 249 $self->{super_column} = $vals->{super_column}; 250 } 251 } 252 return bless ($self, $classname); 253} 254 255sub getName { 256 return 'ColumnOrSuperColumn'; 257} 258 259sub read { 260 my ($self, $input) = @_; 261 my $xfer = 0; 262 my $fname; 263 my $ftype = 0; 264 my $fid = 0; 265 $xfer += $input->readStructBegin(\$fname); 266 while (1) 267 { 268 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid); 269 if ($ftype == TType::STOP) { 270 last; 271 } 272 SWITCH: for($fid) 273 { 274 /^1$/ && do{ if ($ftype == TType::STRUCT) { 275 $self->{column} = new Net::GenCassandra::Column(); 276 $xfer += $self->{column}->read($input); 277 } else { 278 $xfer += $input->skip($ftype); 279 } 280 last; }; 281 /^2$/ && do{ if ($ftype == TType::STRUCT) { 282 $self->{super_column} = new Net::GenCassandra::SuperColumn(); 283 $xfer += $self->{super_column}->read($input); 284 } else { 285 $xfer += $input->skip($ftype); 286 } 287 last; }; 288 $xfer += $input->skip($ftype); 289 } 290 $xfer += $input->readFieldEnd(); 291 } 292 $xfer += $input->readStructEnd(); 293 return $xfer; 294} 295 296sub write { 297 my ($self, $output) = @_; 298 my $xfer = 0; 299 $xfer += $output->writeStructBegin('ColumnOrSuperColumn'); 300 if (defined $self->{column}) { 301 $xfer += $output->writeFieldBegin('column', TType::STRUCT, 1); 302 $xfer += $self->{column}->write($output); 303 $xfer += $output->writeFieldEnd(); 304 } 305 if (defined $self->{super_column}) { 306 $xfer += $output->writeFieldBegin('super_column', TType::STRUCT, 2); 307 $xfer += $self->{super_column}->write($output); 308 $xfer += $output->writeFieldEnd(); 309 } 310 $xfer += $output->writeFieldStop(); 311 $xfer += $output->writeStructEnd(); 312 return $xfer; 313} 314 315package Net::GenCassandra::NotFoundException; 316use base qw(Net::GenThrift::Thrift::TException); 317use base qw(Class::Accessor); 318 319sub new { 320 my $classname = shift; 321 my $self = {}; 322 my $vals = shift || {}; 323 return bless ($self, $classname); 324} 325 326sub getName { 327 return 'NotFoundException'; 328} 329 330sub read { 331 my ($self, $input) = @_; 332 my $xfer = 0; 333 my $fname; 334 my $ftype = 0; 335 my $fid = 0; 336 $xfer += $input->readStructBegin(\$fname); 337 while (1) 338 { 339 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid); 340 if ($ftype == TType::STOP) { 341 last; 342 } 343 SWITCH: for($fid) 344 { 345 $xfer += $input->skip($ftype); 346 } 347 $xfer += $input->readFieldEnd(); 348 } 349 $xfer += $input->readStructEnd(); 350 return $xfer; 351} 352 353sub write { 354 my ($self, $output) = @_; 355 my $xfer = 0; 356 $xfer += $output->writeStructBegin('NotFoundException'); 357 $xfer += $output->writeFieldStop(); 358 $xfer += $output->writeStructEnd(); 359 return $xfer; 360} 361 362package Net::GenCassandra::InvalidRequestException; 363use base qw(Net::GenThrift::Thrift::TException); 364use base qw(Class::Accessor); 365Net::GenCassandra::InvalidRequestException->mk_accessors( qw( why ) ); 366 367sub new { 368 my $classname = shift; 369 my $self = {}; 370 my $vals = shift || {}; 371 $self->{why} = undef; 372 if (UNIVERSAL::isa($vals,'HASH')) { 373 if (defined $vals->{why}) { 374 $self->{why} = $vals->{why}; 375 } 376 } 377 return bless ($self, $classname); 378} 379 380sub getName { 381 return 'InvalidRequestException'; 382} 383 384sub read { 385 my ($self, $input) = @_; 386 my $xfer = 0; 387 my $fname; 388 my $ftype = 0; 389 my $fid = 0; 390 $xfer += $input->readStructBegin(\$fname); 391 while (1) 392 { 393 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid); 394 if ($ftype == TType::STOP) { 395 last; 396 } 397 SWITCH: for($fid) 398 { 399 /^1$/ && do{ if ($ftype == TType::STRING) { 400 $xfer += $input->readString(\$self->{why}); 401 } else { 402 $xfer += $input->skip($ftype); 403 } 404 last; }; 405 $xfer += $input->skip($ftype); 406 } 407 $xfer += $input->readFieldEnd(); 408 } 409 $xfer += $input->readStructEnd(); 410 return $xfer; 411} 412 413sub write { 414 my ($self, $output) = @_; 415 my $xfer = 0; 416 $xfer += $output->writeStructBegin('InvalidRequestException'); 417 if (defined $self->{why}) { 418 $xfer += $output->writeFieldBegin('why', TType::STRING, 1); 419 $xfer += $output->writeString($self->{why}); 420 $xfer += $output->writeFieldEnd(); 421 } 422 $xfer += $output->writeFieldStop(); 423 $xfer += $output->writeStructEnd(); 424 return $xfer; 425} 426 427package Net::GenCassandra::UnavailableException; 428use base qw(Net::GenThrift::Thrift::TException); 429use base qw(Class::Accessor); 430 431sub new { 432 my $classname = shift; 433 my $self = {}; 434 my $vals = shift || {}; 435 return bless ($self, $classname); 436} 437 438sub getName { 439 return 'UnavailableException'; 440} 441 442sub read { 443 my ($self, $input) = @_; 444 my $xfer = 0; 445 my $fname; 446 my $ftype = 0; 447 my $fid = 0; 448 $xfer += $input->readStructBegin(\$fname); 449 while (1) 450 { 451 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid); 452 if ($ftype == TType::STOP) { 453 last; 454 } 455 SWITCH: for($fid) 456 { 457 $xfer += $input->skip($ftype); 458 } 459 $xfer += $input->readFieldEnd(); 460 } 461 $xfer += $input->readStructEnd(); 462 return $xfer; 463} 464 465sub write { 466 my ($self, $output) = @_; 467 my $xfer = 0; 468 $xfer += $output->writeStructBegin('UnavailableException'); 469 $xfer += $output->writeFieldStop(); 470 $xfer += $output->writeStructEnd(); 471 return $xfer; 472} 473 474package Net::GenCassandra::TimedOutException; 475use base qw(Net::GenThrift::Thrift::TException); 476use base qw(Class::Accessor); 477 478sub new { 479 my $classname = shift; 480 my $self = {}; 481 my $vals = shift || {}; 482 return bless ($self, $classname); 483} 484 485sub getName { 486 return 'TimedOutException'; 487} 488 489sub read { 490 my ($self, $input) = @_; 491 my $xfer = 0; 492 my $fname; 493 my $ftype = 0; 494 my $fid = 0; 495 $xfer += $input->readStructBegin(\$fname); 496 while (1) 497 { 498 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid); 499 if ($ftype == TType::STOP) { 500 last; 501 } 502 SWITCH: for($fid) 503 { 504 $xfer += $input->skip($ftype); 505 } 506 $xfer += $input->readFieldEnd(); 507 } 508 $xfer += $input->readStructEnd(); 509 return $xfer; 510} 511 512sub write { 513 my ($self, $output) = @_; 514 my $xfer = 0; 515 $xfer += $output->writeStructBegin('TimedOutException'); 516 $xfer += $output->writeFieldStop(); 517 $xfer += $output->writeStructEnd(); 518 return $xfer; 519} 520 521package Net::GenCassandra::AuthenticationException; 522use base qw(Net::GenThrift::Thrift::TException); 523use base qw(Class::Accessor); 524Net::GenCassandra::AuthenticationException->mk_accessors( qw( why ) ); 525 526sub new { 527 my $classname = shift; 528 my $self = {}; 529 my $vals = shift || {}; 530 $self->{why} = undef; 531 if (UNIVERSAL::isa($vals,'HASH')) { 532 if (defined $vals->{why}) { 533 $self->{why} = $vals->{why}; 534 } 535 } 536 return bless ($self, $classname); 537} 538 539sub getName { 540 return 'AuthenticationException'; 541} 542 543sub read { 544 my ($self, $input) = @_; 545 my $xfer = 0; 546 my $fname; 547 my $ftype = 0; 548 my $fid = 0; 549 $xfer += $input->readStructBegin(\$fname); 550 while (1) 551 { 552 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid); 553 if ($ftype == TType::STOP) { 554 last; 555 } 556 SWITCH: for($fid) 557 { 558 /^1$/ && do{ if ($ftype == TType::STRING) { 559 $xfer += $input->readString(\$self->{why}); 560 } else { 561 $xfer += $input->skip($ftype); 562 } 563 last; }; 564 $xfer += $input->skip($ftype); 565 } 566 $xfer += $input->readFieldEnd(); 567 } 568 $xfer += $input->readStructEnd(); 569 return $xfer; 570} 571 572sub write { 573 my ($self, $output) = @_; 574 my $xfer = 0; 575 $xfer += $output->writeStructBegin('AuthenticationException'); 576 if (defined $self->{why}) { 577 $xfer += $output->writeFieldBegin('why', TType::STRING, 1); 578 $xfer += $output->writeString($self->{why}); 579 $xfer += $output->writeFieldEnd(); 580 } 581 $xfer += $output->writeFieldStop(); 582 $xfer += $output->writeStructEnd(); 583 return $xfer; 584} 585 586package Net::GenCassandra::AuthorizationException; 587use base qw(Net::GenThrift::Thrift::TException); 588use base qw(Class::Accessor); 589Net::GenCassandra::AuthorizationException->mk_accessors( qw( why ) ); 590 591sub new { 592 my $classname = shift; 593 my $self = {}; 594 my $vals = shift || {}; 595 $self->{why} = undef; 596 if (UNIVERSAL::isa($vals,'HASH')) { 597 if (defined $vals->{why}) { 598 $self->{why} = $vals->{why}; 599 } 600 } 601 return bless ($self, $classname); 602} 603 604sub getName { 605 return 'AuthorizationException'; 606} 607 608sub read { 609 my ($self, $input) = @_; 610 my $xfer = 0; 611 my $fname; 612 my $ftype = 0; 613 my $fid = 0; 614 $xfer += $input->readStructBegin(\$fname); 615 while (1) 616 { 617 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid); 618 if ($ftype == TType::STOP) { 619 last; 620 } 621 SWITCH: for($fid) 622 { 623 /^1$/ && do{ if ($ftype == TType::STRING) { 624 $xfer += $input->readString(\$self->{why}); 625 } else { 626 $xfer += $input->skip($ftype); 627 } 628 last; }; 629 $xfer += $input->skip($ftype); 630 } 631 $xfer += $input->readFieldEnd(); 632 } 633 $xfer += $input->readStructEnd(); 634 return $xfer; 635} 636 637sub write { 638 my ($self, $output) = @_; 639 my $xfer = 0; 640 $xfer += $output->writeStructBegin('AuthorizationException'); 641 if (defined $self->{why}) { 642 $xfer += $output->writeFieldBegin('why', TType::STRING, 1); 643 $xfer += $output->writeString($self->{why}); 644 $xfer += $output->writeFieldEnd(); 645 } 646 $xfer += $output->writeFieldStop(); 647 $xfer += $output->writeStructEnd(); 648 return $xfer; 649} 650 651package Net::GenCassandra::ColumnParent; 652use base qw(Class::Accessor); 653Net::GenCassandra::ColumnParent->mk_accessors( qw( column_family super_column ) ); 654 655sub new { 656 my $classname = shift; 657 my $self = {}; 658 my $vals = shift || {}; 659 $self->{column_family} = undef; 660 $self->{super_column} = undef; 661 if (UNIVERSAL::isa($vals,'HASH')) { 662 if (defined $vals->{column_family}) { 663 $self->{column_family} = $vals->{column_family}; 664 } 665 if (defined $vals->{super_column}) { 666 $self->{super_column} = $vals->{super_column}; 667 } 668 } 669 return bless ($self, $classname); 670} 671 672sub getName { 673 return 'ColumnParent'; 674} 675 676sub read { 677 my ($self, $input) = @_; 678 my $xfer = 0; 679 my $fname; 680 my $ftype = 0; 681 my $fid = 0; 682 $xfer += $input->readStructBegin(\$fname); 683 while (1) 684 { 685 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid); 686 if ($ftype == TType::STOP) { 687 last; 688 } 689 SWITCH: for($fid) 690 { 691 /^3$/ && do{ if ($ftype == TType::STRING) { 692 $xfer += $input->readString(\$self->{column_family}); 693 } else { 694 $xfer += $input->skip($ftype); 695 } 696 last; }; 697 /^4$/ && do{ if ($ftype == TType::STRING) { 698 $xfer += $input->readString(\$self->{super_column}); 699 } else { 700 $xfer += $input->skip($ftype); 701 } 702 last; }; 703 $xfer += $input->skip($ftype); 704 } 705 $xfer += $input->readFieldEnd(); 706 } 707 $xfer += $input->readStructEnd(); 708 return $xfer; 709} 710 711sub write { 712 my ($self, $output) = @_; 713 my $xfer = 0; 714 $xfer += $output->writeStructBegin('ColumnParent'); 715 if (defined $self->{column_family}) { 716 $xfer += $output->writeFieldBegin('column_family', TType::STRING, 3); 717 $xfer += $output->writeString($self->{column_family}); 718 $xfer += $output->writeFieldEnd(); 719 } 720 if (defined $self->{super_column}) { 721 $xfer += $output->writeFieldBegin('super_column', TType::STRING, 4); 722 $xfer += $output->writeString($self->{super_column}); 723 $xfer += $output->writeFieldEnd(); 724 } 725 $xfer += $output->writeFieldStop(); 726 $xfer += $output->writeStructEnd(); 727 return $xfer; 728} 729 730package Net::GenCassandra::ColumnPath; 731use base qw(Class::Accessor); 732Net::GenCassandra::ColumnPath->mk_accessors( qw( column_family super_column column ) ); 733 734sub new { 735 my $classname = shift; 736 my $self = {}; 737 my $vals = shift || {}; 738 $self->{column_family} = undef; 739 $self->{super_column} = undef; 740 $self->{column} = undef; 741 if (UNIVERSAL::isa($vals,'HASH')) { 742 if (defined $vals->{column_family}) { 743 $self->{column_family} = $vals->{column_family}; 744 } 745 if (defined $vals->{super_column}) { 746 $self->{super_column} = $vals->{super_column}; 747 } 748 if (defined $vals->{column}) { 749 $self->{column} = $vals->{column}; 750 } 751 } 752 return bless ($self, $classname); 753} 754 755sub getName { 756 return 'ColumnPath'; 757} 758 759sub read { 760 my ($self, $input) = @_; 761 my $xfer = 0; 762 my $fname; 763 my $ftype = 0; 764 my $fid = 0; 765 $xfer += $input->readStructBegin(\$fname); 766 while (1) 767 { 768 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid); 769 if ($ftype == TType::STOP) { 770 last; 771 } 772 SWITCH: for($fid) 773 { 774 /^3$/ && do{ if ($ftype == TType::STRING) { 775 $xfer += $input->readString(\$self->{column_family}); 776 } else { 777 $xfer += $input->skip($ftype); 778 } 779 last; }; 780 /^4$/ && do{ if ($ftype == TType::STRING) { 781 $xfer += $input->readString(\$self->{super_column}); 782 } else { 783 $xfer += $input->skip($ftype); 784 } 785 last; }; 786 /^5$/ && do{ if ($ftype == TType::STRING) { 787 $xfer += $input->readString(\$self->{column}); 788 } else { 789 $xfer += $input->skip($ftype); 790 } 791 last; }; 792 $xfer += $input->skip($ftype); 793 } 794 $xfer += $input->readFieldEnd(); 795 } 796 $xfer += $input->readStructEnd(); 797 return $xfer; 798} 799 800sub write { 801 my ($self, $output) = @_; 802 my $xfer = 0; 803 $xfer += $output->writeStructBegin('ColumnPath'); 804 if (defined $self->{column_family}) { 805 $xfer += $output->writeFieldBegin('column_family', TType::STRING, 3); 806 $xfer += $output->writeString($self->{column_family}); 807 $xfer += $output->writeFieldEnd(); 808 } 809 if (defined $self->{super_column}) { 810 $xfer += $output->writeFieldBegin('super_column', TType::STRING, 4); 811 $xfer += $output->writeString($self->{super_column}); 812 $xfer += $output->writeFieldEnd(); 813 } 814 if (defined $self->{column}) { 815 $xfer += $output->writeFieldBegin('column', TType::STRING, 5); 816 $xfer += $output->writeString($self->{column}); 817 $xfer += $output->writeFieldEnd(); 818 } 819 $xfer += $output->writeFieldStop(); 820 $xfer += $output->writeStructEnd(); 821 return $xfer; 822} 823 824package Net::GenCassandra::SliceRange; 825use base qw(Class::Accessor); 826Net::GenCassandra::SliceRange->mk_accessors( qw( start finish reversed count bitmasks ) ); 827 828sub new { 829 my $classname = shift; 830 my $self = {}; 831 my $vals = shift || {}; 832 $self->{start} = undef; 833 $self->{finish} = undef; 834 $self->{reversed} = 0; 835 $self->{count} = 100; 836 $self->{bitmasks} = undef; 837 if (UNIVERSAL::isa($vals,'HASH')) { 838 if (defined $vals->{start}) { 839 $self->{start} = $vals->{start}; 840 } 841 if (defined $vals->{finish}) { 842 $self->{finish} = $vals->{finish}; 843 } 844 if (defined $vals->{reversed}) { 845 $self->{reversed} = $vals->{reversed}; 846 } 847 if (defined $vals->{count}) { 848 $self->{count} = $vals->{count}; 849 } 850 if (defined $vals->{bitmasks}) { 851 $self->{bitmasks} = $vals->{bitmasks}; 852 } 853 } 854 return bless ($self, $classname); 855} 856 857sub getName { 858 return 'SliceRange'; 859} 860 861sub read { 862 my ($self, $input) = @_; 863 my $xfer = 0; 864 my $fname; 865 my $ftype = 0; 866 my $fid = 0; 867 $xfer += $input->readStructBegin(\$fname); 868 while (1) 869 { 870 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid); 871 if ($ftype == TType::STOP) { 872 last; 873 } 874 SWITCH: for($fid) 875 { 876 /^1$/ && do{ if ($ftype == TType::STRING) { 877 $xfer += $input->readString(\$self->{start}); 878 } else { 879 $xfer += $input->skip($ftype); 880 } 881 last; }; 882 /^2$/ && do{ if ($ftype == TType::STRING) { 883 $xfer += $input->readString(\$self->{finish}); 884 } else { 885 $xfer += $input->skip($ftype); 886 } 887 last; }; 888 /^3$/ && do{ if ($ftype == TType::BOOL) { 889 $xfer += $input->readBool(\$self->{reversed}); 890 } else { 891 $xfer += $input->skip($ftype); 892 } 893 last; }; 894 /^4$/ && do{ if ($ftype == TType::I32) { 895 $xfer += $input->readI32(\$self->{count}); 896 } else { 897 $xfer += $input->skip($ftype); 898 } 899 last; }; 900 /^5$/ && do{ if ($ftype == TType::LIST) { 901 { 902 my $_size7 = 0; 903 $self->{bitmasks} = []; 904 my $_etype10 = 0; 905 $xfer += $input->readListBegin(\$_etype10, \$_size7); 906 for (my $_i11 = 0; $_i11 < $_size7; ++$_i11) 907 { 908 my $elem12 = undef; 909 $xfer += $input->readString(\$elem12); 910 push(@{$self->{bitmasks}},$elem12); 911 } 912 $xfer += $input->readListEnd(); 913 } 914 } else { 915 $xfer += $input->skip($ftype); 916 } 917 last; }; 918 $xfer += $input->skip($ftype); 919 } 920 $xfer += $input->readFieldEnd(); 921 } 922 $xfer += $input->readStructEnd(); 923 return $xfer; 924} 925 926sub write { 927 my ($self, $output) = @_; 928 my $xfer = 0; 929 $xfer += $output->writeStructBegin('SliceRange'); 930 if (defined $self->{start}) { 931 $xfer += $output->writeFieldBegin('start', TType::STRING, 1); 932 $xfer += $output->writeString($self->{start}); 933 $xfer += $output->writeFieldEnd(); 934 } 935 if (defined $self->{finish}) { 936 $xfer += $output->writeFieldBegin('finish', TType::STRING, 2); 937 $xfer += $output->writeString($self->{finish}); 938 $xfer += $output->writeFieldEnd(); 939 } 940 if (defined $self->{reversed}) { 941 $xfer += $output->writeFieldBegin('reversed', TType::BOOL, 3); 942 $xfer += $output->writeBool($self->{reversed}); 943 $xfer += $output->writeFieldEnd(); 944 } 945 if (defined $self->{count}) { 946 $xfer += $output->writeFieldBegin('count', TType::I32, 4); 947 $xfer += $output->writeI32($self->{count}); 948 $xfer += $output->writeFieldEnd(); 949 } 950 if (defined $self->{bitmasks}) { 951 $xfer += $output->writeFieldBegin('bitmasks', TType::LIST, 5); 952 { 953 $output->writeListBegin(TType::STRING, scalar(@{$self->{bitmasks}})); 954 { 955 foreach my $iter13 (@{$self->{bitmasks}}) 956 { 957 $xfer += $output->writeString($iter13); 958 } 959 } 960 $output->writeListEnd(); 961 } 962 $xfer += $output->writeFieldEnd(); 963 } 964 $xfer += $output->writeFieldStop(); 965 $xfer += $output->writeStructEnd(); 966 return $xfer; 967} 968 969package Net::GenCassandra::SlicePredicate; 970use base qw(Class::Accessor); 971Net::GenCassandra::SlicePredicate->mk_accessors( qw( column_names slice_range ) ); 972 973sub new { 974 my $classname = shift; 975 my $self = {}; 976 my $vals = shift || {}; 977 $self->{column_names} = undef; 978 $self->{slice_range} = undef; 979 if (UNIVERSAL::isa($vals,'HASH')) { 980 if (defined $vals->{column_names}) { 981 $self->{column_names} = $vals->{column_names}; 982 } 983 if (defined $vals->{slice_range}) { 984 $self->{slice_range} = $vals->{slice_range}; 985 } 986 } 987 return bless ($self, $classname); 988} 989 990sub getName { 991 return 'SlicePredicate'; 992} 993 994sub read { 995 my ($self, $input) = @_; 996 my $xfer = 0; 997 my $fname; 998 my $ftype = 0; 999 my $fid = 0; 1000 $xfer += $input->readStructBegin(\$fname); 1001 while (1) 1002 { 1003 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid); 1004 if ($ftype == TType::STOP) { 1005 last; 1006 } 1007 SWITCH: for($fid) 1008 { 1009 /^1$/ && do{ if ($ftype == TType::LIST) { 1010 { 1011 my $_size14 = 0; 1012 $self->{column_names} = []; 1013 my $_etype17 = 0; 1014 $xfer += $input->readListBegin(\$_etype17, \$_size14); 1015 for (my $_i18 = 0; $_i18 < $_size14; ++$_i18) 1016 { 1017 my $elem19 = undef; 1018 $xfer += $input->readString(\$elem19); 1019 push(@{$self->{column_names}},$elem19); 1020 } 1021 $xfer += $input->readListEnd(); 1022 } 1023 } else { 1024 $xfer += $input->skip($ftype); 1025 } 1026 last; }; 1027 /^2$/ && do{ if ($ftype == TType::STRUCT) { 1028 $self->{slice_range} = new Net::GenCassandra::SliceRange(); 1029 $xfer += $self->{slice_range}->read($input); 1030 } else { 1031 $xfer += $input->skip($ftype); 1032 } 1033 last; }; 1034 $xfer += $input->skip($ftype); 1035 } 1036 $xfer += $input->readFieldEnd(); 1037 } 1038 $xfer += $input->readStructEnd(); 1039 return $xfer; 1040} 1041 1042sub write { 1043 my ($self, $output) = @_; 1044 my $xfer = 0; 1045 $xfer += $output->writeStructBegin('SlicePredicate'); 1046 if (defined $self->{column_names}) { 1047 $xfer += $output->writeFieldBegin('column_names', TType::LIST, 1); 1048 { 1049 $output->writeListBegin(TType::STRING, scalar(@{$self->{column_names}})); 1050 { 1051 foreach my $iter20 (@{$self->{column_names}}) 1052 { 1053 $xfer += $output->writeString($iter20); 1054 } 1055 } 1056 $output->writeListEnd(); 1057 } 1058 $xfer += $output->writeFieldEnd(); 1059 } 1060 if (defined $self->{slice_range}) { 1061 $xfer += $output->writeFieldBegin('slice_range', TType::STRUCT, 2); 1062 $xfer += $self->{slice_range}->write($output); 1063 $xfer += $output->writeFieldEnd(); 1064 } 1065 $xfer += $output->writeFieldStop(); 1066 $xfer += $output->writeStructEnd(); 1067 return $xfer; 1068} 1069 1070package Net::GenCassandra::KeyRange; 1071use base qw(Class::Accessor); 1072Net::GenCassandra::KeyRange->mk_accessors( qw( start_key end_key start_token end_token count ) ); 1073 1074sub new { 1075 my $classname = shift; 1076 my $self = {}; 1077 my $vals = shift || {}; 1078 $self->{start_key} = undef; 1079 $self->{end_key} = undef; 1080 $self->{start_token} = undef; 1081 $self->{end_token} = undef; 1082 $self->{count} = 100; 1083 if (UNIVERSAL::isa($vals,'HASH')) { 1084 if (defined $vals->{start_key}) { 1085 $self->{start_key} = $vals->{start_key}; 1086 } 1087 if (defined $vals->{end_key}) { 1088 $self->{end_key} = $vals->{end_key}; 1089 } 1090 if (defined $vals->{start_token}) { 1091 $self->{start_token} = $vals->{start_token}; 1092 } 1093 if (defined $vals->{end_token}) { 1094 $self->{end_token} = $vals->{end_token}; 1095 } 1096 if (defined $vals->{count}) { 1097 $self->{count} = $vals->{count}; 1098 } 1099 } 1100 return bless ($self, $classname); 1101} 1102 1103sub getName { 1104 return 'KeyRange'; 1105} 1106 1107sub read { 1108 my ($self, $input) = @_; 1109 my $xfer = 0; 1110 my $fname; 1111 my $ftype = 0; 1112 my $fid = 0; 1113 $xfer += $input->readStructBegin(\$fname); 1114 while (1) 1115 { 1116 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid); 1117 if ($ftype == TType::STOP) { 1118 last; 1119 } 1120 SWITCH: for($fid) 1121 { 1122 /^1$/ && do{ if ($ftype == TType::STRING) { 1123 $xfer += $input->readString(\$self->{start_key}); 1124 } else { 1125 $xfer += $input->skip($ftype); 1126 } 1127 last; }; 1128 /^2$/ && do{ if ($ftype == TType::STRING) { 1129 $xfer += $input->readString(\$self->{end_key}); 1130 } else { 1131 $xfer += $input->skip($ftype); 1132 } 1133 last; }; 1134 /^3$/ && do{ if ($ftype == TType::STRING) { 1135 $xfer += $input->readString(\$self->{start_token}); 1136 } else { 1137 $xfer += $input->skip($ftype); 1138 } 1139 last; }; 1140 /^4$/ && do{ if ($ftype == TType::STRING) { 1141 $xfer += $input->readString(\$self->{end_token}); 1142 } else { 1143 $xfer += $input->skip($ftype); 1144 } 1145 last; }; 1146 /^5$/ && do{ if ($ftype == TType::I32) { 1147 $xfer += $input->readI32(\$self->{count}); 1148 } else { 1149 $xfer += $input->skip($ftype); 1150 } 1151 last; }; 1152 $xfer += $input->skip($ftype); 1153 } 1154 $xfer += $input->readFieldEnd(); 1155 } 1156 $xfer += $input->readStructEnd(); 1157 return $xfer; 1158} 1159 1160sub write { 1161 my ($self, $output) = @_; 1162 my $xfer = 0; 1163 $xfer += $output->writeStructBegin('KeyRange'); 1164 if (defined $self->{start_key}) { 1165 $xfer += $output->writeFieldBegin('start_key', TType::STRING, 1); 1166 $xfer += $output->writeString($self->{start_key}); 1167 $xfer += $output->writeFieldEnd(); 1168 } 1169 if (defined $self->{end_key}) { 1170 $xfer += $output->writeFieldBegin('end_key', TType::STRING, 2); 1171 $xfer += $output->writeString($self->{end_key}); 1172 $xfer += $output->writeFieldEnd(); 1173 } 1174 if (defined $self->{start_token}) { 1175 $xfer += $output->writeFieldBegin('start_token', TType::STRING, 3); 1176 $xfer += $output->writeString($self->{start_token}); 1177 $xfer += $output->writeFieldEnd(); 1178 } 1179 if (defined $self->{end_token}) { 1180 $xfer += $output->writeFieldBegin('end_token', TType::STRING, 4); 1181 $xfer += $output->writeString($self->{end_token}); 1182 $xfer += $output->writeFieldEnd(); 1183 } 1184 if (defined $self->{count}) { 1185 $xfer += $output->writeFieldBegin('count', TType::I32, 5); 1186 $xfer += $output->writeI32($self->{count}); 1187 $xfer += $output->writeFieldEnd(); 1188 } 1189 $xfer += $output->writeFieldStop(); 1190 $xfer += $output->writeStructEnd(); 1191 return $xfer; 1192} 1193 1194package Net::GenCassandra::KeySlice; 1195use base qw(Class::Accessor); 1196Net::GenCassandra::KeySlice->mk_accessors( qw( key columns ) ); 1197 1198sub new { 1199 my $classname = shift; 1200 my $self = {}; 1201 my $vals = shift || {}; 1202 $self->{key} = undef; 1203 $self->{columns} = undef; 1204 if (UNIVERSAL::isa($vals,'HASH')) { 1205 if (defined $vals->{key}) { 1206 $self->{key} = $vals->{key}; 1207 } 1208 if (defined $vals->{columns}) { 1209 $self->{columns} = $vals->{columns}; 1210 } 1211 } 1212 return bless ($self, $classname); 1213} 1214 1215sub getName { 1216 return 'KeySlice'; 1217} 1218 1219sub read { 1220 my ($self, $input) = @_; 1221 my $xfer = 0; 1222 my $fname; 1223 my $ftype = 0; 1224 my $fid = 0; 1225 $xfer += $input->readStructBegin(\$fname); 1226 while (1) 1227 { 1228 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid); 1229 if ($ftype == TType::STOP) { 1230 last; 1231 } 1232 SWITCH: for($fid) 1233 { 1234 /^1$/ && do{ if ($ftype == TType::STRING) { 1235 $xfer += $input->readString(\$self->{key}); 1236 } else { 1237 $xfer += $input->skip($ftype); 1238 } 1239 last; }; 1240 /^2$/ && do{ if ($ftype == TType::LIST) { 1241 { 1242 my $_size21 = 0; 1243 $self->{columns} = []; 1244 my $_etype24 = 0; 1245 $xfer += $input->readListBegin(\$_etype24, \$_size21); 1246 for (my $_i25 = 0; $_i25 < $_size21; ++$_i25) 1247 { 1248 my $elem26 = undef; 1249 $elem26 = new Net::GenCassandra::ColumnOrSuperColumn(); 1250 $xfer += $elem26->read($input); 1251 push(@{$self->{columns}},$elem26); 1252 } 1253 $xfer += $input->readListEnd(); 1254 } 1255 } else { 1256 $xfer += $input->skip($ftype); 1257 } 1258 last; }; 1259 $xfer += $input->skip($ftype); 1260 } 1261 $xfer += $input->readFieldEnd(); 1262 } 1263 $xfer += $input->readStructEnd(); 1264 return $xfer; 1265} 1266 1267sub write { 1268 my ($self, $output) = @_; 1269 my $xfer = 0; 1270 $xfer += $output->writeStructBegin('KeySlice'); 1271 if (defined $self->{key}) { 1272 $xfer += $output->writeFieldBegin('key', TType::STRING, 1); 1273 $xfer += $output->writeString($self->{key}); 1274 $xfer += $output->writeFieldEnd(); 1275 } 1276 if (defined $self->{columns}) { 1277 $xfer += $output->writeFieldBegin('columns', TType::LIST, 2); 1278 { 1279 $output->writeListBegin(TType::STRUCT, scalar(@{$self->{columns}})); 1280 { 1281 foreach my $iter27 (@{$self->{columns}}) 1282 { 1283 $xfer += ${iter27}->write($output); 1284 } 1285 } 1286 $output->writeListEnd(); 1287 } 1288 $xfer += $output->writeFieldEnd(); 1289 } 1290 $xfer += $output->writeFieldStop(); 1291 $xfer += $output->writeStructEnd(); 1292 return $xfer; 1293} 1294 1295package Net::GenCassandra::Deletion; 1296use base qw(Class::Accessor); 1297Net::GenCassandra::Deletion->mk_accessors( qw( timestamp super_column predicate ) ); 1298 1299sub new { 1300 my $classname = shift; 1301 my $self = {}; 1302 my $vals = shift || {}; 1303 $self->{timestamp} = undef; 1304 $self->{super_column} = undef; 1305 $self->{predicate} = undef; 1306 if (UNIVERSAL::isa($vals,'HASH')) { 1307 if (defined $vals->{timestamp}) { 1308 $self->{timestamp} = $vals->{timestamp}; 1309 } 1310 if (defined $vals->{super_column}) { 1311 $self->{super_column} = $vals->{super_column}; 1312 } 1313 if (defined $vals->{predicate}) { 1314 $self->{predicate} = $vals->{predicate}; 1315 } 1316 } 1317 return bless ($self, $classname); 1318} 1319 1320sub getName { 1321 return 'Deletion'; 1322} 1323 1324sub read { 1325 my ($self, $input) = @_; 1326 my $xfer = 0; 1327 my $fname; 1328 my $ftype = 0; 1329 my $fid = 0; 1330 $xfer += $input->readStructBegin(\$fname); 1331 while (1) 1332 { 1333 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid); 1334 if ($ftype == TType::STOP) { 1335 last; 1336 } 1337 SWITCH: for($fid) 1338 { 1339 /^1$/ && do{ if ($ftype == TType::I64) { 1340 $xfer += $input->readI64(\$self->{timestamp}); 1341 } else { 1342 $xfer += $input->skip($ftype); 1343 } 1344 last; }; 1345 /^2$/ && do{ if ($ftype == TType::STRING) { 1346 $xfer += $input->readString(\$self->{super_column}); 1347 } else { 1348 $xfer += $input->skip($ftype); 1349 } 1350 last; }; 1351 /^3$/ && do{ if ($ftype == TType::STRUCT) { 1352 $self->{predicate} = new Net::GenCassandra::SlicePredicate(); 1353 $xfer += $self->{predicate}->read($input); 1354 } else { 1355 $xfer += $input->skip($ftype); 1356 } 1357 last; }; 1358 $xfer += $input->skip($ftype); 1359 } 1360 $xfer += $input->readFieldEnd(); 1361 } 1362 $xfer += $input->readStructEnd(); 1363 return $xfer; 1364} 1365 1366sub write { 1367 my ($self, $output) = @_; 1368 my $xfer = 0; 1369 $xfer += $output->writeStructBegin('Deletion'); 1370 if (defined $self->{timestamp}) { 1371 $xfer += $output->writeFieldBegin('timestamp', TType::I64, 1); 1372 $xfer += $output->writeI64($self->{timestamp}); 1373 $xfer += $output->writeFieldEnd(); 1374 } 1375 if (defined $self->{super_column}) { 1376 $xfer += $output->writeFieldBegin('super_column', TType::STRING, 2); 1377 $xfer += $output->writeString($self->{super_column}); 1378 $xfer += $output->writeFieldEnd(); 1379 } 1380 if (defined $self->{predicate}) { 1381 $xfer += $output->writeFieldBegin('predicate', TType::STRUCT, 3); 1382 $xfer += $self->{predicate}->write($output); 1383 $xfer += $output->writeFieldEnd(); 1384 } 1385 $xfer += $output->writeFieldStop(); 1386 $xfer += $output->writeStructEnd(); 1387 return $xfer; 1388} 1389 1390package Net::GenCassandra::Mutation; 1391use base qw(Class::Accessor); 1392Net::GenCassandra::Mutation->mk_accessors( qw( column_or_supercolumn deletion ) ); 1393 1394sub new { 1395 my $classname = shift; 1396 my $self = {}; 1397 my $vals = shift || {}; 1398 $self->{column_or_supercolumn} = undef; 1399 $self->{deletion} = undef; 1400 if (UNIVERSAL::isa($vals,'HASH')) { 1401 if (defined $vals->{column_or_supercolumn}) { 1402 $self->{column_or_supercolumn} = $vals->{column_or_supercolumn}; 1403 } 1404 if (defined $vals->{deletion}) { 1405 $self->{deletion} = $vals->{deletion}; 1406 } 1407 } 1408 return bless ($self, $classname); 1409} 1410 1411sub getName { 1412 return 'Mutation'; 1413} 1414 1415sub read { 1416 my ($self, $input) = @_; 1417 my $xfer = 0; 1418 my $fname; 1419 my $ftype = 0; 1420 my $fid = 0; 1421 $xfer += $input->readStructBegin(\$fname); 1422 while (1) 1423 { 1424 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid); 1425 if ($ftype == TType::STOP) { 1426 last; 1427 } 1428 SWITCH: for($fid) 1429 { 1430 /^1$/ && do{ if ($ftype == TType::STRUCT) { 1431 $self->{column_or_supercolumn} = new Net::GenCassandra::ColumnOrSuperColumn(); 1432 $xfer += $self->{column_or_supercolumn}->read($input); 1433 } else { 1434 $xfer += $input->skip($ftype); 1435 } 1436 last; }; 1437 /^2$/ && do{ if ($ftype == TType::STRUCT) { 1438 $self->{deletion} = new Net::GenCassandra::Deletion(); 1439 $xfer += $self->{deletion}->read($input); 1440 } else { 1441 $xfer += $input->skip($ftype); 1442 } 1443 last; }; 1444 $xfer += $input->skip($ftype); 1445 } 1446 $xfer += $input->readFieldEnd(); 1447 } 1448 $xfer += $input->readStructEnd(); 1449 return $xfer; 1450} 1451 1452sub write { 1453 my ($self, $output) = @_; 1454 my $xfer = 0; 1455 $xfer += $output->writeStructBegin('Mutation'); 1456 if (defined $self->{column_or_supercolumn}) { 1457 $xfer += $output->writeFieldBegin('column_or_supercolumn', TType::STRUCT, 1); 1458 $xfer += $self->{column_or_supercolumn}->write($output); 1459 $xfer += $output->writeFieldEnd(); 1460 } 1461 if (defined $self->{deletion}) { 1462 $xfer += $output->writeFieldBegin('deletion', TType::STRUCT, 2); 1463 $xfer += $self->{deletion}->write($output); 1464 $xfer += $output->writeFieldEnd(); 1465 } 1466 $xfer += $output->writeFieldStop(); 1467 $xfer += $output->writeStructEnd(); 1468 return $xfer; 1469} 1470 1471package Net::GenCassandra::TokenRange; 1472use base qw(Class::Accessor); 1473Net::GenCassandra::TokenRange->mk_accessors( qw( start_token end_token endpoints ) ); 1474 1475sub new { 1476 my $classname = shift; 1477 my $self = {}; 1478 my $vals = shift || {}; 1479 $self->{start_token} = undef; 1480 $self->{end_token} = undef; 1481 $self->{endpoints} = undef; 1482 if (UNIVERSAL::isa($vals,'HASH')) { 1483 if (defined $vals->{start_token}) { 1484 $self->{start_token} = $vals->{start_token}; 1485 } 1486 if (defined $vals->{end_token}) { 1487 $self->{end_token} = $vals->{end_token}; 1488 } 1489 if (defined $vals->{endpoints}) { 1490 $self->{endpoints} = $vals->{endpoints}; 1491 } 1492 } 1493 return bless ($self, $classname); 1494} 1495 1496sub getName { 1497 return 'TokenRange'; 1498} 1499 1500sub read { 1501 my ($self, $input) = @_; 1502 my $xfer = 0; 1503 my $fname; 1504 my $ftype = 0; 1505 my $fid = 0; 1506 $xfer += $input->readStructBegin(\$fname); 1507 while (1) 1508 { 1509 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid); 1510 if ($ftype == TType::STOP) { 1511 last; 1512 } 1513 SWITCH: for($fid) 1514 { 1515 /^1$/ && do{ if ($ftype == TType::STRING) { 1516 $xfer += $input->readString(\$self->{start_token}); 1517 } else { 1518 $xfer += $input->skip($ftype); 1519 } 1520 last; }; 1521 /^2$/ && do{ if ($ftype == TType::STRING) { 1522 $xfer += $input->readString(\$self->{end_token}); 1523 } else { 1524 $xfer += $input->skip($ftype); 1525 } 1526 last; }; 1527 /^3$/ && do{ if ($ftype == TType::LIST) { 1528 { 1529 my $_size28 = 0; 1530 $self->{endpoints} = []; 1531 my $_etype31 = 0; 1532 $xfer += $input->readListBegin(\$_etype31, \$_size28); 1533 for (my $_i32 = 0; $_i32 < $_size28; ++$_i32) 1534 { 1535 my $elem33 = undef; 1536 $xfer += $input->readString(\$elem33); 1537 push(@{$self->{endpoints}},$elem33); 1538 } 1539 $xfer += $input->readListEnd(); 1540 } 1541 } else { 1542 $xfer += $input->skip($ftype); 1543 } 1544 last; }; 1545 $xfer += $input->skip($ftype); 1546 } 1547 $xfer += $input->readFieldEnd(); 1548 } 1549 $xfer += $input->readStructEnd(); 1550 return $xfer; 1551} 1552 1553sub write { 1554 my ($self, $output) = @_; 1555 my $xfer = 0; 1556 $xfer += $output->writeStructBegin('TokenRange'); 1557 if (defined $self->{start_token}) { 1558 $xfer += $output->writeFieldBegin('start_token', TType::STRING, 1); 1559 $xfer += $output->writeString($self->{start_token}); 1560 $xfer += $output->writeFieldEnd(); 1561 } 1562 if (defined $self->{end_token}) { 1563 $xfer += $output->writeFieldBegin('end_token', TType::STRING, 2); 1564 $xfer += $output->writeString($self->{end_token}); 1565 $xfer += $output->writeFieldEnd(); 1566 } 1567 if (defined $self->{endpoints}) { 1568 $xfer += $output->writeFieldBegin('endpoints', TType::LIST, 3); 1569 { 1570 $output->writeListBegin(TType::STRING, scalar(@{$self->{endpoints}})); 1571 { 1572 foreach my $iter34 (@{$self->{endpoints}}) 1573 { 1574 $xfer += $output->writeString($iter34); 1575 } 1576 } 1577 $output->writeListEnd(); 1578 } 1579 $xfer += $output->writeFieldEnd(); 1580 } 1581 $xfer += $output->writeFieldStop(); 1582 $xfer += $output->writeStructEnd(); 1583 return $xfer; 1584} 1585 1586package Net::GenCassandra::AuthenticationRequest; 1587use base qw(Class::Accessor); 1588Net::GenCassandra::AuthenticationRequest->mk_accessors( qw( credentials ) ); 1589 1590sub new { 1591 my $classname = shift; 1592 my $self = {}; 1593 my $vals = shift || {}; 1594 $self->{credentials} = undef; 1595 if (UNIVERSAL::isa($vals,'HASH')) { 1596 if (defined $vals->{credentials}) { 1597 $self->{credentials} = $vals->{credentials}; 1598 } 1599 } 1600 return bless ($self, $classname); 1601} 1602 1603sub getName { 1604 return 'AuthenticationRequest'; 1605} 1606 1607sub read { 1608 my ($self, $input) = @_; 1609 my $xfer = 0; 1610 my $fname; 1611 my $ftype = 0; 1612 my $fid = 0; 1613 $xfer += $input->readStructBegin(\$fname); 1614 while (1) 1615 { 1616 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid); 1617 if ($ftype == TType::STOP) { 1618 last; 1619 } 1620 SWITCH: for($fid) 1621 { 1622 /^1$/ && do{ if ($ftype == TType::MAP) { 1623 { 1624 my $_size35 = 0; 1625 $self->{credentials} = {}; 1626 my $_ktype36 = 0; 1627 my $_vtype37 = 0; 1628 $xfer += $input->readMapBegin(\$_ktype36, \$_vtype37, \$_size35); 1629 for (my $_i39 = 0; $_i39 < $_size35; ++$_i39) 1630 { 1631 my $key40 = ''; 1632 my $val41 = ''; 1633 $xfer += $input->readString(\$key40); 1634 $xfer += $input->readString(\$val41); 1635 $self->{credentials}->{$key40} = $val41; 1636 } 1637 $xfer += $input->readMapEnd(); 1638 } 1639 } else { 1640 $xfer += $input->skip($ftype); 1641 } 1642 last; }; 1643 $xfer += $input->skip($ftype); 1644 } 1645 $xfer += $input->readFieldEnd(); 1646 } 1647 $xfer += $input->readStructEnd(); 1648 return $xfer; 1649} 1650 1651sub write { 1652 my ($self, $output) = @_; 1653 my $xfer = 0; 1654 $xfer += $output->writeStructBegin('AuthenticationRequest'); 1655 if (defined $self->{credentials}) { 1656 $xfer += $output->writeFieldBegin('credentials', TType::MAP, 1); 1657 { 1658 $output->writeMapBegin(TType::STRING, TType::STRING, scalar(keys %{$self->{credentials}})); 1659 { 1660 while( my ($kiter42,$viter43) = each %{$self->{credentials}}) 1661 { 1662 $xfer += $output->writeString($kiter42); 1663 $xfer += $output->writeString($viter43); 1664 } 1665 } 1666 $output->writeMapEnd(); 1667 } 1668 $xfer += $output->writeFieldEnd(); 1669 } 1670 $xfer += $output->writeFieldStop(); 1671 $xfer += $output->writeStructEnd(); 1672 return $xfer; 1673} 1674 1675package Net::GenCassandra::CfDef; 1676use base qw(Class::Accessor); 1677Net::GenCassandra::CfDef->mk_accessors( qw( table name column_type comparator_type subcomparator_type comment row_cache_size preload_row_cache key_cache_size ) ); 1678 1679sub new { 1680 my $classname = shift; 1681 my $self = {}; 1682 my $vals = shift || {}; 1683 $self->{table} = undef; 1684 $self->{name} = undef; 1685 $self->{column_type} = "Standard"; 1686 $self->{comparator_type} = "BytesType"; 1687 $self->{subcomparator_type} = ""; 1688 $self->{comment} = ""; 1689 $self->{row_cache_size} = 0; 1690 $self->{preload_row_cache} = 0; 1691 $self->{key_cache_size} = 200000; 1692 if (UNIVERSAL::isa($vals,'HASH')) { 1693 if (defined $vals->{table}) { 1694 $self->{table} = $vals->{table}; 1695 } 1696 if (defined $vals->{name}) { 1697 $self->{name} = $vals->{name}; 1698 } 1699 if (defined $vals->{column_type}) { 1700 $self->{column_type} = $vals->{column_type}; 1701 } 1702 if (defined $vals->{comparator_type}) { 1703 $self->{comparator_type} = $vals->{comparator_type}; 1704 } 1705 if (defined $vals->{subcomparator_type}) { 1706 $self->{subcomparator_type} = $vals->{subcomparator_type}; 1707 } 1708 if (defined $vals->{comment}) { 1709 $self->{comment} = $vals->{comment}; 1710 } 1711 if (defined $vals->{row_cache_size}) { 1712 $self->{row_cache_size} = $vals->{row_cache_size}; 1713 } 1714 if (defined $vals->{preload_row_cache}) { 1715 $self->{preload_row_cache} = $vals->{preload_row_cache}; 1716 } 1717 if (defined $vals->{key_cache_size}) { 1718 $self->{key_cache_size} = $vals->{key_cache_size}; 1719 } 1720 } 1721 return bless ($self, $classname); 1722} 1723 1724sub getName { 1725 return 'CfDef'; 1726} 1727 1728sub read { 1729 my ($self, $input) = @_; 1730 my $xfer = 0; 1731 my $fname; 1732 my $ftype = 0; 1733 my $fid = 0; 1734 $xfer += $input->readStructBegin(\$fname); 1735 while (1) 1736 { 1737 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid); 1738 if ($ftype == TType::STOP) { 1739 last; 1740 } 1741 SWITCH: for($fid) 1742 { 1743 /^1$/ && do{ if ($ftype == TType::STRING) { 1744 $xfer += $input->readString(\$self->{table}); 1745 } else { 1746 $xfer += $input->skip($ftype); 1747 } 1748 last; }; 1749 /^2$/ && do{ if ($ftype == TType::STRING) { 1750 $xfer += $input->readString(\$self->{name}); 1751 } else { 1752 $xfer += $input->skip($ftype); 1753 } 1754 last; }; 1755 /^3$/ && do{ if ($ftype == TType::STRING) { 1756 $xfer += $input->readString(\$self->{column_type}); 1757 } else { 1758 $xfer += $input->skip($ftype); 1759 } 1760 last; }; 1761 /^4$/ && do{ if ($ftype == TType::STRING) { 1762 $xfer += $input->readString(\$self->{comparator_type}); 1763 } else { 1764 $xfer += $input->skip($ftype); 1765 } 1766 last; }; 1767 /^5$/ && do{ if ($ftype == TType::STRING) { 1768 $xfer += $input->readString(\$self->{subcomparator_type}); 1769 } else { 1770 $xfer += $input->skip($ftype); 1771 } 1772 last; }; 1773 /^6$/ && do{ if ($ftype == TType::STRING) { 1774 $xfer += $input->readString(\$self->{comment}); 1775 } else { 1776 $xfer += $input->skip($ftype); 1777 } 1778 last; }; 1779 /^7$/ && do{ if ($ftype == TType::DOUBLE) { 1780 $xfer += $input->readDouble(\$self->{row_cache_size}); 1781 } else { 1782 $xfer += $input->skip($ftype); 1783 } 1784 last; }; 1785 /^8$/ && do{ if ($ftype == TType::BOOL) { 1786 $xfer += $input->readBool(\$self->{preload_row_cache}); 1787 } else { 1788 $xfer += $input->skip($ftype); 1789 } 1790 last; }; 1791 /^9$/ && do{ if ($ftype == TType::DOUBLE) { 1792 $xfer += $input->readDouble(\$self->{key_cache_size}); 1793 } else { 1794 $xfer += $input->skip($ftype); 1795 } 1796 last; }; 1797 $xfer += $input->skip($ftype); 1798 } 1799 $xfer += $input->readFieldEnd(); 1800 } 1801 $xfer += $input->readStructEnd(); 1802 return $xfer; 1803} 1804 1805sub write { 1806 my ($self, $output) = @_; 1807 my $xfer = 0; 1808 $xfer += $output->writeStructBegin('CfDef'); 1809 if (defined $self->{table}) { 1810 $xfer += $output->writeFieldBegin('table', TType::STRING, 1); 1811 $xfer += $output->writeString($self->{table}); 1812 $xfer += $output->writeFieldEnd(); 1813 } 1814 if (defined $self->{name}) { 1815 $xfer += $output->writeFieldBegin('name', TType::STRING, 2); 1816 $xfer += $output->writeString($self->{name}); 1817 $xfer += $output->writeFieldEnd(); 1818 } 1819 if (defined $self->{column_type}) { 1820 $xfer += $output->writeFieldBegin('column_type', TType::STRING, 3); 1821 $xfer += $output->writeString($self->{column_type}); 1822 $xfer += $output->writeFieldEnd(); 1823 } 1824 if (defined $self->{comparator_type}) { 1825 $xfer += $output->writeFieldBegin('comparator_type', TType::STRING, 4); 1826 $xfer += $output->writeString($self->{comparator_type}); 1827 $xfer += $output->writeFieldEnd(); 1828 } 1829 if (defined $self->{subcomparator_type}) { 1830 $xfer += $output->writeFieldBegin('subcomparator_type', TType::STRING, 5); 1831 $xfer += $output->writeString($self->{subcomparator_type}); 1832 $xfer += $output->writeFieldEnd(); 1833 } 1834 if (defined $self->{comment}) { 1835 $xfer += $output->writeFieldBegin('comment', TType::STRING, 6); 1836 $xfer += $output->writeString($self->{comment}); 1837 $xfer += $output->writeFieldEnd(); 1838 } 1839 if (defined $self->{row_cache_size}) { 1840 $xfer += $output->writeFieldBegin('row_cache_size', TType::DOUBLE, 7); 1841 $xfer += $output->writeDouble($self->{row_cache_size}); 1842 $xfer += $output->writeFieldEnd(); 1843 } 1844 if (defined $self->{preload_row_cache}) { 1845 $xfer += $output->writeFieldBegin('preload_row_cache', TType::BOOL, 8); 1846 $xfer += $output->writeBool($self->{preload_row_cache}); 1847 $xfer += $output->writeFieldEnd(); 1848 } 1849 if (defined $self->{key_cache_size}) { 1850 $xfer += $output->writeFieldBegin('key_cache_size', TType::DOUBLE, 9); 1851 $xfer += $output->writeDouble($self->{key_cache_size}); 1852 $xfer += $output->writeFieldEnd(); 1853 } 1854 $xfer += $output->writeFieldStop(); 1855 $xfer += $output->writeStructEnd(); 1856 return $xfer; 1857} 1858 1859package Net::GenCassandra::KsDef; 1860use base qw(Class::Accessor); 1861Net::GenCassandra::KsDef->mk_accessors( qw( name strategy_class replication_factor cf_defs ) ); 1862 1863sub new { 1864 my $classname = shift; 1865 my $self = {}; 1866 my $vals = shift || {}; 1867 $self->{name} = undef; 1868 $self->{strategy_class} = undef; 1869 $self->{replication_factor} = undef; 1870 $self->{cf_defs} = undef; 1871 if (UNIVERSAL::isa($vals,'HASH')) { 1872 if (defined $vals->{name}) { 1873 $self->{name} = $vals->{name}; 1874 } 1875 if (defined $vals->{strategy_class}) { 1876 $self->{strategy_class} = $vals->{strategy_class}; 1877 } 1878 if (defined $vals->{replication_factor}) { 1879 $self->{replication_factor} = $vals->{replication_factor}; 1880 } 1881 if (defined $vals->{cf_defs}) { 1882 $self->{cf_defs} = $vals->{cf_defs}; 1883 } 1884 } 1885 return bless ($self, $classname); 1886} 1887 1888sub getName { 1889 return 'KsDef'; 1890} 1891 1892sub read { 1893 my ($self, $input) = @_; 1894 my $xfer = 0; 1895 my $fname; 1896 my $ftype = 0; 1897 my $fid = 0; 1898 $xfer += $input->readStructBegin(\$fname); 1899 while (1) 1900 { 1901 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid); 1902 if ($ftype == TType::STOP) { 1903 last; 1904 } 1905 SWITCH: for($fid) 1906 { 1907 /^1$/ && do{ if ($ftype == TType::STRING) { 1908 $xfer += $input->readString(\$self->{name}); 1909 } else { 1910 $xfer += $input->skip($ftype); 1911 } 1912 last; }; 1913 /^2$/ && do{ if ($ftype == TType::STRING) { 1914 $xfer += $input->readString(\$self->{strategy_class}); 1915 } else { 1916 $xfer += $input->skip($ftype); 1917 } 1918 last; }; 1919 /^3$/ && do{ if ($ftype == TType::I32) { 1920 $xfer += $input->readI32(\$self->{replication_factor}); 1921 } else { 1922 $xfer += $input->skip($ftype); 1923 } 1924 last; }; 1925 /^5$/ && do{ if ($ftype == TType::LIST) { 1926 { 1927 my $_size44 = 0; 1928 $self->{cf_defs} = []; 1929 my $_etype47 = 0; 1930 $xfer += $input->readListBegin(\$_etype47, \$_size44); 1931 for (my $_i48 = 0; $_i48 < $_size44; ++$_i48) 1932 { 1933 my $elem49 = undef; 1934 $elem49 = new Net::GenCassandra::CfDef(); 1935 $xfer += $elem49->read($input); 1936 push(@{$self->{cf_defs}},$elem49); 1937 } 1938 $xfer += $input->readListEnd(); 1939 } 1940 } else { 1941 $xfer += $input->skip($ftype); 1942 } 1943 last; }; 1944 $xfer += $input->skip($ftype); 1945 } 1946 $xfer += $input->readFieldEnd(); 1947 } 1948 $xfer += $input->readStructEnd(); 1949 return $xfer; 1950} 1951 1952sub write { 1953 my ($self, $output) = @_; 1954 my $xfer = 0; 1955 $xfer += $output->writeStructBegin('KsDef'); 1956 if (defined $self->{name}) { 1957 $xfer += $output->writeFieldBegin('name', TType::STRING, 1); 1958 $xfer += $output->writeString($self->{name}); 1959 $xfer += $output->writeFieldEnd(); 1960 } 1961 if (defined $self->{strategy_class}) { 1962 $xfer += $output->writeFieldBegin('strategy_class', TType::STRING, 2); 1963 $xfer += $output->writeString($self->{strategy_class}); 1964 $xfer += $output->writeFieldEnd(); 1965 } 1966 if (defined $self->{replication_factor}) { 1967 $xfer += $output->writeFieldBegin('replication_factor', TType::I32, 3); 1968 $xfer += $output->writeI32($self->{replication_factor}); 1969 $xfer += $output->writeFieldEnd(); 1970 } 1971 if (defined $self->{cf_defs}) { 1972 $xfer += $output->writeFieldBegin('cf_defs', TType::LIST, 5); 1973 { 1974 $output->writeListBegin(TType::STRUCT, scalar(@{$self->{cf_defs}})); 1975 { 1976 foreach my $iter50 (@{$self->{cf_defs}}) 1977 { 1978 $xfer += ${iter50}->write($output); 1979 } 1980 } 1981 $output->writeListEnd(); 1982 } 1983 $xfer += $output->writeFieldEnd(); 1984 } 1985 $xfer += $output->writeFieldStop(); 1986 $xfer += $output->writeStructEnd(); 1987 return $xfer; 1988} 1989 19901; 1991