Subversion Repositories SmartDukaan

Rev

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

Rev Author Line No. Line
349 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 
  def sendMail(self, mail):
20 
    """
21 
    Parameters:
22 
     - mail
23 
    """
24 
    pass
25 
 
26 
  def sendText(self, message):
27 
    """
28 
    Parameters:
29 
     - message
30 
    """
31 
    pass
32 
 
33 
  def addMessage(self, message):
34 
    """
35 
    Parameters:
36 
     - message
37 
    """
38 
    pass
39 
 
40 
  def updateMessage(self, id, message):
41 
    """
42 
    Parameters:
43 
     - id
44 
     - message
45 
    """
46 
    pass
47 
 
48 
  def getMessage(self, id):
49 
    """
50 
    Parameters:
51 
     - id
52 
    """
53 
    pass
54 
 
55 
  def getSubstitutedMessage(self, id, params):
56 
    """
57 
    Parameters:
58 
     - id
59 
     - params
60 
    """
61 
    pass
62 
 
494 rajveer 63 
  def addUser(self, username, password, warehouseId):
64 
    """
65 
    Parameters:
66 
     - username
67 
     - password
68 
     - warehouseId
69 
    """
70 
    pass
349 ashish 71 
 
494 rajveer 72 
  def deleteUser(self, username):
73 
    """
74 
    Parameters:
75 
     - username
76 
    """
77 
    pass
78 
 
79 
  def authenticateUser(self, username, password):
80 
    """
81 
    Parameters:
82 
     - username
83 
     - password
84 
    """
85 
    pass
86 
 
87 
  def updatePassword(self, username, oldPassword, newPassword):
88 
    """
89 
    Parameters:
90 
     - username
91 
     - oldPassword
92 
     - newPassword
93 
    """
94 
    pass
95 
 
96 
 
349 ashish 97 
class Client(Iface):
98 
  def __init__(self, iprot, oprot=None):
99 
    self._iprot = self._oprot = iprot
100 
    if oprot != None:
101 
      self._oprot = oprot
102 
    self._seqid = 0
103 
 
104 
  def sendMail(self, mail):
105 
    """
106 
    Parameters:
107 
     - mail
108 
    """
109 
    self.send_sendMail(mail)
110 
    self.recv_sendMail()
111 
 
112 
  def send_sendMail(self, mail):
113 
    self._oprot.writeMessageBegin('sendMail', TMessageType.CALL, self._seqid)
114 
    args = sendMail_args()
115 
    args.mail = mail
116 
    args.write(self._oprot)
117 
    self._oprot.writeMessageEnd()
118 
    self._oprot.trans.flush()
119 
 
120 
  def recv_sendMail(self, ):
121 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
122 
    if mtype == TMessageType.EXCEPTION:
123 
      x = TApplicationException()
124 
      x.read(self._iprot)
125 
      self._iprot.readMessageEnd()
126 
      raise x
127 
    result = sendMail_result()
128 
    result.read(self._iprot)
129 
    self._iprot.readMessageEnd()
130 
    if result.se != None:
131 
      raise result.se
132 
    return
133 
 
134 
  def sendText(self, message):
135 
    """
136 
    Parameters:
137 
     - message
138 
    """
139 
    self.send_sendText(message)
140 
    self.recv_sendText()
141 
 
142 
  def send_sendText(self, message):
143 
    self._oprot.writeMessageBegin('sendText', TMessageType.CALL, self._seqid)
144 
    args = sendText_args()
145 
    args.message = message
146 
    args.write(self._oprot)
147 
    self._oprot.writeMessageEnd()
148 
    self._oprot.trans.flush()
149 
 
150 
  def recv_sendText(self, ):
151 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
152 
    if mtype == TMessageType.EXCEPTION:
153 
      x = TApplicationException()
154 
      x.read(self._iprot)
155 
      self._iprot.readMessageEnd()
156 
      raise x
157 
    result = sendText_result()
158 
    result.read(self._iprot)
159 
    self._iprot.readMessageEnd()
160 
    if result.se != None:
161 
      raise result.se
162 
    return
163 
 
164 
  def addMessage(self, message):
165 
    """
166 
    Parameters:
167 
     - message
168 
    """
169 
    self.send_addMessage(message)
170 
    self.recv_addMessage()
171 
 
172 
  def send_addMessage(self, message):
173 
    self._oprot.writeMessageBegin('addMessage', TMessageType.CALL, self._seqid)
174 
    args = addMessage_args()
175 
    args.message = message
176 
    args.write(self._oprot)
177 
    self._oprot.writeMessageEnd()
178 
    self._oprot.trans.flush()
179 
 
180 
  def recv_addMessage(self, ):
181 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
182 
    if mtype == TMessageType.EXCEPTION:
183 
      x = TApplicationException()
184 
      x.read(self._iprot)
185 
      self._iprot.readMessageEnd()
186 
      raise x
187 
    result = addMessage_result()
188 
    result.read(self._iprot)
189 
    self._iprot.readMessageEnd()
190 
    if result.se != None:
191 
      raise result.se
192 
    return
193 
 
194 
  def updateMessage(self, id, message):
195 
    """
196 
    Parameters:
197 
     - id
198 
     - message
199 
    """
200 
    self.send_updateMessage(id, message)
201 
    self.recv_updateMessage()
202 
 
203 
  def send_updateMessage(self, id, message):
204 
    self._oprot.writeMessageBegin('updateMessage', TMessageType.CALL, self._seqid)
205 
    args = updateMessage_args()
206 
    args.id = id
207 
    args.message = message
208 
    args.write(self._oprot)
209 
    self._oprot.writeMessageEnd()
210 
    self._oprot.trans.flush()
211 
 
212 
  def recv_updateMessage(self, ):
213 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
214 
    if mtype == TMessageType.EXCEPTION:
215 
      x = TApplicationException()
216 
      x.read(self._iprot)
217 
      self._iprot.readMessageEnd()
218 
      raise x
219 
    result = updateMessage_result()
220 
    result.read(self._iprot)
221 
    self._iprot.readMessageEnd()
222 
    if result.se != None:
223 
      raise result.se
224 
    return
225 
 
226 
  def getMessage(self, id):
227 
    """
228 
    Parameters:
229 
     - id
230 
    """
231 
    self.send_getMessage(id)
353 ashish 232 
    return self.recv_getMessage()
349 ashish 233 
 
234 
  def send_getMessage(self, id):
235 
    self._oprot.writeMessageBegin('getMessage', TMessageType.CALL, self._seqid)
236 
    args = getMessage_args()
237 
    args.id = id
238 
    args.write(self._oprot)
239 
    self._oprot.writeMessageEnd()
240 
    self._oprot.trans.flush()
241 
 
242 
  def recv_getMessage(self, ):
243 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
244 
    if mtype == TMessageType.EXCEPTION:
245 
      x = TApplicationException()
246 
      x.read(self._iprot)
247 
      self._iprot.readMessageEnd()
248 
      raise x
249 
    result = getMessage_result()
250 
    result.read(self._iprot)
251 
    self._iprot.readMessageEnd()
353 ashish 252 
    if result.success != None:
253 
      return result.success
349 ashish 254 
    if result.se != None:
255 
      raise result.se
353 ashish 256 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMessage failed: unknown result");
349 ashish 257 
 
258 
  def getSubstitutedMessage(self, id, params):
259 
    """
260 
    Parameters:
261 
     - id
262 
     - params
263 
    """
264 
    self.send_getSubstitutedMessage(id, params)
353 ashish 265 
    return self.recv_getSubstitutedMessage()
349 ashish 266 
 
267 
  def send_getSubstitutedMessage(self, id, params):
268 
    self._oprot.writeMessageBegin('getSubstitutedMessage', TMessageType.CALL, self._seqid)
269 
    args = getSubstitutedMessage_args()
270 
    args.id = id
271 
    args.params = params
272 
    args.write(self._oprot)
273 
    self._oprot.writeMessageEnd()
274 
    self._oprot.trans.flush()
275 
 
276 
  def recv_getSubstitutedMessage(self, ):
277 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
278 
    if mtype == TMessageType.EXCEPTION:
