0001
0003 """Various descriptions of data specific to LG VX3200"""
0004
0005 from prototypes import *
0006
0007 from p_lg import *
0009
0010 from p_lgvx4400 import *
0012
0013 UINT=UINTlsb
0015 BOOL=BOOLlsb
0016
0017 NUMSPEEDDIALS=100
0018 FIRSTSPEEDDIAL=1
0019 LASTSPEEDDIAL=99
0020 NUMPHONEBOOKENTRIES=200
0021 MAXCALENDARDESCRIPTION=38
0022
0023 NUMEMAILS=3
0024 NUMPHONENUMBERS=5
0025
0026 NORINGTONE=0
0027 NOMSGRINGTONE=0
0028 NOWALLPAPER=0
0029
0030 MEMOLENGTH=33
0031
0032 numbertypetab=( 'home', 'home2', 'office', 'office2', 'cell', 'cell2',
0033 'pager', 'fax', 'fax2', 'none', 'vmbox' )
0034
0035 class speeddial(BaseProtogenClass):
0036 __fields=['entry', 'number']
0037
0038 def __init__(self, *args, **kwargs):
0039 dict={}
0040 dict.update(kwargs)
0042 super(speeddial,self).__init__(**dict)
0044 if self.__class__ is speeddial:
0045 self._update(args,dict)
0046
0047
0048 def getfields(self):
0049 return self.__fields
0050
0051
0052 def _update(self, args, kwargs):
0053 super(speeddial,self)._update(args,kwargs)
0054 keys=kwargs.keys()
0055 for key in keys:
0056 if key in self.__fields:
0057 setattr(self, key, kwargs[key])
0058 del kwargs[key]
0059 if __debug__:
0061 self._complainaboutunusedargs(speeddial,kwargs)
0062 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0063
0065
0066 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0067 'Writes this packet to the supplied buffer'
0068 self._bufferstartoffset=buf.getcurrentoffset()
0069 try: self.__field_entry
0070 except:
0071 self.__field_entry=UINT(**{'sizeinbytes': 2, 'default': 0xffff})
0072 self.__field_entry.writetobuffer(buf)
0073 try: self.__field_number
0074 except:
0075 self.__field_number=UINT(**{'sizeinbytes': 1, 'default': 0xff})
0076 self.__field_number.writetobuffer(buf)
0077 self._bufferendoffset=buf.getcurrentoffset()
0078 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0079
0080
0081 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0082 'Reads this packet from the supplied buffer'
0083 self._bufferstartoffset=buf.getcurrentoffset()
0084 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0085 self.__field_entry=UINT(**{'sizeinbytes': 2, 'default': 0xffff})
0086 self.__field_entry.readfrombuffer(buf)
0087 self.__field_number=UINT(**{'sizeinbytes': 1, 'default': 0xff})
0088 self.__field_number.readfrombuffer(buf)
0089 self._bufferendoffset=buf.getcurrentoffset()
0090
0091
0092 def __getfield_entry(self):
0093 try: self.__field_entry
0094 except:
0095 self.__field_entry=UINT(**{'sizeinbytes': 2, 'default': 0xffff})
0096 return self.__field_entry.getvalue()
0097
0098 def __setfield_entry(self, value):
0099 if isinstance(value,UINT):
0100 self.__field_entry=value
0101 else:
0102 self.__field_entry=UINT(value,**{'sizeinbytes': 2, 'default': 0xffff})
0103
0104 def __delfield_entry(self): del self.__field_entry
0105
0106 entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None)
0107
0108 def __getfield_number(self):
0109 try: self.__field_number
0110 except:
0111 self.__field_number=UINT(**{'sizeinbytes': 1, 'default': 0xff})
0112 return self.__field_number.getvalue()
0113
0114 def __setfield_number(self, value):
0115 if isinstance(value,UINT):
0116 self.__field_number=value
0117 else:
0118 self.__field_number=UINT(value,**{'sizeinbytes': 1, 'default': 0xff})
0119
0120 def __delfield_number(self): del self.__field_number
0121
0122 number=property(__getfield_number, __setfield_number, __delfield_number, None)
0123
0124 def iscontainer(self):
0125 return True
0126
0127 def containerelements(self):
0128 yield ('entry', self.__field_entry, None)
0129 yield ('number', self.__field_number, None)
0130
0131
0132
0133
0134 class speeddials(BaseProtogenClass):
0135 __fields=['speeddials']
0136
0137 def __init__(self, *args, **kwargs):
0138 dict={}
0139 dict.update(kwargs)
0141 super(speeddials,self).__init__(**dict)
0143 if self.__class__ is speeddials:
0144 self._update(args,dict)
0145
0146
0147 def getfields(self):
0148 return self.__fields
0149
0150
0151 def _update(self, args, kwargs):
0152 super(speeddials,self)._update(args,kwargs)
0153 keys=kwargs.keys()
0154 for key in keys:
0155 if key in self.__fields:
0156 setattr(self, key, kwargs[key])
0157 del kwargs[key]
0158 if __debug__:
0160 self._complainaboutunusedargs(speeddials,kwargs)
0161 if len(args):
0162 dict2={'length': NUMSPEEDDIALS, 'elementclass': speeddial}
0163 dict2.update(kwargs)
0164 kwargs=dict2
0165 self.__field_speeddials=LIST(*args,**dict2)
0166
0168
0169 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0170 'Writes this packet to the supplied buffer'
0171 self._bufferstartoffset=buf.getcurrentoffset()
0172 try: self.__field_speeddials
0173 except:
0174 self.__field_speeddials=LIST(**{'length': NUMSPEEDDIALS, 'elementclass': speeddial})
0175 self.__field_speeddials.writetobuffer(buf)
0176 self._bufferendoffset=buf.getcurrentoffset()
0177 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0178
0179
0180 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0181 'Reads this packet from the supplied buffer'
0182 self._bufferstartoffset=buf.getcurrentoffset()
0183 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0184 self.__field_speeddials=LIST(**{'length': NUMSPEEDDIALS, 'elementclass': speeddial})
0185 self.__field_speeddials.readfrombuffer(buf)
0186 self._bufferendoffset=buf.getcurrentoffset()
0187
0188
0189 def __getfield_speeddials(self):
0190 try: self.__field_speeddials
0191 except:
0192 self.__field_speeddials=LIST(**{'length': NUMSPEEDDIALS, 'elementclass': speeddial})
0193 return self.__field_speeddials.getvalue()
0194
0195 def __setfield_speeddials(self, value):
0196 if isinstance(value,LIST):
0197 self.__field_speeddials=value
0198 else:
0199 self.__field_speeddials=LIST(value,**{'length': NUMSPEEDDIALS, 'elementclass': speeddial})
0200
0201 def __delfield_speeddials(self): del self.__field_speeddials
0202
0203 speeddials=property(__getfield_speeddials, __setfield_speeddials, __delfield_speeddials, None)
0204
0205 def iscontainer(self):
0206 return True
0207
0208 def containerelements(self):
0209 yield ('speeddials', self.__field_speeddials, None)
0210
0211
0212
0213
0214 class pbreadentryresponse(BaseProtogenClass):
0215 "Results of reading one entry"
0216 __fields=['header', 'entry']
0217
0218 def __init__(self, *args, **kwargs):
0219 dict={}
0220 dict.update(kwargs)
0222 super(pbreadentryresponse,self).__init__(**dict)
0224 if self.__class__ is pbreadentryresponse:
0225 self._update(args,dict)
0226
0227
0228 def getfields(self):
0229 return self.__fields
0230
0231
0232 def _update(self, args, kwargs):
0233 super(pbreadentryresponse,self)._update(args,kwargs)
0234 keys=kwargs.keys()
0235 for key in keys:
0236 if key in self.__fields:
0237 setattr(self, key, kwargs[key])
0238 del kwargs[key]
0239 if __debug__:
0241 self._complainaboutunusedargs(pbreadentryresponse,kwargs)
0242 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0243
0245
0246 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0247 'Writes this packet to the supplied buffer'
0248 self._bufferstartoffset=buf.getcurrentoffset()
0249 self.__field_header.writetobuffer(buf)
0250 self.__field_entry.writetobuffer(buf)
0251 self._bufferendoffset=buf.getcurrentoffset()
0252 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0253
0254
0255 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0256 'Reads this packet from the supplied buffer'
0257 self._bufferstartoffset=buf.getcurrentoffset()
0258 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0259 self.__field_header=pbheader()
0260 self.__field_header.readfrombuffer(buf)
0261 self.__field_entry=pbentry()
0262 self.__field_entry.readfrombuffer(buf)
0263 self._bufferendoffset=buf.getcurrentoffset()
0264
0265
0266 def __getfield_header(self):
0267 return self.__field_header.getvalue()
0268
0269 def __setfield_header(self, value):
0270 if isinstance(value,pbheader):
0271 self.__field_header=value
0272 else:
0273 self.__field_header=pbheader(value,)
0274
0275 def __delfield_header(self): del self.__field_header
0276
0277 header=property(__getfield_header, __setfield_header, __delfield_header, None)
0278
0279 def __getfield_entry(self):
0280 return self.__field_entry.getvalue()
0281
0282 def __setfield_entry(self, value):
0283 if isinstance(value,pbentry):
0284 self.__field_entry=value
0285 else:
0286 self.__field_entry=pbentry(value,)
0287
0288 def __delfield_entry(self): del self.__field_entry
0289
0290 entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None)
0291
0292 def iscontainer(self):
0293 return True
0294
0295 def containerelements(self):
0296 yield ('header', self.__field_header, None)
0297 yield ('entry', self.__field_entry, None)
0298
0299
0300
0301
0302 class pbupdateentryrequest(BaseProtogenClass):
0303 __fields=['header', 'entry']
0304
0305 def __init__(self, *args, **kwargs):
0306 dict={}
0307 dict.update(kwargs)
0309 super(pbupdateentryrequest,self).__init__(**dict)
0311 if self.__class__ is pbupdateentryrequest:
0312 self._update(args,dict)
0313
0314
0315 def getfields(self):
0316 return self.__fields
0317
0318
0319 def _update(self, args, kwargs):
0320 super(pbupdateentryrequest,self)._update(args,kwargs)
0321 keys=kwargs.keys()
0322 for key in keys:
0323 if key in self.__fields:
0324 setattr(self, key, kwargs[key])
0325 del kwargs[key]
0326 if __debug__:
0328 self._complainaboutunusedargs(pbupdateentryrequest,kwargs)
0329 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0330
0332
0333 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0334 'Writes this packet to the supplied buffer'
0335 self._bufferstartoffset=buf.getcurrentoffset()
0336 try: self.__field_header
0337 except:
0338 self.__field_header=pbheader(**{'command': 0x04, 'flag': 0x01})
0339 self.__field_header.writetobuffer(buf)
0340 self.__field_entry.writetobuffer(buf)
0341 self._bufferendoffset=buf.getcurrentoffset()
0342 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0343
0344
0345 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0346 'Reads this packet from the supplied buffer'
0347 self._bufferstartoffset=buf.getcurrentoffset()
0348 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0349 self.__field_header=pbheader(**{'command': 0x04, 'flag': 0x01})
0350 self.__field_header.readfrombuffer(buf)
0351 self.__field_entry=pbentry()
0352 self.__field_entry.readfrombuffer(buf)
0353 self._bufferendoffset=buf.getcurrentoffset()
0354
0355
0356 def __getfield_header(self):
0357 try: self.__field_header
0358 except:
0359 self.__field_header=pbheader(**{'command': 0x04, 'flag': 0x01})
0360 return self.__field_header.getvalue()
0361
0362 def __setfield_header(self, value):
0363 if isinstance(value,pbheader):
0364 self.__field_header=value
0365 else:
0366 self.__field_header=pbheader(value,**{'command': 0x04, 'flag': 0x01})
0367
0368 def __delfield_header(self): del self.__field_header
0369
0370 header=property(__getfield_header, __setfield_header, __delfield_header, None)
0371
0372 def __getfield_entry(self):
0373 return self.__field_entry.getvalue()
0374
0375 def __setfield_entry(self, value):
0376 if isinstance(value,pbentry):
0377 self.__field_entry=value
0378 else:
0379 self.__field_entry=pbentry(value,)
0380
0381 def __delfield_entry(self): del self.__field_entry
0382
0383 entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None)
0384
0385 def iscontainer(self):
0386 return True
0387
0388 def containerelements(self):
0389 yield ('header', self.__field_header, None)
0390 yield ('entry', self.__field_entry, None)
0391
0392
0393
0394
0395 class pbappendentryrequest(BaseProtogenClass):
0396 __fields=['header', 'entry']
0397
0398 def __init__(self, *args, **kwargs):
0399 dict={}
0400 dict.update(kwargs)
0402 super(pbappendentryrequest,self).__init__(**dict)
0404 if self.__class__ is pbappendentryrequest:
0405 self._update(args,dict)
0406
0407
0408 def getfields(self):
0409 return self.__fields
0410
0411
0412 def _update(self, args, kwargs):
0413 super(pbappendentryrequest,self)._update(args,kwargs)
0414 keys=kwargs.keys()
0415 for key in keys:
0416 if key in self.__fields:
0417 setattr(self, key, kwargs[key])
0418 del kwargs[key]
0419 if __debug__:
0421 self._complainaboutunusedargs(pbappendentryrequest,kwargs)
0422 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0423
0425
0426 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0427 'Writes this packet to the supplied buffer'
0428 self._bufferstartoffset=buf.getcurrentoffset()
0429 try: self.__field_header
0430 except:
0431 self.__field_header=pbheader(**{'command': 0x03, 'flag': 0x01})
0432 self.__field_header.writetobuffer(buf)
0433 self.__field_entry.writetobuffer(buf)
0434 self._bufferendoffset=buf.getcurrentoffset()
0435 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0436
0437
0438 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0439 'Reads this packet from the supplied buffer'
0440 self._bufferstartoffset=buf.getcurrentoffset()
0441 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0442 self.__field_header=pbheader(**{'command': 0x03, 'flag': 0x01})
0443 self.__field_header.readfrombuffer(buf)
0444 self.__field_entry=pbentry()
0445 self.__field_entry.readfrombuffer(buf)
0446 self._bufferendoffset=buf.getcurrentoffset()
0447
0448
0449 def __getfield_header(self):
0450 try: self.__field_header
0451 except:
0452 self.__field_header=pbheader(**{'command': 0x03, 'flag': 0x01})
0453 return self.__field_header.getvalue()
0454
0455 def __setfield_header(self, value):
0456 if isinstance(value,pbheader):
0457 self.__field_header=value
0458 else:
0459 self.__field_header=pbheader(value,**{'command': 0x03, 'flag': 0x01})
0460
0461 def __delfield_header(self): del self.__field_header
0462
0463 header=property(__getfield_header, __setfield_header, __delfield_header, None)
0464
0465 def __getfield_entry(self):
0466 return self.__field_entry.getvalue()
0467
0468 def __setfield_entry(self, value):
0469 if isinstance(value,pbentry):
0470 self.__field_entry=value
0471 else:
0472 self.__field_entry=pbentry(value,)
0473
0474 def __delfield_entry(self): del self.__field_entry
0475
0476 entry=property(__getfield_entry, __setfield_entry, __delfield_entry, None)
0477
0478 def iscontainer(self):
0479 return True
0480
0481 def containerelements(self):
0482 yield ('header', self.__field_header, None)
0483 yield ('entry', self.__field_entry, None)
0484
0485
0486
0487
0488 class pbentry(BaseProtogenClass):
0489 __fields=['serial1', 'entrysize', 'serial2', 'entrynumber', 'name', 'group', 'emails', 'url', 'ringtone', 'msgringtone', 'secret', 'memo', 'wallpaper', 'numbertypes', 'numbers', 'unknown20c']
0490
0491 def __init__(self, *args, **kwargs):
0492 dict={}
0493 dict.update(kwargs)
0495 super(pbentry,self).__init__(**dict)
0497 if self.__class__ is pbentry:
0498 self._update(args,dict)
0499
0500
0501 def getfields(self):
0502 return self.__fields
0503
0504
0505 def _update(self, args, kwargs):
0506 super(pbentry,self)._update(args,kwargs)
0507 keys=kwargs.keys()
0508 for key in keys:
0509 if key in self.__fields:
0510 setattr(self, key, kwargs[key])
0511 del kwargs[key]
0512 if __debug__:
0514 self._complainaboutunusedargs(pbentry,kwargs)
0515 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0516
0518
0519 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0520 'Writes this packet to the supplied buffer'
0521 self._bufferstartoffset=buf.getcurrentoffset()
0522 self.__field_serial1.writetobuffer(buf)
0523 try: self.__field_entrysize
0524 except:
0525 self.__field_entrysize=UINT(**{'sizeinbytes': 2, 'constant': 0x0202})
0526 self.__field_entrysize.writetobuffer(buf)
0527 self.__field_serial2.writetobuffer(buf)
0528 self.__field_entrynumber.writetobuffer(buf)
0529 self.__field_name.writetobuffer(buf)
0530 self.__field_group.writetobuffer(buf)
0531 try: self.__field_emails
0532 except:
0533 self.__field_emails=LIST(**{'elementclass': _gen_p_lgvx3200_79, 'length': NUMEMAILS})
0534 self.__field_emails.writetobuffer(buf)
0535 self.__field_url.writetobuffer(buf)
0536 self.__field_ringtone.writetobuffer(buf)
0537 self.__field_msgringtone.writetobuffer(buf)
0538 self.__field_secret.writetobuffer(buf)
0539 self.__field_memo.writetobuffer(buf)
0540 self.__field_wallpaper.writetobuffer(buf)
0541 try: self.__field_numbertypes
0542 except:
0543 self.__field_numbertypes=LIST(**{'elementclass': _gen_p_lgvx3200_87, 'length': NUMPHONENUMBERS})
0544 self.__field_numbertypes.writetobuffer(buf)
0545 try: self.__field_numbers
0546 except:
0547 self.__field_numbers=LIST(**{'elementclass': _gen_p_lgvx3200_89, 'length': NUMPHONENUMBERS})
0548 self.__field_numbers.writetobuffer(buf)
0549 try: self.__field_unknown20c
0550 except:
0551 self.__field_unknown20c=UNKNOWN()
0552 self.__field_unknown20c.writetobuffer(buf)
0553 self._bufferendoffset=buf.getcurrentoffset()
0554 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0555
0556
0557 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0558 'Reads this packet from the supplied buffer'
0559 self._bufferstartoffset=buf.getcurrentoffset()
0560 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0561 self.__field_serial1=UINT(**{'sizeinbytes': 4})
0562 self.__field_serial1.readfrombuffer(buf)
0563 self.__field_entrysize=UINT(**{'sizeinbytes': 2, 'constant': 0x0202})
0564 self.__field_entrysize.readfrombuffer(buf)
0565 self.__field_serial2=UINT(**{'sizeinbytes': 4})
0566 self.__field_serial2.readfrombuffer(buf)
0567 self.__field_entrynumber=UINT(**{'sizeinbytes': 2})
0568 self.__field_entrynumber.readfrombuffer(buf)
0569 self.__field_name=USTRING(**{'sizeinbytes': 23, 'raiseonunterminatedread': False})
0570 self.__field_name.readfrombuffer(buf)
0571 self.__field_group=UINT(**{'sizeinbytes': 2})
0572 self.__field_group.readfrombuffer(buf)
0573 self.__field_emails=LIST(**{'elementclass': _gen_p_lgvx3200_79, 'length': NUMEMAILS})
0574 self.__field_emails.readfrombuffer(buf)
0575 self.__field_url=USTRING(**{'sizeinbytes': 49, 'raiseonunterminatedread': False})
0576 self.__field_url.readfrombuffer(buf)
0577 self.__field_ringtone=UINT(**{'sizeinbytes': 1})
0578 self.__field_ringtone.readfrombuffer(buf)
0579 self.__field_msgringtone=UINT(**{'sizeinbytes': 1})
0580 self.__field_msgringtone.readfrombuffer(buf)
0581 self.__field_secret=BOOL(**{'sizeinbytes': 1})
0582 self.__field_secret.readfrombuffer(buf)
0583 self.__field_memo=USTRING(**{'raiseonunterminatedread': False, 'sizeinbytes': MEMOLENGTH})
0584 self.__field_memo.readfrombuffer(buf)
0585 self.__field_wallpaper=UINT(**{'sizeinbytes': 1})
0586 self.__field_wallpaper.readfrombuffer(buf)
0587 self.__field_numbertypes=LIST(**{'elementclass': _gen_p_lgvx3200_87, 'length': NUMPHONENUMBERS})
0588 self.__field_numbertypes.readfrombuffer(buf)
0589 self.__field_numbers=LIST(**{'elementclass': _gen_p_lgvx3200_89, 'length': NUMPHONENUMBERS})
0590 self.__field_numbers.readfrombuffer(buf)
0591 self.__field_unknown20c=UNKNOWN()
0592 self.__field_unknown20c.readfrombuffer(buf)
0593 self._bufferendoffset=buf.getcurrentoffset()
0594
0595
0596 def __getfield_serial1(self):
0597 return self.__field_serial1.getvalue()
0598
0599 def __setfield_serial1(self, value):
0600 if isinstance(value,UINT):
0601 self.__field_serial1=value
0602 else:
0603 self.__field_serial1=UINT(value,**{'sizeinbytes': 4})
0604
0605 def __delfield_serial1(self): del self.__field_serial1
0606
0607 serial1=property(__getfield_serial1, __setfield_serial1, __delfield_serial1, None)
0608
0609 def __getfield_entrysize(self):
0610 try: self.__field_entrysize
0611 except:
0612 self.__field_entrysize=UINT(**{'sizeinbytes': 2, 'constant': 0x0202})
0613 return self.__field_entrysize.getvalue()
0614
0615 def __setfield_entrysize(self, value):
0616 if isinstance(value,UINT):
0617 self.__field_entrysize=value
0618 else:
0619 self.__field_entrysize=UINT(value,**{'sizeinbytes': 2, 'constant': 0x0202})
0620
0621 def __delfield_entrysize(self): del self.__field_entrysize
0622
0623 entrysize=property(__getfield_entrysize, __setfield_entrysize, __delfield_entrysize, None)
0624
0625 def __getfield_serial2(self):
0626 return self.__field_serial2.getvalue()
0627
0628 def __setfield_serial2(self, value):
0629 if isinstance(value,UINT):
0630 self.__field_serial2=value
0631 else:
0632 self.__field_serial2=UINT(value,**{'sizeinbytes': 4})
0633
0634 def __delfield_serial2(self): del self.__field_serial2
0635
0636 serial2=property(__getfield_serial2, __setfield_serial2, __delfield_serial2, None)
0637
0638 def __getfield_entrynumber(self):
0639 return self.__field_entrynumber.getvalue()
0640
0641 def __setfield_entrynumber(self, value):
0642 if isinstance(value,UINT):
0643 self.__field_entrynumber=value
0644 else:
0645 self.__field_entrynumber=UINT(value,**{'sizeinbytes': 2})
0646
0647 def __delfield_entrynumber(self): del self.__field_entrynumber
0648
0649 entrynumber=property(__getfield_entrynumber, __setfield_entrynumber, __delfield_entrynumber, None)
0650
0651 def __getfield_name(self):
0652 return self.__field_name.getvalue()
0653
0654 def __setfield_name(self, value):
0655 if isinstance(value,USTRING):
0656 self.__field_name=value
0657 else:
0658 self.__field_name=USTRING(value,**{'sizeinbytes': 23, 'raiseonunterminatedread': False})
0659
0660 def __delfield_name(self): del self.__field_name
0661
0662 name=property(__getfield_name, __setfield_name, __delfield_name, None)
0663
0664 def __getfield_group(self):
0665 return self.__field_group.getvalue()
0666
0667 def __setfield_group(self, value):
0668 if isinstance(value,UINT):
0669 self.__field_group=value
0670 else:
0671 self.__field_group=UINT(value,**{'sizeinbytes': 2})
0672
0673 def __delfield_group(self): del self.__field_group
0674
0675 group=property(__getfield_group, __setfield_group, __delfield_group, None)
0676
0677 def __getfield_emails(self):
0678 try: self.__field_emails
0679 except:
0680 self.__field_emails=LIST(**{'elementclass': _gen_p_lgvx3200_79, 'length': NUMEMAILS})
0681 return self.__field_emails.getvalue()
0682
0683 def __setfield_emails(self, value):
0684 if isinstance(value,LIST):
0685 self.__field_emails=value
0686 else:
0687 self.__field_emails=LIST(value,**{'elementclass': _gen_p_lgvx3200_79, 'length': NUMEMAILS})
0688
0689 def __delfield_emails(self): del self.__field_emails
0690
0691 emails=property(__getfield_emails, __setfield_emails, __delfield_emails, None)
0692
0693 def __getfield_url(self):
0694 return self.__field_url.getvalue()
0695
0696 def __setfield_url(self, value):
0697 if isinstance(value,USTRING):
0698 self.__field_url=value
0699 else:
0700 self.__field_url=USTRING(value,**{'sizeinbytes': 49, 'raiseonunterminatedread': False})
0701
0702 def __delfield_url(self): del self.__field_url
0703
0704 url=property(__getfield_url, __setfield_url, __delfield_url, None)
0705
0706 def __getfield_ringtone(self):
0707 return self.__field_ringtone.getvalue()
0708
0709 def __setfield_ringtone(self, value):
0710 if isinstance(value,UINT):
0711 self.__field_ringtone=value
0712 else:
0713 self.__field_ringtone=UINT(value,**{'sizeinbytes': 1})
0714
0715 def __delfield_ringtone(self): del self.__field_ringtone
0716
0717 ringtone=property(__getfield_ringtone, __setfield_ringtone, __delfield_ringtone, "ringtone index for a call")
0718
0719 def __getfield_msgringtone(self):
0720 return self.__field_msgringtone.getvalue()
0721
0722 def __setfield_msgringtone(self, value):
0723 if isinstance(value,UINT):
0724 self.__field_msgringtone=value
0725 else:
0726 self.__field_msgringtone=UINT(value,**{'sizeinbytes': 1})
0727
0728 def __delfield_msgringtone(self): del self.__field_msgringtone
0729
0730 msgringtone=property(__getfield_msgringtone, __setfield_msgringtone, __delfield_msgringtone, "ringtone index for a text message")
0731
0732 def __getfield_secret(self):
0733 return self.__field_secret.getvalue()
0734
0735 def __setfield_secret(self, value):
0736 if isinstance(value,BOOL):
0737 self.__field_secret=value
0738 else:
0739 self.__field_secret=BOOL(value,**{'sizeinbytes': 1})
0740
0741 def __delfield_secret(self): del self.__field_secret
0742
0743 secret=property(__getfield_secret, __setfield_secret, __delfield_secret, None)
0744
0745 def __getfield_memo(self):
0746 return self.__field_memo.getvalue()
0747
0748 def __setfield_memo(self, value):
0749 if isinstance(value,USTRING):
0750 self.__field_memo=value
0751 else:
0752 self.__field_memo=USTRING(value,**{'raiseonunterminatedread': False, 'sizeinbytes': MEMOLENGTH})
0753
0754 def __delfield_memo(self): del self.__field_memo
0755
0756 memo=property(__getfield_memo, __setfield_memo, __delfield_memo, None)
0757
0758 def __getfield_wallpaper(self):
0759 return self.__field_wallpaper.getvalue()
0760
0761 def __setfield_wallpaper(self, value):
0762 if isinstance(value,UINT):
0763 self.__field_wallpaper=value
0764 else:
0765 self.__field_wallpaper=UINT(value,**{'sizeinbytes': 1})
0766
0767 def __delfield_wallpaper(self): del self.__field_wallpaper
0768
0769 wallpaper=property(__getfield_wallpaper, __setfield_wallpaper, __delfield_wallpaper, None)
0770
0771 def __getfield_numbertypes(self):
0772 try: self.__field_numbertypes
0773 except:
0774 self.__field_numbertypes=LIST(**{'elementclass': _gen_p_lgvx3200_87, 'length': NUMPHONENUMBERS})
0775 return self.__field_numbertypes.getvalue()
0776
0777 def __setfield_numbertypes(self, value):
0778 if isinstance(value,LIST):
0779 self.__field_numbertypes=value
0780 else:
0781 self.__field_numbertypes=LIST(value,**{'elementclass': _gen_p_lgvx3200_87, 'length': NUMPHONENUMBERS})
0782
0783 def __delfield_numbertypes(self): del self.__field_numbertypes
0784
0785 numbertypes=property(__getfield_numbertypes, __setfield_numbertypes, __delfield_numbertypes, None)
0786
0787 def __getfield_numbers(self):
0788 try: self.__field_numbers
0789 except:
0790 self.__field_numbers=LIST(**{'elementclass': _gen_p_lgvx3200_89, 'length': NUMPHONENUMBERS})
0791 return self.__field_numbers.getvalue()
0792
0793 def __setfield_numbers(self, value):
0794 if isinstance(value,LIST):
0795 self.__field_numbers=value
0796 else:
0797 self.__field_numbers=LIST(value,**{'elementclass': _gen_p_lgvx3200_89, 'length': NUMPHONENUMBERS})
0798
0799 def __delfield_numbers(self): del self.__field_numbers
0800
0801 numbers=property(__getfield_numbers, __setfield_numbers, __delfield_numbers, None)
0802
0803 def __getfield_unknown20c(self):
0804 try: self.__field_unknown20c
0805 except:
0806 self.__field_unknown20c=UNKNOWN()
0807 return self.__field_unknown20c.getvalue()
0808
0809 def __setfield_unknown20c(self, value):
0810 if isinstance(value,UNKNOWN):
0811 self.__field_unknown20c=value
0812 else:
0813 self.__field_unknown20c=UNKNOWN(value,)
0814
0815 def __delfield_unknown20c(self): del self.__field_unknown20c
0816
0817 unknown20c=property(__getfield_unknown20c, __setfield_unknown20c, __delfield_unknown20c, None)
0818
0819 def iscontainer(self):
0820 return True
0821
0822 def containerelements(self):
0823 yield ('serial1', self.__field_serial1, None)
0824 yield ('entrysize', self.__field_entrysize, None)
0825 yield ('serial2', self.__field_serial2, None)
0826 yield ('entrynumber', self.__field_entrynumber, None)
0827 yield ('name', self.__field_name, None)
0828 yield ('group', self.__field_group, None)
0829 yield ('emails', self.__field_emails, None)
0830 yield ('url', self.__field_url, None)
0831 yield ('ringtone', self.__field_ringtone, "ringtone index for a call")
0832 yield ('msgringtone', self.__field_msgringtone, "ringtone index for a text message")
0833 yield ('secret', self.__field_secret, None)
0834 yield ('memo', self.__field_memo, None)
0835 yield ('wallpaper', self.__field_wallpaper, None)
0836 yield ('numbertypes', self.__field_numbertypes, None)
0837 yield ('numbers', self.__field_numbers, None)
0838 yield ('unknown20c', self.__field_unknown20c, None)
0839
0840
0841
0842
0843 class _gen_p_lgvx3200_79(BaseProtogenClass):
0844 'Anonymous inner class'
0845 __fields=['email']
0846
0847 def __init__(self, *args, **kwargs):
0848 dict={}
0849 dict.update(kwargs)
0851 super(_gen_p_lgvx3200_79,self).__init__(**dict)
0853 if self.__class__ is _gen_p_lgvx3200_79:
0854 self._update(args,dict)
0855
0856
0857 def getfields(self):
0858 return self.__fields
0859
0860
0861 def _update(self, args, kwargs):
0862 super(_gen_p_lgvx3200_79,self)._update(args,kwargs)
0863 keys=kwargs.keys()
0864 for key in keys:
0865 if key in self.__fields:
0866 setattr(self, key, kwargs[key])
0867 del kwargs[key]
0868 if __debug__:
0870 self._complainaboutunusedargs(_gen_p_lgvx3200_79,kwargs)
0871 if len(args):
0872 dict2={'sizeinbytes': 49, 'raiseonunterminatedread': False}
0873 dict2.update(kwargs)
0874 kwargs=dict2
0875 self.__field_email=USTRING(*args,**dict2)
0876
0878
0879 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0880 'Writes this packet to the supplied buffer'
0881 self._bufferstartoffset=buf.getcurrentoffset()
0882 self.__field_email.writetobuffer(buf)
0883 self._bufferendoffset=buf.getcurrentoffset()
0884 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0885
0886
0887 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0888 'Reads this packet from the supplied buffer'
0889 self._bufferstartoffset=buf.getcurrentoffset()
0890 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0891 self.__field_email=USTRING(**{'sizeinbytes': 49, 'raiseonunterminatedread': False})
0892 self.__field_email.readfrombuffer(buf)
0893 self._bufferendoffset=buf.getcurrentoffset()
0894
0895
0896 def __getfield_email(self):
0897 return self.__field_email.getvalue()
0898
0899 def __setfield_email(self, value):
0900 if isinstance(value,USTRING):
0901 self.__field_email=value
0902 else:
0903 self.__field_email=USTRING(value,**{'sizeinbytes': 49, 'raiseonunterminatedread': False})
0904
0905 def __delfield_email(self): del self.__field_email
0906
0907 email=property(__getfield_email, __setfield_email, __delfield_email, None)
0908
0909 def iscontainer(self):
0910 return True
0911
0912 def containerelements(self):
0913 yield ('email', self.__field_email, None)
0914
0915
0916
0917
0918 class _gen_p_lgvx3200_87(BaseProtogenClass):
0919 'Anonymous inner class'
0920 __fields=['numbertype']
0921
0922 def __init__(self, *args, **kwargs):
0923 dict={}
0924 dict.update(kwargs)
0926 super(_gen_p_lgvx3200_87,self).__init__(**dict)
0928 if self.__class__ is _gen_p_lgvx3200_87:
0929 self._update(args,dict)
0930
0931
0932 def getfields(self):
0933 return self.__fields
0934
0935
0936 def _update(self, args, kwargs):
0937 super(_gen_p_lgvx3200_87,self)._update(args,kwargs)
0938 keys=kwargs.keys()
0939 for key in keys:
0940 if key in self.__fields:
0941 setattr(self, key, kwargs[key])
0942 del kwargs[key]
0943 if __debug__:
0945 self._complainaboutunusedargs(_gen_p_lgvx3200_87,kwargs)
0946 if len(args):
0947 dict2={'sizeinbytes': 1}
0948 dict2.update(kwargs)
0949 kwargs=dict2
0950 self.__field_numbertype=UINT(*args,**dict2)
0951
0953
0954 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0955 'Writes this packet to the supplied buffer'
0956 self._bufferstartoffset=buf.getcurrentoffset()
0957 self.__field_numbertype.writetobuffer(buf)
0958 self._bufferendoffset=buf.getcurrentoffset()
0959 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0960
0961
0962 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0963 'Reads this packet from the supplied buffer'
0964 self._bufferstartoffset=buf.getcurrentoffset()
0965 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0966 self.__field_numbertype=UINT(**{'sizeinbytes': 1})
0967 self.__field_numbertype.readfrombuffer(buf)
0968 self._bufferendoffset=buf.getcurrentoffset()
0969
0970
0971 def __getfield_numbertype(self):
0972 return self.__field_numbertype.getvalue()
0973
0974 def __setfield_numbertype(self, value):
0975 if isinstance(value,UINT):
0976 self.__field_numbertype=value
0977 else:
0978 self.__field_numbertype=UINT(value,**{'sizeinbytes': 1})
0979
0980 def __delfield_numbertype(self): del self.__field_numbertype
0981
0982 numbertype=property(__getfield_numbertype, __setfield_numbertype, __delfield_numbertype, None)
0983
0984 def iscontainer(self):
0985 return True
0986
0987 def containerelements(self):
0988 yield ('numbertype', self.__field_numbertype, None)
0989
0990
0991
0992
0993 class _gen_p_lgvx3200_89(BaseProtogenClass):
0994 'Anonymous inner class'
0995 __fields=['number']
0996
0997 def __init__(self, *args, **kwargs):
0998 dict={}
0999 dict.update(kwargs)
1001 super(_gen_p_lgvx3200_89,self).__init__(**dict)
1003 if self.__class__ is _gen_p_lgvx3200_89:
1004 self._update(args,dict)
1005
1006
1007 def getfields(self):
1008 return self.__fields
1009
1010
1011 def _update(self, args, kwargs):
1012 super(_gen_p_lgvx3200_89,self)._update(args,kwargs)
1013 keys=kwargs.keys()
1014 for key in keys:
1015 if key in self.__fields:
1016 setattr(self, key, kwargs[key])
1017 del kwargs[key]
1018 if __debug__:
1020 self._complainaboutunusedargs(_gen_p_lgvx3200_89,kwargs)
1021 if len(args):
1022 dict2={'sizeinbytes': 49, 'raiseonunterminatedread': False}
1023 dict2.update(kwargs)
1024 kwargs=dict2
1025 self.__field_number=USTRING(*args,**dict2)
1026
1028
1029 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1030 'Writes this packet to the supplied buffer'
1031 self._bufferstartoffset=buf.getcurrentoffset()
1032 self.__field_number.writetobuffer(buf)
1033 self._bufferendoffset=buf.getcurrentoffset()
1034 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1035
1036
1037 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1038 'Reads this packet from the supplied buffer'
1039 self._bufferstartoffset=buf.getcurrentoffset()
1040 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1041 self.__field_number=USTRING(**{'sizeinbytes': 49, 'raiseonunterminatedread': False})
1042 self.__field_number.readfrombuffer(buf)
1043 self._bufferendoffset=buf.getcurrentoffset()
1044
1045
1046 def __getfield_number(self):
1047 return self.__field_number.getvalue()
1048
1049 def __setfield_number(self, value):
1050 if isinstance(value,USTRING):
1051 self.__field_number=value
1052 else:
1053 self.__field_number=USTRING(value,**{'sizeinbytes': 49, 'raiseonunterminatedread': False})
1054
1055 def __delfield_number(self): del self.__field_number
1056
1057 number=property(__getfield_number, __setfield_number, __delfield_number, None)
1058
1059 def iscontainer(self):
1060 return True
1061
1062 def containerelements(self):
1063 yield ('number', self.__field_number, None)
1064
1065
1066
1067
1068 class pbgroup(BaseProtogenClass):
1069 "A single group"
1070 __fields=['icon', 'name']
1071
1072 def __init__(self, *args, **kwargs):
1073 dict={}
1074 dict.update(kwargs)
1076 super(pbgroup,self).__init__(**dict)
1078 if self.__class__ is pbgroup:
1079 self._update(args,dict)
1080
1081
1082 def getfields(self):
1083 return self.__fields
1084
1085
1086 def _update(self, args, kwargs):
1087 super(pbgroup,self)._update(args,kwargs)
1088 keys=kwargs.keys()
1089 for key in keys:
1090 if key in self.__fields:
1091 setattr(self, key, kwargs[key])
1092 del kwargs[key]
1093 if __debug__:
1095 self._complainaboutunusedargs(pbgroup,kwargs)
1096 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1097
1099
1100 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1101 'Writes this packet to the supplied buffer'
1102 self._bufferstartoffset=buf.getcurrentoffset()
1103 self.__field_icon.writetobuffer(buf)
1104 self.__field_name.writetobuffer(buf)
1105 self._bufferendoffset=buf.getcurrentoffset()
1106 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1107
1108
1109 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1110 'Reads this packet from the supplied buffer'
1111 self._bufferstartoffset=buf.getcurrentoffset()
1112 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1113 self.__field_icon=UINT(**{'sizeinbytes': 1})
1114 self.__field_icon.readfrombuffer(buf)
1115 self.__field_name=USTRING(**{'sizeinbytes': 23})
1116 self.__field_name.readfrombuffer(buf)
1117 self._bufferendoffset=buf.getcurrentoffset()
1118
1119
1120 def __getfield_icon(self):
1121 return self.__field_icon.getvalue()
1122
1123 def __setfield_icon(self, value):
1124 if isinstance(value,UINT):
1125 self.__field_icon=value
1126 else:
1127 self.__field_icon=UINT(value,**{'sizeinbytes': 1})
1128
1129 def __delfield_icon(self): del self.__field_icon
1130
1131 icon=property(__getfield_icon, __setfield_icon, __delfield_icon, None)
1132
1133 def __getfield_name(self):
1134 return self.__field_name.getvalue()
1135
1136 def __setfield_name(self, value):
1137 if isinstance(value,USTRING):
1138 self.__field_name=value
1139 else:
1140 self.__field_name=USTRING(value,**{'sizeinbytes': 23})
1141
1142 def __delfield_name(self): del self.__field_name
1143
1144 name=property(__getfield_name, __setfield_name, __delfield_name, None)
1145
1146 def iscontainer(self):
1147 return True
1148
1149 def containerelements(self):
1150 yield ('icon', self.__field_icon, None)
1151 yield ('name', self.__field_name, None)
1152
1153
1154
1155
1156 class pbgroups(BaseProtogenClass):
1157 "Phonebook groups"
1158 __fields=['groups']
1159
1160 def __init__(self, *args, **kwargs):
1161 dict={}
1162 dict.update(kwargs)
1164 super(pbgroups,self).__init__(**dict)
1166 if self.__class__ is pbgroups:
1167 self._update(args,dict)
1168
1169
1170 def getfields(self):
1171 return self.__fields
1172
1173
1174 def _update(self, args, kwargs):
1175 super(pbgroups,self)._update(args,kwargs)
1176 keys=kwargs.keys()
1177 for key in keys:
1178 if key in self.__fields:
1179 setattr(self, key, kwargs[key])
1180 del kwargs[key]
1181 if __debug__:
1183 self._complainaboutunusedargs(pbgroups,kwargs)
1184 if len(args):
1185 dict2={'elementclass': pbgroup}
1186 dict2.update(kwargs)
1187 kwargs=dict2
1188 self.__field_groups=LIST(*args,**dict2)
1189
1191
1192 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1193 'Writes this packet to the supplied buffer'
1194 self._bufferstartoffset=buf.getcurrentoffset()
1195 try: self.__field_groups
1196 except:
1197 self.__field_groups=LIST(**{'elementclass': pbgroup})
1198 self.__field_groups.writetobuffer(buf)
1199 self._bufferendoffset=buf.getcurrentoffset()
1200 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1201
1202
1203 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1204 'Reads this packet from the supplied buffer'
1205 self._bufferstartoffset=buf.getcurrentoffset()
1206 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1207 self.__field_groups=LIST(**{'elementclass': pbgroup})
1208 self.__field_groups.readfrombuffer(buf)
1209 self._bufferendoffset=buf.getcurrentoffset()
1210
1211
1212 def __getfield_groups(self):
1213 try: self.__field_groups
1214 except:
1215 self.__field_groups=LIST(**{'elementclass': pbgroup})
1216 return self.__field_groups.getvalue()
1217
1218 def __setfield_groups(self, value):
1219 if isinstance(value,LIST):
1220 self.__field_groups=value
1221 else:
1222 self.__field_groups=LIST(value,**{'elementclass': pbgroup})
1223
1224 def __delfield_groups(self): del self.__field_groups
1225
1226 groups=property(__getfield_groups, __setfield_groups, __delfield_groups, None)
1227
1228 def iscontainer(self):
1229 return True
1230
1231 def containerelements(self):
1232 yield ('groups', self.__field_groups, None)
1233
1234
1235
1236
1237 class indexentry(BaseProtogenClass):
1238 __fields=['index', 'name']
1239
1240 def __init__(self, *args, **kwargs):
1241 dict={}
1242 dict.update(kwargs)
1244 super(indexentry,self).__init__(**dict)
1246 if self.__class__ is indexentry:
1247 self._update(args,dict)
1248
1249
1250 def getfields(self):
1251 return self.__fields
1252
1253
1254 def _update(self, args, kwargs):
1255 super(indexentry,self)._update(args,kwargs)
1256 keys=kwargs.keys()
1257 for key in keys:
1258 if key in self.__fields:
1259 setattr(self, key, kwargs[key])
1260 del kwargs[key]
1261 if __debug__:
1263 self._complainaboutunusedargs(indexentry,kwargs)
1264 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1265
1267
1268 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1269 'Writes this packet to the supplied buffer'
1270 self._bufferstartoffset=buf.getcurrentoffset()
1271 try: self.__field_index
1272 except:
1273 self.__field_index=UINT(**{'sizeinbytes': 2, 'default': 0xffff})
1274 self.__field_index.writetobuffer(buf)
1275 try: self.__field_name
1276 except:
1277 self.__field_name=USTRING(**{'sizeinbytes': 40, 'default': ""})
1278 self.__field_name.writetobuffer(buf)
1279 self._bufferendoffset=buf.getcurrentoffset()
1280 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1281
1282
1283 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1284 'Reads this packet from the supplied buffer'
1285 self._bufferstartoffset=buf.getcurrentoffset()
1286 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1287 self.__field_index=UINT(**{'sizeinbytes': 2, 'default': 0xffff})
1288 self.__field_index.readfrombuffer(buf)
1289 self.__field_name=USTRING(**{'sizeinbytes': 40, 'default': ""})
1290 self.__field_name.readfrombuffer(buf)
1291 self._bufferendoffset=buf.getcurrentoffset()
1292
1293
1294 def __getfield_index(self):
1295 try: self.__field_index
1296 except:
1297 self.__field_index=UINT(**{'sizeinbytes': 2, 'default': 0xffff})
1298 return self.__field_index.getvalue()
1299
1300 def __setfield_index(self, value):
1301 if isinstance(value,UINT):
1302 self.__field_index=value
1303 else:
1304 self.__field_index=UINT(value,**{'sizeinbytes': 2, 'default': 0xffff})
1305
1306 def __delfield_index(self): del self.__field_index
1307
1308 index=property(__getfield_index, __setfield_index, __delfield_index, None)
1309
1310 def __getfield_name(self):
1311 try: self.__field_name
1312 except:
1313 self.__field_name=USTRING(**{'sizeinbytes': 40, 'default': ""})
1314 return self.__field_name.getvalue()
1315
1316 def __setfield_name(self, value):
1317 if isinstance(value,USTRING):
1318 self.__field_name=value
1319 else:
1320 self.__field_name=USTRING(value,**{'sizeinbytes': 40, 'default': ""})
1321
1322 def __delfield_name(self): del self.__field_name
1323
1324 name=property(__getfield_name, __setfield_name, __delfield_name, None)
1325
1326 def iscontainer(self):
1327 return True
1328
1329 def containerelements(self):
1330 yield ('index', self.__field_index, None)
1331 yield ('name', self.__field_name, None)
1332
1333
1334
1335
1336 class indexfile(BaseProtogenClass):
1337 "Used for tracking wallpaper and ringtones"
1338 __fields=['maxitems', 'numactiveitems', 'items']
1339
1340 def __init__(self, *args, **kwargs):
1341 dict={}
1342 dict.update(kwargs)
1344 super(indexfile,self).__init__(**dict)
1346 if self.__class__ is indexfile:
1347 self._update(args,dict)
1348
1349
1350 def getfields(self):
1351 return self.__fields
1352
1353
1354 def _update(self, args, kwargs):
1355 super(indexfile,self)._update(args,kwargs)
1356 keys=kwargs.keys()
1357 for key in keys:
1358 if key in self.__fields:
1359 setattr(self, key, kwargs[key])
1360 del kwargs[key]
1361 if __debug__:
1363 self._complainaboutunusedargs(indexfile,kwargs)
1364 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1365 try: self.__field_maxitems
1367 except:
1368 self.__field_maxitems=UINT(**{'constant': 30})
1369
1370
1371 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1372 'Writes this packet to the supplied buffer'
1373 self._bufferstartoffset=buf.getcurrentoffset()
1374 self.__field_numactiveitems.writetobuffer(buf)
1375 try: self.__field_items
1376 except:
1377 self.__field_items=LIST(**{'length': self.maxitems, 'elementclass': indexentry, 'createdefault': True})
1378 self.__field_items.writetobuffer(buf)
1379 self._bufferendoffset=buf.getcurrentoffset()
1380 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1381
1382
1383 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1384 'Reads this packet from the supplied buffer'
1385 self._bufferstartoffset=buf.getcurrentoffset()
1386 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1387 self.__field_numactiveitems=UINT(**{'sizeinbytes': 2})
1388 self.__field_numactiveitems.readfrombuffer(buf)
1389 self.__field_items=LIST(**{'length': self.maxitems, 'elementclass': indexentry, 'createdefault': True})
1390 self.__field_items.readfrombuffer(buf)
1391 self._bufferendoffset=buf.getcurrentoffset()
1392
1393
1394 def __getfield_maxitems(self):
1395 return self.__field_maxitems.getvalue()
1396
1397 def __setfield_maxitems(self, value):
1398 if isinstance(value,UINT):
1399 self.__field_maxitems=value
1400 else:
1401 self.__field_maxitems=UINT(value,**{'constant': 30})
1402
1403 def __delfield_maxitems(self): del self.__field_maxitems
1404
1405 maxitems=property(__getfield_maxitems, __setfield_maxitems, __delfield_maxitems, None)
1406
1407 def __getfield_numactiveitems(self):
1408 return self.__field_numactiveitems.getvalue()
1409
1410 def __setfield_numactiveitems(self, value):
1411 if isinstance(value,UINT):
1412 self.__field_numactiveitems=value
1413 else:
1414 self.__field_numactiveitems=UINT(value,**{'sizeinbytes': 2})
1415
1416 def __delfield_numactiveitems(self): del self.__field_numactiveitems
1417
1418 numactiveitems=property(__getfield_numactiveitems, __setfield_numactiveitems, __delfield_numactiveitems, None)
1419
1420 def __getfield_items(self):
1421 try: self.__field_items
1422 except:
1423 self.__field_items=LIST(**{'length': self.maxitems, 'elementclass': indexentry, 'createdefault': True})
1424 return self.__field_items.getvalue()
1425
1426 def __setfield_items(self, value):
1427 if isinstance(value,LIST):
1428 self.__field_items=value
1429 else:
1430 self.__field_items=LIST(value,**{'length': self.maxitems, 'elementclass': indexentry, 'createdefault': True})
1431
1432 def __delfield_items(self): del self.__field_items
1433
1434 items=property(__getfield_items, __setfield_items, __delfield_items, None)
1435
1436 def iscontainer(self):
1437 return True
1438
1439 def containerelements(self):
1440 yield ('maxitems', self.__field_maxitems, None)
1441 yield ('numactiveitems', self.__field_numactiveitems, None)
1442 yield ('items', self.__field_items, None)
1443
1444
1445
1446
1447 class scheduleexception(BaseProtogenClass):
1448 __fields=['pos', 'day', 'month', 'year']
1449
1450 def __init__(self, *args, **kwargs):
1451 dict={}
1452 dict.update(kwargs)
1454 super(scheduleexception,self).__init__(**dict)
1456 if self.__class__ is scheduleexception:
1457 self._update(args,dict)
1458
1459
1460 def getfields(self):
1461 return self.__fields
1462
1463
1464 def _update(self, args, kwargs):
1465 super(scheduleexception,self)._update(args,kwargs)
1466 keys=kwargs.keys()
1467 for key in keys:
1468 if key in self.__fields:
1469 setattr(self, key, kwargs[key])
1470 del kwargs[key]
1471 if __debug__:
1473 self._complainaboutunusedargs(scheduleexception,kwargs)
1474 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1475
1477
1478 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1479 'Writes this packet to the supplied buffer'
1480 self._bufferstartoffset=buf.getcurrentoffset()
1481 self.__field_pos.writetobuffer(buf)
1482 self.__field_day.writetobuffer(buf)
1483 self.__field_month.writetobuffer(buf)
1484 self.__field_year.writetobuffer(buf)
1485 self._bufferendoffset=buf.getcurrentoffset()
1486 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1487
1488
1489 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1490 'Reads this packet from the supplied buffer'
1491 self._bufferstartoffset=buf.getcurrentoffset()
1492 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1493 self.__field_pos=UINT(**{'sizeinbytes': 4})
1494 self.__field_pos.readfrombuffer(buf)
1495 self.__field_day=UINT(**{'sizeinbytes': 1})
1496 self.__field_day.readfrombuffer(buf)
1497 self.__field_month=UINT(**{'sizeinbytes': 1})
1498 self.__field_month.readfrombuffer(buf)
1499 self.__field_year=UINT(**{'sizeinbytes': 2})
1500 self.__field_year.readfrombuffer(buf)
1501 self._bufferendoffset=buf.getcurrentoffset()
1502
1503
1504 def __getfield_pos(self):
1505 return self.__field_pos.getvalue()
1506
1507 def __setfield_pos(self, value):
1508 if isinstance(value,UINT):
1509 self.__field_pos=value
1510 else:
1511 self.__field_pos=UINT(value,**{'sizeinbytes': 4})
1512
1513 def __delfield_pos(self): del self.__field_pos
1514
1515 pos=property(__getfield_pos, __setfield_pos, __delfield_pos, "Refers to event id (position in schedule file) that this suppresses")
1516
1517 def __getfield_day(self):
1518 return self.__field_day.getvalue()
1519
1520 def __setfield_day(self, value):
1521 if isinstance(value,UINT):
1522 self.__field_day=value
1523 else:
1524 self.__field_day=UINT(value,**{'sizeinbytes': 1})
1525
1526 def __delfield_day(self): del self.__field_day
1527
1528 day=property(__getfield_day, __setfield_day, __delfield_day, None)
1529
1530 def __getfield_month(self):
1531 return self.__field_month.getvalue()
1532
1533 def __setfield_month(self, value):
1534 if isinstance(value,UINT):
1535 self.__field_month=value
1536 else:
1537 self.__field_month=UINT(value,**{'sizeinbytes': 1})
1538
1539 def __delfield_month(self): del self.__field_month
1540
1541 month=property(__getfield_month, __setfield_month, __delfield_month, None)
1542
1543 def __getfield_year(self):
1544 return self.__field_year.getvalue()
1545
1546 def __setfield_year(self, value):
1547 if isinstance(value,UINT):
1548 self.__field_year=value
1549 else:
1550 self.__field_year=UINT(value,**{'sizeinbytes': 2})
1551
1552 def __delfield_year(self): del self.__field_year
1553
1554 year=property(__getfield_year, __setfield_year, __delfield_year, None)
1555
1556 def iscontainer(self):
1557 return True
1558
1559 def containerelements(self):
1560 yield ('pos', self.__field_pos, "Refers to event id (position in schedule file) that this suppresses")
1561 yield ('day', self.__field_day, None)
1562 yield ('month', self.__field_month, None)
1563 yield ('year', self.__field_year, None)
1564
1565
1566
1567
1568 class scheduleexceptionfile(BaseProtogenClass):
1569 __fields=['items']
1570
1571 def __init__(self, *args, **kwargs):
1572 dict={}
1573 dict.update(kwargs)
1575 super(scheduleexceptionfile,self).__init__(**dict)
1577 if self.__class__ is scheduleexceptionfile:
1578 self._update(args,dict)
1579
1580
1581 def getfields(self):
1582 return self.__fields
1583
1584
1585 def _update(self, args, kwargs):
1586 super(scheduleexceptionfile,self)._update(args,kwargs)
1587 keys=kwargs.keys()
1588 for key in keys:
1589 if key in self.__fields:
1590 setattr(self, key, kwargs[key])
1591 del kwargs[key]
1592 if __debug__:
1594 self._complainaboutunusedargs(scheduleexceptionfile,kwargs)
1595 if len(args):
1596 dict2={'elementclass': scheduleexception}
1597 dict2.update(kwargs)
1598 kwargs=dict2
1599 self.__field_items=LIST(*args,**dict2)
1600
1602
1603 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1604 'Writes this packet to the supplied buffer'
1605 self._bufferstartoffset=buf.getcurrentoffset()
1606 try: self.__field_items
1607 except:
1608 self.__field_items=LIST(**{'elementclass': scheduleexception})
1609 self.__field_items.writetobuffer(buf)
1610 self._bufferendoffset=buf.getcurrentoffset()
1611 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1612
1613
1614 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1615 'Reads this packet from the supplied buffer'
1616 self._bufferstartoffset=buf.getcurrentoffset()
1617 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1618 self.__field_items=LIST(**{'elementclass': scheduleexception})
1619 self.__field_items.readfrombuffer(buf)
1620 self._bufferendoffset=buf.getcurrentoffset()
1621
1622
1623 def __getfield_items(self):
1624 try: self.__field_items
1625 except:
1626 self.__field_items=LIST(**{'elementclass': scheduleexception})
1627 return self.__field_items.getvalue()
1628
1629 def __setfield_items(self, value):
1630 if isinstance(value,LIST):
1631 self.__field_items=value
1632 else:
1633 self.__field_items=LIST(value,**{'elementclass': scheduleexception})
1634
1635 def __delfield_items(self): del self.__field_items
1636
1637 items=property(__getfield_items, __setfield_items, __delfield_items, None)
1638
1639 def iscontainer(self):
1640 return True
1641
1642 def containerelements(self):
1643 yield ('items', self.__field_items, None)
1644
1645
1646
1647
1648 class scheduleevent(BaseProtogenClass):
1649 __fields=['pos', 'unknown', 'start', 'end', 'repeat', 'daybitmap', 'alarmminutes', 'alarmhours', 'alarmtype', 'snoozedelay', 'ringtone', 'description']
1650
1651 def __init__(self, *args, **kwargs):
1652 dict={}
1653 dict.update(kwargs)
1655 super(scheduleevent,self).__init__(**dict)
1657 if self.__class__ is scheduleevent:
1658 self._update(args,dict)
1659
1660
1661 def getfields(self):
1662 return self.__fields
1663
1664
1665 def _update(self, args, kwargs):
1666 super(scheduleevent,self)._update(args,kwargs)
1667 keys=kwargs.keys()
1668 for key in keys:
1669 if key in self.__fields:
1670 setattr(self, key, kwargs[key])
1671 del kwargs[key]
1672 if __debug__:
1674 self._complainaboutunusedargs(scheduleevent,kwargs)
1675 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1676
1678
1679 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1680 'Writes this packet to the supplied buffer'
1681 self._bufferstartoffset=buf.getcurrentoffset()
1682 self.__field_pos.writetobuffer(buf)
1683 try: self.__field_unknown
1684 except:
1685 self.__field_unknown=UINT(**{'sizeinbytes': 4, 'default': 0 })
1686 self.__field_unknown.writetobuffer(buf)
1687 self.__field_start.writetobuffer(buf)
1688 self.__field_end.writetobuffer(buf)
1689 self.__field_repeat.writetobuffer(buf)
1690 self.__field_daybitmap.writetobuffer(buf)
1691 self.__field_alarmminutes.writetobuffer(buf)
1692 self.__field_alarmhours.writetobuffer(buf)
1693 self.__field_alarmtype.writetobuffer(buf)
1694 try: self.__field_snoozedelay
1695 except:
1696 self.__field_snoozedelay=UINT(**{'sizeinbytes': 1, 'default': 0 })
1697 self.__field_snoozedelay.writetobuffer(buf)
1698 self.__field_ringtone.writetobuffer(buf)
1699 self.__field_description.writetobuffer(buf)
1700 self._bufferendoffset=buf.getcurrentoffset()
1701 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1702
1703
1704 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1705 'Reads this packet from the supplied buffer'
1706 self._bufferstartoffset=buf.getcurrentoffset()
1707 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1708 self.__field_pos=UINT(**{'sizeinbytes': 4})
1709 self.__field_pos.readfrombuffer(buf)
1710 self.__field_unknown=UINT(**{'sizeinbytes': 4, 'default': 0 })
1711 self.__field_unknown.readfrombuffer(buf)
1712 self.__field_start=LGCALDATE(**{'sizeinbytes': 4})
1713 self.__field_start.readfrombuffer(buf)
1714 self.__field_end=LGCALDATE(**{'sizeinbytes': 4})
1715 self.__field_end.readfrombuffer(buf)
1716 self.__field_repeat=UINT(**{'sizeinbytes': 1})
1717 self.__field_repeat.readfrombuffer(buf)
1718 self.__field_daybitmap=UINT(**{'sizeinbytes': 3})
1719 self.__field_daybitmap.readfrombuffer(buf)
1720 self.__field_alarmminutes=UINT(**{'sizeinbytes': 1})
1721 self.__field_alarmminutes.readfrombuffer(buf)
1722 self.__field_alarmhours=UINT(**{'sizeinbytes': 1})
1723 self.__field_alarmhours.readfrombuffer(buf)
1724 self.__field_alarmtype=UINT(**{'sizeinbytes': 1})
1725 self.__field_alarmtype.readfrombuffer(buf)
1726 self.__field_snoozedelay=UINT(**{'sizeinbytes': 1, 'default': 0 })
1727 self.__field_snoozedelay.readfrombuffer(buf)
1728 self.__field_ringtone=UINT(**{'sizeinbytes': 1})
1729 self.__field_ringtone.readfrombuffer(buf)
1730 self.__field_description=USTRING(**{'sizeinbytes': 39, 'raiseonunterminatedread': False, 'raiseontruncate': False })
1731 self.__field_description.readfrombuffer(buf)
1732 self._bufferendoffset=buf.getcurrentoffset()
1733
1734
1735 def __getfield_pos(self):
1736 return self.__field_pos.getvalue()
1737
1738 def __setfield_pos(self, value):
1739 if isinstance(value,UINT):
1740 self.__field_pos=value
1741 else:
1742 self.__field_pos=UINT(value,**{'sizeinbytes': 4})
1743
1744 def __delfield_pos(self): del self.__field_pos
1745
1746 pos=property(__getfield_pos, __setfield_pos, __delfield_pos, "position within file, used as an event id")
1747
1748 def __getfield_unknown(self):
1749 try: self.__field_unknown
1750 except:
1751 self.__field_unknown=UINT(**{'sizeinbytes': 4, 'default': 0 })
1752 return self.__field_unknown.getvalue()
1753
1754 def __setfield_unknown(self, value):
1755 if isinstance(value,UINT):
1756 self.__field_unknown=value
1757 else:
1758 self.__field_unknown=UINT(value,**{'sizeinbytes': 4, 'default': 0 })
1759
1760 def __delfield_unknown(self): del self.__field_unknown
1761
1762 unknown=property(__getfield_unknown, __setfield_unknown, __delfield_unknown, None)
1763
1764 def __getfield_start(self):
1765 return self.__field_start.getvalue()
1766
1767 def __setfield_start(self, value):
1768 if isinstance(value,LGCALDATE):
1769 self.__field_start=value
1770 else:
1771 self.__field_start=LGCALDATE(value,**{'sizeinbytes': 4})
1772
1773 def __delfield_start(self): del self.__field_start
1774
1775 start=property(__getfield_start, __setfield_start, __delfield_start, None)
1776
1777 def __getfield_end(self):
1778 return self.__field_end.getvalue()
1779
1780 def __setfield_end(self, value):
1781 if isinstance(value,LGCALDATE):
1782 self.__field_end=value
1783 else:
1784 self.__field_end=LGCALDATE(value,**{'sizeinbytes': 4})
1785
1786 def __delfield_end(self): del self.__field_end
1787
1788 end=property(__getfield_end, __setfield_end, __delfield_end, None)
1789
1790 def __getfield_repeat(self):
1791 return self.__field_repeat.getvalue()
1792
1793 def __setfield_repeat(self, value):
1794 if isinstance(value,UINT):
1795 self.__field_repeat=value
1796 else:
1797 self.__field_repeat=UINT(value,**{'sizeinbytes': 1})
1798
1799 def __delfield_repeat(self): del self.__field_repeat
1800
1801 repeat=property(__getfield_repeat, __setfield_repeat, __delfield_repeat, None)
1802
1803 def __getfield_daybitmap(self):
1804 return self.__field_daybitmap.getvalue()
1805
1806 def __setfield_daybitmap(self, value):
1807 if isinstance(value,UINT):
1808 self.__field_daybitmap=value
1809 else:
1810 self.__field_daybitmap=UINT(value,**{'sizeinbytes': 3})
1811
1812 def __delfield_daybitmap(self): del self.__field_daybitmap
1813
1814 daybitmap=property(__getfield_daybitmap, __setfield_daybitmap, __delfield_daybitmap, "which days a weekly repeat event happens on")
1815
1816 def __getfield_alarmminutes(self):
1817 return self.__field_alarmminutes.getvalue()
1818
1819 def __setfield_alarmminutes(self, value):
1820 if isinstance(value,UINT):
1821 self.__field_alarmminutes=value
1822 else:
1823 self.__field_alarmminutes=UINT(value,**{'sizeinbytes': 1})
1824
1825 def __delfield_alarmminutes(self): del self.__field_alarmminutes
1826
1827 alarmminutes=property(__getfield_alarmminutes, __setfield_alarmminutes, __delfield_alarmminutes, "a value of 100 indicates not set")
1828
1829 def __getfield_alarmhours(self):
1830 return self.__field_alarmhours.getvalue()
1831
1832 def __setfield_alarmhours(self, value):
1833 if isinstance(value,UINT):
1834 self.__field_alarmhours=value
1835 else:
1836 self.__field_alarmhours=UINT(value,**{'sizeinbytes': 1})
1837
1838 def __delfield_alarmhours(self): del self.__field_alarmhours
1839
1840 alarmhours=property(__getfield_alarmhours, __setfield_alarmhours, __delfield_alarmhours, "a value of 100 indicates not set")
1841
1842 def __getfield_alarmtype(self):
1843 return self.__field_alarmtype.getvalue()
1844
1845 def __setfield_alarmtype(self, value):
1846 if isinstance(value,UINT):
1847 self.__field_alarmtype=value
1848 else:
1849 self.__field_alarmtype=UINT(value,**{'sizeinbytes': 1})
1850
1851 def __delfield_alarmtype(self): del self.__field_alarmtype
1852
1853 alarmtype=property(__getfield_alarmtype, __setfield_alarmtype, __delfield_alarmtype, None)
1854
1855 def __getfield_snoozedelay(self):
1856 try: self.__field_snoozedelay
1857 except:
1858 self.__field_snoozedelay=UINT(**{'sizeinbytes': 1, 'default': 0 })
1859 return self.__field_snoozedelay.getvalue()
1860
1861 def __setfield_snoozedelay(self, value):
1862 if isinstance(value,UINT):
1863 self.__field_snoozedelay=value
1864 else:
1865 self.__field_snoozedelay=UINT(value,**{'sizeinbytes': 1, 'default': 0 })
1866
1867 def __delfield_snoozedelay(self): del self.__field_snoozedelay
1868
1869 snoozedelay=property(__getfield_snoozedelay, __setfield_snoozedelay, __delfield_snoozedelay, None)
1870
1871 def __getfield_ringtone(self):
1872 return self.__field_ringtone.getvalue()
1873
1874 def __setfield_ringtone(self, value):
1875 if isinstance(value,UINT):
1876 self.__field_ringtone=value
1877 else:
1878 self.__field_ringtone=UINT(value,**{'sizeinbytes': 1})
1879
1880 def __delfield_ringtone(self): del self.__field_ringtone
1881
1882 ringtone=property(__getfield_ringtone, __setfield_ringtone, __delfield_ringtone, None)
1883
1884 def __getfield_description(self):
1885 return self.__field_description.getvalue()
1886
1887 def __setfield_description(self, value):
1888 if isinstance(value,USTRING):
1889 self.__field_description=value
1890 else:
1891 self.__field_description=USTRING(value,**{'sizeinbytes': 39, 'raiseonunterminatedread': False, 'raiseontruncate': False })
1892
1893 def __delfield_description(self): del self.__field_description
1894
1895 description=property(__getfield_description, __setfield_description, __delfield_description, None)
1896
1897 def iscontainer(self):
1898 return True
1899
1900 def containerelements(self):
1901 yield ('pos', self.__field_pos, "position within file, used as an event id")
1902 yield ('unknown', self.__field_unknown, None)
1903 yield ('start', self.__field_start, None)
1904 yield ('end', self.__field_end, None)
1905 yield ('repeat', self.__field_repeat, None)
1906 yield ('daybitmap', self.__field_daybitmap, "which days a weekly repeat event happens on")
1907 yield ('alarmminutes', self.__field_alarmminutes, "a value of 100 indicates not set")
1908 yield ('alarmhours', self.__field_alarmhours, "a value of 100 indicates not set")
1909 yield ('alarmtype', self.__field_alarmtype, None)
1910 yield ('snoozedelay', self.__field_snoozedelay, None)
1911 yield ('ringtone', self.__field_ringtone, None)
1912 yield ('description', self.__field_description, None)
1913
1914
1915
1916
1917 class schedulefile(BaseProtogenClass):
1918 __fields=['numactiveitems', 'events']
1919
1920 def __init__(self, *args, **kwargs):
1921 dict={}
1922 dict.update(kwargs)
1924 super(schedulefile,self).__init__(**dict)
1926 if self.__class__ is schedulefile:
1927 self._update(args,dict)
1928
1929
1930 def getfields(self):
1931 return self.__fields
1932
1933
1934 def _update(self, args, kwargs):
1935 super(schedulefile,self)._update(args,kwargs)
1936 keys=kwargs.keys()
1937 for key in keys:
1938 if key in self.__fields:
1939 setattr(self, key, kwargs[key])
1940 del kwargs[key]
1941 if __debug__:
1943 self._complainaboutunusedargs(schedulefile,kwargs)
1944 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1945
1947
1948 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1949 'Writes this packet to the supplied buffer'
1950 self._bufferstartoffset=buf.getcurrentoffset()
1951 self.__field_numactiveitems.writetobuffer(buf)
1952 try: self.__field_events
1953 except:
1954 self.__field_events=LIST(**{'elementclass': scheduleevent})
1955 self.__field_events.writetobuffer(buf)
1956 self._bufferendoffset=buf.getcurrentoffset()
1957 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1958
1959
1960 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1961 'Reads this packet from the supplied buffer'
1962 self._bufferstartoffset=buf.getcurrentoffset()
1963 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1964 self.__field_numactiveitems=UINT(**{'sizeinbytes': 2})
1965 self.__field_numactiveitems.readfrombuffer(buf)
1966 self.__field_events=LIST(**{'elementclass': scheduleevent})
1967 self.__field_events.readfrombuffer(buf)
1968 self._bufferendoffset=buf.getcurrentoffset()
1969
1970
1971 def __getfield_numactiveitems(self):
1972 return self.__field_numactiveitems.getvalue()
1973
1974 def __setfield_numactiveitems(self, value):
1975 if isinstance(value,UINT):
1976 self.__field_numactiveitems=value
1977 else:
1978 self.__field_numactiveitems=UINT(value,**{'sizeinbytes': 2})
1979
1980 def __delfield_numactiveitems(self): del self.__field_numactiveitems
1981
1982 numactiveitems=property(__getfield_numactiveitems, __setfield_numactiveitems, __delfield_numactiveitems, None)
1983
1984 def __getfield_events(self):
1985 try: self.__field_events
1986 except:
1987 self.__field_events=LIST(**{'elementclass': scheduleevent})
1988 return self.__field_events.getvalue()
1989
1990 def __setfield_events(self, value):
1991 if isinstance(value,LIST):
1992 self.__field_events=value
1993 else:
1994 self.__field_events=LIST(value,**{'elementclass': scheduleevent})
1995
1996 def __delfield_events(self): del self.__field_events
1997
1998 events=property(__getfield_events, __setfield_events, __delfield_events, None)
1999
2000 def iscontainer(self):
2001 return True
2002
2003 def containerelements(self):
2004 yield ('numactiveitems', self.__field_numactiveitems, None)
2005 yield ('events', self.__field_events, None)
2006
2007
2008
2009
2010 class call(BaseProtogenClass):
2011 __fields=['GPStime', 'unknown1', 'duration', 'number', 'name', 'numberlength', 'unknown']
2012
2013 def __init__(self, *args, **kwargs):
2014 dict={}
2015 dict.update(kwargs)
2017 super(call,self).__init__(**dict)
2019 if self.__class__ is call:
2020 self._update(args,dict)
2021
2022
2023 def getfields(self):
2024 return self.__fields
2025
2026
2027 def _update(self, args, kwargs):
2028 super(call,self)._update(args,kwargs)
2029 keys=kwargs.keys()
2030 for key in keys:
2031 if key in self.__fields:
2032 setattr(self, key, kwargs[key])
2033 del kwargs[key]
2034 if __debug__:
2036 self._complainaboutunusedargs(call,kwargs)
2037 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2038
2040
2041 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2042 'Writes this packet to the supplied buffer'
2043 self._bufferstartoffset=buf.getcurrentoffset()
2044 self.__field_GPStime.writetobuffer(buf)
2045 self.__field_unknown1.writetobuffer(buf)
2046 self.__field_duration.writetobuffer(buf)
2047 self.__field_number.writetobuffer(buf)
2048 self.__field_name.writetobuffer(buf)
2049 self.__field_numberlength.writetobuffer(buf)
2050 self.__field_unknown.writetobuffer(buf)
2051 self._bufferendoffset=buf.getcurrentoffset()
2052 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2053
2054
2055 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2056 'Reads this packet from the supplied buffer'
2057 self._bufferstartoffset=buf.getcurrentoffset()
2058 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2059 self.__field_GPStime=GPSDATE(**{'sizeinbytes': 4})
2060 self.__field_GPStime.readfrombuffer(buf)
2061 self.__field_unknown1=UINT(**{'sizeinbytes': 4})
2062 self.__field_unknown1.readfrombuffer(buf)
2063 self.__field_duration=UINT(**{'sizeinbytes': 4})
2064 self.__field_duration.readfrombuffer(buf)
2065 self.__field_number=USTRING(**{'sizeinbytes': 49, 'raiseonunterminatedread': False})
2066 self.__field_number.readfrombuffer(buf)
2067 self.__field_name=USTRING(**{'sizeinbytes': 36, 'raiseonunterminatedread': False})
2068 self.__field_name.readfrombuffer(buf)
2069 self.__field_numberlength=UINT(**{'sizeinbytes': 1})
2070 self.__field_numberlength.readfrombuffer(buf)
2071 self.__field_unknown=UNKNOWN(**{'sizeinbytes': 6})
2072 self.__field_unknown.readfrombuffer(buf)
2073 self._bufferendoffset=buf.getcurrentoffset()
2074
2075
2076 def __getfield_GPStime(self):
2077 return self.__field_GPStime.getvalue()
2078
2079 def __setfield_GPStime(self, value):
2080 if isinstance(value,GPSDATE):
2081 self.__field_GPStime=value
2082 else:
2083 self.__field_GPStime=GPSDATE(value,**{'sizeinbytes': 4})
2084
2085 def __delfield_GPStime(self): del self.__field_GPStime
2086
2087 GPStime=property(__getfield_GPStime, __setfield_GPStime, __delfield_GPStime, None)
2088
2089 def __getfield_unknown1(self):
2090 return self.__field_unknown1.getvalue()
2091
2092 def __setfield_unknown1(self, value):
2093 if isinstance(value,UINT):
2094 self.__field_unknown1=value
2095 else:
2096 self.__field_unknown1=UINT(value,**{'sizeinbytes': 4})
2097
2098 def __delfield_unknown1(self): del self.__field_unknown1
2099
2100 unknown1=property(__getfield_unknown1, __setfield_unknown1, __delfield_unknown1, None)
2101
2102 def __getfield_duration(self):
2103 return self.__field_duration.getvalue()
2104
2105 def __setfield_duration(self, value):
2106 if isinstance(value,UINT):
2107 self.__field_duration=value
2108 else:
2109 self.__field_duration=UINT(value,**{'sizeinbytes': 4})
2110
2111 def __delfield_duration(self): del self.__field_duration
2112
2113 duration=property(__getfield_duration, __setfield_duration, __delfield_duration, None)
2114
2115 def __getfield_number(self):
2116 return self.__field_number.getvalue()
2117
2118 def __setfield_number(self, value):
2119 if isinstance(value,USTRING):
2120 self.__field_number=value
2121 else:
2122 self.__field_number=USTRING(value,**{'sizeinbytes': 49, 'raiseonunterminatedread': False})
2123
2124 def __delfield_number(self): del self.__field_number
2125
2126 number=property(__getfield_number, __setfield_number, __delfield_number, None)
2127
2128 def __getfield_name(self):
2129 return self.__field_name.getvalue()
2130
2131 def __setfield_name(self, value):
2132 if isinstance(value,USTRING):
2133 self.__field_name=value
2134 else:
2135 self.__field_name=USTRING(value,**{'sizeinbytes': 36, 'raiseonunterminatedread': False})
2136
2137 def __delfield_name(self): del self.__field_name
2138
2139 name=property(__getfield_name, __setfield_name, __delfield_name, None)
2140
2141 def __getfield_numberlength(self):
2142 return self.__field_numberlength.getvalue()
2143
2144 def __setfield_numberlength(self, value):
2145 if isinstance(value,UINT):
2146 self.__field_numberlength=value
2147 else:
2148 self.__field_numberlength=UINT(value,**{'sizeinbytes': 1})
2149
2150 def __delfield_numberlength(self): del self.__field_numberlength
2151
2152 numberlength=property(__getfield_numberlength, __setfield_numberlength, __delfield_numberlength, None)
2153
2154 def __getfield_unknown(self):
2155 return self.__field_unknown.getvalue()
2156
2157 def __setfield_unknown(self, value):
2158 if isinstance(value,UNKNOWN):
2159 self.__field_unknown=value
2160 else:
2161 self.__field_unknown=UNKNOWN(value,**{'sizeinbytes': 6})
2162
2163 def __delfield_unknown(self): del self.__field_unknown
2164
2165 unknown=property(__getfield_unknown, __setfield_unknown, __delfield_unknown, None)
2166
2167 def iscontainer(self):
2168 return True
2169
2170 def containerelements(self):
2171 yield ('GPStime', self.__field_GPStime, None)
2172 yield ('unknown1', self.__field_unknown1, None)
2173 yield ('duration', self.__field_duration, None)
2174 yield ('number', self.__field_number, None)
2175 yield ('name', self.__field_name, None)
2176 yield ('numberlength', self.__field_numberlength, None)
2177 yield ('unknown', self.__field_unknown, None)
2178
2179
2180
2181
2182 class callhistory(BaseProtogenClass):
2183 __fields=['numcalls', 'unknown1', 'calls']
2184
2185 def __init__(self, *args, **kwargs):
2186 dict={}
2187 dict.update(kwargs)
2189 super(callhistory,self).__init__(**dict)
2191 if self.__class__ is callhistory:
2192 self._update(args,dict)
2193
2194
2195 def getfields(self):
2196 return self.__fields
2197
2198
2199 def _update(self, args, kwargs):
2200 super(callhistory,self)._update(args,kwargs)
2201 keys=kwargs.keys()
2202 for key in keys:
2203 if key in self.__fields:
2204 setattr(self, key, kwargs[key])
2205 del kwargs[key]
2206 if __debug__:
2208 self._complainaboutunusedargs(callhistory,kwargs)
2209 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2210
2212
2213 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2214 'Writes this packet to the supplied buffer'
2215 self._bufferstartoffset=buf.getcurrentoffset()
2216 self.__field_numcalls.writetobuffer(buf)
2217 self.__field_unknown1.writetobuffer(buf)
2218 try: self.__field_calls
2219 except:
2220 self.__field_calls=LIST(**{'elementclass': call})
2221 self.__field_calls.writetobuffer(buf)
2222 self._bufferendoffset=buf.getcurrentoffset()
2223 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2224
2225
2226 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2227 'Reads this packet from the supplied buffer'
2228 self._bufferstartoffset=buf.getcurrentoffset()
2229 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2230 self.__field_numcalls=UINT(**{'sizeinbytes': 4})
2231 self.__field_numcalls.readfrombuffer(buf)
2232 self.__field_unknown1=UINT(**{'sizeinbytes': 1})
2233 self.__field_unknown1.readfrombuffer(buf)
2234 self.__field_calls=LIST(**{'elementclass': call})
2235 self.__field_calls.readfrombuffer(buf)
2236 self._bufferendoffset=buf.getcurrentoffset()
2237
2238
2239 def __getfield_numcalls(self):
2240 return self.__field_numcalls.getvalue()
2241
2242 def __setfield_numcalls(self, value):
2243 if isinstance(value,UINT):
2244 self.__field_numcalls=value
2245 else:
2246 self.__field_numcalls=UINT(value,**{'sizeinbytes': 4})
2247
2248 def __delfield_numcalls(self): del self.__field_numcalls
2249
2250 numcalls=property(__getfield_numcalls, __setfield_numcalls, __delfield_numcalls, None)
2251
2252 def __getfield_unknown1(self):
2253 return self.__field_unknown1.getvalue()
2254
2255 def __setfield_unknown1(self, value):
2256 if isinstance(value,UINT):
2257 self.__field_unknown1=value
2258 else:
2259 self.__field_unknown1=UINT(value,**{'sizeinbytes': 1})
2260
2261 def __delfield_unknown1(self): del self.__field_unknown1
2262
2263 unknown1=property(__getfield_unknown1, __setfield_unknown1, __delfield_unknown1, None)
2264
2265 def __getfield_calls(self):
2266 try: self.__field_calls
2267 except:
2268 self.__field_calls=LIST(**{'elementclass': call})
2269 return self.__field_calls.getvalue()
2270
2271 def __setfield_calls(self, value):
2272 if isinstance(value,LIST):
2273 self.__field_calls=value
2274 else:
2275 self.__field_calls=LIST(value,**{'elementclass': call})
2276
2277 def __delfield_calls(self): del self.__field_calls
2278
2279 calls=property(__getfield_calls, __setfield_calls, __delfield_calls, None)
2280
2281 def iscontainer(self):
2282 return True
2283
2284 def containerelements(self):
2285 yield ('numcalls', self.__field_numcalls, None)
2286 yield ('unknown1', self.__field_unknown1, None)
2287 yield ('calls', self.__field_calls, None)
2288
2289
2290
2291
2292 class msg_record(BaseProtogenClass):
2293 __fields=['unknown1', 'binary', 'unknown3', 'unknown4', 'unknown6', 'length', 'msg']
2294
2295 def __init__(self, *args, **kwargs):
2296 dict={}
2297 dict.update(kwargs)
2299 super(msg_record,self).__init__(**dict)
2301 if self.__class__ is msg_record:
2302 self._update(args,dict)
2303
2304
2305 def getfields(self):
2306 return self.__fields
2307
2308
2309 def _update(self, args, kwargs):
2310 super(msg_record,self)._update(args,kwargs)
2311 keys=kwargs.keys()
2312 for key in keys:
2313 if key in self.__fields:
2314 setattr(self, key, kwargs[key])
2315 del kwargs[key]
2316 if __debug__:
2318 self._complainaboutunusedargs(msg_record,kwargs)
2319 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2320
2322
2323 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2324 'Writes this packet to the supplied buffer'
2325 self._bufferstartoffset=buf.getcurrentoffset()
2326 self.__field_unknown1.writetobuffer(buf)
2327 self.__field_binary.writetobuffer(buf)
2328 self.__field_unknown3.writetobuffer(buf)
2329 self.__field_unknown4.writetobuffer(buf)
2330 self.__field_unknown6.writetobuffer(buf)
2331 self.__field_length.writetobuffer(buf)
2332 try: self.__field_msg
2333 except:
2334 self.__field_msg=LIST(**{'elementclass': _gen_p_lgvx3200_213, 'length': 219})
2335 self.__field_msg.writetobuffer(buf)
2336 self._bufferendoffset=buf.getcurrentoffset()
2337 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2338
2339
2340 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2341 'Reads this packet from the supplied buffer'
2342 self._bufferstartoffset=buf.getcurrentoffset()
2343 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2344 self.__field_unknown1=UINT(**{'sizeinbytes': 1})
2345 self.__field_unknown1.readfrombuffer(buf)
2346 self.__field_binary=UINT(**{'sizeinbytes': 1})
2347 self.__field_binary.readfrombuffer(buf)
2348 self.__field_unknown3=UINT(**{'sizeinbytes': 1})
2349 self.__field_unknown3.readfrombuffer(buf)
2350 self.__field_unknown4=UINT(**{'sizeinbytes': 1})
2351 self.__field_unknown4.readfrombuffer(buf)
2352 self.__field_unknown6=UINT(**{'sizeinbytes': 1})
2353 self.__field_unknown6.readfrombuffer(buf)
2354 self.__field_length=UINT(**{'sizeinbytes': 1})
2355 self.__field_length.readfrombuffer(buf)
2356 self.__field_msg=LIST(**{'elementclass': _gen_p_lgvx3200_213, 'length': 219})
2357 self.__field_msg.readfrombuffer(buf)
2358 self._bufferendoffset=buf.getcurrentoffset()
2359
2360
2361 def __getfield_unknown1(self):
2362 return self.__field_unknown1.getvalue()
2363
2364 def __setfield_unknown1(self, value):
2365 if isinstance(value,UINT):
2366 self.__field_unknown1=value
2367 else:
2368 self.__field_unknown1=UINT(value,**{'sizeinbytes': 1})
2369
2370 def __delfield_unknown1(self): del self.__field_unknown1
2371
2372 unknown1=property(__getfield_unknown1, __setfield_unknown1, __delfield_unknown1, None)
2373
2374 def __getfield_binary(self):
2375 return self.__field_binary.getvalue()
2376
2377 def __setfield_binary(self, value):
2378 if isinstance(value,UINT):
2379 self.__field_binary=value
2380 else:
2381 self.__field_binary=UINT(value,**{'sizeinbytes': 1})
2382
2383 def __delfield_binary(self): del self.__field_binary
2384
2385 binary=property(__getfield_binary, __setfield_binary, __delfield_binary, None)
2386
2387 def __getfield_unknown3(self):
2388 return self.__field_unknown3.getvalue()
2389
2390 def __setfield_unknown3(self, value):
2391 if isinstance(value,UINT):
2392 self.__field_unknown3=value
2393 else:
2394 self.__field_unknown3=UINT(value,**{'sizeinbytes': 1})
2395
2396 def __delfield_unknown3(self): del self.__field_unknown3
2397
2398 unknown3=property(__getfield_unknown3, __setfield_unknown3, __delfield_unknown3, None)
2399
2400 def __getfield_unknown4(self):
2401 return self.__field_unknown4.getvalue()
2402
2403 def __setfield_unknown4(self, value):
2404 if isinstance(value,UINT):
2405 self.__field_unknown4=value
2406 else:
2407 self.__field_unknown4=UINT(value,**{'sizeinbytes': 1})
2408
2409 def __delfield_unknown4(self): del self.__field_unknown4
2410
2411 unknown4=property(__getfield_unknown4, __setfield_unknown4, __delfield_unknown4, None)
2412
2413 def __getfield_unknown6(self):
2414 return self.__field_unknown6.getvalue()
2415
2416 def __setfield_unknown6(self, value):
2417 if isinstance(value,UINT):
2418 self.__field_unknown6=value
2419 else:
2420 self.__field_unknown6=UINT(value,**{'sizeinbytes': 1})
2421
2422 def __delfield_unknown6(self): del self.__field_unknown6
2423
2424 unknown6=property(__getfield_unknown6, __setfield_unknown6, __delfield_unknown6, None)
2425
2426 def __getfield_length(self):
2427 return self.__field_length.getvalue()
2428
2429 def __setfield_length(self, value):
2430 if isinstance(value,UINT):
2431 self.__field_length=value
2432 else:
2433 self.__field_length=UINT(value,**{'sizeinbytes': 1})
2434
2435 def __delfield_length(self): del self.__field_length
2436
2437 length=property(__getfield_length, __setfield_length, __delfield_length, None)
2438
2439 def __getfield_msg(self):
2440 try: self.__field_msg
2441 except:
2442 self.__field_msg=LIST(**{'elementclass': _gen_p_lgvx3200_213, 'length': 219})
2443 return self.__field_msg.getvalue()
2444
2445 def __setfield_msg(self, value):
2446 if isinstance(value,LIST):
2447 self.__field_msg=value
2448 else:
2449 self.__field_msg=LIST(value,**{'elementclass': _gen_p_lgvx3200_213, 'length': 219})
2450
2451 def __delfield_msg(self): del self.__field_msg
2452
2453 msg=property(__getfield_msg, __setfield_msg, __delfield_msg, None)
2454
2455 def iscontainer(self):
2456 return True
2457
2458 def containerelements(self):
2459 yield ('unknown1', self.__field_unknown1, None)
2460 yield ('binary', self.__field_binary, None)
2461 yield ('unknown3', self.__field_unknown3, None)
2462 yield ('unknown4', self.__field_unknown4, None)
2463 yield ('unknown6', self.__field_unknown6, None)
2464 yield ('length', self.__field_length, None)
2465 yield ('msg', self.__field_msg, None)
2466
2467
2468
2469
2470 class _gen_p_lgvx3200_213(BaseProtogenClass):
2471 'Anonymous inner class'
2472 __fields=['byte']
2473
2474 def __init__(self, *args, **kwargs):
2475 dict={}
2476 dict.update(kwargs)
2478 super(_gen_p_lgvx3200_213,self).__init__(**dict)
2480 if self.__class__ is _gen_p_lgvx3200_213:
2481 self._update(args,dict)
2482
2483
2484 def getfields(self):
2485 return self.__fields
2486
2487
2488 def _update(self, args, kwargs):
2489 super(_gen_p_lgvx3200_213,self)._update(args,kwargs)
2490 keys=kwargs.keys()
2491 for key in keys:
2492 if key in self.__fields:
2493 setattr(self, key, kwargs[key])
2494 del kwargs[key]
2495 if __debug__:
2497 self._complainaboutunusedargs(_gen_p_lgvx3200_213,kwargs)
2498 if len(args):
2499 dict2={'sizeinbytes': 1}
2500 dict2.update(kwargs)
2501 kwargs=dict2
2502 self.__field_byte=UINT(*args,**dict2)
2503
2505
2506 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2507 'Writes this packet to the supplied buffer'
2508 self._bufferstartoffset=buf.getcurrentoffset()
2509 self.__field_byte.writetobuffer(buf)
2510 self._bufferendoffset=buf.getcurrentoffset()
2511 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2512
2513
2514 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2515 'Reads this packet from the supplied buffer'
2516 self._bufferstartoffset=buf.getcurrentoffset()
2517 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2518 self.__field_byte=UINT(**{'sizeinbytes': 1})
2519 self.__field_byte.readfrombuffer(buf)
2520 self._bufferendoffset=buf.getcurrentoffset()
2521
2522
2523 def __getfield_byte(self):
2524 return self.__field_byte.getvalue()
2525
2526 def __setfield_byte(self, value):
2527 if isinstance(value,UINT):
2528 self.__field_byte=value
2529 else:
2530 self.__field_byte=UINT(value,**{'sizeinbytes': 1})
2531
2532 def __delfield_byte(self): del self.__field_byte
2533
2534 byte=property(__getfield_byte, __setfield_byte, __delfield_byte, "individual byte of message")
2535
2536 def iscontainer(self):
2537 return True
2538
2539 def containerelements(self):
2540 yield ('byte', self.__field_byte, "individual byte of message")
2541
2542
2543
2544
2545 class recipient_record(BaseProtogenClass):
2546 __fields=['status', 'timesent', 'timereceived', 'unknown', 'number']
2547
2548 def __init__(self, *args, **kwargs):
2549 dict={}
2550 dict.update(kwargs)
2552 super(recipient_record,self).__init__(**dict)
2554 if self.__class__ is recipient_record:
2555 self._update(args,dict)
2556
2557
2558 def getfields(self):
2559 return self.__fields
2560
2561
2562 def _update(self, args, kwargs):
2563 super(recipient_record,self)._update(args,kwargs)
2564 keys=kwargs.keys()
2565 for key in keys:
2566 if key in self.__fields:
2567 setattr(self, key, kwargs[key])
2568 del kwargs[key]
2569 if __debug__:
2571 self._complainaboutunusedargs(recipient_record,kwargs)
2572 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2573
2575
2576 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2577 'Writes this packet to the supplied buffer'
2578 self._bufferstartoffset=buf.getcurrentoffset()
2579 self.__field_status.writetobuffer(buf)
2580 self.__field_timesent.writetobuffer(buf)
2581 self.__field_timereceived.writetobuffer(buf)
2582 self.__field_unknown.writetobuffer(buf)
2583 self.__field_number.writetobuffer(buf)
2584 self._bufferendoffset=buf.getcurrentoffset()
2585 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2586
2587
2588 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2589 'Reads this packet from the supplied buffer'
2590 self._bufferstartoffset=buf.getcurrentoffset()
2591 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2592 self.__field_status=UINT(**{'sizeinbytes': 1})
2593 self.__field_status.readfrombuffer(buf)
2594 self.__field_timesent=LGCALDATE(**{'sizeinbytes': 4})
2595 self.__field_timesent.readfrombuffer(buf)
2596 self.__field_timereceived=LGCALDATE(**{'sizeinbytes': 4})
2597 self.__field_timereceived.readfrombuffer(buf)
2598 self.__field_unknown=UNKNOWN(**{'sizeinbytes': 12})
2599 self.__field_unknown.readfrombuffer(buf)
2600 self.__field_number=USTRING(**{'sizeinbytes': 49})
2601 self.__field_number.readfrombuffer(buf)
2602 self._bufferendoffset=buf.getcurrentoffset()
2603
2604
2605 def __getfield_status(self):
2606 return self.__field_status.getvalue()
2607
2608 def __setfield_status(self, value):
2609 if isinstance(value,UINT):
2610 self.__field_status=value
2611 else:
2612 self.__field_status=UINT(value,**{'sizeinbytes': 1})
2613
2614 def __delfield_status(self): del self.__field_status
2615
2616 status=property(__getfield_status, __setfield_status, __delfield_status, None)
2617
2618 def __getfield_timesent(self):
2619 return self.__field_timesent.getvalue()
2620
2621 def __setfield_timesent(self, value):
2622 if isinstance(value,LGCALDATE):
2623 self.__field_timesent=value
2624 else:
2625 self.__field_timesent=LGCALDATE(value,**{'sizeinbytes': 4})
2626
2627 def __delfield_timesent(self): del self.__field_timesent
2628
2629 timesent=property(__getfield_timesent, __setfield_timesent, __delfield_timesent, None)
2630
2631 def __getfield_timereceived(self):
2632 return self.__field_timereceived.getvalue()
2633
2634 def __setfield_timereceived(self, value):
2635 if isinstance(value,LGCALDATE):
2636 self.__field_timereceived=value
2637 else:
2638 self.__field_timereceived=LGCALDATE(value,**{'sizeinbytes': 4})
2639
2640 def __delfield_timereceived(self): del self.__field_timereceived
2641
2642 timereceived=property(__getfield_timereceived, __setfield_timereceived, __delfield_timereceived, None)
2643
2644 def __getfield_unknown(self):
2645 return self.__field_unknown.getvalue()
2646
2647 def __setfield_unknown(self, value):
2648 if isinstance(value,UNKNOWN):
2649 self.__field_unknown=value
2650 else:
2651 self.__field_unknown=UNKNOWN(value,**{'sizeinbytes': 12})
2652
2653 def __delfield_unknown(self): del self.__field_unknown
2654
2655 unknown=property(__getfield_unknown, __setfield_unknown, __delfield_unknown, None)
2656
2657 def __getfield_number(self):
2658 return self.__field_number.getvalue()
2659
2660 def __setfield_number(self, value):
2661 if isinstance(value,USTRING):
2662 self.__field_number=value
2663 else:
2664 self.__field_number=USTRING(value,**{'sizeinbytes': 49})
2665
2666 def __delfield_number(self): del self.__field_number
2667
2668 number=property(__getfield_number, __setfield_number, __delfield_number, None)
2669
2670 def iscontainer(self):
2671 return True
2672
2673 def containerelements(self):
2674 yield ('status', self.__field_status, None)
2675 yield ('timesent', self.__field_timesent, None)
2676 yield ('timereceived', self.__field_timereceived, None)
2677 yield ('unknown', self.__field_unknown, None)
2678 yield ('number', self.__field_number, None)
2679
2680
2681
2682
2683 class sms_saved(BaseProtogenClass):
2684 __fields=['outboxmsg', 'pad', 'outbox', 'inbox']
2685
2686 def __init__(self, *args, **kwargs):
2687 dict={}
2688 dict.update(kwargs)
2690 super(sms_saved,self).__init__(**dict)
2692 if self.__class__ is sms_saved:
2693 self._update(args,dict)
2694
2695
2696 def getfields(self):
2697 return self.__fields
2698
2699
2700 def _update(self, args, kwargs):
2701 super(sms_saved,self)._update(args,kwargs)
2702 keys=kwargs.keys()
2703 for key in keys:
2704 if key in self.__fields:
2705 setattr(self, key, kwargs[key])
2706 del kwargs[key]
2707 if __debug__:
2709 self._complainaboutunusedargs(sms_saved,kwargs)
2710 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2711
2713
2714 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2715 'Writes this packet to the supplied buffer'
2716 self._bufferstartoffset=buf.getcurrentoffset()
2717 self.__field_outboxmsg.writetobuffer(buf)
2718 self.__field_pad.writetobuffer(buf)
2719 if self.outboxmsg:
2720 self.__field_outbox.writetobuffer(buf)
2721 if not self.outboxmsg:
2722 self.__field_inbox.writetobuffer(buf)
2723 self._bufferendoffset=buf.getcurrentoffset()
2724 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2725
2726
2727 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2728 'Reads this packet from the supplied buffer'
2729 self._bufferstartoffset=buf.getcurrentoffset()
2730 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2731 self.__field_outboxmsg=UINT(**{'sizeinbytes': 4})
2732 self.__field_outboxmsg.readfrombuffer(buf)
2733 self.__field_pad=UNKNOWN(**{'sizeinbytes': 4})
2734 self.__field_pad.readfrombuffer(buf)
2735 if self.outboxmsg:
2736 self.__field_outbox=sms_out()
2737 self.__field_outbox.readfrombuffer(buf)
2738 if not self.outboxmsg:
2739 self.__field_inbox=sms_in()
2740 self.__field_inbox.readfrombuffer(buf)
2741 self._bufferendoffset=buf.getcurrentoffset()
2742
2743
2744 def __getfield_outboxmsg(self):
2745 return self.__field_outboxmsg.getvalue()
2746
2747 def __setfield_outboxmsg(self, value):
2748 if isinstance(value,UINT):
2749 self.__field_outboxmsg=value
2750 else:
2751 self.__field_outboxmsg=UINT(value,**{'sizeinbytes': 4})
2752
2753 def __delfield_outboxmsg(self): del self.__field_outboxmsg
2754
2755 outboxmsg=property(__getfield_outboxmsg, __setfield_outboxmsg, __delfield_outboxmsg, None)
2756
2757 def __getfield_pad(self):
2758 return self.__field_pad.getvalue()
2759
2760 def __setfield_pad(self, value):
2761 if isinstance(value,UNKNOWN):
2762 self.__field_pad=value
2763 else:
2764 self.__field_pad=UNKNOWN(value,**{'sizeinbytes': 4})
2765
2766 def __delfield_pad(self): del self.__field_pad
2767
2768 pad=property(__getfield_pad, __setfield_pad, __delfield_pad, None)
2769
2770 def __getfield_outbox(self):
2771 return self.__field_outbox.getvalue()
2772
2773 def __setfield_outbox(self, value):
2774 if isinstance(value,sms_out):
2775 self.__field_outbox=value
2776 else:
2777 self.__field_outbox=sms_out(value,)
2778
2779 def __delfield_outbox(self): del self.__field_outbox
2780
2781 outbox=property(__getfield_outbox, __setfield_outbox, __delfield_outbox, None)
2782
2783 def __getfield_inbox(self):
2784 return self.__field_inbox.getvalue()
2785
2786 def __setfield_inbox(self, value):
2787 if isinstance(value,sms_in):
2788 self.__field_inbox=value
2789 else:
2790 self.__field_inbox=sms_in(value,)
2791
2792 def __delfield_inbox(self): del self.__field_inbox
2793
2794 inbox=property(__getfield_inbox, __setfield_inbox, __delfield_inbox, None)
2795
2796 def iscontainer(self):
2797 return True
2798
2799 def containerelements(self):
2800 yield ('outboxmsg', self.__field_outboxmsg, None)
2801 yield ('pad', self.__field_pad, None)
2802 if self.outboxmsg:
2803 yield ('outbox', self.__field_outbox, None)
2804 if not self.outboxmsg:
2805 yield ('inbox', self.__field_inbox, None)
2806
2807
2808
2809
2810 class sms_out(BaseProtogenClass):
2811 __fields=['index', 'locked', 'timesent', 'subject', 'num_msg_elements', 'messages', 'unknown', 'priority', 'callback', 'recipients']
2812
2813 def __init__(self, *args, **kwargs):
2814 dict={}
2815 dict.update(kwargs)
2817 super(sms_out,self).__init__(**dict)
2819 if self.__class__ is sms_out:
2820 self._update(args,dict)
2821
2822
2823 def getfields(self):
2824 return self.__fields
2825
2826
2827 def _update(self, args, kwargs):
2828 super(sms_out,self)._update(args,kwargs)
2829 keys=kwargs.keys()
2830 for key in keys:
2831 if key in self.__fields:
2832 setattr(self, key, kwargs[key])
2833 del kwargs[key]
2834 if __debug__:
2836 self._complainaboutunusedargs(sms_out,kwargs)
2837 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2838
2840
2841 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2842 'Writes this packet to the supplied buffer'
2843 self._bufferstartoffset=buf.getcurrentoffset()
2844 self.__field_index.writetobuffer(buf)
2845 self.__field_locked.writetobuffer(buf)
2846 self.__field_timesent.writetobuffer(buf)
2847 self.__field_subject.writetobuffer(buf)
2848 self.__field_num_msg_elements.writetobuffer(buf)
2849 try: self.__field_messages
2850 except:
2851 self.__field_messages=LIST(**{'elementclass': msg_record, 'length': 1})
2852 self.__field_messages.writetobuffer(buf)
2853 self.__field_unknown.writetobuffer(buf)
2854 self.__field_priority.writetobuffer(buf)
2855 self.__field_callback.writetobuffer(buf)
2856 try: self.__field_recipients
2857 except:
2858 self.__field_recipients=LIST(**{'elementclass': recipient_record,'length': 9 })
2859 self.__field_recipients.writetobuffer(buf)
2860 self._bufferendoffset=buf.getcurrentoffset()
2861 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2862
2863
2864 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2865 'Reads this packet from the supplied buffer'
2866 self._bufferstartoffset=buf.getcurrentoffset()
2867 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2868 self.__field_index=UINT(**{'sizeinbytes': 4})
2869 self.__field_index.readfrombuffer(buf)
2870 self.__field_locked=UINT(**{'sizeinbytes': 1})
2871 self.__field_locked.readfrombuffer(buf)
2872 self.__field_timesent=LGCALDATE(**{'sizeinbytes': 4})
2873 self.__field_timesent.readfrombuffer(buf)
2874 self.__field_subject=USTRING(**{'sizeinbytes': 21})
2875 self.__field_subject.readfrombuffer(buf)
2876 self.__field_num_msg_elements=UINT(**{'sizeinbytes': 1})
2877 self.__field_num_msg_elements.readfrombuffer(buf)
2878 self.__field_messages=LIST(**{'elementclass': msg_record, 'length': 1})
2879 self.__field_messages.readfrombuffer(buf)
2880 self.__field_unknown=UNKNOWN(**{'sizeinbytes': 39})
2881 self.__field_unknown.readfrombuffer(buf)
2882 self.__field_priority=UINT(**{'sizeinbytes': 1})
2883 self.__field_priority.readfrombuffer(buf)
2884 self.__field_callback=USTRING(**{'sizeinbytes': 49})
2885 self.__field_callback.readfrombuffer(buf)
2886 self.__field_recipients=LIST(**{'elementclass': recipient_record,'length': 9 })
2887 self.__field_recipients.readfrombuffer(buf)
2888 self._bufferendoffset=buf.getcurrentoffset()
2889
2890
2891 def __getfield_index(self):
2892 return self.__field_index.getvalue()
2893
2894 def __setfield_index(self, value):
2895 if isinstance(value,UINT):
2896 self.__field_index=value
2897 else:
2898 self.__field_index=UINT(value,**{'sizeinbytes': 4})
2899
2900 def __delfield_index(self): del self.__field_index
2901
2902 index=property(__getfield_index, __setfield_index, __delfield_index, None)
2903
2904 def __getfield_locked(self):
2905 return self.__field_locked.getvalue()
2906
2907 def __setfield_locked(self, value):
2908 if isinstance(value,UINT):
2909 self.__field_locked=value
2910 else:
2911 self.__field_locked=UINT(value,**{'sizeinbytes': 1})
2912
2913 def __delfield_locked(self): del self.__field_locked
2914
2915 locked=property(__getfield_locked, __setfield_locked, __delfield_locked, None)
2916
2917 def __getfield_timesent(self):
2918 return self.__field_timesent.getvalue()
2919
2920 def __setfield_timesent(self, value):
2921 if isinstance(value,LGCALDATE):
2922 self.__field_timesent=value
2923 else:
2924 self.__field_timesent=LGCALDATE(value,**{'sizeinbytes': 4})
2925
2926 def __delfield_timesent(self): del self.__field_timesent
2927
2928 timesent=property(__getfield_timesent, __setfield_timesent, __delfield_timesent, None)
2929
2930 def __getfield_subject(self):
2931 return self.__field_subject.getvalue()
2932
2933 def __setfield_subject(self, value):
2934 if isinstance(value,USTRING):
2935 self.__field_subject=value
2936 else:
2937 self.__field_subject=USTRING(value,**{'sizeinbytes': 21})
2938
2939 def __delfield_subject(self): del self.__field_subject
2940
2941 subject=property(__getfield_subject, __setfield_subject, __delfield_subject, None)
2942
2943 def __getfield_num_msg_elements(self):
2944 return self.__field_num_msg_elements.getvalue()
2945
2946 def __setfield_num_msg_elements(self, value):
2947 if isinstance(value,UINT):
2948 self.__field_num_msg_elements=value
2949 else:
2950 self.__field_num_msg_elements=UINT(value,**{'sizeinbytes': 1})
2951
2952 def __delfield_num_msg_elements(self): del self.__field_num_msg_elements
2953
2954 num_msg_elements=property(__getfield_num_msg_elements, __setfield_num_msg_elements, __delfield_num_msg_elements, None)
2955
2956 def __getfield_messages(self):
2957 try: self.__field_messages
2958 except:
2959 self.__field_messages=LIST(**{'elementclass': msg_record, 'length': 1})
2960 return self.__field_messages.getvalue()
2961
2962 def __setfield_messages(self, value):
2963 if isinstance(value,LIST):
2964 self.__field_messages=value
2965 else:
2966 self.__field_messages=LIST(value,**{'elementclass': msg_record, 'length': 1})
2967
2968 def __delfield_messages(self): del self.__field_messages
2969
2970 messages=property(__getfield_messages, __setfield_messages, __delfield_messages, None)
2971
2972 def __getfield_unknown(self):
2973 return self.__field_unknown.getvalue()
2974
2975 def __setfield_unknown(self, value):
2976 if isinstance(value,UNKNOWN):
2977 self.__field_unknown=value
2978 else:
2979 self.__field_unknown=UNKNOWN(value,**{'sizeinbytes': 39})
2980
2981 def __delfield_unknown(self): del self.__field_unknown
2982
2983 unknown=property(__getfield_unknown, __setfield_unknown, __delfield_unknown, None)
2984
2985 def __getfield_priority(self):
2986 return self.__field_priority.getvalue()
2987
2988 def __setfield_priority(self, value):
2989 if isinstance(value,UINT):
2990 self.__field_priority=value
2991 else:
2992 self.__field_priority=UINT(value,**{'sizeinbytes': 1})
2993
2994 def __delfield_priority(self): del self.__field_priority
2995
2996 priority=property(__getfield_priority, __setfield_priority, __delfield_priority, None)
2997
2998 def __getfield_callback(self):
2999 return self.__field_callback.getvalue()
3000
3001 def __setfield_callback(self, value):
3002 if isinstance(value,USTRING):
3003 self.__field_callback=value
3004 else:
3005 self.__field_callback=USTRING(value,**{'sizeinbytes': 49})
3006
3007 def __delfield_callback(self): del self.__field_callback
3008
3009 callback=property(__getfield_callback, __setfield_callback, __delfield_callback, None)
3010
3011 def __getfield_recipients(self):
3012 try: self.__field_recipients
3013 except:
3014 self.__field_recipients=LIST(**{'elementclass': recipient_record,'length': 9 })
3015 return self.__field_recipients.getvalue()
3016
3017 def __setfield_recipients(self, value):
3018 if isinstance(value,LIST):
3019 self.__field_recipients=value
3020 else:
3021 self.__field_recipients=LIST(value,**{'elementclass': recipient_record,'length': 9 })
3022
3023 def __delfield_recipients(self): del self.__field_recipients
3024
3025 recipients=property(__getfield_recipients, __setfield_recipients, __delfield_recipients, None)
3026
3027 def iscontainer(self):
3028 return True
3029
3030 def containerelements(self):
3031 yield ('index', self.__field_index, None)
3032 yield ('locked', self.__field_locked, None)
3033 yield ('timesent', self.__field_timesent, None)
3034 yield ('subject', self.__field_subject, None)
3035 yield ('num_msg_elements', self.__field_num_msg_elements, None)
3036 yield ('messages', self.__field_messages, None)
3037 yield ('unknown', self.__field_unknown, None)
3038 yield ('priority', self.__field_priority, None)
3039 yield ('callback', self.__field_callback, None)
3040 yield ('recipients', self.__field_recipients, None)
3041