Subversion Repositories SmartDukaan

Rev

Rev 575 | Rev 594 | 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 
  """
559 chandransh 22 
  def createAnonymousUser(self, jsessionId):
94 ashish 23 
    """
24 
    Parameters:
559 chandransh 25 
     - jsessionId
94 ashish 26 
    """
27 
    pass
28 
 
559 chandransh 29 
  def getUserById(self, userId):
94 ashish 30 
    """
31 
    Parameters:
32 
     - userId
33 
    """
34 
    pass
35 
 
559 chandransh 36 
  def createUser(self, user):
94 ashish 37 
    """
38 
    Parameters:
559 chandransh 39 
     - user
94 ashish 40 
    """
41 
    pass
42 
 
559 chandransh 43 
  def updateUser(self, user):
94 ashish 44 
    """
45 
    Parameters:
559 chandransh 46 
     - user
94 ashish 47 
    """
48 
    pass
49 
 
559 chandransh 50 
  def deleteUser(self, userId):
94 ashish 51 
    """
52 
    Parameters:
53 
     - userId
54 
    """
55 
    pass
56 
 
559 chandransh 57 
  def getUserState(self, userId):
94 ashish 58 
    """
59 
    Parameters:
60 
     - userId
61 
    """
62 
    pass
63 
 
559 chandransh 64 
  def authenticateUser(self, email, password):
94 ashish 65 
    """
66 
    Parameters:
67 
     - email
68 
     - password
69 
    """
70 
    pass
71 
 
72 
  def userExists(self, email):
73 
    """
74 
    Parameters:
75 
     - email
76 
    """
77 
    pass
78 
 
567 rajveer 79 
  def addAddressForUser(self, userId, address, setDefault):
94 ashish 80 
    """
81 
    Parameters:
82 
     - userId
83 
     - address
513 rajveer 84 
     - setDefault
94 ashish 85 
    """
86 
    pass
87 
 
88 
  def removeAddressForUser(self, userid, addressId):
89 
    """
90 
    Parameters:
91 
     - userid
92 
     - addressId
93 
    """
94 
    pass
95 
 
96 
  def setUserAsLoggedIn(self, userId, timestamp):
97 
    """
98 
    Parameters:
99 
     - userId
100 
     - timestamp
101 
    """
102 
    pass
103 
 
104 
  def setUserAsLoggedOut(self, userid, timestamp):
105 
    """
106 
    Parameters:
107 
     - userid
108 
     - timestamp
109 
    """
110 
    pass
111 
 
504 rajveer 112 
  def setDefaultAddress(self, userid, addressId):
113 
    """
114 
    Parameters:
115 
     - userid
116 
     - addressId
117 
    """
118 
    pass
119 
 
94 ashish 120 
  def updatePassword(self, userid, password):
121 
    """
122 
    Parameters:
123 
     - userid
124 
     - password
125 
    """
126 
    pass
127 
 
581 rajveer 128 
  def forgotPassword(self, email):
129 
    """
130 
    Parameters:
131 
     - email
132 
    """
133 
    pass
134 
 
559 chandransh 135 
  def createCart(self, userId):
94 ashish 136 
    """
137 
    Parameters:
559 chandransh 138 
     - userId
94 ashish 139 
    """
140 
    pass
141 
 
559 chandransh 142 
  def getCurrentCart(self, userId):
94 ashish 143 
    """
144 
    Parameters:
559 chandransh 145 
     - userId
94 ashish 146 
    """
147 
    pass
148 
 
559 chandransh 149 
  def getCart(self, cartId):
94 ashish 150 
    """
151 
    Parameters:
559 chandransh 152 
     - cartId
94 ashish 153 
    """
154 
    pass
155 
 
559 chandransh 156 
  def getCartsForUser(self, userId, status):
94 ashish 157 
    """
158 
    Parameters:
559 chandransh 159 
     - userId
160 
     - status
94 ashish 161 
    """
162 
    pass
163 
 
559 chandransh 164 
  def getCartsByStatus(self, status):
94 ashish 165 
    """
166 
    Parameters:
559 chandransh 167 
     - status
94 ashish 168 
    """
169 
    pass
170 
 
559 chandransh 171 
  def getCartsByTime(self, from_time, to_time, status):
94 ashish 172 
    """
173 
    Parameters:
559 chandransh 174 
     - from_time
175 
     - to_time
176 
     - status
94 ashish 177 
    """
178 
    pass
179 
 
559 chandransh 180 
  def changeCartStatus(self, cartId, status):
130 ashish 181 
    """
182 
    Parameters:
559 chandransh 183 
     - cartId
184 
     - status
130 ashish 185 
    """
186 
    pass
94 ashish 187 
 
559 chandransh 188 
  def addItemToCart(self, cartId, itemId, quantity):
130 ashish 189 
    """
190 
    Parameters:
559 chandransh 191 
     - cartId
192 
     - itemId
193 
     - quantity
130 ashish 194 
    """
195 
    pass
196 
 
559 chandransh 197 
  def deleteItemFromCart(self, cartId, itemId):
198 
    """
199 
    Parameters:
200 
     - cartId
201 
     - itemId
202 
    """
203 
    pass
130 ashish 204 
 
559 chandransh 205 
  def changeQuantity(self, cartId, itemId, quantity):
206 
    """
207 
    Parameters:
208 
     - cartId
209 
     - itemId
210 
     - quantity
211 
    """
212 
    pass
213 
 
214 
  def changeItemStatus(self, cartId, itemId, status):
215 
    """
216 
    Parameters:
217 
     - cartId
218 
     - itemId
219 
     - status
220 
    """
221 
    pass
222 
 
223 
  def addAddressToCart(self, cartId, addressId):
224 
    """
225 
    Parameters:
226 
     - cartId
227 
     - addressId
228 
    """
229 
    pass
230 
 
231 
  def commitCart(self, cartId):
232 
    """
233 
    Parameters:
234 
     - cartId
235 
    """
236 
    pass
237 
 
238 
  def validateCart(self, cartId):
239 
    """
240 
    Parameters:
241 
     - cartId
242 
    """
243 
    pass
244 
 
575 chandransh 245 
  def refreshCart(self, cartId):
246 
    """
247 
    Parameters:
248 
     - cartId
249 
    """
250 
    pass
251 
 
559 chandransh 252 
  def mergeCart(self, fromCartId, toCartId):
253 
    """
254 
    Parameters:
255 
     - fromCartId
256 
     - toCartId
257 
    """
258 
    pass
259 
 
260 
  def addWidget(self, widget):
261 
    """
262 
    Parameters:
263 
     - widget
264 
    """
265 
    pass
266 
 
267 
  def addItemToWidget(self, widget_id, items):
268 
    """
269 
    Parameters:
270 
     - widget_id
271 
     - items
272 
    """
273 
    pass
274 
 
275 
  def deleteItemFromWidget(self, widget_id, item_id):
276 
    """
277 
    Parameters:
278 
     - widget_id
279 
     - item_id
280 
    """
281 
    pass
282 
 
283 
  def updateWidget(self, widgetId, enable):
284 
    """
285 
    Parameters:
286 
     - widgetId
287 
     - enable
288 
    """
289 
    pass
290 
 
291 
  def updateWidgetItem(self, widgetId, enable):
292 
    """
293 
    Parameters:
294 
     - widgetId
295 
     - enable
296 
    """
297 
    pass
298 
 
299 
  def getWidget(self, type, userId, onlyEnabled):
300 
    """
301 
    Parameters:
302 
     - type
303 
     - userId
304 
     - onlyEnabled
305 
    """
306 
    pass
307 
 
308 
  def getMyResearch(self, user_id):
309 
    """
310 
    Parameters:
311 
     - user_id
312 
    """
313 
    pass
314 
 
315 
  def updateMyResearch(self, user_id, item_id):
316 
    """
317 
    Parameters:
318 
     - user_id
319 
     - item_id
320 
    """
321 
    pass
322 
 
323 
  def deleteItemFromMyResearch(self, user_id, item_id):
324 
    """
325 
    Parameters:
326 
     - user_id
327 
     - item_id
328 
    """
329 
    pass
330 
 
331 
  def updateRatings(self, item_id, type, rating, user_id):
332 
    """
333 
    Parameters:
334 
     - item_id
335 
     - type
336 
     - rating
337 
     - user_id
338 
    """
339 
    pass
340 
 
341 
  def getRatings(self, item_id, user_id):
342 
    """
343 
    Parameters:
344 
     - item_id
345 
     - user_id
346 
    """
347 
    pass
348 
 
349 
  def updateBrowseHistory(self, user_id, item_id, isSessionId):
350 
    """
351 
    Parameters:
352 
     - user_id
353 
     - item_id
354 
     - isSessionId
355 
    """
356 
    pass
357 
 
358 
  def getBrowseHistory(self, userId, isSessionId):
359 
    """
360 
    Parameters:
361 
     - userId
362 
     - isSessionId
363 
    """
364 
    pass
365 
 
366 
 
94 ashish 367 
class Client(Iface):
368 
  """
369 
  service
370 
  """
371 
  def __init__(self, iprot, oprot=None):
372 
    self._iprot = self._oprot = iprot
373 
    if oprot != None:
374 
      self._oprot = oprot
375 
    self._seqid = 0
376 
 
559 chandransh 377 
  def createAnonymousUser(self, jsessionId):
94 ashish 378 
    """
379 
    Parameters:
559 chandransh 380 
     - jsessionId
94 ashish 381 
    """
559 chandransh 382 
    self.send_createAnonymousUser(jsessionId)
383 
    return self.recv_createAnonymousUser()
94 ashish 384 
 
559 chandransh 385 
  def send_createAnonymousUser(self, jsessionId):
386 
    self._oprot.writeMessageBegin('createAnonymousUser', TMessageType.CALL, self._seqid)
387 
    args = createAnonymousUser_args()
388 
    args.jsessionId = jsessionId
94 ashish 389 
    args.write(self._oprot)
390 
    self._oprot.writeMessageEnd()
391 
    self._oprot.trans.flush()
392 
 
559 chandransh 393 
  def recv_createAnonymousUser(self, ):
94 ashish 394 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
395 
    if mtype == TMessageType.EXCEPTION:
396 
      x = TApplicationException()
397 
      x.read(self._iprot)
398 
      self._iprot.readMessageEnd()
399 
      raise x
559 chandransh 400 
    result = createAnonymousUser_result()
94 ashish 401 
    result.read(self._iprot)
402 
    self._iprot.readMessageEnd()
403 
    if result.success != None:
404 
      return result.success
559 chandransh 405 
    if result.ucex != None:
406 
      raise result.ucex
407 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createAnonymousUser failed: unknown result");
94 ashish 408 
 
559 chandransh 409 
  def getUserById(self, userId):
94 ashish 410 
    """
411 
    Parameters:
412 
     - userId
413 
    """
559 chandransh 414 
    self.send_getUserById(userId)
415 
    return self.recv_getUserById()
94 ashish 416 
 
559 chandransh 417 
  def send_getUserById(self, userId):
418 
    self._oprot.writeMessageBegin('getUserById', TMessageType.CALL, self._seqid)
419 
    args = getUserById_args()
94 ashish 420 
    args.userId = userId
421 
    args.write(self._oprot)
422 
    self._oprot.writeMessageEnd()
423 
    self._oprot.trans.flush()
424 
 
559 chandransh 425 
  def recv_getUserById(self, ):
94 ashish 426 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
427 
    if mtype == TMessageType.EXCEPTION:
428 
      x = TApplicationException()
429 
      x.read(self._iprot)
430 
      self._iprot.readMessageEnd()
431 
      raise x
559 chandransh 432 
    result = getUserById_result()
94 ashish 433 
    result.read(self._iprot)
434 
    self._iprot.readMessageEnd()
435 
    if result.success != None:
436 
      return result.success
559 chandransh 437 
    if result.ucex != None:
438 
      raise result.ucex
439 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserById failed: unknown result");
94 ashish 440 
 
559 chandransh 441 
  def createUser(self, user):
94 ashish 442 
    """
443 
    Parameters:
559 chandransh 444 
     - user
94 ashish 445 
    """
559 chandransh 446 
    self.send_createUser(user)
447 
    return self.recv_createUser()
94 ashish 448 
 
559 chandransh 449 
  def send_createUser(self, user):
450 
    self._oprot.writeMessageBegin('createUser', TMessageType.CALL, self._seqid)
451 
    args = createUser_args()
452 
    args.user = user
94 ashish 453 
    args.write(self._oprot)
454 
    self._oprot.writeMessageEnd()
455 
    self._oprot.trans.flush()
456 
 
559 chandransh 457 
  def recv_createUser(self, ):
94 ashish 458 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
459 
    if mtype == TMessageType.EXCEPTION:
460 
      x = TApplicationException()
461 
      x.read(self._iprot)
462 
      self._iprot.readMessageEnd()
463 
      raise x
559 chandransh 464 
    result = createUser_result()
94 ashish 465 
    result.read(self._iprot)
466 
    self._iprot.readMessageEnd()
467 
    if result.success != None:
468 
      return result.success
559 chandransh 469 
    if result.ucex != None:
470 
      raise result.ucex
471 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createUser failed: unknown result");
94 ashish 472 
 
559 chandransh 473 
  def updateUser(self, user):
94 ashish 474 
    """
475 
    Parameters:
559 chandransh 476 
     - user
94 ashish 477 
    """
559 chandransh 478 
    self.send_updateUser(user)
479 
    return self.recv_updateUser()
94 ashish 480 
 
559 chandransh 481 
  def send_updateUser(self, user):
482 
    self._oprot.writeMessageBegin('updateUser', TMessageType.CALL, self._seqid)
483 
    args = updateUser_args()
484 
    args.user = user
94 ashish 485 
    args.write(self._oprot)
486 
    self._oprot.writeMessageEnd()
487 
    self._oprot.trans.flush()
488 
 
559 chandransh 489 
  def recv_updateUser(self, ):
94 ashish 490 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
491 
    if mtype == TMessageType.EXCEPTION:
492 
      x = TApplicationException()
493 
      x.read(self._iprot)
494 
      self._iprot.readMessageEnd()
495 
      raise x
559 chandransh 496 
    result = updateUser_result()
94 ashish 497 
    result.read(self._iprot)
498 
    self._iprot.readMessageEnd()
499 
    if result.success != None:
500 
      return result.success
559 chandransh 501 
    if result.ucex != None:
502 
      raise result.ucex
503 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateUser failed: unknown result");
94 ashish 504 
 
559 chandransh 505 
  def deleteUser(self, userId):
94 ashish 506 
    """
507 
    Parameters:
508 
     - userId
509 
    """
559 chandransh 510 
    self.send_deleteUser(userId)
511 
    return self.recv_deleteUser()
94 ashish 512 
 
559 chandransh 513 
  def send_deleteUser(self, userId):
514 
    self._oprot.writeMessageBegin('deleteUser', TMessageType.CALL, self._seqid)
515 
    args = deleteUser_args()
94 ashish 516 
    args.userId = userId
517 
    args.write(self._oprot)
518 
    self._oprot.writeMessageEnd()
519 
    self._oprot.trans.flush()
520 
 
559 chandransh 521 
  def recv_deleteUser(self, ):
94 ashish 522 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
523 
    if mtype == TMessageType.EXCEPTION:
524 
      x = TApplicationException()
525 
      x.read(self._iprot)
526 
      self._iprot.readMessageEnd()
527 
      raise x
559 chandransh 528 
    result = deleteUser_result()
94 ashish 529 
    result.read(self._iprot)
530 
    self._iprot.readMessageEnd()
531 
    if result.success != None:
532 
      return result.success
559 chandransh 533 
    if result.ucex != None:
534 
      raise result.ucex
535 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteUser failed: unknown result");
94 ashish 536 
 
559 chandransh 537 
  def getUserState(self, userId):
94 ashish 538 
    """
539 
    Parameters:
540 
     - userId
541 
    """
559 chandransh 542 
    self.send_getUserState(userId)
543 
    return self.recv_getUserState()
94 ashish 544 
 
559 chandransh 545 
  def send_getUserState(self, userId):
546 
    self._oprot.writeMessageBegin('getUserState', TMessageType.CALL, self._seqid)
547 
    args = getUserState_args()
94 ashish 548 
    args.userId = userId
549 
    args.write(self._oprot)
550 
    self._oprot.writeMessageEnd()
551 
    self._oprot.trans.flush()
552 
 
559 chandransh 553 
  def recv_getUserState(self, ):
94 ashish 554 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
555 
    if mtype == TMessageType.EXCEPTION:
556 
      x = TApplicationException()
557 
      x.read(self._iprot)
558 
      self._iprot.readMessageEnd()
559 
      raise x
559 chandransh 560 
    result = getUserState_result()
94 ashish 561 
    result.read(self._iprot)
562 
    self._iprot.readMessageEnd()
563 
    if result.success != None:
564 
      return result.success
559 chandransh 565 
    if result.ucex != None:
566 
      raise result.ucex
567 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserState failed: unknown result");
94 ashish 568 
 
559 chandransh 569 
  def authenticateUser(self, email, password):
94 ashish 570 
    """
571 
    Parameters:
572 
     - email
573 
     - password
574 
    """
559 chandransh 575 
    self.send_authenticateUser(email, password)
122 ashish 576 
    return self.recv_authenticateUser()
577 
 
559 chandransh 578 
  def send_authenticateUser(self, email, password):
122 ashish 579 
    self._oprot.writeMessageBegin('authenticateUser', TMessageType.CALL, self._seqid)
580 
    args = authenticateUser_args()
559 chandransh 581 
    args.email = email
122 ashish 582 
    args.password = password
583 
    args.write(self._oprot)
584 
    self._oprot.writeMessageEnd()
585 
    self._oprot.trans.flush()
586 
 
587 
  def recv_authenticateUser(self, ):
588 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
589 
    if mtype == TMessageType.EXCEPTION:
590 
      x = TApplicationException()
591 
      x.read(self._iprot)
592 
      self._iprot.readMessageEnd()
593 
      raise x
594 
    result = authenticateUser_result()
595 
    result.read(self._iprot)
596 
    self._iprot.readMessageEnd()
597 
    if result.success != None:
598 
      return result.success
559 chandransh 599 
    if result.auex != None:
600 
      raise result.auex
122 ashish 601 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authenticateUser failed: unknown result");
602 
 
94 ashish 603 
  def userExists(self, email):
604 
    """
605 
    Parameters:
606 
     - email
607 
    """
608 
    self.send_userExists(email)
609 
    return self.recv_userExists()
610 
 
611 
  def send_userExists(self, email):
612 
    self._oprot.writeMessageBegin('userExists', TMessageType.CALL, self._seqid)
613 
    args = userExists_args()
614 
    args.email = email
615 
    args.write(self._oprot)
616 
    self._oprot.writeMessageEnd()
617 
    self._oprot.trans.flush()
618 
 
619 
  def recv_userExists(self, ):
620 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
621 
    if mtype == TMessageType.EXCEPTION:
622 
      x = TApplicationException()
623 
      x.read(self._iprot)
624 
      self._iprot.readMessageEnd()
625 
      raise x
626 
    result = userExists_result()
627 
    result.read(self._iprot)
628 
    self._iprot.readMessageEnd()
629 
    if result.success != None:
630 
      return result.success
631 
    if result.ucx != None:
632 
      raise result.ucx
633 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "userExists failed: unknown result");
634 
 
567 rajveer 635 
  def addAddressForUser(self, userId, address, setDefault):
94 ashish 636 
    """
637 
    Parameters:
638 
     - userId
639 
     - address
513 rajveer 640 
     - setDefault
94 ashish 641 
    """
567 rajveer 642 
    self.send_addAddressForUser(userId, address, setDefault)
94 ashish 643 
    return self.recv_addAddressForUser()
644 
 
567 rajveer 645 
  def send_addAddressForUser(self, userId, address, setDefault):
94 ashish 646 
    self._oprot.writeMessageBegin('addAddressForUser', TMessageType.CALL, self._seqid)
647 
    args = addAddressForUser_args()
559 chandransh 648 
    args.userId = userId
94 ashish 649 
    args.address = address
513 rajveer 650 
    args.setDefault = setDefault
94 ashish 651 
    args.write(self._oprot)
652 
    self._oprot.writeMessageEnd()
653 
    self._oprot.trans.flush()
654 
 
655 
  def recv_addAddressForUser(self, ):
656 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
657 
    if mtype == TMessageType.EXCEPTION:
658 
      x = TApplicationException()
659 
      x.read(self._iprot)
660 
      self._iprot.readMessageEnd()
661 
      raise x
662 
    result = addAddressForUser_result()
663 
    result.read(self._iprot)
664 
    self._iprot.readMessageEnd()
665 
    if result.success != None:
666 
      return result.success
667 
    if result.ucx != None:
668 
      raise result.ucx
669 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addAddressForUser failed: unknown result");
670 
 
671 
  def removeAddressForUser(self, userid, addressId):
672 
    """
673 
    Parameters:
674 
     - userid
675 
     - addressId
676 
    """
677 
    self.send_removeAddressForUser(userid, addressId)
678 
    return self.recv_removeAddressForUser()
679 
 
680 
  def send_removeAddressForUser(self, userid, addressId):
681 
    self._oprot.writeMessageBegin('removeAddressForUser', TMessageType.CALL, self._seqid)
682 
    args = removeAddressForUser_args()
683 
    args.userid = userid
684 
    args.addressId = addressId
685 
    args.write(self._oprot)
686 
    self._oprot.writeMessageEnd()
687 
    self._oprot.trans.flush()
688 
 
689 
  def recv_removeAddressForUser(self, ):
690 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
691 
    if mtype == TMessageType.EXCEPTION:
692 
      x = TApplicationException()
693 
      x.read(self._iprot)
694 
      self._iprot.readMessageEnd()
695 
      raise x
696 
    result = removeAddressForUser_result()
697 
    result.read(self._iprot)
698 
    self._iprot.readMessageEnd()
699 
    if result.success != None:
700 
      return result.success
701 
    if result.ucx != None:
702 
      raise result.ucx
703 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "removeAddressForUser failed: unknown result");
704 
 
705 
  def setUserAsLoggedIn(self, userId, timestamp):
706 
    """
707 
    Parameters:
708 
     - userId
709 
     - timestamp
710 
    """
711 
    self.send_setUserAsLoggedIn(userId, timestamp)
712 
    return self.recv_setUserAsLoggedIn()
713 
 
714 
  def send_setUserAsLoggedIn(self, userId, timestamp):
715 
    self._oprot.writeMessageBegin('setUserAsLoggedIn', TMessageType.CALL, self._seqid)
716 
    args = setUserAsLoggedIn_args()
717 
    args.userId = userId
718 
    args.timestamp = timestamp
719 
    args.write(self._oprot)
720 
    self._oprot.writeMessageEnd()
721 
    self._oprot.trans.flush()
722 
 
723 
  def recv_setUserAsLoggedIn(self, ):
724 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
725 
    if mtype == TMessageType.EXCEPTION:
726 
      x = TApplicationException()
727 
      x.read(self._iprot)
728 
      self._iprot.readMessageEnd()
729 
      raise x
730 
    result = setUserAsLoggedIn_result()
731 
    result.read(self._iprot)
732 
    self._iprot.readMessageEnd()
733 
    if result.success != None:
734 
      return result.success
735 
    if result.ucx != None:
736 
      raise result.ucx
737 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "setUserAsLoggedIn failed: unknown result");
738 
 
739 
  def setUserAsLoggedOut(self, userid, timestamp):
740 
    """
741 
    Parameters:
742 
     - userid
743 
     - timestamp
744 
    """
745 
    self.send_setUserAsLoggedOut(userid, timestamp)
746 
    return self.recv_setUserAsLoggedOut()
747 
 
748 
  def send_setUserAsLoggedOut(self, userid, timestamp):
749 
    self._oprot.writeMessageBegin('setUserAsLoggedOut', TMessageType.CALL, self._seqid)
750 
    args = setUserAsLoggedOut_args()
751 
    args.userid = userid
752 
    args.timestamp = timestamp
753 
    args.write(self._oprot)
754 
    self._oprot.writeMessageEnd()
755 
    self._oprot.trans.flush()
756 
 
757 
  def recv_setUserAsLoggedOut(self, ):
758 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
759 
    if mtype == TMessageType.EXCEPTION:
760 
      x = TApplicationException()
761 
      x.read(self._iprot)
762 
      self._iprot.readMessageEnd()
763 
      raise x
764 
    result = setUserAsLoggedOut_result()
765 
    result.read(self._iprot)
766 
    self._iprot.readMessageEnd()
767 
    if result.success != None:
768 
      return result.success
769 
    if result.ucx != None:
770 
      raise result.ucx
771 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "setUserAsLoggedOut failed: unknown result");
772 
 
504 rajveer 773 
  def setDefaultAddress(self, userid, addressId):
774 
    """
775 
    Parameters:
776 
     - userid
777 
     - addressId
778 
    """
779 
    self.send_setDefaultAddress(userid, addressId)
780 
    return self.recv_setDefaultAddress()
781 
 
782 
  def send_setDefaultAddress(self, userid, addressId):
783 
    self._oprot.writeMessageBegin('setDefaultAddress', TMessageType.CALL, self._seqid)
784 
    args = setDefaultAddress_args()
785 
    args.userid = userid
786 
    args.addressId = addressId
787 
    args.write(self._oprot)
788 
    self._oprot.writeMessageEnd()
789 
    self._oprot.trans.flush()
790 
 
791 
  def recv_setDefaultAddress(self, ):
792 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
793 
    if mtype == TMessageType.EXCEPTION:
794 
      x = TApplicationException()
795 
      x.read(self._iprot)
796 
      self._iprot.readMessageEnd()
797 
      raise x
798 
    result = setDefaultAddress_result()
799 
    result.read(self._iprot)
800 
    self._iprot.readMessageEnd()
801 
    if result.success != None:
802 
      return result.success
803 
    if result.ucx != None:
804 
      raise result.ucx
805 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "setDefaultAddress failed: unknown result");
806 
 
94 ashish 807 
  def updatePassword(self, userid, password):
808 
    """
809 
    Parameters:
810 
     - userid
811 
     - password
812 
    """
813 
    self.send_updatePassword(userid, password)
814 
    return self.recv_updatePassword()
815 
 
816 
  def send_updatePassword(self, userid, password):
817 
    self._oprot.writeMessageBegin('updatePassword', TMessageType.CALL, self._seqid)
818 
    args = updatePassword_args()
819 
    args.userid = userid
820 
    args.password = password
821 
    args.write(self._oprot)
822 
    self._oprot.writeMessageEnd()
823 
    self._oprot.trans.flush()
824 
 
825 
  def recv_updatePassword(self, ):
826 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
827 
    if mtype == TMessageType.EXCEPTION:
828 
      x = TApplicationException()
829 
      x.read(self._iprot)
830 
      self._iprot.readMessageEnd()
831 
      raise x
832 
    result = updatePassword_result()
833 
    result.read(self._iprot)
834 
    self._iprot.readMessageEnd()
835 
    if result.success != None:
836 
      return result.success
837 
    if result.ucx != None:
838 
      raise result.ucx
839 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updatePassword failed: unknown result");
840 
 
581 rajveer 841 
  def forgotPassword(self, email):
842 
    """
843 
    Parameters:
844 
     - email
845 
    """
846 
    self.send_forgotPassword(email)
847 
    return self.recv_forgotPassword()
848 
 
849 
  def send_forgotPassword(self, email):
850 
    self._oprot.writeMessageBegin('forgotPassword', TMessageType.CALL, self._seqid)
851 
    args = forgotPassword_args()
852 
    args.email = email
853 
    args.write(self._oprot)
854 
    self._oprot.writeMessageEnd()
855 
    self._oprot.trans.flush()
856 
 
857 
  def recv_forgotPassword(self, ):
858 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
859 
    if mtype == TMessageType.EXCEPTION:
860 
      x = TApplicationException()
861 
      x.read(self._iprot)
862 
      self._iprot.readMessageEnd()
863 
      raise x
864 
    result = forgotPassword_result()
865 
    result.read(self._iprot)
866 
    self._iprot.readMessageEnd()
867 
    if result.success != None:
868 
      return result.success
869 
    if result.ucx != None:
870 
      raise result.ucx
871 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "forgotPassword failed: unknown result");
872 
 
559 chandransh 873 
  def createCart(self, userId):
94 ashish 874 
    """
875 
    Parameters:
559 chandransh 876 
     - userId
94 ashish 877 
    """
559 chandransh 878 
    self.send_createCart(userId)
879 
    return self.recv_createCart()
94 ashish 880 
 
559 chandransh 881 
  def send_createCart(self, userId):
882 
    self._oprot.writeMessageBegin('createCart', TMessageType.CALL, self._seqid)
883 
    args = createCart_args()
884 
    args.userId = userId
94 ashish 885 
    args.write(self._oprot)
886 
    self._oprot.writeMessageEnd()
887 
    self._oprot.trans.flush()
888 
 
559 chandransh 889 
  def recv_createCart(self, ):
94 ashish 890 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
891 
    if mtype == TMessageType.EXCEPTION:
892 
      x = TApplicationException()
893 
      x.read(self._iprot)
894 
      self._iprot.readMessageEnd()
895 
      raise x
559 chandransh 896 
    result = createCart_result()
94 ashish 897 
    result.read(self._iprot)
898 
    self._iprot.readMessageEnd()
899 
    if result.success != None:
900 
      return result.success
559 chandransh 901 
    if result.scx != None:
902 
      raise result.scx
903 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createCart failed: unknown result");
94 ashish 904 
 
559 chandransh 905 
  def getCurrentCart(self, userId):
94 ashish 906 
    """
907 
    Parameters:
559 chandransh 908 
     - userId
94 ashish 909 
    """
559 chandransh 910 
    self.send_getCurrentCart(userId)
911 
    return self.recv_getCurrentCart()
94 ashish 912 
 
559 chandransh 913 
  def send_getCurrentCart(self, userId):
914 
    self._oprot.writeMessageBegin('getCurrentCart', TMessageType.CALL, self._seqid)
915 
    args = getCurrentCart_args()
916 
    args.userId = userId
94 ashish 917 
    args.write(self._oprot)
918 
    self._oprot.writeMessageEnd()
919 
    self._oprot.trans.flush()
920 
 
559 chandransh 921 
  def recv_getCurrentCart(self, ):
94 ashish 922 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
923 
    if mtype == TMessageType.EXCEPTION:
924 
      x = TApplicationException()
925 
      x.read(self._iprot)
926 
      self._iprot.readMessageEnd()
927 
      raise x
559 chandransh 928 
    result = getCurrentCart_result()
94 ashish 929 
    result.read(self._iprot)
930 
    self._iprot.readMessageEnd()
931 
    if result.success != None:
932 
      return result.success
559 chandransh 933 
    if result.scx != None:
934 
      raise result.scx
935 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCurrentCart failed: unknown result");
94 ashish 936 
 
559 chandransh 937 
  def getCart(self, cartId):
94 ashish 938 
    """
939 
    Parameters:
559 chandransh 940 
     - cartId
94 ashish 941 
    """
559 chandransh 942 
    self.send_getCart(cartId)
943 
    return self.recv_getCart()
94 ashish 944 
 
559 chandransh 945 
  def send_getCart(self, cartId):
946 
    self._oprot.writeMessageBegin('getCart', TMessageType.CALL, self._seqid)
947 
    args = getCart_args()
948 
    args.cartId = cartId
94 ashish 949 
    args.write(self._oprot)
950 
    self._oprot.writeMessageEnd()
951 
    self._oprot.trans.flush()
952 
 
559 chandransh 953 
  def recv_getCart(self, ):
94 ashish 954 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
955 
    if mtype == TMessageType.EXCEPTION:
956 
      x = TApplicationException()
957 
      x.read(self._iprot)
958 
      self._iprot.readMessageEnd()
959 
      raise x
559 chandransh 960 
    result = getCart_result()
94 ashish 961 
    result.read(self._iprot)
962 
    self._iprot.readMessageEnd()
963 
    if result.success != None:
964 
      return result.success
559 chandransh 965 
    if result.scx != None:
966 
      raise result.scx
967 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCart failed: unknown result");
94 ashish 968 
 
559 chandransh 969 
  def getCartsForUser(self, userId, status):
94 ashish 970 
    """
971 
    Parameters:
559 chandransh 972 
     - userId
973 
     - status
94 ashish 974 
    """
559 chandransh 975 
    self.send_getCartsForUser(userId, status)
976 
    return self.recv_getCartsForUser()
94 ashish 977 
 
559 chandransh 978 
  def send_getCartsForUser(self, userId, status):
979 
    self._oprot.writeMessageBegin('getCartsForUser', TMessageType.CALL, self._seqid)
980 
    args = getCartsForUser_args()
981 
    args.userId = userId
982 
    args.status = status
94 ashish 983 
    args.write(self._oprot)
984 
    self._oprot.writeMessageEnd()
985 
    self._oprot.trans.flush()
986 
 
559 chandransh 987 
  def recv_getCartsForUser(self, ):
94 ashish 988 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
989 
    if mtype == TMessageType.EXCEPTION:
990 
      x = TApplicationException()
991 
      x.read(self._iprot)
992 
      self._iprot.readMessageEnd()
993 
      raise x
559 chandransh 994 
    result = getCartsForUser_result()
94 ashish 995 
    result.read(self._iprot)
996 
    self._iprot.readMessageEnd()
997 
    if result.success != None:
998 
      return result.success
559 chandransh 999 
    if result.scx != None:
1000 
      raise result.scx
1001 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCartsForUser failed: unknown result");
94 ashish 1002 
 
559 chandransh 1003 
  def getCartsByStatus(self, status):
94 ashish 1004 
    """
1005 
    Parameters:
559 chandransh 1006 
     - status
94 ashish 1007 
    """
559 chandransh 1008 
    self.send_getCartsByStatus(status)
1009 
    return self.recv_getCartsByStatus()
94 ashish 1010 
 
559 chandransh 1011 
  def send_getCartsByStatus(self, status):
1012 
    self._oprot.writeMessageBegin('getCartsByStatus', TMessageType.CALL, self._seqid)
1013 
    args = getCartsByStatus_args()
1014 
    args.status = status
94 ashish 1015 
    args.write(self._oprot)
1016 
    self._oprot.writeMessageEnd()
1017 
    self._oprot.trans.flush()
1018 
 
559 chandransh 1019 
  def recv_getCartsByStatus(self, ):
94 ashish 1020 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1021 
    if mtype == TMessageType.EXCEPTION:
1022 
      x = TApplicationException()
1023 
      x.read(self._iprot)
1024 
      self._iprot.readMessageEnd()
1025 
      raise x
559 chandransh 1026 
    result = getCartsByStatus_result()
94 ashish 1027 
    result.read(self._iprot)
1028 
    self._iprot.readMessageEnd()
1029 
    if result.success != None:
1030 
      return result.success
559 chandransh 1031 
    if result.scx != None:
1032 
      raise result.scx
1033 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCartsByStatus failed: unknown result");
94 ashish 1034 
 
559 chandransh 1035 
  def getCartsByTime(self, from_time, to_time, status):
94 ashish 1036 
    """
1037 
    Parameters:
559 chandransh 1038 
     - from_time
1039 
     - to_time
1040 
     - status
94 ashish 1041 
    """
559 chandransh 1042 
    self.send_getCartsByTime(from_time, to_time, status)
1043 
    return self.recv_getCartsByTime()
94 ashish 1044 
 
559 chandransh 1045 
  def send_getCartsByTime(self, from_time, to_time, status):
1046 
    self._oprot.writeMessageBegin('getCartsByTime', TMessageType.CALL, self._seqid)
1047 
    args = getCartsByTime_args()
1048 
    args.from_time = from_time
1049 
    args.to_time = to_time
1050 
    args.status = status
94 ashish 1051 
    args.write(self._oprot)
1052 
    self._oprot.writeMessageEnd()
1053 
    self._oprot.trans.flush()
1054 
 
559 chandransh 1055 
  def recv_getCartsByTime(self, ):
94 ashish 1056 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1057 
    if mtype == TMessageType.EXCEPTION:
1058 
      x = TApplicationException()
1059 
      x.read(self._iprot)
1060 
      self._iprot.readMessageEnd()
1061 
      raise x
559 chandransh 1062 
    result = getCartsByTime_result()
94 ashish 1063 
    result.read(self._iprot)
1064 
    self._iprot.readMessageEnd()
1065 
    if result.success != None:
1066 
      return result.success
559 chandransh 1067 
    if result.scx != None:
1068 
      raise result.scx
1069 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCartsByTime failed: unknown result");
94 ashish 1070 
 
559 chandransh 1071 
  def changeCartStatus(self, cartId, status):
130 ashish 1072 
    """
1073 
    Parameters:
559 chandransh 1074 
     - cartId
1075 
     - status