279 
      x = TApplicationException()
280 
      x.read(self._iprot)
281 
      self._iprot.readMessageEnd()
282 
      raise x
283 
    result = getSubstitutedMessage_result()
284 
    result.read(self._iprot)
285 
    self._iprot.readMessageEnd()
353 ashish 286 
    if result.success != None:
287 
      return result.success
349 ashish 288 
    if result.se != None:
289 
      raise result.se
353 ashish 290 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSubstitutedMessage failed: unknown result");
349 ashish 291 
 
494 rajveer 292 
  def addUser(self, username, password, warehouseId):
293 
    """
294 
    Parameters:
295 
     - username
296 
     - password
297 
     - warehouseId
298 
    """
299 
    self.send_addUser(username, password, warehouseId)
300 
    return self.recv_addUser()
349 ashish 301 
 
494 rajveer 302 
  def send_addUser(self, username, password, warehouseId):
303 
    self._oprot.writeMessageBegin('addUser', TMessageType.CALL, self._seqid)
304 
    args = addUser_args()
305 
    args.username = username
306 
    args.password = password
307 
    args.warehouseId = warehouseId
308 
    args.write(self._oprot)
309 
    self._oprot.writeMessageEnd()
310 
    self._oprot.trans.flush()
311 
 
312 
  def recv_addUser(self, ):
313 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
314 
    if mtype == TMessageType.EXCEPTION:
315 
      x = TApplicationException()
316 
      x.read(self._iprot)
317 
      self._iprot.readMessageEnd()
318 
      raise x
319 
    result = addUser_result()
320 
    result.read(self._iprot)
321 
    self._iprot.readMessageEnd()
322 
    if result.success != None:
323 
      return result.success
324 
    if result.se != None:
325 
      raise result.se
326 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addUser failed: unknown result");
327 
 
328 
  def deleteUser(self, username):
329 
    """
330 
    Parameters:
331 
     - username
332 
    """
333 
    self.send_deleteUser(username)
334 
    return self.recv_deleteUser()
335 
 
336 
  def send_deleteUser(self, username):
337 
    self._oprot.writeMessageBegin('deleteUser', TMessageType.CALL, self._seqid)
338 
    args = deleteUser_args()
339 
    args.username = username
340 
    args.write(self._oprot)
341 
    self._oprot.writeMessageEnd()
342 
    self._oprot.trans.flush()
343 
 
344 
  def recv_deleteUser(self, ):
345 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
346 
    if mtype == TMessageType.EXCEPTION:
347 
      x = TApplicationException()
348 
      x.read(self._iprot)
349 
      self._iprot.readMessageEnd()
350 
      raise x
351 
    result = deleteUser_result()
352 
    result.read(self._iprot)
353 
    self._iprot.readMessageEnd()
354 
    if result.success != None:
355 
      return result.success
356 
    if result.se != None:
357 
      raise result.se
358 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteUser failed: unknown result");
359 
 
360 
  def authenticateUser(self, username, password):
361 
    """
362 
    Parameters:
363 
     - username
364 
     - password
365 
    """
366 
    self.send_authenticateUser(username, password)
367 
    return self.recv_authenticateUser()
368 
 
369 
  def send_authenticateUser(self, username, password):
370 
    self._oprot.writeMessageBegin('authenticateUser', TMessageType.CALL, self._seqid)
371 
    args = authenticateUser_args()
372 
    args.username = username
373 
    args.password = password
374 
    args.write(self._oprot)
375 
    self._oprot.writeMessageEnd()
376 
    self._oprot.trans.flush()
377 
 
378 
  def recv_authenticateUser(self, ):
379 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
380 
    if mtype == TMessageType.EXCEPTION:
381 
      x = TApplicationException()
382 
      x.read(self._iprot)
383 
      self._iprot.readMessageEnd()
384 
      raise x
385 
    result = authenticateUser_result()
386 
    result.read(self._iprot)
387 
    self._iprot.readMessageEnd()
388 
    if result.success != None:
389 
      return result.success
390 
    if result.se != None:
391 
      raise result.se
392 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authenticateUser failed: unknown result");
393 
 
394 
  def updatePassword(self, username, oldPassword, newPassword):
395 
    """
396 
    Parameters:
397 
     - username
398 
     - oldPassword
399 
     - newPassword
400 
    """
401 
    self.send_updatePassword(username, oldPassword, newPassword)
402 
    return self.recv_updatePassword()
403 
 
404 
  def send_updatePassword(self, username, oldPassword, newPassword):
405 
    self._oprot.writeMessageBegin('updatePassword', TMessageType.CALL, self._seqid)
406 
    args = updatePassword_args()
407 
    args.username = username
408 
    args.oldPassword = oldPassword
409 
    args.newPassword = newPassword
410 
    args.write(self._oprot)
411 
    self._oprot.writeMessageEnd()
412 
    self._oprot.trans.flush()
413 
 
414 
  def recv_updatePassword(self, ):
415 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
416 
    if mtype == TMessageType.EXCEPTION:
417 
      x = TApplicationException()
418 
      x.read(self._iprot)
419 
      self._iprot.readMessageEnd()
420 
      raise x
421 
    result = updatePassword_result()
422 
    result.read(self._iprot)
423 
    self._iprot.readMessageEnd()
424 
    if result.success != None:
425 
      return result.success
426 
    if result.se != None:
427 
      raise result.se
428 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updatePassword failed: unknown result");
429 
 
430 
 
349 ashish 431 
class Processor(Iface, TProcessor):
432 
  def __init__(self, handler):
433 
    self._handler = handler
434 
    self._processMap = {}
435 
    self._processMap["sendMail"] = Processor.process_sendMail
436 
    self._processMap["sendText"] = Processor.process_sendText
437 
    self._processMap["addMessage"] = Processor.process_addMessage
438 
    self._processMap["updateMessage"] = Processor.process_updateMessage
439 
    self._processMap["getMessage"] = Processor.process_getMessage
440 
    self._processMap["getSubstitutedMessage"] = Processor.process_getSubstitutedMessage
494 rajveer 441 
    self._processMap["addUser"] = Processor.process_addUser
442 
    self._processMap["deleteUser"] = Processor.process_deleteUser
443 
    self._processMap["authenticateUser"] = Processor.process_authenticateUser
444 
    self._processMap["updatePassword"] = Processor.process_updatePassword
349 ashish 445 
 
446 
  def process(self, iprot, oprot):
447 
    (name, type, seqid) = iprot.readMessageBegin()
448 
    if name not in self._processMap:
449 
      iprot.skip(TType.STRUCT)
450 
      iprot.readMessageEnd()
451 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
452 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
453 
      x.write(oprot)
454 
      oprot.writeMessageEnd()
455 
      oprot.trans.flush()
456 
      return
457 
    else:
458 
      self._processMap[name](self, seqid, iprot, oprot)
459 
    return True
460 
 
461 
  def process_sendMail(self, seqid, iprot, oprot):
462 
    args = sendMail_args()
463 
    args.read(iprot)
464 
    iprot.readMessageEnd()
465 
    result = sendMail_result()
466 
    try:
467 
      self._handler.sendMail(args.mail)
468 
    except HelperServiceException, se:
469 
      result.se = se
470 
    oprot.writeMessageBegin("sendMail", TMessageType.REPLY, seqid)
471 
    result.write(oprot)
472 
    oprot.writeMessageEnd()
473 
    oprot.trans.flush()
474 
 
475 
  def process_sendText(self, seqid, iprot, oprot):
476 
    args = sendText_args()
477 
    args.read(iprot)
478 
    iprot.readMessageEnd()
479 
    result = sendText_result()
480 
    try:
481 
      self._handler.sendText(args.message)
482 
    except HelperServiceException, se:
483 
      result.se = se
484 
    oprot.writeMessageBegin("sendText", TMessageType.REPLY, seqid)
485 
    result.write(oprot)
486 
    oprot.writeMessageEnd()
487 
    oprot.trans.flush()
488 
 
489 
  def process_addMessage(self, seqid, iprot, oprot):
490 
    args = addMessage_args()
491 
    args.read(iprot)
