Subversion Repositories SmartDukaan

Rev

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