Subversion Repositories SmartDukaan

Rev

Rev 504 | Rev 559 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
94 ashish 1 
#
2 
# Autogenerated by Thrift
3 
#
4 
# DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
5 
#
6 
 
7 
from thrift.Thrift import *
8 
from ttypes import *
9 
from thrift.Thrift import TProcessor
10 
from thrift.transport import TTransport
11 
from thrift.protocol import TBinaryProtocol
12 
try:
13 
  from thrift.protocol import fastbinary
14 
except:
15 
  fastbinary = None
16 
 
17 
 
18 
class Iface:
19 
  """
20 
  service
21 
  """
22 
  def createContext(self, context, updateExisting):
23 
    """
24 
    Parameters:
25 
     - context
26 
     - updateExisting
27 
    """
28 
    pass
29 
 
122 ashish 30 
  def getContextFromId(self, userId, isSessionId):
94 ashish 31 
    """
32 
    Parameters:
33 
     - userId
122 ashish 34 
     - isSessionId
94 ashish 35 
    """
36 
    pass
37 
 
38 
  def getContextFromEmailOrHandle(self, emailorhandle, isEmail):
39 
    """
40 
    Parameters:
41 
     - emailorhandle
42 
     - isEmail
43 
    """
44 
    pass
45 
 
122 ashish 46 
  def getState(self, userId, isSessionId):
94 ashish 47 
    """
48 
    Parameters:
49 
     - userId
122 ashish 50 
     - isSessionId
94 ashish 51 
    """
52 
    pass
53 
 
122 ashish 54 
  def getPrimaryInfo(self, userId, isSessionId):
94 ashish 55 
    """
56 
    Parameters:
57 
     - userId
122 ashish 58 
     - isSessionId
94 ashish 59 
    """
60 
    pass
61 
 
122 ashish 62 
  def getInternalInfo(self, userId, isSessionId):
94 ashish 63 
    """
64 
    Parameters:
65 
     - userId
122 ashish 66 
     - isSessionId
94 ashish 67 
    """
68 
    pass
69 
 
70 
  def getContext(self, email, password):
71 
    """
72 
    Parameters:
73 
     - email
74 
     - password
75 
    """
76 
    pass
77 
 
122 ashish 78 
  def authenticateUser(self, handle, password, isEmail):
79 
    """
80 
    Parameters:
81 
     - handle
82 
     - password
83 
     - isEmail
84 
    """
85 
    pass
86 
 
94 ashish 87 
  def userExists(self, email):
88 
    """
89 
    Parameters:
90 
     - email
91 
    """
92 
    pass
93 
 
94 
  def addIpAdressForUser(self, ip, timestamp, userId):
95 
    """
96 
    Parameters:
97 
     - ip
98 
     - timestamp
99 
     - userId
100 
    """
101 
    pass
102 
 
513 rajveer 103 
  def addAddressForUser(self, address, userid, timestamp, setDefault):
94 ashish 104 
    """
105 
    Parameters:
106 
     - address
107 
     - userid
108 
     - timestamp
513 rajveer 109 
     - setDefault
94 ashish 110 
    """
111 
    pass
112 
 
113 
  def removeAddressForUser(self, userid, addressId):
114 
    """
115 
    Parameters:
116 
     - userid
117 
     - addressId
118 
    """
119 
    pass
120 
 
121 
  def setUserAsLoggedIn(self, userId, timestamp):
122 
    """
123 
    Parameters:
124 
     - userId
125 
     - timestamp
126 
    """
127 
    pass
128 
 
129 
  def setUserAsLoggedOut(self, userid, timestamp):
130 
    """
131 
    Parameters:
132 
     - userid
133 
     - timestamp
134 
    """
135 
    pass
136 
 
504 rajveer 137 
  def setDefaultAddress(self, userid, addressId):
138 
    """
139 
    Parameters:
140 
     - userid
141 
     - addressId
142 
    """
143 
    pass
144 
 
94 ashish 145 
  def updatePassword(self, userid, password):
146 
    """
147 
    Parameters:
148 
     - userid
149 
     - password
150 
    """
151 
    pass
152 
 
122 ashish 153 
  def deleteUser(self, userid, isSessionId):
94 ashish 154 
    """
155 
    Parameters:
156 
     - userid
122 ashish 157 
     - isSessionId
94 ashish 158 
    """
159 
    pass
160 
 
161 
  def sendEmailVerification(self, userid):
162 
    """
163 
    Parameters:
164 
     - userid
165 
    """
166 
    pass
167 
 
168 
  def sendSMSVerification(self, userid):
169 
    """
170 
    Parameters:
171 
     - userid
172 
    """
173 
    pass
174 
 
175 
  def confirmEmailVerification(self, userid):
176 
    """
177 
    Parameters:
178 
     - userid
179 
    """
180 
    pass
181 
 
182 
  def confirmSMSVerification(self, userid):
183 
    """
184 
    Parameters:
185 
     - userid
186 
    """
187 
    pass
188 
 
189 
  def addSocialhandle(self, userid, socialService, handle):
190 
    """
191 
    Parameters:
192 
     - userid
193 
     - socialService
194 
     - handle
195 
    """
196 
    pass
197 
 
130 ashish 198 
  def sendNewPasswordById(self, userid):
199 
    """
200 
    Parameters:
201 
     - userid
202 
    """
203 
    pass
94 ashish 204 
 
130 ashish 205 
  def sendNewPasswordByHandle(self, emailOrHandle, isEmail):
206 
    """
207 
    Parameters:
208 
     - emailOrHandle
209 
     - isEmail
210 
    """
211 
    pass
212 
 
213 
 
94 ashish 214 
class Client(Iface):
215 
  """
216 
  service
217 
  """
218 
  def __init__(self, iprot, oprot=None):
219 
    self._iprot = self._oprot = iprot
220 
    if oprot != None:
221 
      self._oprot = oprot
222 
    self._seqid = 0
223 
 
224 
  def createContext(self, context, updateExisting):
225 
    """
226 
    Parameters:
227 
     - context
228 
     - updateExisting
229 
    """
230 
    self.send_createContext(context, updateExisting)
231 
    return self.recv_createContext()
232 
 
233 
  def send_createContext(self, context, updateExisting):
234 
    self._oprot.writeMessageBegin('createContext', TMessageType.CALL, self._seqid)
235 
    args = createContext_args()
236 
    args.context = context
237 
    args.updateExisting = updateExisting
238 
    args.write(self._oprot)
239 
    self._oprot.writeMessageEnd()
240 
    self._oprot.trans.flush()
241 
 
242 
  def recv_createContext(self, ):
243 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
244 
    if mtype == TMessageType.EXCEPTION:
245 
      x = TApplicationException()
246 
      x.read(self._iprot)
247 
      self._iprot.readMessageEnd()
248 
      raise x
249 
    result = createContext_result()
250 
    result.read(self._iprot)
251 
    self._iprot.readMessageEnd()
252 
    if result.success != None:
253 
      return result.success
254 
    if result.cex != None:
255 
      raise result.cex
256 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createContext failed: unknown result");
257 
 
122 ashish 258 
  def getContextFromId(self, userId, isSessionId):
94 ashish 259 
    """
260 
    Parameters:
261 
     - userId
122 ashish 262 
     - isSessionId
94 ashish 263 
    """
122 ashish 264 
    self.send_getContextFromId(userId, isSessionId)
94 ashish 265 
    return self.recv_getContextFromId()
266 
 
122 ashish 267 
  def send_getContextFromId(self, userId, isSessionId):
94 ashish 268 
    self._oprot.writeMessageBegin('getContextFromId', TMessageType.CALL, self._seqid)
269 
    args = getContextFromId_args()
270 
    args.userId = userId
122 ashish 271 
    args.isSessionId = isSessionId
94 ashish 272 
    args.write(self._oprot)
273 
    self._oprot.writeMessageEnd()
274 
    self._oprot.trans.flush()
275 
 
276 
  def recv_getContextFromId(self, ):
277 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
278 
    if mtype == TMessageType.EXCEPTION:
279 
      x = TApplicationException()
280 
      x.read(self._iprot)
281 
      self._iprot.readMessageEnd()
282 
      raise x
283 
    result = getContextFromId_result()
284 
    result.read(self._iprot)
285 
    self._iprot.readMessageEnd()
286 
    if result.success != None:
287 
      return result.success
288 
    if result.ucx != None:
289 
      raise result.ucx
290 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getContextFromId failed: unknown result");
291 
 
292 
  def getContextFromEmailOrHandle(self, emailorhandle, isEmail):
293 
    """
294 
    Parameters:
295 
     - emailorhandle
296 
     - isEmail
297 
    """
298 
    self.send_getContextFromEmailOrHandle(emailorhandle, isEmail)
299 
    return self.recv_getContextFromEmailOrHandle()
300 
 
301 
  def send_getContextFromEmailOrHandle(self, emailorhandle, isEmail):
302 
    self._oprot.writeMessageBegin('getContextFromEmailOrHandle', TMessageType.CALL, self._seqid)
303 
    args = getContextFromEmailOrHandle_args()
304 
    args.emailorhandle = emailorhandle
305 
    args.isEmail = isEmail
306 
    args.write(self._oprot)
307 
    self._oprot.writeMessageEnd()
308 
    self._oprot.trans.flush()
309 
 
310 
  def recv_getContextFromEmailOrHandle(self, ):
311 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
312 
    if mtype == TMessageType.EXCEPTION:
313 
      x = TApplicationException()
314 
      x.read(self._iprot)
315 
      self._iprot.readMessageEnd()
316 
      raise x
317 
    result = getContextFromEmailOrHandle_result()
318 
    result.read(self._iprot)
319 
    self._iprot.readMessageEnd()
320 
    if result.success != None:
321 
      return result.success
322 
    if result.ucx != None:
323 
      raise result.ucx
324 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getContextFromEmailOrHandle failed: unknown result");
325 
 
122 ashish 326 
  def getState(self, userId, isSessionId):
94 ashish 327 
    """
328 
    Parameters:
329 
     - userId
122 ashish 330 
     - isSessionId
94 ashish 331 
    """
122 ashish 332 
    self.send_getState(userId, isSessionId)
94 ashish 333 
    return self.recv_getState()
334 
 
122 ashish 335 
  def send_getState(self, userId, isSessionId):
94 ashish 336 
    self._oprot.writeMessageBegin('getState', TMessageType.CALL, self._seqid)
337 
    args = getState_args()
338 
    args.userId = userId
122 ashish 339 
    args.isSessionId = isSessionId
94 ashish 340 
    args.write(self._oprot)
341 
    self._oprot.writeMessageEnd()
342 
    self._oprot.trans.flush()
343 
 
344 
  def recv_getState(self, ):
345 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
346 
    if mtype == TMessageType.EXCEPTION:
347 
      x = TApplicationException()
348 
      x.read(self._iprot)
349 
      self._iprot.readMessageEnd()
350 
      raise x
351 
    result = getState_result()
352 
    result.read(self._iprot)
353 
    self._iprot.readMessageEnd()
354 
    if result.success != None:
355 
      return result.success
356 
    if result.ucx != None:
357 
      raise result.ucx
358 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getState failed: unknown result");
359 
 
122 ashish 360 
  def getPrimaryInfo(self, userId, isSessionId):
94 ashish 361 
    """
362 
    Parameters:
363 
     - userId
122 ashish 364 
     - isSessionId
94 ashish 365 
    """
122 ashish 366 
    self.send_getPrimaryInfo(userId, isSessionId)
94 ashish 367 
    return self.recv_getPrimaryInfo()
368 
 
122 ashish 369 
  def send_getPrimaryInfo(self, userId, isSessionId):
94 ashish 370 
    self._oprot.writeMessageBegin('getPrimaryInfo', TMessageType.CALL, self._seqid)
371 
    args = getPrimaryInfo_args()
372 
    args.userId = userId
122 ashish 373 
    args.isSessionId = isSessionId
94 ashish 374 
    args.write(self._oprot)
375 
    self._oprot.writeMessageEnd()
376 
    self._oprot.trans.flush()
377 
 
378 
  def recv_getPrimaryInfo(self, ):
379 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
380 
    if mtype == TMessageType.EXCEPTION:
381 
      x = TApplicationException()
382 
      x.read(self._iprot)
383 
      self._iprot.readMessageEnd()
384 
      raise x
385 
    result = getPrimaryInfo_result()
386 
    result.read(self._iprot)
387 
    self._iprot.readMessageEnd()
388 
    if result.success != None:
389 
      return result.success
390 
    if result.ucx != None:
391 
      raise result.ucx
392 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getPrimaryInfo failed: unknown result");
393 
 
122 ashish 394 
  def getInternalInfo(self, userId, isSessionId):
94 ashish 395 
    """
396 
    Parameters:
397 
     - userId
122 ashish 398 
     - isSessionId
94 ashish 399 
    """
122 ashish 400 
    self.send_getInternalInfo(userId, isSessionId)
94 ashish 401 
    return self.recv_getInternalInfo()
402 
 
122 ashish 403 
  def send_getInternalInfo(self, userId, isSessionId):
94 ashish 404 
    self._oprot.writeMessageBegin('getInternalInfo', TMessageType.CALL, self._seqid)
405 
    args = getInternalInfo_args()
406 
    args.userId = userId
122 ashish 407 
    args.isSessionId = isSessionId
94 ashish 408 
    args.write(self._oprot)
409 
    self._oprot.writeMessageEnd()
410 
    self._oprot.trans.flush()
411 
 
412 
  def recv_getInternalInfo(self, ):
413 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
414 
    if mtype == TMessageType.EXCEPTION:
415 
      x = TApplicationException()
416 
      x.read(self._iprot)
417 
      self._iprot.readMessageEnd()
418 
      raise x
419 
    result = getInternalInfo_result()
420 
    result.read(self._iprot)
421 
    self._iprot.readMessageEnd()
422 
    if result.success != None:
423 
      return result.success
424 
    if result.ucx != None:
425 
      raise result.ucx
426 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getInternalInfo failed: unknown result");
427 
 
428 
  def getContext(self, email, password):
429 
    """
430 
    Parameters:
431 
     - email
432 
     - password
433 
    """
434 
    self.send_getContext(email, password)
435 
    return self.recv_getContext()
436 
 
437 
  def send_getContext(self, email, password):
438 
    self._oprot.writeMessageBegin('getContext', TMessageType.CALL, self._seqid)
439 
    args = getContext_args()
440 
    args.email = email
441 
    args.password = password
442 
    args.write(self._oprot)
443 
    self._oprot.writeMessageEnd()
444 
    self._oprot.trans.flush()
445 
 
446 
  def recv_getContext(self, ):
447 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
448 
    if mtype == TMessageType.EXCEPTION:
449 
      x = TApplicationException()
450 
      x.read(self._iprot)
451 
      self._iprot.readMessageEnd()
452 
      raise x
453 
    result = getContext_result()
454 
    result.read(self._iprot)
455 
    self._iprot.readMessageEnd()
456 
    if result.success != None:
457 
      return result.success
458 
    if result.ax != None:
459 
      raise result.ax
460 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getContext failed: unknown result");
461 
 
122 ashish 462 
  def authenticateUser(self, handle, password, isEmail):
463 
    """
464 
    Parameters:
465 
     - handle
466 
     - password
467 
     - isEmail
468 
    """
469 
    self.send_authenticateUser(handle, password, isEmail)
470 
    return self.recv_authenticateUser()
471 
 
472 
  def send_authenticateUser(self, handle, password, isEmail):
473 
    self._oprot.writeMessageBegin('authenticateUser', TMessageType.CALL, self._seqid)
474 
    args = authenticateUser_args()
475 
    args.handle = handle
476 
    args.password = password
477 
    args.isEmail = isEmail
478 
    args.write(self._oprot)
479 
    self._oprot.writeMessageEnd()
480 
    self._oprot.trans.flush()
481 
 
482 
  def recv_authenticateUser(self, ):
483 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
484 
    if mtype == TMessageType.EXCEPTION:
485 
      x = TApplicationException()
486 
      x.read(self._iprot)
487 
      self._iprot.readMessageEnd()
488 
      raise x
489 
    result = authenticateUser_result()
490 
    result.read(self._iprot)
491 
    self._iprot.readMessageEnd()
492 
    if result.success != None:
493 
      return result.success
494 
    if result.ax != None:
495 
      raise result.ax
496 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authenticateUser failed: unknown result");
497 
 
94 ashish 498 
  def userExists(self, email):
499 
    """
500 
    Parameters:
501 
     - email
502 
    """
503 
    self.send_userExists(email)
504 
    return self.recv_userExists()
505 
 
506 
  def send_userExists(self, email):
507 
    self._oprot.writeMessageBegin('userExists', TMessageType.CALL, self._seqid)
508 
    args = userExists_args()
509 
    args.email = email
510 
    args.write(self._oprot)
511 
    self._oprot.writeMessageEnd()
512 
    self._oprot.trans.flush()
513 
 
514 
  def recv_userExists(self, ):
515 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
516 
    if mtype == TMessageType.EXCEPTION:
517 
      x = TApplicationException()
518 
      x.read(self._iprot)
519 
      self._iprot.readMessageEnd()
520 
      raise x
521 
    result = userExists_result()
522 
    result.read(self._iprot)
523 
    self._iprot.readMessageEnd()
524 
    if result.success != None:
525 
      return result.success
526 
    if result.ucx != None:
527 
      raise result.ucx
528 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "userExists failed: unknown result");
529 
 
530 
  def addIpAdressForUser(self, ip, timestamp, userId):
531 
    """
532 
    Parameters:
533 
     - ip
534 
     - timestamp
535 
     - userId
536 
    """
537 
    self.send_addIpAdressForUser(ip, timestamp, userId)
538 
    return self.recv_addIpAdressForUser()
539 
 
540 
  def send_addIpAdressForUser(self, ip, timestamp, userId):
541 
    self._oprot.writeMessageBegin('addIpAdressForUser', TMessageType.CALL, self._seqid)
542 
    args = addIpAdressForUser_args()
543 
    args.ip = ip
544 
    args.timestamp = timestamp
545 
    args.userId = userId
546 
    args.write(self._oprot)
547 
    self._oprot.writeMessageEnd()
548 
    self._oprot.trans.flush()
549 
 
550 
  def recv_addIpAdressForUser(self, ):
551 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
552 
    if mtype == TMessageType.EXCEPTION:
553 
      x = TApplicationException()
554 
      x.read(self._iprot)
555 
      self._iprot.readMessageEnd()
556 
      raise x
557 
    result = addIpAdressForUser_result()
558 
    result.read(self._iprot)
559 
    self._iprot.readMessageEnd()
560 
    if result.success != None:
561 
      return result.success
562 
    if result.ucx != None:
563 
      raise result.ucx
564 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addIpAdressForUser failed: unknown result");
565 
 
513 rajveer 566 
  def addAddressForUser(self, address, userid, timestamp, setDefault):
94 ashish 567 
    """
568 
    Parameters:
569 
     - address
570 
     - userid
571 
     - timestamp
513 rajveer 572 
     - setDefault
94 ashish 573 
    """
513 rajveer 574 
    self.send_addAddressForUser(address, userid, timestamp, setDefault)
94 ashish 575 
    return self.recv_addAddressForUser()
576 
 
513 rajveer 577 
  def send_addAddressForUser(self, address, userid, timestamp, setDefault):
94 ashish 578 
    self._oprot.writeMessageBegin('addAddressForUser', TMessageType.CALL, self._seqid)
579 
    args = addAddressForUser_args()
580 
    args.address = address
581 
    args.userid = userid
582 
    args.timestamp = timestamp
513 rajveer 583 
    args.setDefault = setDefault
94 ashish 584 
    args.write(self._oprot)
585 
    self._oprot.writeMessageEnd()
586 
    self._oprot.trans.flush()
587 
 
588 
  def recv_addAddressForUser(self, ):
589 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
590 
    if mtype == TMessageType.EXCEPTION:
591 
      x = TApplicationException()
592 
      x.read(self._iprot)
593 
      self._iprot.readMessageEnd()
594 
      raise x
595 
    result = addAddressForUser_result()
596 
    result.read(self._iprot)
597 
    self._iprot.readMessageEnd()
598 
    if result.success != None:
599 
      return result.success
600 
    if result.ucx != None:
601 
      raise result.ucx
602 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addAddressForUser failed: unknown result");
603 
 
604 
  def removeAddressForUser(self, userid, addressId):
605 
    """
606 
    Parameters:
607 
     - userid
608 
     - addressId
609 
    """
610 
    self.send_removeAddressForUser(userid, addressId)
611 
    return self.recv_removeAddressForUser()
612 
 
613 
  def send_removeAddressForUser(self, userid, addressId):
614 
    self._oprot.writeMessageBegin('removeAddressForUser', TMessageType.CALL, self._seqid)