492 
    iprot.readMessageEnd()
493 
    result = addMessage_result()
494 
    try:
495 
      self._handler.addMessage(args.message)
496 
    except HelperServiceException, se:
497 
      result.se = se
498 
    oprot.writeMessageBegin("addMessage", TMessageType.REPLY, seqid)
499 
    result.write(oprot)
500 
    oprot.writeMessageEnd()
501 
    oprot.trans.flush()
502 
 
503 
  def process_updateMessage(self, seqid, iprot, oprot):
504 
    args = updateMessage_args()
505 
    args.read(iprot)
506 
    iprot.readMessageEnd()
507 
    result = updateMessage_result()
508 
    try:
509 
      self._handler.updateMessage(args.id, args.message)
510 
    except HelperServiceException, se:
511 
      result.se = se
512 
    oprot.writeMessageBegin("updateMessage", TMessageType.REPLY, seqid)
513 
    result.write(oprot)
514 
    oprot.writeMessageEnd()
515 
    oprot.trans.flush()
516 
 
517 
  def process_getMessage(self, seqid, iprot, oprot):
518 
    args = getMessage_args()
519 
    args.read(iprot)
520 
    iprot.readMessageEnd()
521 
    result = getMessage_result()
522 
    try:
353 ashish 523 
      result.success = self._handler.getMessage(args.id)
349 ashish 524 
    except HelperServiceException, se:
525 
      result.se = se
526 
    oprot.writeMessageBegin("getMessage", TMessageType.REPLY, seqid)
527 
    result.write(oprot)
528 
    oprot.writeMessageEnd()
529 
    oprot.trans.flush()
530 
 
531 
  def process_getSubstitutedMessage(self, seqid, iprot, oprot):
532 
    args = getSubstitutedMessage_args()
533 
    args.read(iprot)
534 
    iprot.readMessageEnd()
535 
    result = getSubstitutedMessage_result()
536 
    try:
353 ashish 537 
      result.success = self._handler.getSubstitutedMessage(args.id, args.params)
349 ashish 538 
    except HelperServiceException, se:
539 
      result.se = se
540 
    oprot.writeMessageBegin("getSubstitutedMessage", TMessageType.REPLY, seqid)
541 
    result.write(oprot)
542 
    oprot.writeMessageEnd()
543 
    oprot.trans.flush()
544 
 
494 rajveer 545 
  def process_addUser(self, seqid, iprot, oprot):
546 
    args = addUser_args()
547 
    args.read(iprot)
548 
    iprot.readMessageEnd()
549 
    result = addUser_result()
550 
    try:
551 
      result.success = self._handler.addUser(args.username, args.password, args.warehouseId)
552 
    except HelperServiceException, se:
553 
      result.se = se
554 
    oprot.writeMessageBegin("addUser", TMessageType.REPLY, seqid)
555 
    result.write(oprot)
556 
    oprot.writeMessageEnd()
557 
    oprot.trans.flush()
349 ashish 558 
 
494 rajveer 559 
  def process_deleteUser(self, seqid, iprot, oprot):
560 
    args = deleteUser_args()
561 
    args.read(iprot)
562 
    iprot.readMessageEnd()
563 
    result = deleteUser_result()
564 
    try:
565 
      result.success = self._handler.deleteUser(args.username)
566 
    except HelperServiceException, se:
567 
      result.se = se
568 
    oprot.writeMessageBegin("deleteUser", TMessageType.REPLY, seqid)
569 
    result.write(oprot)
570 
    oprot.writeMessageEnd()
571 
    oprot.trans.flush()
572 
 
573 
  def process_authenticateUser(self, seqid, iprot, oprot):
574 
    args = authenticateUser_args()
575 
    args.read(iprot)
576 
    iprot.readMessageEnd()
577 
    result = authenticateUser_result()
578 
    try:
579 
      result.success = self._handler.authenticateUser(args.username, args.password)
580 
    except HelperServiceException, se:
581 
      result.se = se
582 
    oprot.writeMessageBegin("authenticateUser", TMessageType.REPLY, seqid)
583 
    result.write(oprot)
584 
    oprot.writeMessageEnd()
585 
    oprot.trans.flush()
586 
 
587 
  def process_updatePassword(self, seqid, iprot, oprot):
588 
    args = updatePassword_args()
589 
    args.read(iprot)
590 
    iprot.readMessageEnd()
591 
    result = updatePassword_result()
592 
    try:
593 
      result.success = self._handler.updatePassword(args.username, args.oldPassword, args.newPassword)
594 
    except HelperServiceException, se:
595 
      result.se = se
596 
    oprot.writeMessageBegin("updatePassword", TMessageType.REPLY, seqid)
597 
    result.write(oprot)
598 
    oprot.writeMessageEnd()
599 
    oprot.trans.flush()
600 
 
601 
 
349 ashish 602 
# HELPER FUNCTIONS AND STRUCTURES
603 
 
604 
class sendMail_args:
605 
  """
606 
  Attributes:
607 
   - mail
608 
  """
609 
 
610 
  thrift_spec = (
611 
    None, # 0
612 
    (1, TType.STRUCT, 'mail', (Mail, Mail.thrift_spec), None, ), # 1
613 
  )
614 
 
615 
  def __init__(self, mail=None,):
616 
    self.mail = mail
617 
 
618 
  def read(self, iprot):
619 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
620 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
621 
      return
622 
    iprot.readStructBegin()
623 
    while True:
624 
      (fname, ftype, fid) = iprot.readFieldBegin()
625 
      if ftype == TType.STOP:
626 
        break
627 
      if fid == 1:
628 
        if ftype == TType.STRUCT:
629 
          self.mail = Mail()
630 
          self.mail.read(iprot)
631 
        else:
632 
          iprot.skip(ftype)
633 
      else:
634 
        iprot.skip(ftype)
635 
      iprot.readFieldEnd()
636 
    iprot.readStructEnd()
637 
 
638 
  def write(self, oprot):
639 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
640 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
641 
      return
642 
    oprot.writeStructBegin('sendMail_args')
643 
    if self.mail != None:
644 
      oprot.writeFieldBegin('mail', TType.STRUCT, 1)
645 
      self.mail.write(oprot)
646 
      oprot.writeFieldEnd()
647 
    oprot.writeFieldStop()
648 
    oprot.writeStructEnd()
649 
 
650 
  def __repr__(self):
651 
    L = ['%s=%r' % (key, value)
652 
      for key, value in self.__dict__.iteritems()]
653 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
654 
 
655 
  def __eq__(self, other):
656 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
657 
 
658 
  def __ne__(self, other):
659 
    return not (self == other)
660 
 
661 
class sendMail_result:
662 
  """
663 
  Attributes:
664 
   - se
665 
  """
666 
 
667 
  thrift_spec = (
668 
    None, # 0
669 
    (1, TType.STRUCT, 'se', (HelperServiceException, HelperServiceException.thrift_spec), None, ), # 1
670 
  )
671 
 
672 
  def __init__(self, se=None,):
673 
    self.se = se
674 
 
675 
  def read(self, iprot):
676 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
677 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
678 
      return
679 
    iprot.readStructBegin()
680 
    while True:
681 
      (fname, ftype, fid) = iprot.readFieldBegin()
682 
      if ftype == TType.STOP:
683 
        break
684 
      if fid == 1:
685 
        if ftype == TType.STRUCT:
686 
          self.se = HelperServiceException()
687 
          self.se.read(iprot)
688 
        else:
689 
          iprot.skip(ftype)
690 
      else:
691 
        iprot.skip(ftype)
692 
      iprot.readFieldEnd()
693 
    iprot.readStructEnd()
694 
 
695 
  def write(self, oprot):
696 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
697 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
698 
      return
699 
    oprot.writeStructBegin('sendMail_result')
700 
    if self.se != None:
701 
      oprot.writeFieldBegin('se', TType.STRUCT, 1)
702 
      self.se.write(oprot)
703 
      oprot.writeFieldEnd()
704 
    oprot.writeFieldStop()
705 
    oprot.writeStructEnd()
706 
 
707 
  def __repr__(self):