130 ashish 1076 
    """
559 chandransh 1077 
    self.send_changeCartStatus(cartId, status)
1078 
    self.recv_changeCartStatus()
94 ashish 1079 
 
559 chandransh 1080 
  def send_changeCartStatus(self, cartId, status):
1081 
    self._oprot.writeMessageBegin('changeCartStatus', TMessageType.CALL, self._seqid)
1082 
    args = changeCartStatus_args()
1083 
    args.cartId = cartId
1084 
    args.status = status
130 ashish 1085 
    args.write(self._oprot)
1086 
    self._oprot.writeMessageEnd()
1087 
    self._oprot.trans.flush()
1088 
 
559 chandransh 1089 
  def recv_changeCartStatus(self, ):
130 ashish 1090 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1091 
    if mtype == TMessageType.EXCEPTION:
1092 
      x = TApplicationException()
1093 
      x.read(self._iprot)
1094 
      self._iprot.readMessageEnd()
1095 
      raise x
559 chandransh 1096 
    result = changeCartStatus_result()
130 ashish 1097 
    result.read(self._iprot)
1098 
    self._iprot.readMessageEnd()
559 chandransh 1099 
    if result.scx != None:
1100 
      raise result.scx
1101 
    return
1102 
 
1103 
  def addItemToCart(self, cartId, itemId, quantity):
1104 
    """
1105 
    Parameters:
1106 
     - cartId
1107 
     - itemId
1108 
     - quantity
1109 
    """
1110 
    self.send_addItemToCart(cartId, itemId, quantity)
1111 
    self.recv_addItemToCart()
1112 
 
1113 
  def send_addItemToCart(self, cartId, itemId, quantity):
1114 
    self._oprot.writeMessageBegin('addItemToCart', TMessageType.CALL, self._seqid)
1115 
    args = addItemToCart_args()
1116 
    args.cartId = cartId
1117 
    args.itemId = itemId
1118 
    args.quantity = quantity
1119 
    args.write(self._oprot)
1120 
    self._oprot.writeMessageEnd()
1121 
    self._oprot.trans.flush()
1122 
 
1123 
  def recv_addItemToCart(self, ):
1124 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1125 
    if mtype == TMessageType.EXCEPTION:
1126 
      x = TApplicationException()
1127 
      x.read(self._iprot)
1128 
      self._iprot.readMessageEnd()
1129 
      raise x
1130 
    result = addItemToCart_result()
1131 
    result.read(self._iprot)
1132 
    self._iprot.readMessageEnd()
1133 
    if result.scx != None:
1134 
      raise result.scx
1135 
    return
1136 
 
1137 
  def deleteItemFromCart(self, cartId, itemId):
1138 
    """
1139 
    Parameters:
1140 
     - cartId
1141 
     - itemId
1142 
    """
1143 
    self.send_deleteItemFromCart(cartId, itemId)
1144 
    self.recv_deleteItemFromCart()
1145 
 
1146 
  def send_deleteItemFromCart(self, cartId, itemId):
1147 
    self._oprot.writeMessageBegin('deleteItemFromCart', TMessageType.CALL, self._seqid)
1148 
    args = deleteItemFromCart_args()
1149 
    args.cartId = cartId
1150 
    args.itemId = itemId
1151 
    args.write(self._oprot)
1152 
    self._oprot.writeMessageEnd()
1153 
    self._oprot.trans.flush()
1154 
 
1155 
  def recv_deleteItemFromCart(self, ):
1156 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1157 
    if mtype == TMessageType.EXCEPTION:
1158 
      x = TApplicationException()
1159 
      x.read(self._iprot)
1160 
      self._iprot.readMessageEnd()
1161 
      raise x
1162 
    result = deleteItemFromCart_result()
1163 
    result.read(self._iprot)
1164 
    self._iprot.readMessageEnd()
1165 
    if result.scx != None:
1166 
      raise result.scx
1167 
    return
1168 
 
1169 
  def changeQuantity(self, cartId, itemId, quantity):
1170 
    """
1171 
    Parameters:
1172 
     - cartId
1173 
     - itemId
1174 
     - quantity
1175 
    """
1176 
    self.send_changeQuantity(cartId, itemId, quantity)
1177 
    self.recv_changeQuantity()
1178 
 
1179 
  def send_changeQuantity(self, cartId, itemId, quantity):
1180 
    self._oprot.writeMessageBegin('changeQuantity', TMessageType.CALL, self._seqid)
1181 
    args = changeQuantity_args()
1182 
    args.cartId = cartId
1183 
    args.itemId = itemId
1184 
    args.quantity = quantity
1185 
    args.write(self._oprot)
1186 
    self._oprot.writeMessageEnd()
1187 
    self._oprot.trans.flush()
1188 
 
1189 
  def recv_changeQuantity(self, ):
1190 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1191 
    if mtype == TMessageType.EXCEPTION:
1192 
      x = TApplicationException()
1193 
      x.read(self._iprot)
1194 
      self._iprot.readMessageEnd()
1195 
      raise x
1196 
    result = changeQuantity_result()
1197 
    result.read(self._iprot)
1198 
    self._iprot.readMessageEnd()
1199 
    if result.scx != None:
1200 
      raise result.scx
1201 
    return
1202 
 
1203 
  def changeItemStatus(self, cartId, itemId, status):
1204 
    """
1205 
    Parameters:
1206 
     - cartId
1207 
     - itemId
1208 
     - status
1209 
    """
1210 
    self.send_changeItemStatus(cartId, itemId, status)
1211 
    self.recv_changeItemStatus()
1212 
 
1213 
  def send_changeItemStatus(self, cartId, itemId, status):
1214 
    self._oprot.writeMessageBegin('changeItemStatus', TMessageType.CALL, self._seqid)
1215 
    args = changeItemStatus_args()
1216 
    args.cartId = cartId
1217 
    args.itemId = itemId
1218 
    args.status = status
1219 
    args.write(self._oprot)
1220 
    self._oprot.writeMessageEnd()
1221 
    self._oprot.trans.flush()
1222 
 
1223 
  def recv_changeItemStatus(self, ):
1224 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1225 
    if mtype == TMessageType.EXCEPTION:
1226 
      x = TApplicationException()
1227 
      x.read(self._iprot)
1228 
      self._iprot.readMessageEnd()
1229 
      raise x
1230 
    result = changeItemStatus_result()
1231 
    result.read(self._iprot)
1232 
    self._iprot.readMessageEnd()
1233 
    if result.scx != None:
1234 
      raise result.scx
1235 
    return
1236 
 
1237 
  def addAddressToCart(self, cartId, addressId):
1238 
    """
1239 
    Parameters:
1240 
     - cartId
1241 
     - addressId
1242 
    """
1243 
    self.send_addAddressToCart(cartId, addressId)
1244 
    self.recv_addAddressToCart()
1245 
 
1246 
  def send_addAddressToCart(self, cartId, addressId):
1247 
    self._oprot.writeMessageBegin('addAddressToCart', TMessageType.CALL, self._seqid)
1248 
    args = addAddressToCart_args()
1249 
    args.cartId = cartId
1250 
    args.addressId = addressId
1251 
    args.write(self._oprot)
1252 
    self._oprot.writeMessageEnd()
1253 
    self._oprot.trans.flush()
1254 
 
1255 
  def recv_addAddressToCart(self, ):
1256 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1257 
    if mtype == TMessageType.EXCEPTION:
1258 
      x = TApplicationException()
1259 
      x.read(self._iprot)
1260 
      self._iprot.readMessageEnd()
1261 
      raise x
1262 
    result = addAddressToCart_result()
1263 
    result.read(self._iprot)
1264 
    self._iprot.readMessageEnd()
575 chandransh 1265 
    if result.scx != None:
1266 
      raise result.scx
559 chandransh 1267 
    return
1268 
 
1269 
  def commitCart(self, cartId):
1270 
    """
1271 
    Parameters:
1272 
     - cartId
1273 
    """
1274 
    self.send_commitCart(cartId)
1275 
    return self.recv_commitCart()
1276 
 
1277 
  def send_commitCart(self, cartId):
1278 
    self._oprot.writeMessageBegin('commitCart', TMessageType.CALL, self._seqid)
1279 
    args = commitCart_args()
1280 
    args.cartId = cartId
1281 
    args.write(self._oprot)
1282 
    self._oprot.writeMessageEnd()
1283 
    self._oprot.trans.flush()
1284 
 
1285 
  def recv_commitCart(self, ):
1286 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1287 
    if mtype == TMessageType.EXCEPTION:
1288 
      x = TApplicationException()
1289 
      x.read(self._iprot)
1290 
      self._iprot.readMessageEnd()
1291 
      raise x
1292 
    result = commitCart_result()
1293 
    result.read(self._iprot)
1294 
    self._iprot.readMessageEnd()
130 ashish 1295 
    if result.success != None:
1296 
      return result.success
559 chandransh 1297 
    if result.scx != None:
1298 
      raise result.scx
1299 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "commitCart failed: unknown result");
130 ashish 1300 
 
559 chandransh 1301 
  def validateCart(self, cartId):
130 ashish 1302 
    """
1303 
    Parameters:
559 chandransh 1304 
     - cartId
130 ashish 1305 
    """
559 chandransh 1306 
    self.send_validateCart(cartId)
1307 
    return self.recv_validateCart()
130 ashish 1308 
 
559 chandransh 1309 
  def send_validateCart(self, cartId):
1310 
    self._oprot.writeMessageBegin('validateCart', TMessageType.CALL, self._seqid)
1311 
    args = validateCart_args()
1312 
    args.cartId = cartId
130 ashish 1313 
    args.write(self._oprot)
1314 
    self._oprot.writeMessageEnd()
1315 
    self._oprot.trans.flush()
1316 
 
559 chandransh 1317 
  def recv_validateCart(self, ):
130 ashish 1318 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1319 
    if mtype == TMessageType.EXCEPTION:
1320 
      x = TApplicationException()
1321 
      x.read(self._iprot)
1322 
      self._iprot.readMessageEnd()
1323 
      raise x
559 chandransh 1324 
    result = validateCart_result()
130 ashish 1325 
    result.read(self._iprot)
1326 
    self._iprot.readMessageEnd()
1327 
    if result.success != None:
1328 
      return result.success
575 chandransh 1329 
    if result.scex != None:
1330 
      raise result.scex
559 chandransh 1331 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateCart failed: unknown result");
130 ashish 1332 
 
575 chandransh 1333 
  def refreshCart(self, cartId):
1334 
    """
1335 
    Parameters:
1336 
     - cartId
1337 
    """
1338 
    self.send_refreshCart(cartId)
1339 
    return self.recv_refreshCart()
1340 
 
1341 
  def send_refreshCart(self, cartId):
1342 
    self._oprot.writeMessageBegin('refreshCart', TMessageType.CALL, self._seqid)
1343 
    args = refreshCart_args()
1344 
    args.cartId = cartId
1345 
    args.write(self._oprot)
1346 
    self._oprot.writeMessageEnd()
1347 
    self._oprot.trans.flush()
1348 
 
1349 
  def recv_refreshCart(self, ):
1350 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1351 
    if mtype == TMessageType.EXCEPTION:
1352 
      x = TApplicationException()
1353 
      x.read(self._iprot)
1354 
      self._iprot.readMessageEnd()
1355 
      raise x
1356 
    result = refreshCart_result()
1357 
    result.read(self._iprot)
1358 
    self._iprot.readMessageEnd()
1359 
    if result.success != None:
1360 
      return result.success
1361 
    if result.scex != None:
1362 
      raise result.scex
1363 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "refreshCart failed: unknown result");
1364 
 
559 chandransh 1365 
  def mergeCart(self, fromCartId, toCartId):
1366 
    """
1367 
    Parameters:
1368 
     - fromCartId
1369 
     - toCartId
1370 
    """
1371 
    self.send_mergeCart(fromCartId, toCartId)
1372 
    self.recv_mergeCart()
130 ashish 1373 
 
559 chandransh 1374 
  def send_mergeCart(self, fromCartId, toCartId):
1375 
    self._oprot.writeMessageBegin('mergeCart', TMessageType.CALL, self._seqid)
1376 
    args = mergeCart_args()
1377 
    args.fromCartId = fromCartId
1378 
    args.toCartId = toCartId
1379 
    args.write(self._oprot)
1380 
    self._oprot.writeMessageEnd()
1381 
    self._oprot.trans.flush()
1382 
 
1383 
  def recv_mergeCart(self, ):
1384 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1385 
    if mtype == TMessageType.EXCEPTION:
1386 
      x = TApplicationException()
1387 
      x.read(self._iprot)
1388 
      self._iprot.readMessageEnd()
1389 
      raise x
1390 
    result = mergeCart_result()
1391 
    result.read(self._iprot)
1392 
    self._iprot.readMessageEnd()
1393 
    return
1394 
 
1395 
  def addWidget(self, widget):
1396 
    """
1397 
    Parameters:
1398 
     - widget
1399 
    """
1400 
    self.send_addWidget(widget)
1401 
    self.recv_addWidget()
1402 
 
1403 
  def send_addWidget(self, widget):
1404 
    self._oprot.writeMessageBegin('addWidget', TMessageType.CALL, self._seqid)
1405 
    args = addWidget_args()
1406 
    args.widget = widget
1407 
    args.write(self._oprot)
1408 
    self._oprot.writeMessageEnd()
1409 
    self._oprot.trans.flush()
1410 
 
1411 
  def recv_addWidget(self, ):
1412 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1413 
    if mtype == TMessageType.EXCEPTION:
1414 
      x = TApplicationException()
1415 
      x.read(self._iprot)
1416 
      self._iprot.readMessageEnd()
1417 
      raise x
1418 
    result = addWidget_result()
1419 
    result.read(self._iprot)
1420 
    self._iprot.readMessageEnd()
1421 
    if result.scx != None:
1422 
      raise result.scx
1423 
    return
1424 
 
1425 
  def addItemToWidget(self, widget_id, items):
1426 
    """
1427 
    Parameters:
1428 
     - widget_id
1429 
     - items
1430 
    """
1431 
    self.send_addItemToWidget(widget_id, items)
1432 
    self.recv_addItemToWidget()
1433 
 
1434 
  def send_addItemToWidget(self, widget_id, items):
1435 
    self._oprot.writeMessageBegin('addItemToWidget', TMessageType.CALL, self._seqid)
1436 
    args = addItemToWidget_args()
1437 
    args.widget_id = widget_id
1438 
    args.items = items
1439 
    args.write(self._oprot)
1440 
    self._oprot.writeMessageEnd()
1441 
    self._oprot.trans.flush()
1442 
 
1443 
  def recv_addItemToWidget(self, ):
1444 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1445 
    if mtype == TMessageType.EXCEPTION:
1446 
      x = TApplicationException()
1447 
      x.read(self._iprot)
1448 
      self._iprot.readMessageEnd()
1449 
      raise x
1450 
    result = addItemToWidget_result()
1451 
    result.read(self._iprot)
1452 
    self._iprot.readMessageEnd()
1453 
    if result.scx != None:
1454 
      raise result.scx
1455 
    return
1456 
 
1457 
  def deleteItemFromWidget(self, widget_id, item_id):
1458 
    """
1459 
    Parameters:
1460 
     - widget_id
1461 
     - item_id
1462 
    """
1463 
    self.send_deleteItemFromWidget(widget_id, item_id)
1464 
    self.recv_deleteItemFromWidget()
1465 
 
1466 
  def send_deleteItemFromWidget(self, widget_id, item_id):
1467 
    self._oprot.writeMessageBegin('deleteItemFromWidget', TMessageType.CALL, self._seqid)
1468 
    args = deleteItemFromWidget_args()
1469 
    args.widget_id = widget_id
1470 
    args.item_id = item_id
1471 
    args.write(self._oprot)
1472 
    self._oprot.writeMessageEnd()
1473 
    self._oprot.trans.flush()
1474 
 
1475 
  def recv_deleteItemFromWidget(self, ):
1476 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1477 
    if mtype == TMessageType.EXCEPTION:
1478 
      x = TApplicationException()
1479 
      x.read(self._iprot)
1480 
      self._iprot.readMessageEnd()
1481 
      raise x
1482 
    result = deleteItemFromWidget_result()
1483 
    result.read(self._iprot)
1484 
    self._iprot.readMessageEnd()
1485 
    if result.scx != None:
1486 
      raise result.scx
1487 
    return
1488 
 
1489 
  def updateWidget(self, widgetId, enable):
1490 
    """
1491 
    Parameters:
1492 
     - widgetId
1493 
     - enable
1494 
    """
1495 
    self.send_updateWidget(widgetId, enable)
1496 
    self.recv_updateWidget()
1497 
 
1498 
  def send_updateWidget(self, widgetId, enable):
1499 
    self._oprot.writeMessageBegin('updateWidget', TMessageType.CALL, self._seqid)
1500 
    args = updateWidget_args()
1501 
    args.widgetId = widgetId
1502 
    args.enable = enable
1503 
    args.write(self._oprot)
1504 
    self._oprot.writeMessageEnd()
1505 
    self._oprot.trans.flush()
1506 
 
1507 
  def recv_updateWidget(self, ):
1508 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1509 
    if mtype == TMessageType.EXCEPTION:
1510 
      x = TApplicationException()
1511 
      x.read(self._iprot)
1512 
      self._iprot.readMessageEnd()
1513 
      raise x
1514 
    result = updateWidget_result()
1515 
    result.read(self._iprot)
1516 
    self._iprot.readMessageEnd()
1517 
    if result.scx != None:
1518 
      raise result.scx
1519 
    return
1520 
 
1521 
  def updateWidgetItem(self, widgetId, enable):
1522 
    """
1523 
    Parameters:
1524 
     - widgetId
1525 
     - enable
1526 
    """
1527 
    self.send_updateWidgetItem(widgetId, enable)
1528 
    self.recv_updateWidgetItem()
1529 
 
1530 
  def send_updateWidgetItem(self, widgetId, enable):
1531 
    self._oprot.writeMessageBegin('updateWidgetItem', TMessageType.CALL, self._seqid)
1532 
    args = updateWidgetItem_args()
1533 
    args.widgetId = widgetId
1534 
    args.enable = enable
1535 
    args.write(self._oprot)
1536 
    self._oprot.writeMessageEnd()
1537 
    self._oprot.trans.flush()
1538 
 
1539 
  def recv_updateWidgetItem(self, ):
1540 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1541 
    if mtype == TMessageType.EXCEPTION:
1542 
      x = TApplicationException()
1543 
      x.read(self._iprot)
1544 
      self._iprot.readMessageEnd()
1545 
      raise x
1546 
    result = updateWidgetItem_result()
1547 
    result.read(self._iprot)
1548 
    self._iprot.readMessageEnd()
1549 
    if result.scx != None:
1550 
      raise result.scx
1551 
    return
1552 
 
1553 
  def getWidget(self, type, userId, onlyEnabled):
1554 
    """
1555 
    Parameters:
1556 
     - type
1557 
     - userId
1558 
     - onlyEnabled
1559 
    """
1560 
    self.send_getWidget(type, userId, onlyEnabled)
1561 
    return self.recv_getWidget()
1562 
 
1563 
  def send_getWidget(self, type, userId, onlyEnabled):
1564 
    self._oprot.writeMessageBegin('getWidget', TMessageType.CALL, self._seqid)
1565 
    args = getWidget_args()
1566 
    args.type = type
1567 
    args.userId = userId
1568 
    args.onlyEnabled = onlyEnabled
1569 
    args.write(self._oprot)
1570 
    self._oprot.writeMessageEnd()
1571 
    self._oprot.trans.flush()
1572 
 
1573 
  def recv_getWidget(self, ):
1574 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1575 
    if mtype == TMessageType.EXCEPTION:
1576 
      x = TApplicationException()
1577 
      x.read(self._iprot)
1578 
      self._iprot.readMessageEnd()
1579 
      raise x
1580 
    result = getWidget_result()
1581 
    result.read(self._iprot)
1582 
    self._iprot.readMessageEnd()
1583 
    if result.success != None:
1584 
      return result.success
1585 
    if result.scx != None:
1586 
      raise result.scx
1587 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getWidget failed: unknown result");
1588 
 
1589 
  def getMyResearch(self, user_id):
1590 
    """
1591 
    Parameters:
1592 
     - user_id
1593 
    """
1594 
    self.send_getMyResearch(user_id)
1595 
    return self.recv_getMyResearch()
1596 
 
1597 
  def send_getMyResearch(self, user_id):
1598 
    self._oprot.writeMessageBegin('getMyResearch', TMessageType.CALL, self._seqid)
1599 
    args = getMyResearch_args()
1600 
    args.user_id = user_id
1601 
    args.write(self._oprot)
1602 
    self._oprot.writeMessageEnd()
1603 
    self._oprot.trans.flush()
1604 
 
1605 
  def recv_getMyResearch(self, ):
1606 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1607 
    if mtype == TMessageType.EXCEPTION:
1608 
      x = TApplicationException()
1609 
      x.read(self._iprot)
1610 
      self._iprot.readMessageEnd()
1611 
      raise x
1612 
    result = getMyResearch_result()
1613 
    result.read(self._iprot)
1614 
    self._iprot.readMessageEnd()
1615 
    if result.success != None:
1616 
      return result.success
1617 
    if result.scx != None:
1618 
      raise result.scx
1619 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMyResearch failed: unknown result");
1620 
 
1621 
  def updateMyResearch(self, user_id, item_id):
1622 
    """
1623 
    Parameters:
1624 
     - user_id
1625 
     - item_id
1626 
    """
1627 
    self.send_updateMyResearch(user_id, item_id)
1628 
    return self.recv_updateMyResearch()
1629 
 
1630 
  def send_updateMyResearch(self, user_id, item_id):
1631 
    self._oprot.writeMessageBegin('updateMyResearch', TMessageType.CALL, self._seqid)
1632 
    args = updateMyResearch_args()
1633 
    args.user_id = user_id
1634 
    args.item_id = item_id
1635 
    args.write(self._oprot)
1636 
    self._oprot.writeMessageEnd()
1637 
    self._oprot.trans.flush()
1638 
 
1639 
  def recv_updateMyResearch(self, ):
1640 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1641 
    if mtype == TMessageType.EXCEPTION:
1642 
      x = TApplicationException()
1643 
      x.read(self._iprot)
1644 
      self._iprot.readMessageEnd()
1645 
      raise x
1646 
    result = updateMyResearch_result()
1647 
    result.read(self._iprot)
1648 
    self._iprot.readMessageEnd()
1649 
    if result.success != None:
1650 
      return result.success
1651 
    if result.scx != None:
1652 
      raise result.scx
1653 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateMyResearch failed: unknown result");
1654 
 
1655 
  def deleteItemFromMyResearch(self, user_id, item_id):
1656 
    """
1657 
    Parameters:
1658 
     - user_id
1659 
     - item_id
1660 
    """
1661 
    self.send_deleteItemFromMyResearch(user_id, item_id)
1662 
    self.recv_deleteItemFromMyResearch()
1663 
 
1664 
  def send_deleteItemFromMyResearch(self, user_id, item_id):
1665 
    self._oprot.writeMessageBegin('deleteItemFromMyResearch', TMessageType.CALL, self._seqid)
1666 
    args = deleteItemFromMyResearch_args()
1667 
    args.user_id = user_id
1668 
    args.item_id = item_id
1669 
    args.write(self._oprot)
1670 
    self._oprot.writeMessageEnd()
1671 
    self._oprot.trans.flush()
1672 
 
1673 
  def recv_deleteItemFromMyResearch(self, ):
1674 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1675 
    if mtype == TMessageType.EXCEPTION:
1676 
      x = TApplicationException()
1677 
      x.read(self._iprot)
1678 
      self._iprot.readMessageEnd()
1679 
      raise x
1680 
    result = deleteItemFromMyResearch_result()
1681 
    result.read(self._iprot)
1682 
    self._iprot.readMessageEnd()
1683 
    if result.scx != None:
1684 
      raise result.scx
1685 
    return
1686 
 
1687 
  def updateRatings(self, item_id, type, rating, user_id):
1688 
    """
1689 
    Parameters:
1690 
     - item_id
1691 
     - type
1692 
     - rating
1693 
     - user_id
1694 
    """
1695 
    self.send_updateRatings(item_id, type, rating, user_id)
1696 
    self.recv_updateRatings()
1697 
 
1698 
  def send_updateRatings(self, item_id, type, rating, user_id):
1699 
    self._oprot.writeMessageBegin('updateRatings', TMessageType.CALL, self._seqid)
1700 
    args = updateRatings_args()
1701 
    args.item_id = item_id
1702 
    args.type = type
1703 
    args.rating = rating
1704 
    args.user_id = user_id
1705 
    args.write(self._oprot)
1706 
    self._oprot.writeMessageEnd()
1707 
    self._oprot.trans.flush()
1708 
 
1709 
  def recv_updateRatings(self, ):
1710 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1711 
    if mtype == TMessageType.EXCEPTION:
1712 
      x = TApplicationException()
1713 
      x.read(self._iprot)
1714 
      self._iprot.readMessageEnd()
1715 
      raise x
1716 
    result = updateRatings_result()
1717 
    result.read(self._iprot)
1718 
    self._iprot.readMessageEnd()
1719 
    return
1720 
 
1721 
  def getRatings(self, item_id, user_id):
1722 
    """
1723 
    Parameters:
1724 
     - item_id
1725 
     - user_id
1726 
    """
1727 
    self.send_getRatings(item_id, user_id)
1728 
    return self.recv_getRatings()
1729 
 
1730 
  def send_getRatings(self, item_id, user_id):
1731 
    self._oprot.writeMessageBegin('getRatings', TMessageType.CALL, self._seqid)
1732 
    args = getRatings_args()
1733 
    args.item_id = item_id
1734 
    args.user_id = user_id
1735 
    args.write(self._oprot)
1736 
    self._oprot.writeMessageEnd()
1737 
    self._oprot.trans.flush()
1738 
 
1739 
  def recv_getRatings(self, ):
1740 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1741 
    if mtype == TMessageType.EXCEPTION:
1742 
      x = TApplicationException()
1743 
      x.read(self._iprot)
1744 
      self._iprot.readMessageEnd()
1745 
      raise x
1746 
    result = getRatings_result()
1747 
    result.read(self._iprot)
1748 
    self._iprot.readMessageEnd()
1749 
    if result.success != None:
1750 
      return result.success
1751 
    if result.scx != None:
1752 
      raise result.scx
1753 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRatings failed: unknown result");
1754 
 
1755 
  def updateBrowseHistory(self, user_id, item_id, isSessionId):
1756 
    """
1757 
    Parameters:
1758 
     - user_id
1759 
     - item_id
1760 
     - isSessionId
1761 
    """
1762 
    self.send_updateBrowseHistory(user_id, item_id, isSessionId)
1763 
    self.recv_updateBrowseHistory()
1764 
 
1765 
  def send_updateBrowseHistory(self, user_id, item_id, isSessionId):
1766 
    self._oprot.writeMessageBegin('updateBrowseHistory', TMessageType.CALL, self._seqid)
1767 
    args = updateBrowseHistory_args()
1768 
    args.user_id = user_id
1769 
    args.item_id = item_id
1770 
    args.isSessionId = isSessionId
1771 
    args.write(self._oprot)
1772 
    self._oprot.writeMessageEnd()
1773 
    self._oprot.trans.flush()
1774 
 
1775 
  def recv_updateBrowseHistory(self, ):
1776 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1777 
    if mtype == TMessageType.EXCEPTION:
1778 
      x = TApplicationException()
1779 
      x.read(self._iprot)
1780 
      self._iprot.readMessageEnd()
1781 
      raise x
1782 
    result = updateBrowseHistory_result()
1783 
    result.read(self._iprot)
1784 
    self._iprot.readMessageEnd()
1785 
    return
1786 
 
1787 
  def getBrowseHistory(self, userId, isSessionId):
1788 
    """
1789 
    Parameters:
1790 
     - userId
1791 
     - isSessionId
