0001
0003 """Various descriptions of data specific to Sanyo phones"""
0004
0005 from prototypes import *
0006 from prototypeslg import *
0007
0008
0010 UINT=UINTlsb
0011 BOOL=BOOLlsb
0012 _NUMPBSLOTS=300
0013 _NUMSPEEDDIALS=8
0014 _NUMLONGNUMBERS=5
0015 _LONGPHONENUMBERLEN=30
0016 _NUMEVENTSLOTS=100
0017 _NUMCALLALARMSLOTS=15
0018 NUMCALLHISTORY=20
0019 NUMPHONENUMBERS=7
0020 NUMMESSAGESLOTS=128
0021 NUMTODOSLOTS=20
0022 HASRINGPICBUF=1
0023 FIRSTSPEEDDIAL=2
0024 LASTSPEEDDIAL=9
0025
0026 OUTGOING=0
0027 INCOMING=1
0028 MISSED=2
0029
0030 class sanyoerror(BaseProtogenClass):
0031 __fields=['errorcode', 'unknown']
0032
0033 def __init__(self, *args, **kwargs):
0034 dict={}
0035 dict.update(kwargs)
0037 super(sanyoerror,self).__init__(**dict)
0039 if self.__class__ is sanyoerror:
0040 self._update(args,dict)
0041
0042
0043 def getfields(self):
0044 return self.__fields
0045
0046
0047 def _update(self, args, kwargs):
0048 super(sanyoerror,self)._update(args,kwargs)
0049 keys=kwargs.keys()
0050 for key in keys:
0051 if key in self.__fields:
0052 setattr(self, key, kwargs[key])
0053 del kwargs[key]
0054 if __debug__:
0056 self._complainaboutunusedargs(sanyoerror,kwargs)
0057 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0058
0060
0061 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0062 'Writes this packet to the supplied buffer'
0063 self._bufferstartoffset=buf.getcurrentoffset()
0064 self.__field_errorcode.writetobuffer(buf)
0065 self.__field_unknown.writetobuffer(buf)
0066 self._bufferendoffset=buf.getcurrentoffset()
0067 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0068
0069
0070 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0071 'Reads this packet from the supplied buffer'
0072 self._bufferstartoffset=buf.getcurrentoffset()
0073 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0074 self.__field_errorcode=UINT(**{'sizeinbytes': 1})
0075 self.__field_errorcode.readfrombuffer(buf)
0076 self.__field_unknown=UNKNOWN()
0077 self.__field_unknown.readfrombuffer(buf)
0078 self._bufferendoffset=buf.getcurrentoffset()
0079
0080
0081 def __getfield_errorcode(self):
0082 return self.__field_errorcode.getvalue()
0083
0084 def __setfield_errorcode(self, value):
0085 if isinstance(value,UINT):
0086 self.__field_errorcode=value
0087 else:
0088 self.__field_errorcode=UINT(value,**{'sizeinbytes': 1})
0089
0090 def __delfield_errorcode(self): del self.__field_errorcode
0091
0092 errorcode=property(__getfield_errorcode, __setfield_errorcode, __delfield_errorcode, None)
0093
0094 def __getfield_unknown(self):
0095 return self.__field_unknown.getvalue()
0096
0097 def __setfield_unknown(self, value):
0098 if isinstance(value,UNKNOWN):
0099 self.__field_unknown=value
0100 else:
0101 self.__field_unknown=UNKNOWN(value,)
0102
0103 def __delfield_unknown(self): del self.__field_unknown
0104
0105 unknown=property(__getfield_unknown, __setfield_unknown, __delfield_unknown, None)
0106
0107 def iscontainer(self):
0108 return True
0109
0110 def containerelements(self):
0111 yield ('errorcode', self.__field_errorcode, None)
0112 yield ('unknown', self.__field_unknown, None)
0113
0114
0115
0116
0117 class firmwarerequest(BaseProtogenClass):
0118 __fields=['command']
0119
0120 def __init__(self, *args, **kwargs):
0121 dict={}
0122 dict.update(kwargs)
0124 super(firmwarerequest,self).__init__(**dict)
0126 if self.__class__ is firmwarerequest:
0127 self._update(args,dict)
0128
0129
0130 def getfields(self):
0131 return self.__fields
0132
0133
0134 def _update(self, args, kwargs):
0135 super(firmwarerequest,self)._update(args,kwargs)
0136 keys=kwargs.keys()
0137 for key in keys:
0138 if key in self.__fields:
0139 setattr(self, key, kwargs[key])
0140 del kwargs[key]
0141 if __debug__:
0143 self._complainaboutunusedargs(firmwarerequest,kwargs)
0144 if len(args):
0145 dict2={'sizeinbytes': 1, 'constant': 0x00}
0146 dict2.update(kwargs)
0147 kwargs=dict2
0148 self.__field_command=UINT(*args,**dict2)
0149
0151
0152 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0153 'Writes this packet to the supplied buffer'
0154 self._bufferstartoffset=buf.getcurrentoffset()
0155 try: self.__field_command
0156 except:
0157 self.__field_command=UINT(**{'sizeinbytes': 1, 'constant': 0x00})
0158 self.__field_command.writetobuffer(buf)
0159 self._bufferendoffset=buf.getcurrentoffset()
0160 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0161
0162
0163 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0164 'Reads this packet from the supplied buffer'
0165 self._bufferstartoffset=buf.getcurrentoffset()
0166 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0167 self.__field_command=UINT(**{'sizeinbytes': 1, 'constant': 0x00})
0168 self.__field_command.readfrombuffer(buf)
0169 self._bufferendoffset=buf.getcurrentoffset()
0170
0171
0172 def __getfield_command(self):
0173 try: self.__field_command
0174 except:
0175 self.__field_command=UINT(**{'sizeinbytes': 1, 'constant': 0x00})
0176 return self.__field_command.getvalue()
0177
0178 def __setfield_command(self, value):
0179 if isinstance(value,UINT):
0180 self.__field_command=value
0181 else:
0182 self.__field_command=UINT(value,**{'sizeinbytes': 1, 'constant': 0x00})
0183
0184 def __delfield_command(self): del self.__field_command
0185
0186 command=property(__getfield_command, __setfield_command, __delfield_command, None)
0187
0188 def iscontainer(self):
0189 return True
0190
0191 def containerelements(self):
0192 yield ('command', self.__field_command, None)
0193
0194
0195
0196
0197 class firmwareresponse(BaseProtogenClass):
0198 __fields=['command', 'unknown']
0199
0200 def __init__(self, *args, **kwargs):
0201 dict={}
0202 dict.update(kwargs)
0204 super(firmwareresponse,self).__init__(**dict)
0206 if self.__class__ is firmwareresponse:
0207 self._update(args,dict)
0208
0209
0210 def getfields(self):
0211 return self.__fields
0212
0213
0214 def _update(self, args, kwargs):
0215 super(firmwareresponse,self)._update(args,kwargs)
0216 keys=kwargs.keys()
0217 for key in keys:
0218 if key in self.__fields:
0219 setattr(self, key, kwargs[key])
0220 del kwargs[key]
0221 if __debug__:
0223 self._complainaboutunusedargs(firmwareresponse,kwargs)
0224 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0225
0227
0228 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0229 'Writes this packet to the supplied buffer'
0230 self._bufferstartoffset=buf.getcurrentoffset()
0231 self.__field_command.writetobuffer(buf)
0232 self.__field_unknown.writetobuffer(buf)
0233 self._bufferendoffset=buf.getcurrentoffset()
0234 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0235
0236
0237 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0238 'Reads this packet from the supplied buffer'
0239 self._bufferstartoffset=buf.getcurrentoffset()
0240 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0241 self.__field_command=UINT(**{'sizeinbytes': 1})
0242 self.__field_command.readfrombuffer(buf)
0243 self.__field_unknown=UNKNOWN()
0244 self.__field_unknown.readfrombuffer(buf)
0245 self._bufferendoffset=buf.getcurrentoffset()
0246
0247
0248 def __getfield_command(self):
0249 return self.__field_command.getvalue()
0250
0251 def __setfield_command(self, value):
0252 if isinstance(value,UINT):
0253 self.__field_command=value
0254 else:
0255 self.__field_command=UINT(value,**{'sizeinbytes': 1})
0256
0257 def __delfield_command(self): del self.__field_command
0258
0259 command=property(__getfield_command, __setfield_command, __delfield_command, None)
0260
0261 def __getfield_unknown(self):
0262 return self.__field_unknown.getvalue()
0263
0264 def __setfield_unknown(self, value):
0265 if isinstance(value,UNKNOWN):
0266 self.__field_unknown=value
0267 else:
0268 self.__field_unknown=UNKNOWN(value,)
0269
0270 def __delfield_unknown(self): del self.__field_unknown
0271
0272 unknown=property(__getfield_unknown, __setfield_unknown, __delfield_unknown, None)
0273
0274 def iscontainer(self):
0275 return True
0276
0277 def containerelements(self):
0278 yield ('command', self.__field_command, None)
0279 yield ('unknown', self.__field_unknown, None)
0280
0281
0282
0283
0284 class beginendupdaterequest(BaseProtogenClass):
0285 __fields=['command', 'beginend']
0286
0287 def __init__(self, *args, **kwargs):
0288 dict={}
0289 dict.update(kwargs)
0291 super(beginendupdaterequest,self).__init__(**dict)
0293 if self.__class__ is beginendupdaterequest:
0294 self._update(args,dict)
0295
0296
0297 def getfields(self):
0298 return self.__fields
0299
0300
0301 def _update(self, args, kwargs):
0302 super(beginendupdaterequest,self)._update(args,kwargs)
0303 keys=kwargs.keys()
0304 for key in keys:
0305 if key in self.__fields:
0306 setattr(self, key, kwargs[key])
0307 del kwargs[key]
0308 if __debug__:
0310 self._complainaboutunusedargs(beginendupdaterequest,kwargs)
0311 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0312
0314
0315 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0316 'Writes this packet to the supplied buffer'
0317 self._bufferstartoffset=buf.getcurrentoffset()
0318 try: self.__field_command
0319 except:
0320 self.__field_command=UINT(**{'sizeinbytes': 1, 'constant': 0x29})
0321 self.__field_command.writetobuffer(buf)
0322 self.__field_beginend.writetobuffer(buf)
0323 self._bufferendoffset=buf.getcurrentoffset()
0324 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0325
0326
0327 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0328 'Reads this packet from the supplied buffer'
0329 self._bufferstartoffset=buf.getcurrentoffset()
0330 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0331 self.__field_command=UINT(**{'sizeinbytes': 1, 'constant': 0x29})
0332 self.__field_command.readfrombuffer(buf)
0333 self.__field_beginend=UINT(**{'sizeinbytes': 2})
0334 self.__field_beginend.readfrombuffer(buf)
0335 self._bufferendoffset=buf.getcurrentoffset()
0336
0337
0338 def __getfield_command(self):
0339 try: self.__field_command
0340 except:
0341 self.__field_command=UINT(**{'sizeinbytes': 1, 'constant': 0x29})
0342 return self.__field_command.getvalue()
0343
0344 def __setfield_command(self, value):
0345 if isinstance(value,UINT):
0346 self.__field_command=value
0347 else:
0348 self.__field_command=UINT(value,**{'sizeinbytes': 1, 'constant': 0x29})
0349
0350 def __delfield_command(self): del self.__field_command
0351
0352 command=property(__getfield_command, __setfield_command, __delfield_command, None)
0353
0354 def __getfield_beginend(self):
0355 return self.__field_beginend.getvalue()
0356
0357 def __setfield_beginend(self, value):
0358 if isinstance(value,UINT):
0359 self.__field_beginend=value
0360 else:
0361 self.__field_beginend=UINT(value,**{'sizeinbytes': 2})
0362
0363 def __delfield_beginend(self): del self.__field_beginend
0364
0365 beginend=property(__getfield_beginend, __setfield_beginend, __delfield_beginend, None)
0366
0367 def iscontainer(self):
0368 return True
0369
0370 def containerelements(self):
0371 yield ('command', self.__field_command, None)
0372 yield ('beginend', self.__field_beginend, None)
0373
0374
0375
0376
0377 class beginendupdateresponse(BaseProtogenClass):
0378 __fields=['command', 'beginend']
0379
0380 def __init__(self, *args, **kwargs):
0381 dict={}
0382 dict.update(kwargs)
0384 super(beginendupdateresponse,self).__init__(**dict)
0386 if self.__class__ is beginendupdateresponse:
0387 self._update(args,dict)
0388
0389
0390 def getfields(self):
0391 return self.__fields
0392
0393
0394 def _update(self, args, kwargs):
0395 super(beginendupdateresponse,self)._update(args,kwargs)
0396 keys=kwargs.keys()
0397 for key in keys:
0398 if key in self.__fields:
0399 setattr(self, key, kwargs[key])
0400 del kwargs[key]
0401 if __debug__:
0403 self._complainaboutunusedargs(beginendupdateresponse,kwargs)
0404 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0405
0407
0408 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0409 'Writes this packet to the supplied buffer'
0410 self._bufferstartoffset=buf.getcurrentoffset()
0411 self.__field_command.writetobuffer(buf)
0412 self.__field_beginend.writetobuffer(buf)
0413 self._bufferendoffset=buf.getcurrentoffset()
0414 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0415
0416
0417 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0418 'Reads this packet from the supplied buffer'
0419 self._bufferstartoffset=buf.getcurrentoffset()
0420 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0421 self.__field_command=UINT(**{'sizeinbytes': 1})
0422 self.__field_command.readfrombuffer(buf)
0423 self.__field_beginend=UINT(**{'sizeinbytes': 2})
0424 self.__field_beginend.readfrombuffer(buf)
0425 self._bufferendoffset=buf.getcurrentoffset()
0426
0427
0428 def __getfield_command(self):
0429 return self.__field_command.getvalue()
0430
0431 def __setfield_command(self, value):
0432 if isinstance(value,UINT):
0433 self.__field_command=value
0434 else:
0435 self.__field_command=UINT(value,**{'sizeinbytes': 1})
0436
0437 def __delfield_command(self): del self.__field_command
0438
0439 command=property(__getfield_command, __setfield_command, __delfield_command, None)
0440
0441 def __getfield_beginend(self):
0442 return self.__field_beginend.getvalue()
0443
0444 def __setfield_beginend(self, value):
0445 if isinstance(value,UINT):
0446 self.__field_beginend=value
0447 else:
0448 self.__field_beginend=UINT(value,**{'sizeinbytes': 2})
0449
0450 def __delfield_beginend(self): del self.__field_beginend
0451
0452 beginend=property(__getfield_beginend, __setfield_beginend, __delfield_beginend, None)
0453
0454 def iscontainer(self):
0455 return True
0456
0457 def containerelements(self):
0458 yield ('command', self.__field_command, None)
0459 yield ('beginend', self.__field_beginend, None)
0460
0461
0462
0463
0464 class statusrequest(BaseProtogenClass):
0465 __fields=['command']
0466
0467 def __init__(self, *args, **kwargs):
0468 dict={}
0469 dict.update(kwargs)
0471 super(statusrequest,self).__init__(**dict)
0473 if self.__class__ is statusrequest:
0474 self._update(args,dict)
0475
0476
0477 def getfields(self):
0478 return self.__fields
0479
0480
0481 def _update(self, args, kwargs):
0482 super(statusrequest,self)._update(args,kwargs)
0483 keys=kwargs.keys()
0484 for key in keys:
0485 if key in self.__fields:
0486 setattr(self, key, kwargs[key])
0487 del kwargs[key]
0488 if __debug__:
0490 self._complainaboutunusedargs(statusrequest,kwargs)
0491 if len(args):
0492 dict2={'sizeinbytes': 1, 'constant': 0x0c}
0493 dict2.update(kwargs)
0494 kwargs=dict2
0495 self.__field_command=UINT(*args,**dict2)
0496
0498
0499 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0500 'Writes this packet to the supplied buffer'
0501 self._bufferstartoffset=buf.getcurrentoffset()
0502 try: self.__field_command
0503 except:
0504 self.__field_command=UINT(**{'sizeinbytes': 1, 'constant': 0x0c})
0505 self.__field_command.writetobuffer(buf)
0506 self._bufferendoffset=buf.getcurrentoffset()
0507 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0508
0509
0510 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0511 'Reads this packet from the supplied buffer'
0512 self._bufferstartoffset=buf.getcurrentoffset()
0513 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0514 self.__field_command=UINT(**{'sizeinbytes': 1, 'constant': 0x0c})
0515 self.__field_command.readfrombuffer(buf)
0516 self._bufferendoffset=buf.getcurrentoffset()
0517
0518
0519 def __getfield_command(self):
0520 try: self.__field_command
0521 except:
0522 self.__field_command=UINT(**{'sizeinbytes': 1, 'constant': 0x0c})
0523 return self.__field_command.getvalue()
0524
0525 def __setfield_command(self, value):
0526 if isinstance(value,UINT):
0527 self.__field_command=value
0528 else:
0529 self.__field_command=UINT(value,**{'sizeinbytes': 1, 'constant': 0x0c})
0530
0531 def __delfield_command(self): del self.__field_command
0532
0533 command=property(__getfield_command, __setfield_command, __delfield_command, None)
0534
0535 def iscontainer(self):
0536 return True
0537
0538 def containerelements(self):
0539 yield ('command', self.__field_command, None)
0540
0541
0542
0543
0544 class statusresponse(BaseProtogenClass):
0545 __fields=['readyvalue', 'command', 'dunno1', 'esn', 'flag0', 'dunno2', 'ready', 'dunno3', 'flag2', 'dunno4', 'flag3', 'unknown']
0546
0547 def __init__(self, *args, **kwargs):
0548 dict={}
0549 dict.update(kwargs)
0551 super(statusresponse,self).__init__(**dict)
0553 if self.__class__ is statusresponse:
0554 self._update(args,dict)
0555
0556
0557 def getfields(self):
0558 return self.__fields
0559
0560
0561 def _update(self, args, kwargs):
0562 super(statusresponse,self)._update(args,kwargs)
0563 keys=kwargs.keys()
0564 for key in keys:
0565 if key in self.__fields:
0566 setattr(self, key, kwargs[key])
0567 del kwargs[key]
0568 if __debug__:
0570 self._complainaboutunusedargs(statusresponse,kwargs)
0571 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0572 try: self.__field_readyvalue
0574 except:
0575 self.__field_readyvalue=UINT(**{'constant': 0x0})
0576
0577
0578 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0579 'Writes this packet to the supplied buffer'
0580 self._bufferstartoffset=buf.getcurrentoffset()
0581 self.__field_command.writetobuffer(buf)
0582 self.__field_dunno1.writetobuffer(buf)
0583 self.__field_esn.writetobuffer(buf)
0584 self.__field_flag0.writetobuffer(buf)
0585 self.__field_dunno2.writetobuffer(buf)
0586 self.__field_ready.writetobuffer(buf)
0587 self.__field_dunno3.writetobuffer(buf)
0588 self.__field_flag2.writetobuffer(buf)
0589 self.__field_dunno4.writetobuffer(buf)
0590 self.__field_flag3.writetobuffer(buf)
0591 self.__field_unknown.writetobuffer(buf)
0592 self._bufferendoffset=buf.getcurrentoffset()
0593 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0594
0595
0596 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0597 'Reads this packet from the supplied buffer'
0598 self._bufferstartoffset=buf.getcurrentoffset()
0599 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0600 self.__field_command=UINT(**{'sizeinbytes': 1})
0601 self.__field_command.readfrombuffer(buf)
0602 self.__field_dunno1=UNKNOWN(**{'sizeinbytes': 3})
0603 self.__field_dunno1.readfrombuffer(buf)
0604 self.__field_esn=UINT(**{'sizeinbytes': 4})
0605 self.__field_esn.readfrombuffer(buf)
0606 self.__field_flag0=UINT(**{'sizeinbytes': 1})
0607 self.__field_flag0.readfrombuffer(buf)
0608 self.__field_dunno2=UNKNOWN(**{'sizeinbytes': 14})
0609 self.__field_dunno2.readfrombuffer(buf)
0610 self.__field_ready=UINT(**{'sizeinbytes': 1})
0611 self.__field_ready.readfrombuffer(buf)
0612 self.__field_dunno3=UINT(**{'sizeinbytes': 1})
0613 self.__field_dunno3.readfrombuffer(buf)
0614 self.__field_flag2=UINT(**{'sizeinbytes': 1})
0615 self.__field_flag2.readfrombuffer(buf)
0616 self.__field_dunno4=UNKNOWN(**{'sizeinbytes': 6})
0617 self.__field_dunno4.readfrombuffer(buf)
0618 self.__field_flag3=UINT(**{'sizeinbytes': 1})
0619 self.__field_flag3.readfrombuffer(buf)
0620 self.__field_unknown=UNKNOWN()
0621 self.__field_unknown.readfrombuffer(buf)
0622 self._bufferendoffset=buf.getcurrentoffset()
0623
0624
0625 def __getfield_readyvalue(self):
0626 return self.__field_readyvalue.getvalue()
0627
0628 def __setfield_readyvalue(self, value):
0629 if isinstance(value,UINT):
0630 self.__field_readyvalue=value
0631 else:
0632 self.__field_readyvalue=UINT(value,**{'constant': 0x0})
0633
0634 def __delfield_readyvalue(self): del self.__field_readyvalue
0635
0636 readyvalue=property(__getfield_readyvalue, __setfield_readyvalue, __delfield_readyvalue, None)
0637
0638 def __getfield_command(self):
0639 return self.__field_command.getvalue()
0640
0641 def __setfield_command(self, value):
0642 if isinstance(value,UINT):
0643 self.__field_command=value
0644 else:
0645 self.__field_command=UINT(value,**{'sizeinbytes': 1})
0646
0647 def __delfield_command(self): del self.__field_command
0648
0649 command=property(__getfield_command, __setfield_command, __delfield_command, None)
0650
0651 def __getfield_dunno1(self):
0652 return self.__field_dunno1.getvalue()
0653
0654 def __setfield_dunno1(self, value):
0655 if isinstance(value,UNKNOWN):
0656 self.__field_dunno1=value
0657 else:
0658 self.__field_dunno1=UNKNOWN(value,**{'sizeinbytes': 3})
0659
0660 def __delfield_dunno1(self): del self.__field_dunno1
0661
0662 dunno1=property(__getfield_dunno1, __setfield_dunno1, __delfield_dunno1, None)
0663
0664 def __getfield_esn(self):
0665 return self.__field_esn.getvalue()
0666
0667 def __setfield_esn(self, value):
0668 if isinstance(value,UINT):
0669 self.__field_esn=value
0670 else:
0671 self.__field_esn=UINT(value,**{'sizeinbytes': 4})
0672
0673 def __delfield_esn(self): del self.__field_esn
0674
0675 esn=property(__getfield_esn, __setfield_esn, __delfield_esn, None)
0676
0677 def __getfield_flag0(self):
0678 return self.__field_flag0.getvalue()
0679
0680 def __setfield_flag0(self, value):
0681 if isinstance(value,UINT):
0682 self.__field_flag0=value
0683 else:
0684 self.__field_flag0=UINT(value,**{'sizeinbytes': 1})
0685
0686 def __delfield_flag0(self): del self.__field_flag0
0687
0688 flag0=property(__getfield_flag0, __setfield_flag0, __delfield_flag0, None)
0689
0690 def __getfield_dunno2(self):
0691 return self.__field_dunno2.getvalue()
0692
0693 def __setfield_dunno2(self, value):
0694 if isinstance(value,UNKNOWN):
0695 self.__field_dunno2=value
0696 else:
0697 self.__field_dunno2=UNKNOWN(value,**{'sizeinbytes': 14})
0698
0699 def __delfield_dunno2(self): del self.__field_dunno2
0700
0701 dunno2=property(__getfield_dunno2, __setfield_dunno2, __delfield_dunno2, None)
0702
0703 def __getfield_ready(self):
0704 return self.__field_ready.getvalue()
0705
0706 def __setfield_ready(self, value):
0707 if isinstance(value,UINT):
0708 self.__field_ready=value
0709 else:
0710 self.__field_ready=UINT(value,**{'sizeinbytes': 1})
0711
0712 def __delfield_ready(self): del self.__field_ready
0713
0714 ready=property(__getfield_ready, __setfield_ready, __delfield_ready, None)
0715
0716 def __getfield_dunno3(self):
0717 return self.__field_dunno3.getvalue()
0718
0719 def __setfield_dunno3(self, value):
0720 if isinstance(value,UINT):
0721 self.__field_dunno3=value
0722 else:
0723 self.__field_dunno3=UINT(value,**{'sizeinbytes': 1})
0724
0725 def __delfield_dunno3(self): del self.__field_dunno3
0726
0727 dunno3=property(__getfield_dunno3, __setfield_dunno3, __delfield_dunno3, None)
0728
0729 def __getfield_flag2(self):
0730 return self.__field_flag2.getvalue()
0731
0732 def __setfield_flag2(self, value):
0733 if isinstance(value,UINT):
0734 self.__field_flag2=value
0735 else:
0736 self.__field_flag2=UINT(value,**{'sizeinbytes': 1})
0737
0738 def __delfield_flag2(self): del self.__field_flag2
0739
0740 flag2=property(__getfield_flag2, __setfield_flag2, __delfield_flag2, None)
0741
0742 def __getfield_dunno4(self):
0743 return self.__field_dunno4.getvalue()
0744
0745 def __setfield_dunno4(self, value):
0746 if isinstance(value,UNKNOWN):
0747 self.__field_dunno4=value
0748 else:
0749 self.__field_dunno4=UNKNOWN(value,**{'sizeinbytes': 6})
0750
0751 def __delfield_dunno4(self): del self.__field_dunno4
0752
0753 dunno4=property(__getfield_dunno4, __setfield_dunno4, __delfield_dunno4, None)
0754
0755 def __getfield_flag3(self):
0756 return self.__field_flag3.getvalue()
0757
0758 def __setfield_flag3(self, value):
0759 if isinstance(value,UINT):
0760 self.__field_flag3=value
0761 else:
0762 self.__field_flag3=UINT(value,**{'sizeinbytes': 1})
0763
0764 def __delfield_flag3(self): del self.__field_flag3
0765
0766 flag3=property(__getfield_flag3, __setfield_flag3, __delfield_flag3, None)
0767
0768 def __getfield_unknown(self):
0769 return self.__field_unknown.getvalue()
0770
0771 def __setfield_unknown(self, value):
0772 if isinstance(value,UNKNOWN):
0773 self.__field_unknown=value
0774 else:
0775 self.__field_unknown=UNKNOWN(value,)
0776
0777 def __delfield_unknown(self): del self.__field_unknown
0778
0779 unknown=property(__getfield_unknown, __setfield_unknown, __delfield_unknown, None)
0780
0781 def iscontainer(self):
0782 return True
0783
0784 def containerelements(self):
0785 yield ('readyvalue', self.__field_readyvalue, None)
0786 yield ('command', self.__field_command, None)
0787 yield ('dunno1', self.__field_dunno1, None)
0788 yield ('esn', self.__field_esn, None)
0789 yield ('flag0', self.__field_flag0, None)
0790 yield ('dunno2', self.__field_dunno2, None)
0791 yield ('ready', self.__field_ready, None)
0792 yield ('dunno3', self.__field_dunno3, None)
0793 yield ('flag2', self.__field_flag2, None)
0794 yield ('dunno4', self.__field_dunno4, None)
0795 yield ('flag3', self.__field_flag3, None)
0796 yield ('unknown', self.__field_unknown, None)
0797
0798
0799
0800
0801 class lockcoderequest(BaseProtogenClass):
0802 __fields=['command1', 'command2', 'pad']
0803
0804 def __init__(self, *args, **kwargs):
0805 dict={}
0806 dict.update(kwargs)
0808 super(lockcoderequest,self).__init__(**dict)
0810 if self.__class__ is lockcoderequest:
0811 self._update(args,dict)
0812
0813
0814 def getfields(self):
0815 return self.__fields
0816
0817
0818 def _update(self, args, kwargs):
0819 super(lockcoderequest,self)._update(args,kwargs)
0820 keys=kwargs.keys()
0821 for key in keys:
0822 if key in self.__fields:
0823 setattr(self, key, kwargs[key])
0824 del kwargs[key]
0825 if __debug__:
0827 self._complainaboutunusedargs(lockcoderequest,kwargs)
0828 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0829
0831
0832 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0833 'Writes this packet to the supplied buffer'
0834 self._bufferstartoffset=buf.getcurrentoffset()
0835 try: self.__field_command1
0836 except:
0837 self.__field_command1=UINT(**{'sizeinbytes': 1, 'constant': 0x26})
0838 self.__field_command1.writetobuffer(buf)
0839 try: self.__field_command2
0840 except:
0841 self.__field_command2=UINT(**{'sizeinbytes': 2, 'constant': 0x52})
0842 self.__field_command2.writetobuffer(buf)
0843 try: self.__field_pad
0844 except:
0845 self.__field_pad=UNKNOWN(**{'sizeinbytes': 130})
0846 self.__field_pad.writetobuffer(buf)
0847 self._bufferendoffset=buf.getcurrentoffset()
0848 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0849
0850
0851 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0852 'Reads this packet from the supplied buffer'
0853 self._bufferstartoffset=buf.getcurrentoffset()
0854 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0855 self.__field_command1=UINT(**{'sizeinbytes': 1, 'constant': 0x26})
0856 self.__field_command1.readfrombuffer(buf)
0857 self.__field_command2=UINT(**{'sizeinbytes': 2, 'constant': 0x52})
0858 self.__field_command2.readfrombuffer(buf)
0859 self.__field_pad=UNKNOWN(**{'sizeinbytes': 130})
0860 self.__field_pad.readfrombuffer(buf)
0861 self._bufferendoffset=buf.getcurrentoffset()
0862
0863
0864 def __getfield_command1(self):
0865 try: self.__field_command1
0866 except:
0867 self.__field_command1=UINT(**{'sizeinbytes': 1, 'constant': 0x26})
0868 return self.__field_command1.getvalue()
0869
0870 def __setfield_command1(self, value):
0871 if isinstance(value,UINT):
0872 self.__field_command1=value
0873 else:
0874 self.__field_command1=UINT(value,**{'sizeinbytes': 1, 'constant': 0x26})
0875
0876 def __delfield_command1(self): del self.__field_command1
0877
0878 command1=property(__getfield_command1, __setfield_command1, __delfield_command1, None)
0879
0880 def __getfield_command2(self):
0881 try: self.__field_command2
0882 except:
0883 self.__field_command2=UINT(**{'sizeinbytes': 2, 'constant': 0x52})
0884 return self.__field_command2.getvalue()
0885
0886 def __setfield_command2(self, value):
0887 if isinstance(value,UINT):
0888 self.__field_command2=value
0889 else:
0890 self.__field_command2=UINT(value,**{'sizeinbytes': 2, 'constant': 0x52})
0891
0892 def __delfield_command2(self): del self.__field_command2
0893
0894 command2=property(__getfield_command2, __setfield_command2, __delfield_command2, None)
0895
0896 def __getfield_pad(self):
0897 try: self.__field_pad
0898 except:
0899 self.__field_pad=UNKNOWN(**{'sizeinbytes': 130})
0900 return self.__field_pad.getvalue()
0901
0902 def __setfield_pad(self, value):
0903 if isinstance(value,UNKNOWN):
0904 self.__field_pad=value
0905 else:
0906 self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 130})
0907
0908 def __delfield_pad(self): del self.__field_pad
0909
0910 pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None)
0911
0912 def iscontainer(self):
0913 return True
0914
0915 def containerelements(self):
0916 yield ('command1', self.__field_command1, None)
0917 yield ('command2', self.__field_command2, None)
0918 yield ('pad', self.__field_pad, None)
0919
0920
0921
0922
0923 class lockcoderesponse(BaseProtogenClass):
0924 __fields=['command1', 'command2', 'lockcode', 'pad']
0925
0926 def __init__(self, *args, **kwargs):
0927 dict={}
0928 dict.update(kwargs)
0930 super(lockcoderesponse,self).__init__(**dict)
0932 if self.__class__ is lockcoderesponse:
0933 self._update(args,dict)
0934
0935
0936 def getfields(self):
0937 return self.__fields
0938
0939
0940 def _update(self, args, kwargs):
0941 super(lockcoderesponse,self)._update(args,kwargs)
0942 keys=kwargs.keys()
0943 for key in keys:
0944 if key in self.__fields:
0945 setattr(self, key, kwargs[key])
0946 del kwargs[key]
0947 if __debug__:
0949 self._complainaboutunusedargs(lockcoderesponse,kwargs)
0950 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0951
0953
0954 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0955 'Writes this packet to the supplied buffer'
0956 self._bufferstartoffset=buf.getcurrentoffset()
0957 try: self.__field_command1
0958 except:
0959 self.__field_command1=UINT(**{'sizeinbytes': 1, 'constant': 0x26})
0960 self.__field_command1.writetobuffer(buf)
0961 try: self.__field_command2
0962 except:
0963 self.__field_command2=UINT(**{'sizeinbytes': 2, 'constant': 0x52})
0964 self.__field_command2.writetobuffer(buf)
0965 self.__field_lockcode.writetobuffer(buf)
0966 self.__field_pad.writetobuffer(buf)
0967 self._bufferendoffset=buf.getcurrentoffset()
0968 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0969
0970
0971 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0972 'Reads this packet from the supplied buffer'
0973 self._bufferstartoffset=buf.getcurrentoffset()
0974 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0975 self.__field_command1=UINT(**{'sizeinbytes': 1, 'constant': 0x26})
0976 self.__field_command1.readfrombuffer(buf)
0977 self.__field_command2=UINT(**{'sizeinbytes': 2, 'constant': 0x52})
0978 self.__field_command2.readfrombuffer(buf)
0979 self.__field_lockcode=USTRING(**{'sizeinbytes': 4, 'raiseonunterminatedread': False})
0980 self.__field_lockcode.readfrombuffer(buf)
0981 self.__field_pad=UNKNOWN()
0982 self.__field_pad.readfrombuffer(buf)
0983 self._bufferendoffset=buf.getcurrentoffset()
0984
0985
0986 def __getfield_command1(self):
0987 try: self.__field_command1
0988 except:
0989 self.__field_command1=UINT(**{'sizeinbytes': 1, 'constant': 0x26})
0990 return self.__field_command1.getvalue()
0991
0992 def __setfield_command1(self, value):
0993 if isinstance(value,UINT):
0994 self.__field_command1=value
0995 else:
0996 self.__field_command1=UINT(value,**{'sizeinbytes': 1, 'constant': 0x26})
0997
0998 def __delfield_command1(self): del self.__field_command1
0999
1000 command1=property(__getfield_command1, __setfield_command1, __delfield_command1, None)
1001
1002 def __getfield_command2(self):
1003 try: self.__field_command2
1004 except:
1005 self.__field_command2=UINT(**{'sizeinbytes': 2, 'constant': 0x52})
1006 return self.__field_command2.getvalue()
1007
1008 def __setfield_command2(self, value):
1009 if isinstance(value,UINT):
1010 self.__field_command2=value
1011 else:
1012 self.__field_command2=UINT(value,**{'sizeinbytes': 2, 'constant': 0x52})
1013
1014 def __delfield_command2(self): del self.__field_command2
1015
1016 command2=property(__getfield_command2, __setfield_command2, __delfield_command2, None)
1017
1018 def __getfield_lockcode(self):
1019 return self.__field_lockcode.getvalue()
1020
1021 def __setfield_lockcode(self, value):
1022 if isinstance(value,USTRING):
1023 self.__field_lockcode=value
1024 else:
1025 self.__field_lockcode=USTRING(value,**{'sizeinbytes': 4, 'raiseonunterminatedread': False})
1026
1027 def __delfield_lockcode(self): del self.__field_lockcode
1028
1029 lockcode=property(__getfield_lockcode, __setfield_lockcode, __delfield_lockcode, None)
1030
1031 def __getfield_pad(self):
1032 return self.__field_pad.getvalue()
1033
1034 def __setfield_pad(self, value):
1035 if isinstance(value,UNKNOWN):
1036 self.__field_pad=value
1037 else:
1038 self.__field_pad=UNKNOWN(value,)
1039
1040 def __delfield_pad(self): del self.__field_pad
1041
1042 pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None)
1043
1044 def iscontainer(self):
1045 return True
1046
1047 def containerelements(self):
1048 yield ('command1', self.__field_command1, None)
1049 yield ('command2', self.__field_command2, None)
1050 yield ('lockcode', self.__field_lockcode, None)
1051 yield ('pad', self.__field_pad, None)
1052
1053
1054
1055
1056 class sanyofirmwarerequest(BaseProtogenClass):
1057 __fields=['command']
1058
1059 def __init__(self, *args, **kwargs):
1060 dict={}
1061 dict.update(kwargs)
1063 super(sanyofirmwarerequest,self).__init__(**dict)
1065 if self.__class__ is sanyofirmwarerequest:
1066 self._update(args,dict)
1067
1068
1069 def getfields(self):
1070 return self.__fields
1071
1072
1073 def _update(self, args, kwargs):
1074 super(sanyofirmwarerequest,self)._update(args,kwargs)
1075 keys=kwargs.keys()
1076 for key in keys:
1077 if key in self.__fields:
1078 setattr(self, key, kwargs[key])
1079 del kwargs[key]
1080 if __debug__:
1082 self._complainaboutunusedargs(sanyofirmwarerequest,kwargs)
1083 if len(args):
1084 dict2={'sizeinbytes': 1, 'constant': 0x00}
1085 dict2.update(kwargs)
1086 kwargs=dict2
1087 self.__field_command=UINT(*args,**dict2)
1088
1090
1091 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1092 'Writes this packet to the supplied buffer'
1093 self._bufferstartoffset=buf.getcurrentoffset()
1094 try: self.__field_command
1095 except:
1096 self.__field_command=UINT(**{'sizeinbytes': 1, 'constant': 0x00})
1097 self.__field_command.writetobuffer(buf)
1098 self._bufferendoffset=buf.getcurrentoffset()
1099 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1100
1101
1102 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1103 'Reads this packet from the supplied buffer'
1104 self._bufferstartoffset=buf.getcurrentoffset()
1105 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1106 self.__field_command=UINT(**{'sizeinbytes': 1, 'constant': 0x00})
1107 self.__field_command.readfrombuffer(buf)
1108 self._bufferendoffset=buf.getcurrentoffset()
1109
1110
1111 def __getfield_command(self):
1112 try: self.__field_command
1113 except:
1114 self.__field_command=UINT(**{'sizeinbytes': 1, 'constant': 0x00})
1115 return self.__field_command.getvalue()
1116
1117 def __setfield_command(self, value):
1118 if isinstance(value,UINT):
1119 self.__field_command=value
1120 else:
1121 self.__field_command=UINT(value,**{'sizeinbytes': 1, 'constant': 0x00})
1122
1123 def __delfield_command(self): del self.__field_command
1124
1125 command=property(__getfield_command, __setfield_command, __delfield_command, None)
1126
1127 def iscontainer(self):
1128 return True
1129
1130 def containerelements(self):
1131 yield ('command', self.__field_command, None)
1132
1133
1134
1135
1136 class sanyofirmwareresponse(BaseProtogenClass):
1137 __fields=['command', 'date1', 'time1', 'date2', 'time2', 'string1', 'dunno1', 'date3', 'dunno2', 'time3', 'dunno3', 'firmware', 'pad', 'phonemodel', 'prl']
1138
1139 def __init__(self, *args, **kwargs):
1140 dict={}
1141 dict.update(kwargs)
1143 super(sanyofirmwareresponse,self).__init__(**dict)
1145 if self.__class__ is sanyofirmwareresponse:
1146 self._update(args,dict)
1147
1148
1149 def getfields(self):
1150 return self.__fields
1151
1152
1153 def _update(self, args, kwargs):
1154 super(sanyofirmwareresponse,self)._update(args,kwargs)
1155 keys=kwargs.keys()
1156 for key in keys:
1157 if key in self.__fields:
1158 setattr(self, key, kwargs[key])
1159 del kwargs[key]
1160 if __debug__:
1162 self._complainaboutunusedargs(sanyofirmwareresponse,kwargs)
1163 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1164
1166
1167 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1168 'Writes this packet to the supplied buffer'
1169 self._bufferstartoffset=buf.getcurrentoffset()
1170 self.__field_command.writetobuffer(buf)
1171 self.__field_date1.writetobuffer(buf)
1172 self.__field_time1.writetobuffer(buf)
1173 self.__field_date2.writetobuffer(buf)
1174 self.__field_time2.writetobuffer(buf)
1175 self.__field_string1.writetobuffer(buf)
1176 self.__field_dunno1.writetobuffer(buf)
1177 self.__field_date3.writetobuffer(buf)
1178 self.__field_dunno2.writetobuffer(buf)
1179 self.__field_time3.writetobuffer(buf)
1180 self.__field_dunno3.writetobuffer(buf)
1181 self.__field_firmware.writetobuffer(buf)
1182 self.__field_pad.writetobuffer(buf)
1183 self.__field_phonemodel.writetobuffer(buf)
1184 self.__field_prl.writetobuffer(buf)
1185 self._bufferendoffset=buf.getcurrentoffset()
1186 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1187
1188
1189 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1190 'Reads this packet from the supplied buffer'
1191 self._bufferstartoffset=buf.getcurrentoffset()
1192 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1193 self.__field_command=UINT(**{'sizeinbytes': 1})
1194 self.__field_command.readfrombuffer(buf)
1195 self.__field_date1=USTRING(**{'sizeinbytes': 11, 'terminator': None})
1196 self.__field_date1.readfrombuffer(buf)
1197 self.__field_time1=USTRING(**{'sizeinbytes': 8, 'terminator': None})
1198 self.__field_time1.readfrombuffer(buf)
1199 self.__field_date2=USTRING(**{'sizeinbytes': 11, 'terminator': None})
1200 self.__field_date2.readfrombuffer(buf)
1201 self.__field_time2=USTRING(**{'sizeinbytes': 8, 'terminator': None})
1202 self.__field_time2.readfrombuffer(buf)
1203 self.__field_string1=USTRING(**{'sizeinbytes': 8, 'terminator': None})
1204 self.__field_string1.readfrombuffer(buf)
1205 self.__field_dunno1=UNKNOWN(**{'sizeinbytes': 1})
1206 self.__field_dunno1.readfrombuffer(buf)
1207 self.__field_date3=USTRING(**{'sizeinbytes': 11, 'terminator': None})
1208 self.__field_date3.readfrombuffer(buf)
1209 self.__field_dunno2=UNKNOWN(**{'sizeinbytes': 1})
1210 self.__field_dunno2.readfrombuffer(buf)
1211 self.__field_time3=USTRING(**{'sizeinbytes': 8, 'terminator': None})
1212 self.__field_time3.readfrombuffer(buf)
1213 self.__field_dunno3=UNKNOWN(**{'sizeinbytes': 11})
1214 self.__field_dunno3.readfrombuffer(buf)
1215 self.__field_firmware=USTRING(**{'sizeinbytes': 10, 'terminator': None})
1216 self.__field_firmware.readfrombuffer(buf)
1217 self.__field_pad=UNKNOWN(**{'sizeinbytes': 7})
1218 self.__field_pad.readfrombuffer(buf)
1219 self.__field_phonemodel=USTRING(**{'sizeinbytes': 16, 'terminator': None})
1220 self.__field_phonemodel.readfrombuffer(buf)
1221 self.__field_prl=USTRING(**{'sizeinbytes': 5, 'terminator': None})
1222 self.__field_prl.readfrombuffer(buf)
1223 self._bufferendoffset=buf.getcurrentoffset()
1224
1225
1226 def __getfield_command(self):
1227 return self.__field_command.getvalue()
1228
1229 def __setfield_command(self, value):
1230 if isinstance(value,UINT):
1231 self.__field_command=value
1232 else:
1233 self.__field_command=UINT(value,**{'sizeinbytes': 1})
1234
1235 def __delfield_command(self): del self.__field_command
1236
1237 command=property(__getfield_command, __setfield_command, __delfield_command, None)
1238
1239 def __getfield_date1(self):
1240 return self.__field_date1.getvalue()
1241
1242 def __setfield_date1(self, value):
1243 if isinstance(value,USTRING):
1244 self.__field_date1=value
1245 else:
1246 self.__field_date1=USTRING(value,**{'sizeinbytes': 11, 'terminator': None})
1247
1248 def __delfield_date1(self): del self.__field_date1
1249
1250 date1=property(__getfield_date1, __setfield_date1, __delfield_date1, None)
1251
1252 def __getfield_time1(self):
1253 return self.__field_time1.getvalue()
1254
1255 def __setfield_time1(self, value):
1256 if isinstance(value,USTRING):
1257 self.__field_time1=value
1258 else:
1259 self.__field_time1=USTRING(value,**{'sizeinbytes': 8, 'terminator': None})
1260
1261 def __delfield_time1(self): del self.__field_time1
1262
1263 time1=property(__getfield_time1, __setfield_time1, __delfield_time1, None)
1264
1265 def __getfield_date2(self):
1266 return self.__field_date2.getvalue()
1267
1268 def __setfield_date2(self, value):
1269 if isinstance(value,USTRING):
1270 self.__field_date2=value
1271 else:
1272 self.__field_date2=USTRING(value,**{'sizeinbytes': 11, 'terminator': None})
1273
1274 def __delfield_date2(self): del self.__field_date2
1275
1276 date2=property(__getfield_date2, __setfield_date2, __delfield_date2, None)
1277
1278 def __getfield_time2(self):
1279 return self.__field_time2.getvalue()
1280
1281 def __setfield_time2(self, value):
1282 if isinstance(value,USTRING):
1283 self.__field_time2=value
1284 else:
1285 self.__field_time2=USTRING(value,**{'sizeinbytes': 8, 'terminator': None})
1286
1287 def __delfield_time2(self): del self.__field_time2
1288
1289 time2=property(__getfield_time2, __setfield_time2, __delfield_time2, None)
1290
1291 def __getfield_string1(self):
1292 return self.__field_string1.getvalue()
1293
1294 def __setfield_string1(self, value):
1295 if isinstance(value,USTRING):
1296 self.__field_string1=value
1297 else:
1298 self.__field_string1=USTRING(value,**{'sizeinbytes': 8, 'terminator': None})
1299
1300 def __delfield_string1(self): del self.__field_string1
1301
1302 string1=property(__getfield_string1, __setfield_string1, __delfield_string1, None)
1303
1304 def __getfield_dunno1(self):
1305 return self.__field_dunno1.getvalue()
1306
1307 def __setfield_dunno1(self, value):
1308 if isinstance(value,UNKNOWN):
1309 self.__field_dunno1=value
1310 else:
1311 self.__field_dunno1=UNKNOWN(value,**{'sizeinbytes': 1})
1312
1313 def __delfield_dunno1(self): del self.__field_dunno1
1314
1315 dunno1=property(__getfield_dunno1, __setfield_dunno1, __delfield_dunno1, None)
1316
1317 def __getfield_date3(self):
1318 return self.__field_date3.getvalue()
1319
1320 def __setfield_date3(self, value):
1321 if isinstance(value,USTRING):
1322 self.__field_date3=value
1323 else:
1324 self.__field_date3=USTRING(value,**{'sizeinbytes': 11, 'terminator': None})
1325
1326 def __delfield_date3(self): del self.__field_date3
1327
1328 date3=property(__getfield_date3, __setfield_date3, __delfield_date3, None)
1329
1330 def __getfield_dunno2(self):
1331 return self.__field_dunno2.getvalue()
1332
1333 def __setfield_dunno2(self, value):
1334 if isinstance(value,UNKNOWN):
1335 self.__field_dunno2=value
1336 else:
1337 self.__field_dunno2=UNKNOWN(value,**{'sizeinbytes': 1})
1338
1339 def __delfield_dunno2(self): del self.__field_dunno2
1340
1341 dunno2=property(__getfield_dunno2, __setfield_dunno2, __delfield_dunno2, None)
1342
1343 def __getfield_time3(self):
1344 return self.__field_time3.getvalue()
1345
1346 def __setfield_time3(self, value):
1347 if isinstance(value,USTRING):
1348 self.__field_time3=value
1349 else:
1350 self.__field_time3=USTRING(value,**{'sizeinbytes': 8, 'terminator': None})
1351
1352 def __delfield_time3(self): del self.__field_time3
1353
1354 time3=property(__getfield_time3, __setfield_time3, __delfield_time3, None)
1355
1356 def __getfield_dunno3(self):
1357 return self.__field_dunno3.getvalue()
1358
1359 def __setfield_dunno3(self, value):
1360 if isinstance(value,UNKNOWN):
1361 self.__field_dunno3=value
1362 else:
1363 self.__field_dunno3=UNKNOWN(value,**{'sizeinbytes': 11})
1364
1365 def __delfield_dunno3(self): del self.__field_dunno3
1366
1367 dunno3=property(__getfield_dunno3, __setfield_dunno3, __delfield_dunno3, None)
1368
1369 def __getfield_firmware(self):
1370 return self.__field_firmware.getvalue()
1371
1372 def __setfield_firmware(self, value):
1373 if isinstance(value,USTRING):
1374 self.__field_firmware=value
1375 else:
1376 self.__field_firmware=USTRING(value,**{'sizeinbytes': 10, 'terminator': None})
1377
1378 def __delfield_firmware(self): del self.__field_firmware
1379
1380 firmware=property(__getfield_firmware, __setfield_firmware, __delfield_firmware, None)
1381
1382 def __getfield_pad(self):
1383 return self.__field_pad.getvalue()
1384
1385 def __setfield_pad(self, value):
1386 if isinstance(value,UNKNOWN):
1387 self.__field_pad=value
1388 else:
1389 self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 7})
1390
1391 def __delfield_pad(self): del self.__field_pad
1392
1393 pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None)
1394
1395 def __getfield_phonemodel(self):
1396 return self.__field_phonemodel.getvalue()
1397
1398 def __setfield_phonemodel(self, value):
1399 if isinstance(value,USTRING):
1400 self.__field_phonemodel=value
1401 else:
1402 self.__field_phonemodel=USTRING(value,**{'sizeinbytes': 16, 'terminator': None})
1403
1404 def __delfield_phonemodel(self): del self.__field_phonemodel
1405
1406 phonemodel=property(__getfield_phonemodel, __setfield_phonemodel, __delfield_phonemodel, None)
1407
1408 def __getfield_prl(self):
1409 return self.__field_prl.getvalue()
1410
1411 def __setfield_prl(self, value):
1412 if isinstance(value,USTRING):
1413 self.__field_prl=value
1414 else:
1415 self.__field_prl=USTRING(value,**{'sizeinbytes': 5, 'terminator': None})
1416
1417 def __delfield_prl(self): del self.__field_prl
1418
1419 prl=property(__getfield_prl, __setfield_prl, __delfield_prl, None)
1420
1421 def iscontainer(self):
1422 return True
1423
1424 def containerelements(self):
1425 yield ('command', self.__field_command, None)
1426 yield ('date1', self.__field_date1, None)
1427 yield ('time1', self.__field_time1, None)
1428 yield ('date2', self.__field_date2, None)
1429 yield ('time2', self.__field_time2, None)
1430 yield ('string1', self.__field_string1, None)
1431 yield ('dunno1', self.__field_dunno1, None)
1432 yield ('date3', self.__field_date3, None)
1433 yield ('dunno2', self.__field_dunno2, None)
1434 yield ('time3', self.__field_time3, None)
1435 yield ('dunno3', self.__field_dunno3, None)
1436 yield ('firmware', self.__field_firmware, None)
1437 yield ('pad', self.__field_pad, None)
1438 yield ('phonemodel', self.__field_phonemodel, None)
1439 yield ('prl', self.__field_prl, None)
1440
1441
1442
1443
1444 class reconditionedrequest(BaseProtogenClass):
1445 __fields=['command1', 'command2', 'pad']
1446
1447 def __init__(self, *args, **kwargs):
1448 dict={}
1449 dict.update(kwargs)
1451 super(reconditionedrequest,self).__init__(**dict)
1453 if self.__class__ is reconditionedrequest:
1454 self._update(args,dict)
1455
1456
1457 def getfields(self):
1458 return self.__fields
1459
1460
1461 def _update(self, args, kwargs):
1462 super(reconditionedrequest,self)._update(args,kwargs)
1463 keys=kwargs.keys()
1464 for key in keys:
1465 if key in self.__fields:
1466 setattr(self, key, kwargs[key])
1467 del kwargs[key]
1468 if __debug__:
1470 self._complainaboutunusedargs(reconditionedrequest,kwargs)
1471 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1472
1474
1475 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1476 'Writes this packet to the supplied buffer'
1477 self._bufferstartoffset=buf.getcurrentoffset()
1478 try: self.__field_command1
1479 except:
1480 self.__field_command1=UINT(**{'sizeinbytes': 1, 'constant': 0x26})
1481 self.__field_command1.writetobuffer(buf)
1482 try: self.__field_command2
1483 except:
1484 self.__field_command2=UINT(**{'sizeinbytes': 2, 'constant': 0x0c1b})
1485 self.__field_command2.writetobuffer(buf)
1486 try: self.__field_pad
1487 except:
1488 self.__field_pad=UNKNOWN(**{'sizeinbytes': 130})
1489 self.__field_pad.writetobuffer(buf)
1490 self._bufferendoffset=buf.getcurrentoffset()
1491 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1492
1493
1494 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1495 'Reads this packet from the supplied buffer'
1496 self._bufferstartoffset=buf.getcurrentoffset()
1497 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1498 self.__field_command1=UINT(**{'sizeinbytes': 1, 'constant': 0x26})
1499 self.__field_command1.readfrombuffer(buf)
1500 self.__field_command2=UINT(**{'sizeinbytes': 2, 'constant': 0x0c1b})
1501 self.__field_command2.readfrombuffer(buf)
1502 self.__field_pad=UNKNOWN(**{'sizeinbytes': 130})
1503 self.__field_pad.readfrombuffer(buf)
1504 self._bufferendoffset=buf.getcurrentoffset()
1505
1506
1507 def __getfield_command1(self):
1508 try: self.__field_command1
1509 except:
1510 self.__field_command1=UINT(**{'sizeinbytes': 1, 'constant': 0x26})
1511 return self.__field_command1.getvalue()
1512
1513 def __setfield_command1(self, value):
1514 if isinstance(value,UINT):
1515 self.__field_command1=value
1516 else:
1517 self.__field_command1=UINT(value,**{'sizeinbytes': 1, 'constant': 0x26})
1518
1519 def __delfield_command1(self): del self.__field_command1
1520
1521 command1=property(__getfield_command1, __setfield_command1, __delfield_command1, None)
1522
1523 def __getfield_command2(self):
1524 try: self.__field_command2
1525 except:
1526 self.__field_command2=UINT(**{'sizeinbytes': 2, 'constant': 0x0c1b})
1527 return self.__field_command2.getvalue()
1528
1529 def __setfield_command2(self, value):
1530 if isinstance(value,UINT):
1531 self.__field_command2=value
1532 else:
1533 self.__field_command2=UINT(value,**{'sizeinbytes': 2, 'constant': 0x0c1b})
1534
1535 def __delfield_command2(self): del self.__field_command2
1536
1537 command2=property(__getfield_command2, __setfield_command2, __delfield_command2, None)
1538
1539 def __getfield_pad(self):
1540 try: self.__field_pad
1541 except:
1542 self.__field_pad=UNKNOWN(**{'sizeinbytes': 130})
1543 return self.__field_pad.getvalue()
1544
1545 def __setfield_pad(self, value):
1546 if isinstance(value,UNKNOWN):
1547 self.__field_pad=value
1548 else:
1549 self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 130})
1550
1551 def __delfield_pad(self): del self.__field_pad
1552
1553 pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None)
1554
1555 def iscontainer(self):
1556 return True
1557
1558 def containerelements(self):
1559 yield ('command1', self.__field_command1, None)
1560 yield ('command2', self.__field_command2, None)
1561 yield ('pad', self.__field_pad, None)
1562
1563
1564
1565
1566 class reconditionedresponse(BaseProtogenClass):
1567 __fields=['command1', 'command2', 'reconditioned', 'pad']
1568
1569 def __init__(self, *args, **kwargs):
1570 dict={}
1571 dict.update(kwargs)
1573 super(reconditionedresponse,self).__init__(**dict)
1575 if self.__class__ is reconditionedresponse:
1576 self._update(args,dict)
1577
1578
1579 def getfields(self):
1580 return self.__fields
1581
1582
1583 def _update(self, args, kwargs):
1584 super(reconditionedresponse,self)._update(args,kwargs)
1585 keys=kwargs.keys()
1586 for key in keys:
1587 if key in self.__fields:
1588 setattr(self, key, kwargs[key])
1589 del kwargs[key]
1590 if __debug__:
1592 self._complainaboutunusedargs(reconditionedresponse,kwargs)
1593 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1594
1596
1597 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1598 'Writes this packet to the supplied buffer'
1599 self._bufferstartoffset=buf.getcurrentoffset()
1600 self.__field_command1.writetobuffer(buf)
1601 self.__field_command2.writetobuffer(buf)
1602 self.__field_reconditioned.writetobuffer(buf)
1603 self.__field_pad.writetobuffer(buf)
1604 self._bufferendoffset=buf.getcurrentoffset()
1605 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1606
1607
1608 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1609 'Reads this packet from the supplied buffer'
1610 self._bufferstartoffset=buf.getcurrentoffset()
1611 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1612 self.__field_command1=UINT(**{'sizeinbytes': 1, 'constant': 0x26})
1613 self.__field_command1.readfrombuffer(buf)
1614 self.__field_command2=UINT(**{'sizeinbytes': 2, 'constant': 0x0c1b})
1615 self.__field_command2.readfrombuffer(buf)
1616 self.__field_reconditioned=UINT(**{'sizeinbytes': 1})
1617 self.__field_reconditioned.readfrombuffer(buf)
1618 self.__field_pad=UNKNOWN()
1619 self.__field_pad.readfrombuffer(buf)
1620 self._bufferendoffset=buf.getcurrentoffset()
1621
1622
1623 def __getfield_command1(self):
1624 return self.__field_command1.getvalue()
1625
1626 def __setfield_command1(self, value):
1627 if isinstance(value,UINT):
1628 self.__field_command1=value
1629 else:
1630 self.__field_command1=UINT(value,**{'sizeinbytes': 1, 'constant': 0x26})
1631
1632 def __delfield_command1(self): del self.__field_command1
1633
1634 command1=property(__getfield_command1, __setfield_command1, __delfield_command1, None)
1635
1636 def __getfield_command2(self):
1637 return self.__field_command2.getvalue()
1638
1639 def __setfield_command2(self, value):
1640 if isinstance(value,UINT):
1641 self.__field_command2=value
1642 else:
1643 self.__field_command2=UINT(value,**{'sizeinbytes': 2, 'constant': 0x0c1b})
1644
1645 def __delfield_command2(self): del self.__field_command2
1646
1647 command2=property(__getfield_command2, __setfield_command2, __delfield_command2, None)
1648
1649 def __getfield_reconditioned(self):
1650 return self.__field_reconditioned.getvalue()
1651
1652 def __setfield_reconditioned(self, value):
1653 if isinstance(value,UINT):
1654 self.__field_reconditioned=value
1655 else:
1656 self.__field_reconditioned=UINT(value,**{'sizeinbytes': 1})
1657
1658 def __delfield_reconditioned(self): del self.__field_reconditioned
1659
1660 reconditioned=property(__getfield_reconditioned, __setfield_reconditioned, __delfield_reconditioned, None)
1661
1662 def __getfield_pad(self):
1663 return self.__field_pad.getvalue()
1664
1665 def __setfield_pad(self, value):
1666 if isinstance(value,UNKNOWN):
1667 self.__field_pad=value
1668 else:
1669 self.__field_pad=UNKNOWN(value,)
1670
1671 def __delfield_pad(self): del self.__field_pad
1672
1673 pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None)
1674
1675 def iscontainer(self):
1676 return True
1677
1678 def containerelements(self):
1679 yield ('command1', self.__field_command1, None)
1680 yield ('command2', self.__field_command2, None)
1681 yield ('reconditioned', self.__field_reconditioned, None)
1682 yield ('pad', self.__field_pad, None)
1683
1684
1685
1686
1687 class phonenumberrequest(BaseProtogenClass):
1688 __fields=['command1', 'command2', 'zero', 'pad']
1689
1690 def __init__(self, *args, **kwargs):
1691 dict={}
1692 dict.update(kwargs)
1694 super(phonenumberrequest,self).__init__(**dict)
1696 if self.__class__ is phonenumberrequest:
1697 self._update(args,dict)
1698
1699
1700 def getfields(self):
1701 return self.__fields
1702
1703
1704 def _update(self, args, kwargs):
1705 super(phonenumberrequest,self)._update(args,kwargs)
1706 keys=kwargs.keys()
1707 for key in keys:
1708 if key in self.__fields:
1709 setattr(self, key, kwargs[key])
1710 del kwargs[key]
1711 if __debug__:
1713 self._complainaboutunusedargs(phonenumberrequest,kwargs)
1714 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1715
1717
1718 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1719 'Writes this packet to the supplied buffer'
1720 self._bufferstartoffset=buf.getcurrentoffset()
1721 try: self.__field_command1
1722 except:
1723 self.__field_command1=UINT(**{'sizeinbytes': 1, 'constant': 0x26})
1724 self.__field_command1.writetobuffer(buf)
1725 try: self.__field_command2
1726 except:
1727 self.__field_command2=UINT(**{'sizeinbytes': 1, 'constant': 0xb2})
1728 self.__field_command2.writetobuffer(buf)
1729 try: self.__field_zero
1730 except:
1731 self.__field_zero=UINT(**{'sizeinbytes': 1, 'constant': 0})
1732 self.__field_zero.writetobuffer(buf)
1733 try: self.__field_pad
1734 except:
1735 self.__field_pad=UNKNOWN(**{'sizeinbytes': 130})
1736 self.__field_pad.writetobuffer(buf)
1737 self._bufferendoffset=buf.getcurrentoffset()
1738 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1739
1740
1741 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1742 'Reads this packet from the supplied buffer'
1743 self._bufferstartoffset=buf.getcurrentoffset()
1744 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1745 self.__field_command1=UINT(**{'sizeinbytes': 1, 'constant': 0x26})
1746 self.__field_command1.readfrombuffer(buf)
1747 self.__field_command2=UINT(**{'sizeinbytes': 1, 'constant': 0xb2})
1748 self.__field_command2.readfrombuffer(buf)
1749 self.__field_zero=UINT(**{'sizeinbytes': 1, 'constant': 0})
1750 self.__field_zero.readfrombuffer(buf)
1751 self.__field_pad=UNKNOWN(**{'sizeinbytes': 130})
1752 self.__field_pad.readfrombuffer(buf)
1753 self._bufferendoffset=buf.getcurrentoffset()
1754
1755
1756 def __getfield_command1(self):
1757 try: self.__field_command1
1758 except:
1759 self.__field_command1=UINT(**{'sizeinbytes': 1, 'constant': 0x26})
1760 return self.__field_command1.getvalue()
1761
1762 def __setfield_command1(self, value):
1763 if isinstance(value,UINT):
1764 self.__field_command1=value
1765 else:
1766 self.__field_command1=UINT(value,**{'sizeinbytes': 1, 'constant': 0x26})
1767
1768 def __delfield_command1(self): del self.__field_command1
1769
1770 command1=property(__getfield_command1, __setfield_command1, __delfield_command1, None)
1771
1772 def __getfield_command2(self):
1773 try: self.__field_command2
1774 except:
1775 self.__field_command2=UINT(**{'sizeinbytes': 1, 'constant': 0xb2})
1776 return self.__field_command2.getvalue()
1777
1778 def __setfield_command2(self, value):
1779 if isinstance(value,UINT):
1780 self.__field_command2=value
1781 else:
1782 self.__field_command2=UINT(value,**{'sizeinbytes': 1, 'constant': 0xb2})
1783
1784 def __delfield_command2(self): del self.__field_command2
1785
1786 command2=property(__getfield_command2, __setfield_command2, __delfield_command2, None)
1787
1788 def __getfield_zero(self):
1789 try: self.__field_zero
1790 except:
1791 self.__field_zero=UINT(**{'sizeinbytes': 1, 'constant': 0})
1792 return self.__field_zero.getvalue()
1793
1794 def __setfield_zero(self, value):
1795 if isinstance(value,UINT):
1796 self.__field_zero=value
1797 else:
1798 self.__field_zero=UINT(value,**{'sizeinbytes': 1, 'constant': 0})
1799
1800 def __delfield_zero(self): del self.__field_zero
1801
1802 zero=property(__getfield_zero, __setfield_zero, __delfield_zero, None)
1803
1804 def __getfield_pad(self):
1805 try: self.__field_pad
1806 except:
1807 self.__field_pad=UNKNOWN(**{'sizeinbytes': 130})
1808 return self.__field_pad.getvalue()
1809
1810 def __setfield_pad(self, value):
1811 if isinstance(value,UNKNOWN):
1812 self.__field_pad=value
1813 else:
1814 self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 130})
1815
1816 def __delfield_pad(self): del self.__field_pad
1817
1818 pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None)
1819
1820 def iscontainer(self):
1821 return True
1822
1823 def containerelements(self):
1824 yield ('command1', self.__field_command1, None)
1825 yield ('command2', self.__field_command2, None)
1826 yield ('zero', self.__field_zero, None)
1827 yield ('pad', self.__field_pad, None)
1828
1829
1830
1831
1832 class phonenumberresponse(BaseProtogenClass):
1833 __fields=['command1', 'command2', 'pad1', 'myphonenumber', 'pad2']
1834
1835 def __init__(self, *args, **kwargs):
1836 dict={}
1837 dict.update(kwargs)
1839 super(phonenumberresponse,self).__init__(**dict)
1841 if self.__class__ is phonenumberresponse:
1842 self._update(args,dict)
1843
1844
1845 def getfields(self):
1846 return self.__fields
1847
1848
1849 def _update(self, args, kwargs):
1850 super(phonenumberresponse,self)._update(args,kwargs)
1851 keys=kwargs.keys()
1852 for key in keys:
1853 if key in self.__fields:
1854 setattr(self, key, kwargs[key])
1855 del kwargs[key]
1856 if __debug__:
1858 self._complainaboutunusedargs(phonenumberresponse,kwargs)
1859 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1860
1862
1863 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1864 'Writes this packet to the supplied buffer'
1865 self._bufferstartoffset=buf.getcurrentoffset()
1866 self.__field_command1.writetobuffer(buf)
1867 self.__field_command2.writetobuffer(buf)
1868 self.__field_pad1.writetobuffer(buf)
1869 self.__field_myphonenumber.writetobuffer(buf)
1870 self.__field_pad2.writetobuffer(buf)
1871 self._bufferendoffset=buf.getcurrentoffset()
1872 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1873
1874
1875 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1876 'Reads this packet from the supplied buffer'
1877 self._bufferstartoffset=buf.getcurrentoffset()
1878 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1879 self.__field_command1=UINT(**{'sizeinbytes': 1, 'constant': 0x26})
1880 self.__field_command1.readfrombuffer(buf)
1881 self.__field_command2=UINT(**{'sizeinbytes': 1, 'constant': 0xb2})
1882 self.__field_command2.readfrombuffer(buf)
1883 self.__field_pad1=UNKNOWN(**{'sizeinbytes': 2})
1884 self.__field_pad1.readfrombuffer(buf)
1885 self.__field_myphonenumber=USTRING(**{'sizeinbytes': 10, 'raiseonunterminatedread': False})
1886 self.__field_myphonenumber.readfrombuffer(buf)
1887 self.__field_pad2=UNKNOWN(**{'sizeinbytes': 119})
1888 self.__field_pad2.readfrombuffer(buf)
1889 self._bufferendoffset=buf.getcurrentoffset()
1890
1891
1892 def __getfield_command1(self):
1893 return self.__field_command1.getvalue()
1894
1895 def __setfield_command1(self, value):
1896 if isinstance(value,UINT):
1897 self.__field_command1=value
1898 else:
1899 self.__field_command1=UINT(value,**{'sizeinbytes': 1, 'constant': 0x26})
1900
1901 def __delfield_command1(self): del self.__field_command1
1902
1903 command1=property(__getfield_command1, __setfield_command1, __delfield_command1, None)
1904
1905 def __getfield_command2(self):
1906 return self.__field_command2.getvalue()
1907
1908 def __setfield_command2(self, value):
1909 if isinstance(value,UINT):
1910 self.__field_command2=value
1911 else:
1912 self.__field_command2=UINT(value,**{'sizeinbytes': 1, 'constant': 0xb2})
1913
1914 def __delfield_command2(self): del self.__field_command2
1915
1916 command2=property(__getfield_command2, __setfield_command2, __delfield_command2, None)
1917
1918 def __getfield_pad1(self):
1919 return self.__field_pad1.getvalue()
1920
1921 def __setfield_pad1(self, value):
1922 if isinstance(value,UNKNOWN):
1923 self.__field_pad1=value
1924 else:
1925 self.__field_pad1=UNKNOWN(value,**{'sizeinbytes': 2})
1926
1927 def __delfield_pad1(self): del self.__field_pad1
1928
1929 pad1=property(__getfield_pad1, __setfield_pad1, __delfield_pad1, None)
1930
1931 def __getfield_myphonenumber(self):
1932 return self.__field_myphonenumber.getvalue()
1933
1934 def __setfield_myphonenumber(self, value):
1935 if isinstance(value,USTRING):
1936 self.__field_myphonenumber=value
1937 else:
1938 self.__field_myphonenumber=USTRING(value,**{'sizeinbytes': 10, 'raiseonunterminatedread': False})
1939
1940 def __delfield_myphonenumber(self): del self.__field_myphonenumber
1941
1942 myphonenumber=property(__getfield_myphonenumber, __setfield_myphonenumber, __delfield_myphonenumber, None)
1943
1944 def __getfield_pad2(self):
1945 return self.__field_pad2.getvalue()
1946
1947 def __setfield_pad2(self, value):
1948 if isinstance(value,UNKNOWN):
1949 self.__field_pad2=value
1950 else:
1951 self.__field_pad2=UNKNOWN(value,**{'sizeinbytes': 119})
1952
1953 def __delfield_pad2(self): del self.__field_pad2
1954
1955 pad2=property(__getfield_pad2, __setfield_pad2, __delfield_pad2, None)
1956
1957 def iscontainer(self):
1958 return True
1959
1960 def containerelements(self):
1961 yield ('command1', self.__field_command1, None)
1962 yield ('command2', self.__field_command2, None)
1963 yield ('pad1', self.__field_pad1, None)
1964 yield ('myphonenumber', self.__field_myphonenumber, None)
1965 yield ('pad2', self.__field_pad2, None)
1966
1967
1968
1969
1970 class sanyoheader(BaseProtogenClass):
1971 __fields=['readwrite', 'command', 'packettype']
1972
1973 def __init__(self, *args, **kwargs):
1974 dict={}
1975 dict.update({'readwrite': 0x0d})
1977 dict.update(kwargs)
1979 super(sanyoheader,self).__init__(**dict)
1981 if self.__class__ is sanyoheader:
1982 self._update(args,dict)
1983
1984
1985 def getfields(self):
1986 return self.__fields
1987
1988
1989 def _update(self, args, kwargs):
1990 super(sanyoheader,self)._update(args,kwargs)
1991 keys=kwargs.keys()
1992 for key in keys:
1993 if key in self.__fields:
1994 setattr(self, key, kwargs[key])
1995 del kwargs[key]
1996 if __debug__:
1998 self._complainaboutunusedargs(sanyoheader,kwargs)
1999 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2000
2002
2003 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2004 'Writes this packet to the supplied buffer'
2005 self._bufferstartoffset=buf.getcurrentoffset()
2006 self.__field_readwrite.writetobuffer(buf)
2007 self.__field_command.writetobuffer(buf)
2008 self.__field_packettype.writetobuffer(buf)
2009 self._bufferendoffset=buf.getcurrentoffset()
2010 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2011
2012
2013 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2014 'Reads this packet from the supplied buffer'
2015 self._bufferstartoffset=buf.getcurrentoffset()
2016 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2017 self.__field_readwrite=UINT(**{'sizeinbytes': 1})
2018 self.__field_readwrite.readfrombuffer(buf)
2019 self.__field_command=UINT(**{'sizeinbytes': 1})
2020 self.__field_command.readfrombuffer(buf)
2021 self.__field_packettype=UINT(**{'sizeinbytes': 1})
2022 self.__field_packettype.readfrombuffer(buf)
2023 self._bufferendoffset=buf.getcurrentoffset()
2024
2025
2026 def __getfield_readwrite(self):
2027 return self.__field_readwrite.getvalue()
2028
2029 def __setfield_readwrite(self, value):
2030 if isinstance(value,UINT):
2031 self.__field_readwrite=value
2032 else:
2033 self.__field_readwrite=UINT(value,**{'sizeinbytes': 1})
2034
2035 def __delfield_readwrite(self): del self.__field_readwrite
2036
2037 readwrite=property(__getfield_readwrite, __setfield_readwrite, __delfield_readwrite, None)
2038
2039 def __getfield_command(self):
2040 return self.__field_command.getvalue()
2041
2042 def __setfield_command(self, value):
2043 if isinstance(value,UINT):
2044 self.__field_command=value
2045 else:
2046 self.__field_command=UINT(value,**{'sizeinbytes': 1})
2047
2048 def __delfield_command(self): del self.__field_command
2049
2050 command=property(__getfield_command, __setfield_command, __delfield_command, None)
2051
2052 def __getfield_packettype(self):
2053 return self.__field_packettype.getvalue()
2054
2055 def __setfield_packettype(self, value):
2056 if isinstance(value,UINT):
2057 self.__field_packettype=value
2058 else:
2059 self.__field_packettype=UINT(value,**{'sizeinbytes': 1})
2060
2061 def __delfield_packettype(self): del self.__field_packettype
2062
2063 packettype=property(__getfield_packettype, __setfield_packettype, __delfield_packettype, None)
2064
2065 def iscontainer(self):
2066 return True
2067
2068 def containerelements(self):
2069 yield ('readwrite', self.__field_readwrite, None)
2070 yield ('command', self.__field_command, None)
2071 yield ('packettype', self.__field_packettype, None)
2072
2073
2074
2075
2076 class esnrequest(BaseProtogenClass):
2077 __fields=['command']
2078
2079 def __init__(self, *args, **kwargs):
2080 dict={}
2081 dict.update(kwargs)
2083 super(esnrequest,self).__init__(**dict)
2085 if self.__class__ is esnrequest:
2086 self._update(args,dict)
2087
2088
2089 def getfields(self):
2090 return self.__fields
2091
2092
2093 def _update(self, args, kwargs):
2094 super(esnrequest,self)._update(args,kwargs)
2095 keys=kwargs.keys()
2096 for key in keys:
2097 if key in self.__fields:
2098 setattr(self, key, kwargs[key])
2099 del kwargs[key]
2100 if __debug__:
2102 self._complainaboutunusedargs(esnrequest,kwargs)
2103 if len(args):
2104 dict2={'sizeinbytes': 1, 'constant': 0x01}
2105 dict2.update(kwargs)
2106 kwargs=dict2
2107 self.__field_command=UINT(*args,**dict2)
2108
2110
2111 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2112 'Writes this packet to the supplied buffer'
2113 self._bufferstartoffset=buf.getcurrentoffset()
2114 try: self.__field_command
2115 except:
2116 self.__field_command=UINT(**{'sizeinbytes': 1, 'constant': 0x01})
2117 self.__field_command.writetobuffer(buf)
2118 self._bufferendoffset=buf.getcurrentoffset()
2119 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2120
2121
2122 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2123 'Reads this packet from the supplied buffer'
2124 self._bufferstartoffset=buf.getcurrentoffset()
2125 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2126 self.__field_command=UINT(**{'sizeinbytes': 1, 'constant': 0x01})
2127 self.__field_command.readfrombuffer(buf)
2128 self._bufferendoffset=buf.getcurrentoffset()
2129
2130
2131 def __getfield_command(self):
2132 try: self.__field_command
2133 except:
2134 self.__field_command=UINT(**{'sizeinbytes': 1, 'constant': 0x01})
2135 return self.__field_command.getvalue()
2136
2137 def __setfield_command(self, value):
2138 if isinstance(value,UINT):
2139 self.__field_command=value
2140 else:
2141 self.__field_command=UINT(value,**{'sizeinbytes': 1, 'constant': 0x01})
2142
2143 def __delfield_command(self): del self.__field_command
2144
2145 command=property(__getfield_command, __setfield_command, __delfield_command, None)
2146
2147 def iscontainer(self):
2148 return True
2149
2150 def containerelements(self):
2151 yield ('command', self.__field_command, None)
2152
2153
2154
2155
2156 class esnresponse(BaseProtogenClass):
2157 __fields=['command', 'esn']
2158
2159 def __init__(self, *args, **kwargs):
2160 dict={}
2161 dict.update(kwargs)
2163 super(esnresponse,self).__init__(**dict)
2165 if self.__class__ is esnresponse:
2166 self._update(args,dict)
2167
2168
2169 def getfields(self):
2170 return self.__fields
2171
2172
2173 def _update(self, args, kwargs):
2174 super(esnresponse,self)._update(args,kwargs)
2175 keys=kwargs.keys()
2176 for key in keys:
2177 if key in self.__fields:
2178 setattr(self, key, kwargs[key])
2179 del kwargs[key]
2180 if __debug__:
2182 self._complainaboutunusedargs(esnresponse,kwargs)
2183 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2184
2186
2187 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2188 'Writes this packet to the supplied buffer'
2189 self._bufferstartoffset=buf.getcurrentoffset()
2190 self.__field_command.writetobuffer(buf)
2191 self.__field_esn.writetobuffer(buf)
2192 self._bufferendoffset=buf.getcurrentoffset()
2193 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2194
2195
2196 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2197 'Reads this packet from the supplied buffer'
2198 self._bufferstartoffset=buf.getcurrentoffset()
2199 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2200 self.__field_command=UINT(**{'sizeinbytes': 1, 'constant': 0x01})
2201 self.__field_command.readfrombuffer(buf)
2202 self.__field_esn=UINT(**{'sizeinbytes': 4})
2203 self.__field_esn.readfrombuffer(buf)
2204 self._bufferendoffset=buf.getcurrentoffset()
2205
2206
2207 def __getfield_command(self):
2208 return self.__field_command.getvalue()
2209
2210 def __setfield_command(self, value):
2211 if isinstance(value,UINT):
2212 self.__field_command=value
2213 else:
2214 self.__field_command=UINT(value,**{'sizeinbytes': 1, 'constant': 0x01})
2215
2216 def __delfield_command(self): del self.__field_command
2217
2218 command=property(__getfield_command, __setfield_command, __delfield_command, None)
2219
2220 def __getfield_esn(self):
2221 return self.__field_esn.getvalue()
2222
2223 def __setfield_esn(self, value):
2224 if isinstance(value,UINT):
2225 self.__field_esn=value
2226 else:
2227 self.__field_esn=UINT(value,**{'sizeinbytes': 4})
2228
2229 def __delfield_esn(self): del self.__field_esn
2230
2231 esn=property(__getfield_esn, __setfield_esn, __delfield_esn, None)
2232
2233 def iscontainer(self):
2234 return True
2235
2236 def containerelements(self):
2237 yield ('command', self.__field_command, None)
2238 yield ('esn', self.__field_esn, None)
2239
2240
2241
2242
2243 class ownerinforequest(BaseProtogenClass):
2244 __fields=['header', 'pad']
2245
2246 def __init__(self, *args, **kwargs):
2247 dict={}
2248 dict.update(kwargs)
2250 super(ownerinforequest,self).__init__(**dict)
2252 if self.__class__ is ownerinforequest:
2253 self._update(args,dict)
2254
2255
2256 def getfields(self):
2257 return self.__fields
2258
2259
2260 def _update(self, args, kwargs):
2261 super(ownerinforequest,self)._update(args,kwargs)
2262 keys=kwargs.keys()
2263 for key in keys:
2264 if key in self.__fields:
2265 setattr(self, key, kwargs[key])
2266 del kwargs[key]
2267 if __debug__:
2269 self._complainaboutunusedargs(ownerinforequest,kwargs)
2270 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2271
2273
2274 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2275 'Writes this packet to the supplied buffer'
2276 self._bufferstartoffset=buf.getcurrentoffset()
2277 try: self.__field_header
2278 except:
2279 self.__field_header=sanyoheader(**{'packettype': 0x0c, 'command': 0x3b})
2280 self.__field_header.writetobuffer(buf)
2281 try: self.__field_pad
2282 except:
2283 self.__field_pad=UNKNOWN(**{'sizeinbytes': 502})
2284 self.__field_pad.writetobuffer(buf)
2285 self._bufferendoffset=buf.getcurrentoffset()
2286 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2287
2288
2289 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2290 'Reads this packet from the supplied buffer'
2291 self._bufferstartoffset=buf.getcurrentoffset()
2292 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2293 self.__field_header=sanyoheader(**{'packettype': 0x0c, 'command': 0x3b})
2294 self.__field_header.readfrombuffer(buf)
2295 self.__field_pad=UNKNOWN(**{'sizeinbytes': 502})
2296 self.__field_pad.readfrombuffer(buf)
2297 self._bufferendoffset=buf.getcurrentoffset()
2298
2299
2300 def __getfield_header(self):
2301 try: self.__field_header
2302 except:
2303 self.__field_header=sanyoheader(**{'packettype': 0x0c, 'command': 0x3b})
2304 return self.__field_header.getvalue()
2305
2306 def __setfield_header(self, value):
2307 if isinstance(value,sanyoheader):
2308 self.__field_header=value
2309 else:
2310 self.__field_header=sanyoheader(value,**{'packettype': 0x0c, 'command': 0x3b})
2311
2312 def __delfield_header(self): del self.__field_header
2313
2314 header=property(__getfield_header, __setfield_header, __delfield_header, None)
2315
2316 def __getfield_pad(self):
2317 try: self.__field_pad
2318 except:
2319 self.__field_pad=UNKNOWN(**{'sizeinbytes': 502})
2320 return self.__field_pad.getvalue()
2321
2322 def __setfield_pad(self, value):
2323 if isinstance(value,UNKNOWN):
2324 self.__field_pad=value
2325 else:
2326 self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 502})
2327
2328 def __delfield_pad(self): del self.__field_pad
2329
2330 pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None)
2331
2332 def iscontainer(self):
2333 return True
2334
2335 def containerelements(self):
2336 yield ('header', self.__field_header, None)
2337 yield ('pad', self.__field_pad, None)
2338
2339
2340
2341
2342 class ownerentry(BaseProtogenClass):
2343 __fields=['ownername', 'birthyear', 'birthmonth', 'birthday', 'bloodtype', 'address', 'pad', 'homeemail', 'workemail', 'homephone', 'workphone']
2344
2345 def __init__(self, *args, **kwargs):
2346 dict={}
2347 dict.update(kwargs)
2349 super(ownerentry,self).__init__(**dict)
2351 if self.__class__ is ownerentry:
2352 self._update(args,dict)
2353
2354
2355 def getfields(self):
2356 return self.__fields
2357
2358
2359 def _update(self, args, kwargs):
2360 super(ownerentry,self)._update(args,kwargs)
2361 keys=kwargs.keys()
2362 for key in keys:
2363 if key in self.__fields:
2364 setattr(self, key, kwargs[key])
2365 del kwargs[key]
2366 if __debug__:
2368 self._complainaboutunusedargs(ownerentry,kwargs)
2369 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2370
2372
2373 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2374 'Writes this packet to the supplied buffer'
2375 self._bufferstartoffset=buf.getcurrentoffset()
2376 self.__field_ownername.writetobuffer(buf)
2377 self.__field_birthyear.writetobuffer(buf)
2378 self.__field_birthmonth.writetobuffer(buf)
2379 self.__field_birthday.writetobuffer(buf)
2380 self.__field_bloodtype.writetobuffer(buf)
2381 self.__field_address.writetobuffer(buf)
2382 try: self.__field_pad
2383 except:
2384 self.__field_pad=UNKNOWN(**{'sizeinbytes': 14})
2385 self.__field_pad.writetobuffer(buf)
2386 self.__field_homeemail.writetobuffer(buf)
2387 self.__field_workemail.writetobuffer(buf)
2388 self.__field_homephone.writetobuffer(buf)
2389 self.__field_workphone.writetobuffer(buf)
2390 self._bufferendoffset=buf.getcurrentoffset()
2391 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2392
2393
2394 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2395 'Reads this packet from the supplied buffer'
2396 self._bufferstartoffset=buf.getcurrentoffset()
2397 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2398 self.__field_ownername=USTRING(**{'sizeinbytes': 16, 'raiseonunterminatedread': False})
2399 self.__field_ownername.readfrombuffer(buf)
2400 self.__field_birthyear=UINT(**{'sizeinbytes': 2})
2401 self.__field_birthyear.readfrombuffer(buf)
2402 self.__field_birthmonth=UINT(**{'sizeinbytes': 1})
2403 self.__field_birthmonth.readfrombuffer(buf)
2404 self.__field_birthday=UINT(**{'sizeinbytes': 1})
2405 self.__field_birthday.readfrombuffer(buf)
2406 self.__field_bloodtype=UINT(**{'sizeinbytes': 1})
2407 self.__field_bloodtype.readfrombuffer(buf)
2408 self.__field_address=USTRING(**{'sizeinbytes': 96, 'raiseonunterminatedread': False})
2409 self.__field_address.readfrombuffer(buf)
2410 self.__field_pad=UNKNOWN(**{'sizeinbytes': 14})
2411 self.__field_pad.readfrombuffer(buf)
2412 self.__field_homeemail=USTRING(**{'sizeinbytes': 48, 'raiseonunterminatedread': False})
2413 self.__field_homeemail.readfrombuffer(buf)
2414 self.__field_workemail=USTRING(**{'sizeinbytes': 48, 'raiseonunterminatedread': False})
2415 self.__field_workemail.readfrombuffer(buf)
2416 self.__field_homephone=USTRING(**{'sizeinbytes': 48, 'raiseonunterminatedread': False})
2417 self.__field_homephone.readfrombuffer(buf)
2418 self.__field_workphone=USTRING(**{'sizeinbytes': 48, 'raiseonunterminatedread': False})
2419 self.__field_workphone.readfrombuffer(buf)
2420 self._bufferendoffset=buf.getcurrentoffset()
2421
2422
2423 def __getfield_ownername(self):
2424 return self.__field_ownername.getvalue()
2425
2426 def __setfield_ownername(self, value):
2427 if isinstance(value,USTRING):
2428 self.__field_ownername=value
2429 else:
2430 self.__field_ownername=USTRING(value,**{'sizeinbytes': 16, 'raiseonunterminatedread': False})
2431
2432 def __delfield_ownername(self): del self.__field_ownername
2433
2434 ownername=property(__getfield_ownername, __setfield_ownername, __delfield_ownername, None)
2435
2436 def __getfield_birthyear(self):
2437 return self.__field_birthyear.getvalue()
2438
2439 def __setfield_birthyear(self, value):
2440 if isinstance(value,UINT):
2441 self.__field_birthyear=value
2442 else:
2443 self.__field_birthyear=UINT(value,**{'sizeinbytes': 2})
2444
2445 def __delfield_birthyear(self): del self.__field_birthyear
2446
2447 birthyear=property(__getfield_birthyear, __setfield_birthyear, __delfield_birthyear, None)
2448
2449 def __getfield_birthmonth(self):
2450 return self.__field_birthmonth.getvalue()
2451
2452 def __setfield_birthmonth(self, value):
2453 if isinstance(value,UINT):
2454 self.__field_birthmonth=value
2455 else:
2456 self.__field_birthmonth=UINT(value,**{'sizeinbytes': 1})
2457
2458 def __delfield_birthmonth(self): del self.__field_birthmonth
2459
2460 birthmonth=property(__getfield_birthmonth, __setfield_birthmonth, __delfield_birthmonth, None)
2461
2462 def __getfield_birthday(self):
2463 return self.__field_birthday.getvalue()
2464
2465 def __setfield_birthday(self, value):
2466 if isinstance(value,UINT):
2467 self.__field_birthday=value
2468 else:
2469 self.__field_birthday=UINT(value,**{'sizeinbytes': 1})
2470
2471 def __delfield_birthday(self): del self.__field_birthday
2472
2473 birthday=property(__getfield_birthday, __setfield_birthday, __delfield_birthday, None)
2474
2475 def __getfield_bloodtype(self):
2476 return self.__field_bloodtype.getvalue()
2477
2478 def __setfield_bloodtype(self, value):
2479 if isinstance(value,UINT):
2480 self.__field_bloodtype=value
2481 else:
2482 self.__field_bloodtype=UINT(value,**{'sizeinbytes': 1})
2483
2484 def __delfield_bloodtype(self): del self.__field_bloodtype
2485
2486 bloodtype=property(__getfield_bloodtype, __setfield_bloodtype, __delfield_bloodtype, "0: ?, 1: A, 2: B, 3: O, 4: AB")
2487
2488 def __getfield_address(self):
2489 return self.__field_address.getvalue()
2490
2491 def __setfield_address(self, value):
2492 if isinstance(value,USTRING):
2493 self.__field_address=value
2494 else:
2495 self.__field_address=USTRING(value,**{'sizeinbytes': 96, 'raiseonunterminatedread': False})
2496
2497 def __delfield_address(self): del self.__field_address
2498
2499 address=property(__getfield_address, __setfield_address, __delfield_address, None)
2500
2501 def __getfield_pad(self):
2502 try: self.__field_pad
2503 except:
2504 self.__field_pad=UNKNOWN(**{'sizeinbytes': 14})
2505 return self.__field_pad.getvalue()
2506
2507 def __setfield_pad(self, value):
2508 if isinstance(value,UNKNOWN):
2509 self.__field_pad=value
2510 else:
2511 self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 14})
2512
2513 def __delfield_pad(self): del self.__field_pad
2514
2515 pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None)
2516
2517 def __getfield_homeemail(self):
2518 return self.__field_homeemail.getvalue()
2519
2520 def __setfield_homeemail(self, value):
2521 if isinstance(value,USTRING):
2522 self.__field_homeemail=value
2523 else:
2524 self.__field_homeemail=USTRING(value,**{'sizeinbytes': 48, 'raiseonunterminatedread': False})
2525
2526 def __delfield_homeemail(self): del self.__field_homeemail
2527
2528 homeemail=property(__getfield_homeemail, __setfield_homeemail, __delfield_homeemail, None)
2529
2530 def __getfield_workemail(self):
2531 return self.__field_workemail.getvalue()
2532
2533 def __setfield_workemail(self, value):
2534 if isinstance(value,USTRING):
2535 self.__field_workemail=value
2536 else:
2537 self.__field_workemail=USTRING(value,**{'sizeinbytes': 48, 'raiseonunterminatedread': False})
2538
2539 def __delfield_workemail(self): del self.__field_workemail
2540
2541 workemail=property(__getfield_workemail, __setfield_workemail, __delfield_workemail, None)
2542
2543 def __getfield_homephone(self):
2544 return self.__field_homephone.getvalue()
2545
2546 def __setfield_homephone(self, value):
2547 if isinstance(value,USTRING):
2548 self.__field_homephone=value
2549 else:
2550 self.__field_homephone=USTRING(value,**{'sizeinbytes': 48, 'raiseonunterminatedread': False})
2551
2552 def __delfield_homephone(self): del self.__field_homephone
2553
2554 homephone=property(__getfield_homephone, __setfield_homephone, __delfield_homephone, None)
2555
2556 def __getfield_workphone(self):
2557 return self.__field_workphone.getvalue()
2558
2559 def __setfield_workphone(self, value):
2560 if isinstance(value,USTRING):
2561 self.__field_workphone=value
2562 else:
2563 self.__field_workphone=USTRING(value,**{'sizeinbytes': 48, 'raiseonunterminatedread': False})
2564
2565 def __delfield_workphone(self): del self.__field_workphone
2566
2567 workphone=property(__getfield_workphone, __setfield_workphone, __delfield_workphone, None)
2568
2569 def iscontainer(self):
2570 return True
2571
2572 def containerelements(self):
2573 yield ('ownername', self.__field_ownername, None)
2574 yield ('birthyear', self.__field_birthyear, None)
2575 yield ('birthmonth', self.__field_birthmonth, None)
2576 yield ('birthday', self.__field_birthday, None)
2577 yield ('bloodtype', self.__field_bloodtype, "0: ?, 1: A, 2: B, 3: O, 4: AB")
2578 yield ('address', self.__field_address, None)
2579 yield ('pad', self.__field_pad, None)
2580 yield ('homeemail', self.__field_homeemail, None)
2581 yield ('workemail', self.__field_workemail, None)
2582 yield ('homephone', self.__field_homephone, None)
2583 yield ('workphone', self.__field_workphone, None)
2584
2585
2586
2587
2588 class ownerinforesponse(BaseProtogenClass):
2589 __fields=['header', 'entry', 'pad']
2590
2591 def __init__(self, *args, **kwargs):
2592 dict={}
2593 dict.update(kwargs)
2595 super(ownerinforesponse,self).__init__(**dict)
2597 if self.__class__ is ownerinforesponse:
2598 self._update(args,dict)
2599
2600
2601 def getfields(self):
2602 return self.__fields
2603
2604
2605 def _update(self, args, kwargs):
2606 super(ownerinforesponse,self)._update(args,kwargs)
2607 keys=kwargs.keys()
2608 for key in keys:
2609 if key in self.__fields:
2610 setattr(self, key, kwargs[key])
2611 del kwargs[key]
2612 if __debug__:
2614 self._complainaboutunusedargs(ownerinforesponse,kwargs)
2615 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2616
2618
2619 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2620 'Writes this packet to the supplied buffer'
2621 self._bufferstartoffset=buf.getcurrentoffset()
2622 self.__field_header.writetobuffer(buf)
2623 self.__field_entry.writetobuffer(buf)
2624 self.__field_pad.writetobuffer(buf)
2625 self._bufferendoffset=buf.getcurrentoffset()
2626 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2627
2628
2629 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2630 'Reads this packet from the supplied buffer'
2631 self._bufferstartoffset=buf.getcurrentoffset()
2632 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2633 self.__field_header=sanyoheader()
2634 self.__field_header.readfrombuffer(buf)
2635 self.__field_entry=ownerentry()
2636 self.__field_entry.readfrombuffer(buf)
2637 self.__field_pad=UNKNOWN(**{'sizeinbytes': 178})
2638 self.__field_pad.readfrombuffer(buf)
2639 self._bufferendoffset=buf.getcurrentoffset()
2640
2641
2642 def __getfield_header(self):
2643 return self.__field_header.getvalue()
2644
2645 def __setfield_header(self, value):
2646 if isinstance(value,sanyoheader):
2647 self.__field_header=value
2648 else:
2649 self.__field_header=sanyoheader(value,)
2650
2651 def __delfield_header(self): del self.__field_header
2652
2653 header=property(__getfield_header, __setfield_header, __delfield_header, None)
2654
2655 def __getfield_entry(self):
2656 return self.__field_entry.getvalue()
2657
2658 def __setfield_entry(self, value):
2659 if isinstance(value,ownerentry):
2660 self.__field_entry=value
2661 else:
2662 self.__field_entry=ownerentry(value,)
2663
2664 def __delfield_entry(self): del self.__field_entry
2665
2666 entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None)
2667
2668 def __getfield_pad(self):
2669 return self.__field_pad.getvalue()
2670
2671 def __setfield_pad(self, value):
2672 if isinstance(value,UNKNOWN):
2673 self.__field_pad=value
2674 else:
2675 self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 178})
2676
2677 def __delfield_pad(self): del self.__field_pad
2678
2679 pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None)
2680
2681 def iscontainer(self):
2682 return True
2683
2684 def containerelements(self):
2685 yield ('header', self.__field_header, None)
2686 yield ('entry', self.__field_entry, None)
2687 yield ('pad', self.__field_pad, None)
2688
2689
2690
2691
2692 class eventrequest(BaseProtogenClass):
2693 __fields=['header', 'slot', 'pad']
2694
2695 def __init__(self, *args, **kwargs):
2696 dict={}
2697 dict.update(kwargs)
2699 super(eventrequest,self).__init__(**dict)
2701 if self.__class__ is eventrequest:
2702 self._update(args,dict)
2703
2704
2705 def getfields(self):
2706 return self.__fields
2707
2708
2709 def _update(self, args, kwargs):
2710 super(eventrequest,self)._update(args,kwargs)
2711 keys=kwargs.keys()
2712 for key in keys:
2713 if key in self.__fields:
2714 setattr(self, key, kwargs[key])
2715 del kwargs[key]
2716 if __debug__:
2718 self._complainaboutunusedargs(eventrequest,kwargs)
2719 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2720
2722
2723 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2724 'Writes this packet to the supplied buffer'
2725 self._bufferstartoffset=buf.getcurrentoffset()
2726 try: self.__field_header
2727 except:
2728 self.__field_header=sanyoheader(**{'packettype': 0x0c, 'command': 0x23})
2729 self.__field_header.writetobuffer(buf)
2730 self.__field_slot.writetobuffer(buf)
2731 try: self.__field_pad
2732 except:
2733 self.__field_pad=UNKNOWN(**{'sizeinbytes': 501})
2734 self.__field_pad.writetobuffer(buf)
2735 self._bufferendoffset=buf.getcurrentoffset()
2736 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2737
2738
2739 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2740 'Reads this packet from the supplied buffer'
2741 self._bufferstartoffset=buf.getcurrentoffset()
2742 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2743 self.__field_header=sanyoheader(**{'packettype': 0x0c, 'command': 0x23})
2744 self.__field_header.readfrombuffer(buf)
2745 self.__field_slot=UINT(**{'sizeinbytes': 1})
2746 self.__field_slot.readfrombuffer(buf)
2747 self.__field_pad=UNKNOWN(**{'sizeinbytes': 501})
2748 self.__field_pad.readfrombuffer(buf)
2749 self._bufferendoffset=buf.getcurrentoffset()
2750
2751
2752 def __getfield_header(self):
2753 try: self.__field_header
2754 except:
2755 self.__field_header=sanyoheader(**{'packettype': 0x0c, 'command': 0x23})
2756 return self.__field_header.getvalue()
2757
2758 def __setfield_header(self, value):
2759 if isinstance(value,sanyoheader):
2760 self.__field_header=value
2761 else:
2762 self.__field_header=sanyoheader(value,**{'packettype': 0x0c, 'command': 0x23})
2763
2764 def __delfield_header(self): del self.__field_header
2765
2766 header=property(__getfield_header, __setfield_header, __delfield_header, None)
2767
2768 def __getfield_slot(self):
2769 return self.__field_slot.getvalue()
2770
2771 def __setfield_slot(self, value):
2772 if isinstance(value,UINT):
2773 self.__field_slot=value
2774 else:
2775 self.__field_slot=UINT(value,**{'sizeinbytes': 1})
2776
2777 def __delfield_slot(self): del self.__field_slot
2778
2779 slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None)
2780
2781 def __getfield_pad(self):
2782 try: self.__field_pad
2783 except:
2784 self.__field_pad=UNKNOWN(**{'sizeinbytes': 501})
2785 return self.__field_pad.getvalue()
2786
2787 def __setfield_pad(self, value):
2788 if isinstance(value,UNKNOWN):
2789 self.__field_pad=value
2790 else:
2791 self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 501})
2792
2793 def __delfield_pad(self): del self.__field_pad
2794
2795 pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None)
2796
2797 def iscontainer(self):
2798 return True
2799
2800 def containerelements(self):
2801 yield ('header', self.__field_header, None)
2802 yield ('slot', self.__field_slot, None)
2803 yield ('pad', self.__field_pad, None)
2804
2805
2806
2807
2808 class evententry(BaseProtogenClass):
2809 __fields=['slot', 'flag', 'eventname', 'pad1', 'eventname_len', 'start', 'end', 'location', 'pad2', 'location_len', 'ringtone', 'alarmdiff', 'period', 'dom', 'alarm', 'serial']
2810
2811 def __init__(self, *args, **kwargs):
2812 dict={}
2813 dict.update(kwargs)
2815 super(evententry,self).__init__(**dict)
2817 if self.__class__ is evententry:
2818 self._update(args,dict)
2819
2820
2821 def getfields(self):
2822 return self.__fields
2823
2824
2825 def _update(self, args, kwargs):
2826 super(evententry,self)._update(args,kwargs)
2827 keys=kwargs.keys()
2828 for key in keys:
2829 if key in self.__fields:
2830 setattr(self, key, kwargs[key])
2831 del kwargs[key]
2832 if __debug__:
2834 self._complainaboutunusedargs(evententry,kwargs)
2835 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2836
2838
2839 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2840 'Writes this packet to the supplied buffer'
2841 self._bufferstartoffset=buf.getcurrentoffset()
2842 self.__field_slot.writetobuffer(buf)
2843 self.__field_flag.writetobuffer(buf)
2844 self.__field_eventname.writetobuffer(buf)
2845 try: self.__field_pad1
2846 except:
2847 self.__field_pad1=UNKNOWN(**{'sizeinbytes': 7})
2848 self.__field_pad1.writetobuffer(buf)
2849 self.__field_eventname_len.writetobuffer(buf)
2850 self.__field_start.writetobuffer(buf)
2851 self.__field_end.writetobuffer(buf)
2852 self.__field_location.writetobuffer(buf)
2853 try: self.__field_pad2
2854 except:
2855 self.__field_pad2=UNKNOWN(**{'sizeinbytes': 7})
2856 self.__field_pad2.writetobuffer(buf)
2857 self.__field_location_len.writetobuffer(buf)
2858 self.__field_ringtone.writetobuffer(buf)
2859 self.__field_alarmdiff.writetobuffer(buf)
2860 self.__field_period.writetobuffer(buf)
2861 self.__field_dom.writetobuffer(buf)
2862 self.__field_alarm.writetobuffer(buf)
2863 try: self.__field_serial
2864 except:
2865 self.__field_serial=UINT(**{'sizeinbytes': 1, 'default': 0})
2866 self.__field_serial.writetobuffer(buf)
2867 self._bufferendoffset=buf.getcurrentoffset()
2868 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2869
2870
2871 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2872 'Reads this packet from the supplied buffer'
2873 self._bufferstartoffset=buf.getcurrentoffset()
2874 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2875 self.__field_slot=UINT(**{'sizeinbytes': 1})
2876 self.__field_slot.readfrombuffer(buf)
2877 self.__field_flag=UINT(**{'sizeinbytes': 1})
2878 self.__field_flag.readfrombuffer(buf)
2879 self.__field_eventname=USTRING(**{'sizeinbytes': 14, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'terminator': None})
2880 self.__field_eventname.readfrombuffer(buf)
2881 self.__field_pad1=UNKNOWN(**{'sizeinbytes': 7})
2882 self.__field_pad1.readfrombuffer(buf)
2883 self.__field_eventname_len=UINT(**{'sizeinbytes': 1})
2884 self.__field_eventname_len.readfrombuffer(buf)
2885 self.__field_start=UINT(**{'sizeinbytes': 4})
2886 self.__field_start.readfrombuffer(buf)
2887 self.__field_end=UINT(**{'sizeinbytes': 4})
2888 self.__field_end.readfrombuffer(buf)
2889 self.__field_location=USTRING(**{'sizeinbytes': 14, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'terminator': None})
2890 self.__field_location.readfrombuffer(buf)
2891 self.__field_pad2=UNKNOWN(**{'sizeinbytes': 7})
2892 self.__field_pad2.readfrombuffer(buf)
2893 self.__field_location_len=UINT(**{'sizeinbytes': 1})
2894 self.__field_location_len.readfrombuffer(buf)
2895 self.__field_ringtone=UINT(**{'sizeinbytes': 1})
2896 self.__field_ringtone.readfrombuffer(buf)
2897 self.__field_alarmdiff=UINT(**{'sizeinbytes': 4})
2898 self.__field_alarmdiff.readfrombuffer(buf)
2899 self.__field_period=UINT(**{'sizeinbytes': 1})
2900 self.__field_period.readfrombuffer(buf)
2901 self.__field_dom=UINT(**{'sizeinbytes': 1})
2902 self.__field_dom.readfrombuffer(buf)
2903 self.__field_alarm=UINT(**{'sizeinbytes': 4})
2904 self.__field_alarm.readfrombuffer(buf)
2905 self.__field_serial=UINT(**{'sizeinbytes': 1, 'default': 0})
2906 self.__field_serial.readfrombuffer(buf)
2907 self._bufferendoffset=buf.getcurrentoffset()
2908
2909
2910 def __getfield_slot(self):
2911 return self.__field_slot.getvalue()
2912
2913 def __setfield_slot(self, value):
2914 if isinstance(value,UINT):
2915 self.__field_slot=value
2916 else:
2917 self.__field_slot=UINT(value,**{'sizeinbytes': 1})
2918
2919 def __delfield_slot(self): del self.__field_slot
2920
2921 slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None)
2922
2923 def __getfield_flag(self):
2924 return self.__field_flag.getvalue()
2925
2926 def __setfield_flag(self, value):
2927 if isinstance(value,UINT):
2928 self.__field_flag=value
2929 else:
2930 self.__field_flag=UINT(value,**{'sizeinbytes': 1})
2931
2932 def __delfield_flag(self): del self.__field_flag
2933
2934 flag=property(__getfield_flag, __setfield_flag, __delfield_flag, "0: Not used, 1: Scheduled, 2: Already Happened")
2935
2936 def __getfield_eventname(self):
2937 return self.__field_eventname.getvalue()
2938
2939 def __setfield_eventname(self, value):
2940 if isinstance(value,USTRING):
2941 self.__field_eventname=value
2942 else:
2943 self.__field_eventname=USTRING(value,**{'sizeinbytes': 14, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'terminator': None})
2944
2945 def __delfield_eventname(self): del self.__field_eventname
2946
2947 eventname=property(__getfield_eventname, __setfield_eventname, __delfield_eventname, None)
2948
2949 def __getfield_pad1(self):
2950 try: self.__field_pad1
2951 except:
2952 self.__field_pad1=UNKNOWN(**{'sizeinbytes': 7})
2953 return self.__field_pad1.getvalue()
2954
2955 def __setfield_pad1(self, value):
2956 if isinstance(value,UNKNOWN):
2957 self.__field_pad1=value
2958 else:
2959 self.__field_pad1=UNKNOWN(value,**{'sizeinbytes': 7})
2960
2961 def __delfield_pad1(self): del self.__field_pad1
2962
2963 pad1=property(__getfield_pad1, __setfield_pad1, __delfield_pad1, None)
2964
2965 def __getfield_eventname_len(self):
2966 return self.__field_eventname_len.getvalue()
2967
2968 def __setfield_eventname_len(self, value):
2969 if isinstance(value,UINT):
2970 self.__field_eventname_len=value
2971 else:
2972 self.__field_eventname_len=UINT(value,**{'sizeinbytes': 1})
2973
2974 def __delfield_eventname_len(self): del self.__field_eventname_len
2975
2976 eventname_len=property(__getfield_eventname_len, __setfield_eventname_len, __delfield_eventname_len, None)
2977
2978 def __getfield_start(self):
2979 return self.__field_start.getvalue()
2980
2981 def __setfield_start(self, value):
2982 if isinstance(value,UINT):
2983 self.__field_start=value
2984 else:
2985 self.__field_start=UINT(value,**{'sizeinbytes': 4})
2986
2987 def __delfield_start(self): del self.__field_start
2988
2989 start=property(__getfield_start, __setfield_start, __delfield_start, "# seconds since Jan 1, 1980 approximately")
2990
2991 def