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