Mercurial > hg > Applications > casawiki

comparison Cassandra/lib/Cassandra/Types.pm @ 0:a2f0a2c135cf

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
hg init
author Shoshi TAMAKI <shoshi@cr.ie.u-ryukyu.ac.jp>
date Sun, 06 Jun 2010 22:00:38 +0900
parents
children
comparison
equal deleted inserted replaced
-1:000000000000 0:a2f0a2c135cf
1 #
2 # Autogenerated by Thrift
3 #
4 # DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
5 #
6 require 5.6.0;
7 use strict;
8 use warnings;
9 use Thrift;
10
11 package Cassandra::ConsistencyLevel;
12 use constant ZERO => 0;
13 use constant ONE => 1;
14 use constant QUORUM => 2;
15 use constant DCQUORUM => 3;
16 use constant DCQUORUMSYNC => 4;
17 use constant ALL => 5;
18 use constant ANY => 6;
19 package Cassandra::Column;
20 use base qw(Class::Accessor);
21 Cassandra::Column->mk_accessors( qw( name value timestamp ) );
22
23 sub new {
24 my $classname = shift;
25 my $self = {};
26 my $vals = shift || {};
27 $self->{name} = undef;
28 $self->{value} = undef;
29 $self->{timestamp} = undef;
30 if (UNIVERSAL::isa($vals,'HASH')) {
31 if (defined $vals->{name}) {
32 $self->{name} = $vals->{name};
33 }
34 if (defined $vals->{value}) {
35 $self->{value} = $vals->{value};
36 }
37 if (defined $vals->{timestamp}) {
38 $self->{timestamp} = $vals->{timestamp};
39 }
40 }
41 return bless ($self, $classname);
42 }
43
44 sub getName {
45 return 'Column';
46 }
47
48 sub read {
49 my ($self, $input) = @_;
50 my $xfer = 0;
51 my $fname;
52 my $ftype = 0;
53 my $fid = 0;
54 $xfer += $input->readStructBegin(\$fname);
55 while (1)
56 {
57 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
58 if ($ftype == TType::STOP) {
59 last;
60 }
61 SWITCH: for($fid)
62 {
63 /^1$/ && do{ if ($ftype == TType::STRING) {
64 $xfer += $input->readString(\$self->{name});
65 } else {
66 $xfer += $input->skip($ftype);
67 }
68 last; };
69 /^2$/ && do{ if ($ftype == TType::STRING) {
70 $xfer += $input->readString(\$self->{value});
71 } else {
72 $xfer += $input->skip($ftype);
73 }
74 last; };
75 /^3$/ && do{ if ($ftype == TType::I64) {
76 $xfer += $input->readI64(\$self->{timestamp});
77 } else {
78 $xfer += $input->skip($ftype);
79 }
80 last; };
81 $xfer += $input->skip($ftype);
82 }
83 $xfer += $input->readFieldEnd();
84 }
85 $xfer += $input->readStructEnd();
86 return $xfer;
87 }
88
89 sub write {
90 my ($self, $output) = @_;
91 my $xfer = 0;
92 $xfer += $output->writeStructBegin('Column');
93 if (defined $self->{name}) {
94 $xfer += $output->writeFieldBegin('name', TType::STRING, 1);
95 $xfer += $output->writeString($self->{name});
96 $xfer += $output->writeFieldEnd();
97 }
98 if (defined $self->{value}) {
99 $xfer += $output->writeFieldBegin('value', TType::STRING, 2);
100 $xfer += $output->writeString($self->{value});
101 $xfer += $output->writeFieldEnd();
102 }
103 if (defined $self->{timestamp}) {
104 $xfer += $output->writeFieldBegin('timestamp', TType::I64, 3);
105 $xfer += $output->writeI64($self->{timestamp});
106 $xfer += $output->writeFieldEnd();
107 }
108 $xfer += $output->writeFieldStop();
109 $xfer += $output->writeStructEnd();
110 return $xfer;
111 }
112
113 package Cassandra::SuperColumn;
114 use base qw(Class::Accessor);
115 Cassandra::SuperColumn->mk_accessors( qw( name columns ) );
116
117 sub new {
118 my $classname = shift;
119 my $self = {};
120 my $vals = shift || {};
121 $self->{name} = undef;
122 $self->{columns} = undef;
123 if (UNIVERSAL::isa($vals,'HASH')) {
124 if (defined $vals->{name}) {
125 $self->{name} = $vals->{name};
126 }
127 if (defined $vals->{columns}) {
128 $self->{columns} = $vals->{columns};
129 }
130 }
131 return bless ($self, $classname);
132 }
133
134 sub getName {
135 return 'SuperColumn';
136 }
137
138 sub read {
139 my ($self, $input) = @_;
140 my $xfer = 0;
141 my $fname;
142 my $ftype = 0;
143 my $fid = 0;
144 $xfer += $input->readStructBegin(\$fname);
145 while (1)
146 {
147 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
148 if ($ftype == TType::STOP) {
149 last;
150 }
151 SWITCH: for($fid)
152 {
153 /^1$/ && do{ if ($ftype == TType::STRING) {
154 $xfer += $input->readString(\$self->{name});
155 } else {
156 $xfer += $input->skip($ftype);
157 }
158 last; };
159 /^2$/ && do{ if ($ftype == TType::LIST) {
160 {
161 my $_size0 = 0;
162 $self->{columns} = [];
163 my $_etype3 = 0;
164 $xfer += $input->readListBegin(\$_etype3, \$_size0);
165 for (my $_i4 = 0; $_i4 < $_size0; ++$_i4)
166 {
167 my $elem5 = undef;
168 $elem5 = new Cassandra::Column();
169 $xfer += $elem5->read($input);
170 push(@{$self->{columns}},$elem5);
171 }
172 $xfer += $input->readListEnd();
173 }
174 } else {
175 $xfer += $input->skip($ftype);
176 }
177 last; };
178 $xfer += $input->skip($ftype);
179 }
180 $xfer += $input->readFieldEnd();
181 }
182 $xfer += $input->readStructEnd();
183 return $xfer;
184 }
185
186 sub write {
187 my ($self, $output) = @_;
188 my $xfer = 0;
189 $xfer += $output->writeStructBegin('SuperColumn');
190 if (defined $self->{name}) {
191 $xfer += $output->writeFieldBegin('name', TType::STRING, 1);
192 $xfer += $output->writeString($self->{name});
193 $xfer += $output->writeFieldEnd();
194 }
195 if (defined $self->{columns}) {
196 $xfer += $output->writeFieldBegin('columns', TType::LIST, 2);
197 {
198 $output->writeListBegin(TType::STRUCT, scalar(@{$self->{columns}}));
199 {
200 foreach my $iter6 (@{$self->{columns}})
201 {
202 $xfer += ${iter6}->write($output);
203 }
204 }
205 $output->writeListEnd();
206 }
207 $xfer += $output->writeFieldEnd();
208 }
209 $xfer += $output->writeFieldStop();
210 $xfer += $output->writeStructEnd();
211 return $xfer;
212 }
213
214 package Cassandra::ColumnOrSuperColumn;
215 use base qw(Class::Accessor);
216 Cassandra::ColumnOrSuperColumn->mk_accessors( qw( column super_column ) );
217
218 sub new {
219 my $classname = shift;
220 my $self = {};
221 my $vals = shift || {};
222 $self->{column} = undef;
223 $self->{super_column} = undef;
224 if (UNIVERSAL::isa($vals,'HASH')) {
225 if (defined $vals->{column}) {
226 $self->{column} = $vals->{column};
227 }
228 if (defined $vals->{super_column}) {
229 $self->{super_column} = $vals->{super_column};
230 }
231 }
232 return bless ($self, $classname);
233 }
234
235 sub getName {
236 return 'ColumnOrSuperColumn';
237 }
238
239 sub read {
240 my ($self, $input) = @_;
241 my $xfer = 0;
242 my $fname;
243 my $ftype = 0;
244 my $fid = 0;
245 $xfer += $input->readStructBegin(\$fname);
246 while (1)
247 {
248 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
249 if ($ftype == TType::STOP) {
250 last;
251 }
252 SWITCH: for($fid)
253 {
254 /^1$/ && do{ if ($ftype == TType::STRUCT) {
255 $self->{column} = new Cassandra::Column();
256 $xfer += $self->{column}->read($input);
257 } else {
258 $xfer += $input->skip($ftype);
259 }
260 last; };
261 /^2$/ && do{ if ($ftype == TType::STRUCT) {
262 $self->{super_column} = new Cassandra::SuperColumn();
263 $xfer += $self->{super_column}->read($input);
264 } else {
265 $xfer += $input->skip($ftype);
266 }
267 last; };
268 $xfer += $input->skip($ftype);
269 }
270 $xfer += $input->readFieldEnd();
271 }
272 $xfer += $input->readStructEnd();
273 return $xfer;
274 }
275
276 sub write {
277 my ($self, $output) = @_;
278 my $xfer = 0;
279 $xfer += $output->writeStructBegin('ColumnOrSuperColumn');
280 if (defined $self->{column}) {
281 $xfer += $output->writeFieldBegin('column', TType::STRUCT, 1);
282 $xfer += $self->{column}->write($output);
283 $xfer += $output->writeFieldEnd();
284 }
285 if (defined $self->{super_column}) {
286 $xfer += $output->writeFieldBegin('super_column', TType::STRUCT, 2);
287 $xfer += $self->{super_column}->write($output);
288 $xfer += $output->writeFieldEnd();
289 }
290 $xfer += $output->writeFieldStop();
291 $xfer += $output->writeStructEnd();
292 return $xfer;
293 }
294
295 package Cassandra::NotFoundException;
296 use base qw(Thrift::TException);
297 use base qw(Class::Accessor);
298
299 sub new {
300 my $classname = shift;
301 my $self = {};
302 my $vals = shift || {};
303 return bless ($self, $classname);
304 }
305
306 sub getName {
307 return 'NotFoundException';
308 }
309
310 sub read {
311 my ($self, $input) = @_;
312 my $xfer = 0;
313 my $fname;
314 my $ftype = 0;
315 my $fid = 0;
316 $xfer += $input->readStructBegin(\$fname);
317 while (1)
318 {
319 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
320 if ($ftype == TType::STOP) {
321 last;
322 }
323 SWITCH: for($fid)
324 {
325 $xfer += $input->skip($ftype);
326 }
327 $xfer += $input->readFieldEnd();
328 }
329 $xfer += $input->readStructEnd();
330 return $xfer;
331 }
332
333 sub write {
334 my ($self, $output) = @_;
335 my $xfer = 0;
336 $xfer += $output->writeStructBegin('NotFoundException');
337 $xfer += $output->writeFieldStop();
338 $xfer += $output->writeStructEnd();
339 return $xfer;
340 }
341
342 package Cassandra::InvalidRequestException;
343 use base qw(Thrift::TException);
344 use base qw(Class::Accessor);
345 Cassandra::InvalidRequestException->mk_accessors( qw( why ) );
346
347 sub new {
348 my $classname = shift;
349 my $self = {};
350 my $vals = shift || {};
351 $self->{why} = undef;
352 if (UNIVERSAL::isa($vals,'HASH')) {
353 if (defined $vals->{why}) {
354 $self->{why} = $vals->{why};
355 }
356 }
357 return bless ($self, $classname);
358 }
359
360 sub getName {
361 return 'InvalidRequestException';
362 }
363
364 sub read {
365 my ($self, $input) = @_;
366 my $xfer = 0;
367 my $fname;
368 my $ftype = 0;
369 my $fid = 0;
370 $xfer += $input->readStructBegin(\$fname);
371 while (1)
372 {
373 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
374 if ($ftype == TType::STOP) {
375 last;
376 }
377 SWITCH: for($fid)
378 {
379 /^1$/ && do{ if ($ftype == TType::STRING) {
380 $xfer += $input->readString(\$self->{why});
381 } else {
382 $xfer += $input->skip($ftype);
383 }
384 last; };
385 $xfer += $input->skip($ftype);
386 }
387 $xfer += $input->readFieldEnd();
388 }
389 $xfer += $input->readStructEnd();
390 return $xfer;
391 }
392
393 sub write {
394 my ($self, $output) = @_;
395 my $xfer = 0;
396 $xfer += $output->writeStructBegin('InvalidRequestException');
397 if (defined $self->{why}) {
398 $xfer += $output->writeFieldBegin('why', TType::STRING, 1);
399 $xfer += $output->writeString($self->{why});
400 $xfer += $output->writeFieldEnd();
401 }
402 $xfer += $output->writeFieldStop();
403 $xfer += $output->writeStructEnd();
404 return $xfer;
405 }
406
407 package Cassandra::UnavailableException;
408 use base qw(Thrift::TException);
409 use base qw(Class::Accessor);
410
411 sub new {
412 my $classname = shift;
413 my $self = {};
414 my $vals = shift || {};
415 return bless ($self, $classname);
416 }
417
418 sub getName {
419 return 'UnavailableException';
420 }
421
422 sub read {
423 my ($self, $input) = @_;
424 my $xfer = 0;
425 my $fname;
426 my $ftype = 0;
427 my $fid = 0;
428 $xfer += $input->readStructBegin(\$fname);
429 while (1)
430 {
431 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
432 if ($ftype == TType::STOP) {
433 last;
434 }
435 SWITCH: for($fid)
436 {
437 $xfer += $input->skip($ftype);
438 }
439 $xfer += $input->readFieldEnd();
440 }
441 $xfer += $input->readStructEnd();
442 return $xfer;
443 }
444
445 sub write {
446 my ($self, $output) = @_;
447 my $xfer = 0;
448 $xfer += $output->writeStructBegin('UnavailableException');
449 $xfer += $output->writeFieldStop();
450 $xfer += $output->writeStructEnd();
451 return $xfer;
452 }
453
454 package Cassandra::TimedOutException;
455 use base qw(Thrift::TException);
456 use base qw(Class::Accessor);
457
458 sub new {
459 my $classname = shift;
460 my $self = {};
461 my $vals = shift || {};
462 return bless ($self, $classname);
463 }
464
465 sub getName {
466 return 'TimedOutException';
467 }
468
469 sub read {
470 my ($self, $input) = @_;
471 my $xfer = 0;
472 my $fname;
473 my $ftype = 0;
474 my $fid = 0;
475 $xfer += $input->readStructBegin(\$fname);
476 while (1)
477 {
478 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
479 if ($ftype == TType::STOP) {
480 last;
481 }
482 SWITCH: for($fid)
483 {
484 $xfer += $input->skip($ftype);
485 }
486 $xfer += $input->readFieldEnd();
487 }
488 $xfer += $input->readStructEnd();
489 return $xfer;
490 }
491
492 sub write {
493 my ($self, $output) = @_;
494 my $xfer = 0;
495 $xfer += $output->writeStructBegin('TimedOutException');
496 $xfer += $output->writeFieldStop();
497 $xfer += $output->writeStructEnd();
498 return $xfer;
499 }
500
501 package Cassandra::AuthenticationException;
502 use base qw(Thrift::TException);
503 use base qw(Class::Accessor);
504 Cassandra::AuthenticationException->mk_accessors( qw( why ) );
505
506 sub new {
507 my $classname = shift;
508 my $self = {};
509 my $vals = shift || {};
510 $self->{why} = undef;
511 if (UNIVERSAL::isa($vals,'HASH')) {
512 if (defined $vals->{why}) {
513 $self->{why} = $vals->{why};
514 }
515 }
516 return bless ($self, $classname);
517 }
518
519 sub getName {
520 return 'AuthenticationException';
521 }
522
523 sub read {
524 my ($self, $input) = @_;
525 my $xfer = 0;
526 my $fname;
527 my $ftype = 0;
528 my $fid = 0;
529 $xfer += $input->readStructBegin(\$fname);
530 while (1)
531 {
532 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
533 if ($ftype == TType::STOP) {
534 last;
535 }
536 SWITCH: for($fid)
537 {
538 /^1$/ && do{ if ($ftype == TType::STRING) {
539 $xfer += $input->readString(\$self->{why});
540 } else {
541 $xfer += $input->skip($ftype);
542 }
543 last; };
544 $xfer += $input->skip($ftype);
545 }
546 $xfer += $input->readFieldEnd();
547 }
548 $xfer += $input->readStructEnd();
549 return $xfer;
550 }
551
552 sub write {
553 my ($self, $output) = @_;
554 my $xfer = 0;
555 $xfer += $output->writeStructBegin('AuthenticationException');
556 if (defined $self->{why}) {
557 $xfer += $output->writeFieldBegin('why', TType::STRING, 1);
558 $xfer += $output->writeString($self->{why});
559 $xfer += $output->writeFieldEnd();
560 }
561 $xfer += $output->writeFieldStop();
562 $xfer += $output->writeStructEnd();
563 return $xfer;
564 }
565
566 package Cassandra::AuthorizationException;
567 use base qw(Thrift::TException);
568 use base qw(Class::Accessor);
569 Cassandra::AuthorizationException->mk_accessors( qw( why ) );
570
571 sub new {
572 my $classname = shift;
573 my $self = {};
574 my $vals = shift || {};
575 $self->{why} = undef;
576 if (UNIVERSAL::isa($vals,'HASH')) {
577 if (defined $vals->{why}) {
578 $self->{why} = $vals->{why};
579 }
580 }
581 return bless ($self, $classname);
582 }
583
584 sub getName {
585 return 'AuthorizationException';
586 }
587
588 sub read {
589 my ($self, $input) = @_;
590 my $xfer = 0;
591 my $fname;
592 my $ftype = 0;
593 my $fid = 0;
594 $xfer += $input->readStructBegin(\$fname);
595 while (1)
596 {
597 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
598 if ($ftype == TType::STOP) {
599 last;
600 }
601 SWITCH: for($fid)
602 {
603 /^1$/ && do{ if ($ftype == TType::STRING) {
604 $xfer += $input->readString(\$self->{why});
605 } else {
606 $xfer += $input->skip($ftype);
607 }
608 last; };
609 $xfer += $input->skip($ftype);
610 }
611 $xfer += $input->readFieldEnd();
612 }
613 $xfer += $input->readStructEnd();
614 return $xfer;
615 }
616
617 sub write {
618 my ($self, $output) = @_;
619 my $xfer = 0;
620 $xfer += $output->writeStructBegin('AuthorizationException');
621 if (defined $self->{why}) {
622 $xfer += $output->writeFieldBegin('why', TType::STRING, 1);
623 $xfer += $output->writeString($self->{why});
624 $xfer += $output->writeFieldEnd();
625 }
626 $xfer += $output->writeFieldStop();
627 $xfer += $output->writeStructEnd();
628 return $xfer;
629 }
630
631 package Cassandra::ColumnParent;
632 use base qw(Class::Accessor);
633 Cassandra::ColumnParent->mk_accessors( qw( column_family super_column ) );
634
635 sub new {
636 my $classname = shift;
637 my $self = {};
638 my $vals = shift || {};
639 $self->{column_family} = undef;
640 $self->{super_column} = undef;
641 if (UNIVERSAL::isa($vals,'HASH')) {
642 if (defined $vals->{column_family}) {
643 $self->{column_family} = $vals->{column_family};
644 }
645 if (defined $vals->{super_column}) {
646 $self->{super_column} = $vals->{super_column};
647 }
648 }
649 return bless ($self, $classname);
650 }
651
652 sub getName {
653 return 'ColumnParent';
654 }
655
656 sub read {
657 my ($self, $input) = @_;
658 my $xfer = 0;
659 my $fname;
660 my $ftype = 0;
661 my $fid = 0;
662 $xfer += $input->readStructBegin(\$fname);
663 while (1)
664 {
665 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
666 if ($ftype == TType::STOP) {
667 last;
668 }
669 SWITCH: for($fid)
670 {
671 /^3$/ && do{ if ($ftype == TType::STRING) {
672 $xfer += $input->readString(\$self->{column_family});
673 } else {
674 $xfer += $input->skip($ftype);
675 }
676 last; };
677 /^4$/ && do{ if ($ftype == TType::STRING) {
678 $xfer += $input->readString(\$self->{super_column});
679 } else {
680 $xfer += $input->skip($ftype);
681 }
682 last; };
683 $xfer += $input->skip($ftype);
684 }
685 $xfer += $input->readFieldEnd();
686 }
687 $xfer += $input->readStructEnd();
688 return $xfer;
689 }
690
691 sub write {
692 my ($self, $output) = @_;
693 my $xfer = 0;
694 $xfer += $output->writeStructBegin('ColumnParent');
695 if (defined $self->{column_family}) {
696 $xfer += $output->writeFieldBegin('column_family', TType::STRING, 3);
697 $xfer += $output->writeString($self->{column_family});
698 $xfer += $output->writeFieldEnd();
699 }
700 if (defined $self->{super_column}) {
701 $xfer += $output->writeFieldBegin('super_column', TType::STRING, 4);
702 $xfer += $output->writeString($self->{super_column});
703 $xfer += $output->writeFieldEnd();
704 }
705 $xfer += $output->writeFieldStop();
706 $xfer += $output->writeStructEnd();
707 return $xfer;
708 }
709
710 package Cassandra::ColumnPath;
711 use base qw(Class::Accessor);
712 Cassandra::ColumnPath->mk_accessors( qw( column_family super_column column ) );
713
714 sub new {
715 my $classname = shift;
716 my $self = {};
717 my $vals = shift || {};
718 $self->{column_family} = undef;
719 $self->{super_column} = undef;
720 $self->{column} = undef;
721 if (UNIVERSAL::isa($vals,'HASH')) {
722 if (defined $vals->{column_family}) {
723 $self->{column_family} = $vals->{column_family};
724 }
725 if (defined $vals->{super_column}) {
726 $self->{super_column} = $vals->{super_column};
727 }
728 if (defined $vals->{column}) {
729 $self->{column} = $vals->{column};
730 }
731 }
732 return bless ($self, $classname);
733 }
734
735 sub getName {
736 return 'ColumnPath';
737 }
738
739 sub read {
740 my ($self, $input) = @_;
741 my $xfer = 0;
742 my $fname;
743 my $ftype = 0;
744 my $fid = 0;
745 $xfer += $input->readStructBegin(\$fname);
746 while (1)
747 {
748 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
749 if ($ftype == TType::STOP) {
750 last;
751 }
752 SWITCH: for($fid)
753 {
754 /^3$/ && do{ if ($ftype == TType::STRING) {
755 $xfer += $input->readString(\$self->{column_family});
756 } else {
757 $xfer += $input->skip($ftype);
758 }
759 last; };
760 /^4$/ && do{ if ($ftype == TType::STRING) {
761 $xfer += $input->readString(\$self->{super_column});
762 } else {
763 $xfer += $input->skip($ftype);
764 }
765 last; };
766 /^5$/ && do{ if ($ftype == TType::STRING) {
767 $xfer += $input->readString(\$self->{column});
768 } else {
769 $xfer += $input->skip($ftype);
770 }
771 last; };
772 $xfer += $input->skip($ftype);
773 }
774 $xfer += $input->readFieldEnd();
775 }
776 $xfer += $input->readStructEnd();
777 return $xfer;
778 }
779
780 sub write {
781 my ($self, $output) = @_;
782 my $xfer = 0;
783 $xfer += $output->writeStructBegin('ColumnPath');
784 if (defined $self->{column_family}) {
785 $xfer += $output->writeFieldBegin('column_family', TType::STRING, 3);
786 $xfer += $output->writeString($self->{column_family});
787 $xfer += $output->writeFieldEnd();
788 }
789 if (defined $self->{super_column}) {
790 $xfer += $output->writeFieldBegin('super_column', TType::STRING, 4);
791 $xfer += $output->writeString($self->{super_column});
792 $xfer += $output->writeFieldEnd();
793 }
794 if (defined $self->{column}) {
795 $xfer += $output->writeFieldBegin('column', TType::STRING, 5);
796 $xfer += $output->writeString($self->{column});
797 $xfer += $output->writeFieldEnd();
798 }
799 $xfer += $output->writeFieldStop();
800 $xfer += $output->writeStructEnd();
801 return $xfer;
802 }
803
804 package Cassandra::SliceRange;
805 use base qw(Class::Accessor);
806 Cassandra::SliceRange->mk_accessors( qw( start finish reversed count ) );
807
808 sub new {
809 my $classname = shift;
810 my $self = {};
811 my $vals = shift || {};
812 $self->{start} = undef;
813 $self->{finish} = undef;
814 $self->{reversed} = 0;
815 $self->{count} = 100;
816 if (UNIVERSAL::isa($vals,'HASH')) {
817 if (defined $vals->{start}) {
818 $self->{start} = $vals->{start};
819 }
820 if (defined $vals->{finish}) {
821 $self->{finish} = $vals->{finish};
822 }
823 if (defined $vals->{reversed}) {
824 $self->{reversed} = $vals->{reversed};
825 }
826 if (defined $vals->{count}) {
827 $self->{count} = $vals->{count};
828 }
829 }
830 return bless ($self, $classname);
831 }
832
833 sub getName {
834 return 'SliceRange';
835 }
836
837 sub read {
838 my ($self, $input) = @_;
839 my $xfer = 0;
840 my $fname;
841 my $ftype = 0;
842 my $fid = 0;
843 $xfer += $input->readStructBegin(\$fname);
844 while (1)
845 {
846 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
847 if ($ftype == TType::STOP) {
848 last;
849 }
850 SWITCH: for($fid)
851 {
852 /^1$/ && do{ if ($ftype == TType::STRING) {
853 $xfer += $input->readString(\$self->{start});
854 } else {
855 $xfer += $input->skip($ftype);
856 }
857 last; };
858 /^2$/ && do{ if ($ftype == TType::STRING) {
859 $xfer += $input->readString(\$self->{finish});
860 } else {
861 $xfer += $input->skip($ftype);
862 }
863 last; };
864 /^3$/ && do{ if ($ftype == TType::BOOL) {
865 $xfer += $input->readBool(\$self->{reversed});
866 } else {
867 $xfer += $input->skip($ftype);
868 }
869 last; };
870 /^4$/ && do{ if ($ftype == TType::I32) {
871 $xfer += $input->readI32(\$self->{count});
872 } else {
873 $xfer += $input->skip($ftype);
874 }
875 last; };
876 $xfer += $input->skip($ftype);
877 }
878 $xfer += $input->readFieldEnd();
879 }
880 $xfer += $input->readStructEnd();
881 return $xfer;
882 }
883
884 sub write {
885 my ($self, $output) = @_;
886 my $xfer = 0;
887 $xfer += $output->writeStructBegin('SliceRange');
888 if (defined $self->{start}) {
889 $xfer += $output->writeFieldBegin('start', TType::STRING, 1);
890 $xfer += $output->writeString($self->{start});
891 $xfer += $output->writeFieldEnd();
892 }
893 if (defined $self->{finish}) {
894 $xfer += $output->writeFieldBegin('finish', TType::STRING, 2);
895 $xfer += $output->writeString($self->{finish});
896 $xfer += $output->writeFieldEnd();
897 }
898 if (defined $self->{reversed}) {
899 $xfer += $output->writeFieldBegin('reversed', TType::BOOL, 3);
900 $xfer += $output->writeBool($self->{reversed});
901 $xfer += $output->writeFieldEnd();
902 }
903 if (defined $self->{count}) {
904 $xfer += $output->writeFieldBegin('count', TType::I32, 4);
905 $xfer += $output->writeI32($self->{count});
906 $xfer += $output->writeFieldEnd();
907 }
908 $xfer += $output->writeFieldStop();
909 $xfer += $output->writeStructEnd();
910 return $xfer;
911 }
912
913 package Cassandra::SlicePredicate;
914 use base qw(Class::Accessor);
915 Cassandra::SlicePredicate->mk_accessors( qw( column_names slice_range ) );
916
917 sub new {
918 my $classname = shift;
919 my $self = {};
920 my $vals = shift || {};
921 $self->{column_names} = undef;
922 $self->{slice_range} = undef;
923 if (UNIVERSAL::isa($vals,'HASH')) {
924 if (defined $vals->{column_names}) {
925 $self->{column_names} = $vals->{column_names};
926 }
927 if (defined $vals->{slice_range}) {
928 $self->{slice_range} = $vals->{slice_range};
929 }
930 }
931 return bless ($self, $classname);
932 }
933
934 sub getName {
935 return 'SlicePredicate';
936 }
937
938 sub read {
939 my ($self, $input) = @_;
940 my $xfer = 0;
941 my $fname;
942 my $ftype = 0;
943 my $fid = 0;
944 $xfer += $input->readStructBegin(\$fname);
945 while (1)
946 {
947 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
948 if ($ftype == TType::STOP) {
949 last;
950 }
951 SWITCH: for($fid)
952 {
953 /^1$/ && do{ if ($ftype == TType::LIST) {
954 {
955 my $_size7 = 0;
956 $self->{column_names} = [];
957 my $_etype10 = 0;
958 $xfer += $input->readListBegin(\$_etype10, \$_size7);
959 for (my $_i11 = 0; $_i11 < $_size7; ++$_i11)
960 {
961 my $elem12 = undef;
962 $xfer += $input->readString(\$elem12);
963 push(@{$self->{column_names}},$elem12);
964 }
965 $xfer += $input->readListEnd();
966 }
967 } else {
968 $xfer += $input->skip($ftype);
969 }
970 last; };
971 /^2$/ && do{ if ($ftype == TType::STRUCT) {
972 $self->{slice_range} = new Cassandra::SliceRange();
973 $xfer += $self->{slice_range}->read($input);
974 } else {
975 $xfer += $input->skip($ftype);
976 }
977 last; };
978 $xfer += $input->skip($ftype);
979 }
980 $xfer += $input->readFieldEnd();
981 }
982 $xfer += $input->readStructEnd();
983 return $xfer;
984 }
985
986 sub write {
987 my ($self, $output) = @_;
988 my $xfer = 0;
989 $xfer += $output->writeStructBegin('SlicePredicate');
990 if (defined $self->{column_names}) {
991 $xfer += $output->writeFieldBegin('column_names', TType::LIST, 1);
992 {
993 $output->writeListBegin(TType::STRING, scalar(@{$self->{column_names}}));
994 {
995 foreach my $iter13 (@{$self->{column_names}})
996 {
997 $xfer += $output->writeString($iter13);
998 }
999 }
1000 $output->writeListEnd();
1001 }
1002 $xfer += $output->writeFieldEnd();
1003 }
1004 if (defined $self->{slice_range}) {
1005 $xfer += $output->writeFieldBegin('slice_range', TType::STRUCT, 2);
1006 $xfer += $self->{slice_range}->write($output);
1007 $xfer += $output->writeFieldEnd();
1008 }
1009 $xfer += $output->writeFieldStop();
1010 $xfer += $output->writeStructEnd();
1011 return $xfer;
1012 }
1013
1014 package Cassandra::KeyRange;
1015 use base qw(Class::Accessor);
1016 Cassandra::KeyRange->mk_accessors( qw( start_key end_key start_token end_token count ) );
1017
1018 sub new {
1019 my $classname = shift;
1020 my $self = {};
1021 my $vals = shift || {};
1022 $self->{start_key} = undef;
1023 $self->{end_key} = undef;
1024 $self->{start_token} = undef;
1025 $self->{end_token} = undef;
1026 $self->{count} = 100;
1027 if (UNIVERSAL::isa($vals,'HASH')) {
1028 if (defined $vals->{start_key}) {
1029 $self->{start_key} = $vals->{start_key};
1030 }
1031 if (defined $vals->{end_key}) {
1032 $self->{end_key} = $vals->{end_key};
1033 }
1034 if (defined $vals->{start_token}) {
1035 $self->{start_token} = $vals->{start_token};
1036 }
1037 if (defined $vals->{end_token}) {
1038 $self->{end_token} = $vals->{end_token};
1039 }
1040 if (defined $vals->{count}) {
1041 $self->{count} = $vals->{count};
1042 }
1043 }
1044 return bless ($self, $classname);
1045 }
1046
1047 sub getName {
1048 return 'KeyRange';
1049 }
1050
1051 sub read {
1052 my ($self, $input) = @_;
1053 my $xfer = 0;
1054 my $fname;
1055 my $ftype = 0;
1056 my $fid = 0;
1057 $xfer += $input->readStructBegin(\$fname);
1058 while (1)
1059 {
1060 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
1061 if ($ftype == TType::STOP) {
1062 last;
1063 }
1064 SWITCH: for($fid)
1065 {
1066 /^1$/ && do{ if ($ftype == TType::STRING) {
1067 $xfer += $input->readString(\$self->{start_key});
1068 } else {
1069 $xfer += $input->skip($ftype);
1070 }
1071 last; };
1072 /^2$/ && do{ if ($ftype == TType::STRING) {
1073 $xfer += $input->readString(\$self->{end_key});
1074 } else {
1075 $xfer += $input->skip($ftype);
1076 }
1077 last; };
1078 /^3$/ && do{ if ($ftype == TType::STRING) {
1079 $xfer += $input->readString(\$self->{start_token});
1080 } else {
1081 $xfer += $input->skip($ftype);
1082 }
1083 last; };
1084 /^4$/ && do{ if ($ftype == TType::STRING) {
1085 $xfer += $input->readString(\$self->{end_token});
1086 } else {
1087 $xfer += $input->skip($ftype);
1088 }
1089 last; };
1090 /^5$/ && do{ if ($ftype == TType::I32) {
1091 $xfer += $input->readI32(\$self->{count});
1092 } else {
1093 $xfer += $input->skip($ftype);
1094 }
1095 last; };
1096 $xfer += $input->skip($ftype);
1097 }
1098 $xfer += $input->readFieldEnd();
1099 }
1100 $xfer += $input->readStructEnd();
1101 return $xfer;
1102 }
1103
1104 sub write {
1105 my ($self, $output) = @_;
1106 my $xfer = 0;
1107 $xfer += $output->writeStructBegin('KeyRange');
1108 if (defined $self->{start_key}) {
1109 $xfer += $output->writeFieldBegin('start_key', TType::STRING, 1);
1110 $xfer += $output->writeString($self->{start_key});
1111 $xfer += $output->writeFieldEnd();
1112 }
1113 if (defined $self->{end_key}) {
1114 $xfer += $output->writeFieldBegin('end_key', TType::STRING, 2);
1115 $xfer += $output->writeString($self->{end_key});
1116 $xfer += $output->writeFieldEnd();
1117 }
1118 if (defined $self->{start_token}) {
1119 $xfer += $output->writeFieldBegin('start_token', TType::STRING, 3);
1120 $xfer += $output->writeString($self->{start_token});
1121 $xfer += $output->writeFieldEnd();
1122 }
1123 if (defined $self->{end_token}) {
1124 $xfer += $output->writeFieldBegin('end_token', TType::STRING, 4);
1125 $xfer += $output->writeString($self->{end_token});
1126 $xfer += $output->writeFieldEnd();
1127 }
1128 if (defined $self->{count}) {
1129 $xfer += $output->writeFieldBegin('count', TType::I32, 5);
1130 $xfer += $output->writeI32($self->{count});
1131 $xfer += $output->writeFieldEnd();
1132 }
1133 $xfer += $output->writeFieldStop();
1134 $xfer += $output->writeStructEnd();
1135 return $xfer;
1136 }
1137
1138 package Cassandra::KeySlice;
1139 use base qw(Class::Accessor);
1140 Cassandra::KeySlice->mk_accessors( qw( key columns ) );
1141
1142 sub new {
1143 my $classname = shift;
1144 my $self = {};
1145 my $vals = shift || {};
1146 $self->{key} = undef;
1147 $self->{columns} = undef;
1148 if (UNIVERSAL::isa($vals,'HASH')) {
1149 if (defined $vals->{key}) {
1150 $self->{key} = $vals->{key};
1151 }
1152 if (defined $vals->{columns}) {
1153 $self->{columns} = $vals->{columns};
1154 }
1155 }
1156 return bless ($self, $classname);
1157 }
1158
1159 sub getName {
1160 return 'KeySlice';
1161 }
1162
1163 sub read {
1164 my ($self, $input) = @_;
1165 my $xfer = 0;
1166 my $fname;
1167 my $ftype = 0;
1168 my $fid = 0;
1169 $xfer += $input->readStructBegin(\$fname);
1170 while (1)
1171 {
1172 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
1173 if ($ftype == TType::STOP) {
1174 last;
1175 }
1176 SWITCH: for($fid)
1177 {
1178 /^1$/ && do{ if ($ftype == TType::STRING) {
1179 $xfer += $input->readString(\$self->{key});
1180 } else {
1181 $xfer += $input->skip($ftype);
1182 }
1183 last; };
1184 /^2$/ && do{ if ($ftype == TType::LIST) {
1185 {
1186 my $_size14 = 0;
1187 $self->{columns} = [];
1188 my $_etype17 = 0;
1189 $xfer += $input->readListBegin(\$_etype17, \$_size14);
1190 for (my $_i18 = 0; $_i18 < $_size14; ++$_i18)
1191 {
1192 my $elem19 = undef;
1193 $elem19 = new Cassandra::ColumnOrSuperColumn();
1194 $xfer += $elem19->read($input);
1195 push(@{$self->{columns}},$elem19);
1196 }
1197 $xfer += $input->readListEnd();
1198 }
1199 } else {
1200 $xfer += $input->skip($ftype);
1201 }
1202 last; };
1203 $xfer += $input->skip($ftype);
1204 }
1205 $xfer += $input->readFieldEnd();
1206 }
1207 $xfer += $input->readStructEnd();
1208 return $xfer;
1209 }
1210
1211 sub write {
1212 my ($self, $output) = @_;
1213 my $xfer = 0;
1214 $xfer += $output->writeStructBegin('KeySlice');
1215 if (defined $self->{key}) {
1216 $xfer += $output->writeFieldBegin('key', TType::STRING, 1);
1217 $xfer += $output->writeString($self->{key});
1218 $xfer += $output->writeFieldEnd();
1219 }
1220 if (defined $self->{columns}) {
1221 $xfer += $output->writeFieldBegin('columns', TType::LIST, 2);
1222 {
1223 $output->writeListBegin(TType::STRUCT, scalar(@{$self->{columns}}));
1224 {
1225 foreach my $iter20 (@{$self->{columns}})
1226 {
1227 $xfer += ${iter20}->write($output);
1228 }
1229 }
1230 $output->writeListEnd();
1231 }
1232 $xfer += $output->writeFieldEnd();
1233 }
1234 $xfer += $output->writeFieldStop();
1235 $xfer += $output->writeStructEnd();
1236 return $xfer;
1237 }
1238
1239 package Cassandra::Deletion;
1240 use base qw(Class::Accessor);
1241 Cassandra::Deletion->mk_accessors( qw( timestamp super_column predicate ) );
1242
1243 sub new {
1244 my $classname = shift;
1245 my $self = {};
1246 my $vals = shift || {};
1247 $self->{timestamp} = undef;
1248 $self->{super_column} = undef;
1249 $self->{predicate} = undef;
1250 if (UNIVERSAL::isa($vals,'HASH')) {
1251 if (defined $vals->{timestamp}) {
1252 $self->{timestamp} = $vals->{timestamp};
1253 }
1254 if (defined $vals->{super_column}) {
1255 $self->{super_column} = $vals->{super_column};
1256 }
1257 if (defined $vals->{predicate}) {
1258 $self->{predicate} = $vals->{predicate};
1259 }
1260 }
1261 return bless ($self, $classname);
1262 }
1263
1264 sub getName {
1265 return 'Deletion';
1266 }
1267
1268 sub read {
1269 my ($self, $input) = @_;
1270 my $xfer = 0;
1271 my $fname;
1272 my $ftype = 0;
1273 my $fid = 0;
1274 $xfer += $input->readStructBegin(\$fname);
1275 while (1)
1276 {
1277 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
1278 if ($ftype == TType::STOP) {
1279 last;
1280 }
1281 SWITCH: for($fid)
1282 {
1283 /^1$/ && do{ if ($ftype == TType::I64) {
1284 $xfer += $input->readI64(\$self->{timestamp});
1285 } else {
1286 $xfer += $input->skip($ftype);
1287 }
1288 last; };
1289 /^2$/ && do{ if ($ftype == TType::STRING) {
1290 $xfer += $input->readString(\$self->{super_column});
1291 } else {
1292 $xfer += $input->skip($ftype);
1293 }
1294 last; };
1295 /^3$/ && do{ if ($ftype == TType::STRUCT) {
1296 $self->{predicate} = new Cassandra::SlicePredicate();
1297 $xfer += $self->{predicate}->read($input);
1298 } else {
1299 $xfer += $input->skip($ftype);
1300 }
1301 last; };
1302 $xfer += $input->skip($ftype);
1303 }
1304 $xfer += $input->readFieldEnd();
1305 }
1306 $xfer += $input->readStructEnd();
1307 return $xfer;
1308 }
1309
1310 sub write {
1311 my ($self, $output) = @_;
1312 my $xfer = 0;
1313 $xfer += $output->writeStructBegin('Deletion');
1314 if (defined $self->{timestamp}) {
1315 $xfer += $output->writeFieldBegin('timestamp', TType::I64, 1);
1316 $xfer += $output->writeI64($self->{timestamp});
1317 $xfer += $output->writeFieldEnd();
1318 }
1319 if (defined $self->{super_column}) {
1320 $xfer += $output->writeFieldBegin('super_column', TType::STRING, 2);
1321 $xfer += $output->writeString($self->{super_column});
1322 $xfer += $output->writeFieldEnd();
1323 }
1324 if (defined $self->{predicate}) {
1325 $xfer += $output->writeFieldBegin('predicate', TType::STRUCT, 3);
1326 $xfer += $self->{predicate}->write($output);
1327 $xfer += $output->writeFieldEnd();
1328 }
1329 $xfer += $output->writeFieldStop();
1330 $xfer += $output->writeStructEnd();
1331 return $xfer;
1332 }
1333
1334 package Cassandra::Mutation;
1335 use base qw(Class::Accessor);
1336 Cassandra::Mutation->mk_accessors( qw( column_or_supercolumn deletion ) );
1337
1338 sub new {
1339 my $classname = shift;
1340 my $self = {};
1341 my $vals = shift || {};
1342 $self->{column_or_supercolumn} = undef;
1343 $self->{deletion} = undef;
1344 if (UNIVERSAL::isa($vals,'HASH')) {
1345 if (defined $vals->{column_or_supercolumn}) {
1346 $self->{column_or_supercolumn} = $vals->{column_or_supercolumn};
1347 }
1348 if (defined $vals->{deletion}) {
1349 $self->{deletion} = $vals->{deletion};
1350 }
1351 }
1352 return bless ($self, $classname);
1353 }
1354
1355 sub getName {
1356 return 'Mutation';
1357 }
1358
1359 sub read {
1360 my ($self, $input) = @_;
1361 my $xfer = 0;
1362 my $fname;
1363 my $ftype = 0;
1364 my $fid = 0;
1365 $xfer += $input->readStructBegin(\$fname);
1366 while (1)
1367 {
1368 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
1369 if ($ftype == TType::STOP) {
1370 last;
1371 }
1372 SWITCH: for($fid)
1373 {
1374 /^1$/ && do{ if ($ftype == TType::STRUCT) {
1375 $self->{column_or_supercolumn} = new Cassandra::ColumnOrSuperColumn();
1376 $xfer += $self->{column_or_supercolumn}->read($input);
1377 } else {
1378 $xfer += $input->skip($ftype);
1379 }
1380 last; };
1381 /^2$/ && do{ if ($ftype == TType::STRUCT) {
1382 $self->{deletion} = new Cassandra::Deletion();
1383 $xfer += $self->{deletion}->read($input);
1384 } else {
1385 $xfer += $input->skip($ftype);
1386 }
1387 last; };
1388 $xfer += $input->skip($ftype);
1389 }
1390 $xfer += $input->readFieldEnd();
1391 }
1392 $xfer += $input->readStructEnd();
1393 return $xfer;
1394 }
1395
1396 sub write {
1397 my ($self, $output) = @_;
1398 my $xfer = 0;
1399 $xfer += $output->writeStructBegin('Mutation');
1400 if (defined $self->{column_or_supercolumn}) {
1401 $xfer += $output->writeFieldBegin('column_or_supercolumn', TType::STRUCT, 1);
1402 $xfer += $self->{column_or_supercolumn}->write($output);
1403 $xfer += $output->writeFieldEnd();
1404 }
1405 if (defined $self->{deletion}) {
1406 $xfer += $output->writeFieldBegin('deletion', TType::STRUCT, 2);
1407 $xfer += $self->{deletion}->write($output);
1408 $xfer += $output->writeFieldEnd();
1409 }
1410 $xfer += $output->writeFieldStop();
1411 $xfer += $output->writeStructEnd();
1412 return $xfer;
1413 }
1414
1415 package Cassandra::TokenRange;
1416 use base qw(Class::Accessor);
1417 Cassandra::TokenRange->mk_accessors( qw( start_token end_token endpoints ) );
1418
1419 sub new {
1420 my $classname = shift;
1421 my $self = {};
1422 my $vals = shift || {};
1423 $self->{start_token} = undef;
1424 $self->{end_token} = undef;
1425 $self->{endpoints} = undef;
1426 if (UNIVERSAL::isa($vals,'HASH')) {
1427 if (defined $vals->{start_token}) {
1428 $self->{start_token} = $vals->{start_token};
1429 }
1430 if (defined $vals->{end_token}) {
1431 $self->{end_token} = $vals->{end_token};
1432 }
1433 if (defined $vals->{endpoints}) {
1434 $self->{endpoints} = $vals->{endpoints};
1435 }
1436 }
1437 return bless ($self, $classname);
1438 }
1439
1440 sub getName {
1441 return 'TokenRange';
1442 }
1443
1444 sub read {
1445 my ($self, $input) = @_;
1446 my $xfer = 0;
1447 my $fname;
1448 my $ftype = 0;
1449 my $fid = 0;
1450 $xfer += $input->readStructBegin(\$fname);
1451 while (1)
1452 {
1453 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
1454 if ($ftype == TType::STOP) {
1455 last;
1456 }
1457 SWITCH: for($fid)
1458 {
1459 /^1$/ && do{ if ($ftype == TType::STRING) {
1460 $xfer += $input->readString(\$self->{start_token});
1461 } else {
1462 $xfer += $input->skip($ftype);
1463 }
1464 last; };
1465 /^2$/ && do{ if ($ftype == TType::STRING) {
1466 $xfer += $input->readString(\$self->{end_token});
1467 } else {
1468 $xfer += $input->skip($ftype);
1469 }
1470 last; };
1471 /^3$/ && do{ if ($ftype == TType::LIST) {
1472 {
1473 my $_size21 = 0;
1474 $self->{endpoints} = [];
1475 my $_etype24 = 0;
1476 $xfer += $input->readListBegin(\$_etype24, \$_size21);
1477 for (my $_i25 = 0; $_i25 < $_size21; ++$_i25)
1478 {
1479 my $elem26 = undef;
1480 $xfer += $input->readString(\$elem26);
1481 push(@{$self->{endpoints}},$elem26);
1482 }
1483 $xfer += $input->readListEnd();
1484 }
1485 } else {
1486 $xfer += $input->skip($ftype);
1487 }
1488 last; };
1489 $xfer += $input->skip($ftype);
1490 }
1491 $xfer += $input->readFieldEnd();
1492 }
1493 $xfer += $input->readStructEnd();
1494 return $xfer;
1495 }
1496
1497 sub write {
1498 my ($self, $output) = @_;
1499 my $xfer = 0;
1500 $xfer += $output->writeStructBegin('TokenRange');
1501 if (defined $self->{start_token}) {
1502 $xfer += $output->writeFieldBegin('start_token', TType::STRING, 1);
1503 $xfer += $output->writeString($self->{start_token});
1504 $xfer += $output->writeFieldEnd();
1505 }
1506 if (defined $self->{end_token}) {
1507 $xfer += $output->writeFieldBegin('end_token', TType::STRING, 2);
1508 $xfer += $output->writeString($self->{end_token});
1509 $xfer += $output->writeFieldEnd();
1510 }
1511 if (defined $self->{endpoints}) {
1512 $xfer += $output->writeFieldBegin('endpoints', TType::LIST, 3);
1513 {
1514 $output->writeListBegin(TType::STRING, scalar(@{$self->{endpoints}}));
1515 {
1516 foreach my $iter27 (@{$self->{endpoints}})
1517 {
1518 $xfer += $output->writeString($iter27);
1519 }
1520 }
1521 $output->writeListEnd();
1522 }
1523 $xfer += $output->writeFieldEnd();
1524 }
1525 $xfer += $output->writeFieldStop();
1526 $xfer += $output->writeStructEnd();
1527 return $xfer;
1528 }
1529
1530 package Cassandra::AuthenticationRequest;
1531 use base qw(Class::Accessor);
1532 Cassandra::AuthenticationRequest->mk_accessors( qw( credentials ) );
1533
1534 sub new {
1535 my $classname = shift;
1536 my $self = {};
1537 my $vals = shift || {};
1538 $self->{credentials} = undef;
1539 if (UNIVERSAL::isa($vals,'HASH')) {
1540 if (defined $vals->{credentials}) {
1541 $self->{credentials} = $vals->{credentials};
1542 }
1543 }
1544 return bless ($self, $classname);
1545 }
1546
1547 sub getName {
1548 return 'AuthenticationRequest';
1549 }
1550
1551 sub read {
1552 my ($self, $input) = @_;
1553 my $xfer = 0;
1554 my $fname;
1555 my $ftype = 0;
1556 my $fid = 0;
1557 $xfer += $input->readStructBegin(\$fname);
1558 while (1)
1559 {
1560 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
1561 if ($ftype == TType::STOP) {
1562 last;
1563 }
1564 SWITCH: for($fid)
1565 {
1566 /^1$/ && do{ if ($ftype == TType::MAP) {
1567 {
1568 my $_size28 = 0;
1569 $self->{credentials} = {};
1570 my $_ktype29 = 0;
1571 my $_vtype30 = 0;
1572 $xfer += $input->readMapBegin(\$_ktype29, \$_vtype30, \$_size28);
1573 for (my $_i32 = 0; $_i32 < $_size28; ++$_i32)
1574 {
1575 my $key33 = '';
1576 my $val34 = '';
1577 $xfer += $input->readString(\$key33);
1578 $xfer += $input->readString(\$val34);
1579 $self->{credentials}->{$key33} = $val34;
1580 }
1581 $xfer += $input->readMapEnd();
1582 }
1583 } else {
1584 $xfer += $input->skip($ftype);
1585 }
1586 last; };
1587 $xfer += $input->skip($ftype);
1588 }
1589 $xfer += $input->readFieldEnd();
1590 }
1591 $xfer += $input->readStructEnd();
1592 return $xfer;
1593 }
1594
1595 sub write {
1596 my ($self, $output) = @_;
1597 my $xfer = 0;
1598 $xfer += $output->writeStructBegin('AuthenticationRequest');
1599 if (defined $self->{credentials}) {
1600 $xfer += $output->writeFieldBegin('credentials', TType::MAP, 1);
1601 {
1602 $output->writeMapBegin(TType::STRING, TType::STRING, scalar(keys %{$self->{credentials}}));
1603 {
1604 while( my ($kiter35,$viter36) = each %{$self->{credentials}})
1605 {
1606 $xfer += $output->writeString($kiter35);
1607 $xfer += $output->writeString($viter36);
1608 }
1609 }
1610 $output->writeMapEnd();
1611 }
1612 $xfer += $output->writeFieldEnd();
1613 }
1614 $xfer += $output->writeFieldStop();
1615 $xfer += $output->writeStructEnd();
1616 return $xfer;
1617 }
1618
1619 1;