1792 
    """
1793 
    self.send_getBrowseHistory(userId, isSessionId)
1794 
    return self.recv_getBrowseHistory()
1795 
 
1796 
  def send_getBrowseHistory(self, userId, isSessionId):
1797 
    self._oprot.writeMessageBegin('getBrowseHistory', TMessageType.CALL, self._seqid)
1798 
    args = getBrowseHistory_args()
1799 
    args.userId = userId
1800 
    args.isSessionId = isSessionId
1801 
    args.write(self._oprot)
1802 
    self._oprot.writeMessageEnd()
1803 
    self._oprot.trans.flush()
1804 
 
1805 
  def recv_getBrowseHistory(self, ):
1806 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1807 
    if mtype == TMessageType.EXCEPTION:
1808 
      x = TApplicationException()
1809 
      x.read(self._iprot)
1810 
      self._iprot.readMessageEnd()
1811 
      raise x
1812 
    result = getBrowseHistory_result()
1813 
    result.read(self._iprot)
1814 
    self._iprot.readMessageEnd()
1815 
    if result.success != None:
1816 
      return result.success
1817 
    if result.scx != None:
1818 
      raise result.scx
1819 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBrowseHistory failed: unknown result");
1820 
 
1821 
 
94 ashish 1822 
class Processor(Iface, TProcessor):
1823 
  def __init__(self, handler):
1824 
    self._handler = handler
1825 
    self._processMap = {}
559 chandransh 1826 
    self._processMap["createAnonymousUser"] = Processor.process_createAnonymousUser
1827 
    self._processMap["getUserById"] = Processor.process_getUserById
1828 
    self._processMap["createUser"] = Processor.process_createUser
1829 
    self._processMap["updateUser"] = Processor.process_updateUser
1830 
    self._processMap["deleteUser"] = Processor.process_deleteUser
1831 
    self._processMap["getUserState"] = Processor.process_getUserState
122 ashish 1832 
    self._processMap["authenticateUser"] = Processor.process_authenticateUser
94 ashish 1833 
    self._processMap["userExists"] = Processor.process_userExists
1834 
    self._processMap["addAddressForUser"] = Processor.process_addAddressForUser
1835 
    self._processMap["removeAddressForUser"] = Processor.process_removeAddressForUser
1836 
    self._processMap["setUserAsLoggedIn"] = Processor.process_setUserAsLoggedIn
1837 
    self._processMap["setUserAsLoggedOut"] = Processor.process_setUserAsLoggedOut
504 rajveer 1838 
    self._processMap["setDefaultAddress"] = Processor.process_setDefaultAddress
94 ashish 1839 
    self._processMap["updatePassword"] = Processor.process_updatePassword
581 rajveer 1840 
    self._processMap["forgotPassword"] = Processor.process_forgotPassword
559 chandransh 1841 
    self._processMap["createCart"] = Processor.process_createCart
1842 
    self._processMap["getCurrentCart"] = Processor.process_getCurrentCart
1843 
    self._processMap["getCart"] = Processor.process_getCart
1844 
    self._processMap["getCartsForUser"] = Processor.process_getCartsForUser
1845 
    self._processMap["getCartsByStatus"] = Processor.process_getCartsByStatus
1846 
    self._processMap["getCartsByTime"] = Processor.process_getCartsByTime
1847 
    self._processMap["changeCartStatus"] = Processor.process_changeCartStatus
1848 
    self._processMap["addItemToCart"] = Processor.process_addItemToCart
1849 
    self._processMap["deleteItemFromCart"] = Processor.process_deleteItemFromCart
1850 
    self._processMap["changeQuantity"] = Processor.process_changeQuantity
1851 
    self._processMap["changeItemStatus"] = Processor.process_changeItemStatus
1852 
    self._processMap["addAddressToCart"] = Processor.process_addAddressToCart
1853 
    self._processMap["commitCart"] = Processor.process_commitCart
1854 
    self._processMap["validateCart"] = Processor.process_validateCart
575 chandransh 1855 
    self._processMap["refreshCart"] = Processor.process_refreshCart
559 chandransh 1856 
    self._processMap["mergeCart"] = Processor.process_mergeCart
1857 
    self._processMap["addWidget"] = Processor.process_addWidget
1858 
    self._processMap["addItemToWidget"] = Processor.process_addItemToWidget
1859 
    self._processMap["deleteItemFromWidget"] = Processor.process_deleteItemFromWidget
1860 
    self._processMap["updateWidget"] = Processor.process_updateWidget
1861 
    self._processMap["updateWidgetItem"] = Processor.process_updateWidgetItem
1862 
    self._processMap["getWidget"] = Processor.process_getWidget
1863 
    self._processMap["getMyResearch"] = Processor.process_getMyResearch
1864 
    self._processMap["updateMyResearch"] = Processor.process_updateMyResearch
1865 
    self._processMap["deleteItemFromMyResearch"] = Processor.process_deleteItemFromMyResearch
1866 
    self._processMap["updateRatings"] = Processor.process_updateRatings
1867 
    self._processMap["getRatings"] = Processor.process_getRatings
1868 
    self._processMap["updateBrowseHistory"] = Processor.process_updateBrowseHistory
1869 
    self._processMap["getBrowseHistory"] = Processor.process_getBrowseHistory
94 ashish 1870 
 
1871 
  def process(self, iprot, oprot):
1872 
    (name, type, seqid) = iprot.readMessageBegin()
1873 
    if name not in self._processMap:
1874 
      iprot.skip(TType.STRUCT)
1875 
      iprot.readMessageEnd()
1876 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
1877 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
1878 
      x.write(oprot)
1879 
      oprot.writeMessageEnd()
1880 
      oprot.trans.flush()
1881 
      return
1882 
    else:
1883 
      self._processMap[name](self, seqid, iprot, oprot)
1884 
    return True
1885 
 
559 chandransh 1886 
  def process_createAnonymousUser(self, seqid, iprot, oprot):
1887 
    args = createAnonymousUser_args()
94 ashish 1888 
    args.read(iprot)
1889 
    iprot.readMessageEnd()
559 chandransh 1890 
    result = createAnonymousUser_result()
94 ashish 1891 
    try:
559 chandransh 1892 
      result.success = self._handler.createAnonymousUser(args.jsessionId)
1893 
    except UserContextException, ucex:
1894 
      result.ucex = ucex
1895 
    oprot.writeMessageBegin("createAnonymousUser", TMessageType.REPLY, seqid)
94 ashish 1896 
    result.write(oprot)
1897 
    oprot.writeMessageEnd()
1898 
    oprot.trans.flush()
1899 
 
559 chandransh 1900 
  def process_getUserById(self, seqid, iprot, oprot):
1901 
    args = getUserById_args()
94 ashish 1902 
    args.read(iprot)
1903 
    iprot.readMessageEnd()
559 chandransh 1904 
    result = getUserById_result()
94 ashish 1905 
    try:
559 chandransh 1906 
      result.success = self._handler.getUserById(args.userId)
1907 
    except UserContextException, ucex:
1908 
      result.ucex = ucex
1909 
    oprot.writeMessageBegin("getUserById", TMessageType.REPLY, seqid)
94 ashish 1910 
    result.write(oprot)
1911 
    oprot.writeMessageEnd()
1912 
    oprot.trans.flush()
1913 
 
559 chandransh 1914 
  def process_createUser(self, seqid, iprot, oprot):
1915 
    args = createUser_args()
94 ashish 1916 
    args.read(iprot)
1917 
    iprot.readMessageEnd()
559 chandransh 1918 
    result = createUser_result()
94 ashish 1919 
    try:
559 chandransh 1920 
      result.success = self._handler.createUser(args.user)
1921 
    except UserContextException, ucex:
1922 
      result.ucex = ucex
1923 
    oprot.writeMessageBegin("createUser", TMessageType.REPLY, seqid)
94 ashish 1924 
    result.write(oprot)
1925 
    oprot.writeMessageEnd()
1926 
    oprot.trans.flush()
1927 
 
559 chandransh 1928 
  def process_updateUser(self, seqid, iprot, oprot):
1929 
    args = updateUser_args()
94 ashish 1930 
    args.read(iprot)
1931 
    iprot.readMessageEnd()
559 chandransh 1932 
    result = updateUser_result()
94 ashish 1933 
    try:
559 chandransh 1934 
      result.success = self._handler.updateUser(args.user)
1935 
    except UserContextException, ucex:
1936 
      result.ucex = ucex
1937 
    oprot.writeMessageBegin("updateUser", TMessageType.REPLY, seqid)
94 ashish 1938 
    result.write(oprot)
1939 
    oprot.writeMessageEnd()
1940 
    oprot.trans.flush()
1941 
 
559 chandransh 1942 
  def process_deleteUser(self, seqid, iprot, oprot):
1943 
    args = deleteUser_args()
94 ashish 1944 
    args.read(iprot)
1945 
    iprot.readMessageEnd()
559 chandransh 1946 
    result = deleteUser_result()
94 ashish 1947 
    try:
559 chandransh 1948 
      result.success = self._handler.deleteUser(args.userId)
1949 
    except UserContextException, ucex:
1950 
      result.ucex = ucex
1951 
    oprot.writeMessageBegin("deleteUser", TMessageType.REPLY, seqid)
94 ashish 1952 
    result.write(oprot)
1953 
    oprot.writeMessageEnd()
1954 
    oprot.trans.flush()
1955 
 
559 chandransh 1956 
  def process_getUserState(self, seqid, iprot, oprot):
1957 
    args = getUserState_args()
94 ashish 1958 
    args.read(iprot)
1959 
    iprot.readMessageEnd()
559 chandransh 1960 
    result = getUserState_result()
94 ashish 1961 
    try:
559 chandransh 1962 
      result.success = self._handler.getUserState(args.userId)
1963 
    except UserContextException, ucex:
1964 
      result.ucex = ucex
1965 
    oprot.writeMessageBegin("getUserState", TMessageType.REPLY, seqid)
94 ashish 1966 
    result.write(oprot)
1967 
    oprot.writeMessageEnd()
1968 
    oprot.trans.flush()
1969 
 
122 ashish 1970 
  def process_authenticateUser(self, seqid, iprot, oprot):
1971 
    args = authenticateUser_args()
1972 
    args.read(iprot)
1973 
    iprot.readMessageEnd()
1974 
    result = authenticateUser_result()
1975 
    try:
559 chandransh 1976 
      result.success = self._handler.authenticateUser(args.email, args.password)
1977 
    except AuthenticationException, auex:
1978 
      result.auex = auex
122 ashish 1979 
    oprot.writeMessageBegin("authenticateUser", TMessageType.REPLY, seqid)
1980 
    result.write(oprot)
1981 
    oprot.writeMessageEnd()
1982 
    oprot.trans.flush()
1983 
 
94 ashish 1984 
  def process_userExists(self, seqid, iprot, oprot):
1985 
    args = userExists_args()
1986 
    args.read(iprot)
1987 
    iprot.readMessageEnd()
1988 
    result = userExists_result()
1989 
    try:
1990 
      result.success = self._handler.userExists(args.email)
1991 
    except UserContextException, ucx:
1992 
      result.ucx = ucx
1993 
    oprot.writeMessageBegin("userExists", TMessageType.REPLY, seqid)
1994 
    result.write(oprot)
1995 
    oprot.writeMessageEnd()
1996 
    oprot.trans.flush()
1997 
 
1998 
  def process_addAddressForUser(self, seqid, iprot, oprot):
1999 
    args = addAddressForUser_args()
2000 
    args.read(iprot)
2001 
    iprot.readMessageEnd()
2002 
    result = addAddressForUser_result()
2003 
    try:
567 rajveer 2004 
      result.success = self._handler.addAddressForUser(args.userId, args.address, args.setDefault)
94 ashish 2005 
    except UserContextException, ucx:
2006 
      result.ucx = ucx
2007 
    oprot.writeMessageBegin("addAddressForUser", TMessageType.REPLY, seqid)
2008 
    result.write(oprot)
2009 
    oprot.writeMessageEnd()
2010 
    oprot.trans.flush()
2011 
 
2012 
  def process_removeAddressForUser(self, seqid, iprot, oprot):
2013 
    args = removeAddressForUser_args()
2014 
    args.read(iprot)
2015 
    iprot.readMessageEnd()
2016 
    result = removeAddressForUser_result()
2017 
    try:
2018 
      result.success = self._handler.removeAddressForUser(args.userid, args.addressId)
2019 
    except UserContextException, ucx:
2020 
      result.ucx = ucx
2021 
    oprot.writeMessageBegin("removeAddressForUser", TMessageType.REPLY, seqid)
2022 
    result.write(oprot)
2023 
    oprot.writeMessageEnd()
2024 
    oprot.trans.flush()
2025 
 
2026 
  def process_setUserAsLoggedIn(self, seqid, iprot, oprot):
2027 
    args = setUserAsLoggedIn_args()
2028 
    args.read(iprot)
2029 
    iprot.readMessageEnd()
2030 
    result = setUserAsLoggedIn_result()
2031 
    try:
2032 
      result.success = self._handler.setUserAsLoggedIn(args.userId, args.timestamp)
2033 
    except UserContextException, ucx:
2034 
      result.ucx = ucx
2035 
    oprot.writeMessageBegin("setUserAsLoggedIn", TMessageType.REPLY, seqid)
2036 
    result.write(oprot)
2037 
    oprot.writeMessageEnd()
2038 
    oprot.trans.flush()
2039 
 
2040 
  def process_setUserAsLoggedOut(self, seqid, iprot, oprot):
2041 
    args = setUserAsLoggedOut_args()
2042 
    args.read(iprot)
2043 
    iprot.readMessageEnd()
2044 
    result = setUserAsLoggedOut_result()
2045 
    try:
2046 
      result.success = self._handler.setUserAsLoggedOut(args.userid, args.timestamp)
2047 
    except UserContextException, ucx:
2048 
      result.ucx = ucx
2049 
    oprot.writeMessageBegin("setUserAsLoggedOut", TMessageType.REPLY, seqid)
2050 
    result.write(oprot)
2051 
    oprot.writeMessageEnd()
2052 
    oprot.trans.flush()
2053 
 
504 rajveer 2054 
  def process_setDefaultAddress(self, seqid, iprot, oprot):
2055 
    args = setDefaultAddress_args()
2056 
    args.read(iprot)
2057 
    iprot.readMessageEnd()
2058 
    result = setDefaultAddress_result()
2059 
    try:
2060 
      result.success = self._handler.setDefaultAddress(args.userid, args.addressId)
2061 
    except UserContextException, ucx:
2062 
      result.ucx = ucx
2063 
    oprot.writeMessageBegin("setDefaultAddress", TMessageType.REPLY, seqid)
2064 
    result.write(oprot)
2065 
    oprot.writeMessageEnd()
2066 
    oprot.trans.flush()
2067 
 
94 ashish 2068 
  def process_updatePassword(self, seqid, iprot, oprot):
2069 
    args = updatePassword_args()
2070 
    args.read(iprot)
2071 
    iprot.readMessageEnd()
2072 
    result = updatePassword_result()
2073 
    try:
2074 
      result.success = self._handler.updatePassword(args.userid, args.password)
2075 
    except UserContextException, ucx:
2076 
      result.ucx = ucx
2077 
    oprot.writeMessageBegin("updatePassword", TMessageType.REPLY, seqid)
2078 
    result.write(oprot)
2079 
    oprot.writeMessageEnd()
2080 
    oprot.trans.flush()
2081 
 
581 rajveer 2082 
  def process_forgotPassword(self, seqid, iprot, oprot):
2083 
    args = forgotPassword_args()
2084 
    args.read(iprot)
2085 
    iprot.readMessageEnd()
2086 
    result = forgotPassword_result()
2087 
    try:
2088 
      result.success = self._handler.forgotPassword(args.email)
2089 
    except UserContextException, ucx:
2090 
      result.ucx = ucx
2091 
    oprot.writeMessageBegin("forgotPassword", TMessageType.REPLY, seqid)
2092 
    result.write(oprot)
2093 
    oprot.writeMessageEnd()
2094 
    oprot.trans.flush()
2095 
 
559 chandransh 2096 
  def process_createCart(self, seqid, iprot, oprot):
2097 
    args = createCart_args()
94 ashish 2098 
    args.read(iprot)
2099 
    iprot.readMessageEnd()
559 chandransh 2100 
    result = createCart_result()
94 ashish 2101 
    try:
559 chandransh 2102 
      result.success = self._handler.createCart(args.userId)
2103 
    except ShoppingCartException, scx:
2104 
      result.scx = scx
2105 
    oprot.writeMessageBegin("createCart", TMessageType.REPLY, seqid)
94 ashish 2106 
    result.write(oprot)
2107 
    oprot.writeMessageEnd()
2108 
    oprot.trans.flush()
2109 
 
559 chandransh 2110 
  def process_getCurrentCart(self, seqid, iprot, oprot):
2111 
    args = getCurrentCart_args()
94 ashish 2112 
    args.read(iprot)
2113 
    iprot.readMessageEnd()
559 chandransh 2114 
    result = getCurrentCart_result()
94 ashish 2115 
    try:
559 chandransh 2116 
      result.success = self._handler.getCurrentCart(args.userId)
2117 
    except ShoppingCartException, scx:
2118 
      result.scx = scx
2119 
    oprot.writeMessageBegin("getCurrentCart", TMessageType.REPLY, seqid)
94 ashish 2120 
    result.write(oprot)
2121 
    oprot.writeMessageEnd()
2122 
    oprot.trans.flush()
2123 
 
559 chandransh 2124 
  def process_getCart(self, seqid, iprot, oprot):
2125 
    args = getCart_args()
94 ashish 2126 
    args.read(iprot)
2127 
    iprot.readMessageEnd()
559 chandransh 2128 
    result = getCart_result()
94 ashish 2129 
    try:
559 chandransh 2130 
      result.success = self._handler.getCart(args.cartId)
2131 
    except ShoppingCartException, scx:
2132 
      result.scx = scx
2133 
    oprot.writeMessageBegin("getCart", TMessageType.REPLY, seqid)
94 ashish 2134 
    result.write(oprot)
2135 
    oprot.writeMessageEnd()
2136 
    oprot.trans.flush()
2137 
 
559 chandransh 2138 
  def process_getCartsForUser(self, seqid, iprot, oprot):
2139 
    args = getCartsForUser_args()
94 ashish 2140 
    args.read(iprot)
2141 
    iprot.readMessageEnd()
559 chandransh 2142 
    result = getCartsForUser_result()
94 ashish 2143 
    try:
559 chandransh 2144 
      result.success = self._handler.getCartsForUser(args.userId, args.status)
2145 
    except ShoppingCartException, scx:
2146 
      result.scx = scx
2147 
    oprot.writeMessageBegin("getCartsForUser", TMessageType.REPLY, seqid)
94 ashish 2148 
    result.write(oprot)
2149 
    oprot.writeMessageEnd()
2150 
    oprot.trans.flush()
2151 
 
559 chandransh 2152 
  def process_getCartsByStatus(self, seqid, iprot, oprot):
2153 
    args = getCartsByStatus_args()
94 ashish 2154 
    args.read(iprot)
2155 
    iprot.readMessageEnd()
559 chandransh 2156 
    result = getCartsByStatus_result()
94 ashish 2157 
    try:
559 chandransh 2158 
      result.success = self._handler.getCartsByStatus(args.status)
2159 
    except ShoppingCartException, scx:
2160 
      result.scx = scx
2161 
    oprot.writeMessageBegin("getCartsByStatus", TMessageType.REPLY, seqid)
94 ashish 2162 
    result.write(oprot)
2163 
    oprot.writeMessageEnd()
2164 
    oprot.trans.flush()
2165 
 
559 chandransh 2166 
  def process_getCartsByTime(self, seqid, iprot, oprot):
2167 
    args = getCartsByTime_args()
94 ashish 2168 
    args.read(iprot)
2169 
    iprot.readMessageEnd()
559 chandransh 2170 
    result = getCartsByTime_result()
94 ashish 2171 
    try:
559 chandransh 2172 
      result.success = self._handler.getCartsByTime(args.from_time, args.to_time, args.status)
2173 
    except ShoppingCartException, scx:
2174 
      result.scx = scx
2175 
    oprot.writeMessageBegin("getCartsByTime", TMessageType.REPLY, seqid)
94 ashish 2176 
    result.write(oprot)
2177 
    oprot.writeMessageEnd()
2178 
    oprot.trans.flush()
2179 
 
559 chandransh 2180 
  def process_changeCartStatus(self, seqid, iprot, oprot):
2181 
    args = changeCartStatus_args()
130 ashish 2182 
    args.read(iprot)
2183 
    iprot.readMessageEnd()
559 chandransh 2184 
    result = changeCartStatus_result()
130 ashish 2185 
    try:
559 chandransh 2186 
      self._handler.changeCartStatus(args.cartId, args.status)
2187 
    except ShoppingCartException, scx:
2188 
      result.scx = scx
2189 
    oprot.writeMessageBegin("changeCartStatus", TMessageType.REPLY, seqid)
130 ashish 2190 
    result.write(oprot)
2191 
    oprot.writeMessageEnd()
2192 
    oprot.trans.flush()
94 ashish 2193 
 
559 chandransh 2194 
  def process_addItemToCart(self, seqid, iprot, oprot):
2195 
    args = addItemToCart_args()
130 ashish 2196 
    args.read(iprot)
2197 
    iprot.readMessageEnd()
559 chandransh 2198 
    result = addItemToCart_result()
130 ashish 2199 
    try:
559 chandransh 2200 
      self._handler.addItemToCart(args.cartId, args.itemId, args.quantity)
2201 
    except ShoppingCartException, scx:
2202 
      result.scx = scx
2203 
    oprot.writeMessageBegin("addItemToCart", TMessageType.REPLY, seqid)
130 ashish 2204 
    result.write(oprot)
2205 
    oprot.writeMessageEnd()
2206 
    oprot.trans.flush()
2207 
 
559 chandransh 2208 
  def process_deleteItemFromCart(self, seqid, iprot, oprot):
2209 
    args = deleteItemFromCart_args()
2210 
    args.read(iprot)
2211 
    iprot.readMessageEnd()
2212 
    result = deleteItemFromCart_result()
2213 
    try:
2214 
      self._handler.deleteItemFromCart(args.cartId, args.itemId)
2215 
    except ShoppingCartException, scx:
2216 
      result.scx = scx
2217 
    oprot.writeMessageBegin("deleteItemFromCart", TMessageType.REPLY, seqid)
2218 
    result.write(oprot)
2219 
    oprot.writeMessageEnd()
2220 
    oprot.trans.flush()
130 ashish 2221 
 
559 chandransh 2222 
  def process_changeQuantity(self, seqid, iprot, oprot):
2223 
    args = changeQuantity_args()
2224 
    args.read(iprot)
2225 
    iprot.readMessageEnd()
2226 
    result = changeQuantity_result()
2227 
    try:
2228 
      self._handler.changeQuantity(args.cartId, args.itemId, args.quantity)
2229 
    except ShoppingCartException, scx:
2230 
      result.scx = scx
2231 
    oprot.writeMessageBegin("changeQuantity", TMessageType.REPLY, seqid)
2232 
    result.write(oprot)
2233 
    oprot.writeMessageEnd()
2234 
    oprot.trans.flush()
2235 
 
2236 
  def process_changeItemStatus(self, seqid, iprot, oprot):
2237 
    args = changeItemStatus_args()
2238 
    args.read(iprot)
2239 
    iprot.readMessageEnd()
2240 
    result = changeItemStatus_result()
2241 
    try:
2242 
      self._handler.changeItemStatus(args.cartId, args.itemId, args.status)
2243 
    except ShoppingCartException, scx:
2244 
      result.scx = scx
2245 
    oprot.writeMessageBegin("changeItemStatus", TMessageType.REPLY, seqid)
2246 
    result.write(oprot)
2247 
    oprot.writeMessageEnd()
2248 
    oprot.trans.flush()
2249 
 
2250 
  def process_addAddressToCart(self, seqid, iprot, oprot):
2251 
    args = addAddressToCart_args()
2252 
    args.read(iprot)
2253 
    iprot.readMessageEnd()
2254 
    result = addAddressToCart_result()
575 chandransh 2255 
    try:
2256 
      self._handler.addAddressToCart(args.cartId, args.addressId)
2257 
    except ShoppingCartException, scx:
2258 
      result.scx = scx
559 chandransh 2259 
    oprot.writeMessageBegin("addAddressToCart", TMessageType.REPLY, seqid)
2260 
    result.write(oprot)
2261 
    oprot.writeMessageEnd()
2262 
    oprot.trans.flush()
2263 
 
2264 
  def process_commitCart(self, seqid, iprot, oprot):
2265 
    args = commitCart_args()
2266 
    args.read(iprot)
2267 
    iprot.readMessageEnd()
2268 
    result = commitCart_result()
2269 
    try:
2270 
      result.success = self._handler.commitCart(args.cartId)
2271 
    except ShoppingCartException, scx:
2272 
      result.scx = scx
2273 
    oprot.writeMessageBegin("commitCart", TMessageType.REPLY, seqid)
2274 
    result.write(oprot)
2275 
    oprot.writeMessageEnd()
2276 
    oprot.trans.flush()
2277 
 
2278 
  def process_validateCart(self, seqid, iprot, oprot):
2279 
    args = validateCart_args()
2280 
    args.read(iprot)
2281 
    iprot.readMessageEnd()
2282 
    result = validateCart_result()
575 chandransh 2283 
    try:
2284 
      result.success = self._handler.validateCart(args.cartId)
2285 
    except ShoppingCartException, scex:
2286 
      result.scex = scex
559 chandransh 2287 
    oprot.writeMessageBegin("validateCart", TMessageType.REPLY, seqid)
2288 
    result.write(oprot)
2289 
    oprot.writeMessageEnd()
2290 
    oprot.trans.flush()
2291 
 
575 chandransh 2292 
  def process_refreshCart(self, seqid, iprot, oprot):
2293 
    args = refreshCart_args()
2294 
    args.read(iprot)
2295 
    iprot.readMessageEnd()
2296 
    result = refreshCart_result()
2297 
    try:
2298 
      result.success = self._handler.refreshCart(args.cartId)
2299 
    except ShoppingCartException, scex:
2300 
      result.scex = scex
2301 
    oprot.writeMessageBegin("refreshCart", TMessageType.REPLY, seqid)
2302 
    result.write(oprot)
2303 
    oprot.writeMessageEnd()
2304 
    oprot.trans.flush()
2305 
 
559 chandransh 2306 
  def process_mergeCart(self, seqid, iprot, oprot):
2307 
    args = mergeCart_args()
2308 
    args.read(iprot)
2309 
    iprot.readMessageEnd()
2310 
    result = mergeCart_result()
2311 
    self._handler.mergeCart(args.fromCartId, args.toCartId)
2312 
    oprot.writeMessageBegin("mergeCart", TMessageType.REPLY, seqid)
2313 
    result.write(oprot)
2314 
    oprot.writeMessageEnd()
2315 
    oprot.trans.flush()
2316 
 
2317 
  def process_addWidget(self, seqid, iprot, oprot):
2318 
    args = addWidget_args()
2319 
    args.read(iprot)
2320 
    iprot.readMessageEnd()
2321 
    result = addWidget_result()
2322 
    try:
2323 
      self._handler.addWidget(args.widget)
2324 
    except WidgetException, scx:
2325 
      result.scx = scx
2326 
    oprot.writeMessageBegin("addWidget", TMessageType.REPLY, seqid)
2327 
    result.write(oprot)
2328 
    oprot.writeMessageEnd()
2329 
    oprot.trans.flush()
2330 
 
2331 
  def process_addItemToWidget(self, seqid, iprot, oprot):
2332 
    args = addItemToWidget_args()
2333 
    args.read(iprot)
2334 
    iprot.readMessageEnd()
2335 
    result = addItemToWidget_result()
2336 
    try:
2337 
      self._handler.addItemToWidget(args.widget_id, args.items)
2338 
    except WidgetException, scx:
2339 
      result.scx = scx
2340 
    oprot.writeMessageBegin("addItemToWidget", TMessageType.REPLY, seqid)
2341 
    result.write(oprot)
2342 
    oprot.writeMessageEnd()
2343 
    oprot.trans.flush()
2344 
 
2345 
  def process_deleteItemFromWidget(self, seqid, iprot, oprot):
2346 
    args = deleteItemFromWidget_args()
2347 
    args.read(iprot)
2348 
    iprot.readMessageEnd()
2349 
    result = deleteItemFromWidget_result()
2350 
    try:
2351 
      self._handler.deleteItemFromWidget(args.widget_id, args.item_id)
2352 
    except WidgetException, scx:
2353 
      result.scx = scx
2354 
    oprot.writeMessageBegin("deleteItemFromWidget", TMessageType.REPLY, seqid)
2355 
    result.write(oprot)
2356 
    oprot.writeMessageEnd()
2357 
    oprot.trans.flush()
2358 
 
2359 
  def process_updateWidget(self, seqid, iprot, oprot):
2360 
    args = updateWidget_args()
2361 
    args.read(iprot)
2362 
    iprot.readMessageEnd()
2363 
    result = updateWidget_result()
2364 
    try:
2365 
      self._handler.updateWidget(args.widgetId, args.enable)
2366 
    except WidgetException, scx:
2367 
      result.scx = scx
2368 
    oprot.writeMessageBegin("updateWidget", TMessageType.REPLY, seqid)
2369 
    result.write(oprot)
2370 
    oprot.writeMessageEnd()
2371 
    oprot.trans.flush()
2372 
 
2373 
  def process_updateWidgetItem(self, seqid, iprot, oprot):
2374 
    args = updateWidgetItem_args()
2375 
    args.read(iprot)
2376 
    iprot.readMessageEnd()
2377 
    result = updateWidgetItem_result()
2378 
    try:
2379 
      self._handler.updateWidgetItem(args.widgetId, args.enable)
2380 
    except WidgetException, scx:
2381 
      result.scx = scx
2382 
    oprot.writeMessageBegin("updateWidgetItem", TMessageType.REPLY, seqid)
2383 
    result.write(oprot)
2384 
    oprot.writeMessageEnd()
2385 
    oprot.trans.flush()
2386 
 
2387 
  def process_getWidget(self, seqid, iprot, oprot):
2388 
    args = getWidget_args()
2389 
    args.read(iprot)
2390 
    iprot.readMessageEnd()
2391 
    result = getWidget_result()
2392 
    try:
2393 
      result.success = self._handler.getWidget(args.type, args.userId, args.onlyEnabled)
2394 
    except WidgetException, scx:
2395 
      result.scx = scx
2396 
    oprot.writeMessageBegin("getWidget", TMessageType.REPLY, seqid)
2397 
    result.write(oprot)
2398 
    oprot.writeMessageEnd()
2399 
    oprot.trans.flush()
2400 
 
2401 
  def process_getMyResearch(self, seqid, iprot, oprot):
2402 
    args = getMyResearch_args()
2403 
    args.read(iprot)
2404 
    iprot.readMessageEnd()
2405 
    result = getMyResearch_result()
2406 
    try:
2407 
      result.success = self._handler.getMyResearch(args.user_id)
2408 
    except WidgetException, scx:
2409 
      result.scx = scx
2410 
    oprot.writeMessageBegin("getMyResearch", TMessageType.REPLY, seqid)
2411 
    result.write(oprot)
2412 
    oprot.writeMessageEnd()
2413 
    oprot.trans.flush()
2414 
 
2415 
  def process_updateMyResearch(self, seqid, iprot, oprot):
2416 
    args = updateMyResearch_args()
2417 
    args.read(iprot)
2418 
    iprot.readMessageEnd()
2419 
    result = updateMyResearch_result()
2420 
    try:
2421 
      result.success = self._handler.updateMyResearch(args.user_id, args.item_id)
2422 
    except WidgetException, scx:
2423 
      result.scx = scx
2424 
    oprot.writeMessageBegin("updateMyResearch", TMessageType.REPLY, seqid)
2425 
    result.write(oprot)
2426 
    oprot.writeMessageEnd()
2427 
    oprot.trans.flush()
2428 
 
2429 
  def process_deleteItemFromMyResearch(self, seqid, iprot, oprot):
2430 
    args = deleteItemFromMyResearch_args()
2431 
    args.read(iprot)
2432 
    iprot.readMessageEnd()
2433 
    result = deleteItemFromMyResearch_result()
2434 
    try:
2435 
      self._handler.deleteItemFromMyResearch(args.user_id, args.item_id)
2436 
    except WidgetException, scx:
2437 
      result.scx = scx
2438 
    oprot.writeMessageBegin("deleteItemFromMyResearch", TMessageType.REPLY, seqid)
2439 
    result.write(oprot)
2440 
    oprot.writeMessageEnd()
2441 
    oprot.trans.flush()
2442 
 
2443 
  def process_updateRatings(self, seqid, iprot, oprot):
2444 
    args = updateRatings_args()
2445 
    args.read(iprot)
2446 
    iprot.readMessageEnd()
2447 
    result = updateRatings_result()
2448 
    self._handler.updateRatings(args.item_id, args.type, args.rating, args.user_id)
2449 
    oprot.writeMessageBegin("updateRatings", TMessageType.REPLY, seqid)
2450 
    result.write(oprot)
2451 
    oprot.writeMessageEnd()
2452 
    oprot.trans.flush()
2453 
 
2454 
  def process_getRatings(self, seqid, iprot, oprot):
2455 
    args = getRatings_args()
2456 
    args.read(iprot)
2457 
    iprot.readMessageEnd()
2458 
    result = getRatings_result()
2459 
    try:
2460 
      result.success = self._handler.getRatings(args.item_id, args.user_id)
2461 
    except WidgetException, scx:
2462 
      result.scx = scx
2463 
    oprot.writeMessageBegin("getRatings", TMessageType.REPLY, seqid)
2464 
    result.write(oprot)
2465 
    oprot.writeMessageEnd()
2466 
    oprot.trans.flush()
2467 
 
2468 
  def process_updateBrowseHistory(self, seqid, iprot, oprot):
2469 
    args = updateBrowseHistory_args()
2470 
    args.read(iprot)
2471 
    iprot.readMessageEnd()
2472 
    result = updateBrowseHistory_result()
2473 
    self._handler.updateBrowseHistory(args.user_id, args.item_id, args.isSessionId)
2474 
    oprot.writeMessageBegin("updateBrowseHistory", TMessageType.REPLY, seqid)
2475 
    result.write(oprot)
2476 
    oprot.writeMessageEnd()
2477 
    oprot.trans.flush()
2478 
 
2479 
  def process_getBrowseHistory(self, seqid, iprot, oprot):
2480 
    args = getBrowseHistory_args()
2481 
    args.read(iprot)
2482 
    iprot.readMessageEnd()
2483 
    result = getBrowseHistory_result()
2484 
    try:
2485 
      result.success = self._handler.getBrowseHistory(args.userId, args.isSessionId)
2486 
    except WidgetException, scx:
2487 
      result.scx = scx
2488 
    oprot.writeMessageBegin("getBrowseHistory", TMessageType.REPLY, seqid)
2489 
    result.write(oprot)
2490 
    oprot.writeMessageEnd()
2491 
    oprot.trans.flush()
2492 
 
2493 
 
94 ashish 2494 
# HELPER FUNCTIONS AND STRUCTURES
2495 
 
559 chandransh 2496 
class createAnonymousUser_args:
94 ashish 2497 
  """
2498 
  Attributes:
559 chandransh 2499 
   - jsessionId
94 ashish 2500 
  """
2501 
 
2502 
  thrift_spec = (
2503 
    None, # 0
559 chandransh 2504 
    (1, TType.STRING, 'jsessionId', None, None, ), # 1
94 ashish 2505 
  )
2506 
 
559 chandransh 2507 
  def __init__(self, jsessionId=None,):
2508 
    self.jsessionId = jsessionId
94 ashish 2509 
 
2510 
  def read(self, iprot):
2511 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2512 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2513 
      return
2514 
    iprot.readStructBegin()
2515 
    while True:
2516 
      (fname, ftype, fid) = iprot.readFieldBegin()
2517 
      if ftype == TType.STOP:
2518 
        break
2519 
      if fid == 1:
559 chandransh 2520 
        if ftype == TType.STRING:
2521 
          self.jsessionId = iprot.readString();
94 ashish 2522 
        else:
2523 
          iprot.skip(ftype)
2524 
      else:
2525 
        iprot.skip(ftype)
2526 
      iprot.readFieldEnd()
2527 
    iprot.readStructEnd()
2528 
 
2529 
  def write(self, oprot):
2530 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2531 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2532 
      return
559 chandransh 2533 
    oprot.writeStructBegin('createAnonymousUser_args')
2534 
    if self.jsessionId != None:
2535 
      oprot.writeFieldBegin('jsessionId', TType.STRING, 1)
2536 
      oprot.writeString(self.jsessionId)
94 ashish 2537 
      oprot.writeFieldEnd()
2538 
    oprot.writeFieldStop()
2539 
    oprot.writeStructEnd()
2540 
 
2541 
  def __repr__(self):
2542 
    L = ['%s=%r' % (key, value)
2543 
      for key, value in self.__dict__.iteritems()]
2544 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2545 
 
2546 
  def __eq__(self, other):
2547 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2548 
 
2549 
  def __ne__(self, other):
2550 
    return not (self == other)
2551 
 
559 chandransh 2552 
class createAnonymousUser_result:
94 ashish 2553 
  """
2554 
  Attributes:
2555 
   - success
559 chandransh 2556 
   - ucex
94 ashish 2557 
  """
2558 
 
2559 
  thrift_spec = (
559 chandransh 2560 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
2561 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 2562 
  )
2563 
 
559 chandransh 2564 
  def __init__(self, success=None, ucex=None,):
94 ashish 2565 
    self.success = success
559 chandransh 2566 
    self.ucex = ucex
94 ashish 2567 
 
2568 
  def read(self, iprot):
2569 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2570 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2571 
      return
2572 
    iprot.readStructBegin()
2573 
    while True:
2574 
      (fname, ftype, fid) = iprot.readFieldBegin()
2575 
      if ftype == TType.STOP:
2576 
        break
2577 
      if fid == 0:
2578 
        if ftype == TType.STRUCT:
559 chandransh 2579 
          self.success = User()
94 ashish 2580 
          self.success.read(iprot)
2581 
        else:
2582 
          iprot.skip(ftype)
2583 
      elif fid == 1:
2584 
        if ftype == TType.STRUCT:
559 chandransh 2585 
          self.ucex = UserContextException()
2586 
          self.ucex.read(iprot)
94 ashish 2587 
        else:
2588 
          iprot.skip(ftype)
2589 
      else:
2590 
        iprot.skip(ftype)
2591 
      iprot.readFieldEnd()
2592 
    iprot.readStructEnd()
2593 
 
2594 
  def write(self, oprot):
2595 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2596 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2597 
      return
559 chandransh 2598 
    oprot.writeStructBegin('createAnonymousUser_result')
94 ashish 2599 
    if self.success != None:
2600 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
2601 
      self.success.write(oprot)
2602 
      oprot.writeFieldEnd()
559 chandransh 2603 
    if self.ucex != None:
2604 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
2605 
      self.ucex.write(oprot)
94 ashish 2606 
      oprot.writeFieldEnd()
2607 
    oprot.writeFieldStop()
2608 
    oprot.writeStructEnd()
2609 
 
2610 
  def __repr__(self):
2611 
    L = ['%s=%r' % (key, value)
2612 
      for key, value in self.__dict__.iteritems()]
2613 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2614 
 
2615 
  def __eq__(self, other):
2616 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2617 
 
2618 
  def __ne__(self, other):
2619 
    return not (self == other)
2620 
 
559 chandransh 2621 
class getUserById_args:
94 ashish 2622 
  """
2623 
  Attributes:
2624 
   - userId
2625 
  """
2626 
 
2627 
  thrift_spec = (
2628 
    None, # 0
2629 
    (1, TType.I64, 'userId', None, None, ), # 1
2630 
  )
2631 
 
559 chandransh 2632 
  def __init__(self, userId=None,):
94 ashish 2633 
    self.userId = userId
2634 
 
2635 
  def read(self, iprot):
2636 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2637 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2638 
      return
2639 
    iprot.readStructBegin()
2640 
    while True:
2641 
      (fname, ftype, fid) = iprot.readFieldBegin()
2642 
      if ftype == TType.STOP:
2643 
        break
2644 
      if fid == 1:
2645 
        if ftype == TType.I64:
2646 
          self.userId = iprot.readI64();
2647 
        else:
2648 
          iprot.skip(ftype)
2649 
      else:
2650 
        iprot.skip(ftype)
2651 
      iprot.readFieldEnd()
2652 
    iprot.readStructEnd()
2653 
 
2654 
  def write(self, oprot):
2655 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2656 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2657 
      return
559 chandransh 2658 
    oprot.writeStructBegin('getUserById_args')
94 ashish 2659 
    if self.userId != None:
2660 
      oprot.writeFieldBegin('userId', TType.I64, 1)
2661 
      oprot.writeI64(self.userId)
2662 
      oprot.writeFieldEnd()
2663 
    oprot.writeFieldStop()
2664 
    oprot.writeStructEnd()
2665 
 
2666 
  def __repr__(self):
2667 
    L = ['%s=%r' % (key, value)
2668 
      for key, value in self.__dict__.iteritems()]
2669 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2670 
 
2671 
  def __eq__(self, other):
2672 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2673 
 
2674 
  def __ne__(self, other):
2675 
    return not (self == other)
2676 
 
559 chandransh 2677 
class getUserById_result:
94 ashish 2678 
  """
2679 
  Attributes:
2680 
   - success
559 chandransh 2681 
   - ucex
94 ashish 2682 
  """
2683 
 
2684 
  thrift_spec = (
559 chandransh 2685 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
2686 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 2687 
  )
2688 
 
559 chandransh 2689 
  def __init__(self, success=None, ucex=None,):
94 ashish 2690 
    self.success = success
559 chandransh 2691 
    self.ucex = ucex
94 ashish 2692 
 
2693 
  def read(self, iprot):
2694 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2695 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2696 
      return
2697 
    iprot.readStructBegin()
2698 
    while True:
2699 
      (fname, ftype, fid) = iprot.readFieldBegin()
2700 
      if ftype == TType.STOP:
2701 
        break
2702 
      if fid == 0:
2703 
        if ftype == TType.STRUCT:
559 chandransh 2704 
          self.success = User()
94 ashish 2705 
          self.success.read(iprot)
2706 
        else:
2707 
          iprot.skip(ftype)
2708 
      elif fid == 1:
2709 
        if ftype == TType.STRUCT:
559 chandransh 2710 
          self.ucex = UserContextException()
2711 
          self.ucex.read(iprot)
94 ashish 2712 
        else:
2713 
          iprot.skip(ftype)
2714 
      else:
2715 
        iprot.skip(ftype)
2716 
      iprot.readFieldEnd()
2717 
    iprot.readStructEnd()
2718 
 
2719 
  def write(self, oprot):
2720 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2721 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2722 
      return
559 chandransh 2723 
    oprot.writeStructBegin('getUserById_result')
94 ashish 2724 
    if self.success != None:
2725 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
2726 
      self.success.write(oprot)
2727 
      oprot.writeFieldEnd()
559 chandransh 2728 
    if self.ucex != None:
2729 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
2730 
      self.ucex.write(oprot)
94 ashish 2731 
      oprot.writeFieldEnd()
2732 
    oprot.writeFieldStop()
2733 
    oprot.writeStructEnd()
2734 
 
2735 
  def __repr__(self):
2736 
    L = ['%s=%r' % (key, value)
2737 
      for key, value in self.__dict__.iteritems()]
2738 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2739 
 
2740 
  def __eq__(self, other):
2741 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2742 
 
2743 
  def __ne__(self, other):
2744 
    return not (self == other)
2745 
 
559 chandransh 2746 
class createUser_args:
94 ashish 2747 
  """
2748 
  Attributes:
559 chandransh 2749 
   - user
94 ashish 2750 
  """
2751 
 
2752 
  thrift_spec = (
2753 
    None, # 0
559 chandransh 2754 
    (1, TType.STRUCT, 'user', (User, User.thrift_spec), None, ), # 1
94 ashish 2755 
  )
2756 
 
559 chandransh 2757 
  def __init__(self, user=None,):
2758 
    self.user = user
94 ashish 2759 
 
2760 
  def read(self, iprot):
2761 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2762 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2763 
      return
2764 
    iprot.readStructBegin()
2765 
    while True:
2766 
      (fname, ftype, fid) = iprot.readFieldBegin()
2767 
      if ftype == TType.STOP:
2768 
        break
2769 
      if fid == 1:
559 chandransh 2770 
        if ftype == TType.STRUCT:
2771 
          self.user = User()
2772 
          self.user.read(iprot)
94 ashish 2773 
        else:
2774 
          iprot.skip(ftype)
2775 
      else:
2776 
        iprot.skip(ftype)
2777 
      iprot.readFieldEnd()
2778 
    iprot.readStructEnd()
2779 
 
2780 
  def write(self, oprot):
2781 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2782 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2783 
      return
559 chandransh 2784 
    oprot.writeStructBegin('createUser_args')
2785 
    if self.user != None:
2786 
      oprot.writeFieldBegin('user', TType.STRUCT, 1)
2787 
      self.user.write(oprot)
94 ashish 2788 
      oprot.writeFieldEnd()
2789 
    oprot.writeFieldStop()
2790 
    oprot.writeStructEnd()
2791 
 
2792 
  def __repr__(self):
2793 
    L = ['%s=%r' % (key, value)
2794 
      for key, value in self.__dict__.iteritems()]
2795 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2796 
 
2797 
  def __eq__(self, other):
2798 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2799 
 
2800 
  def __ne__(self, other):
2801 
    return not (self == other)
2802 
 
559 chandransh 2803 
class createUser_result:
94 ashish 2804 
  """
2805 
  Attributes:
2806 
   - success
559 chandransh 2807 
   - ucex
