Subversion Repositories SmartDukaan

Rev

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