708 
    L = ['%s=%r' % (key, value)
709 
      for key, value in self.__dict__.iteritems()]
710 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
711 
 
712 
  def __eq__(self, other):
713 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
714 
 
715 
  def __ne__(self, other):
716 
    return not (self == other)
717 
 
718 
class sendText_args:
719 
  """
720 
  Attributes:
721 
   - message
722 
  """
723 
 
724 
  thrift_spec = (
725 
    None, # 0
726 
    (1, TType.STRUCT, 'message', (TextMessage, TextMessage.thrift_spec), None, ), # 1
727 
  )
728 
 
729 
  def __init__(self, message=None,):
730 
    self.message = message
731 
 
732 
  def read(self, iprot):
733 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
734 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
735 
      return
736 
    iprot.readStructBegin()
737 
    while True:
738 
      (fname, ftype, fid) = iprot.readFieldBegin()
739 
      if ftype == TType.STOP:
740 
        break
741 
      if fid == 1:
742 
        if ftype == TType.STRUCT:
743 
          self.message = TextMessage()
744 
          self.message.read(iprot)
745 
        else:
746 
          iprot.skip(ftype)
747 
      else:
748 
        iprot.skip(ftype)
749 
      iprot.readFieldEnd()
750 
    iprot.readStructEnd()
751 
 
752 
  def write(self, oprot):
753 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
754 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
755 
      return
756 
    oprot.writeStructBegin('sendText_args')
757 
    if self.message != None:
758 
      oprot.writeFieldBegin('message', TType.STRUCT, 1)
759 
      self.message.write(oprot)
760 
      oprot.writeFieldEnd()
761 
    oprot.writeFieldStop()
762 
    oprot.writeStructEnd()
763 
 
764 
  def __repr__(self):
765 
    L = ['%s=%r' % (key, value)
766 
      for key, value in self.__dict__.iteritems()]
767 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
768 
 
769 
  def __eq__(self, other):
770 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
771 
 
772 
  def __ne__(self, other):
773 
    return not (self == other)
774 
 
775 
class sendText_result:
776 
  """
777 
  Attributes:
778 
   - se
779 
  """
780 
 
781 
  thrift_spec = (
782 
    None, # 0
783 
    (1, TType.STRUCT, 'se', (HelperServiceException, HelperServiceException.thrift_spec), None, ), # 1
784 
  )
785 
 
786 
  def __init__(self, se=None,):
787 
    self.se = se
788 
 
789 
  def read(self, iprot):
790 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
791 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
792 
      return
793 
    iprot.readStructBegin()
794 
    while True:
795 
      (fname, ftype, fid) = iprot.readFieldBegin()
796 
      if ftype == TType.STOP:
797 
        break
798 
      if fid == 1:
799 
        if ftype == TType.STRUCT:
800 
          self.se = HelperServiceException()
801 
          self.se.read(iprot)
802 
        else:
803 
          iprot.skip(ftype)
804 
      else:
805 
        iprot.skip(ftype)
806 
      iprot.readFieldEnd()
807 
    iprot.readStructEnd()
808 
 
809 
  def write(self, oprot):
810 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
811 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
812 
      return
813 
    oprot.writeStructBegin('sendText_result')
814 
    if self.se != None:
815 
      oprot.writeFieldBegin('se', TType.STRUCT, 1)
816 
      self.se.write(oprot)
817 
      oprot.writeFieldEnd()
818 
    oprot.writeFieldStop()
819 
    oprot.writeStructEnd()
820 
 
821 
  def __repr__(self):
822 
    L = ['%s=%r' % (key, value)
823 
      for key, value in self.__dict__.iteritems()]
824 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
825 
 
826 
  def __eq__(self, other):
827 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
828 
 
829 
  def __ne__(self, other):
830 
    return not (self == other)
831 
 
832 
class addMessage_args:
833 
  """
834 
  Attributes:
835 
   - message
836 
  """
837 
 
838 
  thrift_spec = (
839 
    None, # 0
840 
    (1, TType.STRUCT, 'message', (Message, Message.thrift_spec), None, ), # 1
841 
  )
842 
 
843 
  def __init__(self, message=None,):
844 
    self.message = message
845 
 
846 
  def read(self, iprot):
847 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
848 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
849 
      return
850 
    iprot.readStructBegin()
851 
    while True:
852 
      (fname, ftype, fid) = iprot.readFieldBegin()
853 
      if ftype == TType.STOP:
854 
        break
855 
      if fid == 1:
856 
        if ftype == TType.STRUCT:
857 
          self.message = Message()
858 
          self.message.read(iprot)
859 
        else:
860 
          iprot.skip(ftype)
861 
      else:
862 
        iprot.skip(ftype)
863 
      iprot.readFieldEnd()
864 
    iprot.readStructEnd()
865 
 
866 
  def write(self, oprot):
867 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
868 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
869 
      return
870 
    oprot.writeStructBegin('addMessage_args')
871 
    if self.message != None:
872 
      oprot.writeFieldBegin('message', TType.STRUCT, 1)
873 
      self.message.write(oprot)
874 
      oprot.writeFieldEnd()
875 
    oprot.writeFieldStop()
876 
    oprot.writeStructEnd()
877 
 
878 
  def __repr__(self):
879 
    L = ['%s=%r' % (key, value)
880 
      for key, value in self.__dict__.iteritems()]
881 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
882 
 
883 
  def __eq__(self, other):
884 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
885 
 
886 
  def __ne__(self, other):
887 
    return not (self == other)
888 
 
889 
class addMessage_result:
890 
  """
891 
  Attributes:
892 
   - se
893 
  """
894 
 
895 
  thrift_spec = (
896 
    None, # 0
897 
    (1, TType.STRUCT, 'se', (HelperServiceException, HelperServiceException.thrift_spec), None, ), # 1
898 
  )
899 
 
900 
  def __init__(self, se=None,):
901 
    self.se = se
902 
 
903 
  def read(self, iprot):
904 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
905 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
906 
      return
907 
    iprot.readStructBegin()
908 
    while True:
909 
      (fname, ftype, fid) = iprot.readFieldBegin()
910 
      if ftype == TType.STOP:
911 
        break
912 
      if fid == 1:
913 
        if ftype == TType.STRUCT:
914 
          self.se = HelperServiceException()
915 
          self.se.read(iprot)
916 
        else:
917 
          iprot.skip(ftype)
918 
      else:
919 
        iprot.skip(ftype)
920 
      iprot.readFieldEnd()
921 
    iprot.readStructEnd()
922 
 
923 
  def write(self, oprot):
924 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
925 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
926 
      return
927 
    oprot.writeStructBegin('addMessage_result')
928 
    if self.se != None:
929 
      oprot.writeFieldBegin('se', TType.STRUCT, 1)
930 
      self.se.write(oprot)
931 
      oprot.writeFieldEnd()
932 
    oprot.writeFieldStop()
933 
    oprot.writeStructEnd()
934 
 
935 
  def __repr__(self):
936 
    L = ['%s=%r' % (key, value)
937 
      for key, value in self.__dict__.iteritems()]
938 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
939 
 
940 
  def __eq__(self, other):
941 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
942 
 
943 
  def __ne__(self, other):
944 
    return not (self == other)
945 
 
946 
class updateMessage_args:
947 
  """
948 
  Attributes:
949 
   - id
950 
   - message
951 
  """
952 
 
953 
  thrift_spec = (
954 
    None, # 0
955 
    (1, TType.I64, 'id', None, None, ), # 1
956 
    (2, TType.STRING, 'message', None, None, ), # 2
957 
  )
958 
 
959 
  def __init__(self, id=None, message=None,):
960 
    self.id = id
961 
    self.message = message
962 
 
963 
  def read(self, iprot):
964 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
965 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
966 
      return
967 
    iprot.readStructBegin()
968 
    while True:
969 
      (fname, ftype, fid) = iprot.readFieldBegin()
970 
      if ftype == TType.STOP:
971 
        break
972 
      if fid == 1:
973 
        if ftype == TType.I64:
974 
          self.id = iprot.readI64();
975 
        else:
976 
          iprot.skip(ftype)