615 
    args = removeAddressForUser_args()
616 
    args.userid = userid
617 
    args.addressId = addressId
618 
    args.write(self._oprot)
619 
    self._oprot.writeMessageEnd()
620 
    self._oprot.trans.flush()
621 
 
622 
  def recv_removeAddressForUser(self, ):
623 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
624 
    if mtype == TMessageType.EXCEPTION:
625 
      x = TApplicationException()
626 
      x.read(self._iprot)
627 
      self._iprot.readMessageEnd()
628 
      raise x
629 
    result = removeAddressForUser_result()
630 
    result.read(self._iprot)
631 
    self._iprot.readMessageEnd()
632 
    if result.success != None:
633 
      return result.success
634 
    if result.ucx != None:
635 
      raise result.ucx
636 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "removeAddressForUser failed: unknown result");
637 
 
638 
  def setUserAsLoggedIn(self, userId, timestamp):
639 
    """
640 
    Parameters:
641 
     - userId
642 
     - timestamp
643 
    """
644 
    self.send_setUserAsLoggedIn(userId, timestamp)
645 
    return self.recv_setUserAsLoggedIn()
646 
 
647 
  def send_setUserAsLoggedIn(self, userId, timestamp):
648 
    self._oprot.writeMessageBegin('setUserAsLoggedIn', TMessageType.CALL, self._seqid)
649 
    args = setUserAsLoggedIn_args()
650 
    args.userId = userId
651 
    args.timestamp = timestamp
652 
    args.write(self._oprot)
653 
    self._oprot.writeMessageEnd()
654 
    self._oprot.trans.flush()
655 
 
656 
  def recv_setUserAsLoggedIn(self, ):
657 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
658 
    if mtype == TMessageType.EXCEPTION:
659 
      x = TApplicationException()
660 
      x.read(self._iprot)
661 
      self._iprot.readMessageEnd()
662 
      raise x
663 
    result = setUserAsLoggedIn_result()
664 
    result.read(self._iprot)
665 
    self._iprot.readMessageEnd()
666 
    if result.success != None:
667 
      return result.success
668 
    if result.ucx != None:
669 
      raise result.ucx
670 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "setUserAsLoggedIn failed: unknown result");
671 
 
672 
  def setUserAsLoggedOut(self, userid, timestamp):
673 
    """
674 
    Parameters:
675 
     - userid
676 
     - timestamp
677 
    """
678 
    self.send_setUserAsLoggedOut(userid, timestamp)
679 
    return self.recv_setUserAsLoggedOut()
680 
 
681 
  def send_setUserAsLoggedOut(self, userid, timestamp):
682 
    self._oprot.writeMessageBegin('setUserAsLoggedOut', TMessageType.CALL, self._seqid)
683 
    args = setUserAsLoggedOut_args()
684 
    args.userid = userid
685 
    args.timestamp = timestamp
686 
    args.write(self._oprot)
687 
    self._oprot.writeMessageEnd()
688 
    self._oprot.trans.flush()
689 
 
690 
  def recv_setUserAsLoggedOut(self, ):
691 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
692 
    if mtype == TMessageType.EXCEPTION:
693 
      x = TApplicationException()
694 
      x.read(self._iprot)
695 
      self._iprot.readMessageEnd()
696 
      raise x
697 
    result = setUserAsLoggedOut_result()
698 
    result.read(self._iprot)
699 
    self._iprot.readMessageEnd()
700 
    if result.success != None:
701 
      return result.success
702 
    if result.ucx != None:
703 
      raise result.ucx
704 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "setUserAsLoggedOut failed: unknown result");
705 
 
504 rajveer 706 
  def setDefaultAddress(self, userid, addressId):
707 
    """
708 
    Parameters:
709 
     - userid
710 
     - addressId
711 
    """
712 
    self.send_setDefaultAddress(userid, addressId)
713 
    return self.recv_setDefaultAddress()
714 
 
715 
  def send_setDefaultAddress(self, userid, addressId):
716 
    self._oprot.writeMessageBegin('setDefaultAddress', TMessageType.CALL, self._seqid)
717 
    args = setDefaultAddress_args()
718 
    args.userid = userid
719 
    args.addressId = addressId
720 
    args.write(self._oprot)
721 
    self._oprot.writeMessageEnd()
722 
    self._oprot.trans.flush()
723 
 
724 
  def recv_setDefaultAddress(self, ):
725 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
726 
    if mtype == TMessageType.EXCEPTION:
727 
      x = TApplicationException()
728 
      x.read(self._iprot)
729 
      self._iprot.readMessageEnd()
730 
      raise x
731 
    result = setDefaultAddress_result()
732 
    result.read(self._iprot)
733 
    self._iprot.readMessageEnd()
734 
    if result.success != None:
735 
      return result.success
736 
    if result.ucx != None:
737 
      raise result.ucx
738 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "setDefaultAddress failed: unknown result");
739 
 
94 ashish 740 
  def updatePassword(self, userid, password):
741 
    """
742 
    Parameters:
743 
     - userid
744 
     - password
745 
    """
746 
    self.send_updatePassword(userid, password)
747 
    return self.recv_updatePassword()
748 
 
749 
  def send_updatePassword(self, userid, password):
750 
    self._oprot.writeMessageBegin('updatePassword', TMessageType.CALL, self._seqid)
751 
    args = updatePassword_args()
752 
    args.userid = userid
753 
    args.password = password
754 
    args.write(self._oprot)
755 
    self._oprot.writeMessageEnd()
756 
    self._oprot.trans.flush()
757 
 
758 
  def recv_updatePassword(self, ):
759 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
760 
    if mtype == TMessageType.EXCEPTION:
761 
      x = TApplicationException()
762 
      x.read(self._iprot)
763 
      self._iprot.readMessageEnd()
764 
      raise x
765 
    result = updatePassword_result()
766 
    result.read(self._iprot)
767 
    self._iprot.readMessageEnd()
768 
    if result.success != None:
769 
      return result.success
770 
    if result.ucx != None:
771 
      raise result.ucx
772 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updatePassword failed: unknown result");
773 
 
122 ashish 774 
  def deleteUser(self, userid, isSessionId):
94 ashish 775 
    """
776 
    Parameters:
777 
     - userid
122 ashish 778 
     - isSessionId
94 ashish 779 
    """
122 ashish 780 
    self.send_deleteUser(userid, isSessionId)
94 ashish 781 
    return self.recv_deleteUser()
782 
 
122 ashish 783 
  def send_deleteUser(self, userid, isSessionId):
94 ashish 784 
    self._oprot.writeMessageBegin('deleteUser', TMessageType.CALL, self._seqid)
785 
    args = deleteUser_args()
786 
    args.userid = userid
122 ashish 787 
    args.isSessionId = isSessionId
94 ashish 788 
    args.write(self._oprot)
789 
    self._oprot.writeMessageEnd()
790 
    self._oprot.trans.flush()
791 
 
792 
  def recv_deleteUser(self, ):
793 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
794 
    if mtype == TMessageType.EXCEPTION:
795 
      x = TApplicationException()
796 
      x.read(self._iprot)
797 
      self._iprot.readMessageEnd()
798 
      raise x
799 
    result = deleteUser_result()
800 
    result.read(self._iprot)
801 
    self._iprot.readMessageEnd()
802 
    if result.success != None:
803 
      return result.success
804 
    if result.ucx != None:
805 
      raise result.ucx
806 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteUser failed: unknown result");
807 
 
808 
  def sendEmailVerification(self, userid):
809 
    """
810 
    Parameters:
811 
     - userid
812 
    """
813 
    self.send_sendEmailVerification(userid)
814 
    return self.recv_sendEmailVerification()
815 
 
816 
  def send_sendEmailVerification(self, userid):
817 
    self._oprot.writeMessageBegin('sendEmailVerification', TMessageType.CALL, self._seqid)
818 
    args = sendEmailVerification_args()
819 
    args.userid = userid
820 
    args.write(self._oprot)
821 
    self._oprot.writeMessageEnd()
822 
    self._oprot.trans.flush()
823 
 
824 
  def recv_sendEmailVerification(self, ):
825 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
826 
    if mtype == TMessageType.EXCEPTION:
827 
      x = TApplicationException()
828 
      x.read(self._iprot)
829 
      self._iprot.readMessageEnd()
830 
      raise x
831 
    result = sendEmailVerification_result()
832 
    result.read(self._iprot)
833 
    self._iprot.readMessageEnd()
834 
    if result.success != None:
835 
      return result.success
836 
    if result.ucx != None:
837 
      raise result.ucx
838 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "sendEmailVerification failed: unknown result");
839 
 
840 
  def sendSMSVerification(self, userid):
841 
    """
842 
    Parameters:
843 
     - userid
844 
    """
845 
    self.send_sendSMSVerification(userid)
846 
    return self.recv_sendSMSVerification()
847 
 
848 
  def send_sendSMSVerification(self, userid):
849 
    self._oprot.writeMessageBegin('sendSMSVerification', TMessageType.CALL, self._seqid)
850 
    args = sendSMSVerification_args()
851 
    args.userid = userid
852 
    args.write(self._oprot)
853 
    self._oprot.writeMessageEnd()
854 
    self._oprot.trans.flush()
855 
 
856 
  def recv_sendSMSVerification(self, ):
857 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
858 
    if mtype == TMessageType.EXCEPTION:
859 
      x = TApplicationException()
860 
      x.read(self._iprot)
861 
      self._iprot.readMessageEnd()
862 
      raise x
863 
    result = sendSMSVerification_result()
864 
    result.read(self._iprot)
865 
    self._iprot.readMessageEnd()
866 
    if result.success != None:
867 
      return result.success
868 
    if result.ucx != None:
869 
      raise result.ucx
870 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "sendSMSVerification failed: unknown result");
871 
 
872 
  def confirmEmailVerification(self, userid):
873 
    """
874 
    Parameters:
875 
     - userid
876 
    """
877 
    self.send_confirmEmailVerification(userid)
878 
    return self.recv_confirmEmailVerification()
879 
 
880 
  def send_confirmEmailVerification(self, userid):
881 
    self._oprot.writeMessageBegin('confirmEmailVerification', TMessageType.CALL, self._seqid)
882 
    args = confirmEmailVerification_args()
883 
    args.userid = userid
884 
    args.write(self._oprot)
885 
    self._oprot.writeMessageEnd()
886 
    self._oprot.trans.flush()
887 
 
888 
  def recv_confirmEmailVerification(self, ):
889 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
890 
    if mtype == TMessageType.EXCEPTION:
891 
      x = TApplicationException()
892 
      x.read(self._iprot)
893 
      self._iprot.readMessageEnd()
894 
      raise x
895 
    result = confirmEmailVerification_result()
896 
    result.read(self._iprot)
897 
    self._iprot.readMessageEnd()
898 
    if result.success != None:
899 
      return result.success
900 
    if result.ucx != None:
901 
      raise result.ucx
902 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "confirmEmailVerification failed: unknown result");
903 
 
904 
  def confirmSMSVerification(self, userid):
905 
    """
906 
    Parameters:
907 
     - userid
908 
    """
909 
    self.send_confirmSMSVerification(userid)
910 
    return self.recv_confirmSMSVerification()
911 
 
912 
  def send_confirmSMSVerification(self, userid):
913 
    self._oprot.writeMessageBegin('confirmSMSVerification', TMessageType.CALL, self._seqid)
914 
    args = confirmSMSVerification_args()
915 
    args.userid = userid
916 
    args.write(self._oprot)
917 
    self._oprot.writeMessageEnd()
918 
    self._oprot.trans.flush()
919 
 
920 
  def recv_confirmSMSVerification(self, ):
921 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
922 
    if mtype == TMessageType.EXCEPTION:
923 
      x = TApplicationException()
924 
      x.read(self._iprot)
925 
      self._iprot.readMessageEnd()
926 
      raise x
927 
    result = confirmSMSVerification_result()
928 
    result.read(self._iprot)
929 
    self._iprot.readMessageEnd()
930 
    if result.success != None:
931 
      return result.success
932 
    if result.ucx != None:
933 
      raise result.ucx
934 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "confirmSMSVerification failed: unknown result");
935 
 
936 
  def addSocialhandle(self, userid, socialService, handle):
937 
    """
938 
    Parameters:
939 
     - userid
940 
     - socialService
941 
     - handle
942 
    """
943 
    self.send_addSocialhandle(userid, socialService, handle)
944 
    return self.recv_addSocialhandle()
945 
 
946 
  def send_addSocialhandle(self, userid, socialService, handle):
947 
    self._oprot.writeMessageBegin('addSocialhandle', TMessageType.CALL, self._seqid)
948 
    args = addSocialhandle_args()
949 
    args.userid = userid
950 
    args.socialService = socialService
951 
    args.handle = handle
952 
    args.write(self._oprot)
953 
    self._oprot.writeMessageEnd()
954 
    self._oprot.trans.flush()
955 
 
956 
  def recv_addSocialhandle(self, ):
957 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
958 
    if mtype == TMessageType.EXCEPTION:
959 
      x = TApplicationException()
960 
      x.read(self._iprot)
961 
      self._iprot.readMessageEnd()
962 
      raise x
963 
    result = addSocialhandle_result()
964 
    result.read(self._iprot)
965 
    self._iprot.readMessageEnd()
966 
    if result.success != None:
967 
      return result.success
968 
    if result.ucx != None:
969 
      raise result.ucx
970 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addSocialhandle failed: unknown result");
971 
 
130 ashish 972 
  def sendNewPasswordById(self, userid):
973 
    """
974 
    Parameters:
975 
     - userid
976 
    """
977 
    self.send_sendNewPasswordById(userid)
978 
    return self.recv_sendNewPasswordById()
94 ashish 979 
 
130 ashish 980 
  def send_sendNewPasswordById(self, userid):
981 
    self._oprot.writeMessageBegin('sendNewPasswordById', TMessageType.CALL, self._seqid)
982 
    args = sendNewPasswordById_args()
983 
    args.userid = userid
984 
    args.write(self._oprot)
985 
    self._oprot.writeMessageEnd()
986 
    self._oprot.trans.flush()
987 
 
988 
  def recv_sendNewPasswordById(self, ):
989 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
990 
    if mtype == TMessageType.EXCEPTION:
991 
      x = TApplicationException()
992 
      x.read(self._iprot)
993 
      self._iprot.readMessageEnd()
994 
      raise x
995 
    result = sendNewPasswordById_result()
996 
    result.read(self._iprot)
997 
    self._iprot.readMessageEnd()
998 
    if result.success != None:
999 
      return result.success
1000 
    if result.ucx != None:
1001 
      raise result.ucx
1002 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "sendNewPasswordById failed: unknown result");
1003 
 
1004 
  def sendNewPasswordByHandle(self, emailOrHandle, isEmail):
1005 
    """
1006 
    Parameters:
1007 
     - emailOrHandle
1008 
     - isEmail
1009 
    """
1010 
    self.send_sendNewPasswordByHandle(emailOrHandle, isEmail)
1011 
    return self.recv_sendNewPasswordByHandle()
1012 
 
1013 
  def send_sendNewPasswordByHandle(self, emailOrHandle, isEmail):
1014 
    self._oprot.writeMessageBegin('sendNewPasswordByHandle', TMessageType.CALL, self._seqid)
1015 
    args = sendNewPasswordByHandle_args()
1016 
    args.emailOrHandle = emailOrHandle
1017 
    args.isEmail = isEmail
1018 
    args.write(self._oprot)
1019 
    self._oprot.writeMessageEnd()
1020 
    self._oprot.trans.flush()
1021 
 
1022 
  def recv_sendNewPasswordByHandle(self, ):
1023 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1024 
    if mtype == TMessageType.EXCEPTION:
1025 
      x = TApplicationException()
1026 
      x.read(self._iprot)
1027 
      self._iprot.readMessageEnd()
1028 
      raise x
1029 
    result = sendNewPasswordByHandle_result()
1030 
    result.read(self._iprot)
1031 
    self._iprot.readMessageEnd()
1032 
    if result.success != None:
1033 
      return result.success
1034 
    if result.ucx != None:
1035 
      raise result.ucx
1036 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "sendNewPasswordByHandle failed: unknown result");
1037 
 
1038 
 
94 ashish 1039 
class Processor(Iface, TProcessor):
1040 
  def __init__(self, handler):
1041 
    self._handler = handler
1042 
    self._processMap = {}
1043 
    self._processMap["createContext"] = Processor.process_createContext
1044 
    self._processMap["getContextFromId"] = Processor.process_getContextFromId
1045 
    self._processMap["getContextFromEmailOrHandle"] = Processor.process_getContextFromEmailOrHandle
1046 
    self._processMap["getState"] = Processor.process_getState
1047 
    self._processMap["getPrimaryInfo"] = Processor.process_getPrimaryInfo
1048 
    self._processMap["getInternalInfo"] = Processor.process_getInternalInfo
1049 
    self._processMap["getContext"] = Processor.process_getContext
122 ashish 1050 
    self._processMap["authenticateUser"] = Processor.process_authenticateUser
94 ashish 1051 
    self._processMap["userExists"] = Processor.process_userExists
1052 
    self._processMap["addIpAdressForUser"] = Processor.process_addIpAdressForUser
1053 
    self._processMap["addAddressForUser"] = Processor.process_addAddressForUser
1054 
    self._processMap["removeAddressForUser"] = Processor.process_removeAddressForUser
1055 
    self._processMap["setUserAsLoggedIn"] = Processor.process_setUserAsLoggedIn
1056 
    self._processMap["setUserAsLoggedOut"] = Processor.process_setUserAsLoggedOut
504 rajveer 1057 
    self._processMap["setDefaultAddress"] = Processor.process_setDefaultAddress
94 ashish 1058 
    self._processMap["updatePassword"] = Processor.process_updatePassword
1059 
    self._processMap["deleteUser"] = Processor.process_deleteUser
1060 
    self._processMap["sendEmailVerification"] = Processor.process_sendEmailVerification
1061 
    self._processMap["sendSMSVerification"] = Processor.process_sendSMSVerification
1062 
    self._processMap["confirmEmailVerification"] = Processor.process_confirmEmailVerification
1063 
    self._processMap["confirmSMSVerification"] = Processor.process_confirmSMSVerification
1064 
    self._processMap["addSocialhandle"] = Processor.process_addSocialhandle
130 ashish 1065 
    self._processMap["sendNewPasswordById"] = Processor.process_sendNewPasswordById
1066 
    self._processMap["sendNewPasswordByHandle"] = Processor.process_sendNewPasswordByHandle
94 ashish 1067 
 
1068 
  def process(self, iprot, oprot):
1069 
    (name, type, seqid) = iprot.readMessageBegin()
1070 
    if name not in self._processMap:
1071 
      iprot.skip(TType.STRUCT)
1072 
      iprot.readMessageEnd()
1073 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
1074 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
1075 
      x.write(oprot)
1076 
      oprot.writeMessageEnd()
1077 
      oprot.trans.flush()
1078 
      return
1079 
    else:
1080 
      self._processMap[name](self, seqid, iprot, oprot)
1081 
    return True
1082 
 
1083 
  def process_createContext(self, seqid, iprot, oprot):
1084 
    args = createContext_args()
1085 
    args.read(iprot)
1086 
    iprot.readMessageEnd()
1087 
    result = createContext_result()
1088 
    try:
1089 
      result.success = self._handler.createContext(args.context, args.updateExisting)
1090 
    except UserContextException, cex:
1091 
      result.cex = cex
1092 
    oprot.writeMessageBegin("createContext", TMessageType.REPLY, seqid)
1093 
    result.write(oprot)
1094 
    oprot.writeMessageEnd()
1095 
    oprot.trans.flush()
1096 
 
1097 
  def process_getContextFromId(self, seqid, iprot, oprot):
1098 
    args = getContextFromId_args()
1099 
    args.read(iprot)
1100 
    iprot.readMessageEnd()
1101 
    result = getContextFromId_result()
1102 
    try:
122 ashish 1103 
      result.success = self._handler.getContextFromId(args.userId, args.isSessionId)
94 ashish 1104 
    except UserContextException, ucx:
1105 
      result.ucx = ucx
1106 
    oprot.writeMessageBegin("getContextFromId", TMessageType.REPLY, seqid)
1107 
    result.write(oprot)
1108 
    oprot.writeMessageEnd()
1109 
    oprot.trans.flush()
1110 
 
1111 
  def process_getContextFromEmailOrHandle(self, seqid, iprot, oprot):
1112 
    args = getContextFromEmailOrHandle_args()
1113 
    args.read(iprot)
1114 
    iprot.readMessageEnd()
1115 
    result = getContextFromEmailOrHandle_result()
1116 
    try:
