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