Subversion Repositories SmartDukaan

Rev

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

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