← Back to branch summary

~dpm/reminders-app/evernote-api-plugin

« back to all changes in this revision

Viewing changes to 3rdParty/evernote-sdk-cpp/src/UserStore.h

  • Committer: Michael Zanetti
  • Date: 2013-11-14 20:19:11 UTC
  • Revision ID: michael.zanetti@canonical.com-20131114201911-pc2rlni3akrqxlgn
first try to connect to evernote

Show diffs side-by-side

added added

removed removed

Lines of Context:
3rdParty/evernote-sdk-cpp/src/UserStore.h
 
1
/**
 
2
 * Autogenerated by Thrift
 
3
 *
 
4
 * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
 
5
 */
 
6
#ifndef UserStore_H
 
7
#define UserStore_H
 
8
 
 
9
#include <TProcessor.h>
 
10
#include "UserStore_types.h"
 
11
 
 
12
namespace evernote { namespace edam {
 
13
 
 
14
class UserStoreIf {
 
15
 public:
 
16
  virtual ~UserStoreIf() {}
 
17
  virtual bool checkVersion(const std::string& clientName, const int16_t edamVersionMajor, const int16_t edamVersionMinor) = 0;
 
18
  virtual void getBootstrapInfo(BootstrapInfo& _return, const std::string& locale) = 0;
 
19
  virtual void authenticate(AuthenticationResult& _return, const std::string& username, const std::string& password, const std::string& consumerKey, const std::string& consumerSecret, const bool supportsTwoFactor) = 0;
 
20
  virtual void authenticateLongSession(AuthenticationResult& _return, const std::string& username, const std::string& password, const std::string& consumerKey, const std::string& consumerSecret, const std::string& deviceIdentifier, const std::string& deviceDescription, const bool supportsTwoFactor) = 0;
 
21
  virtual void completeTwoFactorAuthentication(AuthenticationResult& _return, const std::string& authenticationToken, const std::string& oneTimeCode, const std::string& deviceIdentifier, const std::string& deviceDescription) = 0;
 
22
  virtual void revokeLongSession(const std::string& authenticationToken) = 0;
 
23
  virtual void authenticateToBusiness(AuthenticationResult& _return, const std::string& authenticationToken) = 0;
 
24
  virtual void refreshAuthentication(AuthenticationResult& _return, const std::string& authenticationToken) = 0;
 
25
  virtual void getUser(evernote::edam::User& _return, const std::string& authenticationToken) = 0;
 
26
  virtual void getPublicUserInfo(PublicUserInfo& _return, const std::string& username) = 0;
 
27
  virtual void getPremiumInfo(evernote::edam::PremiumInfo& _return, const std::string& authenticationToken) = 0;
 
28
  virtual void getNoteStoreUrl(std::string& _return, const std::string& authenticationToken) = 0;
 
29
};
 
30
 
 
31
class UserStoreNull : virtual public UserStoreIf {
 
32
 public:
 
33
  virtual ~UserStoreNull() {}
 
34
  bool checkVersion(const std::string& /* clientName */, const int16_t /* edamVersionMajor */, const int16_t /* edamVersionMinor */) {
 
35
    bool _return = false;
 
36
    return _return;
 
37
  }
 
38
  void getBootstrapInfo(BootstrapInfo& /* _return */, const std::string& /* locale */) {
 
39
    return;
 
40
  }
 
41
  void authenticate(AuthenticationResult& /* _return */, const std::string& /* username */, const std::string& /* password */, const std::string& /* consumerKey */, const std::string& /* consumerSecret */, const bool /* supportsTwoFactor */) {
 
42
    return;
 
43
  }
 
44
  void authenticateLongSession(AuthenticationResult& /* _return */, const std::string& /* username */, const std::string& /* password */, const std::string& /* consumerKey */, const std::string& /* consumerSecret */, const std::string& /* deviceIdentifier */, const std::string& /* deviceDescription */, const bool /* supportsTwoFactor */) {
 
45
    return;
 
46
  }
 
47
  void completeTwoFactorAuthentication(AuthenticationResult& /* _return */, const std::string& /* authenticationToken */, const std::string& /* oneTimeCode */, const std::string& /* deviceIdentifier */, const std::string& /* deviceDescription */) {
 
48
    return;
 
49
  }
 
50
  void revokeLongSession(const std::string& /* authenticationToken */) {
 
51
    return;
 
52
  }
 
53
  void authenticateToBusiness(AuthenticationResult& /* _return */, const std::string& /* authenticationToken */) {
 
54
    return;
 
55
  }
 
56
  void refreshAuthentication(AuthenticationResult& /* _return */, const std::string& /* authenticationToken */) {
 
57
    return;
 
58
  }
 
59
  void getUser(evernote::edam::User& /* _return */, const std::string& /* authenticationToken */) {
 
60
    return;
 
61
  }
 
62
  void getPublicUserInfo(PublicUserInfo& /* _return */, const std::string& /* username */) {
 
63
    return;
 
64
  }
 
65
  void getPremiumInfo(evernote::edam::PremiumInfo& /* _return */, const std::string& /* authenticationToken */) {
 
66
    return;
 
67
  }
 
68
  void getNoteStoreUrl(std::string& /* _return */, const std::string& /* authenticationToken */) {
 
69
    return;
 
70
  }
 
71
};
 
72
 
 
73
typedef struct _UserStore_checkVersion_args__isset {
 
74
  _UserStore_checkVersion_args__isset() : clientName(false), edamVersionMajor(false), edamVersionMinor(false) {}
 
75
  bool clientName;
 
76
  bool edamVersionMajor;
 
77
  bool edamVersionMinor;
 
78
} _UserStore_checkVersion_args__isset;
 
79
 
 
80
class UserStore_checkVersion_args {
 
81
 public:
 
82
 
 
83
  UserStore_checkVersion_args() : clientName(""), edamVersionMajor(1), edamVersionMinor(25) {
 
84
  }
 
85
 
 
86
  virtual ~UserStore_checkVersion_args() throw() {}
 
87
 
 
88
  std::string clientName;
 
89
  int16_t edamVersionMajor;
 
90
  int16_t edamVersionMinor;
 
91
 
 
92
  _UserStore_checkVersion_args__isset __isset;
 
93
 
 
94
  bool operator == (const UserStore_checkVersion_args & rhs) const
 
95
  {
 
96
    if (!(clientName == rhs.clientName))
 
97
      return false;
 
98
    if (!(edamVersionMajor == rhs.edamVersionMajor))
 
99
      return false;
 
100
    if (!(edamVersionMinor == rhs.edamVersionMinor))
 
101
      return false;
 
102
    return true;
 
103
  }
 
104
  bool operator != (const UserStore_checkVersion_args &rhs) const {
 
105
    return !(*this == rhs);
 
106
  }
 
107
 
 
108
  bool operator < (const UserStore_checkVersion_args & ) const;
 
109
 
 
110
  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
 
111
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
112
 
 
113
};
 
114
 
 
115
 
 
116
class UserStore_checkVersion_pargs {
 
117
 public:
 
118
 
 
119
 
 
120
  virtual ~UserStore_checkVersion_pargs() throw() {}
 
121
 
 
122
  const std::string* clientName;
 
123
  const int16_t* edamVersionMajor;
 
124
  const int16_t* edamVersionMinor;
 
125
 
 
126
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
127
 
 
128
};
 
129
 
 
130
typedef struct _UserStore_checkVersion_result__isset {
 
131
  _UserStore_checkVersion_result__isset() : success(false) {}
 
132
  bool success;
 
133
} _UserStore_checkVersion_result__isset;
 
134
 
 
135
class UserStore_checkVersion_result {
 
136
 public:
 
137
 
 
138
  UserStore_checkVersion_result() : success(0) {
 
139
  }
 
140
 
 
141
  virtual ~UserStore_checkVersion_result() throw() {}
 
142
 
 
143
  bool success;
 
144
 
 
145
  _UserStore_checkVersion_result__isset __isset;
 
146
 
 
147
  bool operator == (const UserStore_checkVersion_result & rhs) const
 
148
  {
 
149
    if (!(success == rhs.success))
 
150
      return false;
 
151
    return true;
 
152
  }
 
153
  bool operator != (const UserStore_checkVersion_result &rhs) const {
 
154
    return !(*this == rhs);
 
155
  }
 
156
 
 
157
  bool operator < (const UserStore_checkVersion_result & ) const;
 
158
 
 
159
  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
 
160
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
161
 
 
162
};
 
163
 
 
164
typedef struct _UserStore_checkVersion_presult__isset {
 
165
  _UserStore_checkVersion_presult__isset() : success(false) {}
 
166
  bool success;
 
167
} _UserStore_checkVersion_presult__isset;
 
168
 
 
169
class UserStore_checkVersion_presult {
 
170
 public:
 
171
 
 
172
 
 
173
  virtual ~UserStore_checkVersion_presult() throw() {}
 
174
 
 
175
  bool* success;
 
176
 
 
177
  _UserStore_checkVersion_presult__isset __isset;
 
178
 
 
179
  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
 
180
 
 
181
};
 
182
 
 
183
typedef struct _UserStore_getBootstrapInfo_args__isset {
 
184
  _UserStore_getBootstrapInfo_args__isset() : locale(false) {}
 
185
  bool locale;
 
186
} _UserStore_getBootstrapInfo_args__isset;
 
187
 
 
188
class UserStore_getBootstrapInfo_args {
 
189
 public:
 
190
 
 
191
  UserStore_getBootstrapInfo_args() : locale("") {
 
192
  }
 
193
 
 
194
  virtual ~UserStore_getBootstrapInfo_args() throw() {}
 
195
 
 
196
  std::string locale;
 
197
 
 
198
  _UserStore_getBootstrapInfo_args__isset __isset;
 
199
 
 
200
  bool operator == (const UserStore_getBootstrapInfo_args & rhs) const
 
201
  {
 
202
    if (!(locale == rhs.locale))
 
203
      return false;
 
204
    return true;
 
205
  }
 
206
  bool operator != (const UserStore_getBootstrapInfo_args &rhs) const {
 
207
    return !(*this == rhs);
 
208
  }
 
209
 
 
210
  bool operator < (const UserStore_getBootstrapInfo_args & ) const;
 
211
 
 
212
  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
 
213
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
214
 
 
215
};
 
216
 
 
217
 
 
218
class UserStore_getBootstrapInfo_pargs {
 
219
 public:
 
220
 
 
221
 
 
222
  virtual ~UserStore_getBootstrapInfo_pargs() throw() {}
 
223
 
 
224
  const std::string* locale;
 
225
 
 
226
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
227
 
 
228
};
 
229
 
 
230
typedef struct _UserStore_getBootstrapInfo_result__isset {
 
231
  _UserStore_getBootstrapInfo_result__isset() : success(false) {}
 
232
  bool success;
 
233
} _UserStore_getBootstrapInfo_result__isset;
 
234
 
 
235
class UserStore_getBootstrapInfo_result {
 
236
 public:
 
237
 
 
238
  UserStore_getBootstrapInfo_result() {
 
239
  }
 
240
 
 
241
  virtual ~UserStore_getBootstrapInfo_result() throw() {}
 
242
 
 
243
  BootstrapInfo success;
 
244
 
 
245
  _UserStore_getBootstrapInfo_result__isset __isset;
 
246
 
 
247
  bool operator == (const UserStore_getBootstrapInfo_result & rhs) const
 
248
  {
 
249
    if (!(success == rhs.success))
 
250
      return false;
 
251
    return true;
 
252
  }
 
253
  bool operator != (const UserStore_getBootstrapInfo_result &rhs) const {
 
254
    return !(*this == rhs);
 
255
  }
 
256
 
 
257
  bool operator < (const UserStore_getBootstrapInfo_result & ) const;
 
258
 
 
259
  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
 
260
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
261
 
 
262
};
 
263
 
 
264
typedef struct _UserStore_getBootstrapInfo_presult__isset {
 
265
  _UserStore_getBootstrapInfo_presult__isset() : success(false) {}
 
266
  bool success;
 
267
} _UserStore_getBootstrapInfo_presult__isset;
 
268
 
 
269
class UserStore_getBootstrapInfo_presult {
 
270
 public:
 
271
 
 
272
 
 
273
  virtual ~UserStore_getBootstrapInfo_presult() throw() {}
 
274
 
 
275
  BootstrapInfo* success;
 
276
 
 
277
  _UserStore_getBootstrapInfo_presult__isset __isset;
 
278
 
 
279
  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
 
280
 
 
281
};
 
282
 
 
283
typedef struct _UserStore_authenticate_args__isset {
 
284
  _UserStore_authenticate_args__isset() : username(false), password(false), consumerKey(false), consumerSecret(false), supportsTwoFactor(false) {}
 
285
  bool username;
 
286
  bool password;
 
287
  bool consumerKey;
 
288
  bool consumerSecret;
 
289
  bool supportsTwoFactor;
 
290
} _UserStore_authenticate_args__isset;
 
291
 
 
292
class UserStore_authenticate_args {
 
293
 public:
 
294
 
 
295
  UserStore_authenticate_args() : username(""), password(""), consumerKey(""), consumerSecret(""), supportsTwoFactor(0) {
 
296
  }
 
297
 
 
298
  virtual ~UserStore_authenticate_args() throw() {}
 
299
 
 
300
  std::string username;
 
301
  std::string password;
 
302
  std::string consumerKey;
 
303
  std::string consumerSecret;
 
304
  bool supportsTwoFactor;
 
305
 
 
306
  _UserStore_authenticate_args__isset __isset;
 
307
 
 
308
  bool operator == (const UserStore_authenticate_args & rhs) const
 
309
  {
 
310
    if (!(username == rhs.username))
 
311
      return false;
 
312
    if (!(password == rhs.password))
 
313
      return false;
 
314
    if (!(consumerKey == rhs.consumerKey))
 
315
      return false;
 
316
    if (!(consumerSecret == rhs.consumerSecret))
 
317
      return false;
 
318
    if (!(supportsTwoFactor == rhs.supportsTwoFactor))
 
319
      return false;
 
320
    return true;
 
321
  }
 
322
  bool operator != (const UserStore_authenticate_args &rhs) const {
 
323
    return !(*this == rhs);
 
324
  }
 
325
 
 
326
  bool operator < (const UserStore_authenticate_args & ) const;
 
327
 
 
328
  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
 
329
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
330
 
 
331
};
 
332
 
 
333
 
 
334
class UserStore_authenticate_pargs {
 
335
 public:
 
336
 
 
337
 
 
338
  virtual ~UserStore_authenticate_pargs() throw() {}
 
339
 
 
340
  const std::string* username;
 
341
  const std::string* password;
 
342
  const std::string* consumerKey;
 
343
  const std::string* consumerSecret;
 
344
  const bool* supportsTwoFactor;
 
345
 
 
346
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
347
 
 
348
};
 
349
 
 
350
typedef struct _UserStore_authenticate_result__isset {
 
351
  _UserStore_authenticate_result__isset() : success(false), userException(false), systemException(false) {}
 
352
  bool success;
 
353
  bool userException;
 
354
  bool systemException;
 
355
} _UserStore_authenticate_result__isset;
 
356
 
 
357
class UserStore_authenticate_result {
 
358
 public:
 
359
 
 
360
  UserStore_authenticate_result() {
 
361
  }
 
362
 
 
363
  virtual ~UserStore_authenticate_result() throw() {}
 
364
 
 
365
  AuthenticationResult success;
 
366
  evernote::edam::EDAMUserException userException;
 
367
  evernote::edam::EDAMSystemException systemException;
 
368
 
 
369
  _UserStore_authenticate_result__isset __isset;
 
370
 
 
371
  bool operator == (const UserStore_authenticate_result & rhs) const
 
372
  {
 
373
    if (!(success == rhs.success))
 
374
      return false;
 
375
    if (!(userException == rhs.userException))
 
376
      return false;
 
377
    if (!(systemException == rhs.systemException))
 
378
      return false;
 
379
    return true;
 
380
  }
 
381
  bool operator != (const UserStore_authenticate_result &rhs) const {
 
382
    return !(*this == rhs);
 
383
  }
 
384
 
 
385
  bool operator < (const UserStore_authenticate_result & ) const;
 
386
 
 
387
  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
 
388
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
389
 
 
390
};
 
391
 
 
392
typedef struct _UserStore_authenticate_presult__isset {
 
393
  _UserStore_authenticate_presult__isset() : success(false), userException(false), systemException(false) {}
 
394
  bool success;
 
395
  bool userException;
 
396
  bool systemException;
 
397
} _UserStore_authenticate_presult__isset;
 
398
 
 
399
class UserStore_authenticate_presult {
 
400
 public:
 
401
 
 
402
 
 
403
  virtual ~UserStore_authenticate_presult() throw() {}
 
404
 
 
405
  AuthenticationResult* success;
 
406
  evernote::edam::EDAMUserException userException;
 
407
  evernote::edam::EDAMSystemException systemException;
 
408
 
 
409
  _UserStore_authenticate_presult__isset __isset;
 
410
 
 
411
  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
 
412
 
 
413
};
 
414
 
 
415
typedef struct _UserStore_authenticateLongSession_args__isset {
 
416
  _UserStore_authenticateLongSession_args__isset() : username(false), password(false), consumerKey(false), consumerSecret(false), deviceIdentifier(false), deviceDescription(false), supportsTwoFactor(false) {}
 
417
  bool username;
 
418
  bool password;
 
419
  bool consumerKey;
 
420
  bool consumerSecret;
 
421
  bool deviceIdentifier;
 
422
  bool deviceDescription;
 
423
  bool supportsTwoFactor;
 
424
} _UserStore_authenticateLongSession_args__isset;
 
425
 
 
426
class UserStore_authenticateLongSession_args {
 
427
 public:
 
428
 
 
429
  UserStore_authenticateLongSession_args() : username(""), password(""), consumerKey(""), consumerSecret(""), deviceIdentifier(""), deviceDescription(""), supportsTwoFactor(0) {
 
430
  }
 
431
 
 
432
  virtual ~UserStore_authenticateLongSession_args() throw() {}
 
433
 
 
434
  std::string username;
 
435
  std::string password;
 
436
  std::string consumerKey;
 
437
  std::string consumerSecret;
 
438
  std::string deviceIdentifier;
 
439
  std::string deviceDescription;
 
440
  bool supportsTwoFactor;
 
441
 
 
442
  _UserStore_authenticateLongSession_args__isset __isset;
 
443
 
 
444
  bool operator == (const UserStore_authenticateLongSession_args & rhs) const
 
445
  {
 
446
    if (!(username == rhs.username))
 
447
      return false;
 
448
    if (!(password == rhs.password))
 
449
      return false;
 
450
    if (!(consumerKey == rhs.consumerKey))
 
451
      return false;
 
452
    if (!(consumerSecret == rhs.consumerSecret))
 
453
      return false;
 
454
    if (!(deviceIdentifier == rhs.deviceIdentifier))
 
455
      return false;
 
456
    if (!(deviceDescription == rhs.deviceDescription))
 
457
      return false;
 
458
    if (!(supportsTwoFactor == rhs.supportsTwoFactor))
 
459
      return false;
 
460
    return true;
 
461
  }
 
462
  bool operator != (const UserStore_authenticateLongSession_args &rhs) const {
 
463
    return !(*this == rhs);
 
464
  }
 
465
 
 
466
  bool operator < (const UserStore_authenticateLongSession_args & ) const;
 
467
 
 
468
  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
 
469
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
470
 
 
471
};
 
472
 
 
473
 
 
474
class UserStore_authenticateLongSession_pargs {
 
475
 public:
 
476
 
 
477
 
 
478
  virtual ~UserStore_authenticateLongSession_pargs() throw() {}
 
479
 
 
480
  const std::string* username;
 
481
  const std::string* password;
 
482
  const std::string* consumerKey;
 
483
  const std::string* consumerSecret;
 
484
  const std::string* deviceIdentifier;
 
485
  const std::string* deviceDescription;
 
486
  const bool* supportsTwoFactor;
 
487
 
 
488
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
489
 
 
490
};
 
491
 
 
492
typedef struct _UserStore_authenticateLongSession_result__isset {
 
493
  _UserStore_authenticateLongSession_result__isset() : success(false), userException(false), systemException(false) {}
 
494
  bool success;
 
495
  bool userException;
 
496
  bool systemException;
 
497
} _UserStore_authenticateLongSession_result__isset;
 
498
 
 
499
class UserStore_authenticateLongSession_result {
 
500
 public:
 
501
 
 
502
  UserStore_authenticateLongSession_result() {
 
503
  }
 
504
 
 
505
  virtual ~UserStore_authenticateLongSession_result() throw() {}
 
506
 
 
507
  AuthenticationResult success;
 
508
  evernote::edam::EDAMUserException userException;
 
509
  evernote::edam::EDAMSystemException systemException;
 
510
 
 
511
  _UserStore_authenticateLongSession_result__isset __isset;
 
512
 
 
513
  bool operator == (const UserStore_authenticateLongSession_result & rhs) const
 
514
  {
 
515
    if (!(success == rhs.success))
 
516
      return false;
 
517
    if (!(userException == rhs.userException))
 
518
      return false;
 
519
    if (!(systemException == rhs.systemException))
 
520
      return false;
 
521
    return true;
 
522
  }
 
523
  bool operator != (const UserStore_authenticateLongSession_result &rhs) const {
 
524
    return !(*this == rhs);
 
525
  }
 
526
 
 
527
  bool operator < (const UserStore_authenticateLongSession_result & ) const;
 
528
 
 
529
  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
 
530
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
531
 
 
532
};
 
533
 
 
534
typedef struct _UserStore_authenticateLongSession_presult__isset {
 
535
  _UserStore_authenticateLongSession_presult__isset() : success(false), userException(false), systemException(false) {}
 
536
  bool success;
 
537
  bool userException;
 
538
  bool systemException;
 
539
} _UserStore_authenticateLongSession_presult__isset;
 
540
 
 
541
class UserStore_authenticateLongSession_presult {
 
542
 public:
 
543
 
 
544
 
 
545
  virtual ~UserStore_authenticateLongSession_presult() throw() {}
 
546
 
 
547
  AuthenticationResult* success;
 
548
  evernote::edam::EDAMUserException userException;
 
549
  evernote::edam::EDAMSystemException systemException;
 
550
 
 
551
  _UserStore_authenticateLongSession_presult__isset __isset;
 
552
 
 
553
  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
 
554
 
 
555
};
 
556
 
 
557
typedef struct _UserStore_completeTwoFactorAuthentication_args__isset {
 
558
  _UserStore_completeTwoFactorAuthentication_args__isset() : authenticationToken(false), oneTimeCode(false), deviceIdentifier(false), deviceDescription(false) {}
 
559
  bool authenticationToken;
 
560
  bool oneTimeCode;
 
561
  bool deviceIdentifier;
 
562
  bool deviceDescription;
 
563
} _UserStore_completeTwoFactorAuthentication_args__isset;
 
564
 
 
565
class UserStore_completeTwoFactorAuthentication_args {
 
566
 public:
 
567
 
 
568
  UserStore_completeTwoFactorAuthentication_args() : authenticationToken(""), oneTimeCode(""), deviceIdentifier(""), deviceDescription("") {
 
569
  }
 
570
 
 
571
  virtual ~UserStore_completeTwoFactorAuthentication_args() throw() {}
 
572
 
 
573
  std::string authenticationToken;
 
574
  std::string oneTimeCode;
 
575
  std::string deviceIdentifier;
 
576
  std::string deviceDescription;
 
577
 
 
578
  _UserStore_completeTwoFactorAuthentication_args__isset __isset;
 
579
 
 
580
  bool operator == (const UserStore_completeTwoFactorAuthentication_args & rhs) const
 
581
  {
 
582
    if (!(authenticationToken == rhs.authenticationToken))
 
583
      return false;
 
584
    if (!(oneTimeCode == rhs.oneTimeCode))
 
585
      return false;
 
586
    if (!(deviceIdentifier == rhs.deviceIdentifier))
 
587
      return false;
 
588
    if (!(deviceDescription == rhs.deviceDescription))
 
589
      return false;
 
590
    return true;
 
591
  }
 
592
  bool operator != (const UserStore_completeTwoFactorAuthentication_args &rhs) const {
 
593
    return !(*this == rhs);
 
594
  }
 
595
 
 
596
  bool operator < (const UserStore_completeTwoFactorAuthentication_args & ) const;
 
597
 
 
598
  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
 
599
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
600
 
 
601
};
 
602
 
 
603
 
 
604
class UserStore_completeTwoFactorAuthentication_pargs {
 
605
 public:
 
606
 
 
607
 
 
608
  virtual ~UserStore_completeTwoFactorAuthentication_pargs() throw() {}
 
609
 
 
610
  const std::string* authenticationToken;
 
611
  const std::string* oneTimeCode;
 
612
  const std::string* deviceIdentifier;
 
613
  const std::string* deviceDescription;
 
614
 
 
615
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
616
 
 
617
};
 
618
 
 
619
typedef struct _UserStore_completeTwoFactorAuthentication_result__isset {
 
620
  _UserStore_completeTwoFactorAuthentication_result__isset() : success(false), userException(false), systemException(false) {}
 
621
  bool success;
 
622
  bool userException;
 
623
  bool systemException;
 
624
} _UserStore_completeTwoFactorAuthentication_result__isset;
 
625
 
 
626
class UserStore_completeTwoFactorAuthentication_result {
 
627
 public:
 
628
 
 
629
  UserStore_completeTwoFactorAuthentication_result() {
 
630
  }
 
631
 
 
632
  virtual ~UserStore_completeTwoFactorAuthentication_result() throw() {}
 
633
 
 
634
  AuthenticationResult success;
 
635
  evernote::edam::EDAMUserException userException;
 
636
  evernote::edam::EDAMSystemException systemException;
 
637
 
 
638
  _UserStore_completeTwoFactorAuthentication_result__isset __isset;
 
639
 
 
640
  bool operator == (const UserStore_completeTwoFactorAuthentication_result & rhs) const
 
641
  {
 
642
    if (!(success == rhs.success))
 
643
      return false;
 
644
    if (!(userException == rhs.userException))
 
645
      return false;
 
646
    if (!(systemException == rhs.systemException))
 
647
      return false;
 
648
    return true;
 
649
  }
 
650
  bool operator != (const UserStore_completeTwoFactorAuthentication_result &rhs) const {
 
651
    return !(*this == rhs);
 
652
  }
 
653
 
 
654
  bool operator < (const UserStore_completeTwoFactorAuthentication_result & ) const;
 
655
 
 
656
  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
 
657
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
658
 
 
659
};
 
660
 
 
661
typedef struct _UserStore_completeTwoFactorAuthentication_presult__isset {
 
662
  _UserStore_completeTwoFactorAuthentication_presult__isset() : success(false), userException(false), systemException(false) {}
 
663
  bool success;
 
664
  bool userException;
 
665
  bool systemException;
 
666
} _UserStore_completeTwoFactorAuthentication_presult__isset;
 
667
 
 
668
class UserStore_completeTwoFactorAuthentication_presult {
 
669
 public:
 
670
 
 
671
 
 
672
  virtual ~UserStore_completeTwoFactorAuthentication_presult() throw() {}
 
673
 
 
674
  AuthenticationResult* success;
 
675
  evernote::edam::EDAMUserException userException;
 
676
  evernote::edam::EDAMSystemException systemException;
 
677
 
 
678
  _UserStore_completeTwoFactorAuthentication_presult__isset __isset;
 
679
 
 
680
  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
 
681
 
 
682
};
 
683
 
 
684
typedef struct _UserStore_revokeLongSession_args__isset {
 
685
  _UserStore_revokeLongSession_args__isset() : authenticationToken(false) {}
 
686
  bool authenticationToken;
 
687
} _UserStore_revokeLongSession_args__isset;
 
688
 
 
689
class UserStore_revokeLongSession_args {
 
690
 public:
 
691
 
 
692
  UserStore_revokeLongSession_args() : authenticationToken("") {
 
693
  }
 
694
 
 
695
  virtual ~UserStore_revokeLongSession_args() throw() {}
 
696
 
 
697
  std::string authenticationToken;
 
698
 
 
699
  _UserStore_revokeLongSession_args__isset __isset;
 
700
 
 
701
  bool operator == (const UserStore_revokeLongSession_args & rhs) const
 
702
  {
 
703
    if (!(authenticationToken == rhs.authenticationToken))
 
704
      return false;
 
705
    return true;
 
706
  }
 
707
  bool operator != (const UserStore_revokeLongSession_args &rhs) const {
 
708
    return !(*this == rhs);
 
709
  }
 
710
 
 
711
  bool operator < (const UserStore_revokeLongSession_args & ) const;
 
712
 
 
713
  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
 
714
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
715
 
 
716
};
 
717
 
 
718
 
 
719
class UserStore_revokeLongSession_pargs {
 
720
 public:
 
721
 
 
722
 
 
723
  virtual ~UserStore_revokeLongSession_pargs() throw() {}
 
724
 
 
725
  const std::string* authenticationToken;
 
726
 
 
727
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
728
 
 
729
};
 
730
 
 
731
typedef struct _UserStore_revokeLongSession_result__isset {
 
732
  _UserStore_revokeLongSession_result__isset() : userException(false), systemException(false) {}
 
733
  bool userException;
 
734
  bool systemException;
 
735
} _UserStore_revokeLongSession_result__isset;
 
736
 
 
737
class UserStore_revokeLongSession_result {
 
738
 public:
 
739
 
 
740
  UserStore_revokeLongSession_result() {
 
741
  }
 
742
 
 
743
  virtual ~UserStore_revokeLongSession_result() throw() {}
 
744
 
 
745
  evernote::edam::EDAMUserException userException;
 
746
  evernote::edam::EDAMSystemException systemException;
 
747
 
 
748
  _UserStore_revokeLongSession_result__isset __isset;
 
749
 
 
750
  bool operator == (const UserStore_revokeLongSession_result & rhs) const
 
751
  {
 
752
    if (!(userException == rhs.userException))
 
753
      return false;
 
754
    if (!(systemException == rhs.systemException))
 
755
      return false;
 
756
    return true;
 
757
  }
 
758
  bool operator != (const UserStore_revokeLongSession_result &rhs) const {
 
759
    return !(*this == rhs);
 
760
  }
 
761
 
 
762
  bool operator < (const UserStore_revokeLongSession_result & ) const;
 
763
 
 
764
  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
 
765
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
766
 
 
767
};
 
768
 
 
769
typedef struct _UserStore_revokeLongSession_presult__isset {
 
770
  _UserStore_revokeLongSession_presult__isset() : userException(false), systemException(false) {}
 
771
  bool userException;
 
772
  bool systemException;
 
773
} _UserStore_revokeLongSession_presult__isset;
 
774
 
 
775
class UserStore_revokeLongSession_presult {
 
776
 public:
 
777
 
 
778
 
 
779
  virtual ~UserStore_revokeLongSession_presult() throw() {}
 
780
 
 
781
  evernote::edam::EDAMUserException userException;
 
782
  evernote::edam::EDAMSystemException systemException;
 
783
 
 
784
  _UserStore_revokeLongSession_presult__isset __isset;
 
785
 
 
786
  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
 
787
 
 
788
};
 
789
 
 
790
typedef struct _UserStore_authenticateToBusiness_args__isset {
 
791
  _UserStore_authenticateToBusiness_args__isset() : authenticationToken(false) {}
 
792
  bool authenticationToken;
 
793
} _UserStore_authenticateToBusiness_args__isset;
 
794
 
 
795
class UserStore_authenticateToBusiness_args {
 
796
 public:
 
797
 
 
798
  UserStore_authenticateToBusiness_args() : authenticationToken("") {
 
799
  }
 
800
 
 
801
  virtual ~UserStore_authenticateToBusiness_args() throw() {}
 
802
 
 
803
  std::string authenticationToken;
 
804
 
 
805
  _UserStore_authenticateToBusiness_args__isset __isset;
 
806
 
 
807
  bool operator == (const UserStore_authenticateToBusiness_args & rhs) const
 
808
  {
 
809
    if (!(authenticationToken == rhs.authenticationToken))
 
810
      return false;
 
811
    return true;
 
812
  }
 
813
  bool operator != (const UserStore_authenticateToBusiness_args &rhs) const {
 
814
    return !(*this == rhs);
 
815
  }
 
816
 
 
817
  bool operator < (const UserStore_authenticateToBusiness_args & ) const;
 
818
 
 
819
  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
 
820
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
821
 
 
822
};
 
823
 
 
824
 
 
825
class UserStore_authenticateToBusiness_pargs {
 
826
 public:
 
827
 
 
828
 
 
829
  virtual ~UserStore_authenticateToBusiness_pargs() throw() {}
 
830
 
 
831
  const std::string* authenticationToken;
 
832
 
 
833
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
834
 
 
835
};
 
836
 
 
837
typedef struct _UserStore_authenticateToBusiness_result__isset {
 
838
  _UserStore_authenticateToBusiness_result__isset() : success(false), userException(false), systemException(false) {}
 
839
  bool success;
 
840
  bool userException;
 
841
  bool systemException;
 
842
} _UserStore_authenticateToBusiness_result__isset;
 
843
 
 
844
class UserStore_authenticateToBusiness_result {
 
845
 public:
 
846
 
 
847
  UserStore_authenticateToBusiness_result() {
 
848
  }
 
849
 
 
850
  virtual ~UserStore_authenticateToBusiness_result() throw() {}
 
851
 
 
852
  AuthenticationResult success;
 
853
  evernote::edam::EDAMUserException userException;
 
854
  evernote::edam::EDAMSystemException systemException;
 
855
 
 
856
  _UserStore_authenticateToBusiness_result__isset __isset;
 
857
 
 
858
  bool operator == (const UserStore_authenticateToBusiness_result & rhs) const
 
859
  {
 
860
    if (!(success == rhs.success))
 
861
      return false;
 
862
    if (!(userException == rhs.userException))
 
863
      return false;
 
864
    if (!(systemException == rhs.systemException))
 
865
      return false;
 
866
    return true;
 
867
  }
 
868
  bool operator != (const UserStore_authenticateToBusiness_result &rhs) const {
 
869
    return !(*this == rhs);
 
870
  }
 
871
 
 
872
  bool operator < (const UserStore_authenticateToBusiness_result & ) const;
 
873
 
 
874
  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
 
875
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
876
 
 
877
};
 
878
 
 
879
typedef struct _UserStore_authenticateToBusiness_presult__isset {
 
880
  _UserStore_authenticateToBusiness_presult__isset() : success(false), userException(false), systemException(false) {}
 
881
  bool success;
 
882
  bool userException;
 
883
  bool systemException;
 
884
} _UserStore_authenticateToBusiness_presult__isset;
 
885
 
 
886
class UserStore_authenticateToBusiness_presult {
 
887
 public:
 
888
 
 
889
 
 
890
  virtual ~UserStore_authenticateToBusiness_presult() throw() {}
 
891
 
 
892
  AuthenticationResult* success;
 
893
  evernote::edam::EDAMUserException userException;
 
894
  evernote::edam::EDAMSystemException systemException;
 
895
 
 
896
  _UserStore_authenticateToBusiness_presult__isset __isset;
 
897
 
 
898
  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
 
899
 
 
900
};
 
901
 
 
902
typedef struct _UserStore_refreshAuthentication_args__isset {
 
903
  _UserStore_refreshAuthentication_args__isset() : authenticationToken(false) {}
 
904
  bool authenticationToken;
 
905
} _UserStore_refreshAuthentication_args__isset;
 
906
 
 
907
class UserStore_refreshAuthentication_args {
 
908
 public:
 
909
 
 
910
  UserStore_refreshAuthentication_args() : authenticationToken("") {
 
911
  }
 
912
 
 
913
  virtual ~UserStore_refreshAuthentication_args() throw() {}
 
914
 
 
915
  std::string authenticationToken;
 
916
 
 
917
  _UserStore_refreshAuthentication_args__isset __isset;
 
918
 
 
919
  bool operator == (const UserStore_refreshAuthentication_args & rhs) const
 
920
  {
 
921
    if (!(authenticationToken == rhs.authenticationToken))
 
922
      return false;
 
923
    return true;
 
924
  }
 
925
  bool operator != (const UserStore_refreshAuthentication_args &rhs) const {
 
926
    return !(*this == rhs);
 
927
  }
 
928
 
 
929
  bool operator < (const UserStore_refreshAuthentication_args & ) const;
 
930
 
 
931
  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
 
932
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
933
 
 
934
};
 
935
 
 
936
 
 
937
class UserStore_refreshAuthentication_pargs {
 
938
 public:
 
939
 
 
940
 
 
941
  virtual ~UserStore_refreshAuthentication_pargs() throw() {}
 
942
 
 
943
  const std::string* authenticationToken;
 
944
 
 
945
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
946
 
 
947
};
 
948
 
 
949
typedef struct _UserStore_refreshAuthentication_result__isset {
 
950
  _UserStore_refreshAuthentication_result__isset() : success(false), userException(false), systemException(false) {}
 
951
  bool success;
 
952
  bool userException;
 
953
  bool systemException;
 
954
} _UserStore_refreshAuthentication_result__isset;
 
955
 
 
956
class UserStore_refreshAuthentication_result {
 
957
 public:
 
958
 
 
959
  UserStore_refreshAuthentication_result() {
 
960
  }
 
961
 
 
962
  virtual ~UserStore_refreshAuthentication_result() throw() {}
 
963
 
 
964
  AuthenticationResult success;
 
965
  evernote::edam::EDAMUserException userException;
 
966
  evernote::edam::EDAMSystemException systemException;
 
967
 
 
968
  _UserStore_refreshAuthentication_result__isset __isset;
 
969
 
 
970
  bool operator == (const UserStore_refreshAuthentication_result & rhs) const
 
971
  {
 
972
    if (!(success == rhs.success))
 
973
      return false;
 
974
    if (!(userException == rhs.userException))
 
975
      return false;
 
976
    if (!(systemException == rhs.systemException))
 
977
      return false;
 
978
    return true;
 
979
  }
 
980
  bool operator != (const UserStore_refreshAuthentication_result &rhs) const {
 
981
    return !(*this == rhs);
 
982
  }
 
983
 
 
984
  bool operator < (const UserStore_refreshAuthentication_result & ) const;
 
985
 
 
986
  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
 
987
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
988
 
 
989
};
 
990
 
 
991
typedef struct _UserStore_refreshAuthentication_presult__isset {
 
992
  _UserStore_refreshAuthentication_presult__isset() : success(false), userException(false), systemException(false) {}
 
993
  bool success;
 
994
  bool userException;
 
995
  bool systemException;
 
996
} _UserStore_refreshAuthentication_presult__isset;
 
997
 
 
998
class UserStore_refreshAuthentication_presult {
 
999
 public:
 
1000
 
 
1001
 
 
1002
  virtual ~UserStore_refreshAuthentication_presult() throw() {}
 
1003
 
 
1004
  AuthenticationResult* success;
 
1005
  evernote::edam::EDAMUserException userException;
 
1006
  evernote::edam::EDAMSystemException systemException;
 
1007
 
 
1008
  _UserStore_refreshAuthentication_presult__isset __isset;
 
1009
 
 
1010
  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
 
1011
 
 
1012
};
 
1013
 
 
1014
typedef struct _UserStore_getUser_args__isset {
 
1015
  _UserStore_getUser_args__isset() : authenticationToken(false) {}
 
1016
  bool authenticationToken;
 
1017
} _UserStore_getUser_args__isset;
 
1018
 
 
1019
class UserStore_getUser_args {
 
1020
 public:
 
1021
 
 
1022
  UserStore_getUser_args() : authenticationToken("") {
 
1023
  }
 
1024
 
 
1025
  virtual ~UserStore_getUser_args() throw() {}
 
1026
 
 
1027
  std::string authenticationToken;
 
1028
 
 
1029
  _UserStore_getUser_args__isset __isset;
 
1030
 
 
1031
  bool operator == (const UserStore_getUser_args & rhs) const
 
1032
  {
 
1033
    if (!(authenticationToken == rhs.authenticationToken))
 
1034
      return false;
 
1035
    return true;
 
1036
  }
 
1037
  bool operator != (const UserStore_getUser_args &rhs) const {
 
1038
    return !(*this == rhs);
 
1039
  }
 
1040
 
 
1041
  bool operator < (const UserStore_getUser_args & ) const;
 
1042
 
 
1043
  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
 
1044
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
1045
 
 
1046
};
 
1047
 
 
1048
 
 
1049
class UserStore_getUser_pargs {
 
1050
 public:
 
1051
 
 
1052
 
 
1053
  virtual ~UserStore_getUser_pargs() throw() {}
 
1054
 
 
1055
  const std::string* authenticationToken;
 
1056
 
 
1057
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
1058
 
 
1059
};
 
1060
 
 
1061
typedef struct _UserStore_getUser_result__isset {
 
1062
  _UserStore_getUser_result__isset() : success(false), userException(false), systemException(false) {}
 
1063
  bool success;
 
1064
  bool userException;
 
1065
  bool systemException;
 
1066
} _UserStore_getUser_result__isset;
 
1067
 
 
1068
class UserStore_getUser_result {
 
1069
 public:
 
1070
 
 
1071
  UserStore_getUser_result() {
 
1072
  }
 
1073
 
 
1074
  virtual ~UserStore_getUser_result() throw() {}
 
1075
 
 
1076
  evernote::edam::User success;
 
1077
  evernote::edam::EDAMUserException userException;
 
1078
  evernote::edam::EDAMSystemException systemException;
 
1079
 
 
1080
  _UserStore_getUser_result__isset __isset;
 
1081
 
 
1082
  bool operator == (const UserStore_getUser_result & rhs) const
 
1083
  {
 
1084
    if (!(success == rhs.success))
 
1085
      return false;
 
1086
    if (!(userException == rhs.userException))
 
1087
      return false;
 
1088
    if (!(systemException == rhs.systemException))
 
1089
      return false;
 
1090
    return true;
 
1091
  }
 
1092
  bool operator != (const UserStore_getUser_result &rhs) const {
 
1093
    return !(*this == rhs);
 
1094
  }
 
1095
 
 
1096
  bool operator < (const UserStore_getUser_result & ) const;
 
1097
 
 
1098
  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
 
1099
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
1100
 
 
1101
};
 
1102
 
 
1103
typedef struct _UserStore_getUser_presult__isset {
 
1104
  _UserStore_getUser_presult__isset() : success(false), userException(false), systemException(false) {}
 
1105
  bool success;
 
1106
  bool userException;
 
1107
  bool systemException;
 
1108
} _UserStore_getUser_presult__isset;
 
1109
 
 
1110
class UserStore_getUser_presult {
 
1111
 public:
 
1112
 
 
1113
 
 
1114
  virtual ~UserStore_getUser_presult() throw() {}
 
1115
 
 
1116
  evernote::edam::User* success;
 
1117
  evernote::edam::EDAMUserException userException;
 
1118
  evernote::edam::EDAMSystemException systemException;
 
1119
 
 
1120
  _UserStore_getUser_presult__isset __isset;
 
1121
 
 
1122
  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
 
1123
 
 
1124
};
 
1125
 
 
1126
typedef struct _UserStore_getPublicUserInfo_args__isset {
 
1127
  _UserStore_getPublicUserInfo_args__isset() : username(false) {}
 
1128
  bool username;
 
1129
} _UserStore_getPublicUserInfo_args__isset;
 
1130
 
 
1131
class UserStore_getPublicUserInfo_args {
 
1132
 public:
 
1133
 
 
1134
  UserStore_getPublicUserInfo_args() : username("") {
 
1135
  }
 
1136
 
 
1137
  virtual ~UserStore_getPublicUserInfo_args() throw() {}
 
1138
 
 
1139
  std::string username;
 
1140
 
 
1141
  _UserStore_getPublicUserInfo_args__isset __isset;
 
1142
 
 
1143
  bool operator == (const UserStore_getPublicUserInfo_args & rhs) const
 
1144
  {
 
1145
    if (!(username == rhs.username))
 
1146
      return false;
 
1147
    return true;
 
1148
  }
 
1149
  bool operator != (const UserStore_getPublicUserInfo_args &rhs) const {
 
1150
    return !(*this == rhs);
 
1151
  }
 
1152
 
 
1153
  bool operator < (const UserStore_getPublicUserInfo_args & ) const;
 
1154
 
 
1155
  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
 
1156
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
1157
 
 
1158
};
 
1159
 
 
1160
 
 
1161
class UserStore_getPublicUserInfo_pargs {
 
1162
 public:
 
1163
 
 
1164
 
 
1165
  virtual ~UserStore_getPublicUserInfo_pargs() throw() {}
 
1166
 
 
1167
  const std::string* username;
 
1168
 
 
1169
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
1170
 
 
1171
};
 
1172
 
 
1173
typedef struct _UserStore_getPublicUserInfo_result__isset {
 
1174
  _UserStore_getPublicUserInfo_result__isset() : success(false), notFoundException(false), systemException(false), userException(false) {}
 
1175
  bool success;
 
1176
  bool notFoundException;
 
1177
  bool systemException;
 
1178
  bool userException;
 
1179
} _UserStore_getPublicUserInfo_result__isset;
 
1180
 
 
1181
class UserStore_getPublicUserInfo_result {
 
1182
 public:
 
1183
 
 
1184
  UserStore_getPublicUserInfo_result() {
 
1185
  }
 
1186
 
 
1187
  virtual ~UserStore_getPublicUserInfo_result() throw() {}
 
1188
 
 
1189
  PublicUserInfo success;
 
1190
  evernote::edam::EDAMNotFoundException notFoundException;
 
1191
  evernote::edam::EDAMSystemException systemException;
 
1192
  evernote::edam::EDAMUserException userException;
 
1193
 
 
1194
  _UserStore_getPublicUserInfo_result__isset __isset;
 
1195
 
 
1196
  bool operator == (const UserStore_getPublicUserInfo_result & rhs) const
 
1197
  {
 
1198
    if (!(success == rhs.success))
 
1199
      return false;
 
1200
    if (!(notFoundException == rhs.notFoundException))
 
1201
      return false;
 
1202
    if (!(systemException == rhs.systemException))
 
1203
      return false;
 
1204
    if (!(userException == rhs.userException))
 
1205
      return false;
 
1206
    return true;
 
1207
  }
 
1208
  bool operator != (const UserStore_getPublicUserInfo_result &rhs) const {
 
1209
    return !(*this == rhs);
 
1210
  }
 
1211
 
 
1212
  bool operator < (const UserStore_getPublicUserInfo_result & ) const;
 
1213
 
 
1214
  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
 
1215
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
1216
 
 
1217
};
 
1218
 
 
1219
typedef struct _UserStore_getPublicUserInfo_presult__isset {
 
1220
  _UserStore_getPublicUserInfo_presult__isset() : success(false), notFoundException(false), systemException(false), userException(false) {}
 
1221
  bool success;
 
1222
  bool notFoundException;
 
1223
  bool systemException;
 
1224
  bool userException;
 
1225
} _UserStore_getPublicUserInfo_presult__isset;
 
1226
 
 
1227
class UserStore_getPublicUserInfo_presult {
 
1228
 public:
 
1229
 
 
1230
 
 
1231
  virtual ~UserStore_getPublicUserInfo_presult() throw() {}
 
1232
 
 
1233
  PublicUserInfo* success;
 
1234
  evernote::edam::EDAMNotFoundException notFoundException;
 
1235
  evernote::edam::EDAMSystemException systemException;
 
1236
  evernote::edam::EDAMUserException userException;
 
1237
 
 
1238
  _UserStore_getPublicUserInfo_presult__isset __isset;
 
1239
 
 
1240
  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
 
1241
 
 
1242
};
 
1243
 
 
1244
typedef struct _UserStore_getPremiumInfo_args__isset {
 
1245
  _UserStore_getPremiumInfo_args__isset() : authenticationToken(false) {}
 
1246
  bool authenticationToken;
 
1247
} _UserStore_getPremiumInfo_args__isset;
 
1248
 
 
1249
class UserStore_getPremiumInfo_args {
 
1250
 public:
 
1251
 
 
1252
  UserStore_getPremiumInfo_args() : authenticationToken("") {
 
1253
  }
 
1254
 
 
1255
  virtual ~UserStore_getPremiumInfo_args() throw() {}
 
1256
 
 
1257
  std::string authenticationToken;
 
1258
 
 
1259
  _UserStore_getPremiumInfo_args__isset __isset;
 
1260
 
 
1261
  bool operator == (const UserStore_getPremiumInfo_args & rhs) const
 
1262
  {
 
1263
    if (!(authenticationToken == rhs.authenticationToken))
 
1264
      return false;
 
1265
    return true;
 
1266
  }
 
1267
  bool operator != (const UserStore_getPremiumInfo_args &rhs) const {
 
1268
    return !(*this == rhs);
 
1269
  }
 
1270
 
 
1271
  bool operator < (const UserStore_getPremiumInfo_args & ) const;
 
1272
 
 
1273
  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
 
1274
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
1275
 
 
1276
};
 
1277
 
 
1278
 
 
1279
class UserStore_getPremiumInfo_pargs {
 
1280
 public:
 
1281
 
 
1282
 
 
1283
  virtual ~UserStore_getPremiumInfo_pargs() throw() {}
 
1284
 
 
1285
  const std::string* authenticationToken;
 
1286
 
 
1287
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
1288
 
 
1289
};
 
1290
 
 
1291
typedef struct _UserStore_getPremiumInfo_result__isset {
 
1292
  _UserStore_getPremiumInfo_result__isset() : success(false), userException(false), systemException(false) {}
 
1293
  bool success;
 
1294
  bool userException;
 
1295
  bool systemException;
 
1296
} _UserStore_getPremiumInfo_result__isset;
 
1297
 
 
1298
class UserStore_getPremiumInfo_result {
 
1299
 public:
 
1300
 
 
1301
  UserStore_getPremiumInfo_result() {
 
1302
  }
 
1303
 
 
1304
  virtual ~UserStore_getPremiumInfo_result() throw() {}
 
1305
 
 
1306
  evernote::edam::PremiumInfo success;
 
1307
  evernote::edam::EDAMUserException userException;
 
1308
  evernote::edam::EDAMSystemException systemException;
 
1309
 
 
1310
  _UserStore_getPremiumInfo_result__isset __isset;
 
1311
 
 
1312
  bool operator == (const UserStore_getPremiumInfo_result & rhs) const
 
1313
  {
 
1314
    if (!(success == rhs.success))
 
1315
      return false;
 
1316
    if (!(userException == rhs.userException))
 
1317
      return false;
 
1318
    if (!(systemException == rhs.systemException))
 
1319
      return false;
 
1320
    return true;
 
1321
  }
 
1322
  bool operator != (const UserStore_getPremiumInfo_result &rhs) const {
 
1323
    return !(*this == rhs);
 
1324
  }
 
1325
 
 
1326
  bool operator < (const UserStore_getPremiumInfo_result & ) const;
 
1327
 
 
1328
  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
 
1329
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
1330
 
 
1331
};
 
1332
 
 
1333
typedef struct _UserStore_getPremiumInfo_presult__isset {
 
1334
  _UserStore_getPremiumInfo_presult__isset() : success(false), userException(false), systemException(false) {}
 
1335
  bool success;
 
1336
  bool userException;
 
1337
  bool systemException;
 
1338
} _UserStore_getPremiumInfo_presult__isset;
 
1339
 
 
1340
class UserStore_getPremiumInfo_presult {
 
1341
 public:
 
1342
 
 
1343
 
 
1344
  virtual ~UserStore_getPremiumInfo_presult() throw() {}
 
1345
 
 
1346
  evernote::edam::PremiumInfo* success;
 
1347
  evernote::edam::EDAMUserException userException;
 
1348
  evernote::edam::EDAMSystemException systemException;
 
1349
 
 
1350
  _UserStore_getPremiumInfo_presult__isset __isset;
 
1351
 
 
1352
  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
 
1353
 
 
1354
};
 
1355
 
 
1356
typedef struct _UserStore_getNoteStoreUrl_args__isset {
 
1357
  _UserStore_getNoteStoreUrl_args__isset() : authenticationToken(false) {}
 
1358
  bool authenticationToken;
 
1359
} _UserStore_getNoteStoreUrl_args__isset;
 
1360
 
 
1361
class UserStore_getNoteStoreUrl_args {
 
1362
 public:
 
1363
 
 
1364
  UserStore_getNoteStoreUrl_args() : authenticationToken("") {
 
1365
  }
 
1366
 
 
1367
  virtual ~UserStore_getNoteStoreUrl_args() throw() {}
 
1368
 
 
1369
  std::string authenticationToken;
 
1370
 
 
1371
  _UserStore_getNoteStoreUrl_args__isset __isset;
 
1372
 
 
1373
  bool operator == (const UserStore_getNoteStoreUrl_args & rhs) const
 
1374
  {
 
1375
    if (!(authenticationToken == rhs.authenticationToken))
 
1376
      return false;
 
1377
    return true;
 
1378
  }
 
1379
  bool operator != (const UserStore_getNoteStoreUrl_args &rhs) const {
 
1380
    return !(*this == rhs);
 
1381
  }
 
1382
 
 
1383
  bool operator < (const UserStore_getNoteStoreUrl_args & ) const;
 
1384
 
 
1385
  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
 
1386
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
1387
 
 
1388
};
 
1389
 
 
1390
 
 
1391
class UserStore_getNoteStoreUrl_pargs {
 
1392
 public:
 
1393
 
 
1394
 
 
1395
  virtual ~UserStore_getNoteStoreUrl_pargs() throw() {}
 
1396
 
 
1397
  const std::string* authenticationToken;
 
1398
 
 
1399
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
1400
 
 
1401
};
 
1402
 
 
1403
typedef struct _UserStore_getNoteStoreUrl_result__isset {
 
1404
  _UserStore_getNoteStoreUrl_result__isset() : success(false), userException(false), systemException(false) {}
 
1405
  bool success;
 
1406
  bool userException;
 
1407
  bool systemException;
 
1408
} _UserStore_getNoteStoreUrl_result__isset;
 
1409
 
 
1410
class UserStore_getNoteStoreUrl_result {
 
1411
 public:
 
1412
 
 
1413
  UserStore_getNoteStoreUrl_result() : success("") {
 
1414
  }
 
1415
 
 
1416
  virtual ~UserStore_getNoteStoreUrl_result() throw() {}
 
1417
 
 
1418
  std::string success;
 
1419
  evernote::edam::EDAMUserException userException;
 
1420
  evernote::edam::EDAMSystemException systemException;
 
1421
 
 
1422
  _UserStore_getNoteStoreUrl_result__isset __isset;
 
1423
 
 
1424
  bool operator == (const UserStore_getNoteStoreUrl_result & rhs) const
 
1425
  {
 
1426
    if (!(success == rhs.success))
 
1427
      return false;
 
1428
    if (!(userException == rhs.userException))
 
1429
      return false;
 
1430
    if (!(systemException == rhs.systemException))
 
1431
      return false;
 
1432
    return true;
 
1433
  }
 
1434
  bool operator != (const UserStore_getNoteStoreUrl_result &rhs) const {
 
1435
    return !(*this == rhs);
 
1436
  }
 
1437
 
 
1438
  bool operator < (const UserStore_getNoteStoreUrl_result & ) const;
 
1439
 
 
1440
  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
 
1441
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
1442
 
 
1443
};
 
1444
 
 
1445
typedef struct _UserStore_getNoteStoreUrl_presult__isset {
 
1446
  _UserStore_getNoteStoreUrl_presult__isset() : success(false), userException(false), systemException(false) {}
 
1447
  bool success;
 
1448
  bool userException;
 
1449
  bool systemException;
 
1450
} _UserStore_getNoteStoreUrl_presult__isset;
 
1451
 
 
1452
class UserStore_getNoteStoreUrl_presult {
 
1453
 public:
 
1454
 
 
1455
 
 
1456
  virtual ~UserStore_getNoteStoreUrl_presult() throw() {}
 
1457
 
 
1458
  std::string* success;
 
1459
  evernote::edam::EDAMUserException userException;
 
1460
  evernote::edam::EDAMSystemException systemException;
 
1461
 
 
1462
  _UserStore_getNoteStoreUrl_presult__isset __isset;
 
1463
 
 
1464
  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
 
1465
 
 
1466
};
 
1467
 
 
1468
class UserStoreClient : virtual public UserStoreIf {
 
1469
 public:
 
1470
  UserStoreClient(boost::shared_ptr< ::apache::thrift::protocol::TProtocol> prot) :
 
1471
    piprot_(prot),
 
1472
    poprot_(prot) {
 
1473
    iprot_ = prot.get();
 
1474
    oprot_ = prot.get();
 
1475
  }
 
1476
  UserStoreClient(boost::shared_ptr< ::apache::thrift::protocol::TProtocol> iprot, boost::shared_ptr< ::apache::thrift::protocol::TProtocol> oprot) :
 
1477
    piprot_(iprot),
 
1478
    poprot_(oprot) {
 
1479
    iprot_ = iprot.get();
 
1480
    oprot_ = oprot.get();
 
1481
  }
 
1482
  boost::shared_ptr< ::apache::thrift::protocol::TProtocol> getInputProtocol() {
 
1483
    return piprot_;
 
1484
  }
 
1485
  boost::shared_ptr< ::apache::thrift::protocol::TProtocol> getOutputProtocol() {
 
1486
    return poprot_;
 
1487
  }
 
1488
  bool checkVersion(const std::string& clientName, const int16_t edamVersionMajor, const int16_t edamVersionMinor);
 
1489
  void send_checkVersion(const std::string& clientName, const int16_t edamVersionMajor, const int16_t edamVersionMinor);
 
1490
  bool recv_checkVersion();
 
1491
  void getBootstrapInfo(BootstrapInfo& _return, const std::string& locale);
 
1492
  void send_getBootstrapInfo(const std::string& locale);
 
1493
  void recv_getBootstrapInfo(BootstrapInfo& _return);
 
1494
  void authenticate(AuthenticationResult& _return, const std::string& username, const std::string& password, const std::string& consumerKey, const std::string& consumerSecret, const bool supportsTwoFactor);
 
1495
  void send_authenticate(const std::string& username, const std::string& password, const std::string& consumerKey, const std::string& consumerSecret, const bool supportsTwoFactor);
 
1496
  void recv_authenticate(AuthenticationResult& _return);
 
1497
  void authenticateLongSession(AuthenticationResult& _return, const std::string& username, const std::string& password, const std::string& consumerKey, const std::string& consumerSecret, const std::string& deviceIdentifier, const std::string& deviceDescription, const bool supportsTwoFactor);
 
1498
  void send_authenticateLongSession(const std::string& username, const std::string& password, const std::string& consumerKey, const std::string& consumerSecret, const std::string& deviceIdentifier, const std::string& deviceDescription, const bool supportsTwoFactor);
 
1499
  void recv_authenticateLongSession(AuthenticationResult& _return);
 
1500
  void completeTwoFactorAuthentication(AuthenticationResult& _return, const std::string& authenticationToken, const std::string& oneTimeCode, const std::string& deviceIdentifier, const std::string& deviceDescription);
 
1501
  void send_completeTwoFactorAuthentication(const std::string& authenticationToken, const std::string& oneTimeCode, const std::string& deviceIdentifier, const std::string& deviceDescription);
 
1502
  void recv_completeTwoFactorAuthentication(AuthenticationResult& _return);
 
1503
  void revokeLongSession(const std::string& authenticationToken);
 
1504
  void send_revokeLongSession(const std::string& authenticationToken);
 
1505
  void recv_revokeLongSession();
 
1506
  void authenticateToBusiness(AuthenticationResult& _return, const std::string& authenticationToken);
 
1507
  void send_authenticateToBusiness(const std::string& authenticationToken);
 
1508
  void recv_authenticateToBusiness(AuthenticationResult& _return);
 
1509
  void refreshAuthentication(AuthenticationResult& _return, const std::string& authenticationToken);
 
1510
  void send_refreshAuthentication(const std::string& authenticationToken);
 
1511
  void recv_refreshAuthentication(AuthenticationResult& _return);
 
1512
  void getUser(evernote::edam::User& _return, const std::string& authenticationToken);
 
1513
  void send_getUser(const std::string& authenticationToken);
 
1514
  void recv_getUser(evernote::edam::User& _return);
 
1515
  void getPublicUserInfo(PublicUserInfo& _return, const std::string& username);
 
1516
  void send_getPublicUserInfo(const std::string& username);
 
1517
  void recv_getPublicUserInfo(PublicUserInfo& _return);
 
1518
  void getPremiumInfo(evernote::edam::PremiumInfo& _return, const std::string& authenticationToken);
 
1519
  void send_getPremiumInfo(const std::string& authenticationToken);
 
1520
  void recv_getPremiumInfo(evernote::edam::PremiumInfo& _return);
 
1521
  void getNoteStoreUrl(std::string& _return, const std::string& authenticationToken);
 
1522
  void send_getNoteStoreUrl(const std::string& authenticationToken);
 
1523
  void recv_getNoteStoreUrl(std::string& _return);
 
1524
 protected:
 
1525
  boost::shared_ptr< ::apache::thrift::protocol::TProtocol> piprot_;
 
1526
  boost::shared_ptr< ::apache::thrift::protocol::TProtocol> poprot_;
 
1527
  ::apache::thrift::protocol::TProtocol* iprot_;
 
1528
  ::apache::thrift::protocol::TProtocol* oprot_;
 
1529
};
 
1530
 
 
1531
class UserStoreProcessor : virtual public ::apache::thrift::TProcessor {
 
1532
 protected:
 
1533
  boost::shared_ptr<UserStoreIf> iface_;
 
1534
  virtual bool process_fn(::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, std::string& fname, int32_t seqid);
 
1535
 private:
 
1536
  std::map<std::string, void (UserStoreProcessor::*)(int32_t, ::apache::thrift::protocol::TProtocol*, ::apache::thrift::protocol::TProtocol*)> processMap_;
 
1537
  void process_checkVersion(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot);
 
1538
  void process_getBootstrapInfo(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot);
 
1539
  void process_authenticate(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot);
 
1540
  void process_authenticateLongSession(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot);
 
1541
  void process_completeTwoFactorAuthentication(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot);
 
1542
  void process_revokeLongSession(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot);
 
1543
  void process_authenticateToBusiness(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot);
 
1544
  void process_refreshAuthentication(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot);
 
1545
  void process_getUser(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot);
 
1546
  void process_getPublicUserInfo(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot);
 
1547
  void process_getPremiumInfo(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot);
 
1548
  void process_getNoteStoreUrl(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot);
 
1549
 public:
 
1550
  UserStoreProcessor(boost::shared_ptr<UserStoreIf> iface) :
 
1551
    iface_(iface) {
 
1552
    processMap_["checkVersion"] = &UserStoreProcessor::process_checkVersion;
 
1553
    processMap_["getBootstrapInfo"] = &UserStoreProcessor::process_getBootstrapInfo;
 
1554
    processMap_["authenticate"] = &UserStoreProcessor::process_authenticate;
 
1555
    processMap_["authenticateLongSession"] = &UserStoreProcessor::process_authenticateLongSession;
 
1556
    processMap_["completeTwoFactorAuthentication"] = &UserStoreProcessor::process_completeTwoFactorAuthentication;
 
1557
    processMap_["revokeLongSession"] = &UserStoreProcessor::process_revokeLongSession;
 
1558
    processMap_["authenticateToBusiness"] = &UserStoreProcessor::process_authenticateToBusiness;
 
1559
    processMap_["refreshAuthentication"] = &UserStoreProcessor::process_refreshAuthentication;
 
1560
    processMap_["getUser"] = &UserStoreProcessor::process_getUser;
 
1561
    processMap_["getPublicUserInfo"] = &UserStoreProcessor::process_getPublicUserInfo;
 
1562
    processMap_["getPremiumInfo"] = &UserStoreProcessor::process_getPremiumInfo;
 
1563
    processMap_["getNoteStoreUrl"] = &UserStoreProcessor::process_getNoteStoreUrl;
 
1564
  }
 
1565
 
 
1566
  virtual bool process(boost::shared_ptr< ::apache::thrift::protocol::TProtocol> piprot, boost::shared_ptr< ::apache::thrift::protocol::TProtocol> poprot);
 
1567
  virtual ~UserStoreProcessor() {}
 
1568
};
 
1569
 
 
1570
class UserStoreMultiface : virtual public UserStoreIf {
 
1571
 public:
 
1572
  UserStoreMultiface(std::vector<boost::shared_ptr<UserStoreIf> >& ifaces) : ifaces_(ifaces) {
 
1573
  }
 
1574
  virtual ~UserStoreMultiface() {}
 
1575
 protected:
 
1576
  std::vector<boost::shared_ptr<UserStoreIf> > ifaces_;
 
1577
  UserStoreMultiface() {}
 
1578
  void add(boost::shared_ptr<UserStoreIf> iface) {
 
1579
    ifaces_.push_back(iface);
 
1580
  }
 
1581
 public:
 
1582
  bool checkVersion(const std::string& clientName, const int16_t edamVersionMajor, const int16_t edamVersionMinor) {
 
1583
    uint32_t sz = ifaces_.size();
 
1584
    for (uint32_t i = 0; i < sz; ++i) {
 
1585
      if (i == sz - 1) {
 
1586
        return ifaces_[i]->checkVersion(clientName, edamVersionMajor, edamVersionMinor);
 
1587
      } else {
 
1588
        ifaces_[i]->checkVersion(clientName, edamVersionMajor, edamVersionMinor);
 
1589
      }
 
1590
    }
 
1591
  }
 
1592
 
 
1593
  void getBootstrapInfo(BootstrapInfo& _return, const std::string& locale) {
 
1594
    uint32_t sz = ifaces_.size();
 
1595
    for (uint32_t i = 0; i < sz; ++i) {
 
1596
      if (i == sz - 1) {
 
1597
        ifaces_[i]->getBootstrapInfo(_return, locale);
 
1598
        return;
 
1599
      } else {
 
1600
        ifaces_[i]->getBootstrapInfo(_return, locale);
 
1601
      }
 
1602
    }
 
1603
  }
 
1604
 
 
1605
  void authenticate(AuthenticationResult& _return, const std::string& username, const std::string& password, const std::string& consumerKey, const std::string& consumerSecret, const bool supportsTwoFactor) {
 
1606
    uint32_t sz = ifaces_.size();
 
1607
    for (uint32_t i = 0; i < sz; ++i) {
 
1608
      if (i == sz - 1) {
 
1609
        ifaces_[i]->authenticate(_return, username, password, consumerKey, consumerSecret, supportsTwoFactor);
 
1610
        return;
 
1611
      } else {
 
1612
        ifaces_[i]->authenticate(_return, username, password, consumerKey, consumerSecret, supportsTwoFactor);
 
1613
      }
 
1614
    }
 
1615
  }
 
1616
 
 
1617
  void authenticateLongSession(AuthenticationResult& _return, const std::string& username, const std::string& password, const std::string& consumerKey, const std::string& consumerSecret, const std::string& deviceIdentifier, const std::string& deviceDescription, const bool supportsTwoFactor) {
 
1618
    uint32_t sz = ifaces_.size();
 
1619
    for (uint32_t i = 0; i < sz; ++i) {
 
1620
      if (i == sz - 1) {
 
1621
        ifaces_[i]->authenticateLongSession(_return, username, password, consumerKey, consumerSecret, deviceIdentifier, deviceDescription, supportsTwoFactor);
 
1622
        return;
 
1623
      } else {
 
1624
        ifaces_[i]->authenticateLongSession(_return, username, password, consumerKey, consumerSecret, deviceIdentifier, deviceDescription, supportsTwoFactor);
 
1625
      }
 
1626
    }
 
1627
  }
 
1628
 
 
1629
  void completeTwoFactorAuthentication(AuthenticationResult& _return, const std::string& authenticationToken, const std::string& oneTimeCode, const std::string& deviceIdentifier, const std::string& deviceDescription) {
 
1630
    uint32_t sz = ifaces_.size();
 
1631
    for (uint32_t i = 0; i < sz; ++i) {
 
1632
      if (i == sz - 1) {
 
1633
        ifaces_[i]->completeTwoFactorAuthentication(_return, authenticationToken, oneTimeCode, deviceIdentifier, deviceDescription);
 
1634
        return;
 
1635
      } else {
 
1636
        ifaces_[i]->completeTwoFactorAuthentication(_return, authenticationToken, oneTimeCode, deviceIdentifier, deviceDescription);
 
1637
      }
 
1638
    }
 
1639
  }
 
1640
 
 
1641
  void revokeLongSession(const std::string& authenticationToken) {
 
1642
    uint32_t sz = ifaces_.size();
 
1643
    for (uint32_t i = 0; i < sz; ++i) {
 
1644
      ifaces_[i]->revokeLongSession(authenticationToken);
 
1645
    }
 
1646
  }
 
1647
 
 
1648
  void authenticateToBusiness(AuthenticationResult& _return, const std::string& authenticationToken) {
 
1649
    uint32_t sz = ifaces_.size();
 
1650
    for (uint32_t i = 0; i < sz; ++i) {
 
1651
      if (i == sz - 1) {
 
1652
        ifaces_[i]->authenticateToBusiness(_return, authenticationToken);
 
1653
        return;
 
1654
      } else {
 
1655
        ifaces_[i]->authenticateToBusiness(_return, authenticationToken);
 
1656
      }
 
1657
    }
 
1658
  }
 
1659
 
 
1660
  void refreshAuthentication(AuthenticationResult& _return, const std::string& authenticationToken) {
 
1661
    uint32_t sz = ifaces_.size();
 
1662
    for (uint32_t i = 0; i < sz; ++i) {
 
1663
      if (i == sz - 1) {
 
1664
        ifaces_[i]->refreshAuthentication(_return, authenticationToken);
 
1665
        return;
 
1666
      } else {
 
1667
        ifaces_[i]->refreshAuthentication(_return, authenticationToken);
 
1668
      }
 
1669
    }
 
1670
  }
 
1671
 
 
1672
  void getUser(evernote::edam::User& _return, const std::string& authenticationToken) {
 
1673
    uint32_t sz = ifaces_.size();
 
1674
    for (uint32_t i = 0; i < sz; ++i) {
 
1675
      if (i == sz - 1) {
 
1676
        ifaces_[i]->getUser(_return, authenticationToken);
 
1677
        return;
 
1678
      } else {
 
1679
        ifaces_[i]->getUser(_return, authenticationToken);
 
1680
      }
 
1681
    }
 
1682
  }
 
1683
 
 
1684
  void getPublicUserInfo(PublicUserInfo& _return, const std::string& username) {
 
1685
    uint32_t sz = ifaces_.size();
 
1686
    for (uint32_t i = 0; i < sz; ++i) {
 
1687
      if (i == sz - 1) {
 
1688
        ifaces_[i]->getPublicUserInfo(_return, username);
 
1689
        return;
 
1690
      } else {
 
1691
        ifaces_[i]->getPublicUserInfo(_return, username);
 
1692
      }
 
1693
    }
 
1694
  }
 
1695
 
 
1696
  void getPremiumInfo(evernote::edam::PremiumInfo& _return, const std::string& authenticationToken) {
 
1697
    uint32_t sz = ifaces_.size();
 
1698
    for (uint32_t i = 0; i < sz; ++i) {
 
1699
      if (i == sz - 1) {
 
1700
        ifaces_[i]->getPremiumInfo(_return, authenticationToken);
 
1701
        return;
 
1702
      } else {
 
1703
        ifaces_[i]->getPremiumInfo(_return, authenticationToken);
 
1704
      }
 
1705
    }
 
1706
  }
 
1707
 
 
1708
  void getNoteStoreUrl(std::string& _return, const std::string& authenticationToken) {
 
1709
    uint32_t sz = ifaces_.size();
 
1710
    for (uint32_t i = 0; i < sz; ++i) {
 
1711
      if (i == sz - 1) {
 
1712
        ifaces_[i]->getNoteStoreUrl(_return, authenticationToken);
 
1713
        return;
 
1714
      } else {
 
1715
        ifaces_[i]->getNoteStoreUrl(_return, authenticationToken);
 
1716
      }
 
1717
    }
 
1718
  }
 
1719
 
 
1720
};
 
1721
 
 
1722
}} // namespace
 
1723
 
 
1724
#endif