94 ashish 2808 
  """
2809 
 
2810 
  thrift_spec = (
559 chandransh 2811 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
2812 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 2813 
  )
2814 
 
559 chandransh 2815 
  def __init__(self, success=None, ucex=None,):
94 ashish 2816 
    self.success = success
559 chandransh 2817 
    self.ucex = ucex
94 ashish 2818 
 
2819 
  def read(self, iprot):
2820 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2821 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2822 
      return
2823 
    iprot.readStructBegin()
2824 
    while True:
2825 
      (fname, ftype, fid) = iprot.readFieldBegin()
2826 
      if ftype == TType.STOP:
2827 
        break
2828 
      if fid == 0:
2829 
        if ftype == TType.STRUCT:
559 chandransh 2830 
          self.success = User()
94 ashish 2831 
          self.success.read(iprot)
2832 
        else:
2833 
          iprot.skip(ftype)
2834 
      elif fid == 1:
2835 
        if ftype == TType.STRUCT:
559 chandransh 2836 
          self.ucex = UserContextException()
2837 
          self.ucex.read(iprot)
94 ashish 2838 
        else:
2839 
          iprot.skip(ftype)
2840 
      else:
2841 
        iprot.skip(ftype)
2842 
      iprot.readFieldEnd()
2843 
    iprot.readStructEnd()
2844 
 
2845 
  def write(self, oprot):
2846 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2847 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2848 
      return
559 chandransh 2849 
    oprot.writeStructBegin('createUser_result')
94 ashish 2850 
    if self.success != None:
2851 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
2852 
      self.success.write(oprot)
2853 
      oprot.writeFieldEnd()
559 chandransh 2854 
    if self.ucex != None:
2855 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
2856 
      self.ucex.write(oprot)
94 ashish 2857 
      oprot.writeFieldEnd()
2858 
    oprot.writeFieldStop()
2859 
    oprot.writeStructEnd()
2860 
 
2861 
  def __repr__(self):
2862 
    L = ['%s=%r' % (key, value)
2863 
      for key, value in self.__dict__.iteritems()]
2864 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2865 
 
2866 
  def __eq__(self, other):
2867 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2868 
 
2869 
  def __ne__(self, other):
2870 
    return not (self == other)
2871 
 
559 chandransh 2872 
class updateUser_args:
94 ashish 2873 
  """
2874 
  Attributes:
559 chandransh 2875 
   - user
94 ashish 2876 
  """
2877 
 
2878 
  thrift_spec = (
2879 
    None, # 0
559 chandransh 2880 
    (1, TType.STRUCT, 'user', (User, User.thrift_spec), None, ), # 1
94 ashish 2881 
  )
2882 
 
559 chandransh 2883 
  def __init__(self, user=None,):
2884 
    self.user = user
94 ashish 2885 
 
2886 
  def read(self, iprot):
2887 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2888 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2889 
      return
2890 
    iprot.readStructBegin()
2891 
    while True:
2892 
      (fname, ftype, fid) = iprot.readFieldBegin()
2893 
      if ftype == TType.STOP:
2894 
        break
2895 
      if fid == 1:
559 chandransh 2896 
        if ftype == TType.STRUCT:
2897 
          self.user = User()
2898 
          self.user.read(iprot)
94 ashish 2899 
        else:
2900 
          iprot.skip(ftype)
2901 
      else:
2902 
        iprot.skip(ftype)
2903 
      iprot.readFieldEnd()
2904 
    iprot.readStructEnd()
2905 
 
2906 
  def write(self, oprot):
2907 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2908 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2909 
      return
559 chandransh 2910 
    oprot.writeStructBegin('updateUser_args')
2911 
    if self.user != None:
2912 
      oprot.writeFieldBegin('user', TType.STRUCT, 1)
2913 
      self.user.write(oprot)
94 ashish 2914 
      oprot.writeFieldEnd()
2915 
    oprot.writeFieldStop()
2916 
    oprot.writeStructEnd()
2917 
 
2918 
  def __repr__(self):
2919 
    L = ['%s=%r' % (key, value)
2920 
      for key, value in self.__dict__.iteritems()]
2921 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2922 
 
2923 
  def __eq__(self, other):
2924 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2925 
 
2926 
  def __ne__(self, other):
2927 
    return not (self == other)
2928 
 
559 chandransh 2929 
class updateUser_result:
94 ashish 2930 
  """
2931 
  Attributes:
2932 
   - success
559 chandransh 2933 
   - ucex
94 ashish 2934 
  """
2935 
 
2936 
  thrift_spec = (
559 chandransh 2937 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
2938 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 2939 
  )
2940 
 
559 chandransh 2941 
  def __init__(self, success=None, ucex=None,):
94 ashish 2942 
    self.success = success
559 chandransh 2943 
    self.ucex = ucex
94 ashish 2944 
 
2945 
  def read(self, iprot):
2946 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2947 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2948 
      return
2949 
    iprot.readStructBegin()
2950 
    while True:
2951 
      (fname, ftype, fid) = iprot.readFieldBegin()
2952 
      if ftype == TType.STOP:
2953 
        break
2954 
      if fid == 0:
2955 
        if ftype == TType.STRUCT:
559 chandransh 2956 
          self.success = User()
94 ashish 2957 
          self.success.read(iprot)
2958 
        else:
2959 
          iprot.skip(ftype)
2960 
      elif fid == 1:
2961 
        if ftype == TType.STRUCT:
559 chandransh 2962 
          self.ucex = UserContextException()
2963 
          self.ucex.read(iprot)
94 ashish 2964 
        else:
2965 
          iprot.skip(ftype)
2966 
      else:
2967 
        iprot.skip(ftype)
2968 
      iprot.readFieldEnd()
2969 
    iprot.readStructEnd()
2970 
 
2971 
  def write(self, oprot):
2972 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2973 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2974 
      return
559 chandransh 2975 
    oprot.writeStructBegin('updateUser_result')
94 ashish 2976 
    if self.success != None:
2977 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
2978 
      self.success.write(oprot)
2979 
      oprot.writeFieldEnd()
559 chandransh 2980 
    if self.ucex != None:
2981 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
2982 
      self.ucex.write(oprot)
94 ashish 2983 
      oprot.writeFieldEnd()
2984 
    oprot.writeFieldStop()
2985 
    oprot.writeStructEnd()
2986 
 
2987 
  def __repr__(self):
2988 
    L = ['%s=%r' % (key, value)
2989 
      for key, value in self.__dict__.iteritems()]
2990 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2991 
 
2992 
  def __eq__(self, other):
2993 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2994 
 
2995 
  def __ne__(self, other):
2996 
    return not (self == other)
2997 
 
559 chandransh 2998 
class deleteUser_args:
94 ashish 2999 
  """
3000 
  Attributes:
3001 
   - userId
3002 
  """
3003 
 
3004 
  thrift_spec = (
3005 
    None, # 0
3006 
    (1, TType.I64, 'userId', None, None, ), # 1
3007 
  )
3008 
 
559 chandransh 3009 
  def __init__(self, userId=None,):
94 ashish 3010 
    self.userId = userId
3011 
 
3012 
  def read(self, iprot):
3013 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3014 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3015 
      return
3016 
    iprot.readStructBegin()
3017 
    while True:
3018 
      (fname, ftype, fid) = iprot.readFieldBegin()
3019 
      if ftype == TType.STOP:
3020 
        break
3021 
      if fid == 1:
3022 
        if ftype == TType.I64:
3023 
          self.userId = iprot.readI64();
3024 
        else:
3025 
          iprot.skip(ftype)
3026 
      else:
3027 
        iprot.skip(ftype)
3028 
      iprot.readFieldEnd()
3029 
    iprot.readStructEnd()
3030 
 
3031 
  def write(self, oprot):
3032 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3033 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3034 
      return
559 chandransh 3035 
    oprot.writeStructBegin('deleteUser_args')
94 ashish 3036 
    if self.userId != None:
3037 
      oprot.writeFieldBegin('userId', TType.I64, 1)
3038 
      oprot.writeI64(self.userId)
3039 
      oprot.writeFieldEnd()
3040 
    oprot.writeFieldStop()
3041 
    oprot.writeStructEnd()
3042 
 
3043 
  def __repr__(self):
3044 
    L = ['%s=%r' % (key, value)
3045 
      for key, value in self.__dict__.iteritems()]
3046 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3047 
 
3048 
  def __eq__(self, other):
3049 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3050 
 
3051 
  def __ne__(self, other):
3052 
    return not (self == other)
3053 
 
559 chandransh 3054 
class deleteUser_result:
94 ashish 3055 
  """
3056 
  Attributes:
3057 
   - success
559 chandransh 3058 
   - ucex
94 ashish 3059 
  """
3060 
 
3061 
  thrift_spec = (
559 chandransh 3062 
    (0, TType.BOOL, 'success', None, None, ), # 0
3063 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 3064 
  )
3065 
 
559 chandransh 3066 
  def __init__(self, success=None, ucex=None,):
94 ashish 3067 
    self.success = success
559 chandransh 3068 
    self.ucex = ucex
94 ashish 3069 
 
3070 
  def read(self, iprot):
3071 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3072 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3073 
      return
3074 
    iprot.readStructBegin()
3075 
    while True:
3076 
      (fname, ftype, fid) = iprot.readFieldBegin()
3077 
      if ftype == TType.STOP:
3078 
        break
3079 
      if fid == 0:
559 chandransh 3080 
        if ftype == TType.BOOL:
3081 
          self.success = iprot.readBool();
94 ashish 3082 
        else:
3083 
          iprot.skip(ftype)
3084 
      elif fid == 1:
3085 
        if ftype == TType.STRUCT:
559 chandransh 3086 
          self.ucex = UserContextException()
3087 
          self.ucex.read(iprot)
94 ashish 3088 
        else:
3089 
          iprot.skip(ftype)
3090 
      else:
3091 
        iprot.skip(ftype)
3092 
      iprot.readFieldEnd()
3093 
    iprot.readStructEnd()
3094 
 
3095 
  def write(self, oprot):
3096 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3097 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3098 
      return
559 chandransh 3099 
    oprot.writeStructBegin('deleteUser_result')
94 ashish 3100 
    if self.success != None:
559 chandransh 3101 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
3102 
      oprot.writeBool(self.success)
94 ashish 3103 
      oprot.writeFieldEnd()
559 chandransh 3104 
    if self.ucex != None:
3105 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
3106 
      self.ucex.write(oprot)
94 ashish 3107 
      oprot.writeFieldEnd()
3108 
    oprot.writeFieldStop()
3109 
    oprot.writeStructEnd()
3110 
 
3111 
  def __repr__(self):
3112 
    L = ['%s=%r' % (key, value)
3113 
      for key, value in self.__dict__.iteritems()]
3114 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3115 
 
3116 
  def __eq__(self, other):
3117 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3118 
 
3119 
  def __ne__(self, other):
3120 
    return not (self == other)
3121 
 
559 chandransh 3122 
class getUserState_args:
94 ashish 3123 
  """
3124 
  Attributes:
3125 
   - userId
3126 
  """
3127 
 
3128 
  thrift_spec = (
3129 
    None, # 0
3130 
    (1, TType.I64, 'userId', None, None, ), # 1
3131 
  )
3132 
 
559 chandransh 3133 
  def __init__(self, userId=None,):
94 ashish 3134 
    self.userId = userId
3135 
 
3136 
  def read(self, iprot):
3137 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3138 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3139 
      return
3140 
    iprot.readStructBegin()
3141 
    while True:
3142 
      (fname, ftype, fid) = iprot.readFieldBegin()
3143 
      if ftype == TType.STOP:
3144 
        break
3145 
      if fid == 1:
3146 
        if ftype == TType.I64:
3147 
          self.userId = iprot.readI64();
3148 
        else:
3149 
          iprot.skip(ftype)
3150 
      else:
3151 
        iprot.skip(ftype)
3152 
      iprot.readFieldEnd()
3153 
    iprot.readStructEnd()
3154 
 
3155 
  def write(self, oprot):
3156 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3157 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3158 
      return
559 chandransh 3159 
    oprot.writeStructBegin('getUserState_args')
94 ashish 3160 
    if self.userId != None:
3161 
      oprot.writeFieldBegin('userId', TType.I64, 1)
3162 
      oprot.writeI64(self.userId)
3163 
      oprot.writeFieldEnd()
3164 
    oprot.writeFieldStop()
3165 
    oprot.writeStructEnd()
3166 
 
3167 
  def __repr__(self):
3168 
    L = ['%s=%r' % (key, value)
3169 
      for key, value in self.__dict__.iteritems()]
3170 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3171 
 
3172 
  def __eq__(self, other):
3173 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3174 
 
3175 
  def __ne__(self, other):
3176 
    return not (self == other)
3177 
 
559 chandransh 3178 
class getUserState_result:
94 ashish 3179 
  """
3180 
  Attributes:
3181 
   - success
559 chandransh 3182 
   - ucex
94 ashish 3183 
  """
3184 
 
3185 
  thrift_spec = (
559 chandransh 3186 
    (0, TType.STRUCT, 'success', (UserState, UserState.thrift_spec), None, ), # 0
3187 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 3188 
  )
3189 
 
559 chandransh 3190 
  def __init__(self, success=None, ucex=None,):
94 ashish 3191 
    self.success = success
559 chandransh 3192 
    self.ucex = ucex
94 ashish 3193 
 
3194 
  def read(self, iprot):
3195 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3196 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3197 
      return
3198 
    iprot.readStructBegin()
3199 
    while True:
3200 
      (fname, ftype, fid) = iprot.readFieldBegin()
3201 
      if ftype == TType.STOP:
3202 
        break
3203 
      if fid == 0:
3204 
        if ftype == TType.STRUCT:
559 chandransh 3205 
          self.success = UserState()
94 ashish 3206 
          self.success.read(iprot)
3207 
        else:
3208 
          iprot.skip(ftype)
3209 
      elif fid == 1:
3210 
        if ftype == TType.STRUCT:
559 chandransh 3211 
          self.ucex = UserContextException()
3212 
          self.ucex.read(iprot)
94 ashish 3213 
        else:
3214 
          iprot.skip(ftype)
3215 
      else:
3216 
        iprot.skip(ftype)
3217 
      iprot.readFieldEnd()
3218 
    iprot.readStructEnd()
3219 
 
3220 
  def write(self, oprot):
3221 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3222 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3223 
      return
559 chandransh 3224 
    oprot.writeStructBegin('getUserState_result')
94 ashish 3225 
    if self.success != None:
3226 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
3227 
      self.success.write(oprot)
3228 
      oprot.writeFieldEnd()
559 chandransh 3229 
    if self.ucex != None:
3230 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
3231 
      self.ucex.write(oprot)
94 ashish 3232 
      oprot.writeFieldEnd()
3233 
    oprot.writeFieldStop()
3234 
    oprot.writeStructEnd()
3235 
 
3236 
  def __repr__(self):
3237 
    L = ['%s=%r' % (key, value)
3238 
      for key, value in self.__dict__.iteritems()]
3239 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3240 
 
3241 
  def __eq__(self, other):
3242 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3243 
 
3244 
  def __ne__(self, other):
3245 
    return not (self == other)
3246 
 
559 chandransh 3247 
class authenticateUser_args:
94 ashish 3248 
  """
3249 
  Attributes:
3250 
   - email
3251 
   - password
3252 
  """
3253 
 
3254 
  thrift_spec = (
3255 
    None, # 0
3256 
    (1, TType.STRING, 'email', None, None, ), # 1
3257 
    (2, TType.STRING, 'password', None, None, ), # 2
3258 
  )
3259 
 
3260 
  def __init__(self, email=None, password=None,):
3261 
    self.email = email
3262 
    self.password = password
3263 
 
3264 
  def read(self, iprot):
3265 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3266 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3267 
      return
3268 
    iprot.readStructBegin()
3269 
    while True:
3270 
      (fname, ftype, fid) = iprot.readFieldBegin()
3271 
      if ftype == TType.STOP:
3272 
        break
3273 
      if fid == 1:
3274 
        if ftype == TType.STRING:
3275 
          self.email = iprot.readString();
3276 
        else:
3277 
          iprot.skip(ftype)
3278 
      elif fid == 2:
3279 
        if ftype == TType.STRING:
3280 
          self.password = iprot.readString();
3281 
        else:
3282 
          iprot.skip(ftype)
3283 
      else:
3284 
        iprot.skip(ftype)
3285 
      iprot.readFieldEnd()
3286 
    iprot.readStructEnd()
3287 
 
3288 
  def write(self, oprot):
3289 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3290 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3291 
      return
559 chandransh 3292 
    oprot.writeStructBegin('authenticateUser_args')
94 ashish 3293 
    if self.email != None:
3294 
      oprot.writeFieldBegin('email', TType.STRING, 1)
3295 
      oprot.writeString(self.email)
3296 
      oprot.writeFieldEnd()
3297 
    if self.password != None:
3298 
      oprot.writeFieldBegin('password', TType.STRING, 2)
3299 
      oprot.writeString(self.password)
3300 
      oprot.writeFieldEnd()
3301 
    oprot.writeFieldStop()
3302 
    oprot.writeStructEnd()
3303 
 
3304 
  def __repr__(self):
3305 
    L = ['%s=%r' % (key, value)
3306 
      for key, value in self.__dict__.iteritems()]
3307 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3308 
 
3309 
  def __eq__(self, other):
3310 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3311 
 
3312 
  def __ne__(self, other):
3313 
    return not (self == other)
3314 
 
559 chandransh 3315 
class authenticateUser_result:
94 ashish 3316 
  """
3317 
  Attributes:
3318 
   - success
559 chandransh 3319 
   - auex
94 ashish 3320 
  """
3321 
 
3322 
  thrift_spec = (
559 chandransh 3323 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
3324 
    (1, TType.STRUCT, 'auex', (AuthenticationException, AuthenticationException.thrift_spec), None, ), # 1
94 ashish 3325 
  )
3326 
 
559 chandransh 3327 
  def __init__(self, success=None, auex=None,):
94 ashish 3328 
    self.success = success
559 chandransh 3329 
    self.auex = auex
94 ashish 3330 
 
3331 
  def read(self, iprot):
3332 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3333 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3334 
      return
3335 
    iprot.readStructBegin()
3336 
    while True:
3337 
      (fname, ftype, fid) = iprot.readFieldBegin()
3338 
      if ftype == TType.STOP:
3339 
        break
3340 
      if fid == 0:
3341 
        if ftype == TType.STRUCT:
559 chandransh 3342 
          self.success = User()
94 ashish 3343 
          self.success.read(iprot)
3344 
        else:
3345 
          iprot.skip(ftype)
3346 
      elif fid == 1:
3347 
        if ftype == TType.STRUCT:
559 chandransh 3348 
          self.auex = AuthenticationException()
3349 
          self.auex.read(iprot)
94 ashish 3350 
        else:
3351 
          iprot.skip(ftype)
3352 
      else:
3353 
        iprot.skip(ftype)
3354 
      iprot.readFieldEnd()
3355 
    iprot.readStructEnd()
3356 
 
3357 
  def write(self, oprot):
3358 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3359 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3360 
      return
559 chandransh 3361 
    oprot.writeStructBegin('authenticateUser_result')
94 ashish 3362 
    if self.success != None:
3363 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
3364 
      self.success.write(oprot)
3365 
      oprot.writeFieldEnd()
559 chandransh 3366 
    if self.auex != None:
3367 
      oprot.writeFieldBegin('auex', TType.STRUCT, 1)
3368 
      self.auex.write(oprot)
94 ashish 3369 
      oprot.writeFieldEnd()
3370 
    oprot.writeFieldStop()
3371 
    oprot.writeStructEnd()
3372 
 
3373 
  def __repr__(self):
3374 
    L = ['%s=%r' % (key, value)
3375 
      for key, value in self.__dict__.iteritems()]
3376 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3377 
 
3378 
  def __eq__(self, other):
3379 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3380 
 
3381 
  def __ne__(self, other):
3382 
    return not (self == other)
3383 
 
559 chandransh 3384 
class userExists_args:
122 ashish 3385 
  """
3386 
  Attributes:
559 chandransh 3387 
   - email
122 ashish 3388 
  """
3389 
 
3390 
  thrift_spec = (
3391 
    None, # 0
559 chandransh 3392 
    (1, TType.STRING, 'email', None, None, ), # 1
122 ashish 3393 
  )
3394 
 
559 chandransh 3395 
  def __init__(self, email=None,):
3396 
    self.email = email
122 ashish 3397 
 
3398 
  def read(self, iprot):
3399 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3400 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3401 
      return
3402 
    iprot.readStructBegin()
3403 
    while True:
3404 
      (fname, ftype, fid) = iprot.readFieldBegin()
3405 
      if ftype == TType.STOP:
3406 
        break
3407 
      if fid == 1:
3408 
        if ftype == TType.STRING:
559 chandransh 3409 
          self.email = iprot.readString();
122 ashish 3410 
        else:
3411 
          iprot.skip(ftype)
559 chandransh 3412 
      else:
3413 
        iprot.skip(ftype)
3414 
      iprot.readFieldEnd()
3415 
    iprot.readStructEnd()
3416 
 
3417 
  def write(self, oprot):
3418 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3419 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3420 
      return
3421 
    oprot.writeStructBegin('userExists_args')
3422 
    if self.email != None:
3423 
      oprot.writeFieldBegin('email', TType.STRING, 1)
3424 
      oprot.writeString(self.email)
3425 
      oprot.writeFieldEnd()
3426 
    oprot.writeFieldStop()
3427 
    oprot.writeStructEnd()
3428 
 
3429 
  def __repr__(self):
3430 
    L = ['%s=%r' % (key, value)
3431 
      for key, value in self.__dict__.iteritems()]
3432 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3433 
 
3434 
  def __eq__(self, other):
3435 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3436 
 
3437 
  def __ne__(self, other):
3438 
    return not (self == other)
3439 
 
3440 
class userExists_result:
3441 
  """
3442 
  Attributes:
3443 
   - success
3444 
   - ucx
3445 
  """
3446 
 
3447 
  thrift_spec = (
3448 
    (0, TType.BOOL, 'success', None, None, ), # 0
3449 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
3450 
  )
3451 
 
3452 
  def __init__(self, success=None, ucx=None,):
3453 
    self.success = success
3454 
    self.ucx = ucx
3455 
 
3456 
  def read(self, iprot):
3457 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3458 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3459 
      return
3460 
    iprot.readStructBegin()
3461 
    while True:
3462 
      (fname, ftype, fid) = iprot.readFieldBegin()
3463 
      if ftype == TType.STOP:
3464 
        break
3465 
      if fid == 0:
3466 
        if ftype == TType.BOOL:
3467 
          self.success = iprot.readBool();
3468 
        else:
3469 
          iprot.skip(ftype)
3470 
      elif fid == 1:
3471 
        if ftype == TType.STRUCT:
3472 
          self.ucx = UserContextException()
3473 
          self.ucx.read(iprot)
3474 
        else:
3475 
          iprot.skip(ftype)
3476 
      else:
3477 
        iprot.skip(ftype)
3478 
      iprot.readFieldEnd()
3479 
    iprot.readStructEnd()
3480 
 
3481 
  def write(self, oprot):
3482 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3483 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3484 
      return
3485 
    oprot.writeStructBegin('userExists_result')
3486 
    if self.success != None:
3487 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
3488 
      oprot.writeBool(self.success)
3489 
      oprot.writeFieldEnd()
3490 
    if self.ucx != None:
3491 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
3492 
      self.ucx.write(oprot)
3493 
      oprot.writeFieldEnd()
3494 
    oprot.writeFieldStop()
3495 
    oprot.writeStructEnd()
3496 
 
3497 
  def __repr__(self):
3498 
    L = ['%s=%r' % (key, value)
3499 
      for key, value in self.__dict__.iteritems()]
3500 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3501 
 
3502 
  def __eq__(self, other):
3503 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3504 
 
3505 
  def __ne__(self, other):
3506 
    return not (self == other)
3507 
 
3508 
class addAddressForUser_args:
3509 
  """
3510 
  Attributes:
3511 
   - userId
3512 
   - address
3513 
   - setDefault
3514 
  """
3515 
 
3516 
  thrift_spec = (
3517 
    None, # 0
3518 
    (1, TType.I64, 'userId', None, None, ), # 1
3519 
    (2, TType.STRUCT, 'address', (Address, Address.thrift_spec), None, ), # 2
567 rajveer 3520 
    (3, TType.BOOL, 'setDefault', None, None, ), # 3
559 chandransh 3521 
  )
3522 
 
567 rajveer 3523 
  def __init__(self, userId=None, address=None, setDefault=None,):
559 chandransh 3524 
    self.userId = userId
3525 
    self.address = address
3526 
    self.setDefault = setDefault
3527 
 
3528 
  def read(self, iprot):
3529 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3530 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3531 
      return
3532 
    iprot.readStructBegin()
3533 
    while True:
3534 
      (fname, ftype, fid) = iprot.readFieldBegin()
3535 
      if ftype == TType.STOP:
3536 
        break
3537 
      if fid == 1:
3538 
        if ftype == TType.I64:
3539 
          self.userId = iprot.readI64();
3540 
        else:
3541 
          iprot.skip(ftype)
122 ashish 3542 
      elif fid == 2:
559 chandransh 3543 
        if ftype == TType.STRUCT:
3544 
          self.address = Address()
3545 
          self.address.read(iprot)
122 ashish 3546 
        else:
3547 
          iprot.skip(ftype)
3548 
      elif fid == 3:
3549 
        if ftype == TType.BOOL:
559 chandransh 3550 
          self.setDefault = iprot.readBool();
122 ashish 3551 
        else:
3552 
          iprot.skip(ftype)
3553 
      else:
3554 
        iprot.skip(ftype)
3555 
      iprot.readFieldEnd()
3556 
    iprot.readStructEnd()
3557 
 
3558 
  def write(self, oprot):
3559 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3560 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3561 
      return
559 chandransh 3562 
    oprot.writeStructBegin('addAddressForUser_args')
3563 
    if self.userId != None:
3564 
      oprot.writeFieldBegin('userId', TType.I64, 1)
3565 
      oprot.writeI64(self.userId)
122 ashish 3566 
      oprot.writeFieldEnd()
559 chandransh 3567 
    if self.address != None:
3568 
      oprot.writeFieldBegin('address', TType.STRUCT, 2)
3569 
      self.address.write(oprot)
122 ashish 3570 
      oprot.writeFieldEnd()
559 chandransh 3571 
    if self.setDefault != None:
567 rajveer 3572 
      oprot.writeFieldBegin('setDefault', TType.BOOL, 3)
559 chandransh 3573 
      oprot.writeBool(self.setDefault)
3574 
      oprot.writeFieldEnd()
122 ashish 3575 
    oprot.writeFieldStop()
3576 
    oprot.writeStructEnd()
3577 
 
3578 
  def __repr__(self):
3579 
    L = ['%s=%r' % (key, value)
3580 
      for key, value in self.__dict__.iteritems()]
3581 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3582 
 
3583 
  def __eq__(self, other):
3584 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3585 
 
3586 
  def __ne__(self, other):
3587 
    return not (self == other)
3588 
 
559 chandransh 3589 
class addAddressForUser_result:
122 ashish 3590 
  """
3591 
  Attributes:
3592 
   - success
559 chandransh 3593 
   - ucx
122 ashish 3594 
  """
3595 
 
3596 
  thrift_spec = (
567 rajveer 3597 
    (0, TType.I64, 'success', None, None, ), # 0
559 chandransh 3598 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
122 ashish 3599 
  )
3600 
 
559 chandransh 3601 
  def __init__(self, success=None, ucx=None,):
122 ashish 3602 
    self.success = success
559 chandransh 3603 
    self.ucx = ucx
122 ashish 3604 
 
3605 
  def read(self, iprot):
3606 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3607 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3608 
      return
3609 
    iprot.readStructBegin()
3610 
    while True:
3611 
      (fname, ftype, fid) = iprot.readFieldBegin()
3612 
      if ftype == TType.STOP:
3613 
        break
3614 
      if fid == 0:
567 rajveer 3615 
        if ftype == TType.I64:
3616 
          self.success = iprot.readI64();
122 ashish 3617 
        else:
3618 
          iprot.skip(ftype)
3619 
      elif fid == 1:
3620 
        if ftype == TType.STRUCT:
559 chandransh 3621 
          self.ucx = UserContextException()
3622 
          self.ucx.read(iprot)
122 ashish 3623 
        else:
3624 
          iprot.skip(ftype)
3625 
      else:
3626 
        iprot.skip(ftype)
3627 
      iprot.readFieldEnd()
3628 
    iprot.readStructEnd()
3629 
 
3630 
  def write(self, oprot):
3631 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3632 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3633 
      return
559 chandransh 3634 
    oprot.writeStructBegin('addAddressForUser_result')
122 ashish 3635 
    if self.success != None:
567 rajveer 3636 
      oprot.writeFieldBegin('success', TType.I64, 0)
3637 
      oprot.writeI64(self.success)
122 ashish 3638 
      oprot.writeFieldEnd()
559 chandransh 3639 
    if self.ucx != None:
3640 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
3641 
      self.ucx.write(oprot)
122 ashish 3642 
      oprot.writeFieldEnd()
3643 
    oprot.writeFieldStop()
3644 
    oprot.writeStructEnd()
3645 
 
3646 
  def __repr__(self):
3647 
    L = ['%s=%r' % (key, value)
3648 
      for key, value in self.__dict__.iteritems()]
3649 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3650 
 
3651 
  def __eq__(self, other):
3652 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3653 
 
3654 
  def __ne__(self, other):
3655 
    return not (self == other)
3656 
 
559 chandransh 3657 
class removeAddressForUser_args:
94 ashish 3658 
  """
3659 
  Attributes:
559 chandransh 3660 
   - userid
3661 
   - addressId
94 ashish 3662 
  """
3663 
 
3664 
  thrift_spec = (
3665 
    None, # 0
559 chandransh 3666 
    (1, TType.I64, 'userid', None, None, ), # 1
3667 
    (2, TType.I64, 'addressId', None, None, ), # 2
94 ashish 3668 
  )
3669 
 
559 chandransh 3670 
  def __init__(self, userid=None, addressId=None,):
3671 
    self.userid = userid
3672 
    self.addressId = addressId
94 ashish 3673 
 
3674 
  def read(self, iprot):
3675 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3676 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3677 
      return
3678 
    iprot.readStructBegin()
3679 
    while True:
3680 
      (fname, ftype, fid) = iprot.readFieldBegin()
3681 
      if ftype == TType.STOP:
3682 
        break
3683 
      if fid == 1:
559 chandransh 3684 
        if ftype == TType.I64:
3685 
          self.userid = iprot.readI64();
94 ashish 3686 
        else:
3687 
          iprot.skip(ftype)
559 chandransh 3688 
      elif fid == 2:
3689 
        if ftype == TType.I64:
3690 
          self.addressId = iprot.readI64();
3691 
        else:
3692 
          iprot.skip(ftype)
94 ashish 3693 
      else:
3694 
        iprot.skip(ftype)
3695 
      iprot.readFieldEnd()
3696 
    iprot.readStructEnd()
3697 
 
3698 
  def write(self, oprot):
3699 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3700 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3701 
      return
559 chandransh 3702 
    oprot.writeStructBegin('removeAddressForUser_args')
3703 
    if self.userid != None:
3704 
      oprot.writeFieldBegin('userid', TType.I64, 1)
3705 
      oprot.writeI64(self.userid)
94 ashish 3706 
      oprot.writeFieldEnd()
559 chandransh 3707 
    if self.addressId != None:
3708 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
3709 
      oprot.writeI64(self.addressId)
3710 
      oprot.writeFieldEnd()
94 ashish 3711 
    oprot.writeFieldStop()
3712 
    oprot.writeStructEnd()
3713 
 
3714 
  def __repr__(self):
3715 
    L = ['%s=%r' % (key, value)
3716 
      for key, value in self.__dict__.iteritems()]
3717 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3718 
 
3719 
  def __eq__(self, other):
3720 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3721 
 
3722 
  def __ne__(self, other):
3723 
    return not (self == other)
3724 
 
559 chandransh 3725 
class removeAddressForUser_result:
94 ashish 3726 
  """
3727 
  Attributes:
3728 
   - success
3729 
   - ucx
3730 
  """
3731 
 
3732 
  thrift_spec = (
3733 
    (0, TType.BOOL, 'success', None, None, ), # 0
3734 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
3735 
  )
3736 
 
3737 
  def __init__(self, success=None, ucx=None,):
3738 
    self.success = success
3739 
    self.ucx = ucx
3740 
 
3741 
  def read(self, iprot):
3742 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3743 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3744 
      return
3745 
    iprot.readStructBegin()
3746 
    while True:
3747 
      (fname, ftype, fid) = iprot.readFieldBegin()
3748 
      if ftype == TType.STOP:
3749 
        break
3750 
      if fid == 0:
3751 
        if ftype == TType.BOOL:
3752 
          self.success = iprot.readBool();
3753 
        else:
3754 
          iprot.skip(ftype)
3755 
      elif fid == 1:
3756 
        if ftype == TType.STRUCT:
3757 
          self.ucx = UserContextException()
3758 
          self.ucx.read(iprot)
3759 
        else:
3760 
          iprot.skip(ftype)
3761 
      else:
3762 
        iprot.skip(ftype)
3763 
      iprot.readFieldEnd()
3764 
    iprot.readStructEnd()
3765 
 
3766 
  def write(self, oprot):
3767 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3768 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3769 
      return
559 chandransh 3770 
    oprot.writeStructBegin('removeAddressForUser_result')
94 ashish 3771 
    if self.success != None:
3772 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
3773 
      oprot.writeBool(self.success)
3774 
      oprot.writeFieldEnd()
3775 
    if self.ucx != None:
3776 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
3777 
      self.ucx.write(oprot)
3778 
      oprot.writeFieldEnd()
3779 
    oprot.writeFieldStop()
3780 
    oprot.writeStructEnd()
3781 
 
3782 
  def __repr__(self):
3783 
    L = ['%s=%r' % (key, value)
3784 
      for key, value in self.__dict__.iteritems()]
3785 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3786 
 
3787 
  def __eq__(self, other):
3788 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3789 
 
3790 
  def __ne__(self, other):
3791 
    return not (self == other)
3792 
 
559 chandransh 3793 
class setUserAsLoggedIn_args:
94 ashish 3794 
  """
3795 
  Attributes:
559 chandransh 3796 
   - userId
94 ashish 3797 
   - timestamp
3798 
  """
3799 
 
3800 
  thrift_spec = (
3801 
    None, # 0
559 chandransh 3802 
    (1, TType.I64, 'userId', None, None, ), # 1
94 ashish 3803 
    (2, TType.I64, 'timestamp', None, None, ), # 2
3804 
  )
3805 
 
559 chandransh 3806 
  def __init__(self, userId=None, timestamp=None,):
3807 
    self.userId = userId
94 ashish 3808 
    self.timestamp = timestamp
3809 
 
3810 
  def read(self, iprot):
3811 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3812 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3813 
      return
3814 
    iprot.readStructBegin()
3815 
    while True:
3816 
      (fname, ftype, fid) = iprot.readFieldBegin()
3817 
      if ftype == TType.STOP:
3818 
        break
3819 
      if fid == 1:
559 chandransh 3820 
        if ftype == TType.I64:
3821 
          self.userId = iprot.readI64();
94 ashish 3822 
        else:
3823 
          iprot.skip(ftype)
3824 
      elif fid == 2:
3825 
        if ftype == TType.I64:
3826 
          self.timestamp = iprot.readI64();
3827 
        else:
3828 
          iprot.skip(ftype)
3829 
      else:
3830 
        iprot.skip(ftype)
3831 
      iprot.readFieldEnd()
3832 
    iprot.readStructEnd()
3833 
 
3834 
  def write(self, oprot):
3835 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3836 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3837 
      return
559 chandransh 3838 
    oprot.writeStructBegin('setUserAsLoggedIn_args')
3839 
    if self.userId != None:
3840 
      oprot.writeFieldBegin('userId', TType.I64, 1)
3841 
      oprot.writeI64(self.userId)
94 ashish 3842 
      oprot.writeFieldEnd()
3843 
    if self.timestamp != None:
3844 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
3845 
      oprot.writeI64(self.timestamp)
3846 
      oprot.writeFieldEnd()
3847 
    oprot.writeFieldStop()
3848 
    oprot.writeStructEnd()
3849 
 
3850 
  def __repr__(self):
3851 
    L = ['%s=%r' % (key, value)
3852 
      for key, value in self.__dict__.iteritems()]
3853 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3854 
 
3855 
  def __eq__(self, other):
3856 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3857 
 
3858 
  def __ne__(self, other):
3859 
    return not (self == other)
3860 
 
559 chandransh 3861 
class setUserAsLoggedIn_result:
94 ashish 3862 
  """
3863 
  Attributes:
3864 
   - success
3865 
   - ucx
