Evernote/EDAMNoteStore/Types.pm untested

filter: Statementstmt 0.0% 0 / 2039 Branchbran 0.0% 0 / 598 Conditioncond 0.0% 0 / 299 MC/DCmcdc 0.0% 0 / 195 Subroutinesub 0.0% 0 / 69 Podpod 0.0% 0 / 52 totaltotal 0.0% 0 / 3252 CC 300 SCAR 47.8
CC
300
Cov
0%
new
272.0
read
272.0
write
240.0
CRAP 119.2
1 #
2 # Autogenerated by Thrift Compiler (0.9.0)
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 Net::Evernote::EDAMNoteStore::SyncState;
12 use base qw(Class::Accessor);
13 Net::Evernote::EDAMNoteStore::SyncState->mk_accessors( qw( currentTime fullSyncBefore updateCount uploaded ) );
14  
15 sub new {
16 my $classname = shift;
17 my $self = {};
18 my $vals = shift || {};
19 $self->{currentTime} = undef;
20 $self->{fullSyncBefore} = undef;
21 $self->{updateCount} = undef;
22 $self->{uploaded} = undef;
23 if (UNIVERSAL::isa($vals,'HASH')) {
24 if (defined $vals->{currentTime}) {
25 $self->{currentTime} = $vals->{currentTime};
26 }
27 if (defined $vals->{fullSyncBefore}) {
28 $self->{fullSyncBefore} = $vals->{fullSyncBefore};
29 }
30 if (defined $vals->{updateCount}) {
31 $self->{updateCount} = $vals->{updateCount};
32 }
33 if (defined $vals->{uploaded}) {
34 $self->{uploaded} = $vals->{uploaded};
35 }
36 }
37 return bless ($self, $classname);
38 }
39  
40 sub getName {
41 return 'SyncState';
42 }
43  
44 sub read {
45 my ($self, $input) = @_;
46 my $xfer = 0;
47 my $fname;
48 my $ftype = 0;
49 my $fid = 0;
50 $xfer += $input->readStructBegin(\$fname);
51 while (1)
52 {
53 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
54 if ($ftype == TType::STOP) {
55 last;
56 }
57 SWITCH: for($fid)
58 {
59 /^1$/ && do{ if ($ftype == TType::I64) {
60 $xfer += $input->readI64(\$self->{currentTime});
61 } else {
62 $xfer += $input->skip($ftype);
63 }
64 last; };
65 /^2$/ && do{ if ($ftype == TType::I64) {
66 $xfer += $input->readI64(\$self->{fullSyncBefore});
67 } else {
68 $xfer += $input->skip($ftype);
69 }
70 last; };
71 /^3$/ && do{ if ($ftype == TType::I32) {
72 $xfer += $input->readI32(\$self->{updateCount});
73 } else {
74 $xfer += $input->skip($ftype);
75 }
76 last; };
77 /^4$/ && do{ if ($ftype == TType::I64) {
78 $xfer += $input->readI64(\$self->{uploaded});
79 } else {
80 $xfer += $input->skip($ftype);
81 }
82 last; };
83 $xfer += $input->skip($ftype);
84 }
85 $xfer += $input->readFieldEnd();
86 }
87 $xfer += $input->readStructEnd();
88 return $xfer;
89 }
90  
91 sub write {
92 my ($self, $output) = @_;
93 my $xfer = 0;
94 $xfer += $output->writeStructBegin('SyncState');
95 if (defined $self->{currentTime}) {
96 $xfer += $output->writeFieldBegin('currentTime', TType::I64, 1);
97 $xfer += $output->writeI64($self->{currentTime});
98 $xfer += $output->writeFieldEnd();
99 }
100 if (defined $self->{fullSyncBefore}) {
101 $xfer += $output->writeFieldBegin('fullSyncBefore', TType::I64, 2);
102 $xfer += $output->writeI64($self->{fullSyncBefore});
103 $xfer += $output->writeFieldEnd();
104 }
105 if (defined $self->{updateCount}) {
106 $xfer += $output->writeFieldBegin('updateCount', TType::I32, 3);
107 $xfer += $output->writeI32($self->{updateCount});
108 $xfer += $output->writeFieldEnd();
109 }
110 if (defined $self->{uploaded}) {
111 $xfer += $output->writeFieldBegin('uploaded', TType::I64, 4);
112 $xfer += $output->writeI64($self->{uploaded});
113 $xfer += $output->writeFieldEnd();
114 }
115 $xfer += $output->writeFieldStop();
116 $xfer += $output->writeStructEnd();
117 return $xfer;
118 }
119  
120 package Net::Evernote::EDAMNoteStore::SyncChunk;
121 use base qw(Class::Accessor);
122 Net::Evernote::EDAMNoteStore::SyncChunk->mk_accessors( qw( currentTime chunkHighUSN updateCount notes notebooks tags searches resources expungedNotes expungedNotebooks expungedTags expungedSearches linkedNotebooks expungedLinkedNotebooks ) );
123  
124 sub new {
125 my $classname = shift;
126 my $self = {};
127 my $vals = shift || {};
128 $self->{currentTime} = undef;
129 $self->{chunkHighUSN} = undef;
130 $self->{updateCount} = undef;
131 $self->{notes} = undef;
132 $self->{notebooks} = undef;
133 $self->{tags} = undef;
134 $self->{searches} = undef;
135 $self->{resources} = undef;
136 $self->{expungedNotes} = undef;
137 $self->{expungedNotebooks} = undef;
138 $self->{expungedTags} = undef;
139 $self->{expungedSearches} = undef;
140 $self->{linkedNotebooks} = undef;
141 $self->{expungedLinkedNotebooks} = undef;
142 if (UNIVERSAL::isa($vals,'HASH')) {
143 if (defined $vals->{currentTime}) {
144 $self->{currentTime} = $vals->{currentTime};
145 }
146 if (defined $vals->{chunkHighUSN}) {
147 $self->{chunkHighUSN} = $vals->{chunkHighUSN};
148 }
149 if (defined $vals->{updateCount}) {
150 $self->{updateCount} = $vals->{updateCount};
151 }
152 if (defined $vals->{notes}) {
153 $self->{notes} = $vals->{notes};
154 }
155 if (defined $vals->{notebooks}) {
156 $self->{notebooks} = $vals->{notebooks};
157 }
158 if (defined $vals->{tags}) {
159 $self->{tags} = $vals->{tags};
160 }
161 if (defined $vals->{searches}) {
162 $self->{searches} = $vals->{searches};
163 }
164 if (defined $vals->{resources}) {
165 $self->{resources} = $vals->{resources};
166 }
167 if (defined $vals->{expungedNotes}) {
168 $self->{expungedNotes} = $vals->{expungedNotes};
169 }
170 if (defined $vals->{expungedNotebooks}) {
171 $self->{expungedNotebooks} = $vals->{expungedNotebooks};
172 }
173 if (defined $vals->{expungedTags}) {
174 $self->{expungedTags} = $vals->{expungedTags};
175 }
176 if (defined $vals->{expungedSearches}) {
177 $self->{expungedSearches} = $vals->{expungedSearches};
178 }
179 if (defined $vals->{linkedNotebooks}) {
180 $self->{linkedNotebooks} = $vals->{linkedNotebooks};
181 }
182 if (defined $vals->{expungedLinkedNotebooks}) {
183 $self->{expungedLinkedNotebooks} = $vals->{expungedLinkedNotebooks};
184 }
185 }
186 return bless ($self, $classname);
187 }
188  
189 sub getName {
190 return 'SyncChunk';
191 }
192  
193 sub read {
194 my ($self, $input) = @_;
195 my $xfer = 0;
196 my $fname;
197 my $ftype = 0;
198 my $fid = 0;
199 $xfer += $input->readStructBegin(\$fname);
200 while (1)
201 {
202 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
203 if ($ftype == TType::STOP) {
204 last;
205 }
206 SWITCH: for($fid)
207 {
208 /^1$/ && do{ if ($ftype == TType::I64) {
209 $xfer += $input->readI64(\$self->{currentTime});
210 } else {
211 $xfer += $input->skip($ftype);
212 }
213 last; };
214 /^2$/ && do{ if ($ftype == TType::I32) {
215 $xfer += $input->readI32(\$self->{chunkHighUSN});
216 } else {
217 $xfer += $input->skip($ftype);
218 }
219 last; };
220 /^3$/ && do{ if ($ftype == TType::I32) {
221 $xfer += $input->readI32(\$self->{updateCount});
222 } else {
223 $xfer += $input->skip($ftype);
224 }
225 last; };
226 /^4$/ && do{ if ($ftype == TType::LIST) {
227 {
228 my $_size0 = 0;
229 $self->{notes} = [];
230 my $_etype3 = 0;
231 $xfer += $input->readListBegin(\$_etype3, \$_size0);
232 for (my $_i4 = 0; $_i4 < $_size0; ++$_i4)
233 {
234 my $elem5 = undef;
235 $elem5 = Net::Evernote::EDAMTypes::Note->new();
236 $xfer += $elem5->read($input);
237 push(@{$self->{notes}},$elem5);
238 }
239 $xfer += $input->readListEnd();
240 }
241 } else {
242 $xfer += $input->skip($ftype);
243 }
244 last; };
245 /^5$/ && do{ if ($ftype == TType::LIST) {
246 {
247 my $_size6 = 0;
248 $self->{notebooks} = [];
249 my $_etype9 = 0;
250 $xfer += $input->readListBegin(\$_etype9, \$_size6);
251 for (my $_i10 = 0; $_i10 < $_size6; ++$_i10)
252 {
253 my $elem11 = undef;
254 $elem11 = Net::Evernote::EDAMTypes::Notebook->new();
255 $xfer += $elem11->read($input);
256 push(@{$self->{notebooks}},$elem11);
257 }
258 $xfer += $input->readListEnd();
259 }
260 } else {
261 $xfer += $input->skip($ftype);
262 }
263 last; };
264 /^6$/ && do{ if ($ftype == TType::LIST) {
265 {
266 my $_size12 = 0;
267 $self->{tags} = [];
268 my $_etype15 = 0;
269 $xfer += $input->readListBegin(\$_etype15, \$_size12);
270 for (my $_i16 = 0; $_i16 < $_size12; ++$_i16)
271 {
272 my $elem17 = undef;
273 $elem17 = Net::Evernote::EDAMTypes::Tag->new();
274 $xfer += $elem17->read($input);
275 push(@{$self->{tags}},$elem17);
276 }
277 $xfer += $input->readListEnd();
278 }
279 } else {
280 $xfer += $input->skip($ftype);
281 }
282 last; };
283 /^7$/ && do{ if ($ftype == TType::LIST) {
284 {
285 my $_size18 = 0;
286 $self->{searches} = [];
287 my $_etype21 = 0;
288 $xfer += $input->readListBegin(\$_etype21, \$_size18);
289 for (my $_i22 = 0; $_i22 < $_size18; ++$_i22)
290 {
291 my $elem23 = undef;
292 $elem23 = Net::Evernote::EDAMTypes::SavedSearch->new();
293 $xfer += $elem23->read($input);
294 push(@{$self->{searches}},$elem23);
295 }
296 $xfer += $input->readListEnd();
297 }
298 } else {
299 $xfer += $input->skip($ftype);
300 }
301 last; };
302 /^8$/ && do{ if ($ftype == TType::LIST) {
303 {
304 my $_size24 = 0;
305 $self->{resources} = [];
306 my $_etype27 = 0;
307 $xfer += $input->readListBegin(\$_etype27, \$_size24);
308 for (my $_i28 = 0; $_i28 < $_size24; ++$_i28)
309 {
310 my $elem29 = undef;
311 $elem29 = Net::Evernote::EDAMTypes::Resource->new();
312 $xfer += $elem29->read($input);
313 push(@{$self->{resources}},$elem29);
314 }
315 $xfer += $input->readListEnd();
316 }
317 } else {
318 $xfer += $input->skip($ftype);
319 }
320 last; };
321 /^9$/ && do{ if ($ftype == TType::LIST) {
322 {
323 my $_size30 = 0;
324 $self->{expungedNotes} = [];
325 my $_etype33 = 0;
326 $xfer += $input->readListBegin(\$_etype33, \$_size30);
327 for (my $_i34 = 0; $_i34 < $_size30; ++$_i34)
328 {
329 my $elem35 = undef;
330 $xfer += $input->readString(\$elem35);
331 push(@{$self->{expungedNotes}},$elem35);
332 }
333 $xfer += $input->readListEnd();
334 }
335 } else {
336 $xfer += $input->skip($ftype);
337 }
338 last; };
339 /^10$/ && do{ if ($ftype == TType::LIST) {
340 {
341 my $_size36 = 0;
342 $self->{expungedNotebooks} = [];
343 my $_etype39 = 0;
344 $xfer += $input->readListBegin(\$_etype39, \$_size36);
345 for (my $_i40 = 0; $_i40 < $_size36; ++$_i40)
346 {
347 my $elem41 = undef;
348 $xfer += $input->readString(\$elem41);
349 push(@{$self->{expungedNotebooks}},$elem41);
350 }
351 $xfer += $input->readListEnd();
352 }
353 } else {
354 $xfer += $input->skip($ftype);
355 }
356 last; };
357 /^11$/ && do{ if ($ftype == TType::LIST) {
358 {
359 my $_size42 = 0;
360 $self->{expungedTags} = [];
361 my $_etype45 = 0;
362 $xfer += $input->readListBegin(\$_etype45, \$_size42);
363 for (my $_i46 = 0; $_i46 < $_size42; ++$_i46)
364 {
365 my $elem47 = undef;
366 $xfer += $input->readString(\$elem47);
367 push(@{$self->{expungedTags}},$elem47);
368 }
369 $xfer += $input->readListEnd();
370 }
371 } else {
372 $xfer += $input->skip($ftype);
373 }
374 last; };
375 /^12$/ && do{ if ($ftype == TType::LIST) {
376 {
377 my $_size48 = 0;
378 $self->{expungedSearches} = [];
379 my $_etype51 = 0;
380 $xfer += $input->readListBegin(\$_etype51, \$_size48);
381 for (my $_i52 = 0; $_i52 < $_size48; ++$_i52)
382 {
383 my $elem53 = undef;
384 $xfer += $input->readString(\$elem53);
385 push(@{$self->{expungedSearches}},$elem53);
386 }
387 $xfer += $input->readListEnd();
388 }
389 } else {
390 $xfer += $input->skip($ftype);
391 }
392 last; };
393 /^13$/ && do{ if ($ftype == TType::LIST) {
394 {
395 my $_size54 = 0;
396 $self->{linkedNotebooks} = [];
397 my $_etype57 = 0;
398 $xfer += $input->readListBegin(\$_etype57, \$_size54);
399 for (my $_i58 = 0; $_i58 < $_size54; ++$_i58)
400 {
401 my $elem59 = undef;
402 $elem59 = Net::Evernote::EDAMTypes::LinkedNotebook->new();
403 $xfer += $elem59->read($input);
404 push(@{$self->{linkedNotebooks}},$elem59);
405 }
406 $xfer += $input->readListEnd();
407 }
408 } else {
409 $xfer += $input->skip($ftype);
410 }
411 last; };
412 /^14$/ && do{ if ($ftype == TType::LIST) {
413 {
414 my $_size60 = 0;
415 $self->{expungedLinkedNotebooks} = [];
416 my $_etype63 = 0;
417 $xfer += $input->readListBegin(\$_etype63, \$_size60);
418 for (my $_i64 = 0; $_i64 < $_size60; ++$_i64)
419 {
420 my $elem65 = undef;
421 $xfer += $input->readString(\$elem65);
422 push(@{$self->{expungedLinkedNotebooks}},$elem65);
423 }
424 $xfer += $input->readListEnd();
425 }
426 } else {
427 $xfer += $input->skip($ftype);
428 }
429 last; };
430 $xfer += $input->skip($ftype);
431 }
432 $xfer += $input->readFieldEnd();
433 }
434 $xfer += $input->readStructEnd();
435 return $xfer;
436 }
437  
438 sub write {
439 my ($self, $output) = @_;
440 my $xfer = 0;
441 $xfer += $output->writeStructBegin('SyncChunk');
442 if (defined $self->{currentTime}) {
443 $xfer += $output->writeFieldBegin('currentTime', TType::I64, 1);
444 $xfer += $output->writeI64($self->{currentTime});
445 $xfer += $output->writeFieldEnd();
446 }
447 if (defined $self->{chunkHighUSN}) {
448 $xfer += $output->writeFieldBegin('chunkHighUSN', TType::I32, 2);
449 $xfer += $output->writeI32($self->{chunkHighUSN});
450 $xfer += $output->writeFieldEnd();
451 }
452 if (defined $self->{updateCount}) {
453 $xfer += $output->writeFieldBegin('updateCount', TType::I32, 3);
454 $xfer += $output->writeI32($self->{updateCount});
455 $xfer += $output->writeFieldEnd();
456 }
457 if (defined $self->{notes}) {
458 $xfer += $output->writeFieldBegin('notes', TType::LIST, 4);
459 {
460 $xfer += $output->writeListBegin(TType::STRUCT, scalar(@{$self->{notes}}));
461 {
462 foreach my $iter66 (@{$self->{notes}})
463 {
464 $xfer += ${iter66}->write($output);
465 }
466 }
467 $xfer += $output->writeListEnd();
468 }
469 $xfer += $output->writeFieldEnd();
470 }
471 if (defined $self->{notebooks}) {
472 $xfer += $output->writeFieldBegin('notebooks', TType::LIST, 5);
473 {
474 $xfer += $output->writeListBegin(TType::STRUCT, scalar(@{$self->{notebooks}}));
475 {
476 foreach my $iter67 (@{$self->{notebooks}})
477 {
478 $xfer += ${iter67}->write($output);
479 }
480 }
481 $xfer += $output->writeListEnd();
482 }
483 $xfer += $output->writeFieldEnd();
484 }
485 if (defined $self->{tags}) {
486 $xfer += $output->writeFieldBegin('tags', TType::LIST, 6);
487 {
488 $xfer += $output->writeListBegin(TType::STRUCT, scalar(@{$self->{tags}}));
489 {
490 foreach my $iter68 (@{$self->{tags}})
491 {
492 $xfer += ${iter68}->write($output);
493 }
494 }
495 $xfer += $output->writeListEnd();
496 }
497 $xfer += $output->writeFieldEnd();
498 }
499 if (defined $self->{searches}) {
500 $xfer += $output->writeFieldBegin('searches', TType::LIST, 7);
501 {
502 $xfer += $output->writeListBegin(TType::STRUCT, scalar(@{$self->{searches}}));
503 {
504 foreach my $iter69 (@{$self->{searches}})
505 {
506 $xfer += ${iter69}->write($output);
507 }
508 }
509 $xfer += $output->writeListEnd();
510 }
511 $xfer += $output->writeFieldEnd();
512 }
513 if (defined $self->{resources}) {
514 $xfer += $output->writeFieldBegin('resources', TType::LIST, 8);
515 {
516 $xfer += $output->writeListBegin(TType::STRUCT, scalar(@{$self->{resources}}));
517 {
518 foreach my $iter70 (@{$self->{resources}})
519 {
520 $xfer += ${iter70}->write($output);
521 }
522 }
523 $xfer += $output->writeListEnd();
524 }
525 $xfer += $output->writeFieldEnd();
526 }
527 if (defined $self->{expungedNotes}) {
528 $xfer += $output->writeFieldBegin('expungedNotes', TType::LIST, 9);
529 {
530 $xfer += $output->writeListBegin(TType::STRING, scalar(@{$self->{expungedNotes}}));
531 {
532 foreach my $iter71 (@{$self->{expungedNotes}})
533 {
534 $xfer += $output->writeString($iter71);
535 }
536 }
537 $xfer += $output->writeListEnd();
538 }
539 $xfer += $output->writeFieldEnd();
540 }
541 if (defined $self->{expungedNotebooks}) {
542 $xfer += $output->writeFieldBegin('expungedNotebooks', TType::LIST, 10);
543 {
544 $xfer += $output->writeListBegin(TType::STRING, scalar(@{$self->{expungedNotebooks}}));
545 {
546 foreach my $iter72 (@{$self->{expungedNotebooks}})
547 {
548 $xfer += $output->writeString($iter72);
549 }
550 }
551 $xfer += $output->writeListEnd();
552 }
553 $xfer += $output->writeFieldEnd();
554 }
555 if (defined $self->{expungedTags}) {
556 $xfer += $output->writeFieldBegin('expungedTags', TType::LIST, 11);
557 {
558 $xfer += $output->writeListBegin(TType::STRING, scalar(@{$self->{expungedTags}}));
559 {
560 foreach my $iter73 (@{$self->{expungedTags}})
561 {
562 $xfer += $output->writeString($iter73);
563 }
564 }
565 $xfer += $output->writeListEnd();
566 }
567 $xfer += $output->writeFieldEnd();
568 }
569 if (defined $self->{expungedSearches}) {
570 $xfer += $output->writeFieldBegin('expungedSearches', TType::LIST, 12);
571 {
572 $xfer += $output->writeListBegin(TType::STRING, scalar(@{$self->{expungedSearches}}));
573 {
574 foreach my $iter74 (@{$self->{expungedSearches}})
575 {
576 $xfer += $output->writeString($iter74);
577 }
578 }
579 $xfer += $output->writeListEnd();
580 }
581 $xfer += $output->writeFieldEnd();
582 }
583 if (defined $self->{linkedNotebooks}) {
584 $xfer += $output->writeFieldBegin('linkedNotebooks', TType::LIST, 13);
585 {
586 $xfer += $output->writeListBegin(TType::STRUCT, scalar(@{$self->{linkedNotebooks}}));
587 {
588 foreach my $iter75 (@{$self->{linkedNotebooks}})
589 {
590 $xfer += ${iter75}->write($output);
591 }
592 }
593 $xfer += $output->writeListEnd();
594 }
595 $xfer += $output->writeFieldEnd();
596 }
597 if (defined $self->{expungedLinkedNotebooks}) {
598 $xfer += $output->writeFieldBegin('expungedLinkedNotebooks', TType::LIST, 14);
599 {
600 $xfer += $output->writeListBegin(TType::STRING, scalar(@{$self->{expungedLinkedNotebooks}}));
601 {
602 foreach my $iter76 (@{$self->{expungedLinkedNotebooks}})
603 {
604 $xfer += $output->writeString($iter76);
605 }
606 }
607 $xfer += $output->writeListEnd();
608 }
609 $xfer += $output->writeFieldEnd();
610 }
611 $xfer += $output->writeFieldStop();
612 $xfer += $output->writeStructEnd();
613 return $xfer;
614 }
615  
616 package Net::Evernote::EDAMNoteStore::SyncChunkFilter;
617 use base qw(Class::Accessor);
618 Net::Evernote::EDAMNoteStore::SyncChunkFilter->mk_accessors( qw( includeNotes includeNoteResources includeNoteAttributes includeNotebooks includeTags includeSearches includeResources includeLinkedNotebooks includeExpunged includeNoteApplicationDataFullMap includeResourceApplicationDataFullMap includeNoteResourceApplicationDataFullMap requireNoteContentClass ) );
619  
620 sub new {
621 my $classname = shift;
622 my $self = {};
623 my $vals = shift || {};
624 $self->{includeNotes} = undef;
625 $self->{includeNoteResources} = undef;
626 $self->{includeNoteAttributes} = undef;
627 $self->{includeNotebooks} = undef;
628 $self->{includeTags} = undef;
629 $self->{includeSearches} = undef;
630 $self->{includeResources} = undef;
631 $self->{includeLinkedNotebooks} = undef;
632 $self->{includeExpunged} = undef;
633 $self->{includeNoteApplicationDataFullMap} = undef;
634 $self->{includeResourceApplicationDataFullMap} = undef;
635 $self->{includeNoteResourceApplicationDataFullMap} = undef;
636 $self->{requireNoteContentClass} = undef;
637 if (UNIVERSAL::isa($vals,'HASH')) {
638 if (defined $vals->{includeNotes}) {
639 $self->{includeNotes} = $vals->{includeNotes};
640 }
641 if (defined $vals->{includeNoteResources}) {
642 $self->{includeNoteResources} = $vals->{includeNoteResources};
643 }
644 if (defined $vals->{includeNoteAttributes}) {
645 $self->{includeNoteAttributes} = $vals->{includeNoteAttributes};
646 }
647 if (defined $vals->{includeNotebooks}) {
648 $self->{includeNotebooks} = $vals->{includeNotebooks};
649 }
650 if (defined $vals->{includeTags}) {
651 $self->{includeTags} = $vals->{includeTags};
652 }
653 if (defined $vals->{includeSearches}) {
654 $self->{includeSearches} = $vals->{includeSearches};
655 }
656 if (defined $vals->{includeResources}) {
657 $self->{includeResources} = $vals->{includeResources};
658 }
659 if (defined $vals->{includeLinkedNotebooks}) {
660 $self->{includeLinkedNotebooks} = $vals->{includeLinkedNotebooks};
661 }
662 if (defined $vals->{includeExpunged}) {
663 $self->{includeExpunged} = $vals->{includeExpunged};
664 }
665 if (defined $vals->{includeNoteApplicationDataFullMap}) {
666 $self->{includeNoteApplicationDataFullMap} = $vals->{includeNoteApplicationDataFullMap};
667 }
668 if (defined $vals->{includeResourceApplicationDataFullMap}) {
669 $self->{includeResourceApplicationDataFullMap} = $vals->{includeResourceApplicationDataFullMap};
670 }
671 if (defined $vals->{includeNoteResourceApplicationDataFullMap}) {
672 $self->{includeNoteResourceApplicationDataFullMap} = $vals->{includeNoteResourceApplicationDataFullMap};
673 }
674 if (defined $vals->{requireNoteContentClass}) {
675 $self->{requireNoteContentClass} = $vals->{requireNoteContentClass};
676 }
677 }
678 return bless ($self, $classname);
679 }
680  
681 sub getName {
682 return 'SyncChunkFilter';
683 }
684  
685 sub read {
686 my ($self, $input) = @_;
687 my $xfer = 0;
688 my $fname;
689 my $ftype = 0;
690 my $fid = 0;
691 $xfer += $input->readStructBegin(\$fname);
692 while (1)
693 {
694 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
695 if ($ftype == TType::STOP) {
696 last;
697 }
698 SWITCH: for($fid)
699 {
700 /^1$/ && do{ if ($ftype == TType::BOOL) {
701 $xfer += $input->readBool(\$self->{includeNotes});
702 } else {
703 $xfer += $input->skip($ftype);
704 }
705 last; };
706 /^2$/ && do{ if ($ftype == TType::BOOL) {
707 $xfer += $input->readBool(\$self->{includeNoteResources});
708 } else {
709 $xfer += $input->skip($ftype);
710 }
711 last; };
712 /^3$/ && do{ if ($ftype == TType::BOOL) {
713 $xfer += $input->readBool(\$self->{includeNoteAttributes});
714 } else {
715 $xfer += $input->skip($ftype);
716 }
717 last; };
718 /^4$/ && do{ if ($ftype == TType::BOOL) {
719 $xfer += $input->readBool(\$self->{includeNotebooks});
720 } else {
721 $xfer += $input->skip($ftype);
722 }
723 last; };
724 /^5$/ && do{ if ($ftype == TType::BOOL) {
725 $xfer += $input->readBool(\$self->{includeTags});
726 } else {
727 $xfer += $input->skip($ftype);
728 }
729 last; };
730 /^6$/ && do{ if ($ftype == TType::BOOL) {
731 $xfer += $input->readBool(\$self->{includeSearches});
732 } else {
733 $xfer += $input->skip($ftype);
734 }
735 last; };
736 /^7$/ && do{ if ($ftype == TType::BOOL) {
737 $xfer += $input->readBool(\$self->{includeResources});
738 } else {
739 $xfer += $input->skip($ftype);
740 }
741 last; };
742 /^8$/ && do{ if ($ftype == TType::BOOL) {
743 $xfer += $input->readBool(\$self->{includeLinkedNotebooks});
744 } else {
745 $xfer += $input->skip($ftype);
746 }
747 last; };
748 /^9$/ && do{ if ($ftype == TType::BOOL) {
749 $xfer += $input->readBool(\$self->{includeExpunged});
750 } else {
751 $xfer += $input->skip($ftype);
752 }
753 last; };
754 /^10$/ && do{ if ($ftype == TType::BOOL) {
755 $xfer += $input->readBool(\$self->{includeNoteApplicationDataFullMap});
756 } else {
757 $xfer += $input->skip($ftype);
758 }
759 last; };
760 /^12$/ && do{ if ($ftype == TType::BOOL) {
761 $xfer += $input->readBool(\$self->{includeResourceApplicationDataFullMap});
762 } else {
763 $xfer += $input->skip($ftype);
764 }
765 last; };
766 /^13$/ && do{ if ($ftype == TType::BOOL) {
767 $xfer += $input->readBool(\$self->{includeNoteResourceApplicationDataFullMap});
768 } else {
769 $xfer += $input->skip($ftype);
770 }
771 last; };
772 /^11$/ && do{ if ($ftype == TType::STRING) {
773 $xfer += $input->readString(\$self->{requireNoteContentClass});
774 } else {
775 $xfer += $input->skip($ftype);
776 }
777 last; };
778 $xfer += $input->skip($ftype);
779 }
780 $xfer += $input->readFieldEnd();
781 }
782 $xfer += $input->readStructEnd();
783 return $xfer;
784 }
785  
786 sub write {
787 my ($self, $output) = @_;
788 my $xfer = 0;
789 $xfer += $output->writeStructBegin('SyncChunkFilter');
790 if (defined $self->{includeNotes}) {
791 $xfer += $output->writeFieldBegin('includeNotes', TType::BOOL, 1);
792 $xfer += $output->writeBool($self->{includeNotes});
793 $xfer += $output->writeFieldEnd();
794 }
795 if (defined $self->{includeNoteResources}) {
796 $xfer += $output->writeFieldBegin('includeNoteResources', TType::BOOL, 2);
797 $xfer += $output->writeBool($self->{includeNoteResources});
798 $xfer += $output->writeFieldEnd();
799 }
800 if (defined $self->{includeNoteAttributes}) {
801 $xfer += $output->writeFieldBegin('includeNoteAttributes', TType::BOOL, 3);
802 $xfer += $output->writeBool($self->{includeNoteAttributes});
803 $xfer += $output->writeFieldEnd();
804 }
805 if (defined $self->{includeNotebooks}) {
806 $xfer += $output->writeFieldBegin('includeNotebooks', TType::BOOL, 4);
807 $xfer += $output->writeBool($self->{includeNotebooks});
808 $xfer += $output->writeFieldEnd();
809 }
810 if (defined $self->{includeTags}) {
811 $xfer += $output->writeFieldBegin('includeTags', TType::BOOL, 5);
812 $xfer += $output->writeBool($self->{includeTags});
813 $xfer += $output->writeFieldEnd();
814 }
815 if (defined $self->{includeSearches}) {
816 $xfer += $output->writeFieldBegin('includeSearches', TType::BOOL, 6);
817 $xfer += $output->writeBool($self->{includeSearches});
818 $xfer += $output->writeFieldEnd();
819 }
820 if (defined $self->{includeResources}) {
821 $xfer += $output->writeFieldBegin('includeResources', TType::BOOL, 7);
822 $xfer += $output->writeBool($self->{includeResources});
823 $xfer += $output->writeFieldEnd();
824 }
825 if (defined $self->{includeLinkedNotebooks}) {
826 $xfer += $output->writeFieldBegin('includeLinkedNotebooks', TType::BOOL, 8);
827 $xfer += $output->writeBool($self->{includeLinkedNotebooks});
828 $xfer += $output->writeFieldEnd();
829 }
830 if (defined $self->{includeExpunged}) {
831 $xfer += $output->writeFieldBegin('includeExpunged', TType::BOOL, 9);
832 $xfer += $output->writeBool($self->{includeExpunged});
833 $xfer += $output->writeFieldEnd();
834 }
835 if (defined $self->{includeNoteApplicationDataFullMap}) {
836 $xfer += $output->writeFieldBegin('includeNoteApplicationDataFullMap', TType::BOOL, 10);
837 $xfer += $output->writeBool($self->{includeNoteApplicationDataFullMap});
838 $xfer += $output->writeFieldEnd();
839 }
840 if (defined $self->{requireNoteContentClass}) {
841 $xfer += $output->writeFieldBegin('requireNoteContentClass', TType::STRING, 11);
842 $xfer += $output->writeString($self->{requireNoteContentClass});
843 $xfer += $output->writeFieldEnd();
844 }
845 if (defined $self->{includeResourceApplicationDataFullMap}) {
846 $xfer += $output->writeFieldBegin('includeResourceApplicationDataFullMap', TType::BOOL, 12);
847 $xfer += $output->writeBool($self->{includeResourceApplicationDataFullMap});
848 $xfer += $output->writeFieldEnd();
849 }
850 if (defined $self->{includeNoteResourceApplicationDataFullMap}) {
851 $xfer += $output->writeFieldBegin('includeNoteResourceApplicationDataFullMap', TType::BOOL, 13);
852 $xfer += $output->writeBool($self->{includeNoteResourceApplicationDataFullMap});
853 $xfer += $output->writeFieldEnd();
854 }
855 $xfer += $output->writeFieldStop();
856 $xfer += $output->writeStructEnd();
857 return $xfer;
858 }
859  
860 package Net::Evernote::EDAMNoteStore::NoteFilter;
861 use base qw(Class::Accessor);
862 Net::Evernote::EDAMNoteStore::NoteFilter->mk_accessors( qw( order ascending words notebookGuid tagGuids timeZone inactive ) );
863  
864 sub new {
865 my $classname = shift;
866 my $self = {};
867 my $vals = shift || {};
868 $self->{order} = undef;
869 $self->{ascending} = undef;
870 $self->{words} = undef;
871 $self->{notebookGuid} = undef;
872 $self->{tagGuids} = undef;
873 $self->{timeZone} = undef;
874 $self->{inactive} = undef;
875 if (UNIVERSAL::isa($vals,'HASH')) {
876 if (defined $vals->{order}) {
877 $self->{order} = $vals->{order};
878 }
879 if (defined $vals->{ascending}) {
880 $self->{ascending} = $vals->{ascending};
881 }
882 if (defined $vals->{words}) {
883 $self->{words} = $vals->{words};
884 }
885 if (defined $vals->{notebookGuid}) {
886 $self->{notebookGuid} = $vals->{notebookGuid};
887 }
888 if (defined $vals->{tagGuids}) {
889 $self->{tagGuids} = $vals->{tagGuids};
890 }
891 if (defined $vals->{timeZone}) {
892 $self->{timeZone} = $vals->{timeZone};
893 }
894 if (defined $vals->{inactive}) {
895 $self->{inactive} = $vals->{inactive};
896 }
897 }
898 return bless ($self, $classname);
899 }
900  
901 sub getName {
902 return 'NoteFilter';
903 }
904  
905 sub read {
906 my ($self, $input) = @_;
907 my $xfer = 0;
908 my $fname;
909 my $ftype = 0;
910 my $fid = 0;
911 $xfer += $input->readStructBegin(\$fname);
912 while (1)
913 {
914 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
915 if ($ftype == TType::STOP) {
916 last;
917 }
918 SWITCH: for($fid)
919 {
920 /^1$/ && do{ if ($ftype == TType::I32) {
921 $xfer += $input->readI32(\$self->{order});
922 } else {
923 $xfer += $input->skip($ftype);
924 }
925 last; };
926 /^2$/ && do{ if ($ftype == TType::BOOL) {
927 $xfer += $input->readBool(\$self->{ascending});
928 } else {
929 $xfer += $input->skip($ftype);
930 }
931 last; };
932 /^3$/ && do{ if ($ftype == TType::STRING) {
933 $xfer += $input->readString(\$self->{words});
934 } else {
935 $xfer += $input->skip($ftype);
936 }
937 last; };
938 /^4$/ && do{ if ($ftype == TType::STRING) {
939 $xfer += $input->readString(\$self->{notebookGuid});
940 } else {
941 $xfer += $input->skip($ftype);
942 }
943 last; };
944 /^5$/ && do{ if ($ftype == TType::LIST) {
945 {
946 my $_size77 = 0;
947 $self->{tagGuids} = [];
948 my $_etype80 = 0;
949 $xfer += $input->readListBegin(\$_etype80, \$_size77);
950 for (my $_i81 = 0; $_i81 < $_size77; ++$_i81)
951 {
952 my $elem82 = undef;
953 $xfer += $input->readString(\$elem82);
954 push(@{$self->{tagGuids}},$elem82);
955 }
956 $xfer += $input->readListEnd();
957 }
958 } else {
959 $xfer += $input->skip($ftype);
960 }
961 last; };
962 /^6$/ && do{ if ($ftype == TType::STRING) {
963 $xfer += $input->readString(\$self->{timeZone});
964 } else {
965 $xfer += $input->skip($ftype);
966 }
967 last; };
968 /^7$/ && do{ if ($ftype == TType::BOOL) {
969 $xfer += $input->readBool(\$self->{inactive});
970 } else {
971 $xfer += $input->skip($ftype);
972 }
973 last; };
974 $xfer += $input->skip($ftype);
975 }
976 $xfer += $input->readFieldEnd();
977 }
978 $xfer += $input->readStructEnd();
979 return $xfer;
980 }
981  
982 sub write {
983 my ($self, $output) = @_;
984 my $xfer = 0;
985 $xfer += $output->writeStructBegin('NoteFilter');
986 if (defined $self->{order}) {
987 $xfer += $output->writeFieldBegin('order', TType::I32, 1);
988 $xfer += $output->writeI32($self->{order});
989 $xfer += $output->writeFieldEnd();
990 }
991 if (defined $self->{ascending}) {
992 $xfer += $output->writeFieldBegin('ascending', TType::BOOL, 2);
993 $xfer += $output->writeBool($self->{ascending});
994 $xfer += $output->writeFieldEnd();
995 }
996 if (defined $self->{words}) {
997 $xfer += $output->writeFieldBegin('words', TType::STRING, 3);
998 $xfer += $output->writeString($self->{words});
999 $xfer += $output->writeFieldEnd();
1000 }
1001 if (defined $self->{notebookGuid}) {
1002 $xfer += $output->writeFieldBegin('notebookGuid', TType::STRING, 4);
1003 $xfer += $output->writeString($self->{notebookGuid});
1004 $xfer += $output->writeFieldEnd();
1005 }
1006 if (defined $self->{tagGuids}) {
1007 $xfer += $output->writeFieldBegin('tagGuids', TType::LIST, 5);
1008 {
1009 $xfer += $output->writeListBegin(TType::STRING, scalar(@{$self->{tagGuids}}));
1010 {
1011 foreach my $iter83 (@{$self->{tagGuids}})
1012 {
1013 $xfer += $output->writeString($iter83);
1014 }
1015 }
1016 $xfer += $output->writeListEnd();
1017 }
1018 $xfer += $output->writeFieldEnd();
1019 }
1020 if (defined $self->{timeZone}) {
1021 $xfer += $output->writeFieldBegin('timeZone', TType::STRING, 6);
1022 $xfer += $output->writeString($self->{timeZone});
1023 $xfer += $output->writeFieldEnd();
1024 }
1025 if (defined $self->{inactive}) {
1026 $xfer += $output->writeFieldBegin('inactive', TType::BOOL, 7);
1027 $xfer += $output->writeBool($self->{inactive});
1028 $xfer += $output->writeFieldEnd();
1029 }
1030 $xfer += $output->writeFieldStop();
1031 $xfer += $output->writeStructEnd();
1032 return $xfer;
1033 }
1034  
1035 package Net::Evernote::EDAMNoteStore::NoteList;
1036 use base qw(Class::Accessor);
1037 Net::Evernote::EDAMNoteStore::NoteList->mk_accessors( qw( startIndex totalNotes notes stoppedWords searchedWords updateCount ) );
1038  
1039 sub new {
1040 my $classname = shift;
1041 my $self = {};
1042 my $vals = shift || {};
1043 $self->{startIndex} = undef;
1044 $self->{totalNotes} = undef;
1045 $self->{notes} = undef;
1046 $self->{stoppedWords} = undef;
1047 $self->{searchedWords} = undef;
1048 $self->{updateCount} = undef;
1049 if (UNIVERSAL::isa($vals,'HASH')) {
1050 if (defined $vals->{startIndex}) {
1051 $self->{startIndex} = $vals->{startIndex};
1052 }
1053 if (defined $vals->{totalNotes}) {
1054 $self->{totalNotes} = $vals->{totalNotes};
1055 }
1056 if (defined $vals->{notes}) {
1057 $self->{notes} = $vals->{notes};
1058 }
1059 if (defined $vals->{stoppedWords}) {
1060 $self->{stoppedWords} = $vals->{stoppedWords};
1061 }
1062 if (defined $vals->{searchedWords}) {
1063 $self->{searchedWords} = $vals->{searchedWords};
1064 }
1065 if (defined $vals->{updateCount}) {
1066 $self->{updateCount} = $vals->{updateCount};
1067 }
1068 }
1069 return bless ($self, $classname);
1070 }
1071  
1072 sub getName {
1073 return 'NoteList';
1074 }
1075  
1076 sub read {
1077 my ($self, $input) = @_;
1078 my $xfer = 0;
1079 my $fname;
1080 my $ftype = 0;
1081 my $fid = 0;
1082 $xfer += $input->readStructBegin(\$fname);
1083 while (1)
1084 {
1085 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
1086 if ($ftype == TType::STOP) {
1087 last;
1088 }
1089 SWITCH: for($fid)
1090 {
1091 /^1$/ && do{ if ($ftype == TType::I32) {
1092 $xfer += $input->readI32(\$self->{startIndex});
1093 } else {
1094 $xfer += $input->skip($ftype);
1095 }
1096 last; };
1097 /^2$/ && do{ if ($ftype == TType::I32) {
1098 $xfer += $input->readI32(\$self->{totalNotes});
1099 } else {
1100 $xfer += $input->skip($ftype);
1101 }
1102 last; };
1103 /^3$/ && do{ if ($ftype == TType::LIST) {
1104 {
1105 my $_size84 = 0;
1106 $self->{notes} = [];
1107 my $_etype87 = 0;
1108 $xfer += $input->readListBegin(\$_etype87, \$_size84);
1109 for (my $_i88 = 0; $_i88 < $_size84; ++$_i88)
1110 {
1111 my $elem89 = undef;
1112 $elem89 = Net::Evernote::EDAMTypes::Note->new();
1113 $xfer += $elem89->read($input);
1114 push(@{$self->{notes}},$elem89);
1115 }
1116 $xfer += $input->readListEnd();
1117 }
1118 } else {
1119 $xfer += $input->skip($ftype);
1120 }
1121 last; };
1122 /^4$/ && do{ if ($ftype == TType::LIST) {
1123 {
1124 my $_size90 = 0;
1125 $self->{stoppedWords} = [];
1126 my $_etype93 = 0;
1127 $xfer += $input->readListBegin(\$_etype93, \$_size90);
1128 for (my $_i94 = 0; $_i94 < $_size90; ++$_i94)
1129 {
1130 my $elem95 = undef;
1131 $xfer += $input->readString(\$elem95);
1132 push(@{$self->{stoppedWords}},$elem95);
1133 }
1134 $xfer += $input->readListEnd();
1135 }
1136 } else {
1137 $xfer += $input->skip($ftype);
1138 }
1139 last; };
1140 /^5$/ && do{ if ($ftype == TType::LIST) {
1141 {
1142 my $_size96 = 0;
1143 $self->{searchedWords} = [];
1144 my $_etype99 = 0;
1145 $xfer += $input->readListBegin(\$_etype99, \$_size96);
1146 for (my $_i100 = 0; $_i100 < $_size96; ++$_i100)
1147 {
1148 my $elem101 = undef;
1149 $xfer += $input->readString(\$elem101);
1150 push(@{$self->{searchedWords}},$elem101);
1151 }
1152 $xfer += $input->readListEnd();
1153 }
1154 } else {
1155 $xfer += $input->skip($ftype);
1156 }
1157 last; };
1158 /^6$/ && do{ if ($ftype == TType::I32) {
1159 $xfer += $input->readI32(\$self->{updateCount});
1160 } else {
1161 $xfer += $input->skip($ftype);
1162 }
1163 last; };
1164 $xfer += $input->skip($ftype);
1165 }
1166 $xfer += $input->readFieldEnd();
1167 }
1168 $xfer += $input->readStructEnd();
1169 return $xfer;
1170 }
1171  
1172 sub write {
1173 my ($self, $output) = @_;
1174 my $xfer = 0;
1175 $xfer += $output->writeStructBegin('NoteList');
1176 if (defined $self->{startIndex}) {
1177 $xfer += $output->writeFieldBegin('startIndex', TType::I32, 1);
1178 $xfer += $output->writeI32($self->{startIndex});
1179 $xfer += $output->writeFieldEnd();
1180 }
1181 if (defined $self->{totalNotes}) {
1182 $xfer += $output->writeFieldBegin('totalNotes', TType::I32, 2);
1183 $xfer += $output->writeI32($self->{totalNotes});
1184 $xfer += $output->writeFieldEnd();
1185 }
1186 if (defined $self->{notes}) {
1187 $xfer += $output->writeFieldBegin('notes', TType::LIST, 3);
1188 {
1189 $xfer += $output->writeListBegin(TType::STRUCT, scalar(@{$self->{notes}}));
1190 {
1191 foreach my $iter102 (@{$self->{notes}})
1192 {
1193 $xfer += ${iter102}->write($output);
1194 }
1195 }
1196 $xfer += $output->writeListEnd();
1197 }
1198 $xfer += $output->writeFieldEnd();
1199 }
1200 if (defined $self->{stoppedWords}) {
1201 $xfer += $output->writeFieldBegin('stoppedWords', TType::LIST, 4);
1202 {
1203 $xfer += $output->writeListBegin(TType::STRING, scalar(@{$self->{stoppedWords}}));
1204 {
1205 foreach my $iter103 (@{$self->{stoppedWords}})
1206 {
1207 $xfer += $output->writeString($iter103);
1208 }
1209 }
1210 $xfer += $output->writeListEnd();
1211 }
1212 $xfer += $output->writeFieldEnd();
1213 }
1214 if (defined $self->{searchedWords}) {
1215 $xfer += $output->writeFieldBegin('searchedWords', TType::LIST, 5);
1216 {
1217 $xfer += $output->writeListBegin(TType::STRING, scalar(@{$self->{searchedWords}}));
1218 {
1219 foreach my $iter104 (@{$self->{searchedWords}})
1220 {
1221 $xfer += $output->writeString($iter104);
1222 }
1223 }
1224 $xfer += $output->writeListEnd();
1225 }
1226 $xfer += $output->writeFieldEnd();
1227 }
1228 if (defined $self->{updateCount}) {
1229 $xfer += $output->writeFieldBegin('updateCount', TType::I32, 6);
1230 $xfer += $output->writeI32($self->{updateCount});
1231 $xfer += $output->writeFieldEnd();
1232 }
1233 $xfer += $output->writeFieldStop();
1234 $xfer += $output->writeStructEnd();
1235 return $xfer;
1236 }
1237  
1238 package Net::Evernote::EDAMNoteStore::NoteMetadata;
1239 use base qw(Class::Accessor);
1240 Net::Evernote::EDAMNoteStore::NoteMetadata->mk_accessors( qw( guid title contentLength created updated updateSequenceNum notebookGuid tagGuids attributes largestResourceMime largestResourceSize ) );
1241  
1242 sub new {
1243 my $classname = shift;
1244 my $self = {};
1245 my $vals = shift || {};
1246 $self->{guid} = undef;
1247 $self->{title} = undef;
1248 $self->{contentLength} = undef;
1249 $self->{created} = undef;
1250 $self->{updated} = undef;
1251 $self->{updateSequenceNum} = undef;
1252 $self->{notebookGuid} = undef;
1253 $self->{tagGuids} = undef;
1254 $self->{attributes} = undef;
1255 $self->{largestResourceMime} = undef;
1256 $self->{largestResourceSize} = undef;
1257 if (UNIVERSAL::isa($vals,'HASH')) {
1258 if (defined $vals->{guid}) {
1259 $self->{guid} = $vals->{guid};
1260 }
1261 if (defined $vals->{title}) {
1262 $self->{title} = $vals->{title};
1263 }
1264 if (defined $vals->{contentLength}) {
1265 $self->{contentLength} = $vals->{contentLength};
1266 }
1267 if (defined $vals->{created}) {
1268 $self->{created} = $vals->{created};
1269 }
1270 if (defined $vals->{updated}) {
1271 $self->{updated} = $vals->{updated};
1272 }
1273 if (defined $vals->{updateSequenceNum}) {
1274 $self->{updateSequenceNum} = $vals->{updateSequenceNum};
1275 }
1276 if (defined $vals->{notebookGuid}) {
1277 $self->{notebookGuid} = $vals->{notebookGuid};
1278 }
1279 if (defined $vals->{tagGuids}) {
1280 $self->{tagGuids} = $vals->{tagGuids};
1281 }
1282 if (defined $vals->{attributes}) {
1283 $self->{attributes} = $vals->{attributes};
1284 }
1285 if (defined $vals->{largestResourceMime}) {
1286 $self->{largestResourceMime} = $vals->{largestResourceMime};
1287 }
1288 if (defined $vals->{largestResourceSize}) {
1289 $self->{largestResourceSize} = $vals->{largestResourceSize};
1290 }
1291 }
1292 return bless ($self, $classname);
1293 }
1294  
1295 sub getName {
1296 return 'NoteMetadata';
1297 }
1298  
1299 sub read {
1300 my ($self, $input) = @_;
1301 my $xfer = 0;
1302 my $fname;
1303 my $ftype = 0;
1304 my $fid = 0;
1305 $xfer += $input->readStructBegin(\$fname);
1306 while (1)
1307 {
1308 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
1309 if ($ftype == TType::STOP) {
1310 last;
1311 }
1312 SWITCH: for($fid)
1313 {
1314 /^1$/ && do{ if ($ftype == TType::STRING) {
1315 $xfer += $input->readString(\$self->{guid});
1316 } else {
1317 $xfer += $input->skip($ftype);
1318 }
1319 last; };
1320 /^2$/ && do{ if ($ftype == TType::STRING) {
1321 $xfer += $input->readString(\$self->{title});
1322 } else {
1323 $xfer += $input->skip($ftype);
1324 }
1325 last; };
1326 /^5$/ && do{ if ($ftype == TType::I32) {
1327 $xfer += $input->readI32(\$self->{contentLength});
1328 } else {
1329 $xfer += $input->skip($ftype);
1330 }
1331 last; };
1332 /^6$/ && do{ if ($ftype == TType::I64) {
1333 $xfer += $input->readI64(\$self->{created});
1334 } else {
1335 $xfer += $input->skip($ftype);
1336 }
1337 last; };
1338 /^7$/ && do{ if ($ftype == TType::I64) {
1339 $xfer += $input->readI64(\$self->{updated});
1340 } else {
1341 $xfer += $input->skip($ftype);
1342 }
1343 last; };
1344 /^10$/ && do{ if ($ftype == TType::I32) {
1345 $xfer += $input->readI32(\$self->{updateSequenceNum});
1346 } else {
1347 $xfer += $input->skip($ftype);
1348 }
1349 last; };
1350 /^11$/ && do{ if ($ftype == TType::STRING) {
1351 $xfer += $input->readString(\$self->{notebookGuid});
1352 } else {
1353 $xfer += $input->skip($ftype);
1354 }
1355 last; };
1356 /^12$/ && do{ if ($ftype == TType::LIST) {
1357 {
1358 my $_size105 = 0;
1359 $self->{tagGuids} = [];
1360 my $_etype108 = 0;
1361 $xfer += $input->readListBegin(\$_etype108, \$_size105);
1362 for (my $_i109 = 0; $_i109 < $_size105; ++$_i109)
1363 {
1364 my $elem110 = undef;
1365 $xfer += $input->readString(\$elem110);
1366 push(@{$self->{tagGuids}},$elem110);
1367 }
1368 $xfer += $input->readListEnd();
1369 }
1370 } else {
1371 $xfer += $input->skip($ftype);
1372 }
1373 last; };
1374 /^14$/ && do{ if ($ftype == TType::STRUCT) {
1375 $self->{attributes} = Net::Evernote::EDAMTypes::NoteAttributes->new();
1376 $xfer += $self->{attributes}->read($input);
1377 } else {
1378 $xfer += $input->skip($ftype);
1379 }
1380 last; };
1381 /^20$/ && do{ if ($ftype == TType::STRING) {
1382 $xfer += $input->readString(\$self->{largestResourceMime});
1383 } else {
1384 $xfer += $input->skip($ftype);
1385 }
1386 last; };
1387 /^21$/ && do{ if ($ftype == TType::I32) {
1388 $xfer += $input->readI32(\$self->{largestResourceSize});
1389 } else {
1390 $xfer += $input->skip($ftype);
1391 }
1392 last; };
1393 $xfer += $input->skip($ftype);
1394 }
1395 $xfer += $input->readFieldEnd();
1396 }
1397 $xfer += $input->readStructEnd();
1398 return $xfer;
1399 }
1400  
1401 sub write {
1402 my ($self, $output) = @_;
1403 my $xfer = 0;
1404 $xfer += $output->writeStructBegin('NoteMetadata');
1405 if (defined $self->{guid}) {
1406 $xfer += $output->writeFieldBegin('guid', TType::STRING, 1);
1407 $xfer += $output->writeString($self->{guid});
1408 $xfer += $output->writeFieldEnd();
1409 }
1410 if (defined $self->{title}) {
1411 $xfer += $output->writeFieldBegin('title', TType::STRING, 2);
1412 $xfer += $output->writeString($self->{title});
1413 $xfer += $output->writeFieldEnd();
1414 }
1415 if (defined $self->{contentLength}) {
1416 $xfer += $output->writeFieldBegin('contentLength', TType::I32, 5);
1417 $xfer += $output->writeI32($self->{contentLength});
1418 $xfer += $output->writeFieldEnd();
1419 }
1420 if (defined $self->{created}) {
1421 $xfer += $output->writeFieldBegin('created', TType::I64, 6);
1422 $xfer += $output->writeI64($self->{created});
1423 $xfer += $output->writeFieldEnd();
1424 }
1425 if (defined $self->{updated}) {
1426 $xfer += $output->writeFieldBegin('updated', TType::I64, 7);
1427 $xfer += $output->writeI64($self->{updated});
1428 $xfer += $output->writeFieldEnd();
1429 }
1430 if (defined $self->{updateSequenceNum}) {
1431 $xfer += $output->writeFieldBegin('updateSequenceNum', TType::I32, 10);
1432 $xfer += $output->writeI32($self->{updateSequenceNum});
1433 $xfer += $output->writeFieldEnd();
1434 }
1435 if (defined $self->{notebookGuid}) {
1436 $xfer += $output->writeFieldBegin('notebookGuid', TType::STRING, 11);
1437 $xfer += $output->writeString($self->{notebookGuid});
1438 $xfer += $output->writeFieldEnd();
1439 }
1440 if (defined $self->{tagGuids}) {
1441 $xfer += $output->writeFieldBegin('tagGuids', TType::LIST, 12);
1442 {
1443 $xfer += $output->writeListBegin(TType::STRING, scalar(@{$self->{tagGuids}}));
1444 {
1445 foreach my $iter111 (@{$self->{tagGuids}})
1446 {
1447 $xfer += $output->writeString($iter111);
1448 }
1449 }
1450 $xfer += $output->writeListEnd();
1451 }
1452 $xfer += $output->writeFieldEnd();
1453 }
1454 if (defined $self->{attributes}) {
1455 $xfer += $output->writeFieldBegin('attributes', TType::STRUCT, 14);
1456 $xfer += $self->{attributes}->write($output);
1457 $xfer += $output->writeFieldEnd();
1458 }
1459 if (defined $self->{largestResourceMime}) {
1460 $xfer += $output->writeFieldBegin('largestResourceMime', TType::STRING, 20);
1461 $xfer += $output->writeString($self->{largestResourceMime});
1462 $xfer += $output->writeFieldEnd();
1463 }
1464 if (defined $self->{largestResourceSize}) {
1465 $xfer += $output->writeFieldBegin('largestResourceSize', TType::I32, 21);
1466 $xfer += $output->writeI32($self->{largestResourceSize});
1467 $xfer += $output->writeFieldEnd();
1468 }
1469 $xfer += $output->writeFieldStop();
1470 $xfer += $output->writeStructEnd();
1471 return $xfer;
1472 }
1473  
1474 package Net::Evernote::EDAMNoteStore::NotesMetadataList;
1475 use base qw(Class::Accessor);
1476 Net::Evernote::EDAMNoteStore::NotesMetadataList->mk_accessors( qw( startIndex totalNotes notes stoppedWords searchedWords updateCount ) );
1477  
1478 sub new {
1479 my $classname = shift;
1480 my $self = {};
1481 my $vals = shift || {};
1482 $self->{startIndex} = undef;
1483 $self->{totalNotes} = undef;
1484 $self->{notes} = undef;
1485 $self->{stoppedWords} = undef;
1486 $self->{searchedWords} = undef;
1487 $self->{updateCount} = undef;
1488 if (UNIVERSAL::isa($vals,'HASH')) {
1489 if (defined $vals->{startIndex}) {
1490 $self->{startIndex} = $vals->{startIndex};
1491 }
1492 if (defined $vals->{totalNotes}) {
1493 $self->{totalNotes} = $vals->{totalNotes};
1494 }
1495 if (defined $vals->{notes}) {
1496 $self->{notes} = $vals->{notes};
1497 }
1498 if (defined $vals->{stoppedWords}) {
1499 $self->{stoppedWords} = $vals->{stoppedWords};
1500 }
1501 if (defined $vals->{searchedWords}) {
1502 $self->{searchedWords} = $vals->{searchedWords};
1503 }
1504 if (defined $vals->{updateCount}) {
1505 $self->{updateCount} = $vals->{updateCount};
1506 }
1507 }
1508 return bless ($self, $classname);
1509 }
1510  
1511 sub getName {
1512 return 'NotesMetadataList';
1513 }
1514  
1515 sub read {
1516 my ($self, $input) = @_;
1517 my $xfer = 0;
1518 my $fname;
1519 my $ftype = 0;
1520 my $fid = 0;
1521 $xfer += $input->readStructBegin(\$fname);
1522 while (1)
1523 {
1524 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
1525 if ($ftype == TType::STOP) {
1526 last;
1527 }
1528 SWITCH: for($fid)
1529 {
1530 /^1$/ && do{ if ($ftype == TType::I32) {
1531 $xfer += $input->readI32(\$self->{startIndex});
1532 } else {
1533 $xfer += $input->skip($ftype);
1534 }
1535 last; };
1536 /^2$/ && do{ if ($ftype == TType::I32) {
1537 $xfer += $input->readI32(\$self->{totalNotes});
1538 } else {
1539 $xfer += $input->skip($ftype);
1540 }
1541 last; };
1542 /^3$/ && do{ if ($ftype == TType::LIST) {
1543 {
1544 my $_size112 = 0;
1545 $self->{notes} = [];
1546 my $_etype115 = 0;
1547 $xfer += $input->readListBegin(\$_etype115, \$_size112);
1548 for (my $_i116 = 0; $_i116 < $_size112; ++$_i116)
1549 {
1550 my $elem117 = undef;
1551 $elem117 = Net::Evernote::EDAMNoteStore::NoteMetadata->new();
1552 $xfer += $elem117->read($input);
1553 push(@{$self->{notes}},$elem117);
1554 }
1555 $xfer += $input->readListEnd();
1556 }
1557 } else {
1558 $xfer += $input->skip($ftype);
1559 }
1560 last; };
1561 /^4$/ && do{ if ($ftype == TType::LIST) {
1562 {
1563 my $_size118 = 0;
1564 $self->{stoppedWords} = [];
1565 my $_etype121 = 0;
1566 $xfer += $input->readListBegin(\$_etype121, \$_size118);
1567 for (my $_i122 = 0; $_i122 < $_size118; ++$_i122)
1568 {
1569 my $elem123 = undef;
1570 $xfer += $input->readString(\$elem123);
1571 push(@{$self->{stoppedWords}},$elem123);
1572 }
1573 $xfer += $input->readListEnd();
1574 }
1575 } else {
1576 $xfer += $input->skip($ftype);
1577 }
1578 last; };
1579 /^5$/ && do{ if ($ftype == TType::LIST) {
1580 {
1581 my $_size124 = 0;
1582 $self->{searchedWords} = [];
1583 my $_etype127 = 0;
1584 $xfer += $input->readListBegin(\$_etype127, \$_size124);
1585 for (my $_i128 = 0; $_i128 < $_size124; ++$_i128)
1586 {
1587 my $elem129 = undef;
1588 $xfer += $input->readString(\$elem129);
1589 push(@{$self->{searchedWords}},$elem129);
1590 }
1591 $xfer += $input->readListEnd();
1592 }
1593 } else {
1594 $xfer += $input->skip($ftype);
1595 }
1596 last; };
1597 /^6$/ && do{ if ($ftype == TType::I32) {
1598 $xfer += $input->readI32(\$self->{updateCount});
1599 } else {
1600 $xfer += $input->skip($ftype);
1601 }
1602 last; };
1603 $xfer += $input->skip($ftype);
1604 }
1605 $xfer += $input->readFieldEnd();
1606 }
1607 $xfer += $input->readStructEnd();
1608 return $xfer;
1609 }
1610  
1611 sub write {
1612 my ($self, $output) = @_;
1613 my $xfer = 0;
1614 $xfer += $output->writeStructBegin('NotesMetadataList');
1615 if (defined $self->{startIndex}) {
1616 $xfer += $output->writeFieldBegin('startIndex', TType::I32, 1);
1617 $xfer += $output->writeI32($self->{startIndex});
1618 $xfer += $output->writeFieldEnd();
1619 }
1620 if (defined $self->{totalNotes}) {
1621 $xfer += $output->writeFieldBegin('totalNotes', TType::I32, 2);
1622 $xfer += $output->writeI32($self->{totalNotes});
1623 $xfer += $output->writeFieldEnd();
1624 }
1625 if (defined $self->{notes}) {
1626 $xfer += $output->writeFieldBegin('notes', TType::LIST, 3);
1627 {
1628 $xfer += $output->writeListBegin(TType::STRUCT, scalar(@{$self->{notes}}));
1629 {
1630 foreach my $iter130 (@{$self->{notes}})
1631 {
1632 $xfer += ${iter130}->write($output);
1633 }
1634 }
1635 $xfer += $output->writeListEnd();
1636 }
1637 $xfer += $output->writeFieldEnd();
1638 }
1639 if (defined $self->{stoppedWords}) {
1640 $xfer += $output->writeFieldBegin('stoppedWords', TType::LIST, 4);
1641 {
1642 $xfer += $output->writeListBegin(TType::STRING, scalar(@{$self->{stoppedWords}}));
1643 {
1644 foreach my $iter131 (@{$self->{stoppedWords}})
1645 {
1646 $xfer += $output->writeString($iter131);
1647 }
1648 }
1649 $xfer += $output->writeListEnd();
1650 }
1651 $xfer += $output->writeFieldEnd();
1652 }
1653 if (defined $self->{searchedWords}) {
1654 $xfer += $output->writeFieldBegin('searchedWords', TType::LIST, 5);
1655 {
1656 $xfer += $output->writeListBegin(TType::STRING, scalar(@{$self->{searchedWords}}));
1657 {
1658 foreach my $iter132 (@{$self->{searchedWords}})
1659 {
1660 $xfer += $output->writeString($iter132);
1661 }
1662 }
1663 $xfer += $output->writeListEnd();
1664 }
1665 $xfer += $output->writeFieldEnd();
1666 }
1667 if (defined $self->{updateCount}) {
1668 $xfer += $output->writeFieldBegin('updateCount', TType::I32, 6);
1669 $xfer += $output->writeI32($self->{updateCount});
1670 $xfer += $output->writeFieldEnd();
1671 }
1672 $xfer += $output->writeFieldStop();
1673 $xfer += $output->writeStructEnd();
1674 return $xfer;
1675 }
1676  
1677 package Net::Evernote::EDAMNoteStore::NotesMetadataResultSpec;
1678 use base qw(Class::Accessor);
1679 Net::Evernote::EDAMNoteStore::NotesMetadataResultSpec->mk_accessors( qw( includeTitle includeContentLength includeCreated includeUpdated includeUpdateSequenceNum includeNotebookGuid includeTagGuids includeAttributes includeLargestResourceMime includeLargestResourceSize ) );
1680  
1681 sub new {
1682 my $classname = shift;
1683 my $self = {};
1684 my $vals = shift || {};
1685 $self->{includeTitle} = undef;
1686 $self->{includeContentLength} = undef;
1687 $self->{includeCreated} = undef;
1688 $self->{includeUpdated} = undef;
1689 $self->{includeUpdateSequenceNum} = undef;
1690 $self->{includeNotebookGuid} = undef;
1691 $self->{includeTagGuids} = undef;
1692 $self->{includeAttributes} = undef;
1693 $self->{includeLargestResourceMime} = undef;
1694 $self->{includeLargestResourceSize} = undef;
1695 if (UNIVERSAL::isa($vals,'HASH')) {
1696 if (defined $vals->{includeTitle}) {
1697 $self->{includeTitle} = $vals->{includeTitle};
1698 }
1699 if (defined $vals->{includeContentLength}) {
1700 $self->{includeContentLength} = $vals->{includeContentLength};
1701 }
1702 if (defined $vals->{includeCreated}) {
1703 $self->{includeCreated} = $vals->{includeCreated};
1704 }
1705 if (defined $vals->{includeUpdated}) {
1706 $self->{includeUpdated} = $vals->{includeUpdated};
1707 }
1708 if (defined $vals->{includeUpdateSequenceNum}) {
1709 $self->{includeUpdateSequenceNum} = $vals->{includeUpdateSequenceNum};
1710 }
1711 if (defined $vals->{includeNotebookGuid}) {
1712 $self->{includeNotebookGuid} = $vals->{includeNotebookGuid};
1713 }
1714 if (defined $vals->{includeTagGuids}) {
1715 $self->{includeTagGuids} = $vals->{includeTagGuids};
1716 }
1717 if (defined $vals->{includeAttributes}) {
1718 $self->{includeAttributes} = $vals->{includeAttributes};
1719 }
1720 if (defined $vals->{includeLargestResourceMime}) {
1721 $self->{includeLargestResourceMime} = $vals->{includeLargestResourceMime};
1722 }
1723 if (defined $vals->{includeLargestResourceSize}) {
1724 $self->{includeLargestResourceSize} = $vals->{includeLargestResourceSize};
1725 }
1726 }
1727 return bless ($self, $classname);
1728 }
1729  
1730 sub getName {
1731 return 'NotesMetadataResultSpec';
1732 }
1733  
1734 sub read {
1735 my ($self, $input) = @_;
1736 my $xfer = 0;
1737 my $fname;
1738 my $ftype = 0;
1739 my $fid = 0;
1740 $xfer += $input->readStructBegin(\$fname);
1741 while (1)
1742 {
1743 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
1744 if ($ftype == TType::STOP) {
1745 last;
1746 }
1747 SWITCH: for($fid)
1748 {
1749 /^2$/ && do{ if ($ftype == TType::BOOL) {
1750 $xfer += $input->readBool(\$self->{includeTitle});
1751 } else {
1752 $xfer += $input->skip($ftype);
1753 }
1754 last; };
1755 /^5$/ && do{ if ($ftype == TType::BOOL) {
1756 $xfer += $input->readBool(\$self->{includeContentLength});
1757 } else {
1758 $xfer += $input->skip($ftype);
1759 }
1760 last; };
1761 /^6$/ && do{ if ($ftype == TType::BOOL) {
1762 $xfer += $input->readBool(\$self->{includeCreated});
1763 } else {
1764 $xfer += $input->skip($ftype);
1765 }
1766 last; };
1767 /^7$/ && do{ if ($ftype == TType::BOOL) {
1768 $xfer += $input->readBool(\$self->{includeUpdated});
1769 } else {
1770 $xfer += $input->skip($ftype);
1771 }
1772 last; };
1773 /^10$/ && do{ if ($ftype == TType::BOOL) {
1774 $xfer += $input->readBool(\$self->{includeUpdateSequenceNum});
1775 } else {
1776 $xfer += $input->skip($ftype);
1777 }
1778 last; };
1779 /^11$/ && do{ if ($ftype == TType::BOOL) {
1780 $xfer += $input->readBool(\$self->{includeNotebookGuid});
1781 } else {
1782 $xfer += $input->skip($ftype);
1783 }
1784 last; };
1785 /^12$/ && do{ if ($ftype == TType::BOOL) {
1786 $xfer += $input->readBool(\$self->{includeTagGuids});
1787 } else {
1788 $xfer += $input->skip($ftype);
1789 }
1790 last; };
1791 /^14$/ && do{ if ($ftype == TType::BOOL) {
1792 $xfer += $input->readBool(\$self->{includeAttributes});
1793 } else {
1794 $xfer += $input->skip($ftype);
1795 }
1796 last; };
1797 /^20$/ && do{ if ($ftype == TType::BOOL) {
1798 $xfer += $input->readBool(\$self->{includeLargestResourceMime});
1799 } else {
1800 $xfer += $input->skip($ftype);
1801 }
1802 last; };
1803 /^21$/ && do{ if ($ftype == TType::BOOL) {
1804 $xfer += $input->readBool(\$self->{includeLargestResourceSize});
1805 } else {
1806 $xfer += $input->skip($ftype);
1807 }
1808 last; };
1809 $xfer += $input->skip($ftype);
1810 }
1811 $xfer += $input->readFieldEnd();
1812 }
1813 $xfer += $input->readStructEnd();
1814 return $xfer;
1815 }
1816  
1817 sub write {
1818 my ($self, $output) = @_;
1819 my $xfer = 0;
1820 $xfer += $output->writeStructBegin('NotesMetadataResultSpec');
1821 if (defined $self->{includeTitle}) {
1822 $xfer += $output->writeFieldBegin('includeTitle', TType::BOOL, 2);
1823 $xfer += $output->writeBool($self->{includeTitle});
1824 $xfer += $output->writeFieldEnd();
1825 }
1826 if (defined $self->{includeContentLength}) {
1827 $xfer += $output->writeFieldBegin('includeContentLength', TType::BOOL, 5);
1828 $xfer += $output->writeBool($self->{includeContentLength});
1829 $xfer += $output->writeFieldEnd();
1830 }
1831 if (defined $self->{includeCreated}) {
1832 $xfer += $output->writeFieldBegin('includeCreated', TType::BOOL, 6);
1833 $xfer += $output->writeBool($self->{includeCreated});
1834 $xfer += $output->writeFieldEnd();
1835 }
1836 if (defined $self->{includeUpdated}) {
1837 $xfer += $output->writeFieldBegin('includeUpdated', TType::BOOL, 7);
1838 $xfer += $output->writeBool($self->{includeUpdated});
1839 $xfer += $output->writeFieldEnd();
1840 }
1841 if (defined $self->{includeUpdateSequenceNum}) {
1842 $xfer += $output->writeFieldBegin('includeUpdateSequenceNum', TType::BOOL, 10);
1843 $xfer += $output->writeBool($self->{includeUpdateSequenceNum});
1844 $xfer += $output->writeFieldEnd();
1845 }
1846 if (defined $self->{includeNotebookGuid}) {
1847 $xfer += $output->writeFieldBegin('includeNotebookGuid', TType::BOOL, 11);
1848 $xfer += $output->writeBool($self->{includeNotebookGuid});
1849 $xfer += $output->writeFieldEnd();
1850 }
1851 if (defined $self->{includeTagGuids}) {
1852 $xfer += $output->writeFieldBegin('includeTagGuids', TType::BOOL, 12);
1853 $xfer += $output->writeBool($self->{includeTagGuids});
1854 $xfer += $output->writeFieldEnd();
1855 }
1856 if (defined $self->{includeAttributes}) {
1857 $xfer += $output->writeFieldBegin('includeAttributes', TType::BOOL, 14);
1858 $xfer += $output->writeBool($self->{includeAttributes});
1859 $xfer += $output->writeFieldEnd();
1860 }
1861 if (defined $self->{includeLargestResourceMime}) {
1862 $xfer += $output->writeFieldBegin('includeLargestResourceMime', TType::BOOL, 20);
1863 $xfer += $output->writeBool($self->{includeLargestResourceMime});
1864 $xfer += $output->writeFieldEnd();
1865 }
1866 if (defined $self->{includeLargestResourceSize}) {
1867 $xfer += $output->writeFieldBegin('includeLargestResourceSize', TType::BOOL, 21);
1868 $xfer += $output->writeBool($self->{includeLargestResourceSize});
1869 $xfer += $output->writeFieldEnd();
1870 }
1871 $xfer += $output->writeFieldStop();
1872 $xfer += $output->writeStructEnd();
1873 return $xfer;
1874 }
1875  
1876 package Net::Evernote::EDAMNoteStore::NoteCollectionCounts;
1877 use base qw(Class::Accessor);
1878 Net::Evernote::EDAMNoteStore::NoteCollectionCounts->mk_accessors( qw( notebookCounts tagCounts trashCount ) );
1879  
1880 sub new {
1881 my $classname = shift;
1882 my $self = {};
1883 my $vals = shift || {};
1884 $self->{notebookCounts} = undef;
1885 $self->{tagCounts} = undef;
1886 $self->{trashCount} = undef;
1887 if (UNIVERSAL::isa($vals,'HASH')) {
1888 if (defined $vals->{notebookCounts}) {
1889 $self->{notebookCounts} = $vals->{notebookCounts};
1890 }
1891 if (defined $vals->{tagCounts}) {
1892 $self->{tagCounts} = $vals->{tagCounts};
1893 }
1894 if (defined $vals->{trashCount}) {
1895 $self->{trashCount} = $vals->{trashCount};
1896 }
1897 }
1898 return bless ($self, $classname);
1899 }
1900  
1901 sub getName {
1902 return 'NoteCollectionCounts';
1903 }
1904  
1905 sub read {
1906 my ($self, $input) = @_;
1907 my $xfer = 0;
1908 my $fname;
1909 my $ftype = 0;
1910 my $fid = 0;
1911 $xfer += $input->readStructBegin(\$fname);
1912 while (1)
1913 {
1914 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
1915 if ($ftype == TType::STOP) {
1916 last;
1917 }
1918 SWITCH: for($fid)
1919 {
1920 /^1$/ && do{ if ($ftype == TType::MAP) {
1921 {
1922 my $_size133 = 0;
1923 $self->{notebookCounts} = {};
1924 my $_ktype134 = 0;
1925 my $_vtype135 = 0;
1926 $xfer += $input->readMapBegin(\$_ktype134, \$_vtype135, \$_size133);
1927 for (my $_i137 = 0; $_i137 < $_size133; ++$_i137)
1928 {
1929 my $key138 = '';
1930 my $val139 = 0;
1931 $xfer += $input->readString(\$key138);
1932 $xfer += $input->readI32(\$val139);
1933 $self->{notebookCounts}->{$key138} = $val139;
1934 }
1935 $xfer += $input->readMapEnd();
1936 }
1937 } else {
1938 $xfer += $input->skip($ftype);
1939 }
1940 last; };
1941 /^2$/ && do{ if ($ftype == TType::MAP) {
1942 {
1943 my $_size140 = 0;
1944 $self->{tagCounts} = {};
1945 my $_ktype141 = 0;
1946 my $_vtype142 = 0;
1947 $xfer += $input->readMapBegin(\$_ktype141, \$_vtype142, \$_size140);
1948 for (my $_i144 = 0; $_i144 < $_size140; ++$_i144)
1949 {
1950 my $key145 = '';
1951 my $val146 = 0;
1952 $xfer += $input->readString(\$key145);
1953 $xfer += $input->readI32(\$val146);
1954 $self->{tagCounts}->{$key145} = $val146;
1955 }
1956 $xfer += $input->readMapEnd();
1957 }
1958 } else {
1959 $xfer += $input->skip($ftype);
1960 }
1961 last; };
1962 /^3$/ && do{ if ($ftype == TType::I32) {
1963 $xfer += $input->readI32(\$self->{trashCount});
1964 } else {
1965 $xfer += $input->skip($ftype);
1966 }
1967 last; };
1968 $xfer += $input->skip($ftype);
1969 }
1970 $xfer += $input->readFieldEnd();
1971 }
1972 $xfer += $input->readStructEnd();
1973 return $xfer;
1974 }
1975  
1976 sub write {
1977 my ($self, $output) = @_;
1978 my $xfer = 0;
1979 $xfer += $output->writeStructBegin('NoteCollectionCounts');
1980 if (defined $self->{notebookCounts}) {
1981 $xfer += $output->writeFieldBegin('notebookCounts', TType::MAP, 1);
1982 {
1983 $xfer += $output->writeMapBegin(TType::STRING, TType::I32, scalar(keys %{$self->{notebookCounts}}));
1984 {
1985 while( my ($kiter147,$viter148) = each %{$self->{notebookCounts}})
1986 {
1987 $xfer += $output->writeString($kiter147);
1988 $xfer += $output->writeI32($viter148);
1989 }
1990 }
1991 $xfer += $output->writeMapEnd();
1992 }
1993 $xfer += $output->writeFieldEnd();
1994 }
1995 if (defined $self->{tagCounts}) {
1996 $xfer += $output->writeFieldBegin('tagCounts', TType::MAP, 2);
1997 {
1998 $xfer += $output->writeMapBegin(TType::STRING, TType::I32, scalar(keys %{$self->{tagCounts}}));
1999 {
2000 while( my ($kiter149,$viter150) = each %{$self->{tagCounts}})
2001 {
2002 $xfer += $output->writeString($kiter149);
2003 $xfer += $output->writeI32($viter150);
2004 }
2005 }
2006 $xfer += $output->writeMapEnd();
2007 }
2008 $xfer += $output->writeFieldEnd();
2009 }
2010 if (defined $self->{trashCount}) {
2011 $xfer += $output->writeFieldBegin('trashCount', TType::I32, 3);
2012 $xfer += $output->writeI32($self->{trashCount});
2013 $xfer += $output->writeFieldEnd();
2014 }
2015 $xfer += $output->writeFieldStop();
2016 $xfer += $output->writeStructEnd();
2017 return $xfer;
2018 }
2019  
2020 package Net::Evernote::EDAMNoteStore::AdImpressions;
2021 use base qw(Class::Accessor);
2022 Net::Evernote::EDAMNoteStore::AdImpressions->mk_accessors( qw( adId impressionCount impressionTime ) );
2023  
2024 sub new {
2025 my $classname = shift;
2026 my $self = {};
2027 my $vals = shift || {};
2028 $self->{adId} = undef;
2029 $self->{impressionCount} = undef;
2030 $self->{impressionTime} = undef;
2031 if (UNIVERSAL::isa($vals,'HASH')) {
2032 if (defined $vals->{adId}) {
2033 $self->{adId} = $vals->{adId};
2034 }
2035 if (defined $vals->{impressionCount}) {
2036 $self->{impressionCount} = $vals->{impressionCount};
2037 }
2038 if (defined $vals->{impressionTime}) {
2039 $self->{impressionTime} = $vals->{impressionTime};
2040 }
2041 }
2042 return bless ($self, $classname);
2043 }
2044  
2045 sub getName {
2046 return 'AdImpressions';
2047 }
2048  
2049 sub read {
2050 my ($self, $input) = @_;
2051 my $xfer = 0;
2052 my $fname;
2053 my $ftype = 0;
2054 my $fid = 0;
2055 $xfer += $input->readStructBegin(\$fname);
2056 while (1)
2057 {
2058 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
2059 if ($ftype == TType::STOP) {
2060 last;
2061 }
2062 SWITCH: for($fid)
2063 {
2064 /^1$/ && do{ if ($ftype == TType::I32) {
2065 $xfer += $input->readI32(\$self->{adId});
2066 } else {
2067 $xfer += $input->skip($ftype);
2068 }
2069 last; };
2070 /^2$/ && do{ if ($ftype == TType::I32) {
2071 $xfer += $input->readI32(\$self->{impressionCount});
2072 } else {
2073 $xfer += $input->skip($ftype);
2074 }
2075 last; };
2076 /^3$/ && do{ if ($ftype == TType::I32) {
2077 $xfer += $input->readI32(\$self->{impressionTime});
2078 } else {
2079 $xfer += $input->skip($ftype);
2080 }
2081 last; };
2082 $xfer += $input->skip($ftype);
2083 }
2084 $xfer += $input->readFieldEnd();
2085 }
2086 $xfer += $input->readStructEnd();
2087 return $xfer;
2088 }
2089  
2090 sub write {
2091 my ($self, $output) = @_;
2092 my $xfer = 0;
2093 $xfer += $output->writeStructBegin('AdImpressions');
2094 if (defined $self->{adId}) {
2095 $xfer += $output->writeFieldBegin('adId', TType::I32, 1);
2096 $xfer += $output->writeI32($self->{adId});
2097 $xfer += $output->writeFieldEnd();
2098 }
2099 if (defined $self->{impressionCount}) {
2100 $xfer += $output->writeFieldBegin('impressionCount', TType::I32, 2);
2101 $xfer += $output->writeI32($self->{impressionCount});
2102 $xfer += $output->writeFieldEnd();
2103 }
2104 if (defined $self->{impressionTime}) {
2105 $xfer += $output->writeFieldBegin('impressionTime', TType::I32, 3);
2106 $xfer += $output->writeI32($self->{impressionTime});
2107 $xfer += $output->writeFieldEnd();
2108 }
2109 $xfer += $output->writeFieldStop();
2110 $xfer += $output->writeStructEnd();
2111 return $xfer;
2112 }
2113  
2114 package Net::Evernote::EDAMNoteStore::AdParameters;
2115 use base qw(Class::Accessor);
2116 Net::Evernote::EDAMNoteStore::AdParameters->mk_accessors( qw( clientLanguage impressions supportHtml clientProperties ) );
2117  
2118 sub new {
2119 my $classname = shift;
2120 my $self = {};
2121 my $vals = shift || {};
2122 $self->{clientLanguage} = undef;
2123 $self->{impressions} = undef;
2124 $self->{supportHtml} = undef;
2125 $self->{clientProperties} = undef;
2126 if (UNIVERSAL::isa($vals,'HASH')) {
2127 if (defined $vals->{clientLanguage}) {
2128 $self->{clientLanguage} = $vals->{clientLanguage};
2129 }
2130 if (defined $vals->{impressions}) {
2131 $self->{impressions} = $vals->{impressions};
2132 }
2133 if (defined $vals->{supportHtml}) {
2134 $self->{supportHtml} = $vals->{supportHtml};
2135 }
2136 if (defined $vals->{clientProperties}) {
2137 $self->{clientProperties} = $vals->{clientProperties};
2138 }
2139 }
2140 return bless ($self, $classname);
2141 }
2142  
2143 sub getName {
2144 return 'AdParameters';
2145 }
2146  
2147 sub read {
2148 my ($self, $input) = @_;
2149 my $xfer = 0;
2150 my $fname;
2151 my $ftype = 0;
2152 my $fid = 0;
2153 $xfer += $input->readStructBegin(\$fname);
2154 while (1)
2155 {
2156 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
2157 if ($ftype == TType::STOP) {
2158 last;
2159 }
2160 SWITCH: for($fid)
2161 {
2162 /^2$/ && do{ if ($ftype == TType::STRING) {
2163 $xfer += $input->readString(\$self->{clientLanguage});
2164 } else {
2165 $xfer += $input->skip($ftype);
2166 }
2167 last; };
2168 /^4$/ && do{ if ($ftype == TType::LIST) {
2169 {
2170 my $_size151 = 0;
2171 $self->{impressions} = [];
2172 my $_etype154 = 0;
2173 $xfer += $input->readListBegin(\$_etype154, \$_size151);
2174 for (my $_i155 = 0; $_i155 < $_size151; ++$_i155)
2175 {
2176 my $elem156 = undef;
2177 $elem156 = Net::Evernote::EDAMNoteStore::AdImpressions->new();
2178 $xfer += $elem156->read($input);
2179 push(@{$self->{impressions}},$elem156);
2180 }
2181 $xfer += $input->readListEnd();
2182 }
2183 } else {
2184 $xfer += $input->skip($ftype);
2185 }
2186 last; };
2187 /^5$/ && do{ if ($ftype == TType::BOOL) {
2188 $xfer += $input->readBool(\$self->{supportHtml});
2189 } else {
2190 $xfer += $input->skip($ftype);
2191 }
2192 last; };
2193 /^6$/ && do{ if ($ftype == TType::MAP) {
2194 {
2195 my $_size157 = 0;
2196 $self->{clientProperties} = {};
2197 my $_ktype158 = 0;
2198 my $_vtype159 = 0;
2199 $xfer += $input->readMapBegin(\$_ktype158, \$_vtype159, \$_size157);
2200 for (my $_i161 = 0; $_i161 < $_size157; ++$_i161)
2201 {
2202 my $key162 = '';
2203 my $val163 = '';
2204 $xfer += $input->readString(\$key162);
2205 $xfer += $input->readString(\$val163);
2206 $self->{clientProperties}->{$key162} = $val163;
2207 }
2208 $xfer += $input->readMapEnd();
2209 }
2210 } else {
2211 $xfer += $input->skip($ftype);
2212 }
2213 last; };
2214 $xfer += $input->skip($ftype);
2215 }
2216 $xfer += $input->readFieldEnd();
2217 }
2218 $xfer += $input->readStructEnd();
2219 return $xfer;
2220 }
2221  
2222 sub write {
2223 my ($self, $output) = @_;
2224 my $xfer = 0;
2225 $xfer += $output->writeStructBegin('AdParameters');
2226 if (defined $self->{clientLanguage}) {
2227 $xfer += $output->writeFieldBegin('clientLanguage', TType::STRING, 2);
2228 $xfer += $output->writeString($self->{clientLanguage});
2229 $xfer += $output->writeFieldEnd();
2230 }
2231 if (defined $self->{impressions}) {
2232 $xfer += $output->writeFieldBegin('impressions', TType::LIST, 4);
2233 {
2234 $xfer += $output->writeListBegin(TType::STRUCT, scalar(@{$self->{impressions}}));
2235 {
2236 foreach my $iter164 (@{$self->{impressions}})
2237 {
2238 $xfer += ${iter164}->write($output);
2239 }
2240 }
2241 $xfer += $output->writeListEnd();
2242 }
2243 $xfer += $output->writeFieldEnd();
2244 }
2245 if (defined $self->{supportHtml}) {
2246 $xfer += $output->writeFieldBegin('supportHtml', TType::BOOL, 5);
2247 $xfer += $output->writeBool($self->{supportHtml});
2248 $xfer += $output->writeFieldEnd();
2249 }
2250 if (defined $self->{clientProperties}) {
2251 $xfer += $output->writeFieldBegin('clientProperties', TType::MAP, 6);
2252 {
2253 $xfer += $output->writeMapBegin(TType::STRING, TType::STRING, scalar(keys %{$self->{clientProperties}}));
2254 {
2255 while( my ($kiter165,$viter166) = each %{$self->{clientProperties}})
2256 {
2257 $xfer += $output->writeString($kiter165);
2258 $xfer += $output->writeString($viter166);
2259 }
2260 }
2261 $xfer += $output->writeMapEnd();
2262 }
2263 $xfer += $output->writeFieldEnd();
2264 }
2265 $xfer += $output->writeFieldStop();
2266 $xfer += $output->writeStructEnd();
2267 return $xfer;
2268 }
2269  
2270 package Net::Evernote::EDAMNoteStore::NoteEmailParameters;
2271 use base qw(Class::Accessor);
2272 Net::Evernote::EDAMNoteStore::NoteEmailParameters->mk_accessors( qw( guid note toAddresses ccAddresses subject message ) );
2273  
2274 sub new {
2275 my $classname = shift;
2276 my $self = {};
2277 my $vals = shift || {};
2278 $self->{guid} = undef;
2279 $self->{note} = undef;
2280 $self->{toAddresses} = undef;
2281 $self->{ccAddresses} = undef;
2282 $self->{subject} = undef;
2283 $self->{message} = undef;
2284 if (UNIVERSAL::isa($vals,'HASH')) {
2285 if (defined $vals->{guid}) {
2286 $self->{guid} = $vals->{guid};
2287 }
2288 if (defined $vals->{note}) {
2289 $self->{note} = $vals->{note};
2290 }
2291 if (defined $vals->{toAddresses}) {
2292 $self->{toAddresses} = $vals->{toAddresses};
2293 }
2294 if (defined $vals->{ccAddresses}) {
2295 $self->{ccAddresses} = $vals->{ccAddresses};
2296 }
2297 if (defined $vals->{subject}) {
2298 $self->{subject} = $vals->{subject};
2299 }
2300 if (defined $vals->{message}) {
2301 $self->{message} = $vals->{message};
2302 }
2303 }
2304 return bless ($self, $classname);
2305 }
2306  
2307 sub getName {
2308 return 'NoteEmailParameters';
2309 }
2310  
2311 sub read {
2312 my ($self, $input) = @_;
2313 my $xfer = 0;
2314 my $fname;
2315 my $ftype = 0;
2316 my $fid = 0;
2317 $xfer += $input->readStructBegin(\$fname);
2318 while (1)
2319 {
2320 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
2321 if ($ftype == TType::STOP) {
2322 last;
2323 }
2324 SWITCH: for($fid)
2325 {
2326 /^1$/ && do{ if ($ftype == TType::STRING) {
2327 $xfer += $input->readString(\$self->{guid});
2328 } else {
2329 $xfer += $input->skip($ftype);
2330 }
2331 last; };
2332 /^2$/ && do{ if ($ftype == TType::STRUCT) {
2333 $self->{note} = Net::Evernote::EDAMTypes::Note->new();
2334 $xfer += $self->{note}->read($input);
2335 } else {
2336 $xfer += $input->skip($ftype);
2337 }
2338 last; };
2339 /^3$/ && do{ if ($ftype == TType::LIST) {
2340 {
2341 my $_size167 = 0;
2342 $self->{toAddresses} = [];
2343 my $_etype170 = 0;
2344 $xfer += $input->readListBegin(\$_etype170, \$_size167);
2345 for (my $_i171 = 0; $_i171 < $_size167; ++$_i171)
2346 {
2347 my $elem172 = undef;
2348 $xfer += $input->readString(\$elem172);
2349 push(@{$self->{toAddresses}},$elem172);
2350 }
2351 $xfer += $input->readListEnd();
2352 }
2353 } else {
2354 $xfer += $input->skip($ftype);
2355 }
2356 last; };
2357 /^4$/ && do{ if ($ftype == TType::LIST) {
2358 {
2359 my $_size173 = 0;
2360 $self->{ccAddresses} = [];
2361 my $_etype176 = 0;
2362 $xfer += $input->readListBegin(\$_etype176, \$_size173);
2363 for (my $_i177 = 0; $_i177 < $_size173; ++$_i177)
2364 {
2365 my $elem178 = undef;
2366 $xfer += $input->readString(\$elem178);
2367 push(@{$self->{ccAddresses}},$elem178);
2368 }
2369 $xfer += $input->readListEnd();
2370 }
2371 } else {
2372 $xfer += $input->skip($ftype);
2373 }
2374 last; };
2375 /^5$/ && do{ if ($ftype == TType::STRING) {
2376 $xfer += $input->readString(\$self->{subject});
2377 } else {
2378 $xfer += $input->skip($ftype);
2379 }
2380 last; };
2381 /^6$/ && do{ if ($ftype == TType::STRING) {
2382 $xfer += $input->readString(\$self->{message});
2383 } else {
2384 $xfer += $input->skip($ftype);
2385 }
2386 last; };
2387 $xfer += $input->skip($ftype);
2388 }
2389 $xfer += $input->readFieldEnd();
2390 }
2391 $xfer += $input->readStructEnd();
2392 return $xfer;
2393 }
2394  
2395 sub write {
2396 my ($self, $output) = @_;
2397 my $xfer = 0;
2398 $xfer += $output->writeStructBegin('NoteEmailParameters');
2399 if (defined $self->{guid}) {
2400 $xfer += $output->writeFieldBegin('guid', TType::STRING, 1);
2401 $xfer += $output->writeString($self->{guid});
2402 $xfer += $output->writeFieldEnd();
2403 }
2404 if (defined $self->{note}) {
2405 $xfer += $output->writeFieldBegin('note', TType::STRUCT, 2);
2406 $xfer += $self->{note}->write($output);
2407 $xfer += $output->writeFieldEnd();
2408 }
2409 if (defined $self->{toAddresses}) {
2410 $xfer += $output->writeFieldBegin('toAddresses', TType::LIST, 3);
2411 {
2412 $xfer += $output->writeListBegin(TType::STRING, scalar(@{$self->{toAddresses}}));
2413 {
2414 foreach my $iter179 (@{$self->{toAddresses}})
2415 {
2416 $xfer += $output->writeString($iter179);
2417 }
2418 }
2419 $xfer += $output->writeListEnd();
2420 }
2421 $xfer += $output->writeFieldEnd();
2422 }
2423 if (defined $self->{ccAddresses}) {
2424 $xfer += $output->writeFieldBegin('ccAddresses', TType::LIST, 4);
2425 {
2426 $xfer += $output->writeListBegin(TType::STRING, scalar(@{$self->{ccAddresses}}));
2427 {
2428 foreach my $iter180 (@{$self->{ccAddresses}})
2429 {
2430 $xfer += $output->writeString($iter180);
2431 }
2432 }
2433 $xfer += $output->writeListEnd();
2434 }
2435 $xfer += $output->writeFieldEnd();
2436 }
2437 if (defined $self->{subject}) {
2438 $xfer += $output->writeFieldBegin('subject', TType::STRING, 5);
2439 $xfer += $output->writeString($self->{subject});
2440 $xfer += $output->writeFieldEnd();
2441 }
2442 if (defined $self->{message}) {
2443 $xfer += $output->writeFieldBegin('message', TType::STRING, 6);
2444 $xfer += $output->writeString($self->{message});
2445 $xfer += $output->writeFieldEnd();
2446 }
2447 $xfer += $output->writeFieldStop();
2448 $xfer += $output->writeStructEnd();
2449 return $xfer;
2450 }
2451  
2452 package Net::Evernote::EDAMNoteStore::NoteVersionId;
2453 use base qw(Class::Accessor);
2454 Net::Evernote::EDAMNoteStore::NoteVersionId->mk_accessors( qw( updateSequenceNum updated saved title ) );
2455  
2456 sub new {
2457 my $classname = shift;
2458 my $self = {};
2459 my $vals = shift || {};
2460 $self->{updateSequenceNum} = undef;
2461 $self->{updated} = undef;
2462 $self->{saved} = undef;
2463 $self->{title} = undef;
2464 if (UNIVERSAL::isa($vals,'HASH')) {
2465 if (defined $vals->{updateSequenceNum}) {
2466 $self->{updateSequenceNum} = $vals->{updateSequenceNum};
2467 }
2468 if (defined $vals->{updated}) {
2469 $self->{updated} = $vals->{updated};
2470 }
2471 if (defined $vals->{saved}) {
2472 $self->{saved} = $vals->{saved};
2473 }
2474 if (defined $vals->{title}) {
2475 $self->{title} = $vals->{title};
2476 }
2477 }
2478 return bless ($self, $classname);
2479 }
2480  
2481 sub getName {
2482 return 'NoteVersionId';
2483 }
2484  
2485 sub read {
2486 my ($self, $input) = @_;
2487 my $xfer = 0;
2488 my $fname;
2489 my $ftype = 0;
2490 my $fid = 0;
2491 $xfer += $input->readStructBegin(\$fname);
2492 while (1)
2493 {
2494 $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
2495 if ($ftype == TType::STOP) {
2496 last;
2497 }
2498 SWITCH: for($fid)
2499 {
2500 /^1$/ && do{ if ($ftype == TType::I32) {
2501 $xfer += $input->readI32(\$self->{updateSequenceNum});
2502 } else {
2503 $xfer += $input->skip($ftype);
2504 }
2505 last; };
2506 /^2$/ && do{ if ($ftype == TType::I64) {
2507 $xfer += $input->readI64(\$self->{updated});
2508 } else {
2509 $xfer += $input->skip($ftype);
2510 }
2511 last; };
2512 /^3$/ && do{ if ($ftype == TType::I64) {
2513 $xfer += $input->readI64(\$self->{saved});
2514 } else {
2515 $xfer += $input->skip($ftype);
2516 }
2517 last; };
2518 /^4$/ && do{ if ($ftype == TType::STRING) {
2519 $xfer += $input->readString(\$self->{title});
2520 } else {
2521 $xfer += $input->skip($ftype);
2522 }
2523 last; };
2524 $xfer += $input->skip($ftype);
2525 }
2526 $xfer += $input->readFieldEnd();
2527 }
2528 $xfer += $input->readStructEnd();
2529 return $xfer;
2530 }
2531  
2532 sub write {
2533 my ($self, $output) = @_;
2534 my $xfer = 0;
2535 $xfer += $output->writeStructBegin('NoteVersionId');
2536 if (defined $self->{updateSequenceNum}) {
2537 $xfer += $output->writeFieldBegin('updateSequenceNum', TType::I32, 1);
2538 $xfer += $output->writeI32($self->{updateSequenceNum});
2539 $xfer += $output->writeFieldEnd();
2540 }
2541 if (defined $self->{updated}) {
2542 $xfer += $output->writeFieldBegin('updated', TType::I64, 2);
2543 $xfer += $output->writeI64($self->{updated});
2544 $xfer += $output->writeFieldEnd();
2545 }
2546 if (defined $self->{saved}) {
2547 $xfer += $output->writeFieldBegin('saved', TType::I64, 3);
2548 $xfer += $output->writeI64($self->{saved});
2549 $xfer += $output->writeFieldEnd();
2550 }
2551 if (defined $self->{title}) {
2552 $xfer += $output->writeFieldBegin('title', TType::STRING, 4);
2553 $xfer += $output->writeString($self->{title});
2554 $xfer += $output->writeFieldEnd();
2555 }
2556 $xfer += $output->writeFieldStop();
2557 $xfer += $output->writeStructEnd();
2558 return $xfer;
2559 }
2560  
2561 1;