977 
      elif fid == 2:
978 
        if ftype == TType.STRING:
979 
          self.message = iprot.readString();
980 
        else:
981 
          iprot.skip(ftype)
982 
      else:
983 
        iprot.skip(ftype)
984 
      iprot.readFieldEnd()
985 
    iprot.readStructEnd()
986 
 
987 
  def write(self, oprot):
988 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
989 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
990 
      return
991 
    oprot.writeStructBegin('updateMessage_args')
992 
    if self.id != None:
993 
      oprot.writeFieldBegin('id', TType.I64, 1)
994 
      oprot.writeI64(self.id)
995 
      oprot.writeFieldEnd()
996 
    if self.message != None:
997 
      oprot.writeFieldBegin('message', TType.STRING, 2)
998 
      oprot.writeString(self.message)
999 
      oprot.writeFieldEnd()
1000 
    oprot.writeFieldStop()
1001 
    oprot.writeStructEnd()
1002 
 
1003 
  def __repr__(self):
1004 
    L = ['%s=%r' % (key, value)
1005 
      for key, value in self.__dict__.iteritems()]
1006 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
1007 
 
1008 
  def __eq__(self, other):
1009 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
1010 
 
1011 
  def __ne__(self, other):
1012 
    return not (self == other)
1013 
 
1014 
class updateMessage_result:
1015 
  """
1016 
  Attributes:
1017 
   - se
1018 
  """
1019 
 
1020 
  thrift_spec = (
1021 
    None, # 0
1022 
    (1, TType.STRUCT, 'se', (HelperServiceException, HelperServiceException.thrift_spec), None, ), # 1
1023 
  )
1024 
 
1025 
  def __init__(self, se=None,):
1026 
    self.se = se
1027 
 
1028 
  def read(self, iprot):
1029 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
1030 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
1031 
      return
1032 
    iprot.readStructBegin()
1033 
    while True:
1034 
      (fname, ftype, fid) = iprot.readFieldBegin()
1035 
      if ftype == TType.STOP:
1036 
        break
1037 
      if fid == 1:
1038 
        if ftype == TType.STRUCT:
1039 
          self.se = HelperServiceException()
1040 
          self.se.read(iprot)
1041 
        else:
1042 
          iprot.skip(ftype)
1043 
      else:
1044 
        iprot.skip(ftype)
1045 
      iprot.readFieldEnd()
1046 
    iprot.readStructEnd()
1047 
 
1048 
  def write(self, oprot):
1049 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
1050 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
1051 
      return
1052 
    oprot.writeStructBegin('updateMessage_result')
1053 
    if self.se != None:
1054 
      oprot.writeFieldBegin('se', TType.STRUCT, 1)
1055 
      self.se.write(oprot)
1056 
      oprot.writeFieldEnd()
1057 
    oprot.writeFieldStop()
1058 
    oprot.writeStructEnd()
1059 
 
1060 
  def __repr__(self):
1061 
    L = ['%s=%r' % (key, value)
1062 
      for key, value in self.__dict__.iteritems()]
1063 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
1064 
 
1065 
  def __eq__(self, other):
1066 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
1067 
 
1068 
  def __ne__(self, other):
1069 
    return not (self == other)
1070 
 
1071 
class getMessage_args:
1072 
  """
1073 
  Attributes:
1074 
   - id
1075 
  """
1076 
 
1077 
  thrift_spec = (
1078 
    None, # 0
1079 
    (1, TType.I64, 'id', None, None, ), # 1
1080 
  )
1081 
 
1082 
  def __init__(self, id=None,):
1083 
    self.id = id
1084 
 
1085 
  def read(self, iprot):
1086 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
1087 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
1088 
      return
1089 
    iprot.readStructBegin()
1090 
    while True:
1091 
      (fname, ftype, fid) = iprot.readFieldBegin()
1092 
      if ftype == TType.STOP:
1093 
        break
1094 
      if fid == 1:
1095 
        if ftype == TType.I64:
1096 
          self.id = iprot.readI64();
1097 
        else:
1098 
          iprot.skip(ftype)
1099 
      else:
1100 
        iprot.skip(ftype)
1101 
      iprot.readFieldEnd()
1102 
    iprot.readStructEnd()
1103 
 
1104 
  def write(self, oprot):
1105 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
1106 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
1107 
      return
1108 
    oprot.writeStructBegin('getMessage_args')
1109 
    if self.id != None:
1110 
      oprot.writeFieldBegin('id', TType.I64, 1)
1111 
      oprot.writeI64(self.id)
1112 
      oprot.writeFieldEnd()
1113 
    oprot.writeFieldStop()
1114 
    oprot.writeStructEnd()
1115 
 
1116 
  def __repr__(self):
1117 
    L = ['%s=%r' % (key, value)
1118 
      for key, value in self.__dict__.iteritems()]
1119 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
1120 
 
1121 
  def __eq__(self, other):
1122 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
1123 
 
1124 
  def __ne__(self, other):
1125 
    return not (self == other)
1126 
 
1127 
class getMessage_result:
1128 
  """
1129 
  Attributes:
353 ashish 1130 
   - success
349 ashish 1131 
   - se
1132 
  """
1133 
 
1134 
  thrift_spec = (
353 ashish 1135 
    (0, TType.STRUCT, 'success', (Message, Message.thrift_spec), None, ), # 0
349 ashish 1136 
    (1, TType.STRUCT, 'se', (HelperServiceException, HelperServiceException.thrift_spec), None, ), # 1
1137 
  )
1138 
 
353 ashish 1139 
  def __init__(self, success=None, se=None,):
1140 
    self.success = success
349 ashish 1141 
    self.se = se
1142 
 
1143 
  def read(self, iprot):
1144 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
1145 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
1146 
      return
1147 
    iprot.readStructBegin()
1148 
    while True:
1149 
      (fname, ftype, fid) = iprot.readFieldBegin()
1150 
      if ftype == TType.STOP:
1151 
        break
353 ashish 1152 
      if fid == 0:
349 ashish 1153 
        if ftype == TType.STRUCT:
353 ashish 1154 
          self.success = Message()
1155 
          self.success.read(iprot)
1156 
        else:
1157 
          iprot.skip(ftype)
1158 
      elif fid == 1:
1159 
        if ftype == TType.STRUCT:
349 ashish 1160 
          self.se = HelperServiceException()
1161 
          self.se.read(iprot)
1162 
        else:
1163 
          iprot.skip(ftype)
1164 
      else:
1165 
        iprot.skip(ftype)
1166 
      iprot.readFieldEnd()
1167 
    iprot.readStructEnd()
1168 
 
1169 
  def write(self, oprot):
1170 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
1171 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
1172 
      return
1173 
    oprot.writeStructBegin('getMessage_result')
353 ashish 1174 
    if self.success != None:
1175 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
1176 
      self.success.write(oprot)
1177 
      oprot.writeFieldEnd()
349 ashish 1178 
    if self.se != None:
1179 
      oprot.writeFieldBegin('se', TType.STRUCT, 1)
1180 
      self.se.write(oprot)
1181 
      oprot.writeFieldEnd()
1182 
    oprot.writeFieldStop()
1183 
    oprot.writeStructEnd()
1184 
 
1185 
  def __repr__(self):
1186 
    L = ['%s=%r' % (key, value)
1187 
      for key, value in self.__dict__.iteritems()]
1188 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
1189 
 
1190 
  def __eq__(self, other):
1191 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
1192 
 
1193 
  def __ne__(self, other):
1194 
    return not (self == other)
1195 
 
1196 
class getSubstitutedMessage_args:
1197 
  """
1198 
  Attributes:
1199 
   - id
1200 
   - params
1201 
  """
1202 
 
1203 
  thrift_spec = (
1204 
    None, # 0
1205 
    (1, TType.I64, 'id', None, None, ), # 1
1206 
    (2, TType.MAP, 'params', (TType.STRING,None,TType.STRING,None), None, ), # 2
1207 
  )
1208 
 
1209 
  def __init__(self, id=None, params=None,):
1210 
    self.id = id
1211 
    self.params = params
1212 
 
1213 
  def read(self, iprot):
