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