1117 
      result.success = self._handler.getContextFromEmailOrHandle(args.emailorhandle, args.isEmail)
1118 
    except UserContextException, ucx:
1119 
      result.ucx = ucx
1120 
    oprot.writeMessageBegin("getContextFromEmailOrHandle", TMessageType.REPLY, seqid)
1121 
    result.write(oprot)
1122 
    oprot.writeMessageEnd()
1123 
    oprot.trans.flush()
1124 
 
1125 
  def process_getState(self, seqid, iprot, oprot):
1126 
    args = getState_args()
1127 
    args.read(iprot)
1128 
    iprot.readMessageEnd()
1129 
    result = getState_result()
1130 
    try:
122 ashish 1131 
      result.success = self._handler.getState(args.userId, args.isSessionId)
94 ashish 1132 
    except UserContextException, ucx:
1133 
      result.ucx = ucx
1134 
    oprot.writeMessageBegin("getState", TMessageType.REPLY, seqid)
1135 
    result.write(oprot)
1136 
    oprot.writeMessageEnd()
1137 
    oprot.trans.flush()
1138 
 
1139 
  def process_getPrimaryInfo(self, seqid, iprot, oprot):
1140 
    args = getPrimaryInfo_args()
1141 
    args.read(iprot)
1142 
    iprot.readMessageEnd()
1143 
    result = getPrimaryInfo_result()
1144 
    try:
122 ashish 1145 
      result.success = self._handler.getPrimaryInfo(args.userId, args.isSessionId)
94 ashish 1146 
    except UserContextException, ucx:
1147 
      result.ucx = ucx
1148 
    oprot.writeMessageBegin("getPrimaryInfo", TMessageType.REPLY, seqid)
1149 
    result.write(oprot)
1150 
    oprot.writeMessageEnd()
1151 
    oprot.trans.flush()
1152 
 
1153 
  def process_getInternalInfo(self, seqid, iprot, oprot):
1154 
    args = getInternalInfo_args()
1155 
    args.read(iprot)
1156 
    iprot.readMessageEnd()
1157 
    result = getInternalInfo_result()
1158 
    try:
122 ashish 1159 
      result.success = self._handler.getInternalInfo(args.userId, args.isSessionId)
94 ashish 1160 
    except UserContextException, ucx:
1161 
      result.ucx = ucx
1162 
    oprot.writeMessageBegin("getInternalInfo", TMessageType.REPLY, seqid)
1163 
    result.write(oprot)
1164 
    oprot.writeMessageEnd()
1165 
    oprot.trans.flush()
1166 
 
1167 
  def process_getContext(self, seqid, iprot, oprot):
1168 
    args = getContext_args()
1169 
    args.read(iprot)
1170 
    iprot.readMessageEnd()
1171 
    result = getContext_result()
1172 
    try:
1173 
      result.success = self._handler.getContext(args.email, args.password)
1174 
    except AuthenticationException, ax:
1175 
      result.ax = ax
1176 
    oprot.writeMessageBegin("getContext", TMessageType.REPLY, seqid)
1177 
    result.write(oprot)
1178 
    oprot.writeMessageEnd()
1179 
    oprot.trans.flush()
1180 
 
122 ashish 1181 
  def process_authenticateUser(self, seqid, iprot, oprot):
1182 
    args = authenticateUser_args()
1183 
    args.read(iprot)
1184 
    iprot.readMessageEnd()
1185 
    result = authenticateUser_result()
1186 
    try:
1187 
      result.success = self._handler.authenticateUser(args.handle, args.password, args.isEmail)
1188 
    except AuthenticationException, ax:
1189 
      result.ax = ax
1190 
    oprot.writeMessageBegin("authenticateUser", TMessageType.REPLY, seqid)
1191 
    result.write(oprot)
1192 
    oprot.writeMessageEnd()
1193 
    oprot.trans.flush()
1194 
 
94 ashish 1195 
  def process_userExists(self, seqid, iprot, oprot):
1196 
    args = userExists_args()
1197 
    args.read(iprot)
1198 
    iprot.readMessageEnd()
1199 
    result = userExists_result()
1200 
    try:
1201 
      result.success = self._handler.userExists(args.email)
1202 
    except UserContextException, ucx:
1203 
      result.ucx = ucx
1204 
    oprot.writeMessageBegin("userExists", TMessageType.REPLY, seqid)
1205 
    result.write(oprot)
1206 
    oprot.writeMessageEnd()
1207 
    oprot.trans.flush()
1208 
 
1209 
  def process_addIpAdressForUser(self, seqid, iprot, oprot):
1210 
    args = addIpAdressForUser_args()
1211 
    args.read(iprot)
1212 
    iprot.readMessageEnd()
1213 
    result = addIpAdressForUser_result()
1214 
    try:
1215 
      result.success = self._handler.addIpAdressForUser(args.ip, args.timestamp, args.userId)
1216 
    except UserContextException, ucx:
1217 
      result.ucx = ucx
1218 
    oprot.writeMessageBegin("addIpAdressForUser", TMessageType.REPLY, seqid)
1219 
    result.write(oprot)
1220 
    oprot.writeMessageEnd()
1221 
    oprot.trans.flush()
1222 
 
1223 
  def process_addAddressForUser(self, seqid, iprot, oprot):
1224 
    args = addAddressForUser_args()
1225 
    args.read(iprot)
1226 
    iprot.readMessageEnd()
1227 
    result = addAddressForUser_result()
1228 
    try:
513 rajveer 1229 
      result.success = self._handler.addAddressForUser(args.address, args.userid, args.timestamp, args.setDefault)
94 ashish 1230 
    except UserContextException, ucx:
1231 
      result.ucx = ucx
1232 
    oprot.writeMessageBegin("addAddressForUser", TMessageType.REPLY, seqid)
1233 
    result.write(oprot)
1234 
    oprot.writeMessageEnd()
1235 
    oprot.trans.flush()
1236 
 
1237 
  def process_removeAddressForUser(self, seqid, iprot, oprot):
1238 
    args = removeAddressForUser_args()
1239 
    args.read(iprot)
1240 
    iprot.readMessageEnd()
1241 
    result = removeAddressForUser_result()
1242 
    try:
1243 
      result.success = self._handler.removeAddressForUser(args.userid, args.addressId)
1244 
    except UserContextException, ucx:
1245 
      result.ucx = ucx
1246 
    oprot.writeMessageBegin("removeAddressForUser", TMessageType.REPLY, seqid)
1247 
    result.write(oprot)
1248 
    oprot.writeMessageEnd()
1249 
    oprot.trans.flush()
1250 
 
1251 
  def process_setUserAsLoggedIn(self, seqid, iprot, oprot):
1252 
    args = setUserAsLoggedIn_args()
1253 
    args.read(iprot)
1254 
    iprot.readMessageEnd()
1255 
    result = setUserAsLoggedIn_result()
1256 
    try:
1257 
      result.success = self._handler.setUserAsLoggedIn(args.userId, args.timestamp)
1258 
    except UserContextException, ucx:
1259 
      result.ucx = ucx
1260 
    oprot.writeMessageBegin("setUserAsLoggedIn", TMessageType.REPLY, seqid)
1261 
    result.write(oprot)
1262 
    oprot.writeMessageEnd()
1263 
    oprot.trans.flush()
1264 
 
1265 
  def process_setUserAsLoggedOut(self, seqid, iprot, oprot):
1266 
    args = setUserAsLoggedOut_args()
1267 
    args.read(iprot)
1268 
    iprot.readMessageEnd()
1269 
    result = setUserAsLoggedOut_result()
1270 
    try:
1271 
      result.success = self._handler.setUserAsLoggedOut(args.userid, args.timestamp)
1272 
    except UserContextException, ucx:
1273 
      result.ucx = ucx
1274 
    oprot.writeMessageBegin("setUserAsLoggedOut", TMessageType.REPLY, seqid)
1275 
    result.write(oprot)
1276 
    oprot.writeMessageEnd()
1277 
    oprot.trans.flush()
1278 
 
504 rajveer 1279 
  def process_setDefaultAddress(self, seqid, iprot, oprot):
1280 
    args = setDefaultAddress_args()
1281 
    args.read(iprot)
1282 
    iprot.readMessageEnd()
1283 
    result = setDefaultAddress_result()
1284 
    try:
1285 
      result.success = self._handler.setDefaultAddress(args.userid, args.addressId)
1286 
    except UserContextException, ucx:
1287 
      result.ucx = ucx
1288 
    oprot.writeMessageBegin("setDefaultAddress", TMessageType.REPLY, seqid)
1289 
    result.write(oprot)
1290 
    oprot.writeMessageEnd()
1291 
    oprot.trans.flush()
1292 
 
94 ashish 1293 
  def process_updatePassword(self, seqid, iprot, oprot):
1294 
    args = updatePassword_args()
1295 
    args.read(iprot)
1296 
    iprot.readMessageEnd()
1297 
    result = updatePassword_result()
1298 
    try:
1299 
      result.success = self._handler.updatePassword(args.userid, args.password)
1300 
    except UserContextException, ucx:
1301 
      result.ucx = ucx
1302 
    oprot.writeMessageBegin("updatePassword", TMessageType.REPLY, seqid)
1303 
    result.write(oprot)
1304 
    oprot.writeMessageEnd()
1305 
    oprot.trans.flush()
1306 
 
1307 
  def process_deleteUser(self, seqid, iprot, oprot):
1308 
    args = deleteUser_args()
1309 
    args.read(iprot)
1310 
    iprot.readMessageEnd()
1311 
    result = deleteUser_result()
1312 
    try:
122 ashish 1313 
      result.success = self._handler.deleteUser(args.userid, args.isSessionId)
94 ashish 1314 
    except UserContextException, ucx:
1315 
      result.ucx = ucx
1316 
    oprot.writeMessageBegin("deleteUser", TMessageType.REPLY, seqid)
1317 
    result.write(oprot)
1318 
    oprot.writeMessageEnd()
1319 
    oprot.trans.flush()
1320 
 
1321 
  def process_sendEmailVerification(self, seqid, iprot, oprot):
1322 
    args = sendEmailVerification_args()
1323 
    args.read(iprot)
1324 
    iprot.readMessageEnd()
1325 
    result = sendEmailVerification_result()
1326 
    try:
1327 
      result.success = self._handler.sendEmailVerification(args.userid)
1328 
    except UserContextException, ucx:
1329 
      result.ucx = ucx
1330 
    oprot.writeMessageBegin("sendEmailVerification", TMessageType.REPLY, seqid)
1331 
    result.write(oprot)
1332 
    oprot.writeMessageEnd()
1333 
    oprot.trans.flush()
1334 
 
1335 
  def process_sendSMSVerification(self, seqid, iprot, oprot):
1336 
    args = sendSMSVerification_args()
1337 
    args.read(iprot)
1338 
    iprot.readMessageEnd()
1339 
    result = sendSMSVerification_result()
1340 
    try:
1341 
      result.success = self._handler.sendSMSVerification(args.userid)
1342 
    except UserContextException, ucx:
1343 
      result.ucx = ucx
1344 
    oprot.writeMessageBegin("sendSMSVerification", TMessageType.REPLY, seqid)
1345 
    result.write(oprot)
1346 
    oprot.writeMessageEnd()
1347 
    oprot.trans.flush()
1348 
 
1349 
  def process_confirmEmailVerification(self, seqid, iprot, oprot):
1350 
    args = confirmEmailVerification_args()
1351 
    args.read(iprot)
1352 
    iprot.readMessageEnd()
1353 
    result = confirmEmailVerification_result()
1354 
    try:
1355 
      result.success = self._handler.confirmEmailVerification(args.userid)
1356 
    except UserContextException, ucx:
1357 
      result.ucx = ucx
1358 
    oprot.writeMessageBegin("confirmEmailVerification", TMessageType.REPLY, seqid)
1359 
    result.write(oprot)
1360 
    oprot.writeMessageEnd()
1361 
    oprot.trans.flush()
1362 
 
1363 
  def process_confirmSMSVerification(self, seqid, iprot, oprot):
1364 
    args = confirmSMSVerification_args()
1365 
    args.read(iprot)
1366 
    iprot.readMessageEnd()
1367 
    result = confirmSMSVerification_result()
1368 
    try:
1369 
      result.success = self._handler.confirmSMSVerification(args.userid)
1370 
    except UserContextException, ucx:
1371 
      result.ucx = ucx
1372 
    oprot.writeMessageBegin("confirmSMSVerification", TMessageType.REPLY, seqid)
1373 
    result.write(oprot)
1374 
    oprot.writeMessageEnd()
1375 
    oprot.trans.flush()
1376 
 
1377 
  def process_addSocialhandle(self, seqid, iprot, oprot):
1378 
    args = addSocialhandle_args()
1379 
    args.read(iprot)
1380 
    iprot.readMessageEnd()
1381 
    result = addSocialhandle_result()
1382 
    try:
1383 
      result.success = self._handler.addSocialhandle(args.userid, args.socialService, args.handle)
1384 
    except UserContextException, ucx:
1385 
      result.ucx = ucx
1386 
    oprot.writeMessageBegin("addSocialhandle", TMessageType.REPLY, seqid)
1387 
    result.write(oprot)
1388 
    oprot.writeMessageEnd()
1389 
    oprot.trans.flush()
1390 
 
130 ashish 1391 
  def process_sendNewPasswordById(self, seqid, iprot, oprot):
1392 
    args = sendNewPasswordById_args()
1393 
    args.read(iprot)
1394 
    iprot.readMessageEnd()
1395 
    result = sendNewPasswordById_result()
1396 
    try:
1397 
      result.success = self._handler.sendNewPasswordById(args.userid)
1398 
    except UserContextException, ucx:
1399 
      result.ucx = ucx
1400 
    oprot.writeMessageBegin("sendNewPasswordById", TMessageType.REPLY, seqid)
1401 
    result.write(oprot)
1402 
    oprot.writeMessageEnd()
1403 
    oprot.trans.flush()
94 ashish 1404 
 
130 ashish 1405 
  def process_sendNewPasswordByHandle(self, seqid, iprot, oprot):
1406 
    args = sendNewPasswordByHandle_args()
1407 
    args.read(iprot)
1408 
    iprot.readMessageEnd()
1409 
    result = sendNewPasswordByHandle_result()
1410 
    try:
1411 
      result.success = self._handler.sendNewPasswordByHandle(args.emailOrHandle, args.isEmail)
1412 
    except UserContextException, ucx:
1413 
      result.ucx = ucx
1414 
    oprot.writeMessageBegin("sendNewPasswordByHandle", TMessageType.REPLY, seqid)
1415 
    result.write(oprot)
1416 
    oprot.writeMessageEnd()
1417 
    oprot.trans.flush()
1418 
 
1419 
 
94 ashish 1420 
# HELPER FUNCTIONS AND STRUCTURES
1421 
 
1422 
class createContext_args:
1423 
  """
1424 
  Attributes:
1425 
   - context
1426 
   - updateExisting
1427 
  """
1428 
 
1429 
  thrift_spec = (
1430 
    None, # 0
122 ashish 1431 
    (1, TType.STRUCT, 'context', (UserContext, UserContext.thrift_spec), None, ), # 1
94 ashish 1432 
    (2, TType.BOOL, 'updateExisting', None, None, ), # 2
1433 
  )
1434 
 
1435 
  def __init__(self, context=None, updateExisting=None,):
1436 
    self.context = context
1437 
    self.updateExisting = updateExisting
1438 
 
1439 
  def read(self, iprot):
1440 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
1441 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
1442 
      return
1443 
    iprot.readStructBegin()
1444 
    while True:
1445 
      (fname, ftype, fid) = iprot.readFieldBegin()
1446 
      if ftype == TType.STOP:
1447 
        break
1448 
      if fid == 1:
1449 
        if ftype == TType.STRUCT:
122 ashish 1450 
          self.context = UserContext()
94 ashish 1451 
          self.context.read(iprot)
1452 
        else:
1453 
          iprot.skip(ftype)
1454 
      elif fid == 2:
1455 
        if ftype == TType.BOOL:
1456 
          self.updateExisting = iprot.readBool();
1457 
        else:
1458 
          iprot.skip(ftype)
1459 
      else:
1460 
        iprot.skip(ftype)
1461 
      iprot.readFieldEnd()
1462 
    iprot.readStructEnd()
1463 
 
1464 
  def write(self, oprot):
1465 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
1466 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
1467 
      return
1468 
    oprot.writeStructBegin('createContext_args')
1469 
    if self.context != None:
1470 
      oprot.writeFieldBegin('context', TType.STRUCT, 1)
1471 
      self.context.write(oprot)
1472 
      oprot.writeFieldEnd()
1473 
    if self.updateExisting != None:
1474 
      oprot.writeFieldBegin('updateExisting', TType.BOOL, 2)
1475 
      oprot.writeBool(self.updateExisting)
1476 
      oprot.writeFieldEnd()
1477 
    oprot.writeFieldStop()
1478 
    oprot.writeStructEnd()
1479 
 
1480 
  def __repr__(self):
1481 
    L = ['%s=%r' % (key, value)
1482 
      for key, value in self.__dict__.iteritems()]
1483 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
1484 
 
1485 
  def __eq__(self, other):
1486 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
1487 
 
1488 
  def __ne__(self, other):
1489 
    return not (self == other)
1490 
 
1491 
class createContext_result:
1492 
  """
1493 
  Attributes:
1494 
   - success
1495 
   - cex
1496 
  """
1497 
 