1214 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
1215 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
1216 
      return
1217 
    iprot.readStructBegin()
1218 
    while True:
1219 
      (fname, ftype, fid) = iprot.readFieldBegin()
1220 
      if ftype == TType.STOP:
1221 
        break
1222 
      if fid == 1:
1223 
        if ftype == TType.I64:
1224 
          self.id = iprot.readI64();
1225 
        else:
1226 
          iprot.skip(ftype)
1227 
      elif fid == 2:
1228 
        if ftype == TType.MAP:
1229 
          self.params = {}
472 rajveer 1230 
          (_ktype15, _vtype16, _size14 ) = iprot.readMapBegin()
1231 
          for _i18 in xrange(_size14):
1232 
            _key19 = iprot.readString();
1233 
            _val20 = iprot.readString();
1234 
            self.params[_key19] = _val20
349 ashish 1235 
          iprot.readMapEnd()
1236 
        else:
1237 
          iprot.skip(ftype)
1238 
      else:
1239 
        iprot.skip(ftype)
1240 
      iprot.readFieldEnd()
1241 
    iprot.readStructEnd()
1242 
 
1243 
  def write(self, oprot):
1244 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
1245 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
1246 
      return
1247 
    oprot.writeStructBegin('getSubstitutedMessage_args')
1248 
    if self.id != None:
1249 
      oprot.writeFieldBegin('id', TType.I64, 1)
1250 
      oprot.writeI64(self.id)
1251 
      oprot.writeFieldEnd()
1252 
    if self.params != None:
1253 
      oprot.writeFieldBegin('params', TType.MAP, 2)
1254 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.params))
472 rajveer 1255 
      for kiter21,viter22 in self.params.items():
1256 
        oprot.writeString(kiter21)
1257 
        oprot.writeString(viter22)
349 ashish 1258 
      oprot.writeMapEnd()
1259 
      oprot.writeFieldEnd()
1260 
    oprot.writeFieldStop()
1261 
    oprot.writeStructEnd()
1262 
 
1263 
  def __repr__(self):
1264 
    L = ['%s=%r' % (key, value)
1265 
      for key, value in self.__dict__.iteritems()]
1266 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
1267 
 
1268 
  def __eq__(self, other):
1269 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
1270 
 
1271 
  def __ne__(self, other):
1272 
    return not (self == other)
1273 
 
1274 
class getSubstitutedMessage_result:
1275 
  """
1276 
  Attributes:
353 ashish 1277 
   - success
349 ashish 1278 
   - se
1279 
  """
1280 
 
1281 
  thrift_spec = (
353 ashish 1282 
    (0, TType.STRUCT, 'success', (Message, Message.thrift_spec), None, ), # 0
349 ashish 1283 
    (1, TType.STRUCT, 'se', (HelperServiceException, HelperServiceException.thrift_spec), None, ), # 1
1284 
  )
1285 
 
353 ashish 1286 
  def __init__(self, success=None, se=None,):
1287 
    self.success = success
349 ashish 1288 
    self.se = se
1289 
 
1290 
  def read(self, iprot):
1291 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
1292 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
1293 
      return
1294 
    iprot.readStructBegin()
1295 
    while True:
1296 
      (fname, ftype, fid) = iprot.readFieldBegin()
1297 
      if ftype == TType.STOP:
1298 
        break
353 ashish 1299 
      if fid == 0:
349 ashish 1300 
        if ftype == TType.STRUCT:
353 ashish 1301 
          self.success = Message()
1302 
          self.success.read(iprot)
1303 
        else:
1304 
          iprot.skip(ftype)
1305 
      elif fid == 1:
1306 
        if ftype == TType.STRUCT:
349 ashish 1307 
          self.se = HelperServiceException()
1308 
          self.se.read(iprot)
1309 
        else:
1310 
          iprot.skip(ftype)
1311 
      else:
1312 
        iprot.skip(ftype)
1313 
      iprot.readFieldEnd()
1314 
    iprot.readStructEnd()
1315 
 
1316 
  def write(self, oprot):
1317 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
1318 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
1319 
      return
1320 
    oprot.writeStructBegin('getSubstitutedMessage_result')
353 ashish 1321 
    if self.success != None:
1322 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
1323 
      self.success.write(oprot)
1324 
      oprot.writeFieldEnd()
349 ashish 1325 
    if self.se != None:
1326 
      oprot.writeFieldBegin('se', TType.STRUCT, 1)
1327 
      self.se.write(oprot)
1328 
      oprot.writeFieldEnd()
1329 
    oprot.writeFieldStop()
1330 
    oprot.writeStructEnd()
1331 
 
1332 
  def __repr__(self):
1333 
    L = ['%s=%r' % (key, value)
1334 
      for key, value in self.__dict__.iteritems()]
1335 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
1336 
 
1337 
  def __eq__(self, other):
1338 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
1339 
 
1340 
  def __ne__(self, other):
1341 
    return not (self == other)
1342 
 
494 rajveer 1343 
class addUser_args:
1344 
  """
1345 
  Attributes:
1346 
   - username
1347 
   - password
1348 
   - warehouseId
1349 
  """
349 ashish 1350 
 
494 rajveer 1351 
  thrift_spec = (
1352 
    None, # 0
1353 
    (1, TType.STRING, 'username', None, None, ), # 1
1354 
    (2, TType.STRING, 'password', None, None, ), # 2
1355 
    (3, TType.I64, 'warehouseId', None, None, ), # 3
1356 
  )
1357 
 
1358 
  def __init__(self, username=None, password=None, warehouseId=None,):
1359 
    self.username = username
1360 
    self.password = password
1361 
    self.warehouseId = warehouseId
1362 
 
1363 
  def read(self, iprot):
1364 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
1365 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
1366 
      return
1367 
    iprot.readStructBegin()
1368 
    while True:
1369 
      (fname, ftype, fid) = iprot.readFieldBegin()
1370 
      if ftype == TType.STOP:
1371 
        break
1372 
      if fid == 1:
1373 
        if ftype == TType.STRING:
1374 
          self.username = iprot.readString();
1375 
        else:
1376 
          iprot.skip(ftype)
1377 
      elif fid == 2:
1378 
        if ftype == TType.STRING:
1379 
          self.password = iprot.readString();
1380 
        else:
1381 
          iprot.skip(ftype)
1382 
      elif fid == 3:
1383 
        if ftype == TType.I64:
1384 
          self.warehouseId = iprot.readI64();
1385 
        else:
1386 
          iprot.skip(ftype)
1387 
      else:
1388 
        iprot.skip(ftype)
1389 
      iprot.readFieldEnd()
1390 
    iprot.readStructEnd()
1391 
 
1392 
  def write(self, oprot):
1393 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
1394 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
1395 
      return
1396 
    oprot.writeStructBegin('addUser_args')
1397 
    if self.username != None:
1398 
      oprot.writeFieldBegin('username', TType.STRING, 1)
1399 
      oprot.writeString(self.username)
1400 
      oprot.writeFieldEnd()
1401 
    if self.password != None:
1402 
      oprot.writeFieldBegin('password', TType.STRING, 2)
1403 
      oprot.writeString(self.password)
1404 
      oprot.writeFieldEnd()
1405 
    if self.warehouseId != None:
1406 
      oprot.writeFieldBegin('warehouseId', TType.I64, 3)
1407 
      oprot.writeI64(self.warehouseId)
1408 
      oprot.writeFieldEnd()
1409 
    oprot.writeFieldStop()
1410 
    oprot.writeStructEnd()
1411 
 
1412 
  def __repr__(self):
1413 
    L = ['%s=%r' % (key, value)
1414 
      for key, value in self.__dict__.iteritems()]
1415 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
1416 
 
1417 
  def __eq__(self, other):
1418 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
1419 
 
1420 
  def __ne__(self, other):
1421 
    return not (self == other)
1422 
 
1423 
class addUser_result:
1424 
  """
1425 
  Attributes:
1426 
   - success
1427 
   - se
1428 
  """
1429 
 
