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