Evernote/EDAMUserStore/UserStore.pm untested

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