1430 
  thrift_spec = (
1431 
    (0, TType.BOOL, 'success', None, None, ), # 0
1432 
    (1, TType.STRUCT, 'se', (HelperServiceException, HelperServiceException.thrift_spec), None, ), # 1
1433 
  )
1434 
 
1435 
  def __init__(self, success=None, se=None,):
1436 
    self.success = success
1437 
    self.se = se
1438 
 
1439 
  def read(self, iprot):
1440 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
1441 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
1442 
      return
1443 
    iprot.readStructBegin()
1444 
    while True:
1445 
      (fname, ftype, fid) = iprot.readFieldBegin()
1446 
      if ftype == TType.STOP:
1447 
        break
1448 
      if fid == 0:
1449 
        if ftype == TType.BOOL:
1450 
          self.success = iprot.readBool();
1451 
        else:
1452 
          iprot.skip(ftype)
1453 
      elif fid == 1:
1454 
        if ftype == TType.STRUCT:
1455 
          self.se = HelperServiceException()
1456 
          self.se.read(iprot)
1457 
        else:
1458 
          iprot.skip(ftype)
1459 
      else:
1460 
        iprot.skip(ftype)
1461 
      iprot.readFieldEnd()
1462 
    iprot.readStructEnd()
1463 
 
1464 
  def write(self, oprot):
1465 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
1466 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
1467 
      return
1468 
    oprot.writeStructBegin('addUser_result')
1469 
    if self.success != None:
1470 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
1471 
      oprot.writeBool(self.success)
1472 
      oprot.writeFieldEnd()
1473 
    if self.se != None:
1474 
      oprot.writeFieldBegin('se', TType.STRUCT, 1)
1475 
      self.se.write(oprot)
1476 
      oprot.writeFieldEnd()
1477 
    oprot.writeFieldStop()
1478 
    oprot.writeStructEnd()
1479 
 
1480 
  def __repr__(self):
1481 
    L = ['%s=%r' % (key, value)
1482 
      for key, value in self.__dict__.iteritems()]
1483 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
1484 
 
1485 
  def __eq__(self, other):
1486 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
1487 
 
1488 
  def __ne__(self, other):
1489 
    return not (self == other)
1490 
 
1491 
class deleteUser_args:
1492 
  """
1493 
  Attributes:
1494 
   - username
1495 
  """
1496 
 
1497 
  thrift_spec = (
1498 
    None, # 0
1499 
    (1, TType.STRING, 'username', None, None, ), # 1
1500 
  )
1501 
 
1502 
  def __init__(self, username=None,):
1503 
    self.username = username
1504 
 
1505 
  def read(self, iprot):
1506 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
1507 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
1508 
      return
1509 
    iprot.readStructBegin()
1510 
    while True:
1511 
      (fname, ftype, fid) = iprot.readFieldBegin()
1512 
      if ftype == TType.STOP:
1513 
        break
1514 
      if fid == 1:
1515 
        if ftype == TType.STRING:
1516 
          self.username = iprot.readString();
1517 
        else:
1518 
          iprot.skip(ftype)
1519 
      else:
1520 
        iprot.skip(ftype)
1521 
      iprot.readFieldEnd()
1522 
    iprot.readStructEnd()
1523 
 
1524 
  def write(self, oprot):
1525 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
1526 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
1527 
      return
1528 
    oprot.writeStructBegin('deleteUser_args')
1529 
    if self.username != None:
1530 
      oprot.writeFieldBegin('username', TType.STRING, 1)
1531 
      oprot.writeString(self.username)
1532 
      oprot.writeFieldEnd()
1533 
    oprot.writeFieldStop()
1534 
    oprot.writeStructEnd()
1535 
 
1536 
  def __repr__(self):
1537 
    L = ['%s=%r' % (key, value)
1538 
      for key, value in self.__dict__.iteritems()]
1539 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
1540 
 
1541 
  def __eq__(self, other):
1542 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
1543 
 
1544 
  def __ne__(self, other):
1545 
    return not (self == other)
1546 
 
1547 
class deleteUser_result:
1548 
  """
1549 
  Attributes:
1550 
   - success
1551 
   - se
1552 
  """
1553 
 
1554 
  thrift_spec = (
1555 
    (0, TType.BOOL, 'success', None, None, ), # 0
1556 
    (1, TType.STRUCT, 'se', (HelperServiceException, HelperServiceException.thrift_spec), None, ), # 1
1557 
  )
1558 
 
1559 
  def __init__(self, success=None, se=None,):
1560 
    self.success = success
1561 
    self.se = se
1562 
 
1563 
  def read(self, iprot):
1564 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
1565 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
1566 
      return
1567 
    iprot.readStructBegin()
1568 
    while True:
1569 
      (fname, ftype, fid) = iprot.readFieldBegin()
1570 
      if ftype == TType.STOP:
1571 
        break
1572 
      if fid == 0:
1573 
        if ftype == TType.BOOL:
1574 
          self.success = iprot.readBool();
1575 
        else:
1576 
          iprot.skip(ftype)
1577 
      elif fid == 1:
1578 
        if ftype == TType.STRUCT:
1579 
          self.se = HelperServiceException()
1580 
          self.se.read(iprot)
1581 
        else:
1582 
          iprot.skip(ftype)
1583 
      else:
1584 
        iprot.skip(ftype)
1585 
      iprot.readFieldEnd()
1586 
    iprot.readStructEnd()
1587 
 
1588 
  def write(self, oprot):
1589 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
1590 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
1591 
      return
1592 
    oprot.writeStructBegin('deleteUser_result')
1593 
    if self.success != None:
1594 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
1595 
      oprot.writeBool(self.success)
1596 
      oprot.writeFieldEnd()
1597 
    if self.se != None:
1598 
      oprot.writeFieldBegin('se', TType.STRUCT, 1)
1599 
      self.se.write(oprot)
1600 
      oprot.writeFieldEnd()
1601 
    oprot.writeFieldStop()
1602 
    oprot.writeStructEnd()
1603 
 
1604 
  def __repr__(self):
1605 
    L = ['%s=%r' % (key, value)
1606 
      for key, value in self.__dict__.iteritems()]
1607 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
1608 
 
1609 
  def __eq__(self, other):
1610 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
1611 
 
1612 
  def __ne__(self, other):
1613 
    return not (self == other)
1614 
 
1615 
class authenticateUser_args:
1616 
  """
1617 
  Attributes:
1618 
   - username
1619 
   - password
1620 
  """
1621 
 
1622 
  thrift_spec = (
1623 
    None, # 0
1624 
    (1, TType.STRING, 'username', None, None, ), # 1
1625 
    (2, TType.STRING, 'password', None, None, ), # 2
1626 
  )
1627 
 
1628 
  def __init__(self, username=None, password=None,):
1629 
    self.username = username
1630 
    self.password = password
1631 
 
1632 
  def read(self, iprot):
1633 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
1634 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
1635 
      return
1636 
    iprot.readStructBegin()
1637 
    while True:
1638 
      (fname, ftype, fid) = iprot.readFieldBegin()
1639 
      if ftype == TType.STOP:
1640 
        break
1641 
      if fid == 1:
1642 
        if ftype == TType.STRING:
1643 
          self.username = iprot.readString();
1644 
        else:
1645 
          iprot.skip(ftype)
1646 
      elif fid == 2:
1647 
        if ftype == TType.STRING:
1648 
          self.password = iprot.readString();
1649 
        else:
1650 
          iprot.skip(ftype)
1651 
      else:
1652 
        iprot.skip(ftype)
1653 
      iprot.readFieldEnd()
1654 
    iprot.readStructEnd()
1655 
 
1656 
  def write(self, oprot):
1657 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
1658 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
1659 
      return
1660 
    oprot.writeStructBegin('authenticateUser_args')
1661 
    if self.username != None:
1662 
      oprot.writeFieldBegin('username', TType.STRING, 1)
1663 
      oprot.writeString(self.username)
1664 
      oprot.writeFieldEnd()
1665 
    if self.password != None:
1666 
      oprot.writeFieldBegin('password', TType.STRING, 2)
1667 
      oprot.writeString(self.password)
1668 
      oprot.writeFieldEnd()
1669 
    oprot.writeFieldStop()