3866 
  """
3867 
 
3868 
  thrift_spec = (
3869 
    (0, TType.BOOL, 'success', None, None, ), # 0
3870 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
3871 
  )
3872 
 
3873 
  def __init__(self, success=None, ucx=None,):
3874 
    self.success = success
3875 
    self.ucx = ucx
3876 
 
3877 
  def read(self, iprot):
3878 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3879 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3880 
      return
3881 
    iprot.readStructBegin()
3882 
    while True:
3883 
      (fname, ftype, fid) = iprot.readFieldBegin()
3884 
      if ftype == TType.STOP:
3885 
        break
3886 
      if fid == 0:
3887 
        if ftype == TType.BOOL:
3888 
          self.success = iprot.readBool();
3889 
        else:
3890 
          iprot.skip(ftype)
3891 
      elif fid == 1:
3892 
        if ftype == TType.STRUCT:
3893 
          self.ucx = UserContextException()
3894 
          self.ucx.read(iprot)
3895 
        else:
3896 
          iprot.skip(ftype)
3897 
      else:
3898 
        iprot.skip(ftype)
3899 
      iprot.readFieldEnd()
3900 
    iprot.readStructEnd()
3901 
 
3902 
  def write(self, oprot):
3903 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3904 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3905 
      return
559 chandransh 3906 
    oprot.writeStructBegin('setUserAsLoggedIn_result')
94 ashish 3907 
    if self.success != None:
3908 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
3909 
      oprot.writeBool(self.success)
3910 
      oprot.writeFieldEnd()
3911 
    if self.ucx != None:
3912 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
3913 
      self.ucx.write(oprot)
3914 
      oprot.writeFieldEnd()
3915 
    oprot.writeFieldStop()
3916 
    oprot.writeStructEnd()
3917 
 
3918 
  def __repr__(self):
3919 
    L = ['%s=%r' % (key, value)
3920 
      for key, value in self.__dict__.iteritems()]
3921 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3922 
 
3923 
  def __eq__(self, other):
3924 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3925 
 
3926 
  def __ne__(self, other):
3927 
    return not (self == other)
3928 
 
559 chandransh 3929 
class setUserAsLoggedOut_args:
94 ashish 3930 
  """
3931 
  Attributes:
3932 
   - userid
3933 
   - timestamp
3934 
  """
3935 
 
3936 
  thrift_spec = (
3937 
    None, # 0
559 chandransh 3938 
    (1, TType.I64, 'userid', None, None, ), # 1
3939 
    (2, TType.I64, 'timestamp', None, None, ), # 2
94 ashish 3940 
  )
3941 
 
559 chandransh 3942 
  def __init__(self, userid=None, timestamp=None,):
94 ashish 3943 
    self.userid = userid
3944 
    self.timestamp = timestamp
3945 
 
3946 
  def read(self, iprot):
3947 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3948 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3949 
      return
3950 
    iprot.readStructBegin()
3951 
    while True:
3952 
      (fname, ftype, fid) = iprot.readFieldBegin()
3953 
      if ftype == TType.STOP:
3954 
        break
3955 
      if fid == 1:
3956 
        if ftype == TType.I64:
3957 
          self.userid = iprot.readI64();
3958 
        else:
3959 
          iprot.skip(ftype)
559 chandransh 3960 
      elif fid == 2:
94 ashish 3961 
        if ftype == TType.I64:
3962 
          self.timestamp = iprot.readI64();
3963 
        else:
3964 
          iprot.skip(ftype)
3965 
      else:
3966 
        iprot.skip(ftype)
3967 
      iprot.readFieldEnd()
3968 
    iprot.readStructEnd()
3969 
 
3970 
  def write(self, oprot):
3971 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3972 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3973 
      return
559 chandransh 3974 
    oprot.writeStructBegin('setUserAsLoggedOut_args')
94 ashish 3975 
    if self.userid != None:
559 chandransh 3976 
      oprot.writeFieldBegin('userid', TType.I64, 1)
94 ashish 3977 
      oprot.writeI64(self.userid)
3978 
      oprot.writeFieldEnd()
3979 
    if self.timestamp != None:
559 chandransh 3980 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
94 ashish 3981 
      oprot.writeI64(self.timestamp)
3982 
      oprot.writeFieldEnd()
3983 
    oprot.writeFieldStop()
3984 
    oprot.writeStructEnd()
3985 
 
3986 
  def __repr__(self):
3987 
    L = ['%s=%r' % (key, value)
3988 
      for key, value in self.__dict__.iteritems()]
3989 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3990 
 
3991 
  def __eq__(self, other):
3992 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3993 
 
3994 
  def __ne__(self, other):
3995 
    return not (self == other)
3996 
 
559 chandransh 3997 
class setUserAsLoggedOut_result:
94 ashish 3998 
  """
3999 
  Attributes:
4000 
   - success
4001 
   - ucx
4002 
  """
4003 
 
4004 
  thrift_spec = (
4005 
    (0, TType.BOOL, 'success', None, None, ), # 0
4006 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
4007 
  )
4008 
 
4009 
  def __init__(self, success=None, ucx=None,):
4010 
    self.success = success
4011 
    self.ucx = ucx
4012 
 
4013 
  def read(self, iprot):
4014 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4015 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4016 
      return
4017 
    iprot.readStructBegin()
4018 
    while True:
4019 
      (fname, ftype, fid) = iprot.readFieldBegin()
4020 
      if ftype == TType.STOP:
4021 
        break
4022 
      if fid == 0:
4023 
        if ftype == TType.BOOL:
4024 
          self.success = iprot.readBool();
4025 
        else:
4026 
          iprot.skip(ftype)
4027 
      elif fid == 1:
4028 
        if ftype == TType.STRUCT:
4029 
          self.ucx = UserContextException()
4030 
          self.ucx.read(iprot)
4031 
        else:
4032 
          iprot.skip(ftype)
4033 
      else:
4034 
        iprot.skip(ftype)
4035 
      iprot.readFieldEnd()
4036 
    iprot.readStructEnd()
4037 
 
4038 
  def write(self, oprot):
4039 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4040 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4041 
      return
559 chandransh 4042 
    oprot.writeStructBegin('setUserAsLoggedOut_result')
94 ashish 4043 
    if self.success != None:
4044 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
4045 
      oprot.writeBool(self.success)
4046 
      oprot.writeFieldEnd()
4047 
    if self.ucx != None:
4048 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
4049 
      self.ucx.write(oprot)
4050 
      oprot.writeFieldEnd()
4051 
    oprot.writeFieldStop()
4052 
    oprot.writeStructEnd()
4053 
 
4054 
  def __repr__(self):
4055 
    L = ['%s=%r' % (key, value)
4056 
      for key, value in self.__dict__.iteritems()]
4057 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4058 
 
4059 
  def __eq__(self, other):
4060 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4061 
 
4062 
  def __ne__(self, other):
4063 
    return not (self == other)
4064 
 
559 chandransh 4065 
class setDefaultAddress_args:
94 ashish 4066 
  """
4067 
  Attributes:
4068 
   - userid
4069 
   - addressId
4070 
  """
4071 
 
4072 
  thrift_spec = (
4073 
    None, # 0
4074 
    (1, TType.I64, 'userid', None, None, ), # 1
4075 
    (2, TType.I64, 'addressId', None, None, ), # 2
4076 
  )
4077 
 
4078 
  def __init__(self, userid=None, addressId=None,):
4079 
    self.userid = userid
4080 
    self.addressId = addressId
4081 
 
4082 
  def read(self, iprot):
4083 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4084 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4085 
      return
4086 
    iprot.readStructBegin()
4087 
    while True:
4088 
      (fname, ftype, fid) = iprot.readFieldBegin()
4089 
      if ftype == TType.STOP:
4090 
        break
4091 
      if fid == 1:
4092 
        if ftype == TType.I64:
4093 
          self.userid = iprot.readI64();
4094 
        else:
4095 
          iprot.skip(ftype)
4096 
      elif fid == 2:
4097 
        if ftype == TType.I64:
4098 
          self.addressId = iprot.readI64();
4099 
        else:
4100 
          iprot.skip(ftype)
4101 
      else:
4102 
        iprot.skip(ftype)
4103 
      iprot.readFieldEnd()
4104 
    iprot.readStructEnd()
4105 
 
4106 
  def write(self, oprot):
4107 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4108 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4109 
      return
559 chandransh 4110 
    oprot.writeStructBegin('setDefaultAddress_args')
94 ashish 4111 
    if self.userid != None:
4112 
      oprot.writeFieldBegin('userid', TType.I64, 1)
4113 
      oprot.writeI64(self.userid)
4114 
      oprot.writeFieldEnd()
4115 
    if self.addressId != None:
4116 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
4117 
      oprot.writeI64(self.addressId)
4118 
      oprot.writeFieldEnd()
4119 
    oprot.writeFieldStop()
4120 
    oprot.writeStructEnd()
4121 
 
4122 
  def __repr__(self):
4123 
    L = ['%s=%r' % (key, value)
4124 
      for key, value in self.__dict__.iteritems()]
4125 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4126 
 
4127 
  def __eq__(self, other):
4128 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4129 
 
4130 
  def __ne__(self, other):
4131 
    return not (self == other)
4132 
 
559 chandransh 4133 
class setDefaultAddress_result:
94 ashish 4134 
  """
4135 
  Attributes:
4136 
   - success
4137 
   - ucx
4138 
  """
4139 
 
4140 
  thrift_spec = (
4141 
    (0, TType.BOOL, 'success', None, None, ), # 0
4142 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
4143 
  )
4144 
 
4145 
  def __init__(self, success=None, ucx=None,):
4146 
    self.success = success
4147 
    self.ucx = ucx
4148 
 
4149 
  def read(self, iprot):
4150 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4151 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4152 
      return
4153 
    iprot.readStructBegin()
4154 
    while True:
4155 
      (fname, ftype, fid) = iprot.readFieldBegin()
4156 
      if ftype == TType.STOP:
4157 
        break
4158 
      if fid == 0:
4159 
        if ftype == TType.BOOL:
4160 
          self.success = iprot.readBool();
4161 
        else:
4162 
          iprot.skip(ftype)
4163 
      elif fid == 1:
4164 
        if ftype == TType.STRUCT:
4165 
          self.ucx = UserContextException()
4166 
          self.ucx.read(iprot)
4167 
        else:
4168 
          iprot.skip(ftype)
4169 
      else:
4170 
        iprot.skip(ftype)
4171 
      iprot.readFieldEnd()
4172 
    iprot.readStructEnd()
4173 
 
4174 
  def write(self, oprot):
4175 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4176 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4177 
      return
559 chandransh 4178 
    oprot.writeStructBegin('setDefaultAddress_result')
94 ashish 4179 
    if self.success != None:
4180 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
4181 
      oprot.writeBool(self.success)
4182 
      oprot.writeFieldEnd()
4183 
    if self.ucx != None:
4184 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
4185 
      self.ucx.write(oprot)
4186 
      oprot.writeFieldEnd()
4187 
    oprot.writeFieldStop()
4188 
    oprot.writeStructEnd()
4189 
 
4190 
  def __repr__(self):
4191 
    L = ['%s=%r' % (key, value)
4192 
      for key, value in self.__dict__.iteritems()]
4193 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4194 
 
4195 
  def __eq__(self, other):
4196 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4197 
 
4198 
  def __ne__(self, other):
4199 
    return not (self == other)
4200 
 
559 chandransh 4201 
class updatePassword_args:
94 ashish 4202 
  """
4203 
  Attributes:
559 chandransh 4204 
   - userid
4205 
   - password
94 ashish 4206 
  """
4207 
 
4208 
  thrift_spec = (
4209 
    None, # 0
559 chandransh 4210 
    (1, TType.I64, 'userid', None, None, ), # 1
4211 
    (2, TType.STRING, 'password', None, None, ), # 2
94 ashish 4212 
  )
4213 
 
559 chandransh 4214 
  def __init__(self, userid=None, password=None,):
4215 
    self.userid = userid
4216 
    self.password = password
94 ashish 4217 
 
4218 
  def read(self, iprot):
4219 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4220 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4221 
      return
4222 
    iprot.readStructBegin()
4223 
    while True:
4224 
      (fname, ftype, fid) = iprot.readFieldBegin()
4225 
      if ftype == TType.STOP:
4226 
        break
4227 
      if fid == 1:
4228 
        if ftype == TType.I64:
559 chandransh 4229 
          self.userid = iprot.readI64();
94 ashish 4230 
        else:
4231 
          iprot.skip(ftype)
4232 
      elif fid == 2:
559 chandransh 4233 
        if ftype == TType.STRING:
4234 
          self.password = iprot.readString();
94 ashish 4235 
        else:
4236 
          iprot.skip(ftype)
4237 
      else:
4238 
        iprot.skip(ftype)
4239 
      iprot.readFieldEnd()
4240 
    iprot.readStructEnd()
4241 
 
4242 
  def write(self, oprot):
4243 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4244 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4245 
      return
559 chandransh 4246 
    oprot.writeStructBegin('updatePassword_args')
4247 
    if self.userid != None:
4248 
      oprot.writeFieldBegin('userid', TType.I64, 1)
4249 
      oprot.writeI64(self.userid)
94 ashish 4250 
      oprot.writeFieldEnd()
559 chandransh 4251 
    if self.password != None:
4252 
      oprot.writeFieldBegin('password', TType.STRING, 2)
4253 
      oprot.writeString(self.password)
94 ashish 4254 
      oprot.writeFieldEnd()
4255 
    oprot.writeFieldStop()
4256 
    oprot.writeStructEnd()
4257 
 
4258 
  def __repr__(self):
4259 
    L = ['%s=%r' % (key, value)
4260 
      for key, value in self.__dict__.iteritems()]
4261 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4262 
 
4263 
  def __eq__(self, other):
4264 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4265 
 
4266 
  def __ne__(self, other):
4267 
    return not (self == other)
4268 
 
559 chandransh 4269 
class updatePassword_result:
94 ashish 4270 
  """
4271 
  Attributes:
4272 
   - success
4273 
   - ucx
4274 
  """
4275 
 
4276 
  thrift_spec = (
4277 
    (0, TType.BOOL, 'success', None, None, ), # 0
4278 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
4279 
  )
4280 
 
4281 
  def __init__(self, success=None, ucx=None,):
4282 
    self.success = success
4283 
    self.ucx = ucx
4284 
 
4285 
  def read(self, iprot):
4286 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4287 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4288 
      return
4289 
    iprot.readStructBegin()
4290 
    while True:
4291 
      (fname, ftype, fid) = iprot.readFieldBegin()
4292 
      if ftype == TType.STOP:
4293 
        break
4294 
      if fid == 0:
4295 
        if ftype == TType.BOOL:
4296 
          self.success = iprot.readBool();
4297 
        else:
4298 
          iprot.skip(ftype)
4299 
      elif fid == 1:
4300 
        if ftype == TType.STRUCT:
4301 
          self.ucx = UserContextException()
4302 
          self.ucx.read(iprot)
4303 
        else:
4304 
          iprot.skip(ftype)
4305 
      else:
4306 
        iprot.skip(ftype)
4307 
      iprot.readFieldEnd()
4308 
    iprot.readStructEnd()
4309 
 
4310 
  def write(self, oprot):
4311 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4312 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4313 
      return
559 chandransh 4314 
    oprot.writeStructBegin('updatePassword_result')
94 ashish 4315 
    if self.success != None:
4316 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
4317 
      oprot.writeBool(self.success)
4318 
      oprot.writeFieldEnd()
4319 
    if self.ucx != None:
4320 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
4321 
      self.ucx.write(oprot)
4322 
      oprot.writeFieldEnd()
4323 
    oprot.writeFieldStop()
4324 
    oprot.writeStructEnd()
4325 
 
4326 
  def __repr__(self):
4327 
    L = ['%s=%r' % (key, value)
4328 
      for key, value in self.__dict__.iteritems()]
4329 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4330 
 
4331 
  def __eq__(self, other):
4332 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4333 
 
4334 
  def __ne__(self, other):
4335 
    return not (self == other)
4336 
 
581 rajveer 4337 
class forgotPassword_args:
4338 
  """
4339 
  Attributes:
4340 
   - email
4341 
  """
4342 
 
4343 
  thrift_spec = (
4344 
    None, # 0
4345 
    (1, TType.STRING, 'email', None, None, ), # 1
4346 
  )
4347 
 
4348 
  def __init__(self, email=None,):
4349 
    self.email = email
4350 
 
4351 
  def read(self, iprot):
4352 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4353 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4354 
      return
4355 
    iprot.readStructBegin()
4356 
    while True:
4357 
      (fname, ftype, fid) = iprot.readFieldBegin()
4358 
      if ftype == TType.STOP:
4359 
        break
4360 
      if fid == 1:
4361 
        if ftype == TType.STRING:
4362 
          self.email = iprot.readString();
4363 
        else:
4364 
          iprot.skip(ftype)
4365 
      else:
4366 
        iprot.skip(ftype)
4367 
      iprot.readFieldEnd()
4368 
    iprot.readStructEnd()
4369 
 
4370 
  def write(self, oprot):
4371 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4372 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4373 
      return
4374 
    oprot.writeStructBegin('forgotPassword_args')
4375 
    if self.email != None:
4376 
      oprot.writeFieldBegin('email', TType.STRING, 1)
4377 
      oprot.writeString(self.email)
4378 
      oprot.writeFieldEnd()
4379 
    oprot.writeFieldStop()
4380 
    oprot.writeStructEnd()
4381 
 
4382 
  def __repr__(self):
4383 
    L = ['%s=%r' % (key, value)
4384 
      for key, value in self.__dict__.iteritems()]
4385 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4386 
 
4387 
  def __eq__(self, other):
4388 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4389 
 
4390 
  def __ne__(self, other):
4391 
    return not (self == other)
4392 
 
4393 
class forgotPassword_result:
4394 
  """
4395 
  Attributes:
4396 
   - success
4397 
   - ucx
4398 
  """
4399 
 
4400 
  thrift_spec = (
4401 
    (0, TType.BOOL, 'success', None, None, ), # 0
4402 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
4403 
  )
4404 
 
4405 
  def __init__(self, success=None, ucx=None,):
4406 
    self.success = success
4407 
    self.ucx = ucx
4408 
 
4409 
  def read(self, iprot):
4410 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4411 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4412 
      return
4413 
    iprot.readStructBegin()
4414 
    while True:
4415 
      (fname, ftype, fid) = iprot.readFieldBegin()
4416 
      if ftype == TType.STOP:
4417 
        break
4418 
      if fid == 0:
4419 
        if ftype == TType.BOOL:
4420 
          self.success = iprot.readBool();
4421 
        else:
4422 
          iprot.skip(ftype)
4423 
      elif fid == 1:
4424 
        if ftype == TType.STRUCT:
4425 
          self.ucx = UserContextException()
4426 
          self.ucx.read(iprot)
4427 
        else:
4428 
          iprot.skip(ftype)
4429 
      else:
4430 
        iprot.skip(ftype)
4431 
      iprot.readFieldEnd()
4432 
    iprot.readStructEnd()
4433 
 
4434 
  def write(self, oprot):
4435 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4436 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4437 
      return
4438 
    oprot.writeStructBegin('forgotPassword_result')
4439 
    if self.success != None:
4440 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
4441 
      oprot.writeBool(self.success)
4442 
      oprot.writeFieldEnd()
4443 
    if self.ucx != None:
4444 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
4445 
      self.ucx.write(oprot)
4446 
      oprot.writeFieldEnd()
4447 
    oprot.writeFieldStop()
4448 
    oprot.writeStructEnd()
4449 
 
4450 
  def __repr__(self):
4451 
    L = ['%s=%r' % (key, value)
4452 
      for key, value in self.__dict__.iteritems()]
4453 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4454 
 
4455 
  def __eq__(self, other):
4456 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4457 
 
4458 
  def __ne__(self, other):
4459 
    return not (self == other)
4460 
 
559 chandransh 4461 
class createCart_args:
94 ashish 4462 
  """
4463 
  Attributes:
559 chandransh 4464 
   - userId
94 ashish 4465 
  """
4466 
 
4467 
  thrift_spec = (
4468 
    None, # 0
559 chandransh 4469 
    (1, TType.I64, 'userId', None, None, ), # 1
94 ashish 4470 
  )
4471 
 
559 chandransh 4472 
  def __init__(self, userId=None,):
4473 
    self.userId = userId
94 ashish 4474 
 
4475 
  def read(self, iprot):
4476 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4477 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4478 
      return
4479 
    iprot.readStructBegin()
4480 
    while True:
4481 
      (fname, ftype, fid) = iprot.readFieldBegin()
4482 
      if ftype == TType.STOP:
4483 
        break
4484 
      if fid == 1:
4485 
        if ftype == TType.I64:
559 chandransh 4486 
          self.userId = iprot.readI64();
94 ashish 4487 
        else:
4488 
          iprot.skip(ftype)
559 chandransh 4489 
      else:
4490 
        iprot.skip(ftype)
4491 
      iprot.readFieldEnd()
4492 
    iprot.readStructEnd()
4493 
 
4494 
  def write(self, oprot):
4495 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4496 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4497 
      return
4498 
    oprot.writeStructBegin('createCart_args')
4499 
    if self.userId != None:
4500 
      oprot.writeFieldBegin('userId', TType.I64, 1)
4501 
      oprot.writeI64(self.userId)
4502 
      oprot.writeFieldEnd()
4503 
    oprot.writeFieldStop()
4504 
    oprot.writeStructEnd()
4505 
 
4506 
  def __repr__(self):
4507 
    L = ['%s=%r' % (key, value)
4508 
      for key, value in self.__dict__.iteritems()]
4509 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4510 
 
4511 
  def __eq__(self, other):
4512 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4513 
 
4514 
  def __ne__(self, other):
4515 
    return not (self == other)
4516 
 
4517 
class createCart_result:
4518 
  """
4519 
  Attributes:
4520 
   - success
4521 
   - scx
4522 
  """
4523 
 
4524 
  thrift_spec = (
4525 
    (0, TType.I64, 'success', None, None, ), # 0
4526 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
4527 
  )
4528 
 
4529 
  def __init__(self, success=None, scx=None,):
4530 
    self.success = success
4531 
    self.scx = scx
4532 
 
4533 
  def read(self, iprot):
4534 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4535 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4536 
      return
4537 
    iprot.readStructBegin()
4538 
    while True:
4539 
      (fname, ftype, fid) = iprot.readFieldBegin()
4540 
      if ftype == TType.STOP:
4541 
        break
4542 
      if fid == 0:
94 ashish 4543 
        if ftype == TType.I64:
559 chandransh 4544 
          self.success = iprot.readI64();
94 ashish 4545 
        else:
4546 
          iprot.skip(ftype)
559 chandransh 4547 
      elif fid == 1:
4548 
        if ftype == TType.STRUCT:
4549 
          self.scx = ShoppingCartException()
4550 
          self.scx.read(iprot)
4551 
        else:
4552 
          iprot.skip(ftype)
94 ashish 4553 
      else:
4554 
        iprot.skip(ftype)
4555 
      iprot.readFieldEnd()
4556 
    iprot.readStructEnd()
4557 
 
4558 
  def write(self, oprot):
4559 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4560 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4561 
      return
559 chandransh 4562 
    oprot.writeStructBegin('createCart_result')
4563 
    if self.success != None:
4564 
      oprot.writeFieldBegin('success', TType.I64, 0)
4565 
      oprot.writeI64(self.success)
94 ashish 4566 
      oprot.writeFieldEnd()
559 chandransh 4567 
    if self.scx != None:
4568 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
4569 
      self.scx.write(oprot)
94 ashish 4570 
      oprot.writeFieldEnd()
4571 
    oprot.writeFieldStop()
4572 
    oprot.writeStructEnd()
4573 
 
4574 
  def __repr__(self):
4575 
    L = ['%s=%r' % (key, value)
4576 
      for key, value in self.__dict__.iteritems()]
4577 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4578 
 
4579 
  def __eq__(self, other):
4580 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4581 
 
4582 
  def __ne__(self, other):
4583 
    return not (self == other)
4584 
 
559 chandransh 4585 
class getCurrentCart_args:
94 ashish 4586 
  """
4587 
  Attributes:
559 chandransh 4588 
   - userId
4589 
  """
4590 
 
4591 
  thrift_spec = (
4592 
    None, # 0
4593 
    (1, TType.I64, 'userId', None, None, ), # 1
4594 
  )
4595 
 
4596 
  def __init__(self, userId=None,):
4597 
    self.userId = userId
4598 
 
4599 
  def read(self, iprot):
4600 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4601 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4602 
      return
4603 
    iprot.readStructBegin()
4604 
    while True:
4605 
      (fname, ftype, fid) = iprot.readFieldBegin()
4606 
      if ftype == TType.STOP:
4607 
        break
4608 
      if fid == 1:
4609 
        if ftype == TType.I64:
4610 
          self.userId = iprot.readI64();
4611 
        else:
4612 
          iprot.skip(ftype)
4613 
      else:
4614 
        iprot.skip(ftype)
4615 
      iprot.readFieldEnd()
4616 
    iprot.readStructEnd()
4617 
 
4618 
  def write(self, oprot):
4619 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4620 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4621 
      return
4622 
    oprot.writeStructBegin('getCurrentCart_args')
4623 
    if self.userId != None:
4624 
      oprot.writeFieldBegin('userId', TType.I64, 1)
4625 
      oprot.writeI64(self.userId)
4626 
      oprot.writeFieldEnd()
4627 
    oprot.writeFieldStop()
4628 
    oprot.writeStructEnd()
4629 
 
4630 
  def __repr__(self):
4631 
    L = ['%s=%r' % (key, value)
4632 
      for key, value in self.__dict__.iteritems()]
4633 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4634 
 
4635 
  def __eq__(self, other):
4636 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4637 
 
4638 
  def __ne__(self, other):
4639 
    return not (self == other)
4640 
 
4641 
class getCurrentCart_result:
4642 
  """
4643 
  Attributes:
94 ashish 4644 
   - success
559 chandransh 4645 
   - scx
94 ashish 4646 
  """
4647 
 
4648 
  thrift_spec = (
559 chandransh 4649 
    (0, TType.STRUCT, 'success', (Cart, Cart.thrift_spec), None, ), # 0
4650 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 4651 
  )
4652 
 
559 chandransh 4653 
  def __init__(self, success=None, scx=None,):
94 ashish 4654 
    self.success = success
559 chandransh 4655 
    self.scx = scx
94 ashish 4656 
 
4657 
  def read(self, iprot):
4658 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4659 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4660 
      return
4661 
    iprot.readStructBegin()
4662 
    while True:
4663 
      (fname, ftype, fid) = iprot.readFieldBegin()
4664 
      if ftype == TType.STOP:
4665 
        break
4666 
      if fid == 0:
559 chandransh 4667 
        if ftype == TType.STRUCT:
4668 
          self.success = Cart()
4669 
          self.success.read(iprot)
94 ashish 4670 
        else:
4671 
          iprot.skip(ftype)
4672 
      elif fid == 1:
4673 
        if ftype == TType.STRUCT:
559 chandransh 4674 
          self.scx = ShoppingCartException()
4675 
          self.scx.read(iprot)
94 ashish 4676 
        else:
4677 
          iprot.skip(ftype)
4678 
      else:
4679 
        iprot.skip(ftype)
4680 
      iprot.readFieldEnd()
4681 
    iprot.readStructEnd()
4682 
 
4683 
  def write(self, oprot):
4684 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4685 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4686 
      return
559 chandransh 4687 
    oprot.writeStructBegin('getCurrentCart_result')
94 ashish 4688 
    if self.success != None:
559 chandransh 4689 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
4690 
      self.success.write(oprot)
94 ashish 4691 
      oprot.writeFieldEnd()
559 chandransh 4692 
    if self.scx != None:
4693 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
4694 
      self.scx.write(oprot)
94 ashish 4695 
      oprot.writeFieldEnd()
4696 
    oprot.writeFieldStop()
4697 
    oprot.writeStructEnd()
4698 
 
4699 
  def __repr__(self):
4700 
    L = ['%s=%r' % (key, value)
4701 
      for key, value in self.__dict__.iteritems()]
4702 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4703 
 
4704 
  def __eq__(self, other):
4705 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4706 
 
4707 
  def __ne__(self, other):
4708 
    return not (self == other)
4709 
 
559 chandransh 4710 
class getCart_args:
504 rajveer 4711 
  """
4712 
  Attributes:
559 chandransh 4713 
   - cartId
504 rajveer 4714 
  """
4715 
 
4716 
  thrift_spec = (
4717 
    None, # 0
559 chandransh 4718 
    (1, TType.I64, 'cartId', None, None, ), # 1
504 rajveer 4719 
  )
4720 
 
559 chandransh 4721 
  def __init__(self, cartId=None,):
4722 
    self.cartId = cartId
504 rajveer 4723 
 
4724 
  def read(self, iprot):
4725 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4726 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4727 
      return
4728 
    iprot.readStructBegin()
4729 
    while True:
4730 
      (fname, ftype, fid) = iprot.readFieldBegin()
4731 
      if ftype == TType.STOP:
4732 
        break
4733 
      if fid == 1:
4734 
        if ftype == TType.I64:
559 chandransh 4735 
          self.cartId = iprot.readI64();
504 rajveer 4736 
        else:
4737 
          iprot.skip(ftype)
4738 
      else:
4739 
        iprot.skip(ftype)
4740 
      iprot.readFieldEnd()
4741 
    iprot.readStructEnd()
4742 
 
4743 
  def write(self, oprot):
4744 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4745 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4746 
      return
559 chandransh 4747 
    oprot.writeStructBegin('getCart_args')
4748 
    if self.cartId != None:
4749 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
4750 
      oprot.writeI64(self.cartId)
504 rajveer 4751 
      oprot.writeFieldEnd()
4752 
    oprot.writeFieldStop()
4753 
    oprot.writeStructEnd()
4754 
 
4755 
  def __repr__(self):
4756 
    L = ['%s=%r' % (key, value)
4757 
      for key, value in self.__dict__.iteritems()]
4758 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4759 
 
4760 
  def __eq__(self, other):
4761 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4762 
 
4763 
  def __ne__(self, other):
4764 
    return not (self == other)
4765 
 
559 chandransh 4766 
class getCart_result:
504 rajveer 4767 
  """
4768 
  Attributes:
4769 
   - success
559 chandransh 4770 
   - scx
504 rajveer 4771 
  """
4772 
 
4773 
  thrift_spec = (
559 chandransh 4774 
    (0, TType.STRUCT, 'success', (Cart, Cart.thrift_spec), None, ), # 0
4775 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
504 rajveer 4776 
  )
4777 
 
559 chandransh 4778 
  def __init__(self, success=None, scx=None,):
504 rajveer 4779 
    self.success = success
559 chandransh 4780 
    self.scx = scx
504 rajveer 4781 
 
4782 
  def read(self, iprot):
4783 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4784 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4785 
      return
4786 
    iprot.readStructBegin()
4787 
    while True:
4788 
      (fname, ftype, fid) = iprot.readFieldBegin()
4789 
      if ftype == TType.STOP:
4790 
        break
4791 
      if fid == 0:
559 chandransh 4792 
        if ftype == TType.STRUCT:
4793 
          self.success = Cart()
4794 
          self.success.read(iprot)
504 rajveer 4795 
        else:
4796 
          iprot.skip(ftype)
4797 
      elif fid == 1:
4798 
        if ftype == TType.STRUCT:
559 chandransh 4799 
          self.scx = ShoppingCartException()
4800 
          self.scx.read(iprot)
504 rajveer 4801 
        else:
4802 
          iprot.skip(ftype)
4803 
      else:
4804 
        iprot.skip(ftype)
4805 
      iprot.readFieldEnd()
4806 
    iprot.readStructEnd()
4807 
 
4808 
  def write(self, oprot):
4809 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4810 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4811 
      return
559 chandransh 4812 
    oprot.writeStructBegin('getCart_result')
504 rajveer 4813 
    if self.success != None:
559 chandransh 4814 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
4815 
      self.success.write(oprot)
504 rajveer 4816 
      oprot.writeFieldEnd()
559 chandransh 4817 
    if self.scx != None:
4818 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
4819 
      self.scx.write(oprot)
504 rajveer 4820 
      oprot.writeFieldEnd()
4821 
    oprot.writeFieldStop()
4822 
    oprot.writeStructEnd()
4823 
 
4824 
  def __repr__(self):
4825 
    L = ['%s=%r' % (key, value)
4826 
      for key, value in self.__dict__.iteritems()]
4827 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4828 
 
4829 
  def __eq__(self, other):
4830 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4831 
 
4832 
  def __ne__(self, other):
4833 
    return not (self == other)
4834 
 
559 chandransh 4835 
class getCartsForUser_args:
94 ashish 4836 
  """
4837 
  Attributes:
559 chandransh 4838 
   - userId
4839 
   - status
94 ashish 4840 
  """
4841 
 
4842 
  thrift_spec = (
4843 
    None, # 0
559 chandransh 4844 
    (1, TType.I64, 'userId', None, None, ), # 1
4845 
    (2, TType.I32, 'status', None, None, ), # 2
94 ashish 4846 
  )
4847 
 
559 chandransh 4848 
  def __init__(self, userId=None, status=None,):
4849 
    self.userId = userId
4850 
    self.status = status
94 ashish 4851 
 
4852 
  def read(self, iprot):
4853 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4854 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4855 
      return
4856 
    iprot.readStructBegin()
4857 
    while True:
4858 
      (fname, ftype, fid) = iprot.readFieldBegin()
4859 
      if ftype == TType.STOP:
4860 
        break
4861 
      if fid == 1:
4862 
        if ftype == TType.I64:
559 chandransh 4863 
          self.userId = iprot.readI64();
94 ashish 4864 
        else:
4865 
          iprot.skip(ftype)
4866 
      elif fid == 2:
559 chandransh 4867 
        if ftype == TType.I32:
4868 
          self.status = iprot.readI32();
94 ashish 4869 
        else:
4870 
          iprot.skip(ftype)
4871 
      else:
4872 
        iprot.skip(ftype)
4873 
      iprot.readFieldEnd()
4874 
    iprot.readStructEnd()
4875 
 
4876 
  def write(self, oprot):
4877 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4878 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4879 
      return
559 chandransh 4880 
    oprot.writeStructBegin('getCartsForUser_args')
4881 
    if self.userId != None:
4882 
      oprot.writeFieldBegin('userId', TType.I64, 1)
4883 
      oprot.writeI64(self.userId)
94 ashish 4884 
      oprot.writeFieldEnd()
559 chandransh 4885 
    if self.status != None:
4886 
      oprot.writeFieldBegin('status', TType.I32, 2)
4887 
      oprot.writeI32(self.status)
94 ashish 4888 
      oprot.writeFieldEnd()
4889 
    oprot.writeFieldStop()
4890 
    oprot.writeStructEnd()
4891 
 
4892 
  def __repr__(self):
4893 
    L = ['%s=%r' % (key, value)
4894 
      for key, value in self.__dict__.iteritems()]
4895 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4896 
 
4897 
  def __eq__(self, other):
4898 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4899 
 
4900 
  def __ne__(self, other):
4901 
    return not (self == other)
4902 
 
559 chandransh 4903 
class getCartsForUser_result:
94 ashish 4904 
  """
4905 
  Attributes:
4906 
   - success
559 chandransh 4907 
   - scx
94 ashish 4908 
  """
4909 
 
4910 
  thrift_spec = (
559 chandransh 4911 
    (0, TType.LIST, 'success', (TType.STRUCT,(Cart, Cart.thrift_spec)), None, ), # 0
4912 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 4913 
  )
4914 
 
559 chandransh 4915 
  def __init__(self, success=None, scx=None,):
94 ashish 4916 
    self.success = success
559 chandransh 4917 
    self.scx = scx
94 ashish 4918 
 
4919 
  def read(self, iprot):
4920 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4921 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4922 
      return
4923 
    iprot.readStructBegin()
4924 
    while True:
4925 
      (fname, ftype, fid) = iprot.readFieldBegin()
4926 
      if ftype == TType.STOP:
4927 
        break
4928 
      if fid == 0:
559 chandransh 4929 
        if ftype == TType.LIST:
4930 
          self.success = []
567 rajveer 4931 
          (_etype40, _size37) = iprot.readListBegin()
4932 
          for _i41 in xrange(_size37):
4933 
            _elem42 = Cart()
4934 
            _elem42.read(iprot)
4935 
            self.success.append(_elem42)
559 chandransh 4936 
          iprot.readListEnd()
94 ashish 4937 
        else:
4938 
          iprot.skip(ftype)
4939 
      elif fid == 1:
4940 
        if ftype == TType.STRUCT:
559 chandransh 4941 
          self.scx = ShoppingCartException()
4942 
          self.scx.read(iprot)
94 ashish 4943 
        else:
4944 
          iprot.skip(ftype)
4945 
      else:
4946 
        iprot.skip(ftype)
4947 
      iprot.readFieldEnd()
4948 
    iprot.readStructEnd()
4949 
 
4950 
  def write(self, oprot):
4951 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4952 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4953 
      return
559 chandransh 4954 
    oprot.writeStructBegin('getCartsForUser_result')
94 ashish 4955 
    if self.success != None:
559 chandransh 4956 
      oprot.writeFieldBegin('success', TType.LIST, 0)
4957 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
567 rajveer 4958 
      for iter43 in self.success:
4959 
        iter43.write(oprot)
559 chandransh 4960 
      oprot.writeListEnd()
94 ashish 4961 
      oprot.writeFieldEnd()
559 chandransh 4962 
    if self.scx != None:
4963 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
4964 
      self.scx.write(oprot)
94 ashish 4965 
      oprot.writeFieldEnd()
4966 
    oprot.writeFieldStop()
4967 
    oprot.writeStructEnd()
4968 
 
4969 
  def __repr__(self):
4970 
    L = ['%s=%r' % (key, value)
4971 
      for key, value in self.__dict__.iteritems()]
4972 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4973 
 
4974 
  def __eq__(self, other):
4975 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4976 
 
4977 
  def __ne__(self, other):
4978 
    return not (self == other)
4979 
 
559 chandransh 4980 
class getCartsByStatus_args:
94 ashish 4981 
  """
