0001 # THIS FILE IS AUTOMATICALLY GENERATED. EDIT THE SOURCE FILE NOT THIS ONE 0002 0003 """Various descriptions of data specific to Sanyo SCP-8100""" 0004 0005 from prototypes import * 0006 0007 # Make all sanyo stuff available in this module as well 0008 from p_sanyo import * 0009 from p_sanyomedia import * 0010 from p_sanyonewer import * 0011 0012 # We use LSB for all integer like fields 0013 UINT=UINTlsb 0014 BOOL=BOOLlsb 0015 _NUMPBSLOTS=300 0016 _NUMSPEEDDIALS=8 0017 _NUMLONGNUMBERS=5 0018 _LONGPHONENUMBERLEN=30 0019 _NUMEVENTSLOTS=100 0020 _NUMCALLALARMSLOTS=15 0021 _NUMCALLHISTORY=20 0022 _MAXNUMBERLEN=48 0023 _MAXEMAILLEN=48 0024 0025 class phonenumber(BaseProtogenClass): 0026 __fields=['number_len', 'number'] 0027 0028 def __init__(self, *args, **kwargs): 0029 dict={} 0030 # What was supplied to this function 0031 dict.update(kwargs) 0032 # Parent constructor 0033 super(phonenumber,self).__init__(**dict) 0034 if self.__class__ is phonenumber: 0035 self._update(args,dict) 0036 0037 0038 def getfields(self): 0039 return self.__fields 0040 0041 0042 def _update(self, args, kwargs): 0043 super(phonenumber,self)._update(args,kwargs) 0044 keys=kwargs.keys() 0045 for key in keys: 0046 if key in self.__fields: 0047 setattr(self, key, kwargs[key]) 0048 del kwargs[key] 0049 # Were any unrecognized kwargs passed in? 0050 if __debug__: 0051 self._complainaboutunusedargs(phonenumber,kwargs) 0052 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 0053 # Make all P fields that haven't already been constructed 0054 0055 0056 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 0057 'Writes this packet to the supplied buffer' 0058 self._bufferstartoffset=buf.getcurrentoffset() 0059 try: self.__field_number_len 0060 except: 0061 self.__field_number_len=UINT(**{'sizeinbytes': 1, 'default': 0}) 0062 self.__field_number_len.writetobuffer(buf) 0063 try: self.__field_number 0064 except: 0065 self.__field_number=USTRING(**{'sizeinbytes': 49, 'default': ""}) 0066 self.__field_number.writetobuffer(buf) 0067 self._bufferendoffset=buf.getcurrentoffset() 0068 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 0069 0070 0071 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 0072 'Reads this packet from the supplied buffer' 0073 self._bufferstartoffset=buf.getcurrentoffset() 0074 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 0075 self.__field_number_len=UINT(**{'sizeinbytes': 1, 'default': 0}) 0076 self.__field_number_len.readfrombuffer(buf) 0077 self.__field_number=USTRING(**{'sizeinbytes': 49, 'default': ""}) 0078 self.__field_number.readfrombuffer(buf) 0079 self._bufferendoffset=buf.getcurrentoffset() 0080 0081 0082 def __getfield_number_len(self): 0083 try: self.__field_number_len 0084 except: 0085 self.__field_number_len=UINT(**{'sizeinbytes': 1, 'default': 0}) 0086 return self.__field_number_len.getvalue() 0087 0088 def __setfield_number_len(self, value): 0089 if isinstance(value,UINT): 0090 self.__field_number_len=value 0091 else: 0092 self.__field_number_len=UINT(value,**{'sizeinbytes': 1, 'default': 0}) 0093 0094 def __delfield_number_len(self): del self.__field_number_len 0095 0096 number_len=property(__getfield_number_len, __setfield_number_len, __delfield_number_len, None) 0097 0098 def __getfield_number(self): 0099 try: self.__field_number 0100 except: 0101 self.__field_number=USTRING(**{'sizeinbytes': 49, 'default': ""}) 0102 return self.__field_number.getvalue() 0103 0104 def __setfield_number(self, value): 0105 if isinstance(value,USTRING): 0106 self.__field_number=value 0107 else: 0108 self.__field_number=USTRING(value,**{'sizeinbytes': 49, 'default': ""}) 0109 0110 def __delfield_number(self): del self.__field_number 0111 0112 number=property(__getfield_number, __setfield_number, __delfield_number, None) 0113 0114 def iscontainer(self): 0115 return True 0116 0117 def containerelements(self): 0118 yield ('number_len', self.__field_number_len, None) 0119 yield ('number', self.__field_number, None) 0120 0121 0122 0123 0124 class phonebookentry(BaseProtogenClass): 0125 __fields=['slot', 'slotdup', 'name', 'numbers', 'email_len', 'email', 'url_len', 'url', 'secret', 'name_len'] 0126 0127 def __init__(self, *args, **kwargs): 0128 dict={} 0129 # What was supplied to this function 0130 dict.update(kwargs) 0131 # Parent constructor 0132 super(phonebookentry,self).__init__(**dict) 0133 if self.__class__ is phonebookentry: 0134 self._update(args,dict) 0135 0136 0137 def getfields(self): 0138 return self.__fields 0139 0140 0141 def _update(self, args, kwargs): 0142 super(phonebookentry,self)._update(args,kwargs) 0143 keys=kwargs.keys() 0144 for key in keys: 0145 if key in self.__fields: 0146 setattr(self, key, kwargs[key]) 0147 del kwargs[key] 0148 # Were any unrecognized kwargs passed in? 0149 if __debug__: 0150 self._complainaboutunusedargs(phonebookentry,kwargs) 0151 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 0152 # Make all P fields that haven't already been constructed 0153 0154 0155 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 0156 'Writes this packet to the supplied buffer' 0157 self._bufferstartoffset=buf.getcurrentoffset() 0158 self.__field_slot.writetobuffer(buf) 0159 self.__field_slotdup.writetobuffer(buf) 0160 self.__field_name.writetobuffer(buf) 0161 try: self.__field_numbers 0162 except: 0163 self.__field_numbers=LIST(**{'length': 7, 'createdefault': True, 'elementclass': phonenumber}) 0164 self.__field_numbers.writetobuffer(buf) 0165 try: self.__field_email_len 0166 except: 0167 self.__field_email_len=UINT(**{'sizeinbytes': 1}) 0168 self.__field_email_len.writetobuffer(buf) 0169 try: self.__field_email 0170 except: 0171 self.__field_email=USTRING(**{'sizeinbytes': 49, 'default': ""}) 0172 self.__field_email.writetobuffer(buf) 0173 try: self.__field_url_len 0174 except: 0175 self.__field_url_len=UINT(**{'sizeinbytes': 1}) 0176 self.__field_url_len.writetobuffer(buf) 0177 try: self.__field_url 0178 except: 0179 self.__field_url=USTRING(**{'sizeinbytes': 49, 'default': ""}) 0180 self.__field_url.writetobuffer(buf) 0181 try: self.__field_secret 0182 except: 0183 self.__field_secret=BOOL(**{'sizeinbytes': 1}) 0184 self.__field_secret.writetobuffer(buf) 0185 self.__field_name_len.writetobuffer(buf) 0186 self._bufferendoffset=buf.getcurrentoffset() 0187 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 0188 0189 0190 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 0191 'Reads this packet from the supplied buffer' 0192 self._bufferstartoffset=buf.getcurrentoffset() 0193 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 0194 self.__field_slot=UINT(**{'sizeinbytes': 2}) 0195 self.__field_slot.readfrombuffer(buf) 0196 self.__field_slotdup=UINT(**{'sizeinbytes': 2}) 0197 self.__field_slotdup.readfrombuffer(buf) 0198 self.__field_name=USTRING(**{'sizeinbytes': 16, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'terminator': None}) 0199 self.__field_name.readfrombuffer(buf) 0200 self.__field_numbers=LIST(**{'length': 7, 'createdefault': True, 'elementclass': phonenumber}) 0201 self.__field_numbers.readfrombuffer(buf) 0202 self.__field_email_len=UINT(**{'sizeinbytes': 1}) 0203 self.__field_email_len.readfrombuffer(buf) 0204 self.__field_email=USTRING(**{'sizeinbytes': 49, 'default': ""}) 0205 self.__field_email.readfrombuffer(buf) 0206 self.__field_url_len=UINT(**{'sizeinbytes': 1}) 0207 self.__field_url_len.readfrombuffer(buf) 0208 self.__field_url=USTRING(**{'sizeinbytes': 49, 'default': ""}) 0209 self.__field_url.readfrombuffer(buf) 0210 self.__field_secret=BOOL(**{'sizeinbytes': 1}) 0211 self.__field_secret.readfrombuffer(buf) 0212 self.__field_name_len=UINT(**{'sizeinbytes': 1}) 0213 self.__field_name_len.readfrombuffer(buf) 0214 self._bufferendoffset=buf.getcurrentoffset() 0215 0216 0217 def __getfield_slot(self): 0218 return self.__field_slot.getvalue() 0219 0220 def __setfield_slot(self, value): 0221 if isinstance(value,UINT): 0222 self.__field_slot=value 0223 else: 0224 self.__field_slot=UINT(value,**{'sizeinbytes': 2}) 0225 0226 def __delfield_slot(self): del self.__field_slot 0227 0228 slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None) 0229 0230 def __getfield_slotdup(self): 0231 return self.__field_slotdup.getvalue() 0232 0233 def __setfield_slotdup(self, value): 0234 if isinstance(value,UINT): 0235 self.__field_slotdup=value 0236 else: 0237 self.__field_slotdup=UINT(value,**{'sizeinbytes': 2}) 0238 0239 def __delfield_slotdup(self): del self.__field_slotdup 0240 0241 slotdup=property(__getfield_slotdup, __setfield_slotdup, __delfield_slotdup, None) 0242 0243 def __getfield_name(self): 0244 return self.__field_name.getvalue() 0245 0246 def __setfield_name(self, value): 0247 if isinstance(value,USTRING): 0248 self.__field_name=value 0249 else: 0250 self.__field_name=USTRING(value,**{'sizeinbytes': 16, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'terminator': None}) 0251 0252 def __delfield_name(self): del self.__field_name 0253 0254 name=property(__getfield_name, __setfield_name, __delfield_name, None) 0255 0256 def __getfield_numbers(self): 0257 try: self.__field_numbers 0258 except: 0259 self.__field_numbers=LIST(**{'length': 7, 'createdefault': True, 'elementclass': phonenumber}) 0260 return self.__field_numbers.getvalue() 0261 0262 def __setfield_numbers(self, value): 0263 if isinstance(value,LIST): 0264 self.__field_numbers=value 0265 else: 0266 self.__field_numbers=LIST(value,**{'length': 7, 'createdefault': True, 'elementclass': phonenumber}) 0267 0268 def __delfield_numbers(self): del self.__field_numbers 0269 0270 numbers=property(__getfield_numbers, __setfield_numbers, __delfield_numbers, None) 0271 0272 def __getfield_email_len(self): 0273 try: self.__field_email_len 0274 except: 0275 self.__field_email_len=UINT(**{'sizeinbytes': 1}) 0276 return self.__field_email_len.getvalue() 0277 0278 def __setfield_email_len(self, value): 0279 if isinstance(value,UINT): 0280 self.__field_email_len=value 0281 else: 0282 self.__field_email_len=UINT(value,**{'sizeinbytes': 1}) 0283 0284 def __delfield_email_len(self): del self.__field_email_len 0285 0286 email_len=property(__getfield_email_len, __setfield_email_len, __delfield_email_len, None) 0287 0288 def __getfield_email(self): 0289 try: self.__field_email 0290 except: 0291 self.__field_email=USTRING(**{'sizeinbytes': 49, 'default': ""}) 0292 return self.__field_email.getvalue() 0293 0294 def __setfield_email(self, value): 0295 if isinstance(value,USTRING): 0296 self.__field_email=value 0297 else: 0298 self.__field_email=USTRING(value,**{'sizeinbytes': 49, 'default': ""}) 0299 0300 def __delfield_email(self): del self.__field_email 0301 0302 email=property(__getfield_email, __setfield_email, __delfield_email, None) 0303 0304 def __getfield_url_len(self): 0305 try: self.__field_url_len 0306 except: 0307 self.__field_url_len=UINT(**{'sizeinbytes': 1}) 0308 return self.__field_url_len.getvalue() 0309 0310 def __setfield_url_len(self, value): 0311 if isinstance(value,UINT): 0312 self.__field_url_len=value 0313 else: 0314 self.__field_url_len=UINT(value,**{'sizeinbytes': 1}) 0315 0316 def __delfield_url_len(self): del self.__field_url_len 0317 0318 url_len=property(__getfield_url_len, __setfield_url_len, __delfield_url_len, None) 0319 0320 def __getfield_url(self): 0321 try: self.__field_url 0322 except: 0323 self.__field_url=USTRING(**{'sizeinbytes': 49, 'default': ""}) 0324 return self.__field_url.getvalue() 0325 0326 def __setfield_url(self, value): 0327 if isinstance(value,USTRING): 0328 self.__field_url=value 0329 else: 0330 self.__field_url=USTRING(value,**{'sizeinbytes': 49, 'default': ""}) 0331 0332 def __delfield_url(self): del self.__field_url 0333 0334 url=property(__getfield_url, __setfield_url, __delfield_url, None) 0335 0336 def __getfield_secret(self): 0337 try: self.__field_secret 0338 except: 0339 self.__field_secret=BOOL(**{'sizeinbytes': 1}) 0340 return self.__field_secret.getvalue() 0341 0342 def __setfield_secret(self, value): 0343 if isinstance(value,BOOL): 0344 self.__field_secret=value 0345 else: 0346 self.__field_secret=BOOL(value,**{'sizeinbytes': 1}) 0347 0348 def __delfield_secret(self): del self.__field_secret 0349 0350 secret=property(__getfield_secret, __setfield_secret, __delfield_secret, None) 0351 0352 def __getfield_name_len(self): 0353 return self.__field_name_len.getvalue() 0354 0355 def __setfield_name_len(self, value): 0356 if isinstance(value,UINT): 0357 self.__field_name_len=value 0358 else: 0359 self.__field_name_len=UINT(value,**{'sizeinbytes': 1}) 0360 0361 def __delfield_name_len(self): del self.__field_name_len 0362 0363 name_len=property(__getfield_name_len, __setfield_name_len, __delfield_name_len, None) 0364 0365 def iscontainer(self): 0366 return True 0367 0368 def containerelements(self): 0369 yield ('slot', self.__field_slot, None) 0370 yield ('slotdup', self.__field_slotdup, None) 0371 yield ('name', self.__field_name, None) 0372 yield ('numbers', self.__field_numbers, None) 0373 yield ('email_len', self.__field_email_len, None) 0374 yield ('email', self.__field_email, None) 0375 yield ('url_len', self.__field_url_len, None) 0376 yield ('url', self.__field_url, None) 0377 yield ('secret', self.__field_secret, None) 0378 yield ('name_len', self.__field_name_len, None) 0379 0380 0381 0382 0383 class phonebookslotresponse(BaseProtogenClass): 0384 __fields=['header', 'entry', 'pad'] 0385 0386 def __init__(self, *args, **kwargs): 0387 dict={} 0388 # What was supplied to this function 0389 dict.update(kwargs) 0390 # Parent constructor 0391 super(phonebookslotresponse,self).__init__(**dict) 0392 if self.__class__ is phonebookslotresponse: 0393 self._update(args,dict) 0394 0395 0396 def getfields(self): 0397 return self.__fields 0398 0399 0400 def _update(self, args, kwargs): 0401 super(phonebookslotresponse,self)._update(args,kwargs) 0402 keys=kwargs.keys() 0403 for key in keys: 0404 if key in self.__fields: 0405 setattr(self, key, kwargs[key]) 0406 del kwargs[key] 0407 # Were any unrecognized kwargs passed in? 0408 if __debug__: 0409 self._complainaboutunusedargs(phonebookslotresponse,kwargs) 0410 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 0411 # Make all P fields that haven't already been constructed 0412 0413 0414 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 0415 'Writes this packet to the supplied buffer' 0416 self._bufferstartoffset=buf.getcurrentoffset() 0417 self.__field_header.writetobuffer(buf) 0418 self.__field_entry.writetobuffer(buf) 0419 self.__field_pad.writetobuffer(buf) 0420 self._bufferendoffset=buf.getcurrentoffset() 0421 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 0422 0423 0424 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 0425 'Reads this packet from the supplied buffer' 0426 self._bufferstartoffset=buf.getcurrentoffset() 0427 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 0428 self.__field_header=sanyoheader() 0429 self.__field_header.readfrombuffer(buf) 0430 self.__field_entry=phonebookentry() 0431 self.__field_entry.readfrombuffer(buf) 0432 self.__field_pad=UNKNOWN() 0433 self.__field_pad.readfrombuffer(buf) 0434 self._bufferendoffset=buf.getcurrentoffset() 0435 0436 0437 def __getfield_header(self): 0438 return self.__field_header.getvalue() 0439 0440 def __setfield_header(self, value): 0441 if isinstance(value,sanyoheader): 0442 self.__field_header=value 0443 else: 0444 self.__field_header=sanyoheader(value,) 0445 0446 def __delfield_header(self): del self.__field_header 0447 0448 header=property(__getfield_header, __setfield_header, __delfield_header, None) 0449 0450 def __getfield_entry(self): 0451 return self.__field_entry.getvalue() 0452 0453 def __setfield_entry(self, value): 0454 if isinstance(value,phonebookentry): 0455 self.__field_entry=value 0456 else: 0457 self.__field_entry=phonebookentry(value,) 0458 0459 def __delfield_entry(self): del self.__field_entry 0460 0461 entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None) 0462 0463 def __getfield_pad(self): 0464 return self.__field_pad.getvalue() 0465 0466 def __setfield_pad(self, value): 0467 if isinstance(value,UNKNOWN): 0468 self.__field_pad=value 0469 else: 0470 self.__field_pad=UNKNOWN(value,) 0471 0472 def __delfield_pad(self): del self.__field_pad 0473 0474 pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None) 0475 0476 def iscontainer(self): 0477 return True 0478 0479 def containerelements(self): 0480 yield ('header', self.__field_header, None) 0481 yield ('entry', self.__field_entry, None) 0482 yield ('pad', self.__field_pad, None) 0483 0484 0485 0486 0487 class phonebookslotupdaterequest(BaseProtogenClass): 0488 __fields=['header', 'entry', 'pad'] 0489 0490 def __init__(self, *args, **kwargs): 0491 dict={} 0492 # What was supplied to this function 0493 dict.update(kwargs) 0494 # Parent constructor 0495 super(phonebookslotupdaterequest,self).__init__(**dict) 0496 if self.__class__ is phonebookslotupdaterequest: 0497 self._update(args,dict) 0498 0499 0500 def getfields(self): 0501 return self.__fields 0502 0503 0504 def _update(self, args, kwargs): 0505 super(phonebookslotupdaterequest,self)._update(args,kwargs) 0506 keys=kwargs.keys() 0507 for key in keys: 0508 if key in self.__fields: 0509 setattr(self, key, kwargs[key]) 0510 del kwargs[key] 0511 # Were any unrecognized kwargs passed in? 0512 if __debug__: 0513 self._complainaboutunusedargs(phonebookslotupdaterequest,kwargs) 0514 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 0515 # Make all P fields that haven't already been constructed 0516 0517 0518 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 0519 'Writes this packet to the supplied buffer' 0520 self._bufferstartoffset=buf.getcurrentoffset() 0521 try: self.__field_header 0522 except: 0523 self.__field_header=sanyowriteheader(**{'packettype': 0x0c, 'command': 0x28}) 0524 self.__field_header.writetobuffer(buf) 0525 self.__field_entry.writetobuffer(buf) 0526 try: self.__field_pad 0527 except: 0528 self.__field_pad=UNKNOWN(**{'sizeinbytes': 500}) 0529 self.__field_pad.writetobuffer(buf) 0530 self._bufferendoffset=buf.getcurrentoffset() 0531 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 0532 0533 0534 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 0535 'Reads this packet from the supplied buffer' 0536 self._bufferstartoffset=buf.getcurrentoffset() 0537 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 0538 self.__field_header=sanyowriteheader(**{'packettype': 0x0c, 'command': 0x28}) 0539 self.__field_header.readfrombuffer(buf) 0540 self.__field_entry=phonebookentry() 0541 self.__field_entry.readfrombuffer(buf) 0542 self.__field_pad=UNKNOWN(**{'sizeinbytes': 500}) 0543 self.__field_pad.readfrombuffer(buf) 0544 self._bufferendoffset=buf.getcurrentoffset() 0545 0546 0547 def __getfield_header(self): 0548 try: self.__field_header 0549 except: 0550 self.__field_header=sanyowriteheader(**{'packettype': 0x0c, 'command': 0x28}) 0551 return self.__field_header.getvalue() 0552 0553 def __setfield_header(self, value): 0554 if isinstance(value,sanyowriteheader): 0555 self.__field_header=value 0556 else: 0557 self.__field_header=sanyowriteheader(value,**{'packettype': 0x0c, 'command': 0x28}) 0558 0559 def __delfield_header(self): del self.__field_header 0560 0561 header=property(__getfield_header, __setfield_header, __delfield_header, None) 0562 0563 def __getfield_entry(self): 0564 return self.__field_entry.getvalue() 0565 0566 def __setfield_entry(self, value): 0567 if isinstance(value,phonebookentry): 0568 self.__field_entry=value 0569 else: 0570 self.__field_entry=phonebookentry(value,) 0571 0572 def __delfield_entry(self): del self.__field_entry 0573 0574 entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None) 0575 0576 def __getfield_pad(self): 0577 try: self.__field_pad 0578 except: 0579 self.__field_pad=UNKNOWN(**{'sizeinbytes': 500}) 0580 return self.__field_pad.getvalue() 0581 0582 def __setfield_pad(self, value): 0583 if isinstance(value,UNKNOWN): 0584 self.__field_pad=value 0585 else: 0586 self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 500}) 0587 0588 def __delfield_pad(self): del self.__field_pad 0589 0590 pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None) 0591 0592 def iscontainer(self): 0593 return True 0594 0595 def containerelements(self): 0596 yield ('header', self.__field_header, None) 0597 yield ('entry', self.__field_entry, None) 0598 yield ('pad', self.__field_pad, None) 0599 0600 0601 0602 0603 class evententry(BaseProtogenClass): 0604 __fields=['slot', 'flag', 'eventname', 'pad1', 'eventname_len', 'start', 'end', 'location', 'pad2', 'location_len', 'pad3', 'alarmdiff', 'period', 'dom', 'alarm', 'serial', 'pad4', 'ringtone'] 0605 0606 def __init__(self, *args, **kwargs): 0607 dict={} 0608 # What was supplied to this function 0609 dict.update(kwargs) 0610 # Parent constructor 0611 super(evententry,self).__init__(**dict) 0612 if self.__class__ is evententry: 0613 self._update(args,dict) 0614 0615 0616 def getfields(self): 0617 return self.__fields 0618 0619 0620 def _update(self, args, kwargs): 0621 super(evententry,self)._update(args,kwargs) 0622 keys=kwargs.keys() 0623 for key in keys: 0624 if key in self.__fields: 0625 setattr(self, key, kwargs[key]) 0626 del kwargs[key] 0627 # Were any unrecognized kwargs passed in? 0628 if __debug__: 0629 self._complainaboutunusedargs(evententry,kwargs) 0630 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 0631 # Make all P fields that haven't already been constructed 0632 0633 0634 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 0635 'Writes this packet to the supplied buffer' 0636 self._bufferstartoffset=buf.getcurrentoffset() 0637 self.__field_slot.writetobuffer(buf) 0638 self.__field_flag.writetobuffer(buf) 0639 self.__field_eventname.writetobuffer(buf) 0640 try: self.__field_pad1 0641 except: 0642 self.__field_pad1=UNKNOWN(**{'sizeinbytes': 7}) 0643 self.__field_pad1.writetobuffer(buf) 0644 self.__field_eventname_len.writetobuffer(buf) 0645 self.__field_start.writetobuffer(buf) 0646 self.__field_end.writetobuffer(buf) 0647 self.__field_location.writetobuffer(buf) 0648 try: self.__field_pad2 0649 except: 0650 self.__field_pad2=UNKNOWN(**{'sizeinbytes': 7}) 0651 self.__field_pad2.writetobuffer(buf) 0652 self.__field_location_len.writetobuffer(buf) 0653 try: self.__field_pad3 0654 except: 0655 self.__field_pad3=UNKNOWN(**{'sizeinbytes': 1}) 0656 self.__field_pad3.writetobuffer(buf) 0657 self.__field_alarmdiff.writetobuffer(buf) 0658 self.__field_period.writetobuffer(buf) 0659 self.__field_dom.writetobuffer(buf) 0660 self.__field_alarm.writetobuffer(buf) 0661 try: self.__field_serial 0662 except: 0663 self.__field_serial=UINT(**{'sizeinbytes': 1, 'default': 0}) 0664 self.__field_serial.writetobuffer(buf) 0665 try: self.__field_pad4 0666 except: 0667 self.__field_pad4=UNKNOWN(**{'sizeinbytes': 3}) 0668 self.__field_pad4.writetobuffer(buf) 0669 self.__field_ringtone.writetobuffer(buf) 0670 self._bufferendoffset=buf.getcurrentoffset() 0671 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 0672 0673 0674 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 0675 'Reads this packet from the supplied buffer' 0676 self._bufferstartoffset=buf.getcurrentoffset() 0677 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 0678 self.__field_slot=UINT(**{'sizeinbytes': 1}) 0679 self.__field_slot.readfrombuffer(buf) 0680 self.__field_flag=UINT(**{'sizeinbytes': 1}) 0681 self.__field_flag.readfrombuffer(buf) 0682 self.__field_eventname=USTRING(**{'sizeinbytes': 14, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'terminator': None}) 0683 self.__field_eventname.readfrombuffer(buf) 0684 self.__field_pad1=UNKNOWN(**{'sizeinbytes': 7}) 0685 self.__field_pad1.readfrombuffer(buf) 0686 self.__field_eventname_len=UINT(**{'sizeinbytes': 1}) 0687 self.__field_eventname_len.readfrombuffer(buf) 0688 self.__field_start=UINT(**{'sizeinbytes': 4}) 0689 self.__field_start.readfrombuffer(buf) 0690 self.__field_end=UINT(**{'sizeinbytes': 4}) 0691 self.__field_end.readfrombuffer(buf) 0692 self.__field_location=USTRING(**{'sizeinbytes': 14, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'terminator': None}) 0693 self.__field_location.readfrombuffer(buf) 0694 self.__field_pad2=UNKNOWN(**{'sizeinbytes': 7}) 0695 self.__field_pad2.readfrombuffer(buf) 0696 self.__field_location_len=UINT(**{'sizeinbytes': 1}) 0697 self.__field_location_len.readfrombuffer(buf) 0698 self.__field_pad3=UNKNOWN(**{'sizeinbytes': 1}) 0699 self.__field_pad3.readfrombuffer(buf) 0700 self.__field_alarmdiff=UINT(**{'sizeinbytes': 4}) 0701 self.__field_alarmdiff.readfrombuffer(buf) 0702 self.__field_period=UINT(**{'sizeinbytes': 1}) 0703 self.__field_period.readfrombuffer(buf) 0704 self.__field_dom=UINT(**{'sizeinbytes': 1}) 0705 self.__field_dom.readfrombuffer(buf) 0706 self.__field_alarm=UINT(**{'sizeinbytes': 4}) 0707 self.__field_alarm.readfrombuffer(buf) 0708 self.__field_serial=UINT(**{'sizeinbytes': 1, 'default': 0}) 0709 self.__field_serial.readfrombuffer(buf) 0710 self.__field_pad4=UNKNOWN(**{'sizeinbytes': 3}) 0711 self.__field_pad4.readfrombuffer(buf) 0712 self.__field_ringtone=UINT(**{'sizeinbytes': 1}) 0713 self.__field_ringtone.readfrombuffer(buf) 0714 self._bufferendoffset=buf.getcurrentoffset() 0715 0716 0717 def __getfield_slot(self): 0718 return self.__field_slot.getvalue() 0719 0720 def __setfield_slot(self, value): 0721 if isinstance(value,UINT): 0722 self.__field_slot=value 0723 else: 0724 self.__field_slot=UINT(value,**{'sizeinbytes': 1}) 0725 0726 def __delfield_slot(self): del self.__field_slot 0727 0728 slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None) 0729 0730 def __getfield_flag(self): 0731 return self.__field_flag.getvalue() 0732 0733 def __setfield_flag(self, value): 0734 if isinstance(value,UINT): 0735 self.__field_flag=value 0736 else: 0737 self.__field_flag=UINT(value,**{'sizeinbytes': 1}) 0738 0739 def __delfield_flag(self): del self.__field_flag 0740 0741 flag=property(__getfield_flag, __setfield_flag, __delfield_flag, "0: Not used, 1: Scheduled, 2: Already Happened") 0742 0743 def __getfield_eventname(self): 0744 return self.__field_eventname.getvalue() 0745 0746 def __setfield_eventname(self, value): 0747 if isinstance(value,USTRING): 0748 self.__field_eventname=value 0749 else: 0750 self.__field_eventname=USTRING(value,**{'sizeinbytes': 14, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'terminator': None}) 0751 0752 def __delfield_eventname(self): del self.__field_eventname 0753 0754 eventname=property(__getfield_eventname, __setfield_eventname, __delfield_eventname, None) 0755 0756 def __getfield_pad1(self): 0757 try: self.__field_pad1 0758 except: 0759 self.__field_pad1=UNKNOWN(**{'sizeinbytes': 7}) 0760 return self.__field_pad1.getvalue() 0761 0762 def __setfield_pad1(self, value): 0763 if isinstance(value,UNKNOWN): 0764 self.__field_pad1=value 0765 else: 0766 self.__field_pad1=UNKNOWN(value,**{'sizeinbytes': 7}) 0767 0768 def __delfield_pad1(self): del self.__field_pad1 0769 0770 pad1=property(__getfield_pad1, __setfield_pad1, __delfield_pad1, None) 0771 0772 def __getfield_eventname_len(self): 0773 return self.__field_eventname_len.getvalue() 0774 0775 def __setfield_eventname_len(self, value): 0776 if isinstance(value,UINT): 0777 self.__field_eventname_len=value 0778 else: 0779 self.__field_eventname_len=UINT(value,**{'sizeinbytes': 1}) 0780 0781 def __delfield_eventname_len(self): del self.__field_eventname_len 0782 0783 eventname_len=property(__getfield_eventname_len, __setfield_eventname_len, __delfield_eventname_len, None) 0784 0785 def __getfield_start(self): 0786 return self.__field_start.getvalue() 0787 0788 def __setfield_start(self, value): 0789 if isinstance(value,UINT): 0790 self.__field_start=value 0791 else: 0792 self.__field_start=UINT(value,**{'sizeinbytes': 4}) 0793 0794 def __delfield_start(self): del self.__field_start 0795 0796 start=property(__getfield_start, __setfield_start, __delfield_start, "# seconds since Jan 1, 1980 approximately") 0797 0798 def __getfield_end(self): 0799 return self.__field_end.getvalue() 0800 0801 def __setfield_end(self, value): 0802 if isinstance(value,UINT): 0803 self.__field_end=value 0804 else: 0805 self.__field_end=UINT(value,**{'sizeinbytes': 4}) 0806 0807 def __delfield_end(self): del self.__field_end 0808 0809 end=property(__getfield_end, __setfield_end, __delfield_end, None) 0810 0811 def __getfield_location(self): 0812 return self.__field_location.getvalue() 0813 0814 def __setfield_location(self, value): 0815 if isinstance(value,USTRING): 0816 self.__field_location=value 0817 else: 0818 self.__field_location=USTRING(value,**{'sizeinbytes': 14, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'terminator': None}) 0819 0820 def __delfield_location(self): del self.__field_location 0821 0822 location=property(__getfield_location, __setfield_location, __delfield_location, None) 0823 0824 def __getfield_pad2(self): 0825 try: self.__field_pad2 0826 except: 0827 self.__field_pad2=UNKNOWN(**{'sizeinbytes': 7}) 0828 return self.__field_pad2.getvalue() 0829 0830 def __setfield_pad2(self, value): 0831 if isinstance(value,UNKNOWN): 0832 self.__field_pad2=value 0833 else: 0834 self.__field_pad2=UNKNOWN(value,**{'sizeinbytes': 7}) 0835 0836 def __delfield_pad2(self): del self.__field_pad2 0837 0838 pad2=property(__getfield_pad2, __setfield_pad2, __delfield_pad2, None) 0839 0840 def __getfield_location_len(self): 0841 return self.__field_location_len.getvalue() 0842 0843 def __setfield_location_len(self, value): 0844 if isinstance(value,UINT): 0845 self.__field_location_len=value 0846 else: 0847 self.__field_location_len=UINT(value,**{'sizeinbytes': 1}) 0848 0849 def __delfield_location_len(self): del self.__field_location_len 0850 0851 location_len=property(__getfield_location_len, __setfield_location_len, __delfield_location_len, None) 0852 0853 def __getfield_pad3(self): 0854 try: self.__field_pad3 0855 except: 0856 self.__field_pad3=UNKNOWN(**{'sizeinbytes': 1}) 0857 return self.__field_pad3.getvalue() 0858 0859 def __setfield_pad3(self, value): 0860 if isinstance(value,UNKNOWN): 0861 self.__field_pad3=value 0862 else: 0863 self.__field_pad3=UNKNOWN(value,**{'sizeinbytes': 1}) 0864 0865 def __delfield_pad3(self): del self.__field_pad3 0866 0867 pad3=property(__getfield_pad3, __setfield_pad3, __delfield_pad3, None) 0868 0869 def __getfield_alarmdiff(self): 0870 return self.__field_alarmdiff.getvalue() 0871 0872 def __setfield_alarmdiff(self, value): 0873 if isinstance(value,UINT): 0874 self.__field_alarmdiff=value 0875 else: 0876 self.__field_alarmdiff=UINT(value,**{'sizeinbytes': 4}) 0877 0878 def __delfield_alarmdiff(self): del self.__field_alarmdiff 0879 0880 alarmdiff=property(__getfield_alarmdiff, __setfield_alarmdiff, __delfield_alarmdiff, "Displayed alarm time") 0881 0882 def __getfield_period(self): 0883 return self.__field_period.getvalue() 0884 0885 def __setfield_period(self, value): 0886 if isinstance(value,UINT): 0887 self.__field_period=value 0888 else: 0889 self.__field_period=UINT(value,**{'sizeinbytes': 1}) 0890 0891 def __delfield_period(self): del self.__field_period 0892 0893 period=property(__getfield_period, __setfield_period, __delfield_period, "No, Daily, Weekly, Monthly, Yearly") 0894 0895 def __getfield_dom(self): 0896 return self.__field_dom.getvalue() 0897 0898 def __setfield_dom(self, value): 0899 if isinstance(value,UINT): 0900 self.__field_dom=value 0901 else: 0902 self.__field_dom=UINT(value,**{'sizeinbytes': 1}) 0903 0904 def __delfield_dom(self): del self.__field_dom 0905 0906 dom=property(__getfield_dom, __setfield_dom, __delfield_dom, "Day of month for the event") 0907 0908 def __getfield_alarm(self): 0909 return self.__field_alarm.getvalue() 0910 0911 def __setfield_alarm(self, value): 0912 if isinstance(value,UINT): 0913 self.__field_alarm=value 0914 else: 0915 self.__field_alarm=UINT(value,**{'sizeinbytes': 4}) 0916 0917 def __delfield_alarm(self): del self.__field_alarm 0918 0919 alarm=property(__getfield_alarm, __setfield_alarm, __delfield_alarm, None) 0920 0921 def __getfield_serial(self): 0922 try: self.__field_serial 0923 except: 0924 self.__field_serial=UINT(**{'sizeinbytes': 1, 'default': 0}) 0925 return self.__field_serial.getvalue() 0926 0927 def __setfield_serial(self, value): 0928 if isinstance(value,UINT): 0929 self.__field_serial=value 0930 else: 0931 self.__field_serial=UINT(value,**{'sizeinbytes': 1, 'default': 0}) 0932 0933 def __delfield_serial(self): del self.__field_serial 0934 0935 serial=property(__getfield_serial, __setfield_serial, __delfield_serial, "Some kind of serial number") 0936 0937 def __getfield_pad4(self): 0938 try: self.__field_pad4 0939 except: 0940 self.__field_pad4=UNKNOWN(**{'sizeinbytes': 3}) 0941 return self.__field_pad4.getvalue() 0942 0943 def __setfield_pad4(self, value): 0944 if isinstance(value,UNKNOWN): 0945 self.__field_pad4=value 0946 else: 0947 self.__field_pad4=UNKNOWN(value,**{'sizeinbytes': 3}) 0948 0949 def __delfield_pad4(self): del self.__field_pad4 0950 0951 pad4=property(__getfield_pad4, __setfield_pad4, __delfield_pad4, None) 0952 0953 def __getfield_ringtone(self): 0954 return self.__field_ringtone.getvalue() 0955 0956 def __setfield_ringtone(self, value): 0957 if isinstance(value,UINT): 0958 self.__field_ringtone=value 0959 else: 0960 self.__field_ringtone=UINT(value,**{'sizeinbytes': 1}) 0961 0962 def __delfield_ringtone(self): del self.__field_ringtone 0963 0964 ringtone=property(__getfield_ringtone, __setfield_ringtone, __delfield_ringtone, "0: Beep, 1: Voice, 2: Silent") 0965 0966 def iscontainer(self): 0967 return True 0968 0969 def containerelements(self): 0970 yield ('slot', self.__field_slot, None) 0971 yield ('flag', self.__field_flag, "0: Not used, 1: Scheduled, 2: Already Happened") 0972 yield ('eventname', self.__field_eventname, None) 0973 yield ('pad1', self.__field_pad1, None) 0974 yield ('eventname_len', self.__field_eventname_len, None) 0975 yield ('start', self.__field_start, "# seconds since Jan 1, 1980 approximately") 0976 yield ('end', self.__field_end, None) 0977 yield ('location', self.__field_location, None) 0978 yield ('pad2', self.__field_pad2, None) 0979 yield ('location_len', self.__field_location_len, None) 0980 yield ('pad3', self.__field_pad3, None) 0981 yield ('alarmdiff', self.__field_alarmdiff, "Displayed alarm time") 0982 yield ('period', self.__field_period, "No, Daily, Weekly, Monthly, Yearly") 0983 yield ('dom', self.__field_dom, "Day of month for the event") 0984 yield ('alarm', self.__field_alarm, None) 0985 yield ('serial', self.__field_serial, "Some kind of serial number") 0986 yield ('pad4', self.__field_pad4, None) 0987 yield ('ringtone', self.__field_ringtone, "0: Beep, 1: Voice, 2: Silent") 0988 0989 0990 0991 0992 class eventresponse(BaseProtogenClass): 0993 __fields=['header', 'entry', 'pad'] 0994 0995 def __init__(self, *args, **kwargs): 0996 dict={} 0997 # What was supplied to this function 0998 dict.update(kwargs) 0999 # Parent constructor 1000 super(eventresponse,self).__init__(**dict) 1001 if self.__class__ is eventresponse: 1002 self._update(args,dict) 1003 1004 1005 def getfields(self): 1006 return self.__fields 1007 1008 1009 def _update(self, args, kwargs): 1010 super(eventresponse,self)._update(args,kwargs) 1011 keys=kwargs.keys() 1012 for key in keys: 1013 if key in self.__fields: 1014 setattr(self, key, kwargs[key]) 1015 del kwargs[key] 1016 # Were any unrecognized kwargs passed in? 1017 if __debug__: 1018 self._complainaboutunusedargs(eventresponse,kwargs) 1019 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 1020 # Make all P fields that haven't already been constructed 1021 1022 1023 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 1024 'Writes this packet to the supplied buffer' 1025 self._bufferstartoffset=buf.getcurrentoffset() 1026 self.__field_header.writetobuffer(buf) 1027 self.__field_entry.writetobuffer(buf) 1028 self.__field_pad.writetobuffer(buf) 1029 self._bufferendoffset=buf.getcurrentoffset() 1030 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 1031 1032 1033 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 1034 'Reads this packet from the supplied buffer' 1035 self._bufferstartoffset=buf.getcurrentoffset() 1036 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 1037 self.__field_header=sanyoheader() 1038 self.__field_header.readfrombuffer(buf) 1039 self.__field_entry=evententry() 1040 self.__field_entry.readfrombuffer(buf) 1041 self.__field_pad=UNKNOWN() 1042 self.__field_pad.readfrombuffer(buf) 1043 self._bufferendoffset=buf.getcurrentoffset() 1044 1045 1046 def __getfield_header(self): 1047 return self.__field_header.getvalue() 1048 1049 def __setfield_header(self, value): 1050 if isinstance(value,sanyoheader): 1051 self.__field_header=value 1052 else: 1053 self.__field_header=sanyoheader(value,) 1054 1055 def __delfield_header(self): del self.__field_header 1056 1057 header=property(__getfield_header, __setfield_header, __delfield_header, None) 1058 1059 def __getfield_entry(self): 1060 return self.__field_entry.getvalue() 1061 1062 def __setfield_entry(self, value): 1063 if isinstance(value,evententry): 1064 self.__field_entry=value 1065 else: 1066 self.__field_entry=evententry(value,) 1067 1068 def __delfield_entry(self): del self.__field_entry 1069 1070 entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None) 1071 1072 def __getfield_pad(self): 1073 return self.__field_pad.getvalue() 1074 1075 def __setfield_pad(self, value): 1076 if isinstance(value,UNKNOWN): 1077 self.__field_pad=value 1078 else: 1079 self.__field_pad=UNKNOWN(value,) 1080 1081 def __delfield_pad(self): del self.__field_pad 1082 1083 pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None) 1084 1085 def iscontainer(self): 1086 return True 1087 1088 def containerelements(self): 1089 yield ('header', self.__field_header, None) 1090 yield ('entry', self.__field_entry, None) 1091 yield ('pad', self.__field_pad, None) 1092 1093 1094 1095 1096 class eventupdaterequest(BaseProtogenClass): 1097 __fields=['header', 'entry', 'pad'] 1098 1099 def __init__(self, *args, **kwargs): 1100 dict={} 1101 # What was supplied to this function 1102 dict.update(kwargs) 1103 # Parent constructor 1104 super(eventupdaterequest,self).__init__(**dict) 1105 if self.__class__ is eventupdaterequest: 1106 self._update(args,dict) 1107 1108 1109 def getfields(self): 1110 return self.__fields 1111 1112 1113 def _update(self, args, kwargs): 1114 super(eventupdaterequest,self)._update(args,kwargs) 1115 keys=kwargs.keys() 1116 for key in keys: 1117 if key in self.__fields: 1118 setattr(self, key, kwargs[key]) 1119 del kwargs[key] 1120 # Were any unrecognized kwargs passed in? 1121 if __debug__: 1122 self._complainaboutunusedargs(eventupdaterequest,kwargs) 1123 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 1124 # Make all P fields that haven't already been constructed 1125 1126 1127 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 1128 'Writes this packet to the supplied buffer' 1129 self._bufferstartoffset=buf.getcurrentoffset() 1130 try: self.__field_header 1131 except: 1132 self.__field_header=sanyowriteheader(**{'packettype': 0x0c, 'command':0x23}) 1133 self.__field_header.writetobuffer(buf) 1134 self.__field_entry.writetobuffer(buf) 1135 try: self.__field_pad 1136 except: 1137 self.__field_pad=UNKNOWN(**{'sizeinbytes': 400}) 1138 self.__field_pad.writetobuffer(buf) 1139 self._bufferendoffset=buf.getcurrentoffset() 1140 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 1141 1142 1143 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 1144 'Reads this packet from the supplied buffer' 1145 self._bufferstartoffset=buf.getcurrentoffset() 1146 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 1147 self.__field_header=sanyowriteheader(**{'packettype': 0x0c, 'command':0x23}) 1148 self.__field_header.readfrombuffer(buf) 1149 self.__field_entry=evententry() 1150 self.__field_entry.readfrombuffer(buf) 1151 self.__field_pad=UNKNOWN(**{'sizeinbytes': 400}) 1152 self.__field_pad.readfrombuffer(buf) 1153 self._bufferendoffset=buf.getcurrentoffset() 1154 1155 1156 def __getfield_header(self): 1157 try: self.__field_header 1158 except: 1159 self.__field_header=sanyowriteheader(**{'packettype': 0x0c, 'command':0x23}) 1160 return self.__field_header.getvalue() 1161 1162 def __setfield_header(self, value): 1163 if isinstance(value,sanyowriteheader): 1164 self.__field_header=value 1165 else: 1166 self.__field_header=sanyowriteheader(value,**{'packettype': 0x0c, 'command':0x23}) 1167 1168 def __delfield_header(self): del self.__field_header 1169 1170 header=property(__getfield_header, __setfield_header, __delfield_header, None) 1171 1172 def __getfield_entry(self): 1173 return self.__field_entry.getvalue() 1174 1175 def __setfield_entry(self, value): 1176 if isinstance(value,evententry): 1177 self.__field_entry=value 1178 else: 1179 self.__field_entry=evententry(value,) 1180 1181 def __delfield_entry(self): del self.__field_entry 1182 1183 entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None) 1184 1185 def __getfield_pad(self): 1186 try: self.__field_pad 1187 except: 1188 self.__field_pad=UNKNOWN(**{'sizeinbytes': 400}) 1189 return self.__field_pad.getvalue() 1190 1191 def __setfield_pad(self, value): 1192 if isinstance(value,UNKNOWN): 1193 self.__field_pad=value 1194 else: 1195 self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 400}) 1196 1197 def __delfield_pad(self): del self.__field_pad 1198 1199 pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None) 1200 1201 def iscontainer(self): 1202 return True 1203 1204 def containerelements(self): 1205 yield ('header', self.__field_header, None) 1206 yield ('entry', self.__field_entry, None) 1207 yield ('pad', self.__field_pad, None) 1208 1209 1210 1211 1212 class callalarmentry(BaseProtogenClass): 1213 __fields=['ringtone', 'slot', 'flag', 'dunno1', 'phonenum', 'phonenum_len', 'date', 'period', 'dom', 'datedup', 'name', 'pad1', 'name_len', 'phonenumbertype', 'phonenumberslot', 'serial'] 1214 1215 def __init__(self, *args, **kwargs): 1216 dict={} 1217 # What was supplied to this function 1218 dict.update(kwargs) 1219 # Parent constructor 1220 super(callalarmentry,self).__init__(**dict) 1221 if self.__class__ is callalarmentry: 1222 self._update(args,dict) 1223 1224 1225 def getfields(self): 1226 return self.__fields 1227 1228 1229 def _update(self, args, kwargs): 1230 super(callalarmentry,self)._update(args,kwargs) 1231 keys=kwargs.keys() 1232 for key in keys: 1233 if key in self.__fields: 1234 setattr(self, key, kwargs[key]) 1235 del kwargs[key] 1236 # Were any unrecognized kwargs passed in? 1237 if __debug__: 1238 self._complainaboutunusedargs(callalarmentry,kwargs) 1239 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 1240 # Make all P fields that haven't already been constructed 1241 try: self.__field_ringtone 1242 except: 1243 self.__field_ringtone=UINT(**{'constant': 0}) 1244 1245 1246 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 1247 'Writes this packet to the supplied buffer' 1248 self._bufferstartoffset=buf.getcurrentoffset() 1249 self.__field_slot.writetobuffer(buf) 1250 self.__field_flag.writetobuffer(buf) 1251 try: self.__field_dunno1 1252 except: 1253 self.__field_dunno1=UINT(**{'sizeinbytes': 1, 'default': 0}) 1254 self.__field_dunno1.writetobuffer(buf) 1255 self.__field_phonenum.writetobuffer(buf) 1256 self.__field_phonenum_len.writetobuffer(buf) 1257 self.__field_date.writetobuffer(buf) 1258 self.__field_period.writetobuffer(buf) 1259 self.__field_dom.writetobuffer(buf) 1260 self.__field_datedup.writetobuffer(buf) 1261 self.__field_name.writetobuffer(buf) 1262 try: self.__field_pad1 1263 except: 1264 self.__field_pad1=UNKNOWN(**{'sizeinbytes': 1}) 1265 self.__field_pad1.writetobuffer(buf) 1266 self.__field_name_len.writetobuffer(buf) 1267 self.__field_phonenumbertype.writetobuffer(buf) 1268 self.__field_phonenumberslot.writetobuffer(buf) 1269 try: self.__field_serial 1270 except: 1271 self.__field_serial=UINT(**{'sizeinbytes': 1, 'default': 0}) 1272 self.__field_serial.writetobuffer(buf) 1273 self._bufferendoffset=buf.getcurrentoffset() 1274 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 1275 1276 1277 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 1278 'Reads this packet from the supplied buffer' 1279 self._bufferstartoffset=buf.getcurrentoffset() 1280 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 1281 self.__field_slot=UINT(**{'sizeinbytes': 1}) 1282 self.__field_slot.readfrombuffer(buf) 1283 self.__field_flag=UINT(**{'sizeinbytes': 1}) 1284 self.__field_flag.readfrombuffer(buf) 1285 self.__field_dunno1=UINT(**{'sizeinbytes': 1, 'default': 0}) 1286 self.__field_dunno1.readfrombuffer(buf) 1287 self.__field_phonenum=USTRING(**{'sizeinbytes': 49, 'raiseonunterminatedread': False}) 1288 self.__field_phonenum.readfrombuffer(buf) 1289 self.__field_phonenum_len=UINT(**{'sizeinbytes': 1}) 1290 self.__field_phonenum_len.readfrombuffer(buf) 1291 self.__field_date=UINT(**{'sizeinbytes': 4}) 1292 self.__field_date.readfrombuffer(buf) 1293 self.__field_period=UINT(**{'sizeinbytes': 1}) 1294 self.__field_period.readfrombuffer(buf) 1295 self.__field_dom=UINT(**{'sizeinbytes': 1}) 1296 self.__field_dom.readfrombuffer(buf) 1297 self.__field_datedup=UINT(**{'sizeinbytes': 4}) 1298 self.__field_datedup.readfrombuffer(buf) 1299 self.__field_name=USTRING(**{'sizeinbytes': 16, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'terminator': None}) 1300 self.__field_name.readfrombuffer(buf) 1301 self.__field_pad1=UNKNOWN(**{'sizeinbytes': 1}) 1302 self.__field_pad1.readfrombuffer(buf) 1303 self.__field_name_len=UINT(**{'sizeinbytes': 1}) 1304 self.__field_name_len.readfrombuffer(buf) 1305 self.__field_phonenumbertype=UINT(**{'sizeinbytes': 1}) 1306 self.__field_phonenumbertype.readfrombuffer(buf) 1307 self.__field_phonenumberslot=UINT(**{'sizeinbytes': 2}) 1308 self.__field_phonenumberslot.readfrombuffer(buf) 1309 self.__field_serial=UINT(**{'sizeinbytes': 1, 'default': 0}) 1310 self.__field_serial.readfrombuffer(buf) 1311 self._bufferendoffset=buf.getcurrentoffset() 1312 1313 1314 def __getfield_ringtone(self): 1315 return self.__field_ringtone.getvalue() 1316 1317 def __setfield_ringtone(self, value): 1318 if isinstance(value,UINT): 1319 self.__field_ringtone=value 1320 else: 1321 self.__field_ringtone=UINT(value,**{'constant': 0}) 1322 1323 def __delfield_ringtone(self): del self.__field_ringtone 1324 1325 ringtone=property(__getfield_ringtone, __setfield_ringtone, __delfield_ringtone, None) 1326 1327 def __getfield_slot(self): 1328 return self.__field_slot.getvalue() 1329 1330 def __setfield_slot(self, value): 1331 if isinstance(value,UINT): 1332 self.__field_slot=value 1333 else: 1334 self.__field_slot=UINT(value,**{'sizeinbytes': 1}) 1335 1336 def __delfield_slot(self): del self.__field_slot 1337 1338 slot=property(__getfield_slot, __setfield_slot, __delfield_slot, None) 1339 1340 def __getfield_flag(self): 1341 return self.__field_flag.getvalue() 1342 1343 def __setfield_flag(self, value): 1344 if isinstance(value,UINT): 1345 self.__field_flag=value 1346 else: 1347 self.__field_flag=UINT(value,**{'sizeinbytes': 1}) 1348 1349 def __delfield_flag(self): del self.__field_flag 1350 1351 flag=property(__getfield_flag, __setfield_flag, __delfield_flag, "0: Not used, 1: Scheduled, 2: Already Happened") 1352 1353 def __getfield_dunno1(self): 1354 try: self.__field_dunno1 1355 except: 1356 self.__field_dunno1=UINT(**{'sizeinbytes': 1, 'default': 0}) 1357 return self.__field_dunno1.getvalue() 1358 1359 def __setfield_dunno1(self, value): 1360 if isinstance(value,UINT): 1361 self.__field_dunno1=value 1362 else: 1363 self.__field_dunno1=UINT(value,**{'sizeinbytes': 1, 'default': 0}) 1364 1365 def __delfield_dunno1(self): del self.__field_dunno1 1366 1367 dunno1=property(__getfield_dunno1, __setfield_dunno1, __delfield_dunno1, "Related to Snooze?") 1368 1369 def __getfield_phonenum(self): 1370 return self.__field_phonenum.getvalue() 1371 1372 def __setfield_phonenum(self, value): 1373 if isinstance(value,USTRING): 1374 self.__field_phonenum=value 1375 else: 1376 self.__field_phonenum=USTRING(value,**{'sizeinbytes': 49, 'raiseonunterminatedread': False}) 1377 1378 def __delfield_phonenum(self): del self.__field_phonenum 1379 1380 phonenum=property(__getfield_phonenum, __setfield_phonenum, __delfield_phonenum, None) 1381 1382 def __getfield_phonenum_len(self): 1383 return self.__field_phonenum_len.getvalue() 1384 1385 def __setfield_phonenum_len(self, value): 1386 if isinstance(value,UINT): 1387 self.__field_phonenum_len=value 1388 else: 1389 self.__field_phonenum_len=UINT(value,**{'sizeinbytes': 1}) 1390 1391 def __delfield_phonenum_len(self): del self.__field_phonenum_len 1392 1393 phonenum_len=property(__getfield_phonenum_len, __setfield_phonenum_len, __delfield_phonenum_len, None) 1394 1395 def __getfield_date(self): 1396 return self.__field_date.getvalue() 1397 1398 def __setfield_date(self, value): 1399 if isinstance(value,UINT): 1400 self.__field_date=value 1401 else: 1402 self.__field_date=UINT(value,**{'sizeinbytes': 4}) 1403 1404 def __delfield_date(self): del self.__field_date 1405 1406 date=property(__getfield_date, __setfield_date, __delfield_date, "# seconds since Jan 1, 1980 approximately") 1407 1408 def __getfield_period(self): 1409 return self.__field_period.getvalue() 1410 1411 def __setfield_period(self, value): 1412 if isinstance(value,UINT): 1413 self.__field_period=value 1414 else: 1415 self.__field_period=UINT(value,**{'sizeinbytes': 1}) 1416 1417 def __delfield_period(self): del self.__field_period 1418 1419 period=property(__getfield_period, __setfield_period, __delfield_period, "No, Daily, Weekly, Monthly, Yearly") 1420 1421 def __getfield_dom(self): 1422 return self.__field_dom.getvalue() 1423 1424 def __setfield_dom(self, value): 1425 if isinstance(value,UINT): 1426 self.__field_dom=value 1427 else: 1428 self.__field_dom=UINT(value,**{'sizeinbytes': 1}) 1429 1430 def __delfield_dom(self): del self.__field_dom 1431 1432 dom=property(__getfield_dom, __setfield_dom, __delfield_dom, "Day of month for the event") 1433 1434 def __getfield_datedup(self): 1435 return self.__field_datedup.getvalue() 1436 1437 def __setfield_datedup(self, value): 1438 if isinstance(value,UINT): 1439 self.__field_datedup=value 1440 else: 1441 self.__field_datedup=UINT(value,**{'sizeinbytes': 4}) 1442 1443 def __delfield_datedup(self): del self.__field_datedup 1444 1445 datedup=property(__getfield_datedup, __setfield_datedup, __delfield_datedup, "Copy of the date. Always the same???") 1446 1447 def __getfield_name(self): 1448 return self.__field_name.getvalue() 1449 1450 def __setfield_name(self, value): 1451 if isinstance(value,USTRING): 1452 self.__field_name=value 1453 else: 1454 self.__field_name=USTRING(value,**{'sizeinbytes': 16, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'terminator': None}) 1455 1456 def __delfield_name(self): del self.__field_name 1457 1458 name=property(__getfield_name, __setfield_name, __delfield_name, None) 1459 1460 def __getfield_pad1(self): 1461 try: self.__field_pad1 1462 except: 1463 self.__field_pad1=UNKNOWN(**{'sizeinbytes': 1}) 1464 return self.__field_pad1.getvalue() 1465 1466 def __setfield_pad1(self, value): 1467 if isinstance(value,UNKNOWN): 1468 self.__field_pad1=value 1469 else: 1470 self.__field_pad1=UNKNOWN(value,**{'sizeinbytes': 1}) 1471 1472 def __delfield_pad1(self): del self.__field_pad1 1473 1474 pad1=property(__getfield_pad1, __setfield_pad1, __delfield_pad1, None) 1475 1476 def __getfield_name_len(self): 1477 return self.__field_name_len.getvalue() 1478 1479 def __setfield_name_len(self, value): 1480 if isinstance(value,UINT): 1481 self.__field_name_len=value 1482 else: 1483 self.__field_name_len=UINT(value,**{'sizeinbytes': 1}) 1484 1485 def __delfield_name_len(self): del self.__field_name_len 1486 1487 name_len=property(__getfield_name_len, __setfield_name_len, __delfield_name_len, None) 1488 1489 def __getfield_phonenumbertype(self): 1490 return self.__field_phonenumbertype.getvalue() 1491 1492 def __setfield_phonenumbertype(self, value): 1493 if isinstance(value,UINT): 1494 self.__field_phonenumbertype=value 1495 else: 1496 self.__field_phonenumbertype=UINT(value,**{'sizeinbytes': 1}) 1497 1498 def __delfield_phonenumbertype(self): del self.__field_phonenumbertype 1499 1500 phonenumbertype=property(__getfield_phonenumbertype, __setfield_phonenumbertype, __delfield_phonenumbertype, "1: Home, 2: Work, ...") 1501 1502 def __getfield_phonenumberslot(self): 1503 return self.__field_phonenumberslot.getvalue() 1504 1505 def __setfield_phonenumberslot(self, value): 1506 if isinstance(value,UINT): 1507 self.__field_phonenumberslot=value 1508 else: 1509 self.__field_phonenumberslot=UINT(value,**{'sizeinbytes': 2}) 1510 1511 def __delfield_phonenumberslot(self): del self.__field_phonenumberslot 1512 1513 phonenumberslot=property(__getfield_phonenumberslot, __setfield_phonenumberslot, __delfield_phonenumberslot, None) 1514 1515 def __getfield_serial(self): 1516 try: self.__field_serial 1517 except: 1518 self.__field_serial=UINT(**{'sizeinbytes': 1, 'default': 0}) 1519 return self.__field_serial.getvalue() 1520 1521 def __setfield_serial(self, value): 1522 if isinstance(value,UINT): 1523 self.__field_serial=value 1524 else: 1525 self.__field_serial=UINT(value,**{'sizeinbytes': 1, 'default': 0}) 1526 1527 def __delfield_serial(self): del self.__field_serial 1528 1529 serial=property(__getfield_serial, __setfield_serial, __delfield_serial, None) 1530 1531 def iscontainer(self): 1532 return True 1533 1534 def containerelements(self): 1535 yield ('ringtone', self.__field_ringtone, None) 1536 yield ('slot', self.__field_slot, None) 1537 yield ('flag', self.__field_flag, "0: Not used, 1: Scheduled, 2: Already Happened") 1538 yield ('dunno1', self.__field_dunno1, "Related to Snooze?") 1539 yield ('phonenum', self.__field_phonenum, None) 1540 yield ('phonenum_len', self.__field_phonenum_len, None) 1541 yield ('date', self.__field_date, "# seconds since Jan 1, 1980 approximately") 1542 yield ('period', self.__field_period, "No, Daily, Weekly, Monthly, Yearly") 1543 yield ('dom', self.__field_dom, "Day of month for the event") 1544 yield ('datedup', self.__field_datedup, "Copy of the date. Always the same???") 1545 yield ('name', self.__field_name, None) 1546 yield ('pad1', self.__field_pad1, None) 1547 yield ('name_len', self.__field_name_len, None) 1548 yield ('phonenumbertype', self.__field_phonenumbertype, "1: Home, 2: Work, ...") 1549 yield ('phonenumberslot', self.__field_phonenumberslot, None) 1550 yield ('serial', self.__field_serial, None) 1551 1552 1553 1554 1555 class callalarmresponse(BaseProtogenClass): 1556 __fields=['header', 'entry', 'pad'] 1557 1558 def __init__(self, *args, **kwargs): 1559 dict={} 1560 # What was supplied to this function 1561 dict.update(kwargs) 1562 # Parent constructor 1563 super(callalarmresponse,self).__init__(**dict) 1564 if self.__class__ is callalarmresponse: 1565 self._update(args,dict) 1566 1567 1568 def getfields(self): 1569 return self.__fields 1570 1571 1572 def _update(self, args, kwargs): 1573 super(callalarmresponse,self)._update(args,kwargs) 1574 keys=kwargs.keys() 1575 for key in keys: 1576 if key in self.__fields: 1577 setattr(self, key, kwargs[key]) 1578 del kwargs[key] 1579 # Were any unrecognized kwargs passed in? 1580 if __debug__: 1581 self._complainaboutunusedargs(callalarmresponse,kwargs) 1582 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 1583 # Make all P fields that haven't already been constructed 1584 1585 1586 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 1587 'Writes this packet to the supplied buffer' 1588 self._bufferstartoffset=buf.getcurrentoffset() 1589 self.__field_header.writetobuffer(buf) 1590 self.__field_entry.writetobuffer(buf) 1591 self.__field_pad.writetobuffer(buf) 1592 self._bufferendoffset=buf.getcurrentoffset() 1593 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 1594 1595 1596 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 1597 'Reads this packet from the supplied buffer' 1598 self._bufferstartoffset=buf.getcurrentoffset() 1599 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 1600 self.__field_header=sanyoheader() 1601 self.__field_header.readfrombuffer(buf) 1602 self.__field_entry=callalarmentry() 1603 self.__field_entry.readfrombuffer(buf) 1604 self.__field_pad=UNKNOWN() 1605 self.__field_pad.readfrombuffer(buf) 1606 self._bufferendoffset=buf.getcurrentoffset() 1607 1608 1609 def __getfield_header(self): 1610 return self.__field_header.getvalue() 1611 1612 def __setfield_header(self, value): 1613 if isinstance(value,sanyoheader): 1614 self.__field_header=value 1615 else: 1616 self.__field_header=sanyoheader(value,) 1617 1618 def __delfield_header(self): del self.__field_header 1619 1620 header=property(__getfield_header, __setfield_header, __delfield_header, None) 1621 1622 def __getfield_entry(self): 1623 return self.__field_entry.getvalue() 1624 1625 def __setfield_entry(self, value): 1626 if isinstance(value,callalarmentry): 1627 self.__field_entry=value 1628 else: 1629 self.__field_entry=callalarmentry(value,) 1630 1631 def __delfield_entry(self): del self.__field_entry 1632 1633 entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None) 1634 1635 def __getfield_pad(self): 1636 return self.__field_pad.getvalue() 1637 1638 def __setfield_pad(self, value): 1639 if isinstance(value,UNKNOWN): 1640 self.__field_pad=value 1641 else: 1642 self.__field_pad=UNKNOWN(value,) 1643 1644 def __delfield_pad(self): del self.__field_pad 1645 1646 pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None) 1647 1648 def iscontainer(self): 1649 return True 1650 1651 def containerelements(self): 1652 yield ('header', self.__field_header, None) 1653 yield ('entry', self.__field_entry, None) 1654 yield ('pad', self.__field_pad, None) 1655 1656 1657 1658 1659 class callalarmupdaterequest(BaseProtogenClass): 1660 __fields=['header', 'entry', 'pad'] 1661 1662 def __init__(self, *args, **kwargs): 1663 dict={} 1664 # What was supplied to this function 1665 dict.update(kwargs) 1666 # Parent constructor 1667 super(callalarmupdaterequest,self).__init__(**dict) 1668 if self.__class__ is callalarmupdaterequest: 1669 self._update(args,dict) 1670 1671 1672 def getfields(self): 1673 return self.__fields 1674 1675 1676 def _update(self, args, kwargs): 1677 super(callalarmupdaterequest,self)._update(args,kwargs) 1678 keys=kwargs.keys() 1679 for key in keys: 1680 if key in self.__fields: 1681 setattr(self, key, kwargs[key]) 1682 del kwargs[key] 1683 # Were any unrecognized kwargs passed in? 1684 if __debug__: 1685 self._complainaboutunusedargs(callalarmupdaterequest,kwargs) 1686 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`) 1687 # Make all P fields that haven't already been constructed 1688 1689 1690 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"): 1691 'Writes this packet to the supplied buffer' 1692 self._bufferstartoffset=buf.getcurrentoffset() 1693 try: self.__field_header 1694 except: 1695 self.__field_header=sanyowriteheader(**{'packettype': 0x0c, 'command':0x24}) 1696 self.__field_header.writetobuffer(buf) 1697 self.__field_entry.writetobuffer(buf) 1698 try: self.__field_pad 1699 except: 1700 self.__field_pad=UNKNOWN(**{'sizeinbytes': 400}) 1701 self.__field_pad.writetobuffer(buf) 1702 self._bufferendoffset=buf.getcurrentoffset() 1703 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle) 1704 1705 1706 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"): 1707 'Reads this packet from the supplied buffer' 1708 self._bufferstartoffset=buf.getcurrentoffset() 1709 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle) 1710 self.__field_header=sanyowriteheader(**{'packettype': 0x0c, 'command':0x24}) 1711 self.__field_header.readfrombuffer(buf) 1712 self.__field_entry=callalarmentry() 1713 self.__field_entry.readfrombuffer(buf) 1714 self.__field_pad=UNKNOWN(**{'sizeinbytes': 400}) 1715 self.__field_pad.readfrombuffer(buf) 1716 self._bufferendoffset=buf.getcurrentoffset() 1717 1718 1719 def __getfield_header(self): 1720 try: self.__field_header 1721 except: 1722 self.__field_header=sanyowriteheader(**{'packettype': 0x0c, 'command':0x24}) 1723 return self.__field_header.getvalue() 1724 1725 def __setfield_header(self, value): 1726 if isinstance(value,sanyowriteheader): 1727 self.__field_header=value 1728 else: 1729 self.__field_header=sanyowriteheader(value,**{'packettype': 0x0c, 'command':0x24}) 1730 1731 def __delfield_header(self): del self.__field_header 1732 1733 header=property(__getfield_header, __setfield_header, __delfield_header, None) 1734 1735 def __getfield_entry(self): 1736 return self.__field_entry.getvalue() 1737 1738 def __setfield_entry(self, value): 1739 if isinstance(value,callalarmentry): 1740 self.__field_entry=value 1741 else: 1742 self.__field_entry=callalarmentry(value,) 1743 1744 def __delfield_entry(self): del self.__field_entry 1745 1746 entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None) 1747 1748 def __getfield_pad(self): 1749 try: self.__field_pad 1750 except: 1751 self.__field_pad=UNKNOWN(**{'sizeinbytes': 400}) 1752 return self.__field_pad.getvalue() 1753 1754 def __setfield_pad(self, value): 1755 if isinstance(value,UNKNOWN): 1756 self.__field_pad=value 1757 else: 1758 self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 400}) 1759 1760 def __delfield_pad(self): del self.__field_pad 1761 1762 pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None) 1763 1764 def iscontainer(self): 1765 return True 1766 1767 def containerelements(self): 1768 yield ('header', self.__field_header, None) 1769 yield ('entry', self.__field_entry, None) 1770 yield ('pad', self.__field_pad, None) 1771 1772 1773 1774 1775
Generated by PyXR 0.9.4