Subversion Repositories SmartDukaan

Rev

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

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