4982 
  Attributes:
559 chandransh 4983 
   - status
94 ashish 4984 
  """
4985 
 
4986 
  thrift_spec = (
4987 
    None, # 0
559 chandransh 4988 
    (1, TType.I32, 'status', None, None, ), # 1
94 ashish 4989 
  )
4990 
 
559 chandransh 4991 
  def __init__(self, status=None,):
4992 
    self.status = status
94 ashish 4993 
 
4994 
  def read(self, iprot):
4995 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4996 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4997 
      return
4998 
    iprot.readStructBegin()
4999 
    while True:
5000 
      (fname, ftype, fid) = iprot.readFieldBegin()
5001 
      if ftype == TType.STOP:
5002 
        break
5003 
      if fid == 1:
559 chandransh 5004 
        if ftype == TType.I32:
5005 
          self.status = iprot.readI32();
5006 
        else:
5007 
          iprot.skip(ftype)
5008 
      else:
5009 
        iprot.skip(ftype)
5010 
      iprot.readFieldEnd()
5011 
    iprot.readStructEnd()
5012 
 
5013 
  def write(self, oprot):
5014 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5015 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5016 
      return
5017 
    oprot.writeStructBegin('getCartsByStatus_args')
5018 
    if self.status != None:
5019 
      oprot.writeFieldBegin('status', TType.I32, 1)
5020 
      oprot.writeI32(self.status)
5021 
      oprot.writeFieldEnd()
5022 
    oprot.writeFieldStop()
5023 
    oprot.writeStructEnd()
5024 
 
5025 
  def __repr__(self):
5026 
    L = ['%s=%r' % (key, value)
5027 
      for key, value in self.__dict__.iteritems()]
5028 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5029 
 
5030 
  def __eq__(self, other):
5031 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5032 
 
5033 
  def __ne__(self, other):
5034 
    return not (self == other)
5035 
 
5036 
class getCartsByStatus_result:
5037 
  """
5038 
  Attributes:
5039 
   - success
5040 
   - scx
5041 
  """
5042 
 
5043 
  thrift_spec = (
5044 
    (0, TType.LIST, 'success', (TType.STRUCT,(Cart, Cart.thrift_spec)), None, ), # 0
5045 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
5046 
  )
5047 
 
5048 
  def __init__(self, success=None, scx=None,):
5049 
    self.success = success
5050 
    self.scx = scx
5051 
 
5052 
  def read(self, iprot):
5053 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5054 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5055 
      return
5056 
    iprot.readStructBegin()
5057 
    while True:
5058 
      (fname, ftype, fid) = iprot.readFieldBegin()
5059 
      if ftype == TType.STOP:
5060 
        break
5061 
      if fid == 0:
5062 
        if ftype == TType.LIST:
5063 
          self.success = []
567 rajveer 5064 
          (_etype47, _size44) = iprot.readListBegin()
5065 
          for _i48 in xrange(_size44):
5066 
            _elem49 = Cart()
5067 
            _elem49.read(iprot)
5068 
            self.success.append(_elem49)
559 chandransh 5069 
          iprot.readListEnd()
5070 
        else:
5071 
          iprot.skip(ftype)
5072 
      elif fid == 1:
5073 
        if ftype == TType.STRUCT:
5074 
          self.scx = ShoppingCartException()
5075 
          self.scx.read(iprot)
5076 
        else:
5077 
          iprot.skip(ftype)
5078 
      else:
5079 
        iprot.skip(ftype)
5080 
      iprot.readFieldEnd()
5081 
    iprot.readStructEnd()
5082 
 
5083 
  def write(self, oprot):
5084 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5085 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5086 
      return
5087 
    oprot.writeStructBegin('getCartsByStatus_result')
5088 
    if self.success != None:
5089 
      oprot.writeFieldBegin('success', TType.LIST, 0)
5090 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
567 rajveer 5091 
      for iter50 in self.success:
5092 
        iter50.write(oprot)
559 chandransh 5093 
      oprot.writeListEnd()
5094 
      oprot.writeFieldEnd()
5095 
    if self.scx != None:
5096 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
5097 
      self.scx.write(oprot)
5098 
      oprot.writeFieldEnd()
5099 
    oprot.writeFieldStop()
5100 
    oprot.writeStructEnd()
5101 
 
5102 
  def __repr__(self):
5103 
    L = ['%s=%r' % (key, value)
5104 
      for key, value in self.__dict__.iteritems()]
5105 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5106 
 
5107 
  def __eq__(self, other):
5108 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5109 
 
5110 
  def __ne__(self, other):
5111 
    return not (self == other)
5112 
 
5113 
class getCartsByTime_args:
5114 
  """
5115 
  Attributes:
5116 
   - from_time
5117 
   - to_time
5118 
   - status
5119 
  """
5120 
 
5121 
  thrift_spec = (
5122 
    None, # 0
5123 
    (1, TType.I64, 'from_time', None, None, ), # 1
5124 
    (2, TType.I64, 'to_time', None, None, ), # 2
5125 
    (3, TType.I32, 'status', None, None, ), # 3
5126 
  )
5127 
 
5128 
  def __init__(self, from_time=None, to_time=None, status=None,):
5129 
    self.from_time = from_time
5130 
    self.to_time = to_time
5131 
    self.status = status
5132 
 
5133 
  def read(self, iprot):
5134 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5135 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5136 
      return
5137 
    iprot.readStructBegin()
5138 
    while True:
5139 
      (fname, ftype, fid) = iprot.readFieldBegin()
5140 
      if ftype == TType.STOP:
5141 
        break
5142 
      if fid == 1:
94 ashish 5143 
        if ftype == TType.I64:
559 chandransh 5144 
          self.from_time = iprot.readI64();
94 ashish 5145 
        else:
5146 
          iprot.skip(ftype)
122 ashish 5147 
      elif fid == 2:
559 chandransh 5148 
        if ftype == TType.I64:
5149 
          self.to_time = iprot.readI64();
122 ashish 5150 
        else:
5151 
          iprot.skip(ftype)
559 chandransh 5152 
      elif fid == 3:
5153 
        if ftype == TType.I32:
5154 
          self.status = iprot.readI32();
5155 
        else:
5156 
          iprot.skip(ftype)
94 ashish 5157 
      else:
5158 
        iprot.skip(ftype)
5159 
      iprot.readFieldEnd()
5160 
    iprot.readStructEnd()
5161 
 
5162 
  def write(self, oprot):
5163 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5164 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5165 
      return
559 chandransh 5166 
    oprot.writeStructBegin('getCartsByTime_args')
5167 
    if self.from_time != None:
5168 
      oprot.writeFieldBegin('from_time', TType.I64, 1)
5169 
      oprot.writeI64(self.from_time)
94 ashish 5170 
      oprot.writeFieldEnd()
559 chandransh 5171 
    if self.to_time != None:
5172 
      oprot.writeFieldBegin('to_time', TType.I64, 2)
5173 
      oprot.writeI64(self.to_time)
122 ashish 5174 
      oprot.writeFieldEnd()
559 chandransh 5175 
    if self.status != None:
5176 
      oprot.writeFieldBegin('status', TType.I32, 3)
5177 
      oprot.writeI32(self.status)
5178 
      oprot.writeFieldEnd()
94 ashish 5179 
    oprot.writeFieldStop()
5180 
    oprot.writeStructEnd()
5181 
 
5182 
  def __repr__(self):
5183 
    L = ['%s=%r' % (key, value)
5184 
      for key, value in self.__dict__.iteritems()]
5185 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5186 
 
5187 
  def __eq__(self, other):
5188 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5189 
 
5190 
  def __ne__(self, other):
5191 
    return not (self == other)
5192 
 
559 chandransh 5193 
class getCartsByTime_result:
94 ashish 5194 
  """
5195 
  Attributes:
5196 
   - success
559 chandransh 5197 
   - scx
94 ashish 5198 
  """
5199 
 
5200 
  thrift_spec = (
559 chandransh 5201 
    (0, TType.LIST, 'success', (TType.STRUCT,(Cart, Cart.thrift_spec)), None, ), # 0
5202 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 5203 
  )
5204 
 
559 chandransh 5205 
  def __init__(self, success=None, scx=None,):
94 ashish 5206 
    self.success = success
559 chandransh 5207 
    self.scx = scx
94 ashish 5208 
 
5209 
  def read(self, iprot):
5210 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5211 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5212 
      return
5213 
    iprot.readStructBegin()
5214 
    while True:
5215 
      (fname, ftype, fid) = iprot.readFieldBegin()
5216 
      if ftype == TType.STOP:
5217 
        break
5218 
      if fid == 0:
559 chandransh 5219 
        if ftype == TType.LIST:
5220 
          self.success = []
567 rajveer 5221 
          (_etype54, _size51) = iprot.readListBegin()
5222 
          for _i55 in xrange(_size51):
5223 
            _elem56 = Cart()
5224 
            _elem56.read(iprot)
5225 
            self.success.append(_elem56)
559 chandransh 5226 
          iprot.readListEnd()
94 ashish 5227 
        else:
5228 
          iprot.skip(ftype)
5229 
      elif fid == 1:
5230 
        if ftype == TType.STRUCT:
559 chandransh 5231 
          self.scx = ShoppingCartException()
5232 
          self.scx.read(iprot)
94 ashish 5233 
        else:
5234 
          iprot.skip(ftype)
5235 
      else:
5236 
        iprot.skip(ftype)
5237 
      iprot.readFieldEnd()
5238 
    iprot.readStructEnd()
5239 
 
5240 
  def write(self, oprot):
5241 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5242 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5243 
      return
559 chandransh 5244 
    oprot.writeStructBegin('getCartsByTime_result')
94 ashish 5245 
    if self.success != None:
559 chandransh 5246 
      oprot.writeFieldBegin('success', TType.LIST, 0)
5247 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
567 rajveer 5248 
      for iter57 in self.success:
5249 
        iter57.write(oprot)
559 chandransh 5250 
      oprot.writeListEnd()
94 ashish 5251 
      oprot.writeFieldEnd()
559 chandransh 5252 
    if self.scx != None:
5253 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
5254 
      self.scx.write(oprot)
94 ashish 5255 
      oprot.writeFieldEnd()
5256 
    oprot.writeFieldStop()
5257 
    oprot.writeStructEnd()
5258 
 
5259 
  def __repr__(self):
5260 
    L = ['%s=%r' % (key, value)
5261 
      for key, value in self.__dict__.iteritems()]
5262 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5263 
 
5264 
  def __eq__(self, other):
5265 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5266 
 
5267 
  def __ne__(self, other):
5268 
    return not (self == other)
5269 
 
559 chandransh 5270 
class changeCartStatus_args:
94 ashish 5271 
  """
5272 
  Attributes:
559 chandransh 5273 
   - cartId
5274 
   - status
94 ashish 5275 
  """
5276 
 
5277 
  thrift_spec = (
5278 
    None, # 0
559 chandransh 5279 
    (1, TType.I64, 'cartId', None, None, ), # 1
5280 
    (2, TType.I32, 'status', None, None, ), # 2
94 ashish 5281 
  )
5282 
 
559 chandransh 5283 
  def __init__(self, cartId=None, status=None,):
5284 
    self.cartId = cartId
5285 
    self.status = status
94 ashish 5286 
 
5287 
  def read(self, iprot):
5288 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5289 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5290 
      return
5291 
    iprot.readStructBegin()
5292 
    while True:
5293 
      (fname, ftype, fid) = iprot.readFieldBegin()
5294 
      if ftype == TType.STOP:
5295 
        break
5296 
      if fid == 1:
5297 
        if ftype == TType.I64:
559 chandransh 5298 
          self.cartId = iprot.readI64();
94 ashish 5299 
        else:
5300 
          iprot.skip(ftype)
559 chandransh 5301 
      elif fid == 2:
5302 
        if ftype == TType.I32:
5303 
          self.status = iprot.readI32();
5304 
        else:
5305 
          iprot.skip(ftype)
94 ashish 5306 
      else:
5307 
        iprot.skip(ftype)
5308 
      iprot.readFieldEnd()
5309 
    iprot.readStructEnd()
5310 
 
5311 
  def write(self, oprot):
5312 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5313 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5314 
      return
559 chandransh 5315 
    oprot.writeStructBegin('changeCartStatus_args')
5316 
    if self.cartId != None:
5317 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
5318 
      oprot.writeI64(self.cartId)
94 ashish 5319 
      oprot.writeFieldEnd()
559 chandransh 5320 
    if self.status != None:
5321 
      oprot.writeFieldBegin('status', TType.I32, 2)
5322 
      oprot.writeI32(self.status)
5323 
      oprot.writeFieldEnd()
94 ashish 5324 
    oprot.writeFieldStop()
5325 
    oprot.writeStructEnd()
5326 
 
5327 
  def __repr__(self):
5328 
    L = ['%s=%r' % (key, value)
5329 
      for key, value in self.__dict__.iteritems()]
5330 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5331 
 
5332 
  def __eq__(self, other):
5333 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5334 
 
5335 
  def __ne__(self, other):
5336 
    return not (self == other)
5337 
 
559 chandransh 5338 
class changeCartStatus_result:
94 ashish 5339 
  """
5340 
  Attributes:
559 chandransh 5341 
   - scx
5342 
  """
5343 
 
5344 
  thrift_spec = (
5345 
    None, # 0
5346 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
5347 
  )
5348 
 
5349 
  def __init__(self, scx=None,):
5350 
    self.scx = scx
5351 
 
5352 
  def read(self, iprot):
5353 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5354 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5355 
      return
5356 
    iprot.readStructBegin()
5357 
    while True:
5358 
      (fname, ftype, fid) = iprot.readFieldBegin()
5359 
      if ftype == TType.STOP:
5360 
        break
5361 
      if fid == 1:
5362 
        if ftype == TType.STRUCT:
5363 
          self.scx = ShoppingCartException()
5364 
          self.scx.read(iprot)
5365 
        else:
5366 
          iprot.skip(ftype)
5367 
      else:
5368 
        iprot.skip(ftype)
5369 
      iprot.readFieldEnd()
5370 
    iprot.readStructEnd()
5371 
 
5372 
  def write(self, oprot):
5373 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5374 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5375 
      return
5376 
    oprot.writeStructBegin('changeCartStatus_result')
5377 
    if self.scx != None:
5378 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
5379 
      self.scx.write(oprot)
5380 
      oprot.writeFieldEnd()
5381 
    oprot.writeFieldStop()
5382 
    oprot.writeStructEnd()
5383 
 
5384 
  def __repr__(self):
5385 
    L = ['%s=%r' % (key, value)
5386 
      for key, value in self.__dict__.iteritems()]
5387 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5388 
 
5389 
  def __eq__(self, other):
5390 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5391 
 
5392 
  def __ne__(self, other):
5393 
    return not (self == other)
5394 
 
5395 
class addItemToCart_args:
5396 
  """
5397 
  Attributes:
5398 
   - cartId
5399 
   - itemId
5400 
   - quantity
5401 
  """
5402 
 
5403 
  thrift_spec = (
5404 
    None, # 0
5405 
    (1, TType.I64, 'cartId', None, None, ), # 1
5406 
    (2, TType.I64, 'itemId', None, None, ), # 2
5407 
    (3, TType.I64, 'quantity', None, None, ), # 3
5408 
  )
5409 
 
5410 
  def __init__(self, cartId=None, itemId=None, quantity=None,):
5411 
    self.cartId = cartId
5412 
    self.itemId = itemId
5413 
    self.quantity = quantity
5414 
 
5415 
  def read(self, iprot):
5416 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5417 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5418 
      return
5419 
    iprot.readStructBegin()
5420 
    while True:
5421 
      (fname, ftype, fid) = iprot.readFieldBegin()
5422 
      if ftype == TType.STOP:
5423 
        break
5424 
      if fid == 1:
5425 
        if ftype == TType.I64:
5426 
          self.cartId = iprot.readI64();
5427 
        else:
5428 
          iprot.skip(ftype)
5429 
      elif fid == 2:
5430 
        if ftype == TType.I64:
5431 
          self.itemId = iprot.readI64();
5432 
        else:
5433 
          iprot.skip(ftype)
5434 
      elif fid == 3:
5435 
        if ftype == TType.I64:
5436 
          self.quantity = iprot.readI64();
5437 
        else:
5438 
          iprot.skip(ftype)
5439 
      else:
5440 
        iprot.skip(ftype)
5441 
      iprot.readFieldEnd()
5442 
    iprot.readStructEnd()
5443 
 
5444 
  def write(self, oprot):
5445 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5446 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5447 
      return
5448 
    oprot.writeStructBegin('addItemToCart_args')
5449 
    if self.cartId != None:
5450 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
5451 
      oprot.writeI64(self.cartId)
5452 
      oprot.writeFieldEnd()
5453 
    if self.itemId != None:
5454 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
5455 
      oprot.writeI64(self.itemId)
5456 
      oprot.writeFieldEnd()
5457 
    if self.quantity != None:
5458 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
5459 
      oprot.writeI64(self.quantity)
5460 
      oprot.writeFieldEnd()
5461 
    oprot.writeFieldStop()
5462 
    oprot.writeStructEnd()
5463 
 
5464 
  def __repr__(self):
5465 
    L = ['%s=%r' % (key, value)
5466 
      for key, value in self.__dict__.iteritems()]
5467 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5468 
 
5469 
  def __eq__(self, other):
5470 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5471 
 
5472 
  def __ne__(self, other):
5473 
    return not (self == other)
5474 
 
5475 
class addItemToCart_result:
5476 
  """
5477 
  Attributes:
5478 
   - scx
5479 
  """
5480 
 
5481 
  thrift_spec = (
5482 
    None, # 0
5483 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
5484 
  )
5485 
 
5486 
  def __init__(self, scx=None,):
5487 
    self.scx = scx
5488 
 
5489 
  def read(self, iprot):
5490 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5491 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5492 
      return
5493 
    iprot.readStructBegin()
5494 
    while True:
5495 
      (fname, ftype, fid) = iprot.readFieldBegin()
5496 
      if ftype == TType.STOP:
5497 
        break
5498 
      if fid == 1:
5499 
        if ftype == TType.STRUCT:
5500 
          self.scx = ShoppingCartException()
5501 
          self.scx.read(iprot)
5502 
        else:
5503 
          iprot.skip(ftype)
5504 
      else:
5505 
        iprot.skip(ftype)
5506 
      iprot.readFieldEnd()
5507 
    iprot.readStructEnd()
5508 
 
5509 
  def write(self, oprot):
5510 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5511 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5512 
      return
5513 
    oprot.writeStructBegin('addItemToCart_result')
5514 
    if self.scx != None:
5515 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
5516 
      self.scx.write(oprot)
5517 
      oprot.writeFieldEnd()
5518 
    oprot.writeFieldStop()
5519 
    oprot.writeStructEnd()
5520 
 
5521 
  def __repr__(self):
5522 
    L = ['%s=%r' % (key, value)
5523 
      for key, value in self.__dict__.iteritems()]
5524 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5525 
 
5526 
  def __eq__(self, other):
5527 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5528 
 
5529 
  def __ne__(self, other):
5530 
    return not (self == other)
5531 
 
5532 
class deleteItemFromCart_args:
5533 
  """
5534 
  Attributes:
5535 
   - cartId
5536 
   - itemId
5537 
  """
5538 
 
5539 
  thrift_spec = (
5540 
    None, # 0
5541 
    (1, TType.I64, 'cartId', None, None, ), # 1
5542 
    (2, TType.I64, 'itemId', None, None, ), # 2
5543 
  )
5544 
 
5545 
  def __init__(self, cartId=None, itemId=None,):
5546 
    self.cartId = cartId
5547 
    self.itemId = itemId
5548 
 
5549 
  def read(self, iprot):
5550 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5551 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5552 
      return
5553 
    iprot.readStructBegin()
5554 
    while True:
5555 
      (fname, ftype, fid) = iprot.readFieldBegin()
5556 
      if ftype == TType.STOP:
5557 
        break
5558 
      if fid == 1:
5559 
        if ftype == TType.I64:
5560 
          self.cartId = iprot.readI64();
5561 
        else:
5562 
          iprot.skip(ftype)
5563 
      elif fid == 2:
5564 
        if ftype == TType.I64:
5565 
          self.itemId = iprot.readI64();
5566 
        else:
5567 
          iprot.skip(ftype)
5568 
      else:
5569 
        iprot.skip(ftype)
5570 
      iprot.readFieldEnd()
5571 
    iprot.readStructEnd()
5572 
 
5573 
  def write(self, oprot):
5574 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5575 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5576 
      return
5577 
    oprot.writeStructBegin('deleteItemFromCart_args')
5578 
    if self.cartId != None:
5579 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
5580 
      oprot.writeI64(self.cartId)
5581 
      oprot.writeFieldEnd()
5582 
    if self.itemId != None:
5583 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
5584 
      oprot.writeI64(self.itemId)
5585 
      oprot.writeFieldEnd()
5586 
    oprot.writeFieldStop()
5587 
    oprot.writeStructEnd()
5588 
 
5589 
  def __repr__(self):
5590 
    L = ['%s=%r' % (key, value)
5591 
      for key, value in self.__dict__.iteritems()]
5592 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5593 
 
5594 
  def __eq__(self, other):
5595 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5596 
 
5597 
  def __ne__(self, other):
5598 
    return not (self == other)
5599 
 
5600 
class deleteItemFromCart_result:
5601 
  """
5602 
  Attributes:
5603 
   - scx
5604 
  """
5605 
 
5606 
  thrift_spec = (
5607 
    None, # 0
5608 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
5609 
  )
5610 
 
5611 
  def __init__(self, scx=None,):
5612 
    self.scx = scx
5613 
 
5614 
  def read(self, iprot):
5615 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5616 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5617 
      return
5618 
    iprot.readStructBegin()
5619 
    while True:
5620 
      (fname, ftype, fid) = iprot.readFieldBegin()
5621 
      if ftype == TType.STOP:
5622 
        break
5623 
      if fid == 1:
5624 
        if ftype == TType.STRUCT:
5625 
          self.scx = ShoppingCartException()
5626 
          self.scx.read(iprot)
5627 
        else:
5628 
          iprot.skip(ftype)
5629 
      else:
5630 
        iprot.skip(ftype)
5631 
      iprot.readFieldEnd()
5632 
    iprot.readStructEnd()
5633 
 
5634 
  def write(self, oprot):
5635 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5636 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5637 
      return
5638 
    oprot.writeStructBegin('deleteItemFromCart_result')
5639 
    if self.scx != None:
5640 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
5641 
      self.scx.write(oprot)
5642 
      oprot.writeFieldEnd()
5643 
    oprot.writeFieldStop()
5644 
    oprot.writeStructEnd()
5645 
 
5646 
  def __repr__(self):
5647 
    L = ['%s=%r' % (key, value)
5648 
      for key, value in self.__dict__.iteritems()]
5649 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5650 
 
5651 
  def __eq__(self, other):
5652 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5653 
 
5654 
  def __ne__(self, other):
5655 
    return not (self == other)
5656 
 
5657 
class changeQuantity_args:
5658 
  """
5659 
  Attributes:
5660 
   - cartId
5661 
   - itemId
5662 
   - quantity
5663 
  """
5664 
 
5665 
  thrift_spec = (
5666 
    None, # 0
5667 
    (1, TType.I64, 'cartId', None, None, ), # 1
5668 
    (2, TType.I64, 'itemId', None, None, ), # 2
5669 
    (3, TType.I64, 'quantity', None, None, ), # 3
5670 
  )
5671 
 
5672 
  def __init__(self, cartId=None, itemId=None, quantity=None,):
5673 
    self.cartId = cartId
5674 
    self.itemId = itemId
5675 
    self.quantity = quantity
5676 
 
5677 
  def read(self, iprot):
5678 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5679 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5680 
      return
5681 
    iprot.readStructBegin()
5682 
    while True:
5683 
      (fname, ftype, fid) = iprot.readFieldBegin()
5684 
      if ftype == TType.STOP:
5685 
        break
5686 
      if fid == 1:
5687 
        if ftype == TType.I64:
5688 
          self.cartId = iprot.readI64();
5689 
        else:
5690 
          iprot.skip(ftype)
5691 
      elif fid == 2:
5692 
        if ftype == TType.I64:
5693 
          self.itemId = iprot.readI64();
5694 
        else:
5695 
          iprot.skip(ftype)
5696 
      elif fid == 3:
5697 
        if ftype == TType.I64:
5698 
          self.quantity = iprot.readI64();
5699 
        else:
5700 
          iprot.skip(ftype)
5701 
      else:
5702 
        iprot.skip(ftype)
5703 
      iprot.readFieldEnd()
5704 
    iprot.readStructEnd()
5705 
 
5706 
  def write(self, oprot):
5707 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5708 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5709 
      return
5710 
    oprot.writeStructBegin('changeQuantity_args')
5711 
    if self.cartId != None:
5712 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
5713 
      oprot.writeI64(self.cartId)
5714 
      oprot.writeFieldEnd()
5715 
    if self.itemId != None:
5716 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
5717 
      oprot.writeI64(self.itemId)
5718 
      oprot.writeFieldEnd()
5719 
    if self.quantity != None:
5720 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
5721 
      oprot.writeI64(self.quantity)
5722 
      oprot.writeFieldEnd()
5723 
    oprot.writeFieldStop()
5724 
    oprot.writeStructEnd()
5725 
 
5726 
  def __repr__(self):
5727 
    L = ['%s=%r' % (key, value)
5728 
      for key, value in self.__dict__.iteritems()]
5729 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5730 
 
5731 
  def __eq__(self, other):
5732 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5733 
 
5734 
  def __ne__(self, other):
5735 
    return not (self == other)
5736 
 
5737 
class changeQuantity_result:
5738 
  """
5739 
  Attributes:
5740 
   - scx
5741 
  """
5742 
 
5743 
  thrift_spec = (
5744 
    None, # 0
5745 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
5746 
  )
5747 
 
5748 
  def __init__(self, scx=None,):
5749 
    self.scx = scx
5750 
 
5751 
  def read(self, iprot):
5752 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5753 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5754 
      return
5755 
    iprot.readStructBegin()
5756 
    while True:
5757 
      (fname, ftype, fid) = iprot.readFieldBegin()
5758 
      if ftype == TType.STOP:
5759 
        break
5760 
      if fid == 1:
5761 
        if ftype == TType.STRUCT:
5762 
          self.scx = ShoppingCartException()
5763 
          self.scx.read(iprot)
5764 
        else:
5765 
          iprot.skip(ftype)
5766 
      else:
5767 
        iprot.skip(ftype)
5768 
      iprot.readFieldEnd()
5769 
    iprot.readStructEnd()
5770 
 
5771 
  def write(self, oprot):
5772 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5773 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5774 
      return
5775 
    oprot.writeStructBegin('changeQuantity_result')
5776 
    if self.scx != None:
5777 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
5778 
      self.scx.write(oprot)
5779 
      oprot.writeFieldEnd()
5780 
    oprot.writeFieldStop()
5781 
    oprot.writeStructEnd()
5782 
 
5783 
  def __repr__(self):
5784 
    L = ['%s=%r' % (key, value)
5785 
      for key, value in self.__dict__.iteritems()]
5786 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5787 
 
5788 
  def __eq__(self, other):
5789 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5790 
 
5791 
  def __ne__(self, other):
5792 
    return not (self == other)
5793 
 
5794 
class changeItemStatus_args:
5795 
  """
5796 
  Attributes:
5797 
   - cartId
5798 
   - itemId
5799 
   - status
5800 
  """
5801 
 
5802 
  thrift_spec = (
5803 
    None, # 0
5804 
    (1, TType.I64, 'cartId', None, None, ), # 1
5805 
    (2, TType.I64, 'itemId', None, None, ), # 2
5806 
    (3, TType.I32, 'status', None, None, ), # 3
5807 
  )
5808 
 
5809 
  def __init__(self, cartId=None, itemId=None, status=None,):
5810 
    self.cartId = cartId
5811 
    self.itemId = itemId
5812 
    self.status = status
5813 
 
5814 
  def read(self, iprot):
5815 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5816 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5817 
      return
5818 
    iprot.readStructBegin()
5819 
    while True:
5820 
      (fname, ftype, fid) = iprot.readFieldBegin()
5821 
      if ftype == TType.STOP:
5822 
        break
5823 
      if fid == 1:
5824 
        if ftype == TType.I64:
5825 
          self.cartId = iprot.readI64();
5826 
        else:
5827 
          iprot.skip(ftype)
5828 
      elif fid == 2:
5829 
        if ftype == TType.I64:
5830 
          self.itemId = iprot.readI64();
5831 
        else:
5832 
          iprot.skip(ftype)
5833 
      elif fid == 3:
5834 
        if ftype == TType.I32:
5835 
          self.status = iprot.readI32();
5836 
        else:
5837 
          iprot.skip(ftype)
5838 
      else:
5839 
        iprot.skip(ftype)
5840 
      iprot.readFieldEnd()
5841 
    iprot.readStructEnd()
5842 
 
5843 
  def write(self, oprot):
5844 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5845 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5846 
      return
5847 
    oprot.writeStructBegin('changeItemStatus_args')
5848 
    if self.cartId != None:
5849 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
5850 
      oprot.writeI64(self.cartId)
5851 
      oprot.writeFieldEnd()
5852 
    if self.itemId != None:
5853 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
5854 
      oprot.writeI64(self.itemId)
5855 
      oprot.writeFieldEnd()
5856 
    if self.status != None:
5857 
      oprot.writeFieldBegin('status', TType.I32, 3)
5858 
      oprot.writeI32(self.status)
5859 
      oprot.writeFieldEnd()
5860 
    oprot.writeFieldStop()
5861 
    oprot.writeStructEnd()
5862 
 
5863 
  def __repr__(self):
5864 
    L = ['%s=%r' % (key, value)
5865 
      for key, value in self.__dict__.iteritems()]
5866 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5867 
 
5868 
  def __eq__(self, other):
5869 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5870 
 
5871 
  def __ne__(self, other):
5872 
    return not (self == other)
5873 
 
5874 
class changeItemStatus_result:
5875 
  """
5876 
  Attributes:
5877 
   - scx
5878 
  """
5879 
 
5880 
  thrift_spec = (
5881 
    None, # 0
5882 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
5883 
  )
5884 
 
5885 
  def __init__(self, scx=None,):
5886 
    self.scx = scx
5887 
 
5888 
  def read(self, iprot):
5889 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5890 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5891 
      return
5892 
    iprot.readStructBegin()
5893 
    while True:
5894 
      (fname, ftype, fid) = iprot.readFieldBegin()
5895 
      if ftype == TType.STOP:
5896 
        break
5897 
      if fid == 1:
5898 
        if ftype == TType.STRUCT:
5899 
          self.scx = ShoppingCartException()
5900 
          self.scx.read(iprot)
5901 
        else:
5902 
          iprot.skip(ftype)
5903 
      else:
5904 
        iprot.skip(ftype)
5905 
      iprot.readFieldEnd()
5906 
    iprot.readStructEnd()
5907 
 
5908 
  def write(self, oprot):
5909 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5910 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5911 
      return
5912 
    oprot.writeStructBegin('changeItemStatus_result')
5913 
    if self.scx != None:
5914 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
5915 
      self.scx.write(oprot)
5916 
      oprot.writeFieldEnd()
5917 
    oprot.writeFieldStop()
5918 
    oprot.writeStructEnd()
5919 
 
5920 
  def __repr__(self):
5921 
    L = ['%s=%r' % (key, value)
5922 
      for key, value in self.__dict__.iteritems()]
5923 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5924 
 
5925 
  def __eq__(self, other):
5926 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5927 
 
5928 
  def __ne__(self, other):
5929 
    return not (self == other)
5930 
 
5931 
class addAddressToCart_args:
5932 
  """
5933 
  Attributes:
5934 
   - cartId
5935 
   - addressId
5936 
  """
5937 
 
5938 
  thrift_spec = (
5939 
    None, # 0
5940 
    (1, TType.I64, 'cartId', None, None, ), # 1
5941 
    (2, TType.I64, 'addressId', None, None, ), # 2
5942 
  )
5943 
 
5944 
  def __init__(self, cartId=None, addressId=None,):
5945 
    self.cartId = cartId
5946 
    self.addressId = addressId
5947 
 
5948 
  def read(self, iprot):
5949 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5950 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5951 
      return
5952 
    iprot.readStructBegin()
5953 
    while True:
5954 
      (fname, ftype, fid) = iprot.readFieldBegin()
5955 
      if ftype == TType.STOP:
5956 
        break
5957 
      if fid == 1:
5958 
        if ftype == TType.I64:
5959 
          self.cartId = iprot.readI64();
5960 
        else:
5961 
          iprot.skip(ftype)
5962 
      elif fid == 2:
5963 
        if ftype == TType.I64:
5964 
          self.addressId = iprot.readI64();
5965 
        else:
5966 
          iprot.skip(ftype)
5967 
      else:
5968 
        iprot.skip(ftype)
5969 
      iprot.readFieldEnd()
5970 
    iprot.readStructEnd()
5971 
 
5972 
  def write(self, oprot):
5973 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5974 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5975 
      return
5976 
    oprot.writeStructBegin('addAddressToCart_args')
5977 
    if self.cartId != None:
5978 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
5979 
      oprot.writeI64(self.cartId)
5980 
      oprot.writeFieldEnd()
5981 
    if self.addressId != None:
5982 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
5983 
      oprot.writeI64(self.addressId)
5984 
      oprot.writeFieldEnd()
5985 
    oprot.writeFieldStop()
5986 
    oprot.writeStructEnd()
5987 
 
5988 
  def __repr__(self):
5989 
    L = ['%s=%r' % (key, value)
5990 
      for key, value in self.__dict__.iteritems()]
5991 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5992 
 
5993 
  def __eq__(self, other):
5994 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5995 
 
5996 
  def __ne__(self, other):
5997 
    return not (self == other)
5998 
 
5999 
class addAddressToCart_result:
575 chandransh 6000 
  """
6001 
  Attributes:
6002 
   - scx
6003 
  """
559 chandransh 6004 
 
6005 
  thrift_spec = (
575 chandransh 6006 
    None, # 0
6007 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
559 chandransh 6008 
  )
6009 
 
575 chandransh 6010 
  def __init__(self, scx=None,):
6011 
    self.scx = scx
6012 
 
559 chandransh 6013 
  def read(self, iprot):
6014 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6015 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6016 
      return
6017 
    iprot.readStructBegin()
6018 
    while True:
6019 
      (fname, ftype, fid) = iprot.readFieldBegin()
6020 
      if ftype == TType.STOP:
6021 
        break
575 chandransh 6022 
      if fid == 1:
6023 
        if ftype == TType.STRUCT:
6024 
          self.scx = ShoppingCartException()
6025 
          self.scx.read(iprot)
6026 
        else:
6027 
          iprot.skip(ftype)
559 chandransh 6028 
      else:
6029 
        iprot.skip(ftype)
6030 
      iprot.readFieldEnd()
6031 
    iprot.readStructEnd()
6032 
 
6033 
  def write(self, oprot):
6034 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6035 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6036 
      return
6037 
    oprot.writeStructBegin('addAddressToCart_result')
575 chandransh 6038 
    if self.scx != None:
6039 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
6040 
      self.scx.write(oprot)
6041 
      oprot.writeFieldEnd()
559 chandransh 6042 
    oprot.writeFieldStop()
6043 
    oprot.writeStructEnd()
6044 
 
6045 
  def __repr__(self):
6046 
    L = ['%s=%r' % (key, value)
6047 
      for key, value in self.__dict__.iteritems()]
6048 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6049 
 
6050 
  def __eq__(self, other):
6051 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6052 
 
6053 
  def __ne__(self, other):
6054 
    return not (self == other)
6055 
 
6056 
class commitCart_args:
6057 
  """