1670 
    oprot.writeStructEnd()
1671 
 
1672 
  def __repr__(self):
1673 
    L = ['%s=%r' % (key, value)
1674 
      for key, value in self.__dict__.iteritems()]
1675 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
1676 
 
1677 
  def __eq__(self, other):
1678 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
1679 
 
1680 
  def __ne__(self, other):
1681 
    return not (self == other)
1682 
 
1683 
class authenticateUser_result:
1684 
  """
1685 
  Attributes:
1686 
   - success
1687 
   - se
1688 
  """
1689 
 
1690 
  thrift_spec = (
1691 
    (0, TType.I64, 'success', None, None, ), # 0
1692 
    (1, TType.STRUCT, 'se', (HelperServiceException, HelperServiceException.thrift_spec), None, ), # 1
1693 
  )
1694 
 
1695 
  def __init__(self, success=None, se=None,):
1696 
    self.success = success
1697 
    self.se = se
1698 
 
1699 
  def read(self, iprot):
1700 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
1701 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
1702 
      return
1703 
    iprot.readStructBegin()
1704 
    while True:
1705 
      (fname, ftype, fid) = iprot.readFieldBegin()
1706 
      if ftype == TType.STOP:
1707 
        break
1708 
      if fid == 0:
1709 
        if ftype == TType.I64:
1710 
          self.success = iprot.readI64();
1711 
        else:
1712 
          iprot.skip(ftype)
1713 
      elif fid == 1:
1714 
        if ftype == TType.STRUCT:
1715 
          self.se = HelperServiceException()
1716 
          self.se.read(iprot)
1717 
        else:
1718 
          iprot.skip(ftype)
1719 
      else:
1720 
        iprot.skip(ftype)
1721 
      iprot.readFieldEnd()
1722 
    iprot.readStructEnd()
1723 
 
1724 
  def write(self, oprot):
1725 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
1726 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
1727 
      return
1728 
    oprot.writeStructBegin('authenticateUser_result')
1729 
    if self.success != None:
1730 
      oprot.writeFieldBegin('success', TType.I64, 0)
1731 
      oprot.writeI64(self.success)
1732 
      oprot.writeFieldEnd()
1733 
    if self.se != None:
1734 
      oprot.writeFieldBegin('se', TType.STRUCT, 1)
1735 
      self.se.write(oprot)
1736 
      oprot.writeFieldEnd()
1737 
    oprot.writeFieldStop()
1738 
    oprot.writeStructEnd()
1739 
 
1740 
  def __repr__(self):
1741 
    L = ['%s=%r' % (key, value)
1742 
      for key, value in self.__dict__.iteritems()]
1743 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
1744 
 
1745 
  def __eq__(self, other):
1746 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
1747 
 
1748 
  def __ne__(self, other):
1749 
    return not (self == other)
1750 
 
1751 
class updatePassword_args:
1752 
  """
1753 
  Attributes:
1754 
   - username
1755 
   - oldPassword
1756 
   - newPassword
1757 
  """
1758 
 
1759 
  thrift_spec = (
1760 
    None, # 0
1761 
    (1, TType.STRING, 'username', None, None, ), # 1
1762 
    (2, TType.STRING, 'oldPassword', None, None, ), # 2
1763 
    (3, TType.STRING, 'newPassword', None, None, ), # 3
1764 
  )
1765 
 
1766 
  def __init__(self, username=None, oldPassword=None, newPassword=None,):
1767 
    self.username = username
1768 
    self.oldPassword = oldPassword
1769 
    self.newPassword = newPassword
1770 
 
1771 
  def read(self, iprot):
1772 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
1773 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
1774 
      return
1775 
    iprot.readStructBegin()
1776 
    while True:
1777 
      (fname, ftype, fid) = iprot.readFieldBegin()
1778 
      if ftype == TType.STOP:
1779 
        break
1780 
      if fid == 1:
1781 
        if ftype == TType.STRING:
1782 
          self.username = iprot.readString();
1783 
        else:
1784 
          iprot.skip(ftype)
1785 
      elif fid == 2:
1786 
        if ftype == TType.STRING:
1787 
          self.oldPassword = iprot.readString();
1788 
        else:
1789 
          iprot.skip(ftype)
1790 
      elif fid == 3:
1791 
        if ftype == TType.STRING:
1792 
          self.newPassword = iprot.readString();
1793 
        else:
1794 
          iprot.skip(ftype)
1795 
      else:
1796 
        iprot.skip(ftype)
1797 
      iprot.readFieldEnd()
1798 
    iprot.readStructEnd()
1799 
 
1800 
  def write(self, oprot):
1801 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
1802 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
1803 
      return
1804 
    oprot.writeStructBegin('updatePassword_args')
1805 
    if self.username != None:
1806 
      oprot.writeFieldBegin('username', TType.STRING, 1)
1807 
      oprot.writeString(self.username)
1808 
      oprot.writeFieldEnd()
1809 
    if self.oldPassword != None:
1810 
      oprot.writeFieldBegin('oldPassword', TType.STRING, 2)
1811 
      oprot.writeString(self.oldPassword)
1812 
      oprot.writeFieldEnd()
1813 
    if self.newPassword != None:
1814 
      oprot.writeFieldBegin('newPassword', TType.STRING, 3)
1815 
      oprot.writeString(self.newPassword)
1816 
      oprot.writeFieldEnd()
1817 
    oprot.writeFieldStop()
1818 
    oprot.writeStructEnd()
1819 
 
1820 
  def __repr__(self):
1821 
    L = ['%s=%r' % (key, value)
1822 
      for key, value in self.__dict__.iteritems()]
1823 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
1824 
 
1825 
  def __eq__(self, other):
1826 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
1827 
 
1828 
  def __ne__(self, other):
1829 
    return not (self == other)
1830 
 
1831 
class updatePassword_result:
1832 
  """
1833 
  Attributes:
1834 
   - success
1835 
   - se
1836 
  """
1837 
 
1838 
  thrift_spec = (
1839 
    (0, TType.BOOL, 'success', None, None, ), # 0
1840 
    (1, TType.STRUCT, 'se', (HelperServiceException, HelperServiceException.thrift_spec), None, ), # 1
1841 
  )
1842 
 
1843 
  def __init__(self, success=None, se=None,):
1844 
    self.success = success
1845 
    self.se = se
1846 
 
1847 
  def read(self, iprot):
1848 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
1849 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
1850 
      return
1851 
    iprot.readStructBegin()
1852 
    while True:
1853 
      (fname, ftype, fid) = iprot.readFieldBegin()
1854 
      if ftype == TType.STOP:
1855 
        break
1856 
      if fid == 0:
1857 
        if ftype == TType.BOOL:
1858 
          self.success = iprot.readBool();
1859 
        else:
1860 
          iprot.skip(ftype)
1861 
      elif fid == 1:
1862 
        if ftype == TType.STRUCT:
1863 
          self.se = HelperServiceException()
1864 
          self.se.read(iprot)
1865 
        else:
1866 
          iprot.skip(ftype)
1867 
      else:
1868 
        iprot.skip(ftype)
1869 
      iprot.readFieldEnd()
1870 
    iprot.readStructEnd()
1871 
 
1872 
  def write(self, oprot):
1873 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
1874 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
1875 
      return
1876 
    oprot.writeStructBegin('updatePassword_result')
1877 
    if self.success != None:
1878 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
1879 
      oprot.writeBool(self.success)
1880 
      oprot.writeFieldEnd()
1881 
    if self.se != None:
1882 
      oprot.writeFieldBegin('se', TType.STRUCT, 1)
1883 
      self.se.write(oprot)
1884 
      oprot.writeFieldEnd()
1885 
    oprot.writeFieldStop()
1886 
    oprot.writeStructEnd()
1887 
 
1888 
  def __repr__(self):
1889 
    L = ['%s=%r' % (key, value)
1890 
      for key, value in self.__dict__.iteritems()]
1891 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
1892 
 
1893 
  def __eq__(self, other):
1894 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
1895 
 
1896 
  def __ne__(self, other):
1897 
    return not (self == other)
1898 
 
1899