1498 
  thrift_spec = (
122 ashish 1499 
    (0, TType.STRUCT, 'success', (UserContext, UserContext.thrift_spec), None, ), # 0
94 ashish 1500 
    (1, TType.STRUCT, 'cex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
1501 
  )
1502 
 
1503 
  def __init__(self, success=None, cex=None,):
1504 
    self.success = success
1505 
    self.cex = cex
1506 
 
1507 
  def read(self, iprot):
1508 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
1509 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
1510 
      return
1511 
    iprot.readStructBegin()
1512 
    while True:
1513 
      (fname, ftype, fid) = iprot.readFieldBegin()
1514 
      if ftype == TType.STOP:
1515 
        break
1516 
      if fid == 0:
1517 
        if ftype == TType.STRUCT:
122 ashish 1518 
          self.success = UserContext()
94 ashish 1519 
          self.success.read(iprot)
1520 
        else:
1521 
          iprot.skip(ftype)
1522 
      elif fid == 1:
1523 
        if ftype == TType.STRUCT:
1524 
          self.cex = UserContextException()
1525 
          self.cex.read(iprot)
1526 
        else:
1527 
          iprot.skip(ftype)
1528 
      else:
1529 
        iprot.skip(ftype)
1530 
      iprot.readFieldEnd()
1531 
    iprot.readStructEnd()
1532 
 
1533 
  def write(self, oprot):
1534 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
1535 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
1536 
      return
1537 
    oprot.writeStructBegin('createContext_result')
1538 
    if self.success != None:
1539 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
1540 
      self.success.write(oprot)
1541 
      oprot.writeFieldEnd()
1542 
    if self.cex != None:
1543 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
1544 
      self.cex.write(oprot)
1545 
      oprot.writeFieldEnd()
1546 
    oprot.writeFieldStop()
1547 
    oprot.writeStructEnd()
1548 
 
1549 
  def __repr__(self):
1550 
    L = ['%s=%r' % (key, value)
1551 
      for key, value in self.__dict__.iteritems()]
1552 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
1553 
 
1554 
  def __eq__(self, other):
1555 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
1556 
 
1557 
  def __ne__(self, other):
1558 
    return not (self == other)
1559 
 
1560 
class getContextFromId_args:
1561 
  """
1562 
  Attributes:
1563 
   - userId
122 ashish 1564 
   - isSessionId
94 ashish 1565 
  """
1566 
 
1567 
  thrift_spec = (
1568 
    None, # 0
1569 
    (1, TType.I64, 'userId', None, None, ), # 1
122 ashish 1570 
    (2, TType.BOOL, 'isSessionId', None, None, ), # 2
94 ashish 1571 
  )
1572 
 
122 ashish 1573 
  def __init__(self, userId=None, isSessionId=None,):
94 ashish 1574 
    self.userId = userId
122 ashish 1575 
    self.isSessionId = isSessionId
94 ashish 1576 
 
1577 
  def read(self, iprot):
1578 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
1579 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
1580 
      return
1581 
    iprot.readStructBegin()
1582 
    while True:
1583 
      (fname, ftype, fid) = iprot.readFieldBegin()
1584 
      if ftype == TType.STOP:
1585 
        break
1586 
      if fid == 1:
1587 
        if ftype == TType.I64:
1588 
          self.userId = iprot.readI64();
1589 
        else:
1590 
          iprot.skip(ftype)
122 ashish 1591 
      elif fid == 2:
1592 
        if ftype == TType.BOOL:
1593 
          self.isSessionId = iprot.readBool();
1594 
        else:
1595 
          iprot.skip(ftype)
94 ashish 1596 
      else:
1597 
        iprot.skip(ftype)
1598 
      iprot.readFieldEnd()
1599 
    iprot.readStructEnd()
1600 
 
1601 
  def write(self, oprot):
1602 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
1603 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
1604 
      return
1605 
    oprot.writeStructBegin('getContextFromId_args')
1606 
    if self.userId != None:
1607 
      oprot.writeFieldBegin('userId', TType.I64, 1)
1608 
      oprot.writeI64(self.userId)
1609 
      oprot.writeFieldEnd()
122 ashish 1610 
    if self.isSessionId != None:
1611 
      oprot.writeFieldBegin('isSessionId', TType.BOOL, 2)
1612 
      oprot.writeBool(self.isSessionId)
1613 
      oprot.writeFieldEnd()
94 ashish 1614 
    oprot.writeFieldStop()
1615 
    oprot.writeStructEnd()
1616 
 
1617 
  def __repr__(self):
1618 
    L = ['%s=%r' % (key, value)
1619 
      for key, value in self.__dict__.iteritems()]
1620 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
1621 
 
1622 
  def __eq__(self, other):
1623 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
1624 
 
1625 
  def __ne__(self, other):
1626 
    return not (self == other)
1627 
 
1628 
class getContextFromId_result:
1629 
  """
1630 
  Attributes:
1631 
   - success
1632 
   - ucx
1633 
  """
1634 
 
1635 
  thrift_spec = (
122 ashish 1636 
    (0, TType.STRUCT, 'success', (UserContext, UserContext.thrift_spec), None, ), # 0
94 ashish 1637 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
1638 
  )
1639 
 
1640 
  def __init__(self, success=None, ucx=None,):
1641 
    self.success = success
1642 
    self.ucx = ucx
1643 
 
1644 
  def read(self, iprot):
1645 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
1646 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
1647 
      return
1648 
    iprot.readStructBegin()
1649 
    while True:
1650 
      (fname, ftype, fid) = iprot.readFieldBegin()
1651 
      if ftype == TType.STOP:
1652 
        break
1653 
      if fid == 0:
1654 
        if ftype == TType.STRUCT:
122 ashish 1655 
          self.success = UserContext()
94 ashish 1656 
          self.success.read(iprot)
1657 
        else:
1658 
          iprot.skip(ftype)
1659 
      elif fid == 1:
1660 
        if ftype == TType.STRUCT:
1661 
          self.ucx = UserContextException()
1662 
          self.ucx.read(iprot)
1663 
        else:
1664 
          iprot.skip(ftype)
1665 
      else:
1666 
        iprot.skip(ftype)
1667 
      iprot.readFieldEnd()
1668 
    iprot.readStructEnd()
1669 
 
1670 
  def write(self, oprot):
1671 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
1672 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
1673 
      return
1674 
    oprot.writeStructBegin('getContextFromId_result')
1675 
    if self.success != None:
1676 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
1677 
      self.success.write(oprot)
1678 
      oprot.writeFieldEnd()
1679 
    if self.ucx != None:
1680 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
1681 
      self.ucx.write(oprot)
1682 
      oprot.writeFieldEnd()
1683 
    oprot.writeFieldStop()
1684 
    oprot.writeStructEnd()
1685 
 
1686 
  def __repr__(self):
1687 
    L = ['%s=%r' % (key, value)
1688 
      for key, value in self.__dict__.iteritems()]
1689 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
1690 
 
1691 
  def __eq__(self, other):
1692 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
1693 
 
1694 
  def __ne__(self, other):
1695 
    return not (self == other)
1696 
 
1697 
class getContextFromEmailOrHandle_args:
1698 
  """
1699 
  Attributes:
1700 
   - emailorhandle
1701 
   - isEmail
1702 
  """
1703 
 
1704 
  thrift_spec = (
1705 
    None, # 0
1706 
    (1, TType.STRING, 'emailorhandle', None, None, ), # 1
1707 
    (2, TType.BOOL, 'isEmail', None, None, ), # 2
1708 
  )
1709 
 
1710 
  def __init__(self, emailorhandle=None, isEmail=None,):
1711 
    self.emailorhandle = emailorhandle
1712 
    self.isEmail = isEmail
1713 
 
1714 
  def read(self, iprot):
1715 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
1716 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
1717 
      return
1718 
    iprot.readStructBegin()
1719 
    while True:
1720 
      (fname, ftype, fid) = iprot.readFieldBegin()
1721 
      if ftype == TType.STOP:
1722 
        break
1723 
      if fid == 1:
1724 
        if ftype == TType.STRING:
1725 
          self.emailorhandle = iprot.readString();
1726 
        else:
1727 
          iprot.skip(ftype)
1728 
      elif fid == 2:
1729 
        if ftype == TType.BOOL:
1730 
          self.isEmail = iprot.readBool();
1731 
        else:
1732 
          iprot.skip(ftype)
1733 
      else:
1734 
        iprot.skip(ftype)
1735 
      iprot.readFieldEnd()
1736 
    iprot.readStructEnd()
1737 
 
1738 
  def write(self, oprot):
1739 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
1740 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
1741 
      return
1742 
    oprot.writeStructBegin('getContextFromEmailOrHandle_args')
1743 
    if self.emailorhandle != None:
1744 
      oprot.writeFieldBegin('emailorhandle', TType.STRING, 1)
1745 
      oprot.writeString(self.emailorhandle)
1746 
      oprot.writeFieldEnd()
1747 
    if self.isEmail != None:
1748 
      oprot.writeFieldBegin('isEmail', TType.BOOL, 2)
1749 
      oprot.writeBool(self.isEmail)
1750 
      oprot.writeFieldEnd()
1751 
    oprot.writeFieldStop()
1752 
    oprot.writeStructEnd()
1753 
 
1754 
  def __repr__(self):
1755 
    L = ['%s=%r' % (key, value)
1756 
      for key, value in self.__dict__.iteritems()]
1757 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
1758 
 
1759 
  def __eq__(self, other):
1760 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
1761 
 
1762 
  def __ne__(self, other):
1763 
    return not (self == other)
1764 
 
1765 
class getContextFromEmailOrHandle_result:
1766 
  """
1767 
  Attributes:
1768 
   - success
1769 
   - ucx
1770 
  """
1771 
 
1772 
  thrift_spec = (
122 ashish 1773 
    (0, TType.STRUCT, 'success', (UserContext, UserContext.thrift_spec), None, ), # 0
94 ashish 1774 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
1775 
  )
1776 
 
1777 
  def __init__(self, success=None, ucx=None,):
1778 
    self.success = success
1779 
    self.ucx = ucx
1780 
 
1781 
  def read(self, iprot):
1782 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
1783 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
1784 
      return
1785 
    iprot.readStructBegin()
1786 
    while True:
1787 
      (fname, ftype, fid) = iprot.readFieldBegin()
1788 
      if ftype == TType.STOP:
1789 
        break
1790 
      if fid == 0:
1791 
        if ftype == TType.STRUCT:
122 ashish 1792 
          self.success = UserContext()
94 ashish 1793 
          self.success.read(iprot)
1794 
        else:
1795 
          iprot.skip(ftype)
1796 
      elif fid == 1:
1797 
        if ftype == TType.STRUCT:
1798 
          self.ucx = UserContextException()
1799 
          self.ucx.read(iprot)
1800 
        else:
1801 
          iprot.skip(ftype)
1802 
      else:
1803 
        iprot.skip(ftype)
1804 
      iprot.readFieldEnd()
1805 
    iprot.readStructEnd()
1806 
 
1807 
  def write(self, oprot):
1808 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
1809 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
1810 
      return
1811 
    oprot.writeStructBegin('getContextFromEmailOrHandle_result')
1812 
    if self.success != None:
1813 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
1814 
      self.success.write(oprot)
1815 
      oprot.writeFieldEnd()
1816 
    if self.ucx != None:
1817 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
1818 
      self.ucx.write(oprot)
1819 
      oprot.writeFieldEnd()
1820 
    oprot.writeFieldStop()
1821 
    oprot.writeStructEnd()
1822 
 
1823 
  def __repr__(self):
1824 
    L = ['%s=%r' % (key, value)
1825 
      for key, value in self.__dict__.iteritems()]
1826 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
1827 
 
1828 
  def __eq__(self, other):
1829 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
1830 
 
1831 
  def __ne__(self, other):
1832 
    return not (self == other)
1833 
 
1834 
class getState_args:
1835 
  """
1836 
  Attributes:
1837 
   - userId
122 ashish 1838 
   - isSessionId
94 ashish 1839 
  """
1840 
 
1841 
  thrift_spec = (
1842 
    None, # 0
1843 
    (1, TType.I64, 'userId', None, None, ), # 1
122 ashish 1844 
    (2, TType.BOOL, 'isSessionId', None, None, ), # 2
94 ashish 1845 
  )
1846 
 
122 ashish 1847 
  def __init__(self, userId=None, isSessionId=None,):
94 ashish 1848 
    self.userId = userId
122 ashish 1849 
    self.isSessionId = isSessionId
94 ashish 1850 
 
1851 
  def read(self, iprot):
1852 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
1853 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
1854 
      return
1855 
    iprot.readStructBegin()
1856 
    while True:
1857 
      (fname, ftype, fid) = iprot.readFieldBegin()
1858 
      if ftype == TType.STOP:
1859 
        break
1860 
      if fid == 1:
1861 
        if ftype == TType.I64:
1862 
          self.userId = iprot.readI64();
1863 
        else:
1864 
          iprot.skip(ftype)
122 ashish 1865 
      elif fid == 2:
1866 
        if ftype == TType.BOOL:
1867 
          self.isSessionId = iprot.readBool();
1868 
        else:
1869 
          iprot.skip(ftype)
94 ashish 1870 
      else:
1871 
        iprot.skip(ftype)
1872 
      iprot.readFieldEnd()
1873 
    iprot.readStructEnd()
1874 
 
1875 
  def write(self, oprot):
1876 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
1877 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
1878 
      return
1879 
    oprot.writeStructBegin('getState_args')
1880 
    if self.userId != None:
1881 
      oprot.writeFieldBegin('userId', TType.I64, 1)
1882 
      oprot.writeI64(self.userId)
1883 
      oprot.writeFieldEnd()
122 ashish 1884 
    if self.isSessionId != None:
1885 
      oprot.writeFieldBegin('isSessionId', TType.BOOL, 2)
1886 
      oprot.writeBool(self.isSessionId)
1887 
      oprot.writeFieldEnd()
94 ashish 1888 
    oprot.writeFieldStop()
1889 
    oprot.writeStructEnd()
1890 
 
1891 
  def __repr__(self):
1892 
    L = ['%s=%r' % (key, value)
1893 
      for key, value in self.__dict__.iteritems()]
1894 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
1895 
 
1896 
  def __eq__(self, other):
1897 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
1898 
 
1899 
  def __ne__(self, other):
1900 
    return not (self == other)
1901 
 
1902 
class getState_result:
1903 
  """
1904 
  Attributes:
1905 
   - success
1906 
   - ucx
1907 
  """
1908 
 
1909 
  thrift_spec = (
122 ashish 1910 
    (0, TType.STRUCT, 'success', (UserState, UserState.thrift_spec), None, ), # 0
94 ashish 1911 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
1912 
  )
1913 
 
1914 
  def __init__(self, success=None, ucx=None,):
1915 
    self.success = success
1916 
    self.ucx = ucx
1917 
 
1918 
  def read(self, iprot):
1919 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
1920 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
1921 
      return
1922 
    iprot.readStructBegin()
1923 
    while True:
1924 
      (fname, ftype, fid) = iprot.readFieldBegin()
1925 
      if ftype == TType.STOP:
1926 
        break
1927 
      if fid == 0:
1928 
        if ftype == TType.STRUCT:
122 ashish 1929 
          self.success = UserState()
94 ashish 1930 
          self.success.read(iprot)
1931 
        else:
1932 
          iprot.skip(ftype)
1933 
      elif fid == 1:
1934 
        if ftype == TType.STRUCT:
1935 
          self.ucx = UserContextException()
1936 
          self.ucx.read(iprot)
1937 
        else:
1938 
          iprot.skip(ftype)
1939 
      else:
1940 
        iprot.skip(ftype)
1941 
      iprot.readFieldEnd()
1942 
    iprot.readStructEnd()
1943 
 
1944 
  def write(self, oprot):
1945 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
1946 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
1947 
      return
1948 
    oprot.writeStructBegin('getState_result')
1949 
    if self.success != None:
1950 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
1951 
      self.success.write(oprot)
1952 
      oprot.writeFieldEnd()
1953 
    if self.ucx != None:
1954 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
1955 
      self.ucx.write(oprot)
1956 
      oprot.writeFieldEnd()
1957 
    oprot.writeFieldStop()
1958 
    oprot.writeStructEnd()
1959 
 
1960 
  def __repr__(self):
1961 
    L = ['%s=%r' % (key, value)
1962 
      for key, value in self.__dict__.iteritems()]
1963 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
1964 
 
1965 
  def __eq__(self, other):
1966 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
1967 
 
1968 
  def __ne__(self, other):
1969 
    return not (self == other)
1970 
 
1971 
class getPrimaryInfo_args:
1972 
  """
1973 
  Attributes:
1974 
   - userId
122 ashish 1975 
   - isSessionId
94 ashish 1976 
  """
1977 
 
1978 
  thrift_spec = (
1979 
    None, # 0
1980 
    (1, TType.I64, 'userId', None, None, ), # 1
122 ashish 1981 
    (2, TType.BOOL, 'isSessionId', None, None, ), # 2
94 ashish 1982 
  )
1983 
 
122 ashish 1984 
  def __init__(self, userId=None, isSessionId=None,):
94 ashish 1985 
    self.userId = userId
122 ashish 1986 
    self.isSessionId = isSessionId
94 ashish 1987 
 
1988 
  def read(self, iprot):
1989 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
1990 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
1991 
      return
1992 
    iprot.readStructBegin()
1993 
    while True:
1994 
      (fname, ftype, fid) = iprot.readFieldBegin()
1995 
      if ftype == TType.STOP:
1996 
        break
1997 
      if fid == 1:
1998 
        if ftype == TType.I64:
1999 
          self.userId = iprot.readI64();
2000 
        else:
2001 
          iprot.skip(ftype)
122 ashish 2002 
      elif fid == 2:
2003 
        if ftype == TType.BOOL:
2004 
          self.isSessionId = iprot.readBool();
2005 
        else:
2006 
          iprot.skip(ftype)
94 ashish 2007 
      else:
2008 
        iprot.skip(ftype)
2009 
      iprot.readFieldEnd()
2010 
    iprot.readStructEnd()
2011 
 
2012 
  def write(self, oprot):
2013 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2014 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2015 
      return
2016 
    oprot.writeStructBegin('getPrimaryInfo_args')
2017 
    if self.userId != None:
2018 
      oprot.writeFieldBegin('userId', TType.I64, 1)
2019 
      oprot.writeI64(self.userId)
2020 
      oprot.writeFieldEnd()
122 ashish 2021 
    if self.isSessionId != None:
2022 
      oprot.writeFieldBegin('isSessionId', TType.BOOL, 2)
2023 
      oprot.writeBool(self.isSessionId)
2024 
      oprot.writeFieldEnd()
94 ashish 2025 
    oprot.writeFieldStop()
2026 
    oprot.writeStructEnd()
2027 
 
2028 
  def __repr__(self):
2029 
    L = ['%s=%r' % (key, value)
2030 
      for key, value in self.__dict__.iteritems()]
2031 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2032 
 
2033 
  def __eq__(self, other):
2034 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2035 
 
2036 
  def __ne__(self, other):
2037 
    return not (self == other)
2038 
 
2039 
class getPrimaryInfo_result:
2040 
  """
2041 
  Attributes:
2042 
   - success
2043 
   - ucx
2044 
  """
2045 
 
2046 
  thrift_spec = (
122 ashish 2047 
    (0, TType.STRUCT, 'success', (UserPrimaryInfo, UserPrimaryInfo.thrift_spec), None, ), # 0
94 ashish 2048 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
2049 
  )
2050 
 
2051 
  def __init__(self, success=None, ucx=None,):
2052 
    self.success = success
2053 
    self.ucx = ucx
2054 
 
2055 
  def read(self, iprot):
2056 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2057 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2058 
      return
2059 
    iprot.readStructBegin()
2060 
    while True:
2061 
      (fname, ftype, fid) = iprot.readFieldBegin()
2062 
      if ftype == TType.STOP:
2063 
        break
2064 
      if fid == 0:
2065 
        if ftype == TType.STRUCT:
122 ashish 2066 
          self.success = UserPrimaryInfo()
94 ashish 2067 
          self.success.read(iprot)
2068 
        else:
2069 
          iprot.skip(ftype)
2070 
      elif fid == 1:
2071 
        if ftype == TType.STRUCT:
2072 
          self.ucx = UserContextException()
2073 
          self.ucx.read(iprot)
2074 
        else:
2075 
          iprot.skip(ftype)
2076 
      else:
2077 
        iprot.skip(ftype)
2078 
      iprot.readFieldEnd()
2079 
    iprot.readStructEnd()
2080 
 
2081 
  def write(self, oprot):
2082 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2083 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2084 
      return
2085 
    oprot.writeStructBegin('getPrimaryInfo_result')
2086 
    if self.success != None:
2087 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
2088 
      self.success.write(oprot)
2089 
      oprot.writeFieldEnd()
2090 
    if self.ucx != None:
2091 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
2092 
      self.ucx.write(oprot)
2093 
      oprot.writeFieldEnd()
2094 
    oprot.writeFieldStop()
2095 
    oprot.writeStructEnd()
2096 
 
2097 
  def __repr__(self):
2098 
    L = ['%s=%r' % (key, value)
2099 
      for key, value in self.__dict__.iteritems()]
2100 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2101 
 
2102 
  def __eq__(self, other):
2103 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2104 
 
2105 
  def __ne__(self, other):
2106 
    return not (self == other)
2107 
 
2108 
class getInternalInfo_args:
2109 
  """
2110 
  Attributes:
2111 
   - userId
122 ashish 2112 
   - isSessionId
94 ashish 2113 
  """
2114 
 
2115 
  thrift_spec = (
2116 
    None, # 0
2117 
    (1, TType.I64, 'userId', None, None, ), # 1
122 ashish 2118 
    (2, TType.BOOL, 'isSessionId', None, None, ), # 2
94 ashish 2119 
  )
2120 
 
122 ashish 2121 
  def __init__(self, userId=None, isSessionId=None,):
94 ashish 2122 
    self.userId = userId
122 ashish 2123 
    self.isSessionId = isSessionId
94 ashish 2124 
 
2125 
  def read(self, iprot):
2126 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2127 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2128 
      return
2129 
    iprot.readStructBegin()
2130 
    while True:
2131 
      (fname, ftype, fid) = iprot.readFieldBegin()
2132 
      if ftype == TType.STOP:
2133 
        break
2134 
      if fid == 1:
2135 
        if ftype == TType.I64:
2136 
          self.userId = iprot.readI64();
2137 
        else:
2138 
          iprot.skip(ftype)
122 ashish 2139 
      elif fid == 2:
2140 
        if ftype == TType.BOOL:
2141 
          self.isSessionId = iprot.readBool();
2142 
        else:
2143 
          iprot.skip(ftype)
94 ashish 2144 
      else:
2145 
        iprot.skip(ftype)
2146 
      iprot.readFieldEnd()
2147 
    iprot.readStructEnd()
2148 
 
2149 
  def write(self, oprot):
2150 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2151 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2152 
      return
2153 
    oprot.writeStructBegin('getInternalInfo_args')
2154 
    if self.userId != None:
2155 
      oprot.writeFieldBegin('userId', TType.I64, 1)
2156 
      oprot.writeI64(self.userId)
2157 
      oprot.writeFieldEnd()
122 ashish 2158 
    if self.isSessionId != None:
2159 
      oprot.writeFieldBegin('isSessionId', TType.BOOL, 2)
2160 
      oprot.writeBool(self.isSessionId)
2161 
      oprot.writeFieldEnd()
94 ashish 2162 
    oprot.writeFieldStop()
2163 
    oprot.writeStructEnd()
2164 
 
2165 
  def __repr__(self):
2166 
    L = ['%s=%r' % (key, value)
2167 
      for key, value in self.__dict__.iteritems()]
2168 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2169 
 
2170 
  def __eq__(self, other):
2171 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2172 
 
2173 
  def __ne__(self, other):
2174 
    return not (self == other)
2175 
 
2176 
class getInternalInfo_result:
2177 
  """
2178 
  Attributes:
2179 
   - success
2180 
   - ucx
2181 
  """
2182 
 
2183 
  thrift_spec = (
122 ashish 2184 
    (0, TType.STRUCT, 'success', (UserInternalInfo, UserInternalInfo.thrift_spec), None, ), # 0
94 ashish 2185 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
2186 
  )
2187 
 
2188 
  def __init__(self, success=None, ucx=None,):
2189 
    self.success = success
2190 
    self.ucx = ucx
2191 
 
2192 
  def read(self, iprot):
2193 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2194 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2195 
      return
2196 
    iprot.readStructBegin()
2197 
    while True:
2198 
      (fname, ftype, fid) = iprot.readFieldBegin()
2199 
      if ftype == TType.STOP:
2200 
        break
2201 
      if fid == 0:
2202 
        if ftype == TType.STRUCT:
122 ashish 2203 
          self.success = UserInternalInfo()
94 ashish 2204 
          self.success.read(iprot)
2205 
        else:
2206 
          iprot.skip(ftype)
2207 
      elif fid == 1:
2208 
        if ftype == TType.STRUCT:
2209 
          self.ucx = UserContextException()
2210 
          self.ucx.read(iprot)
2211 
        else:
2212 
          iprot.skip(ftype)
2213 
      else:
2214 
        iprot.skip(ftype)
2215 
      iprot.readFieldEnd()
2216 
    iprot.readStructEnd()
2217 
 
2218 
  def write(self, oprot):
2219 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2220 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2221 
      return
2222 
    oprot.writeStructBegin('getInternalInfo_result')
2223 
    if self.success != None:
2224 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
2225 
      self.success.write(oprot)
2226 
      oprot.writeFieldEnd()
2227 
    if self.ucx != None:
2228 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
2229 
      self.ucx.write(oprot)
2230 
      oprot.writeFieldEnd()
2231 
    oprot.writeFieldStop()
2232 
    oprot.writeStructEnd()
2233 
 
2234 
  def __repr__(self):
2235 
    L = ['%s=%r' % (key, value)
2236 
      for key, value in self.__dict__.iteritems()]
2237 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2238 
 
2239 
  def __eq__(self, other):
2240 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2241 
 
2242 
  def __ne__(self, other):
2243 
    return not (self == other)
2244 
 
2245 
class getContext_args:
2246 
  """
2247 
  Attributes:
2248 
   - email
2249 
   - password
2250 
  """
2251 
 
2252 
  thrift_spec = (
2253 
    None, # 0
2254 
    (1, TType.STRING, 'email', None, None, ), # 1
2255 
    (2, TType.STRING, 'password', None, None, ), # 2
2256 
  )
2257 
 
2258 
  def __init__(self, email=None, password=None,):
2259 
    self.email = email
2260 
    self.password = password
2261 
 
2262 
  def read(self, iprot):
2263 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2264 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2265 
      return
2266 
    iprot.readStructBegin()
2267 
    while True:
2268 
      (fname, ftype, fid) = iprot.readFieldBegin()
2269 
      if ftype == TType.STOP:
2270 
        break
2271 
      if fid == 1:
2272 
        if ftype == TType.STRING:
2273 
          self.email = iprot.readString();
2274 
        else:
2275 
          iprot.skip(ftype)
2276 
      elif fid == 2:
2277 
        if ftype == TType.STRING:
2278 
          self.password = iprot.readString();
2279 
        else:
2280 
          iprot.skip(ftype)
2281 
      else:
2282 
        iprot.skip(ftype)
2283 
      iprot.readFieldEnd()
2284 
    iprot.readStructEnd()
2285 
 
2286 
  def write(self, oprot):
2287 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2288 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2289 
      return
2290 
    oprot.writeStructBegin('getContext_args')
2291 
    if self.email != None:
2292 
      oprot.writeFieldBegin('email', TType.STRING, 1)
2293 
      oprot.writeString(self.email)
2294 
      oprot.writeFieldEnd()
2295 
    if self.password != None:
2296 
      oprot.writeFieldBegin('password', TType.STRING, 2)
2297 
      oprot.writeString(self.password)
2298 
      oprot.writeFieldEnd()
2299 
    oprot.writeFieldStop()
2300 
    oprot.writeStructEnd()
2301 
 
2302 
  def __repr__(self):
2303 
    L = ['%s=%r' % (key, value)
2304 
      for key, value in self.__dict__.iteritems()]
2305 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2306 
 
2307 
  def __eq__(self, other):
2308 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2309 
 
2310 
  def __ne__(self, other):
2311 
    return not (self == other)
2312 
 
2313 
class getContext_result:
2314 
  """
2315 
  Attributes:
2316 
   - success
2317 
   - ax
2318 
  """
2319 
 
2320 
  thrift_spec = (
122 ashish 2321 
    (0, TType.STRUCT, 'success', (UserContext, UserContext.thrift_spec), None, ), # 0
94 ashish 2322 
    (1, TType.STRUCT, 'ax', (AuthenticationException, AuthenticationException.thrift_spec), None, ), # 1
2323 
  )
2324 
 
2325 
  def __init__(self, success=None, ax=None,):
2326 
    self.success = success
2327 
    self.ax = ax
2328 
 
2329 
  def read(self, iprot):
2330 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2331 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2332 
      return
2333 
    iprot.readStructBegin()
2334 
    while True:
2335 
      (fname, ftype, fid) = iprot.readFieldBegin()
2336 
      if ftype == TType.STOP:
2337 
        break
2338 
      if fid == 0:
2339 
        if ftype == TType.STRUCT:
122 ashish 2340 
          self.success = UserContext()
94 ashish 2341 
          self.success.read(iprot)
2342 
        else:
2343 
          iprot.skip(ftype)
2344 
      elif fid == 1:
2345 
        if ftype == TType.STRUCT:
2346 
          self.ax = AuthenticationException()
2347 
          self.ax.read(iprot)
2348 
        else:
2349 
          iprot.skip(ftype)
2350 
      else:
2351 
        iprot.skip(ftype)
2352 
      iprot.readFieldEnd()
2353 
    iprot.readStructEnd()
2354 
 
2355 
  def write(self, oprot):
2356 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2357 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2358 
      return
2359 
    oprot.writeStructBegin('getContext_result')
2360 
    if self.success != None:
2361 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
2362 
      self.success.write(oprot)
2363 
      oprot.writeFieldEnd()
2364 
    if self.ax != None:
2365 
      oprot.writeFieldBegin('ax', TType.STRUCT, 1)
2366 
      self.ax.write(oprot)
2367 
      oprot.writeFieldEnd()
2368 
    oprot.writeFieldStop()
2369 
    oprot.writeStructEnd()
2370 
 
2371 
  def __repr__(self):
2372 
    L = ['%s=%r' % (key, value)
2373 
      for key, value in self.__dict__.iteritems()]
2374 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2375 
 
2376 
  def __eq__(self, other):
2377 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2378 
 
2379 
  def __ne__(self, other):
2380 
    return not (self == other)
2381 
 
122 ashish 2382 
class authenticateUser_args:
2383 
  """
2384 
  Attributes:
2385 
   - handle
2386 
   - password
2387 
   - isEmail
2388 
  """
2389 
 
2390 
  thrift_spec = (
2391 
    None, # 0
2392 
    (1, TType.STRING, 'handle', None, None, ), # 1
2393 
    (2, TType.STRING, 'password', None, None, ), # 2
2394 
    (3, TType.BOOL, 'isEmail', None, None, ), # 3
2395 
  )
2396 
 
2397 
  def __init__(self, handle=None, password=None, isEmail=None,):
2398 
    self.handle = handle
2399 
    self.password = password
2400 
    self.isEmail = isEmail
2401 
 
2402 
  def read(self, iprot):
2403 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2404 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2405 
      return
2406 
    iprot.readStructBegin()
2407 
    while True:
2408 
      (fname, ftype, fid) = iprot.readFieldBegin()
2409 
      if ftype == TType.STOP:
2410 
        break
2411 
      if fid == 1:
2412 
        if ftype == TType.STRING:
2413 
          self.handle = iprot.readString();
2414 
        else:
2415 
          iprot.skip(ftype)
2416 
      elif fid == 2:
2417 
        if ftype == TType.STRING:
2418 
          self.password = iprot.readString();
2419 
        else:
2420 
          iprot.skip(ftype)
2421 
      elif fid == 3:
2422 
        if ftype == TType.BOOL:
2423 
          self.isEmail = iprot.readBool();
2424 
        else:
2425 
          iprot.skip(ftype)
2426 
      else:
2427 
        iprot.skip(ftype)
2428 
      iprot.readFieldEnd()
2429 
    iprot.readStructEnd()
2430 
 
2431 
  def write(self, oprot):
2432 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2433 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2434 
      return
2435 
    oprot.writeStructBegin('authenticateUser_args')
2436 
    if self.handle != None:
2437 
      oprot.writeFieldBegin('handle', TType.STRING, 1)
2438 
      oprot.writeString(self.handle)
2439 
      oprot.writeFieldEnd()
2440 
    if self.password != None:
2441 
      oprot.writeFieldBegin('password', TType.STRING, 2)
2442 
      oprot.writeString(self.password)
2443 
      oprot.writeFieldEnd()
2444 
    if self.isEmail != None:
2445 
      oprot.writeFieldBegin('isEmail', TType.BOOL, 3)
2446 
      oprot.writeBool(self.isEmail)
2447 
      oprot.writeFieldEnd()
2448 
    oprot.writeFieldStop()
2449 
    oprot.writeStructEnd()
2450 
 
2451 
  def __repr__(self):
2452 
    L = ['%s=%r' % (key, value)
2453 
      for key, value in self.__dict__.iteritems()]
2454 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2455 
 
2456 
  def __eq__(self, other):
2457 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2458 
 
2459 
  def __ne__(self, other):
2460 
    return not (self == other)
2461 
 
2462 
class authenticateUser_result:
2463 
  """
2464 
  Attributes:
2465 
   - success
2466 
   - ax
2467 
  """
2468 
 
2469 
  thrift_spec = (
2470 
    (0, TType.BOOL, 'success', None, None, ), # 0
2471 
    (1, TType.STRUCT, 'ax', (AuthenticationException, AuthenticationException.thrift_spec), None, ), # 1
2472 
  )
2473 
 
2474 
  def __init__(self, success=None, ax=None,):
2475 
    self.success = success
2476 
    self.ax = ax
2477 
 
2478 
  def read(self, iprot):
2479 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2480 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2481 
      return
2482 
    iprot.readStructBegin()
2483 
    while True:
2484 
      (fname, ftype, fid) = iprot.readFieldBegin()
2485 
      if ftype == TType.STOP:
2486 
        break
2487 
      if fid == 0:
2488 
        if ftype == TType.BOOL:
2489 
          self.success = iprot.readBool();
2490 
        else:
2491 
          iprot.skip(ftype)
2492 
      elif fid == 1:
2493 
        if ftype == TType.STRUCT:
2494 
          self.ax = AuthenticationException()
2495 
          self.ax.read(iprot)
2496 
        else:
2497 
          iprot.skip(ftype)
2498 
      else:
2499 
        iprot.skip(ftype)
2500 
      iprot.readFieldEnd()
2501 
    iprot.readStructEnd()
2502 
 
2503 
  def write(self, oprot):
2504 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2505 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2506 
      return
2507 
    oprot.writeStructBegin('authenticateUser_result')
2508 
    if self.success != None:
2509 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
2510 
      oprot.writeBool(self.success)
2511 
      oprot.writeFieldEnd()
2512 
    if self.ax != None:
2513 
      oprot.writeFieldBegin('ax', TType.STRUCT, 1)
2514 
      self.ax.write(oprot)
2515 
      oprot.writeFieldEnd()
2516 
    oprot.writeFieldStop()
2517 
    oprot.writeStructEnd()
2518 
 
2519 
  def __repr__(self):
2520 
    L = ['%s=%r' % (key, value)
2521 
      for key, value in self.__dict__.iteritems()]
2522 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2523 
 
2524 
  def __eq__(self, other):
2525 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2526 
 
2527 
  def __ne__(self, other):
2528 
    return not (self == other)
2529 
 
94 ashish 2530 
class userExists_args:
2531 
  """
2532 
  Attributes:
2533 
   - email
2534 
  """
2535 
 
2536 
  thrift_spec = (
2537 
    None, # 0
2538 
    (1, TType.STRING, 'email', None, None, ), # 1
2539 
  )
2540 
 
2541 
  def __init__(self, email=None,):
2542 
    self.email = email
2543 
 
2544 
  def read(self, iprot):
2545 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2546 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2547 
      return
2548 
    iprot.readStructBegin()
2549 
    while True:
2550 
      (fname, ftype, fid) = iprot.readFieldBegin()
2551 
      if ftype == TType.STOP:
2552 
        break
2553 
      if fid == 1:
2554 
        if ftype == TType.STRING:
2555 
          self.email = iprot.readString();
2556 
        else:
2557 
          iprot.skip(ftype)
2558 
      else:
2559 
        iprot.skip(ftype)
2560 
      iprot.readFieldEnd()
2561 
    iprot.readStructEnd()
2562 
 
2563 
  def write(self, oprot):
2564 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2565 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2566 
      return
2567 
    oprot.writeStructBegin('userExists_args')
2568 
    if self.email != None:
2569 
      oprot.writeFieldBegin('email', TType.STRING, 1)
2570 
      oprot.writeString(self.email)
2571 
      oprot.writeFieldEnd()
2572 
    oprot.writeFieldStop()
2573 
    oprot.writeStructEnd()
2574 
 
2575 
  def __repr__(self):
2576 
    L = ['%s=%r' % (key, value)
2577 
      for key, value in self.__dict__.iteritems()]
2578 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2579 
 
2580 
  def __eq__(self, other):
2581 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2582 
 
2583 
  def __ne__(self, other):
2584 
    return not (self == other)
2585 
 
2586 
class userExists_result:
2587 
  """
2588 
  Attributes:
2589 
   - success
2590 
   - ucx
2591 
  """
2592 
 
2593 
  thrift_spec = (
2594 
    (0, TType.BOOL, 'success', None, None, ), # 0
2595 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
2596 
  )
2597 
 
2598 
  def __init__(self, success=None, ucx=None,):
2599 
    self.success = success
2600 
    self.ucx = ucx
2601 
 
2602 
  def read(self, iprot):
2603 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2604 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2605 
      return
2606 
    iprot.readStructBegin()
2607 
    while True:
2608 
      (fname, ftype, fid) = iprot.readFieldBegin()
2609 
      if ftype == TType.STOP:
2610 
        break
2611 
      if fid == 0:
2612 
        if ftype == TType.BOOL:
2613 
          self.success = iprot.readBool();
2614 
        else:
2615 
          iprot.skip(ftype)
2616 
      elif fid == 1:
2617 
        if ftype == TType.STRUCT:
2618 
          self.ucx = UserContextException()
2619 
          self.ucx.read(iprot)
2620 
        else:
2621 
          iprot.skip(ftype)
2622 
      else:
2623 
        iprot.skip(ftype)
2624 
      iprot.readFieldEnd()
2625 
    iprot.readStructEnd()
2626 
 
2627 
  def write(self, oprot):
2628 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2629 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2630 
      return
2631 
    oprot.writeStructBegin('userExists_result')
2632 
    if self.success != None:
2633 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
2634 
      oprot.writeBool(self.success)
2635 
      oprot.writeFieldEnd()
2636 
    if self.ucx != None:
2637 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
2638 
      self.ucx.write(oprot)
2639 
      oprot.writeFieldEnd()
2640 
    oprot.writeFieldStop()
2641 
    oprot.writeStructEnd()
2642 
 
2643 
  def __repr__(self):
2644 
    L = ['%s=%r' % (key, value)
2645 
      for key, value in self.__dict__.iteritems()]
2646 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2647 
 
2648 
  def __eq__(self, other):
2649 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2650 
 
2651 
  def __ne__(self, other):
2652 
    return not (self == other)
2653 
 
2654 
class addIpAdressForUser_args:
2655 
  """
2656 
  Attributes:
2657 
   - ip
2658 
   - timestamp
2659 
   - userId
2660 
  """
2661 
 
2662 
  thrift_spec = (
2663 
    None, # 0
2664 
    (1, TType.STRING, 'ip', None, None, ), # 1
2665 
    (2, TType.I64, 'timestamp', None, None, ), # 2
2666 
    (3, TType.I64, 'userId', None, None, ), # 3
2667 
  )
2668 
 
2669 
  def __init__(self, ip=None, timestamp=None, userId=None,):
2670 
    self.ip = ip
2671 
    self.timestamp = timestamp
2672 
    self.userId = userId
2673 
 
2674 
  def read(self, iprot):
2675 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2676 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2677 
      return
2678 
    iprot.readStructBegin()
2679 
    while True:
2680 
      (fname, ftype, fid) = iprot.readFieldBegin()
2681 
      if ftype == TType.STOP:
2682 
        break
2683 
      if fid == 1:
2684 
        if ftype == TType.STRING:
2685 
          self.ip = iprot.readString();
2686 
        else:
2687 
          iprot.skip(ftype)
2688 
      elif fid == 2:
2689 
        if ftype == TType.I64:
2690 
          self.timestamp = iprot.readI64();
2691 
        else:
2692 
          iprot.skip(ftype)
2693 
      elif fid == 3:
2694 
        if ftype == TType.I64:
2695 
          self.userId = iprot.readI64();
2696 
        else:
2697 
          iprot.skip(ftype)
2698 
      else:
2699 
        iprot.skip(ftype)
2700 
      iprot.readFieldEnd()
2701 
    iprot.readStructEnd()
2702 
 
2703 
  def write(self, oprot):
2704 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2705 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2706 
      return
2707 
    oprot.writeStructBegin('addIpAdressForUser_args')
2708 
    if self.ip != None:
2709 
      oprot.writeFieldBegin('ip', TType.STRING, 1)
2710 
      oprot.writeString(self.ip)
2711 
      oprot.writeFieldEnd()
2712 
    if self.timestamp != None:
2713 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
2714 
      oprot.writeI64(self.timestamp)
2715 
      oprot.writeFieldEnd()
2716 
    if self.userId != None:
2717 
      oprot.writeFieldBegin('userId', TType.I64, 3)
2718 
      oprot.writeI64(self.userId)
2719 
      oprot.writeFieldEnd()
2720 
    oprot.writeFieldStop()
2721 
    oprot.writeStructEnd()
2722 
 
2723 
  def __repr__(self):
2724 
    L = ['%s=%r' % (key, value)
2725 
      for key, value in self.__dict__.iteritems()]
2726 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2727 
 
2728 
  def __eq__(self, other):
2729 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2730 
 
2731 
  def __ne__(self, other):
2732 
    return not (self == other)
2733 
 
2734 
class addIpAdressForUser_result:
2735 
  """
2736 
  Attributes:
2737 
   - success
2738 
   - ucx
2739 
  """
2740 
 
2741 
  thrift_spec = (
2742 
    (0, TType.BOOL, 'success', None, None, ), # 0
2743 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
2744 
  )
2745 
 
2746 
  def __init__(self, success=None, ucx=None,):
2747 
    self.success = success
2748 
    self.ucx = ucx
2749 
 
2750 
  def read(self, iprot):
2751 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2752 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2753 
      return
2754 
    iprot.readStructBegin()
2755 
    while True:
2756 
      (fname, ftype, fid) = iprot.readFieldBegin()
2757 
      if ftype == TType.STOP:
2758 
        break
2759 
      if fid == 0:
2760 
        if ftype == TType.BOOL:
2761 
          self.success = iprot.readBool();
2762 
        else:
2763 
          iprot.skip(ftype)
2764 
      elif fid == 1:
2765 
        if ftype == TType.STRUCT:
2766 
          self.ucx = UserContextException()
2767 
          self.ucx.read(iprot)
2768 
        else:
2769 
          iprot.skip(ftype)
2770 
      else:
2771 
        iprot.skip(ftype)
2772 
      iprot.readFieldEnd()
2773 
    iprot.readStructEnd()
2774 
 
2775 
  def write(self, oprot):
2776 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2777 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2778 
      return
2779 
    oprot.writeStructBegin('addIpAdressForUser_result')
2780 
    if self.success != None:
2781 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
2782 
      oprot.writeBool(self.success)
2783 
      oprot.writeFieldEnd()
2784 
    if self.ucx != None:
2785 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
2786 
      self.ucx.write(oprot)
2787 
      oprot.writeFieldEnd()
2788 
    oprot.writeFieldStop()
2789 
    oprot.writeStructEnd()
2790 
 
2791 
  def __repr__(self):
2792 
    L = ['%s=%r' % (key, value)
2793 
      for key, value in self.__dict__.iteritems()]
2794 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2795 
 
2796 
  def __eq__(self, other):
2797 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2798 
 
2799 
  def __ne__(self, other):
2800 
    return not (self == other)
2801 
 
2802 
class addAddressForUser_args:
2803 
  """
2804 
  Attributes:
2805 
   - address
2806 
   - userid
2807 
   - timestamp
513 rajveer 2808 
   - setDefault
94 ashish 2809 
  """
2810 
 
2811 
  thrift_spec = (
2812 
    None, # 0
122 ashish 2813 
    (1, TType.STRUCT, 'address', (Address, Address.thrift_spec), None, ), # 1
94 ashish 2814 
    (2, TType.I64, 'userid', None, None, ), # 2
2815 
    (3, TType.I64, 'timestamp', None, None, ), # 3
513 rajveer 2816 
    (4, TType.BOOL, 'setDefault', None, None, ), # 4
94 ashish 2817 
  )
2818 
 
513 rajveer 2819 
  def __init__(self, address=None, userid=None, timestamp=None, setDefault=None,):
94 ashish 2820 
    self.address = address
2821 
    self.userid = userid
2822 
    self.timestamp = timestamp
513 rajveer 2823 
    self.setDefault = setDefault
94 ashish 2824 
 
2825 
  def read(self, iprot):
2826 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2827 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2828 
      return
2829 
    iprot.readStructBegin()
2830 
    while True:
2831 
      (fname, ftype, fid) = iprot.readFieldBegin()
2832 
      if ftype == TType.STOP:
2833 
        break
2834 
      if fid == 1:
2835 
        if ftype == TType.STRUCT:
122 ashish 2836 
          self.address = Address()
94 ashish 2837 
          self.address.read(iprot)
2838 
        else:
2839 
          iprot.skip(ftype)
2840 
      elif fid == 2:
2841 
        if ftype == TType.I64:
2842 
          self.userid = iprot.readI64();
2843 
        else:
2844 
          iprot.skip(ftype)
2845 
      elif fid == 3:
2846 
        if ftype == TType.I64:
2847 
          self.timestamp = iprot.readI64();
2848 
        else:
2849 
          iprot.skip(ftype)
513 rajveer 2850 
      elif fid == 4:
2851 
        if ftype == TType.BOOL:
2852 
          self.setDefault = iprot.readBool();
2853 
        else:
2854 
          iprot.skip(ftype)
94 ashish 2855 
      else:
2856 
        iprot.skip(ftype)
2857 
      iprot.readFieldEnd()
2858 
    iprot.readStructEnd()
2859 
 
2860 
  def write(self, oprot):
2861 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2862 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2863 
      return
2864 
    oprot.writeStructBegin('addAddressForUser_args')
2865 
    if self.address != None:
2866 
      oprot.writeFieldBegin('address', TType.STRUCT, 1)
2867 
      self.address.write(oprot)
2868 
      oprot.writeFieldEnd()
2869 
    if self.userid != None:
2870 
      oprot.writeFieldBegin('userid', TType.I64, 2)
2871 
      oprot.writeI64(self.userid)
2872 
      oprot.writeFieldEnd()
2873 
    if self.timestamp != None:
2874 
      oprot.writeFieldBegin('timestamp', TType.I64, 3)
2875 
      oprot.writeI64(self.timestamp)
2876 
      oprot.writeFieldEnd()
513 rajveer 2877 
    if self.setDefault != None:
2878 
      oprot.writeFieldBegin('setDefault', TType.BOOL, 4)
2879 
      oprot.writeBool(self.setDefault)
2880 
      oprot.writeFieldEnd()
94 ashish 2881 
    oprot.writeFieldStop()
2882 
    oprot.writeStructEnd()
2883 
 
2884 
  def __repr__(self):
2885 
    L = ['%s=%r' % (key, value)
2886 
      for key, value in self.__dict__.iteritems()]
2887 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2888 
 
2889 
  def __eq__(self, other):
2890 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2891 
 
2892 
  def __ne__(self, other):
2893 
    return not (self == other)
2894 
 
2895 
class addAddressForUser_result:
2896 
  """
2897 
  Attributes:
2898 
   - success
2899 
   - ucx
2900 
  """
2901 
 
2902 
  thrift_spec = (
2903 
    (0, TType.BOOL, 'success', None, None, ), # 0
2904 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
2905 
  )
2906 
 
2907 
  def __init__(self, success=None, ucx=None,):
2908 
    self.success = success
2909 
    self.ucx = ucx
2910 
 
2911 
  def read(self, iprot):
2912 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2913 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2914 
      return
2915 
    iprot.readStructBegin()
2916 
    while True:
2917 
      (fname, ftype, fid) = iprot.readFieldBegin()
2918 
      if ftype == TType.STOP:
2919 
        break
2920 
      if fid == 0:
2921 
        if ftype == TType.BOOL:
2922 
          self.success = iprot.readBool();
2923 
        else:
2924 
          iprot.skip(ftype)
2925 
      elif fid == 1:
2926 
        if ftype == TType.STRUCT:
2927 
          self.ucx = UserContextException()
2928 
          self.ucx.read(iprot)
2929 
        else:
2930 
          iprot.skip(ftype)
2931 
      else:
2932 
        iprot.skip(ftype)
2933 
      iprot.readFieldEnd()
2934 
    iprot.readStructEnd()
2935 
 
2936 
  def write(self, oprot):
2937 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2938 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2939 
      return
2940 
    oprot.writeStructBegin('addAddressForUser_result')
2941 
    if self.success != None:
2942 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
2943 
      oprot.writeBool(self.success)
2944 
      oprot.writeFieldEnd()
2945 
    if self.ucx != None:
2946 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
2947 
      self.ucx.write(oprot)
2948 
      oprot.writeFieldEnd()
2949 
    oprot.writeFieldStop()
2950 
    oprot.writeStructEnd()
2951 
 
2952 
  def __repr__(self):
2953 
    L = ['%s=%r' % (key, value)
2954 
      for key, value in self.__dict__.iteritems()]
2955 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2956 
 
2957 
  def __eq__(self, other):
2958 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2959 
 
2960 
  def __ne__(self, other):
2961 
    return not (self == other)
2962 
 
2963 
class removeAddressForUser_args:
2964 
  """
2965 
  Attributes:
2966 
   - userid
2967 
   - addressId
2968 
  """
2969 
 
2970 
  thrift_spec = (
2971 
    None, # 0
2972 
    (1, TType.I64, 'userid', None, None, ), # 1
2973 
    (2, TType.I64, 'addressId', None, None, ), # 2
2974 
  )
2975 
 
2976 
  def __init__(self, userid=None, addressId=None,):
2977 
    self.userid = userid
2978 
    self.addressId = addressId
2979 
 
2980 
  def read(self, iprot):
2981 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2982 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2983 
      return
2984 
    iprot.readStructBegin()
2985 
    while True:
2986 
      (fname, ftype, fid) = iprot.readFieldBegin()
2987 
      if ftype == TType.STOP:
2988 
        break
2989 
      if fid == 1:
2990 
        if ftype == TType.I64:
2991 
          self.userid = iprot.readI64();
2992 
        else:
2993 
          iprot.skip(ftype)
2994 
      elif fid == 2:
2995 
        if ftype == TType.I64:
2996 
          self.addressId = iprot.readI64();
2997 
        else:
2998 
          iprot.skip(ftype)
2999 
      else:
3000 
        iprot.skip(ftype)
3001 
      iprot.readFieldEnd()
3002 
    iprot.readStructEnd()
3003 
 
3004 
  def write(self, oprot):
3005 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3006 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3007 
      return
3008 
    oprot.writeStructBegin('removeAddressForUser_args')
3009 
    if self.userid != None:
3010 
      oprot.writeFieldBegin('userid', TType.I64, 1)
3011 
      oprot.writeI64(self.userid)
3012 
      oprot.writeFieldEnd()
3013 
    if self.addressId != None:
3014 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
3015 
      oprot.writeI64(self.addressId)
3016 
      oprot.writeFieldEnd()
3017 
    oprot.writeFieldStop()
3018 
    oprot.writeStructEnd()
3019 
 
3020 
  def __repr__(self):
3021 
    L = ['%s=%r' % (key, value)
3022 
      for key, value in self.__dict__.iteritems()]
3023 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3024 
 
3025 
  def __eq__(self, other):
3026 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3027 
 
3028 
  def __ne__(self, other):
3029 
    return not (self == other)
3030 
 
3031 
class removeAddressForUser_result:
3032 
  """
3033 
  Attributes:
3034 
   - success
3035 
   - ucx
3036 
  """
3037 
 
3038 
  thrift_spec = (
3039 
    (0, TType.BOOL, 'success', None, None, ), # 0
3040 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
3041 
  )
3042 
 
3043 
  def __init__(self, success=None, ucx=None,):
3044 
    self.success = success
3045 
    self.ucx = ucx
3046 
 
3047 
  def read(self, iprot):
3048 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3049 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3050 
      return
3051 
    iprot.readStructBegin()
3052 
    while True:
3053 
      (fname, ftype, fid) = iprot.readFieldBegin()
3054 
      if ftype == TType.STOP:
3055 
        break
3056 
      if fid == 0:
3057 
        if ftype == TType.BOOL:
3058 
          self.success = iprot.readBool();
3059 
        else:
3060 
          iprot.skip(ftype)
3061 
      elif fid == 1:
3062 
        if ftype == TType.STRUCT:
3063 
          self.ucx = UserContextException()
3064 
          self.ucx.read(iprot)
3065 
        else:
3066 
          iprot.skip(ftype)
3067 
      else:
3068 
        iprot.skip(ftype)
3069 
      iprot.readFieldEnd()
3070 
    iprot.readStructEnd()
3071 
 
3072 
  def write(self, oprot):
3073 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3074 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3075 
      return
3076 
    oprot.writeStructBegin('removeAddressForUser_result')
3077 
    if self.success != None:
3078 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
3079 
      oprot.writeBool(self.success)
3080 
      oprot.writeFieldEnd()
3081 
    if self.ucx != None:
3082 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
3083 
      self.ucx.write(oprot)
3084 
      oprot.writeFieldEnd()
3085 
    oprot.writeFieldStop()
3086 
    oprot.writeStructEnd()
3087 
 
3088 
  def __repr__(self):
3089 
    L = ['%s=%r' % (key, value)
3090 
      for key, value in self.__dict__.iteritems()]
3091 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3092 
 
3093 
  def __eq__(self, other):
3094 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3095 
 
3096 
  def __ne__(self, other):
3097 
    return not (self == other)
3098 
 
3099 
class setUserAsLoggedIn_args:
3100 
  """
3101 
  Attributes:
3102 
   - userId
3103 
   - timestamp
3104 
  """
3105 
 
3106 
  thrift_spec = (
3107 
    None, # 0
3108 
    (1, TType.I64, 'userId', None, None, ), # 1
3109 
    (2, TType.I64, 'timestamp', None, None, ), # 2
3110 
  )
3111 
 
3112 
  def __init__(self, userId=None, timestamp=None,):
3113 
    self.userId = userId
3114 
    self.timestamp = timestamp
3115 
 
3116 
  def read(self, iprot):
3117 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3118 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3119 
      return
3120 
    iprot.readStructBegin()
3121 
    while True:
3122 
      (fname, ftype, fid) = iprot.readFieldBegin()
3123 
      if ftype == TType.STOP:
3124 
        break
3125 
      if fid == 1:
3126 
        if ftype == TType.I64:
3127 
          self.userId = iprot.readI64();
3128 
        else:
3129 
          iprot.skip(ftype)
3130 
      elif fid == 2:
3131 
        if ftype == TType.I64:
3132 
          self.timestamp = iprot.readI64();
3133 
        else:
3134 
          iprot.skip(ftype)
3135 
      else:
3136 
        iprot.skip(ftype)
3137 
      iprot.readFieldEnd()
3138 
    iprot.readStructEnd()
3139 
 
3140 
  def write(self, oprot):
3141 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3142 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3143 
      return
3144 
    oprot.writeStructBegin('setUserAsLoggedIn_args')
3145 
    if self.userId != None:
3146 
      oprot.writeFieldBegin('userId', TType.I64, 1)
3147 
      oprot.writeI64(self.userId)
3148 
      oprot.writeFieldEnd()
3149 
    if self.timestamp != None:
3150 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
3151 
      oprot.writeI64(self.timestamp)
3152 
      oprot.writeFieldEnd()
3153 
    oprot.writeFieldStop()
3154 
    oprot.writeStructEnd()
3155 
 
3156 
  def __repr__(self):
3157 
    L = ['%s=%r' % (key, value)
3158 
      for key, value in self.__dict__.iteritems()]
3159 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3160 
 
3161 
  def __eq__(self, other):
3162 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3163 
 
3164 
  def __ne__(self, other):
3165 
    return not (self == other)
3166 
 
3167 
class setUserAsLoggedIn_result:
3168 
  """
3169 
  Attributes:
3170 
   - success
3171 
   - ucx
3172 
  """
3173 
 
3174 
  thrift_spec = (
3175 
    (0, TType.BOOL, 'success', None, None, ), # 0
3176 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
3177 
  )
3178 
 
3179 
  def __init__(self, success=None, ucx=None,):
3180 
    self.success = success
3181 
    self.ucx = ucx
3182 
 
3183 
  def read(self, iprot):
3184 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3185 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3186 
      return
3187 
    iprot.readStructBegin()
3188 
    while True:
3189 
      (fname, ftype, fid) = iprot.readFieldBegin()
3190 
      if ftype == TType.STOP:
3191 
        break
3192 
      if fid == 0:
3193 
        if ftype == TType.BOOL:
3194 
          self.success = iprot.readBool();
3195 
        else:
3196 
          iprot.skip(ftype)
3197 
      elif fid == 1:
3198 
        if ftype == TType.STRUCT:
3199 
          self.ucx = UserContextException()
3200 
          self.ucx.read(iprot)
3201 
        else:
3202 
          iprot.skip(ftype)
3203 
      else:
3204 
        iprot.skip(ftype)
3205 
      iprot.readFieldEnd()
3206 
    iprot.readStructEnd()
3207 
 
3208 
  def write(self, oprot):
3209 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3210 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3211 
      return
3212 
    oprot.writeStructBegin('setUserAsLoggedIn_result')
3213 
    if self.success != None:
3214 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
3215 
      oprot.writeBool(self.success)
3216 
      oprot.writeFieldEnd()
3217 
    if self.ucx != None:
3218 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
3219 
      self.ucx.write(oprot)
3220 
      oprot.writeFieldEnd()
3221 
    oprot.writeFieldStop()
3222 
    oprot.writeStructEnd()
3223 
 
3224 
  def __repr__(self):
3225 
    L = ['%s=%r' % (key, value)
3226 
      for key, value in self.__dict__.iteritems()]
3227 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3228 
 
3229 
  def __eq__(self, other):
3230 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3231 
 
3232 
  def __ne__(self, other):
3233 
    return not (self == other)
3234 
 
3235 
class setUserAsLoggedOut_args:
3236 
  """
3237 
  Attributes:
3238 
   - userid
3239 
   - timestamp
3240 
  """
3241 
 
3242 
  thrift_spec = (
3243 
    None, # 0
3244 
    (1, TType.I64, 'userid', None, None, ), # 1
3245 
    (2, TType.I64, 'timestamp', None, None, ), # 2
3246 
  )
3247 
 
3248 
  def __init__(self, userid=None, timestamp=None,):
3249 
    self.userid = userid
3250 
    self.timestamp = timestamp
3251 
 
3252 
  def read(self, iprot):
3253 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3254 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3255 
      return
3256 
    iprot.readStructBegin()
3257 
    while True:
3258 
      (fname, ftype, fid) = iprot.readFieldBegin()
3259 
      if ftype == TType.STOP:
3260 
        break
3261 
      if fid == 1:
3262 
        if ftype == TType.I64:
3263 
          self.userid = iprot.readI64();
3264 
        else:
3265 
          iprot.skip(ftype)
3266 
      elif fid == 2:
3267 
        if ftype == TType.I64:
3268 
          self.timestamp = iprot.readI64();
3269 
        else:
3270 
          iprot.skip(ftype)
3271 
      else:
3272 
        iprot.skip(ftype)
3273 
      iprot.readFieldEnd()
3274 
    iprot.readStructEnd()
3275 
 
3276 
  def write(self, oprot):
3277 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3278 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3279 
      return
3280 
    oprot.writeStructBegin('setUserAsLoggedOut_args')
3281 
    if self.userid != None:
3282 
      oprot.writeFieldBegin('userid', TType.I64, 1)
3283 
      oprot.writeI64(self.userid)
3284 
      oprot.writeFieldEnd()
3285 
    if self.timestamp != None:
3286 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
3287 
      oprot.writeI64(self.timestamp)
3288 
      oprot.writeFieldEnd()
3289 
    oprot.writeFieldStop()
3290 
    oprot.writeStructEnd()
3291 
 
3292 
  def __repr__(self):
3293 
    L = ['%s=%r' % (key, value)
3294 
      for key, value in self.__dict__.iteritems()]
3295 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3296 
 
3297 
  def __eq__(self, other):
3298 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3299 
 
3300 
  def __ne__(self, other):
3301 
    return not (self == other)
3302 
 
3303 
class setUserAsLoggedOut_result:
3304 
  """
3305 
  Attributes:
3306 
   - success
3307 
   - ucx
3308 
  """
3309 
 
3310 
  thrift_spec = (
3311 
    (0, TType.BOOL, 'success', None, None, ), # 0
3312 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
3313 
  )
3314 
 
3315 
  def __init__(self, success=None, ucx=None,):
3316 
    self.success = success
3317 
    self.ucx = ucx
3318 
 
3319 
  def read(self, iprot):
3320 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3321 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3322 
      return
3323 
    iprot.readStructBegin()
3324 
    while True:
3325 
      (fname, ftype, fid) = iprot.readFieldBegin()
3326 
      if ftype == TType.STOP:
3327 
        break
3328 
      if fid == 0:
3329 
        if ftype == TType.BOOL:
3330 
          self.success = iprot.readBool();
3331 
        else:
3332 
          iprot.skip(ftype)
3333 
      elif fid == 1:
3334 
        if ftype == TType.STRUCT:
3335 
          self.ucx = UserContextException()
3336 
          self.ucx.read(iprot)
3337 
        else:
3338 
          iprot.skip(ftype)
3339 
      else:
3340 
        iprot.skip(ftype)
3341 
      iprot.readFieldEnd()
3342 
    iprot.readStructEnd()
3343 
 
3344 
  def write(self, oprot):
3345 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3346 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3347 
      return
3348 
    oprot.writeStructBegin('setUserAsLoggedOut_result')
3349 
    if self.success != None:
3350 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
3351 
      oprot.writeBool(self.success)
3352 
      oprot.writeFieldEnd()
3353 
    if self.ucx != None:
3354 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
3355 
      self.ucx.write(oprot)
3356 
      oprot.writeFieldEnd()
3357 
    oprot.writeFieldStop()
3358 
    oprot.writeStructEnd()
3359 
 
3360 
  def __repr__(self):
3361 
    L = ['%s=%r' % (key, value)
3362 
      for key, value in self.__dict__.iteritems()]
3363 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3364 
 
3365 
  def __eq__(self, other):
3366 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3367 
 
3368 
  def __ne__(self, other):
3369 
    return not (self == other)
3370 
 
504 rajveer 3371 
class setDefaultAddress_args:
3372 
  """
3373 
  Attributes:
3374 
   - userid
3375 
   - addressId
3376 
  """
3377 
 
3378 
  thrift_spec = (
3379 
    None, # 0
3380 
    (1, TType.I64, 'userid', None, None, ), # 1
3381 
    (2, TType.I64, 'addressId', None, None, ), # 2
3382 
  )
3383 
 
3384 
  def __init__(self, userid=None, addressId=None,):
3385 
    self.userid = userid
3386 
    self.addressId = addressId
3387 
 
3388 
  def read(self, iprot):
3389 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3390 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3391 
      return
3392 
    iprot.readStructBegin()
3393 
    while True:
3394 
      (fname, ftype, fid) = iprot.readFieldBegin()
3395 
      if ftype == TType.STOP:
3396 
        break
3397 
      if fid == 1:
3398 
        if ftype == TType.I64:
3399 
          self.userid = iprot.readI64();
3400 
        else:
3401 
          iprot.skip(ftype)
3402 
      elif fid == 2:
3403 
        if ftype == TType.I64:
3404 
          self.addressId = iprot.readI64();
3405 
        else:
3406 
          iprot.skip(ftype)
3407 
      else:
3408 
        iprot.skip(ftype)
3409 
      iprot.readFieldEnd()
3410 
    iprot.readStructEnd()
3411 
 
3412 
  def write(self, oprot):
3413 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3414 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3415 
      return
3416 
    oprot.writeStructBegin('setDefaultAddress_args')
3417 
    if self.userid != None:
3418 
      oprot.writeFieldBegin('userid', TType.I64, 1)
3419 
      oprot.writeI64(self.userid)
3420 
      oprot.writeFieldEnd()
3421 
    if self.addressId != None:
3422 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
3423 
      oprot.writeI64(self.addressId)
3424 
      oprot.writeFieldEnd()
3425 
    oprot.writeFieldStop()
3426 
    oprot.writeStructEnd()
3427 
 
3428 
  def __repr__(self):
3429 
    L = ['%s=%r' % (key, value)
3430 
      for key, value in self.__dict__.iteritems()]
3431 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3432 
 
3433 
  def __eq__(self, other):
3434 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3435 
 
3436 
  def __ne__(self, other):
3437 
    return not (self == other)
3438 
 
3439 
class setDefaultAddress_result:
3440 
  """
3441 
  Attributes:
3442 
   - success
3443 
   - ucx
3444 
  """
3445 
 
3446 
  thrift_spec = (
3447 
    (0, TType.BOOL, 'success', None, None, ), # 0
3448 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
3449 
  )
3450 
 
3451 
  def __init__(self, success=None, ucx=None,):
3452 
    self.success = success
3453 
    self.ucx = ucx
3454 
 
3455 
  def read(self, iprot):
3456 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3457 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3458 
      return
3459 
    iprot.readStructBegin()
3460 
    while True:
3461 
      (fname, ftype, fid) = iprot.readFieldBegin()
3462 
      if ftype == TType.STOP:
3463 
        break
3464 
      if fid == 0:
3465 
        if ftype == TType.BOOL:
3466 
          self.success = iprot.readBool();
3467 
        else:
3468 
          iprot.skip(ftype)
3469 
      elif fid == 1:
3470 
        if ftype == TType.STRUCT:
3471 
          self.ucx = UserContextException()
3472 
          self.ucx.read(iprot)
3473 
        else:
3474 
          iprot.skip(ftype)
3475 
      else:
3476 
        iprot.skip(ftype)
3477 
      iprot.readFieldEnd()
3478 
    iprot.readStructEnd()
3479 
 
3480 
  def write(self, oprot):
3481 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3482 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3483 
      return
3484 
    oprot.writeStructBegin('setDefaultAddress_result')
3485 
    if self.success != None:
3486 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
3487 
      oprot.writeBool(self.success)
3488 
      oprot.writeFieldEnd()
3489 
    if self.ucx != None:
3490 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
3491 
      self.ucx.write(oprot)
3492 
      oprot.writeFieldEnd()
3493 
    oprot.writeFieldStop()
3494 
    oprot.writeStructEnd()
3495 
 
3496 
  def __repr__(self):
3497 
    L = ['%s=%r' % (key, value)
3498 
      for key, value in self.__dict__.iteritems()]
3499 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3500 
 
3501 
  def __eq__(self, other):
3502 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3503 
 
3504 
  def __ne__(self, other):
3505 
    return not (self == other)
3506 
 
94 ashish 3507 
class updatePassword_args:
3508 
  """
3509 
  Attributes:
3510 
   - userid
3511 
   - password
3512 
  """
3513 
 
3514 
  thrift_spec = (
3515 
    None, # 0
3516 
    (1, TType.I64, 'userid', None, None, ), # 1
3517 
    (2, TType.STRING, 'password', None, None, ), # 2
3518 
  )
3519 
 
3520 
  def __init__(self, userid=None, password=None,):
3521 
    self.userid = userid
3522 
    self.password = password
3523 
 
3524 
  def read(self, iprot):
3525 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3526 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3527 
      return
3528 
    iprot.readStructBegin()
3529 
    while True:
3530 
      (fname, ftype, fid) = iprot.readFieldBegin()
3531 
      if ftype == TType.STOP:
3532 
        break
3533 
      if fid == 1:
3534 
        if ftype == TType.I64:
3535 
          self.userid = iprot.readI64();
3536 
        else:
3537 
          iprot.skip(ftype)
3538 
      elif fid == 2:
3539 
        if ftype == TType.STRING:
3540 
          self.password = iprot.readString();
3541 
        else:
3542 
          iprot.skip(ftype)
3543 
      else:
3544 
        iprot.skip(ftype)
3545 
      iprot.readFieldEnd()
3546 
    iprot.readStructEnd()
3547 
 
3548 
  def write(self, oprot):
3549 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3550 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3551 
      return
3552 
    oprot.writeStructBegin('updatePassword_args')
3553 
    if self.userid != None:
3554 
      oprot.writeFieldBegin('userid', TType.I64, 1)
3555 
      oprot.writeI64(self.userid)
3556 
      oprot.writeFieldEnd()
3557 
    if self.password != None:
3558 
      oprot.writeFieldBegin('password', TType.STRING, 2)
3559 
      oprot.writeString(self.password)
3560 
      oprot.writeFieldEnd()
3561 
    oprot.writeFieldStop()
3562 
    oprot.writeStructEnd()
3563 
 
3564 
  def __repr__(self):
3565 
    L = ['%s=%r' % (key, value)
3566 
      for key, value in self.__dict__.iteritems()]
3567 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3568 
 
3569 
  def __eq__(self, other):
3570 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3571 
 
3572 
  def __ne__(self, other):
3573 
    return not (self == other)
3574 
 
3575 
class updatePassword_result:
3576 
  """
3577 
  Attributes:
3578 
   - success
3579 
   - ucx
3580 
  """
3581 
 
3582 
  thrift_spec = (
3583 
    (0, TType.BOOL, 'success', None, None, ), # 0
3584 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
3585 
  )
3586 
 
3587 
  def __init__(self, success=None, ucx=None,):
3588 
    self.success = success
3589 
    self.ucx = ucx
3590 
 
3591 
  def read(self, iprot):
3592 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3593 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3594 
      return
3595 
    iprot.readStructBegin()
3596 
    while True:
3597 
      (fname, ftype, fid) = iprot.readFieldBegin()
3598 
      if ftype == TType.STOP:
3599 
        break
3600 
      if fid == 0:
3601 
        if ftype == TType.BOOL:
3602 
          self.success = iprot.readBool();
3603 
        else:
3604 
          iprot.skip(ftype)
3605 
      elif fid == 1:
3606 
        if ftype == TType.STRUCT:
3607 
          self.ucx = UserContextException()
3608 
          self.ucx.read(iprot)
3609 
        else:
3610 
          iprot.skip(ftype)
3611 
      else:
3612 
        iprot.skip(ftype)
3613 
      iprot.readFieldEnd()
3614 
    iprot.readStructEnd()
3615 
 
3616 
  def write(self, oprot):
3617 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3618 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3619 
      return
3620 
    oprot.writeStructBegin('updatePassword_result')
3621 
    if self.success != None:
3622 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
3623 
      oprot.writeBool(self.success)
3624 
      oprot.writeFieldEnd()
3625 
    if self.ucx != None:
3626 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
3627 
      self.ucx.write(oprot)
3628 
      oprot.writeFieldEnd()
3629 
    oprot.writeFieldStop()
3630 
    oprot.writeStructEnd()
3631 
 
3632 
  def __repr__(self):
3633 
    L = ['%s=%r' % (key, value)
3634 
      for key, value in self.__dict__.iteritems()]
3635 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3636 
 
3637 
  def __eq__(self, other):
3638 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3639 
 
3640 
  def __ne__(self, other):
3641 
    return not (self == other)
3642 
 
3643 
class deleteUser_args:
3644 
  """
3645 
  Attributes:
3646 
   - userid
122 ashish 3647 
   - isSessionId
94 ashish 3648 
  """
3649 
 
3650 
  thrift_spec = (
3651 
    None, # 0
3652 
    (1, TType.I64, 'userid', None, None, ), # 1
122 ashish 3653 
    (2, TType.BOOL, 'isSessionId', None, None, ), # 2
94 ashish 3654 
  )
3655 
 
122 ashish 3656 
  def __init__(self, userid=None, isSessionId=None,):
94 ashish 3657 
    self.userid = userid
122 ashish 3658 
    self.isSessionId = isSessionId
94 ashish 3659 
 
3660 
  def read(self, iprot):
3661 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3662 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3663 
      return
3664 
    iprot.readStructBegin()
3665 
    while True:
3666 
      (fname, ftype, fid) = iprot.readFieldBegin()
3667 
      if ftype == TType.STOP:
3668 
        break
3669 
      if fid == 1:
3670 
        if ftype == TType.I64:
3671 
          self.userid = iprot.readI64();
3672 
        else:
3673 
          iprot.skip(ftype)
122 ashish 3674 
      elif fid == 2:
3675 
        if ftype == TType.BOOL:
3676 
          self.isSessionId = iprot.readBool();
3677 
        else:
3678 
          iprot.skip(ftype)
94 ashish 3679 
      else:
3680 
        iprot.skip(ftype)
3681 
      iprot.readFieldEnd()
3682 
    iprot.readStructEnd()
3683 
 
3684 
  def write(self, oprot):
3685 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3686 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3687 
      return
3688 
    oprot.writeStructBegin('deleteUser_args')
3689 
    if self.userid != None:
3690 
      oprot.writeFieldBegin('userid', TType.I64, 1)
3691 
      oprot.writeI64(self.userid)
3692 
      oprot.writeFieldEnd()
122 ashish 3693 
    if self.isSessionId != None:
3694 
      oprot.writeFieldBegin('isSessionId', TType.BOOL, 2)
3695 
      oprot.writeBool(self.isSessionId)
3696 
      oprot.writeFieldEnd()
94 ashish 3697 
    oprot.writeFieldStop()
3698 
    oprot.writeStructEnd()
3699 
 
3700 
  def __repr__(self):
3701 
    L = ['%s=%r' % (key, value)
3702 
      for key, value in self.__dict__.iteritems()]
3703 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3704 
 
3705 
  def __eq__(self, other):
3706 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3707 
 
3708 
  def __ne__(self, other):
3709 
    return not (self == other)
3710 
 
3711 
class deleteUser_result:
3712 
  """
3713 
  Attributes:
3714 
   - success
3715 
   - ucx
3716 
  """
3717 
 
3718 
  thrift_spec = (
3719 
    (0, TType.BOOL, 'success', None, None, ), # 0
3720 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
3721 
  )
3722 
 
3723 
  def __init__(self, success=None, ucx=None,):
3724 
    self.success = success
3725 
    self.ucx = ucx
3726 
 
3727 
  def read(self, iprot):
3728 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3729 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3730 
      return
3731 
    iprot.readStructBegin()
3732 
    while True:
3733 
      (fname, ftype, fid) = iprot.readFieldBegin()
3734 
      if ftype == TType.STOP:
3735 
        break
3736 
      if fid == 0:
3737 
        if ftype == TType.BOOL:
3738 
          self.success = iprot.readBool();
3739 
        else:
3740 
          iprot.skip(ftype)
3741 
      elif fid == 1:
3742 
        if ftype == TType.STRUCT:
3743 
          self.ucx = UserContextException()
3744 
          self.ucx.read(iprot)
3745 
        else:
3746 
          iprot.skip(ftype)
3747 
      else:
3748 
        iprot.skip(ftype)
3749 
      iprot.readFieldEnd()
3750 
    iprot.readStructEnd()
3751 
 
3752 
  def write(self, oprot):
3753 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3754 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3755 
      return
3756 
    oprot.writeStructBegin('deleteUser_result')
3757 
    if self.success != None:
3758 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
3759 
      oprot.writeBool(self.success)
3760 
      oprot.writeFieldEnd()
3761 
    if self.ucx != None:
3762 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
3763 
      self.ucx.write(oprot)
3764 
      oprot.writeFieldEnd()
3765 
    oprot.writeFieldStop()
3766 
    oprot.writeStructEnd()
3767 
 
3768 
  def __repr__(self):
3769 
    L = ['%s=%r' % (key, value)
3770 
      for key, value in self.__dict__.iteritems()]
3771 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3772 
 
3773 
  def __eq__(self, other):
3774 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3775 
 
3776 
  def __ne__(self, other):
3777 
    return not (self == other)
3778 
 
3779 
class sendEmailVerification_args:
3780 
  """
3781 
  Attributes:
3782 
   - userid
3783 
  """
3784 
 
3785 
  thrift_spec = (
3786 
    None, # 0
3787 
    (1, TType.I64, 'userid', None, None, ), # 1
3788 
  )
3789 
 
3790 
  def __init__(self, userid=None,):
3791 
    self.userid = userid
3792 
 
3793 
  def read(self, iprot):
3794 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3795 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3796 
      return
3797 
    iprot.readStructBegin()
3798 
    while True:
3799 
      (fname, ftype, fid) = iprot.readFieldBegin()
3800 
      if ftype == TType.STOP:
3801 
        break
3802 
      if fid == 1:
3803 
        if ftype == TType.I64:
3804 
          self.userid = iprot.readI64();
3805 
        else:
3806 
          iprot.skip(ftype)
3807 
      else:
3808 
        iprot.skip(ftype)
3809 
      iprot.readFieldEnd()
3810 
    iprot.readStructEnd()
3811 
 
3812 
  def write(self, oprot):
3813 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3814 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3815 
      return
3816 
    oprot.writeStructBegin('sendEmailVerification_args')
3817 
    if self.userid != None:
3818 
      oprot.writeFieldBegin('userid', TType.I64, 1)
3819 
      oprot.writeI64(self.userid)
3820 
      oprot.writeFieldEnd()
3821 
    oprot.writeFieldStop()
3822 
    oprot.writeStructEnd()
3823 
 
3824 
  def __repr__(self):
3825 
    L = ['%s=%r' % (key, value)
3826 
      for key, value in self.__dict__.iteritems()]
3827 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3828 
 
3829 
  def __eq__(self, other):
3830 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3831 
 
3832 
  def __ne__(self, other):
3833 
    return not (self == other)
3834 
 
3835 
class sendEmailVerification_result:
3836 
  """
3837 
  Attributes:
3838 
   - success
3839 
   - ucx
3840 
  """
3841 
 
3842 
  thrift_spec = (
3843 
    (0, TType.BOOL, 'success', None, None, ), # 0
3844 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
3845 
  )
3846 
 
3847 
  def __init__(self, success=None, ucx=None,):
3848 
    self.success = success
3849 
    self.ucx = ucx
3850 
 
3851 
  def read(self, iprot):
3852 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3853 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3854 
      return
3855 
    iprot.readStructBegin()
3856 
    while True:
3857 
      (fname, ftype, fid) = iprot.readFieldBegin()
3858 
      if ftype == TType.STOP:
3859 
        break
3860 
      if fid == 0:
3861 
        if ftype == TType.BOOL:
3862 
          self.success = iprot.readBool();
3863 
        else:
3864 
          iprot.skip(ftype)
3865 
      elif fid == 1:
3866 
        if ftype == TType.STRUCT:
3867 
          self.ucx = UserContextException()
3868 
          self.ucx.read(iprot)
3869 
        else:
3870 
          iprot.skip(ftype)
3871 
      else:
3872 
        iprot.skip(ftype)
3873 
      iprot.readFieldEnd()
3874 
    iprot.readStructEnd()
3875 
 
3876 
  def write(self, oprot):
3877 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3878 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3879 
      return
3880 
    oprot.writeStructBegin('sendEmailVerification_result')
3881 
    if self.success != None:
3882 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
3883 
      oprot.writeBool(self.success)
3884 
      oprot.writeFieldEnd()
3885 
    if self.ucx != None:
3886 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
3887 
      self.ucx.write(oprot)
3888 
      oprot.writeFieldEnd()
3889 
    oprot.writeFieldStop()
3890 
    oprot.writeStructEnd()
3891 
 
3892 
  def __repr__(self):
3893 
    L = ['%s=%r' % (key, value)
3894 
      for key, value in self.__dict__.iteritems()]
3895 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3896 
 
3897 
  def __eq__(self, other):
3898 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3899 
 
3900 
  def __ne__(self, other):
3901 
    return not (self == other)
3902 
 
3903 
class sendSMSVerification_args:
3904 
  """
3905 
  Attributes:
3906 
   - userid
3907 
  """
3908 
 
3909 
  thrift_spec = (
3910 
    None, # 0
3911 
    (1, TType.I64, 'userid', None, None, ), # 1
3912 
  )
3913 
 
3914 
  def __init__(self, userid=None,):
3915 
    self.userid = userid
3916 
 
3917 
  def read(self, iprot):
3918 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3919 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3920 
      return
3921 
    iprot.readStructBegin()
3922 
    while True:
3923 
      (fname, ftype, fid) = iprot.readFieldBegin()
3924 
      if ftype == TType.STOP:
3925 
        break
3926 
      if fid == 1:
3927 
        if ftype == TType.I64:
3928 
          self.userid = iprot.readI64();
3929 
        else:
3930 
          iprot.skip(ftype)
3931 
      else:
3932 
        iprot.skip(ftype)
3933 
      iprot.readFieldEnd()
3934 
    iprot.readStructEnd()
3935 
 
3936 
  def write(self, oprot):
3937 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3938 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3939 
      return
3940 
    oprot.writeStructBegin('sendSMSVerification_args')
3941 
    if self.userid != None:
3942 
      oprot.writeFieldBegin('userid', TType.I64, 1)
3943 
      oprot.writeI64(self.userid)
3944 
      oprot.writeFieldEnd()
3945 
    oprot.writeFieldStop()
3946 
    oprot.writeStructEnd()
3947 
 
3948 
  def __repr__(self):
3949 
    L = ['%s=%r' % (key, value)
3950 
      for key, value in self.__dict__.iteritems()]
3951 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3952 
 
3953 
  def __eq__(self, other):
3954 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3955 
 
3956 
  def __ne__(self, other):
3957 
    return not (self == other)
3958 
 
3959 
class sendSMSVerification_result:
3960 
  """
3961 
  Attributes:
3962 
   - success
3963 
   - ucx
3964 
  """
3965 
 
3966 
  thrift_spec = (
3967 
    (0, TType.BOOL, 'success', None, None, ), # 0
3968 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
3969 
  )
3970 
 
3971 
  def __init__(self, success=None, ucx=None,):
3972 
    self.success = success
3973 
    self.ucx = ucx
3974 
 
3975 
  def read(self, iprot):
3976 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3977 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3978 
      return
3979 
    iprot.readStructBegin()
3980 
    while True:
3981 
      (fname, ftype, fid) = iprot.readFieldBegin()
3982 
      if ftype == TType.STOP:
3983 
        break
3984 
      if fid == 0:
3985 
        if ftype == TType.BOOL:
3986 
          self.success = iprot.readBool();
3987 
        else:
3988 
          iprot.skip(ftype)
3989 
      elif fid == 1:
3990 
        if ftype == TType.STRUCT:
3991 
          self.ucx = UserContextException()
3992 
          self.ucx.read(iprot)
3993 
        else:
3994 
          iprot.skip(ftype)
3995 
      else:
3996 
        iprot.skip(ftype)
3997 
      iprot.readFieldEnd()
3998 
    iprot.readStructEnd()
3999 
 
4000 
  def write(self, oprot):
4001 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4002 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4003 
      return
4004 
    oprot.writeStructBegin('sendSMSVerification_result')
4005 
    if self.success != None:
4006 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
4007 
      oprot.writeBool(self.success)
4008 
      oprot.writeFieldEnd()
4009 
    if self.ucx != None:
4010 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
4011 
      self.ucx.write(oprot)
4012 
      oprot.writeFieldEnd()
4013 
    oprot.writeFieldStop()
4014 
    oprot.writeStructEnd()
4015 
 
4016 
  def __repr__(self):
4017 
    L = ['%s=%r' % (key, value)
4018 
      for key, value in self.__dict__.iteritems()]
4019 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4020 
 
4021 
  def __eq__(self, other):
4022 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4023 
 
4024 
  def __ne__(self, other):
4025 
    return not (self == other)
4026 
 
4027 
class confirmEmailVerification_args:
4028 
  """
4029 
  Attributes:
4030 
   - userid
4031 
  """
4032 
 
4033 
  thrift_spec = (
4034 
    None, # 0
4035 
    (1, TType.I64, 'userid', None, None, ), # 1
4036 
  )
4037 
 
4038 
  def __init__(self, userid=None,):
4039 
    self.userid = userid
4040 
 
4041 
  def read(self, iprot):
4042 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4043 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4044 
      return
4045 
    iprot.readStructBegin()
4046 
    while True:
4047 
      (fname, ftype, fid) = iprot.readFieldBegin()
4048 
      if ftype == TType.STOP:
4049 
        break
4050 
      if fid == 1:
4051 
        if ftype == TType.I64:
4052 
          self.userid = iprot.readI64();
4053 
        else:
4054 
          iprot.skip(ftype)
4055 
      else:
4056 
        iprot.skip(ftype)
4057 
      iprot.readFieldEnd()
4058 
    iprot.readStructEnd()
4059 
 
4060 
  def write(self, oprot):
4061 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4062 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4063 
      return
4064 
    oprot.writeStructBegin('confirmEmailVerification_args')
4065 
    if self.userid != None:
4066 
      oprot.writeFieldBegin('userid', TType.I64, 1)
4067 
      oprot.writeI64(self.userid)
4068 
      oprot.writeFieldEnd()
4069 
    oprot.writeFieldStop()
4070 
    oprot.writeStructEnd()
4071 
 
4072 
  def __repr__(self):
4073 
    L = ['%s=%r' % (key, value)
4074 
      for key, value in self.__dict__.iteritems()]
4075 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4076 
 
4077 
  def __eq__(self, other):
4078 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4079 
 
4080 
  def __ne__(self, other):
4081 
    return not (self == other)
4082 
 
4083 
class confirmEmailVerification_result:
4084 
  """
4085 
  Attributes:
4086 
   - success
4087 
   - ucx
4088 
  """
4089 
 
4090 
  thrift_spec = (
4091 
    (0, TType.BOOL, 'success', None, None, ), # 0
4092 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
4093 
  )
4094 
 
4095 
  def __init__(self, success=None, ucx=None,):
4096 
    self.success = success
4097 
    self.ucx = ucx
4098 
 
4099 
  def read(self, iprot):
4100 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4101 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4102 
      return
4103 
    iprot.readStructBegin()
4104 
    while True:
4105 
      (fname, ftype, fid) = iprot.readFieldBegin()
4106 
      if ftype == TType.STOP:
4107 
        break
4108 
      if fid == 0:
4109 
        if ftype == TType.BOOL:
4110 
          self.success = iprot.readBool();
4111 
        else:
4112 
          iprot.skip(ftype)
4113 
      elif fid == 1:
4114 
        if ftype == TType.STRUCT:
4115 
          self.ucx = UserContextException()
4116 
          self.ucx.read(iprot)
4117 
        else:
4118 
          iprot.skip(ftype)
4119 
      else:
4120 
        iprot.skip(ftype)
4121 
      iprot.readFieldEnd()
4122 
    iprot.readStructEnd()
4123 
 
4124 
  def write(self, oprot):
4125 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4126 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4127 
      return
4128 
    oprot.writeStructBegin('confirmEmailVerification_result')
4129 
    if self.success != None:
4130 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
4131 
      oprot.writeBool(self.success)
4132 
      oprot.writeFieldEnd()
4133 
    if self.ucx != None:
4134 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
4135 
      self.ucx.write(oprot)
4136 
      oprot.writeFieldEnd()
4137 
    oprot.writeFieldStop()
4138 
    oprot.writeStructEnd()
4139 
 
4140 
  def __repr__(self):
4141 
    L = ['%s=%r' % (key, value)
4142 
      for key, value in self.__dict__.iteritems()]
4143 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4144 
 
4145 
  def __eq__(self, other):
4146 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4147 
 
4148 
  def __ne__(self, other):
4149 
    return not (self == other)
4150 
 
4151 
class confirmSMSVerification_args:
4152 
  """
4153 
  Attributes:
4154 
   - userid
4155 
  """
4156 
 
4157 
  thrift_spec = (
4158 
    None, # 0
4159 
    (1, TType.I64, 'userid', None, None, ), # 1
4160 
  )
4161 
 
4162 
  def __init__(self, userid=None,):
4163 
    self.userid = userid
4164 
 
4165 
  def read(self, iprot):
4166 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4167 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4168 
      return
4169 
    iprot.readStructBegin()
4170 
    while True:
4171 
      (fname, ftype, fid) = iprot.readFieldBegin()
4172 
      if ftype == TType.STOP:
4173 
        break
4174 
      if fid == 1:
4175 
        if ftype == TType.I64:
4176 
          self.userid = iprot.readI64();
4177 
        else:
4178 
          iprot.skip(ftype)
4179 
      else:
4180 
        iprot.skip(ftype)
4181 
      iprot.readFieldEnd()
4182 
    iprot.readStructEnd()
4183 
 
4184 
  def write(self, oprot):
4185 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4186 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4187 
      return
4188 
    oprot.writeStructBegin('confirmSMSVerification_args')
4189 
    if self.userid != None:
4190 
      oprot.writeFieldBegin('userid', TType.I64, 1)
4191 
      oprot.writeI64(self.userid)
4192 
      oprot.writeFieldEnd()
4193 
    oprot.writeFieldStop()
4194 
    oprot.writeStructEnd()
4195 
 
4196 
  def __repr__(self):
4197 
    L = ['%s=%r' % (key, value)
4198 
      for key, value in self.__dict__.iteritems()]
4199 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4200 
 
4201 
  def __eq__(self, other):
4202 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4203 
 
4204 
  def __ne__(self, other):
4205 
    return not (self == other)
4206 
 
4207 
class confirmSMSVerification_result:
4208 
  """
4209 
  Attributes:
4210 
   - success
4211 
   - ucx
4212 
  """
4213 
 
4214 
  thrift_spec = (
4215 
    (0, TType.BOOL, 'success', None, None, ), # 0
4216 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
4217 
  )
4218 
 
4219 
  def __init__(self, success=None, ucx=None,):
4220 
    self.success = success
4221 
    self.ucx = ucx
4222 
 
4223 
  def read(self, iprot):
4224 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4225 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4226 
      return
4227 
    iprot.readStructBegin()
4228 
    while True:
4229 
      (fname, ftype, fid) = iprot.readFieldBegin()
4230 
      if ftype == TType.STOP:
4231 
        break
4232 
      if fid == 0:
4233 
        if ftype == TType.BOOL:
4234 
          self.success = iprot.readBool();
4235 
        else:
4236 
          iprot.skip(ftype)
4237 
      elif fid == 1:
4238 
        if ftype == TType.STRUCT:
4239 
          self.ucx = UserContextException()
4240 
          self.ucx.read(iprot)
4241 
        else:
4242 
          iprot.skip(ftype)
4243 
      else:
4244 
        iprot.skip(ftype)
4245 
      iprot.readFieldEnd()
4246 
    iprot.readStructEnd()
4247 
 
4248 
  def write(self, oprot):
4249 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4250 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4251 
      return
4252 
    oprot.writeStructBegin('confirmSMSVerification_result')
4253 
    if self.success != None:
4254 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
4255 
      oprot.writeBool(self.success)
4256 
      oprot.writeFieldEnd()
4257 
    if self.ucx != None:
4258 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
4259 
      self.ucx.write(oprot)
4260 
      oprot.writeFieldEnd()
4261 
    oprot.writeFieldStop()
4262 
    oprot.writeStructEnd()
4263 
 
4264 
  def __repr__(self):
4265 
    L = ['%s=%r' % (key, value)
4266 
      for key, value in self.__dict__.iteritems()]
4267 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4268 
 
4269 
  def __eq__(self, other):
4270 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4271 
 
4272 
  def __ne__(self, other):
4273 
    return not (self == other)
4274 
 
4275 
class addSocialhandle_args:
4276 
  """
4277 
  Attributes:
4278 
   - userid
4279 
   - socialService
4280 
   - handle
4281 
  """
4282 
 
4283 
  thrift_spec = (
4284 
    None, # 0
4285 
    (1, TType.I64, 'userid', None, None, ), # 1
4286 
    (2, TType.STRING, 'socialService', None, None, ), # 2
4287 
    (3, TType.STRING, 'handle', None, None, ), # 3
4288 
  )
4289 
 
4290 
  def __init__(self, userid=None, socialService=None, handle=None,):
4291 
    self.userid = userid
4292 
    self.socialService = socialService
4293 
    self.handle = handle
4294 
 
4295 
  def read(self, iprot):
4296 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4297 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4298 
      return
4299 
    iprot.readStructBegin()
4300 
    while True:
4301 
      (fname, ftype, fid) = iprot.readFieldBegin()
4302 
      if ftype == TType.STOP:
4303 
        break
4304 
      if fid == 1:
4305 
        if ftype == TType.I64:
4306 
          self.userid = iprot.readI64();
4307 
        else:
4308 
          iprot.skip(ftype)
4309 
      elif fid == 2:
4310 
        if ftype == TType.STRING:
4311 
          self.socialService = iprot.readString();
4312 
        else:
4313 
          iprot.skip(ftype)
4314 
      elif fid == 3:
4315 
        if ftype == TType.STRING:
4316 
          self.handle = iprot.readString();
4317 
        else:
4318 
          iprot.skip(ftype)
4319 
      else:
4320 
        iprot.skip(ftype)
4321 
      iprot.readFieldEnd()
4322 
    iprot.readStructEnd()
4323 
 
4324 
  def write(self, oprot):
4325 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4326 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4327 
      return
4328 
    oprot.writeStructBegin('addSocialhandle_args')
4329 
    if self.userid != None:
4330 
      oprot.writeFieldBegin('userid', TType.I64, 1)
4331 
      oprot.writeI64(self.userid)
4332 
      oprot.writeFieldEnd()
4333 
    if self.socialService != None:
4334 
      oprot.writeFieldBegin('socialService', TType.STRING, 2)
4335 
      oprot.writeString(self.socialService)
4336 
      oprot.writeFieldEnd()
4337 
    if self.handle != None:
4338 
      oprot.writeFieldBegin('handle', TType.STRING, 3)
4339 
      oprot.writeString(self.handle)
4340 
      oprot.writeFieldEnd()
4341 
    oprot.writeFieldStop()
4342 
    oprot.writeStructEnd()
4343 
 
4344 
  def __repr__(self):
4345 
    L = ['%s=%r' % (key, value)
4346 
      for key, value in self.__dict__.iteritems()]
4347 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4348 
 
4349 
  def __eq__(self, other):
4350 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4351 
 
4352 
  def __ne__(self, other):
4353 
    return not (self == other)
4354 
 
4355 
class addSocialhandle_result:
4356 
  """
4357 
  Attributes:
4358 
   - success
4359 
   - ucx
4360 
  """
4361 
 
4362 
  thrift_spec = (
4363 
    (0, TType.BOOL, 'success', None, None, ), # 0
4364 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
4365 
  )
4366 
 
4367 
  def __init__(self, success=None, ucx=None,):
4368 
    self.success = success
4369 
    self.ucx = ucx
4370 
 
4371 
  def read(self, iprot):
4372 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4373 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4374 
      return
4375 
    iprot.readStructBegin()
4376 
    while True:
4377 
      (fname, ftype, fid) = iprot.readFieldBegin()
4378 
      if ftype == TType.STOP:
4379 
        break
4380 
      if fid == 0:
4381 
        if ftype == TType.BOOL:
4382 
          self.success = iprot.readBool();
4383 
        else:
4384 
          iprot.skip(ftype)
4385 
      elif fid == 1:
4386 
        if ftype == TType.STRUCT:
4387 
          self.ucx = UserContextException()
4388 
          self.ucx.read(iprot)
4389 
        else:
4390 
          iprot.skip(ftype)
4391 
      else:
4392 
        iprot.skip(ftype)
4393 
      iprot.readFieldEnd()
4394 
    iprot.readStructEnd()
4395 
 
4396 
  def write(self, oprot):
4397 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4398 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4399 
      return
4400 
    oprot.writeStructBegin('addSocialhandle_result')
4401 
    if self.success != None:
4402 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
4403 
      oprot.writeBool(self.success)
4404 
      oprot.writeFieldEnd()
4405 
    if self.ucx != None:
4406 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
4407 
      self.ucx.write(oprot)
4408 
      oprot.writeFieldEnd()
4409 
    oprot.writeFieldStop()
4410 
    oprot.writeStructEnd()
4411 
 
4412 
  def __repr__(self):
4413 
    L = ['%s=%r' % (key, value)
4414 
      for key, value in self.__dict__.iteritems()]
4415 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4416 
 
4417 
  def __eq__(self, other):
4418 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4419 
 
4420 
  def __ne__(self, other):
4421 
    return not (self == other)
4422 
 
130 ashish 4423 
class sendNewPasswordById_args:
4424 
  """
4425 
  Attributes:
4426 
   - userid
4427 
  """
94 ashish 4428 
 
130 ashish 4429 
  thrift_spec = (
4430 
    None, # 0
4431 
    (1, TType.I64, 'userid', None, None, ), # 1
4432 
  )
4433 
 
4434 
  def __init__(self, userid=None,):
4435 
    self.userid = userid
4436 
 
4437 
  def read(self, iprot):
4438 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4439 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4440 
      return
4441 
    iprot.readStructBegin()
4442 
    while True:
4443 
      (fname, ftype, fid) = iprot.readFieldBegin()
4444 
      if ftype == TType.STOP:
4445 
        break
4446 
      if fid == 1:
4447 
        if ftype == TType.I64:
4448 
          self.userid = iprot.readI64();
4449 
        else:
4450 
          iprot.skip(ftype)
4451 
      else:
4452 
        iprot.skip(ftype)
4453 
      iprot.readFieldEnd()
4454 
    iprot.readStructEnd()
4455 
 
4456 
  def write(self, oprot):
4457 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4458 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4459 
      return
4460 
    oprot.writeStructBegin('sendNewPasswordById_args')
4461 
    if self.userid != None:
4462 
      oprot.writeFieldBegin('userid', TType.I64, 1)
4463 
      oprot.writeI64(self.userid)
4464 
      oprot.writeFieldEnd()
4465 
    oprot.writeFieldStop()
4466 
    oprot.writeStructEnd()
4467 
 
4468 
  def __repr__(self):
4469 
    L = ['%s=%r' % (key, value)
4470 
      for key, value in self.__dict__.iteritems()]
4471 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4472 
 
4473 
  def __eq__(self, other):
4474 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4475 
 
4476 
  def __ne__(self, other):
4477 
    return not (self == other)
4478 
 
4479 
class sendNewPasswordById_result:
4480 
  """
4481 
  Attributes:
4482 
   - success
4483 
   - ucx
4484 
  """
4485 
 
4486 
  thrift_spec = (
4487 
    (0, TType.BOOL, 'success', None, None, ), # 0
4488 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
4489 
  )
4490 
 
4491 
  def __init__(self, success=None, ucx=None,):
4492 
    self.success = success
4493 
    self.ucx = ucx
4494 
 
4495 
  def read(self, iprot):
4496 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4497 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4498 
      return
4499 
    iprot.readStructBegin()
4500 
    while True:
4501 
      (fname, ftype, fid) = iprot.readFieldBegin()
4502 
      if ftype == TType.STOP:
4503 
        break
4504 
      if fid == 0:
4505 
        if ftype == TType.BOOL:
4506 
          self.success = iprot.readBool();
4507 
        else:
4508 
          iprot.skip(ftype)
4509 
      elif fid == 1:
4510 
        if ftype == TType.STRUCT:
4511 
          self.ucx = UserContextException()
4512 
          self.ucx.read(iprot)
4513 
        else:
4514 
          iprot.skip(ftype)
4515 
      else:
4516 
        iprot.skip(ftype)
4517 
      iprot.readFieldEnd()
4518 
    iprot.readStructEnd()
4519 
 
4520 
  def write(self, oprot):
4521 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4522 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4523 
      return
4524 
    oprot.writeStructBegin('sendNewPasswordById_result')
4525 
    if self.success != None:
4526 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
4527 
      oprot.writeBool(self.success)
4528 
      oprot.writeFieldEnd()
4529 
    if self.ucx != None:
4530 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
4531 
      self.ucx.write(oprot)
4532 
      oprot.writeFieldEnd()
4533 
    oprot.writeFieldStop()
4534 
    oprot.writeStructEnd()
4535 
 
4536 
  def __repr__(self):
4537 
    L = ['%s=%r' % (key, value)
4538 
      for key, value in self.__dict__.iteritems()]
4539 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4540 
 
4541 
  def __eq__(self, other):
4542 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4543 
 
4544 
  def __ne__(self, other):
4545 
    return not (self == other)
4546 
 
4547 
class sendNewPasswordByHandle_args:
4548 
  """
4549 
  Attributes:
4550 
   - emailOrHandle
4551 
   - isEmail
4552 
  """
4553 
 
4554 
  thrift_spec = (
4555 
    None, # 0
4556 
    (1, TType.STRING, 'emailOrHandle', None, None, ), # 1
4557 
    (2, TType.BOOL, 'isEmail', None, None, ), # 2
4558 
  )
4559 
 
4560 
  def __init__(self, emailOrHandle=None, isEmail=None,):
4561 
    self.emailOrHandle = emailOrHandle
4562 
    self.isEmail = isEmail
4563 
 
4564 
  def read(self, iprot):
4565 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4566 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4567 
      return
4568 
    iprot.readStructBegin()
4569 
    while True:
4570 
      (fname, ftype, fid) = iprot.readFieldBegin()
4571 
      if ftype == TType.STOP:
4572 
        break
4573 
      if fid == 1:
4574 
        if ftype == TType.STRING:
4575 
          self.emailOrHandle = iprot.readString();
4576 
        else:
4577 
          iprot.skip(ftype)
4578 
      elif fid == 2:
4579 
        if ftype == TType.BOOL:
4580 
          self.isEmail = iprot.readBool();
4581 
        else:
4582 
          iprot.skip(ftype)
4583 
      else:
4584 
        iprot.skip(ftype)
4585 
      iprot.readFieldEnd()
4586 
    iprot.readStructEnd()
4587 
 
4588 
  def write(self, oprot):
4589 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4590 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4591 
      return
4592 
    oprot.writeStructBegin('sendNewPasswordByHandle_args')
4593 
    if self.emailOrHandle != None:
4594 
      oprot.writeFieldBegin('emailOrHandle', TType.STRING, 1)
4595 
      oprot.writeString(self.emailOrHandle)
4596 
      oprot.writeFieldEnd()
4597 
    if self.isEmail != None:
4598 
      oprot.writeFieldBegin('isEmail', TType.BOOL, 2)
4599 
      oprot.writeBool(self.isEmail)
4600 
      oprot.writeFieldEnd()
4601 
    oprot.writeFieldStop()
4602 
    oprot.writeStructEnd()
4603 
 
4604 
  def __repr__(self):
4605 
    L = ['%s=%r' % (key, value)
4606 
      for key, value in self.__dict__.iteritems()]
4607 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4608 
 
4609 
  def __eq__(self, other):
4610 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4611 
 
4612 
  def __ne__(self, other):
4613 
    return not (self == other)
4614 
 
4615 
class sendNewPasswordByHandle_result:
4616 
  """
4617 
  Attributes:
4618 
   - success
4619 
   - ucx
4620 
  """
4621 
 
4622 
  thrift_spec = (
4623 
    (0, TType.BOOL, 'success', None, None, ), # 0
4624 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
4625 
  )
4626 
 
4627 
  def __init__(self, success=None, ucx=None,):
4628 
    self.success = success
4629 
    self.ucx = ucx
4630 
 
4631 
  def read(self, iprot):
4632 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4633 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4634 
      return
4635 
    iprot.readStructBegin()
4636 
    while True:
4637 
      (fname, ftype, fid) = iprot.readFieldBegin()
4638 
      if ftype == TType.STOP:
4639 
        break
4640 
      if fid == 0:
4641 
        if ftype == TType.BOOL:
4642 
          self.success = iprot.readBool();
4643 
        else:
4644 
          iprot.skip(ftype)
4645 
      elif fid == 1:
4646 
        if ftype == TType.STRUCT:
4647 
          self.ucx = UserContextException()
4648 
          self.ucx.read(iprot)
4649 
        else:
4650 
          iprot.skip(ftype)
4651 
      else:
4652 
        iprot.skip(ftype)
4653 
      iprot.readFieldEnd()
4654 
    iprot.readStructEnd()
4655 
 
4656 
  def write(self, oprot):
4657 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4658 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4659 
      return
4660 
    oprot.writeStructBegin('sendNewPasswordByHandle_result')
4661 
    if self.success != None:
4662 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
4663 
      oprot.writeBool(self.success)
4664 
      oprot.writeFieldEnd()
4665 
    if self.ucx != None:
4666 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
4667 
      self.ucx.write(oprot)
4668 
      oprot.writeFieldEnd()
4669 
    oprot.writeFieldStop()
4670 
    oprot.writeStructEnd()
4671 
 
4672 
  def __repr__(self):
4673 
    L = ['%s=%r' % (key, value)
4674 
      for key, value in self.__dict__.iteritems()]
4675 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4676 
 
4677 
  def __eq__(self, other):
4678 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4679 
 
4680 
  def __ne__(self, other):
4681 
    return not (self == other)
4682 
 
4683