6058 
  Attributes:
6059 
   - cartId
6060 
  """
6061 
 
6062 
  thrift_spec = (
6063 
    None, # 0
6064 
    (1, TType.I64, 'cartId', None, None, ), # 1
6065 
  )
6066 
 
6067 
  def __init__(self, cartId=None,):
6068 
    self.cartId = cartId
6069 
 
6070 
  def read(self, iprot):
6071 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6072 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6073 
      return
6074 
    iprot.readStructBegin()
6075 
    while True:
6076 
      (fname, ftype, fid) = iprot.readFieldBegin()
6077 
      if ftype == TType.STOP:
6078 
        break
6079 
      if fid == 1:
6080 
        if ftype == TType.I64:
6081 
          self.cartId = iprot.readI64();
6082 
        else:
6083 
          iprot.skip(ftype)
6084 
      else:
6085 
        iprot.skip(ftype)
6086 
      iprot.readFieldEnd()
6087 
    iprot.readStructEnd()
6088 
 
6089 
  def write(self, oprot):
6090 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6091 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6092 
      return
6093 
    oprot.writeStructBegin('commitCart_args')
6094 
    if self.cartId != None:
6095 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
6096 
      oprot.writeI64(self.cartId)
6097 
      oprot.writeFieldEnd()
6098 
    oprot.writeFieldStop()
6099 
    oprot.writeStructEnd()
6100 
 
6101 
  def __repr__(self):
6102 
    L = ['%s=%r' % (key, value)
6103 
      for key, value in self.__dict__.iteritems()]
6104 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6105 
 
6106 
  def __eq__(self, other):
6107 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6108 
 
6109 
  def __ne__(self, other):
6110 
    return not (self == other)
6111 
 
6112 
class commitCart_result:
6113 
  """
6114 
  Attributes:
94 ashish 6115 
   - success
559 chandransh 6116 
   - scx
94 ashish 6117 
  """
6118 
 
6119 
  thrift_spec = (
575 chandransh 6120 
    (0, TType.I64, 'success', None, None, ), # 0
559 chandransh 6121 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 6122 
  )
6123 
 
559 chandransh 6124 
  def __init__(self, success=None, scx=None,):
94 ashish 6125 
    self.success = success
559 chandransh 6126 
    self.scx = scx
94 ashish 6127 
 
6128 
  def read(self, iprot):
6129 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6130 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6131 
      return
6132 
    iprot.readStructBegin()
6133 
    while True:
6134 
      (fname, ftype, fid) = iprot.readFieldBegin()
6135 
      if ftype == TType.STOP:
6136 
        break
6137 
      if fid == 0:
575 chandransh 6138 
        if ftype == TType.I64:
6139 
          self.success = iprot.readI64();
94 ashish 6140 
        else:
6141 
          iprot.skip(ftype)
6142 
      elif fid == 1:
6143 
        if ftype == TType.STRUCT:
559 chandransh 6144 
          self.scx = ShoppingCartException()
6145 
          self.scx.read(iprot)
94 ashish 6146 
        else:
6147 
          iprot.skip(ftype)
6148 
      else:
6149 
        iprot.skip(ftype)
6150 
      iprot.readFieldEnd()
6151 
    iprot.readStructEnd()
6152 
 
6153 
  def write(self, oprot):
6154 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6155 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6156 
      return
559 chandransh 6157 
    oprot.writeStructBegin('commitCart_result')
94 ashish 6158 
    if self.success != None:
575 chandransh 6159 
      oprot.writeFieldBegin('success', TType.I64, 0)
6160 
      oprot.writeI64(self.success)
94 ashish 6161 
      oprot.writeFieldEnd()
559 chandransh 6162 
    if self.scx != None:
6163 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
6164 
      self.scx.write(oprot)
94 ashish 6165 
      oprot.writeFieldEnd()
6166 
    oprot.writeFieldStop()
6167 
    oprot.writeStructEnd()
6168 
 
6169 
  def __repr__(self):
6170 
    L = ['%s=%r' % (key, value)
6171 
      for key, value in self.__dict__.iteritems()]
6172 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6173 
 
6174 
  def __eq__(self, other):
6175 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6176 
 
6177 
  def __ne__(self, other):
6178 
    return not (self == other)
6179 
 
559 chandransh 6180 
class validateCart_args:
94 ashish 6181 
  """
6182 
  Attributes:
559 chandransh 6183 
   - cartId
94 ashish 6184 
  """
6185 
 
6186 
  thrift_spec = (
6187 
    None, # 0
559 chandransh 6188 
    (1, TType.I64, 'cartId', None, None, ), # 1
94 ashish 6189 
  )
6190 
 
559 chandransh 6191 
  def __init__(self, cartId=None,):
6192 
    self.cartId = cartId
94 ashish 6193 
 
6194 
  def read(self, iprot):
6195 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6196 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6197 
      return
6198 
    iprot.readStructBegin()
6199 
    while True:
6200 
      (fname, ftype, fid) = iprot.readFieldBegin()
6201 
      if ftype == TType.STOP:
6202 
        break
6203 
      if fid == 1:
6204 
        if ftype == TType.I64:
559 chandransh 6205 
          self.cartId = iprot.readI64();
94 ashish 6206 
        else:
6207 
          iprot.skip(ftype)
6208 
      else:
6209 
        iprot.skip(ftype)
6210 
      iprot.readFieldEnd()
6211 
    iprot.readStructEnd()
6212 
 
6213 
  def write(self, oprot):
6214 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6215 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6216 
      return
559 chandransh 6217 
    oprot.writeStructBegin('validateCart_args')
6218 
    if self.cartId != None:
6219 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
6220 
      oprot.writeI64(self.cartId)
94 ashish 6221 
      oprot.writeFieldEnd()
6222 
    oprot.writeFieldStop()
6223 
    oprot.writeStructEnd()
6224 
 
6225 
  def __repr__(self):
6226 
    L = ['%s=%r' % (key, value)
6227 
      for key, value in self.__dict__.iteritems()]
6228 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6229 
 
6230 
  def __eq__(self, other):
6231 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6232 
 
6233 
  def __ne__(self, other):
6234 
    return not (self == other)
6235 
 
559 chandransh 6236 
class validateCart_result:
94 ashish 6237 
  """
6238 
  Attributes:
6239 
   - success
575 chandransh 6240 
   - scex
94 ashish 6241 
  """
6242 
 
6243 
  thrift_spec = (
6244 
    (0, TType.BOOL, 'success', None, None, ), # 0
575 chandransh 6245 
    (1, TType.STRUCT, 'scex', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 6246 
  )
6247 
 
575 chandransh 6248 
  def __init__(self, success=None, scex=None,):
94 ashish 6249 
    self.success = success
575 chandransh 6250 
    self.scex = scex
94 ashish 6251 
 
6252 
  def read(self, iprot):
6253 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6254 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6255 
      return
6256 
    iprot.readStructBegin()
6257 
    while True:
6258 
      (fname, ftype, fid) = iprot.readFieldBegin()
6259 
      if ftype == TType.STOP:
6260 
        break
6261 
      if fid == 0:
6262 
        if ftype == TType.BOOL:
6263 
          self.success = iprot.readBool();
6264 
        else:
6265 
          iprot.skip(ftype)
575 chandransh 6266 
      elif fid == 1:
6267 
        if ftype == TType.STRUCT:
6268 
          self.scex = ShoppingCartException()
6269 
          self.scex.read(iprot)
6270 
        else:
6271 
          iprot.skip(ftype)
94 ashish 6272 
      else:
6273 
        iprot.skip(ftype)
6274 
      iprot.readFieldEnd()
6275 
    iprot.readStructEnd()
6276 
 
6277 
  def write(self, oprot):
6278 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6279 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6280 
      return
559 chandransh 6281 
    oprot.writeStructBegin('validateCart_result')
94 ashish 6282 
    if self.success != None:
6283 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6284 
      oprot.writeBool(self.success)
6285 
      oprot.writeFieldEnd()
575 chandransh 6286 
    if self.scex != None:
6287 
      oprot.writeFieldBegin('scex', TType.STRUCT, 1)
6288 
      self.scex.write(oprot)
6289 
      oprot.writeFieldEnd()
559 chandransh 6290 
    oprot.writeFieldStop()
6291 
    oprot.writeStructEnd()
6292 
 
6293 
  def __repr__(self):
6294 
    L = ['%s=%r' % (key, value)
6295 
      for key, value in self.__dict__.iteritems()]
6296 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6297 
 
6298 
  def __eq__(self, other):
6299 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6300 
 
6301 
  def __ne__(self, other):
6302 
    return not (self == other)
6303 
 
575 chandransh 6304 
class refreshCart_args:
6305 
  """
6306 
  Attributes:
6307 
   - cartId
6308 
  """
6309 
 
6310 
  thrift_spec = (
6311 
    None, # 0
6312 
    (1, TType.I64, 'cartId', None, None, ), # 1
6313 
  )
6314 
 
6315 
  def __init__(self, cartId=None,):
6316 
    self.cartId = cartId
6317 
 
6318 
  def read(self, iprot):
6319 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6320 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6321 
      return
6322 
    iprot.readStructBegin()
6323 
    while True:
6324 
      (fname, ftype, fid) = iprot.readFieldBegin()
6325 
      if ftype == TType.STOP:
6326 
        break
6327 
      if fid == 1:
6328 
        if ftype == TType.I64:
6329 
          self.cartId = iprot.readI64();
6330 
        else:
6331 
          iprot.skip(ftype)
6332 
      else:
6333 
        iprot.skip(ftype)
6334 
      iprot.readFieldEnd()
6335 
    iprot.readStructEnd()
6336 
 
6337 
  def write(self, oprot):
6338 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6339 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6340 
      return
6341 
    oprot.writeStructBegin('refreshCart_args')
6342 
    if self.cartId != None:
6343 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
6344 
      oprot.writeI64(self.cartId)
6345 
      oprot.writeFieldEnd()
6346 
    oprot.writeFieldStop()
6347 
    oprot.writeStructEnd()
6348 
 
6349 
  def __repr__(self):
6350 
    L = ['%s=%r' % (key, value)
6351 
      for key, value in self.__dict__.iteritems()]
6352 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6353 
 
6354 
  def __eq__(self, other):
6355 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6356 
 
6357 
  def __ne__(self, other):
6358 
    return not (self == other)
6359 
 
6360 
class refreshCart_result:
6361 
  """
6362 
  Attributes:
6363 
   - success
6364 
   - scex
6365 
  """
6366 
 
6367 
  thrift_spec = (
6368 
    (0, TType.BOOL, 'success', None, None, ), # 0
6369 
    (1, TType.STRUCT, 'scex', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
6370 
  )
6371 
 
6372 
  def __init__(self, success=None, scex=None,):
6373 
    self.success = success
6374 
    self.scex = scex
6375 
 
6376 
  def read(self, iprot):
6377 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6378 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6379 
      return
6380 
    iprot.readStructBegin()
6381 
    while True:
6382 
      (fname, ftype, fid) = iprot.readFieldBegin()
6383 
      if ftype == TType.STOP:
6384 
        break
6385 
      if fid == 0:
6386 
        if ftype == TType.BOOL:
6387 
          self.success = iprot.readBool();
6388 
        else:
6389 
          iprot.skip(ftype)
6390 
      elif fid == 1:
6391 
        if ftype == TType.STRUCT:
6392 
          self.scex = ShoppingCartException()
6393 
          self.scex.read(iprot)
6394 
        else:
6395 
          iprot.skip(ftype)
6396 
      else:
6397 
        iprot.skip(ftype)
6398 
      iprot.readFieldEnd()
6399 
    iprot.readStructEnd()
6400 
 
6401 
  def write(self, oprot):
6402 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6403 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6404 
      return
6405 
    oprot.writeStructBegin('refreshCart_result')
6406 
    if self.success != None:
6407 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6408 
      oprot.writeBool(self.success)
6409 
      oprot.writeFieldEnd()
6410 
    if self.scex != None:
6411 
      oprot.writeFieldBegin('scex', TType.STRUCT, 1)
6412 
      self.scex.write(oprot)
6413 
      oprot.writeFieldEnd()
6414 
    oprot.writeFieldStop()
6415 
    oprot.writeStructEnd()
6416 
 
6417 
  def __repr__(self):
6418 
    L = ['%s=%r' % (key, value)
6419 
      for key, value in self.__dict__.iteritems()]
6420 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6421 
 
6422 
  def __eq__(self, other):
6423 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6424 
 
6425 
  def __ne__(self, other):
6426 
    return not (self == other)
6427 
 
559 chandransh 6428 
class mergeCart_args:
6429 
  """
6430 
  Attributes:
6431 
   - fromCartId
6432 
   - toCartId
6433 
  """
6434 
 
6435 
  thrift_spec = (
6436 
    None, # 0
6437 
    (1, TType.I64, 'fromCartId', None, None, ), # 1
6438 
    (2, TType.I64, 'toCartId', None, None, ), # 2
6439 
  )
6440 
 
6441 
  def __init__(self, fromCartId=None, toCartId=None,):
6442 
    self.fromCartId = fromCartId
6443 
    self.toCartId = toCartId
6444 
 
6445 
  def read(self, iprot):
6446 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6447 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6448 
      return
6449 
    iprot.readStructBegin()
6450 
    while True:
6451 
      (fname, ftype, fid) = iprot.readFieldBegin()
6452 
      if ftype == TType.STOP:
6453 
        break
6454 
      if fid == 1:
6455 
        if ftype == TType.I64:
6456 
          self.fromCartId = iprot.readI64();
6457 
        else:
6458 
          iprot.skip(ftype)
6459 
      elif fid == 2:
6460 
        if ftype == TType.I64:
6461 
          self.toCartId = iprot.readI64();
6462 
        else:
6463 
          iprot.skip(ftype)
6464 
      else:
6465 
        iprot.skip(ftype)
6466 
      iprot.readFieldEnd()
6467 
    iprot.readStructEnd()
6468 
 
6469 
  def write(self, oprot):
6470 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6471 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6472 
      return
6473 
    oprot.writeStructBegin('mergeCart_args')
6474 
    if self.fromCartId != None:
6475 
      oprot.writeFieldBegin('fromCartId', TType.I64, 1)
6476 
      oprot.writeI64(self.fromCartId)
94 ashish 6477 
      oprot.writeFieldEnd()
559 chandransh 6478 
    if self.toCartId != None:
6479 
      oprot.writeFieldBegin('toCartId', TType.I64, 2)
6480 
      oprot.writeI64(self.toCartId)
6481 
      oprot.writeFieldEnd()
94 ashish 6482 
    oprot.writeFieldStop()
6483 
    oprot.writeStructEnd()
6484 
 
6485 
  def __repr__(self):
6486 
    L = ['%s=%r' % (key, value)
6487 
      for key, value in self.__dict__.iteritems()]
6488 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6489 
 
6490 
  def __eq__(self, other):
6491 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6492 
 
6493 
  def __ne__(self, other):
6494 
    return not (self == other)
6495 
 
559 chandransh 6496 
class mergeCart_result:
6497 
 
6498 
  thrift_spec = (
6499 
  )
6500 
 
6501 
  def read(self, iprot):
6502 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6503 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6504 
      return
6505 
    iprot.readStructBegin()
6506 
    while True:
6507 
      (fname, ftype, fid) = iprot.readFieldBegin()
6508 
      if ftype == TType.STOP:
6509 
        break
6510 
      else:
6511 
        iprot.skip(ftype)
6512 
      iprot.readFieldEnd()
6513 
    iprot.readStructEnd()
6514 
 
6515 
  def write(self, oprot):
6516 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6517 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6518 
      return
6519 
    oprot.writeStructBegin('mergeCart_result')
6520 
    oprot.writeFieldStop()
6521 
    oprot.writeStructEnd()
6522 
 
6523 
  def __repr__(self):
6524 
    L = ['%s=%r' % (key, value)
6525 
      for key, value in self.__dict__.iteritems()]
6526 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6527 
 
6528 
  def __eq__(self, other):
6529 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6530 
 
6531 
  def __ne__(self, other):
6532 
    return not (self == other)
6533 
 
6534 
class addWidget_args:
94 ashish 6535 
  """
6536 
  Attributes:
559 chandransh 6537 
   - widget
94 ashish 6538 
  """
6539 
 
6540 
  thrift_spec = (
6541 
    None, # 0
559 chandransh 6542 
    (1, TType.STRUCT, 'widget', (Widget, Widget.thrift_spec), None, ), # 1
94 ashish 6543 
  )
6544 
 
559 chandransh 6545 
  def __init__(self, widget=None,):
6546 
    self.widget = widget
94 ashish 6547 
 
6548 
  def read(self, iprot):
6549 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6550 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6551 
      return
6552 
    iprot.readStructBegin()
6553 
    while True:
6554 
      (fname, ftype, fid) = iprot.readFieldBegin()
6555 
      if ftype == TType.STOP:
6556 
        break
6557 
      if fid == 1:
559 chandransh 6558 
        if ftype == TType.STRUCT:
6559 
          self.widget = Widget()
6560 
          self.widget.read(iprot)
6561 
        else:
6562 
          iprot.skip(ftype)
6563 
      else:
6564 
        iprot.skip(ftype)
6565 
      iprot.readFieldEnd()
6566 
    iprot.readStructEnd()
6567 
 
6568 
  def write(self, oprot):
6569 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6570 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6571 
      return
6572 
    oprot.writeStructBegin('addWidget_args')
6573 
    if self.widget != None:
6574 
      oprot.writeFieldBegin('widget', TType.STRUCT, 1)
6575 
      self.widget.write(oprot)
6576 
      oprot.writeFieldEnd()
6577 
    oprot.writeFieldStop()
6578 
    oprot.writeStructEnd()
6579 
 
6580 
  def __repr__(self):
6581 
    L = ['%s=%r' % (key, value)
6582 
      for key, value in self.__dict__.iteritems()]
6583 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6584 
 
6585 
  def __eq__(self, other):
6586 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6587 
 
6588 
  def __ne__(self, other):
6589 
    return not (self == other)
6590 
 
6591 
class addWidget_result:
6592 
  """
6593 
  Attributes:
6594 
   - scx
6595 
  """
6596 
 
6597 
  thrift_spec = (
6598 
    None, # 0
6599 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
6600 
  )
6601 
 
6602 
  def __init__(self, scx=None,):
6603 
    self.scx = scx
6604 
 
6605 
  def read(self, iprot):
6606 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6607 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6608 
      return
6609 
    iprot.readStructBegin()
6610 
    while True:
6611 
      (fname, ftype, fid) = iprot.readFieldBegin()
6612 
      if ftype == TType.STOP:
6613 
        break
6614 
      if fid == 1:
6615 
        if ftype == TType.STRUCT:
6616 
          self.scx = WidgetException()
6617 
          self.scx.read(iprot)
6618 
        else:
6619 
          iprot.skip(ftype)
6620 
      else:
6621 
        iprot.skip(ftype)
6622 
      iprot.readFieldEnd()
6623 
    iprot.readStructEnd()
6624 
 
6625 
  def write(self, oprot):
6626 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6627 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6628 
      return
6629 
    oprot.writeStructBegin('addWidget_result')
6630 
    if self.scx != None:
6631 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
6632 
      self.scx.write(oprot)
6633 
      oprot.writeFieldEnd()
6634 
    oprot.writeFieldStop()
6635 
    oprot.writeStructEnd()
6636 
 
6637 
  def __repr__(self):
6638 
    L = ['%s=%r' % (key, value)
6639 
      for key, value in self.__dict__.iteritems()]
6640 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6641 
 
6642 
  def __eq__(self, other):
6643 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6644 
 
6645 
  def __ne__(self, other):
6646 
    return not (self == other)
6647 
 
6648 
class addItemToWidget_args:
6649 
  """
6650 
  Attributes:
6651 
   - widget_id
6652 
   - items
6653 
  """
6654 
 
6655 
  thrift_spec = (
6656 
    None, # 0
6657 
    (1, TType.I64, 'widget_id', None, None, ), # 1
6658 
    (2, TType.LIST, 'items', (TType.I64,None), None, ), # 2
6659 
  )
6660 
 
6661 
  def __init__(self, widget_id=None, items=None,):
6662 
    self.widget_id = widget_id
6663 
    self.items = items
6664 
 
6665 
  def read(self, iprot):
6666 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6667 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6668 
      return
6669 
    iprot.readStructBegin()
6670 
    while True:
6671 
      (fname, ftype, fid) = iprot.readFieldBegin()
6672 
      if ftype == TType.STOP:
6673 
        break
6674 
      if fid == 1:
94 ashish 6675 
        if ftype == TType.I64:
559 chandransh 6676 
          self.widget_id = iprot.readI64();
94 ashish 6677 
        else:
6678 
          iprot.skip(ftype)
559 chandransh 6679 
      elif fid == 2:
6680 
        if ftype == TType.LIST:
6681 
          self.items = []
567 rajveer 6682 
          (_etype61, _size58) = iprot.readListBegin()
6683 
          for _i62 in xrange(_size58):
6684 
            _elem63 = iprot.readI64();
6685 
            self.items.append(_elem63)
559 chandransh 6686 
          iprot.readListEnd()
6687 
        else:
6688 
          iprot.skip(ftype)
94 ashish 6689 
      else:
6690 
        iprot.skip(ftype)
6691 
      iprot.readFieldEnd()
6692 
    iprot.readStructEnd()
6693 
 
6694 
  def write(self, oprot):
6695 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6696 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6697 
      return
559 chandransh 6698 
    oprot.writeStructBegin('addItemToWidget_args')
6699 
    if self.widget_id != None:
6700 
      oprot.writeFieldBegin('widget_id', TType.I64, 1)
6701 
      oprot.writeI64(self.widget_id)
94 ashish 6702 
      oprot.writeFieldEnd()
559 chandransh 6703 
    if self.items != None:
6704 
      oprot.writeFieldBegin('items', TType.LIST, 2)
6705 
      oprot.writeListBegin(TType.I64, len(self.items))
567 rajveer 6706 
      for iter64 in self.items:
6707 
        oprot.writeI64(iter64)
559 chandransh 6708 
      oprot.writeListEnd()
6709 
      oprot.writeFieldEnd()
94 ashish 6710 
    oprot.writeFieldStop()
6711 
    oprot.writeStructEnd()
6712 
 
6713 
  def __repr__(self):
6714 
    L = ['%s=%r' % (key, value)
6715 
      for key, value in self.__dict__.iteritems()]
6716 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6717 
 
6718 
  def __eq__(self, other):
6719 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6720 
 
6721 
  def __ne__(self, other):
6722 
    return not (self == other)
6723 
 
559 chandransh 6724 
class addItemToWidget_result:
94 ashish 6725 
  """
6726 
  Attributes:
559 chandransh 6727 
   - scx
6728 
  """
6729 
 
6730 
  thrift_spec = (
6731 
    None, # 0
6732 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
6733 
  )
6734 
 
6735 
  def __init__(self, scx=None,):
6736 
    self.scx = scx
6737 
 
6738 
  def read(self, iprot):
6739 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6740 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6741 
      return
6742 
    iprot.readStructBegin()
6743 
    while True:
6744 
      (fname, ftype, fid) = iprot.readFieldBegin()
6745 
      if ftype == TType.STOP:
6746 
        break
6747 
      if fid == 1:
6748 
        if ftype == TType.STRUCT:
6749 
          self.scx = WidgetException()
6750 
          self.scx.read(iprot)
6751 
        else:
6752 
          iprot.skip(ftype)
6753 
      else:
6754 
        iprot.skip(ftype)
6755 
      iprot.readFieldEnd()
6756 
    iprot.readStructEnd()
6757 
 
6758 
  def write(self, oprot):
6759 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6760 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6761 
      return
6762 
    oprot.writeStructBegin('addItemToWidget_result')
6763 
    if self.scx != None:
6764 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
6765 
      self.scx.write(oprot)
6766 
      oprot.writeFieldEnd()
6767 
    oprot.writeFieldStop()
6768 
    oprot.writeStructEnd()
6769 
 
6770 
  def __repr__(self):
6771 
    L = ['%s=%r' % (key, value)
6772 
      for key, value in self.__dict__.iteritems()]
6773 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6774 
 
6775 
  def __eq__(self, other):
6776 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6777 
 
6778 
  def __ne__(self, other):
6779 
    return not (self == other)
6780 
 
6781 
class deleteItemFromWidget_args:
6782 
  """
6783 
  Attributes:
6784 
   - widget_id
6785 
   - item_id
6786 
  """
6787 
 
6788 
  thrift_spec = (
6789 
    None, # 0
6790 
    (1, TType.I64, 'widget_id', None, None, ), # 1
6791 
    (2, TType.I64, 'item_id', None, None, ), # 2
6792 
  )
6793 
 
6794 
  def __init__(self, widget_id=None, item_id=None,):
6795 
    self.widget_id = widget_id
6796 
    self.item_id = item_id
6797 
 
6798 
  def read(self, iprot):
6799 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6800 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6801 
      return
6802 
    iprot.readStructBegin()
6803 
    while True:
6804 
      (fname, ftype, fid) = iprot.readFieldBegin()
6805 
      if ftype == TType.STOP:
6806 
        break
6807 
      if fid == 1:
6808 
        if ftype == TType.I64:
6809 
          self.widget_id = iprot.readI64();
6810 
        else:
6811 
          iprot.skip(ftype)
6812 
      elif fid == 2:
6813 
        if ftype == TType.I64:
6814 
          self.item_id = iprot.readI64();
6815 
        else:
6816 
          iprot.skip(ftype)
6817 
      else:
6818 
        iprot.skip(ftype)
6819 
      iprot.readFieldEnd()
6820 
    iprot.readStructEnd()
6821 
 
6822 
  def write(self, oprot):
6823 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6824 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6825 
      return
6826 
    oprot.writeStructBegin('deleteItemFromWidget_args')
6827 
    if self.widget_id != None:
6828 
      oprot.writeFieldBegin('widget_id', TType.I64, 1)
6829 
      oprot.writeI64(self.widget_id)
6830 
      oprot.writeFieldEnd()
6831 
    if self.item_id != None:
6832 
      oprot.writeFieldBegin('item_id', TType.I64, 2)
6833 
      oprot.writeI64(self.item_id)
6834 
      oprot.writeFieldEnd()
6835 
    oprot.writeFieldStop()
6836 
    oprot.writeStructEnd()
6837 
 
6838 
  def __repr__(self):
6839 
    L = ['%s=%r' % (key, value)
6840 
      for key, value in self.__dict__.iteritems()]
6841 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6842 
 
6843 
  def __eq__(self, other):
6844 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6845 
 
6846 
  def __ne__(self, other):
6847 
    return not (self == other)
6848 
 
6849 
class deleteItemFromWidget_result:
6850 
  """
6851 
  Attributes:
6852 
   - scx
6853 
  """
6854 
 
6855 
  thrift_spec = (
6856 
    None, # 0
6857 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
6858 
  )
6859 
 
6860 
  def __init__(self, scx=None,):
6861 
    self.scx = scx
6862 
 
6863 
  def read(self, iprot):
6864 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6865 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6866 
      return
6867 
    iprot.readStructBegin()
6868 
    while True:
6869 
      (fname, ftype, fid) = iprot.readFieldBegin()
6870 
      if ftype == TType.STOP:
6871 
        break
6872 
      if fid == 1:
6873 
        if ftype == TType.STRUCT:
6874 
          self.scx = WidgetException()
6875 
          self.scx.read(iprot)
6876 
        else:
6877 
          iprot.skip(ftype)
6878 
      else:
6879 
        iprot.skip(ftype)
6880 
      iprot.readFieldEnd()
6881 
    iprot.readStructEnd()
6882 
 
6883 
  def write(self, oprot):
6884 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6885 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6886 
      return
6887 
    oprot.writeStructBegin('deleteItemFromWidget_result')
6888 
    if self.scx != None:
6889 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
6890 
      self.scx.write(oprot)
6891 
      oprot.writeFieldEnd()
6892 
    oprot.writeFieldStop()
6893 
    oprot.writeStructEnd()
6894 
 
6895 
  def __repr__(self):
6896 
    L = ['%s=%r' % (key, value)
6897 
      for key, value in self.__dict__.iteritems()]
6898 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6899 
 
6900 
  def __eq__(self, other):
6901 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6902 
 
6903 
  def __ne__(self, other):
6904 
    return not (self == other)
6905 
 
6906 
class updateWidget_args:
6907 
  """
6908 
  Attributes:
6909 
   - widgetId
6910 
   - enable
6911 
  """
6912 
 
6913 
  thrift_spec = (
6914 
    None, # 0
6915 
    (1, TType.I64, 'widgetId', None, None, ), # 1
6916 
    (2, TType.BOOL, 'enable', None, None, ), # 2
6917 
  )
6918 
 
6919 
  def __init__(self, widgetId=None, enable=None,):
6920 
    self.widgetId = widgetId
6921 
    self.enable = enable
6922 
 
6923 
  def read(self, iprot):
6924 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6925 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6926 
      return
6927 
    iprot.readStructBegin()
6928 
    while True:
6929 
      (fname, ftype, fid) = iprot.readFieldBegin()
6930 
      if ftype == TType.STOP:
6931 
        break
6932 
      if fid == 1:
6933 
        if ftype == TType.I64:
6934 
          self.widgetId = iprot.readI64();
6935 
        else:
6936 
          iprot.skip(ftype)
6937 
      elif fid == 2:
6938 
        if ftype == TType.BOOL:
6939 
          self.enable = iprot.readBool();
6940 
        else:
6941 
          iprot.skip(ftype)
6942 
      else:
6943 
        iprot.skip(ftype)
6944 
      iprot.readFieldEnd()
6945 
    iprot.readStructEnd()
6946 
 
6947 
  def write(self, oprot):
6948 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6949 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6950 
      return
6951 
    oprot.writeStructBegin('updateWidget_args')
6952 
    if self.widgetId != None:
6953 
      oprot.writeFieldBegin('widgetId', TType.I64, 1)
6954 
      oprot.writeI64(self.widgetId)
6955 
      oprot.writeFieldEnd()
6956 
    if self.enable != None:
6957 
      oprot.writeFieldBegin('enable', TType.BOOL, 2)
6958 
      oprot.writeBool(self.enable)
6959 
      oprot.writeFieldEnd()
6960 
    oprot.writeFieldStop()
6961 
    oprot.writeStructEnd()
6962 
 
6963 
  def __repr__(self):
6964 
    L = ['%s=%r' % (key, value)
6965 
      for key, value in self.__dict__.iteritems()]
6966 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6967 
 
6968 
  def __eq__(self, other):
6969 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6970 
 
6971 
  def __ne__(self, other):
6972 
    return not (self == other)
6973 
 
6974 
class updateWidget_result:
6975 
  """
6976 
  Attributes:
6977 
   - scx
6978 
  """
6979 
 
6980 
  thrift_spec = (
6981 
    None, # 0
6982 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
6983 
  )
6984 
 
6985 
  def __init__(self, scx=None,):
6986 
    self.scx = scx
6987 
 
6988 
  def read(self, iprot):
6989 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6990 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6991 
      return
6992 
    iprot.readStructBegin()
6993 
    while True:
6994 
      (fname, ftype, fid) = iprot.readFieldBegin()
6995 
      if ftype == TType.STOP:
6996 
        break
6997 
      if fid == 1:
6998 
        if ftype == TType.STRUCT:
6999 
          self.scx = WidgetException()
7000 
          self.scx.read(iprot)
7001 
        else:
7002 
          iprot.skip(ftype)
7003 
      else:
7004 
        iprot.skip(ftype)
7005 
      iprot.readFieldEnd()
7006 
    iprot.readStructEnd()
7007 
 
7008 
  def write(self, oprot):
7009 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7010 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7011 
      return
7012 
    oprot.writeStructBegin('updateWidget_result')
7013 
    if self.scx != None:
7014 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
7015 
      self.scx.write(oprot)
7016 
      oprot.writeFieldEnd()
7017 
    oprot.writeFieldStop()
7018 
    oprot.writeStructEnd()
7019 
 
7020 
  def __repr__(self):
7021 
    L = ['%s=%r' % (key, value)
7022 
      for key, value in self.__dict__.iteritems()]
7023 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7024 
 
7025 
  def __eq__(self, other):
7026 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7027 
 
7028 
  def __ne__(self, other):
7029 
    return not (self == other)
7030 
 
7031 
class updateWidgetItem_args:
7032 
  """
7033 
  Attributes:
7034 
   - widgetId
7035 
   - enable
7036 
  """
7037 
 
7038 
  thrift_spec = (
7039 
    None, # 0
7040 
    (1, TType.I64, 'widgetId', None, None, ), # 1
7041 
    (2, TType.BOOL, 'enable', None, None, ), # 2
7042 
  )
7043 
 
7044 
  def __init__(self, widgetId=None, enable=None,):
7045 
    self.widgetId = widgetId
7046 
    self.enable = enable
7047 
 
7048 
  def read(self, iprot):
7049 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7050 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7051 
      return
7052 
    iprot.readStructBegin()
7053 
    while True:
7054 
      (fname, ftype, fid) = iprot.readFieldBegin()
7055 
      if ftype == TType.STOP:
7056 
        break
7057 
      if fid == 1:
7058 
        if ftype == TType.I64:
7059 
          self.widgetId = iprot.readI64();
7060 
        else:
7061 
          iprot.skip(ftype)
7062 
      elif fid == 2:
7063 
        if ftype == TType.BOOL:
7064 
          self.enable = iprot.readBool();
7065 
        else:
7066 
          iprot.skip(ftype)
7067 
      else:
7068 
        iprot.skip(ftype)
7069 
      iprot.readFieldEnd()
7070 
    iprot.readStructEnd()
7071 
 
7072 
  def write(self, oprot):
7073 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7074 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7075 
      return
7076 
    oprot.writeStructBegin('updateWidgetItem_args')
7077 
    if self.widgetId != None:
7078 
      oprot.writeFieldBegin('widgetId', TType.I64, 1)
7079 
      oprot.writeI64(self.widgetId)
7080 
      oprot.writeFieldEnd()
7081 
    if self.enable != None:
7082 
      oprot.writeFieldBegin('enable', TType.BOOL, 2)
7083 
      oprot.writeBool(self.enable)
7084 
      oprot.writeFieldEnd()
7085 
    oprot.writeFieldStop()
7086 
    oprot.writeStructEnd()
7087 
 
7088 
  def __repr__(self):
7089 
    L = ['%s=%r' % (key, value)
7090 
      for key, value in self.__dict__.iteritems()]
7091 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7092 
 
7093 
  def __eq__(self, other):
7094 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7095 
 
7096 
  def __ne__(self, other):
7097 
    return not (self == other)
7098 
 
7099 
class updateWidgetItem_result:
7100 
  """
7101 
  Attributes:
7102 
   - scx
7103 
  """
7104 
 
7105 
  thrift_spec = (
7106 
    None, # 0
7107 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
7108 
  )
7109 
 
7110 
  def __init__(self, scx=None,):
7111 
    self.scx = scx
7112 
 
7113 
  def read(self, iprot):
7114 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7115 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7116 
      return
7117 
    iprot.readStructBegin()
7118 
    while True:
7119 
      (fname, ftype, fid) = iprot.readFieldBegin()
7120 
      if ftype == TType.STOP:
7121 
        break
7122 
      if fid == 1:
7123 
        if ftype == TType.STRUCT:
7124 
          self.scx = WidgetException()
7125 
          self.scx.read(iprot)
7126 
        else:
7127 
          iprot.skip(ftype)
7128 
      else:
7129 
        iprot.skip(ftype)
7130 
      iprot.readFieldEnd()
7131 
    iprot.readStructEnd()
7132 
 
7133 
  def write(self, oprot):
7134 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7135 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7136 
      return
7137 
    oprot.writeStructBegin('updateWidgetItem_result')
7138 
    if self.scx != None:
7139 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
7140 
      self.scx.write(oprot)
7141 
      oprot.writeFieldEnd()
7142 
    oprot.writeFieldStop()
7143 
    oprot.writeStructEnd()
7144 
 
7145 
  def __repr__(self):
7146 
    L = ['%s=%r' % (key, value)
7147 
      for key, value in self.__dict__.iteritems()]
7148 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7149 
 
7150 
  def __eq__(self, other):
7151 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7152 
 
7153 
  def __ne__(self, other):
7154 
    return not (self == other)
7155 
 
7156 
class getWidget_args:
7157 
  """
7158 
  Attributes:
7159 
   - type
7160 
   - userId
7161 
   - onlyEnabled
7162 
  """
7163 
 
7164 
  thrift_spec = (
7165 
    None, # 0
7166 
    (1, TType.I32, 'type', None, None, ), # 1
7167 
    (2, TType.I64, 'userId', None, None, ), # 2
7168 
    (3, TType.BOOL, 'onlyEnabled', None, None, ), # 3
7169 
  )
7170 
 
7171 
  def __init__(self, type=None, userId=None, onlyEnabled=None,):
7172 
    self.type = type
7173 
    self.userId = userId
7174 
    self.onlyEnabled = onlyEnabled
7175 
 
7176 
  def read(self, iprot):
7177 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7178 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7179 
      return
7180 
    iprot.readStructBegin()
7181 
    while True:
7182 
      (fname, ftype, fid) = iprot.readFieldBegin()
7183 
      if ftype == TType.STOP:
7184 
        break
7185 
      if fid == 1:
7186 
        if ftype == TType.I32:
7187 
          self.type = iprot.readI32();
7188 
        else:
7189 
          iprot.skip(ftype)
7190 
      elif fid == 2:
7191 
        if ftype == TType.I64:
7192 
          self.userId = iprot.readI64();
7193 
        else:
7194 
          iprot.skip(ftype)
7195 
      elif fid == 3:
7196 
        if ftype == TType.BOOL:
7197 
          self.onlyEnabled = iprot.readBool();
7198 
        else:
7199 
          iprot.skip(ftype)
7200 
      else:
7201 
        iprot.skip(ftype)
7202 
      iprot.readFieldEnd()
7203 
    iprot.readStructEnd()
7204 
 
7205 
  def write(self, oprot):
7206 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7207 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7208 
      return
7209 
    oprot.writeStructBegin('getWidget_args')
7210 
    if self.type != None:
7211 
      oprot.writeFieldBegin('type', TType.I32, 1)
7212 
      oprot.writeI32(self.type)
7213 
      oprot.writeFieldEnd()
7214 
    if self.userId != None:
7215 
      oprot.writeFieldBegin('userId', TType.I64, 2)
7216 
      oprot.writeI64(self.userId)
7217 
      oprot.writeFieldEnd()
7218 
    if self.onlyEnabled != None:
7219 
      oprot.writeFieldBegin('onlyEnabled', TType.BOOL, 3)
7220 
      oprot.writeBool(self.onlyEnabled)
7221 
      oprot.writeFieldEnd()
7222 
    oprot.writeFieldStop()
7223 
    oprot.writeStructEnd()
7224 
 
7225 
  def __repr__(self):
7226 
    L = ['%s=%r' % (key, value)
7227 
      for key, value in self.__dict__.iteritems()]
7228 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7229 
 
7230 
  def __eq__(self, other):
7231 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7232 
 
7233 
  def __ne__(self, other):
7234 
    return not (self == other)
7235 
 
7236 
class getWidget_result:
7237 
  """
7238 
  Attributes:
94 ashish 7239 
   - success
559 chandransh 7240 
   - scx
94 ashish 7241 
  """
7242 
 
7243 
  thrift_spec = (
559 chandransh 7244 
    (0, TType.STRUCT, 'success', (Widget, Widget.thrift_spec), None, ), # 0
7245 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
94 ashish 7246 
  )
7247 
 
559 chandransh 7248 
  def __init__(self, success=None, scx=None,):
94 ashish 7249 
    self.success = success
559 chandransh 7250 
    self.scx = scx
94 ashish 7251 
 
7252 
  def read(self, iprot):
7253 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7254 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7255 
      return
7256 
    iprot.readStructBegin()
7257 
    while True:
7258 
      (fname, ftype, fid) = iprot.readFieldBegin()
7259 
      if ftype == TType.STOP:
7260 
        break
7261 
      if fid == 0:
559 chandransh 7262 
        if ftype == TType.STRUCT:
7263 
          self.success = Widget()
7264 
          self.success.read(iprot)
94 ashish 7265 
        else:
7266 
          iprot.skip(ftype)
7267 
      elif fid == 1:
7268 
        if ftype == TType.STRUCT:
559 chandransh 7269 
          self.scx = WidgetException()
7270 
          self.scx.read(iprot)
94 ashish 7271 
        else:
7272 
          iprot.skip(ftype)
7273 
      else:
7274 
        iprot.skip(ftype)
7275 
      iprot.readFieldEnd()
7276 
    iprot.readStructEnd()
7277 
 
7278 
  def write(self, oprot):
7279 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7280 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7281 
      return
559 chandransh 7282 
    oprot.writeStructBegin('getWidget_result')
94 ashish 7283 
    if self.success != None:
559 chandransh 7284 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7285 
      self.success.write(oprot)
94 ashish 7286 
      oprot.writeFieldEnd()
559 chandransh 7287 
    if self.scx != None:
7288 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
7289 
      self.scx.write(oprot)
94 ashish 7290 
      oprot.writeFieldEnd()
7291 
    oprot.writeFieldStop()
7292 
    oprot.writeStructEnd()
7293 
 
7294 
  def __repr__(self):
7295 
    L = ['%s=%r' % (key, value)
7296 
      for key, value in self.__dict__.iteritems()]
7297 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7298 
 
7299 
  def __eq__(self, other):
7300 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7301 
 
7302 
  def __ne__(self, other):
7303 
    return not (self == other)
7304 
 
559 chandransh 7305 
class getMyResearch_args:
94 ashish 7306 
  """
7307 
  Attributes:
559 chandransh 7308 
   - user_id
94 ashish 7309 
  """
7310 
 
7311 
  thrift_spec = (
7312 
    None, # 0
559 chandransh 7313 
    (1, TType.I64, 'user_id', None, None, ), # 1
94 ashish 7314 
  )
7315 
 
559 chandransh 7316 
  def __init__(self, user_id=None,):
7317 
    self.user_id = user_id
94 ashish 7318 
 
7319 
  def read(self, iprot):
7320 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7321 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7322 
      return
7323 
    iprot.readStructBegin()
7324 
    while True:
7325 
      (fname, ftype, fid) = iprot.readFieldBegin()
7326 
      if ftype == TType.STOP:
7327 
        break
7328 
      if fid == 1:
7329 
        if ftype == TType.I64:
559 chandransh 7330 
          self.user_id = iprot.readI64();
94 ashish 7331 
        else:
7332 
          iprot.skip(ftype)
7333 
      else:
7334 
        iprot.skip(ftype)
7335 
      iprot.readFieldEnd()
7336 
    iprot.readStructEnd()
7337 
 
7338 
  def write(self, oprot):
7339 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7340 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7341 
      return
559 chandransh 7342 
    oprot.writeStructBegin('getMyResearch_args')
7343 
    if self.user_id != None:
7344 
      oprot.writeFieldBegin('user_id', TType.I64, 1)
7345 
      oprot.writeI64(self.user_id)
94 ashish 7346 
      oprot.writeFieldEnd()
7347 
    oprot.writeFieldStop()
7348 
    oprot.writeStructEnd()
7349 
 
7350 
  def __repr__(self):
7351 
    L = ['%s=%r' % (key, value)
7352 
      for key, value in self.__dict__.iteritems()]
7353 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7354 
 
7355 
  def __eq__(self, other):
7356 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7357 
 
7358 
  def __ne__(self, other):
7359 
    return not (self == other)
7360 
 
559 chandransh 7361 
class getMyResearch_result:
94 ashish 7362 
  """
7363 
  Attributes:
7364 
   - success
559 chandransh 7365 
   - scx
94 ashish 7366 
  """
7367 
 
7368 
  thrift_spec = (
559 chandransh 7369 
    (0, TType.STRUCT, 'success', (Widget, Widget.thrift_spec), None, ), # 0
7370 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
94 ashish 7371 
  )
7372 
 
559 chandransh 7373 
  def __init__(self, success=None, scx=None,):
94 ashish 7374 
    self.success = success
559 chandransh 7375 
    self.scx = scx
94 ashish 7376 
 
7377 
  def read(self, iprot):
7378 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7379 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7380 
      return
7381 
    iprot.readStructBegin()
7382 
    while True:
7383 
      (fname, ftype, fid) = iprot.readFieldBegin()
7384 
      if ftype == TType.STOP:
7385 
        break
7386 
      if fid == 0:
559 chandransh 7387 
        if ftype == TType.STRUCT:
7388 
          self.success = Widget()
7389 
          self.success.read(iprot)
94 ashish 7390 
        else:
7391 
          iprot.skip(ftype)
7392 
      elif fid == 1:
7393 
        if ftype == TType.STRUCT:
559 chandransh 7394 
          self.scx = WidgetException()
7395 
          self.scx.read(iprot)
94 ashish 7396 
        else:
7397 
          iprot.skip(ftype)
7398 
      else:
7399 
        iprot.skip(ftype)
7400 
      iprot.readFieldEnd()
7401 
    iprot.readStructEnd()
7402 
 
7403 
  def write(self, oprot):
7404 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7405 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7406 
      return
559 chandransh 7407 
    oprot.writeStructBegin('getMyResearch_result')
94 ashish 7408 
    if self.success != None:
559 chandransh 7409 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7410 
      self.success.write(oprot)
94 ashish 7411 
      oprot.writeFieldEnd()
559 chandransh 7412 
    if self.scx != None:
7413 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
7414 
      self.scx.write(oprot)
94 ashish 7415 
      oprot.writeFieldEnd()
7416 
    oprot.writeFieldStop()
7417 
    oprot.writeStructEnd()
7418 
 
7419 
  def __repr__(self):
7420 
    L = ['%s=%r' % (key, value)
7421 
      for key, value in self.__dict__.iteritems()]
7422 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7423 
 
7424 
  def __eq__(self, other):
7425 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7426 
 
7427 
  def __ne__(self, other):
7428 
    return not (self == other)
7429 
 
559 chandransh 7430 
class updateMyResearch_args:
94 ashish 7431 
  """
7432 
  Attributes:
559 chandransh 7433 
   - user_id
7434 
   - item_id
94 ashish 7435 
  """
7436 
 
7437 
  thrift_spec = (
7438 
    None, # 0
559 chandransh 7439 
    (1, TType.I64, 'user_id', None, None, ), # 1
7440 
    (2, TType.I64, 'item_id', None, None, ), # 2
94 ashish 7441 
  )
7442 
 
559 chandransh 7443 
  def __init__(self, user_id=None, item_id=None,):
7444 
    self.user_id = user_id
7445 
    self.item_id = item_id
94 ashish 7446 
 
7447 
  def read(self, iprot):
7448 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7449 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7450 
      return
7451 
    iprot.readStructBegin()
7452 
    while True:
7453 
      (fname, ftype, fid) = iprot.readFieldBegin()
7454 
      if ftype == TType.STOP:
7455 
        break
7456 
      if fid == 1:
7457 
        if ftype == TType.I64:
559 chandransh 7458 
          self.user_id = iprot.readI64();
94 ashish 7459 
        else:
7460 
          iprot.skip(ftype)
7461 
      elif fid == 2:
559 chandransh 7462 
        if ftype == TType.I64:
7463 
          self.item_id = iprot.readI64();
94 ashish 7464 
        else:
7465 
          iprot.skip(ftype)
7466 
      else:
7467 
        iprot.skip(ftype)
7468 
      iprot.readFieldEnd()
7469 
    iprot.readStructEnd()
7470 
 
7471 
  def write(self, oprot):
7472 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7473 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7474 
      return
559 chandransh 7475 
    oprot.writeStructBegin('updateMyResearch_args')
7476 
    if self.user_id != None:
7477 
      oprot.writeFieldBegin('user_id', TType.I64, 1)
7478 
      oprot.writeI64(self.user_id)
94 ashish 7479 
      oprot.writeFieldEnd()
559 chandransh 7480 
    if self.item_id != None:
7481 
      oprot.writeFieldBegin('item_id', TType.I64, 2)
7482 
      oprot.writeI64(self.item_id)
94 ashish 7483 
      oprot.writeFieldEnd()
7484 
    oprot.writeFieldStop()
7485 
    oprot.writeStructEnd()
7486 
 
7487 
  def __repr__(self):
7488 
    L = ['%s=%r' % (key, value)
7489 
      for key, value in self.__dict__.iteritems()]
7490 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7491 
 
7492 
  def __eq__(self, other):
7493 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7494 
 
7495 
  def __ne__(self, other):
7496 
    return not (self == other)
7497 
 
559 chandransh 7498 
class updateMyResearch_result:
94 ashish 7499 
  """
7500 
  Attributes:
7501 
   - success
559 chandransh 7502 
   - scx
94 ashish 7503 
  """
7504 
 
7505 
  thrift_spec = (
7506 
    (0, TType.BOOL, 'success', None, None, ), # 0
559 chandransh 7507 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
94 ashish 7508 
  )
7509 
 
559 chandransh 7510 
  def __init__(self, success=None, scx=None,):
94 ashish 7511 
    self.success = success
559 chandransh 7512 
    self.scx = scx
94 ashish 7513 
 
7514 
  def read(self, iprot):
7515 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7516 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7517 
      return
7518 
    iprot.readStructBegin()
7519 
    while True:
7520 
      (fname, ftype, fid) = iprot.readFieldBegin()
7521 
      if ftype == TType.STOP:
7522 
        break
7523 
      if fid == 0:
7524 
        if ftype == TType.BOOL:
7525 
          self.success = iprot.readBool();
7526 
        else:
7527 
          iprot.skip(ftype)
7528 
      elif fid == 1:
7529 
        if ftype == TType.STRUCT:
559 chandransh 7530 
          self.scx = WidgetException()
7531 
          self.scx.read(iprot)
94 ashish 7532 
        else:
7533 
          iprot.skip(ftype)
7534 
      else:
7535 
        iprot.skip(ftype)
7536 
      iprot.readFieldEnd()
7537 
    iprot.readStructEnd()
7538 
 
7539 
  def write(self, oprot):
7540 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7541 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7542 
      return
559 chandransh 7543 
    oprot.writeStructBegin('updateMyResearch_result')
94 ashish 7544 
    if self.success != None:
7545 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
7546 
      oprot.writeBool(self.success)
7547 
      oprot.writeFieldEnd()
559 chandransh 7548 
    if self.scx != None:
7549 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
7550 
      self.scx.write(oprot)
94 ashish 7551 
      oprot.writeFieldEnd()
7552 
    oprot.writeFieldStop()
7553 
    oprot.writeStructEnd()
7554 
 
7555 
  def __repr__(self):
7556 
    L = ['%s=%r' % (key, value)
7557 
      for key, value in self.__dict__.iteritems()]
7558 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7559 
 
7560 
  def __eq__(self, other):
7561 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7562 
 
7563 
  def __ne__(self, other):
7564 
    return not (self == other)
7565 
 
559 chandransh 7566 
class deleteItemFromMyResearch_args:
130 ashish 7567 
  """
7568 
  Attributes:
559 chandransh 7569 
   - user_id
7570 
   - item_id
130 ashish 7571 
  """
94 ashish 7572 
 
130 ashish 7573 
  thrift_spec = (
7574 
    None, # 0
559 chandransh 7575 
    (1, TType.I64, 'user_id', None, None, ), # 1
7576 
    (2, TType.I64, 'item_id', None, None, ), # 2
130 ashish 7577 
  )
7578 
 
559 chandransh 7579 
  def __init__(self, user_id=None, item_id=None,):
7580 
    self.user_id = user_id
7581 
    self.item_id = item_id
130 ashish 7582 
 
7583 
  def read(self, iprot):
7584 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7585 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7586 
      return
7587 
    iprot.readStructBegin()
7588 
    while True:
7589 
      (fname, ftype, fid) = iprot.readFieldBegin()
7590 
      if ftype == TType.STOP:
7591 
        break
7592 
      if fid == 1:
7593 
        if ftype == TType.I64:
559 chandransh 7594 
          self.user_id = iprot.readI64();
130 ashish 7595 
        else:
7596 
          iprot.skip(ftype)
559 chandransh 7597 
      elif fid == 2:
7598 
        if ftype == TType.I64:
7599 
          self.item_id = iprot.readI64();
7600 
        else:
7601 
          iprot.skip(ftype)
130 ashish 7602 
      else:
7603 
        iprot.skip(ftype)
7604 
      iprot.readFieldEnd()
7605 
    iprot.readStructEnd()
7606 
 
7607 
  def write(self, oprot):
7608 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7609 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7610 
      return
559 chandransh 7611 
    oprot.writeStructBegin('deleteItemFromMyResearch_args')
7612 
    if self.user_id != None:
7613 
      oprot.writeFieldBegin('user_id', TType.I64, 1)
7614 
      oprot.writeI64(self.user_id)
130 ashish 7615 
      oprot.writeFieldEnd()
559 chandransh 7616 
    if self.item_id != None:
7617 
      oprot.writeFieldBegin('item_id', TType.I64, 2)
7618 
      oprot.writeI64(self.item_id)
7619 
      oprot.writeFieldEnd()
130 ashish 7620 
    oprot.writeFieldStop()
7621 
    oprot.writeStructEnd()
7622 
 
7623 
  def __repr__(self):
7624 
    L = ['%s=%r' % (key, value)
7625 
      for key, value in self.__dict__.iteritems()]
7626 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7627 
 
7628 
  def __eq__(self, other):
7629 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7630 
 
7631 
  def __ne__(self, other):
7632 
    return not (self == other)
7633 
 
559 chandransh 7634 
class deleteItemFromMyResearch_result:
130 ashish 7635 
  """
7636 
  Attributes:
559 chandransh 7637 
   - scx
7638 
  """
7639 
 
7640 
  thrift_spec = (
7641 
    None, # 0
7642 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
7643 
  )
7644 
 
7645 
  def __init__(self, scx=None,):
7646 
    self.scx = scx
7647 
 
7648 
  def read(self, iprot):
7649 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7650 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7651 
      return
7652 
    iprot.readStructBegin()
7653 
    while True:
7654 
      (fname, ftype, fid) = iprot.readFieldBegin()
7655 
      if ftype == TType.STOP:
7656 
        break
7657 
      if fid == 1:
7658 
        if ftype == TType.STRUCT:
7659 
          self.scx = WidgetException()
7660 
          self.scx.read(iprot)
7661 
        else:
7662 
          iprot.skip(ftype)
7663 
      else:
7664 
        iprot.skip(ftype)
7665 
      iprot.readFieldEnd()
7666 
    iprot.readStructEnd()
7667 
 
7668 
  def write(self, oprot):
7669 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7670 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7671 
      return
7672 
    oprot.writeStructBegin('deleteItemFromMyResearch_result')
7673 
    if self.scx != None:
7674 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
7675 
      self.scx.write(oprot)
7676 
      oprot.writeFieldEnd()
7677 
    oprot.writeFieldStop()
7678 
    oprot.writeStructEnd()
7679 
 
7680 
  def __repr__(self):
7681 
    L = ['%s=%r' % (key, value)
7682 
      for key, value in self.__dict__.iteritems()]
7683 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7684 
 
7685 
  def __eq__(self, other):
7686 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7687 
 
7688 
  def __ne__(self, other):
7689 
    return not (self == other)
7690 
 
7691 
class updateRatings_args:
7692 
  """
7693 
  Attributes:
7694 
   - item_id
7695 
   - type
7696 
   - rating
7697 
   - user_id
7698 
  """
7699 
 
7700 
  thrift_spec = (
7701 
    None, # 0
7702 
    (1, TType.I64, 'item_id', None, None, ), # 1
7703 
    (2, TType.I32, 'type', None, None, ), # 2
7704 
    (3, TType.DOUBLE, 'rating', None, None, ), # 3
7705 
    (4, TType.I64, 'user_id', None, None, ), # 4
7706 
  )
7707 
 
7708 
  def __init__(self, item_id=None, type=None, rating=None, user_id=None,):
7709 
    self.item_id = item_id
7710 
    self.type = type
7711 
    self.rating = rating
7712 
    self.user_id = user_id
7713 
 
7714 
  def read(self, iprot):
7715 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7716 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7717 
      return
7718 
    iprot.readStructBegin()
7719 
    while True:
7720 
      (fname, ftype, fid) = iprot.readFieldBegin()
7721 
      if ftype == TType.STOP:
7722 
        break
7723 
      if fid == 1:
7724 
        if ftype == TType.I64:
7725 
          self.item_id = iprot.readI64();
7726 
        else:
7727 
          iprot.skip(ftype)
7728 
      elif fid == 2:
7729 
        if ftype == TType.I32:
7730 
          self.type = iprot.readI32();
7731 
        else:
7732 
          iprot.skip(ftype)
7733 
      elif fid == 3:
7734 
        if ftype == TType.DOUBLE:
7735 
          self.rating = iprot.readDouble();
7736 
        else:
7737 
          iprot.skip(ftype)
7738 
      elif fid == 4:
7739 
        if ftype == TType.I64:
7740 
          self.user_id = iprot.readI64();
7741 
        else:
7742 
          iprot.skip(ftype)
7743 
      else:
7744 
        iprot.skip(ftype)
7745 
      iprot.readFieldEnd()
7746 
    iprot.readStructEnd()
7747 
 
7748 
  def write(self, oprot):
7749 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7750 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7751 
      return
7752 
    oprot.writeStructBegin('updateRatings_args')
7753 
    if self.item_id != None:
7754 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
7755 
      oprot.writeI64(self.item_id)
7756 
      oprot.writeFieldEnd()
7757 
    if self.type != None:
7758 
      oprot.writeFieldBegin('type', TType.I32, 2)
7759 
      oprot.writeI32(self.type)
7760 
      oprot.writeFieldEnd()
7761 
    if self.rating != None:
7762 
      oprot.writeFieldBegin('rating', TType.DOUBLE, 3)
7763 
      oprot.writeDouble(self.rating)
7764 
      oprot.writeFieldEnd()
7765 
    if self.user_id != None:
7766 
      oprot.writeFieldBegin('user_id', TType.I64, 4)
7767 
      oprot.writeI64(self.user_id)
7768 
      oprot.writeFieldEnd()
7769 
    oprot.writeFieldStop()
7770 
    oprot.writeStructEnd()
7771 
 
7772 
  def __repr__(self):
7773 
    L = ['%s=%r' % (key, value)
7774 
      for key, value in self.__dict__.iteritems()]
7775 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7776 
 
7777 
  def __eq__(self, other):
7778 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7779 
 
7780 
  def __ne__(self, other):
7781 
    return not (self == other)
7782 
 
7783 
class updateRatings_result:
7784 
 
7785 
  thrift_spec = (
7786 
  )
7787 
 
7788 
  def read(self, iprot):
7789 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7790 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7791 
      return
7792 
    iprot.readStructBegin()
7793 
    while True:
7794 
      (fname, ftype, fid) = iprot.readFieldBegin()
7795 
      if ftype == TType.STOP:
7796 
        break
7797 
      else:
7798 
        iprot.skip(ftype)
7799 
      iprot.readFieldEnd()
7800 
    iprot.readStructEnd()
7801 
 
7802 
  def write(self, oprot):
7803 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7804 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7805 
      return
7806 
    oprot.writeStructBegin('updateRatings_result')
7807 
    oprot.writeFieldStop()
7808 
    oprot.writeStructEnd()
7809 
 
7810 
  def __repr__(self):
7811 
    L = ['%s=%r' % (key, value)
7812 
      for key, value in self.__dict__.iteritems()]
7813 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7814 
 
7815 
  def __eq__(self, other):
7816 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7817 
 
7818 
  def __ne__(self, other):
7819 
    return not (self == other)
7820 
 
7821 
class getRatings_args:
7822 
  """
7823 
  Attributes:
7824 
   - item_id
7825 
   - user_id
7826 
  """
7827 
 
7828 
  thrift_spec = (
7829 
    None, # 0
7830 
    (1, TType.I64, 'item_id', None, None, ), # 1
7831 
    (2, TType.I64, 'user_id', None, None, ), # 2
7832 
  )
7833 
 
7834 
  def __init__(self, item_id=None, user_id=None,):
7835 
    self.item_id = item_id
7836 
    self.user_id = user_id
7837 
 
7838 
  def read(self, iprot):
7839 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7840 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7841 
      return
7842 
    iprot.readStructBegin()
7843 
    while True:
7844 
      (fname, ftype, fid) = iprot.readFieldBegin()
7845 
      if ftype == TType.STOP:
7846 
        break
7847 
      if fid == 1:
7848 
        if ftype == TType.I64:
7849 
          self.item_id = iprot.readI64();
7850 
        else:
7851 
          iprot.skip(ftype)
7852 
      elif fid == 2:
7853 
        if ftype == TType.I64:
7854 
          self.user_id = iprot.readI64();
7855 
        else:
7856 
          iprot.skip(ftype)
7857 
      else:
7858 
        iprot.skip(ftype)
7859 
      iprot.readFieldEnd()
7860 
    iprot.readStructEnd()
7861 
 
7862 
  def write(self, oprot):
7863 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7864 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7865 
      return
7866 
    oprot.writeStructBegin('getRatings_args')
7867 
    if self.item_id != None:
7868 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
7869 
      oprot.writeI64(self.item_id)
7870 
      oprot.writeFieldEnd()
7871 
    if self.user_id != None:
7872 
      oprot.writeFieldBegin('user_id', TType.I64, 2)
7873 
      oprot.writeI64(self.user_id)
7874 
      oprot.writeFieldEnd()
7875 
    oprot.writeFieldStop()
7876 
    oprot.writeStructEnd()
7877 
 
7878 
  def __repr__(self):
7879 
    L = ['%s=%r' % (key, value)
7880 
      for key, value in self.__dict__.iteritems()]
7881 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7882 
 
7883 
  def __eq__(self, other):
7884 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7885 
 
7886 
  def __ne__(self, other):
7887 
    return not (self == other)
7888 
 
7889 
class getRatings_result:
7890 
  """
7891 
  Attributes:
130 ashish 7892 
   - success
559 chandransh 7893 
   - scx
130 ashish 7894 
  """
7895 
 
7896 
  thrift_spec = (
559 chandransh 7897 
    (0, TType.STRUCT, 'success', (RatingsWidget, RatingsWidget.thrift_spec), None, ), # 0
7898 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
130 ashish 7899 
  )
7900 
 
559 chandransh 7901 
  def __init__(self, success=None, scx=None,):
130 ashish 7902 
    self.success = success
559 chandransh 7903 
    self.scx = scx
130 ashish 7904 
 
7905 
  def read(self, iprot):
7906 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7907 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7908 
      return
7909 
    iprot.readStructBegin()
7910 
    while True:
7911 
      (fname, ftype, fid) = iprot.readFieldBegin()
7912 
      if ftype == TType.STOP:
7913 
        break
7914 
      if fid == 0:
559 chandransh 7915 
        if ftype == TType.STRUCT:
7916 
          self.success = RatingsWidget()
7917 
          self.success.read(iprot)
130 ashish 7918 
        else:
7919 
          iprot.skip(ftype)
7920 
      elif fid == 1:
7921 
        if ftype == TType.STRUCT:
559 chandransh 7922 
          self.scx = WidgetException()
7923 
          self.scx.read(iprot)
130 ashish 7924 
        else:
7925 
          iprot.skip(ftype)
7926 
      else:
7927 
        iprot.skip(ftype)
7928 
      iprot.readFieldEnd()
7929 
    iprot.readStructEnd()
7930 
 
7931 
  def write(self, oprot):
7932 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7933 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7934 
      return
559 chandransh 7935 
    oprot.writeStructBegin('getRatings_result')
130 ashish 7936 
    if self.success != None:
559 chandransh 7937 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7938 
      self.success.write(oprot)
130 ashish 7939 
      oprot.writeFieldEnd()
559 chandransh 7940 
    if self.scx != None:
7941 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
7942 
      self.scx.write(oprot)
130 ashish 7943 
      oprot.writeFieldEnd()
7944 
    oprot.writeFieldStop()
7945 
    oprot.writeStructEnd()
7946 
 
7947 
  def __repr__(self):
7948 
    L = ['%s=%r' % (key, value)
7949 
      for key, value in self.__dict__.iteritems()]
7950 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7951 
 
7952 
  def __eq__(self, other):
7953 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7954 
 
7955 
  def __ne__(self, other):
7956 
    return not (self == other)
7957 
 
559 chandransh 7958 
class updateBrowseHistory_args:
130 ashish 7959 
  """
7960 
  Attributes:
559 chandransh 7961 
   - user_id
7962 
   - item_id
7963 
   - isSessionId
130 ashish 7964 
  """
7965 
 
7966 
  thrift_spec = (
7967 
    None, # 0
559 chandransh 7968 
    (1, TType.I64, 'user_id', None, None, ), # 1
7969 
    (2, TType.I64, 'item_id', None, None, ), # 2
7970 
    (3, TType.BOOL, 'isSessionId', None, None, ), # 3
130 ashish 7971 
  )
7972 
 
559 chandransh 7973 
  def __init__(self, user_id=None, item_id=None, isSessionId=None,):
7974 
    self.user_id = user_id
7975 
    self.item_id = item_id
7976 
    self.isSessionId = isSessionId
130 ashish 7977 
 
7978 
  def read(self, iprot):
7979 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7980 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7981 
      return
7982 
    iprot.readStructBegin()
7983 
    while True:
7984 
      (fname, ftype, fid) = iprot.readFieldBegin()
7985 
      if ftype == TType.STOP:
7986 
        break
7987 
      if fid == 1:
559 chandransh 7988 
        if ftype == TType.I64:
7989 
          self.user_id = iprot.readI64();
130 ashish 7990 
        else:
7991 
          iprot.skip(ftype)
7992 
      elif fid == 2:
559 chandransh 7993 
        if ftype == TType.I64:
7994 
          self.item_id = iprot.readI64();
7995 
        else:
7996 
          iprot.skip(ftype)
7997 
      elif fid == 3:
130 ashish 7998 
        if ftype == TType.BOOL:
559 chandransh 7999 
          self.isSessionId = iprot.readBool();
130 ashish 8000 
        else:
8001 
          iprot.skip(ftype)
8002 
      else:
8003 
        iprot.skip(ftype)
8004 
      iprot.readFieldEnd()
8005 
    iprot.readStructEnd()
8006 
 
8007 
  def write(self, oprot):
8008 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8009 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8010 
      return
559 chandransh 8011 
    oprot.writeStructBegin('updateBrowseHistory_args')
8012 
    if self.user_id != None:
8013 
      oprot.writeFieldBegin('user_id', TType.I64, 1)
8014 
      oprot.writeI64(self.user_id)
130 ashish 8015 
      oprot.writeFieldEnd()
559 chandransh 8016 
    if self.item_id != None:
8017 
      oprot.writeFieldBegin('item_id', TType.I64, 2)
8018 
      oprot.writeI64(self.item_id)
130 ashish 8019 
      oprot.writeFieldEnd()
559 chandransh 8020 
    if self.isSessionId != None:
8021 
      oprot.writeFieldBegin('isSessionId', TType.BOOL, 3)
8022 
      oprot.writeBool(self.isSessionId)
8023 
      oprot.writeFieldEnd()
130 ashish 8024 
    oprot.writeFieldStop()
8025 
    oprot.writeStructEnd()
8026 
 
8027 
  def __repr__(self):
8028 
    L = ['%s=%r' % (key, value)
8029 
      for key, value in self.__dict__.iteritems()]
8030 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8031 
 
8032 
  def __eq__(self, other):
8033 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8034 
 
8035 
  def __ne__(self, other):
8036 
    return not (self == other)
8037 
 
559 chandransh 8038 
class updateBrowseHistory_result:
8039 
 
8040 
  thrift_spec = (
8041 
  )
8042 
 
8043 
  def read(self, iprot):
8044 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8045 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8046 
      return
8047 
    iprot.readStructBegin()
8048 
    while True:
8049 
      (fname, ftype, fid) = iprot.readFieldBegin()
8050 
      if ftype == TType.STOP:
8051 
        break
8052 
      else:
8053 
        iprot.skip(ftype)
8054 
      iprot.readFieldEnd()
8055 
    iprot.readStructEnd()
8056 
 
8057 
  def write(self, oprot):
8058 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8059 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8060 
      return
8061 
    oprot.writeStructBegin('updateBrowseHistory_result')
8062 
    oprot.writeFieldStop()
8063 
    oprot.writeStructEnd()
8064 
 
8065 
  def __repr__(self):
8066 
    L = ['%s=%r' % (key, value)
8067 
      for key, value in self.__dict__.iteritems()]
8068 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8069 
 
8070 
  def __eq__(self, other):
8071 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8072 
 
8073 
  def __ne__(self, other):
8074 
    return not (self == other)
8075 
 
8076 
class getBrowseHistory_args:
130 ashish 8077 
  """
8078 
  Attributes:
559 chandransh 8079 
   - userId
8080 
   - isSessionId
8081 
  """
8082 
 
8083 
  thrift_spec = (
8084 
    None, # 0
8085 
    (1, TType.I64, 'userId', None, None, ), # 1
8086 
    (2, TType.BOOL, 'isSessionId', None, None, ), # 2
8087 
  )
8088 
 
8089 
  def __init__(self, userId=None, isSessionId=None,):
8090 
    self.userId = userId
8091 
    self.isSessionId = isSessionId
8092 
 
8093 
  def read(self, iprot):
8094 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8095 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8096 
      return
8097 
    iprot.readStructBegin()
8098 
    while True:
8099 
      (fname, ftype, fid) = iprot.readFieldBegin()
8100 
      if ftype == TType.STOP:
8101 
        break
8102 
      if fid == 1:
8103 
        if ftype == TType.I64:
8104 
          self.userId = iprot.readI64();
8105 
        else:
8106 
          iprot.skip(ftype)
8107 
      elif fid == 2:
8108 
        if ftype == TType.BOOL:
8109 
          self.isSessionId = iprot.readBool();
8110 
        else:
8111 
          iprot.skip(ftype)
8112 
      else:
8113 
        iprot.skip(ftype)
8114 
      iprot.readFieldEnd()
8115 
    iprot.readStructEnd()
8116 
 
8117 
  def write(self, oprot):
8118 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8119 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8120 
      return
8121 
    oprot.writeStructBegin('getBrowseHistory_args')
8122 
    if self.userId != None:
8123 
      oprot.writeFieldBegin('userId', TType.I64, 1)
8124 
      oprot.writeI64(self.userId)
8125 
      oprot.writeFieldEnd()
8126 
    if self.isSessionId != None:
8127 
      oprot.writeFieldBegin('isSessionId', TType.BOOL, 2)
8128 
      oprot.writeBool(self.isSessionId)
8129 
      oprot.writeFieldEnd()
8130 
    oprot.writeFieldStop()
8131 
    oprot.writeStructEnd()
8132 
 
8133 
  def __repr__(self):
8134 
    L = ['%s=%r' % (key, value)
8135 
      for key, value in self.__dict__.iteritems()]
8136 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8137 
 
8138 
  def __eq__(self, other):
8139 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8140 
 
8141 
  def __ne__(self, other):
8142 
    return not (self == other)
8143 
 
8144 
class getBrowseHistory_result:
8145 
  """
8146 
  Attributes:
130 ashish 8147 
   - success
559 chandransh 8148 
   - scx
130 ashish 8149 
  """
8150 
 
8151 
  thrift_spec = (
559 chandransh 8152 
    (0, TType.STRUCT, 'success', (Widget, Widget.thrift_spec), None, ), # 0
8153 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
130 ashish 8154 
  )
8155 
 
559 chandransh 8156 
  def __init__(self, success=None, scx=None,):
130 ashish 8157 
    self.success = success
559 chandransh 8158 
    self.scx = scx
130 ashish 8159 
 
8160 
  def read(self, iprot):
8161 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8162 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8163 
      return
8164 
    iprot.readStructBegin()
8165 
    while True:
8166 
      (fname, ftype, fid) = iprot.readFieldBegin()
8167 
      if ftype == TType.STOP:
8168 
        break
8169 
      if fid == 0:
559 chandransh 8170 
        if ftype == TType.STRUCT:
8171 
          self.success = Widget()
8172 
          self.success.read(iprot)
130 ashish 8173 
        else:
8174 
          iprot.skip(ftype)
8175 
      elif fid == 1:
8176 
        if ftype == TType.STRUCT:
559 chandransh 8177 
          self.scx = WidgetException()
8178 
          self.scx.read(iprot)
130 ashish 8179 
        else:
8180 
          iprot.skip(ftype)
8181 
      else:
8182 
        iprot.skip(ftype)
8183 
      iprot.readFieldEnd()
8184 
    iprot.readStructEnd()
8185 
 
8186 
  def write(self, oprot):
8187 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8188 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8189 
      return
559 chandransh 8190 
    oprot.writeStructBegin('getBrowseHistory_result')
130 ashish 8191 
    if self.success != None:
559 chandransh 8192 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8193 
      self.success.write(oprot)
130 ashish 8194 
      oprot.writeFieldEnd()
559 chandransh 8195 
    if self.scx != None:
8196 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
8197 
      self.scx.write(oprot)
130 ashish 8198 
      oprot.writeFieldEnd()
8199 
    oprot.writeFieldStop()
8200 
    oprot.writeStructEnd()
8201 
 
8202 
  def __repr__(self):
8203 
    L = ['%s=%r' % (key, value)
8204 
      for key, value in self.__dict__.iteritems()]
8205 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8206 
 
8207 
  def __eq__(self, other):
8208 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8209 
 
8210 
  def __ne__(self, other):
8211 
    return not (self == other)
8212 
 
8213