0001
0003 """Various descriptions of data specific to LG VX9100"""
0004 import time
0005 from prototypes import *
0006 from prototypeslg import *
0007
0008 from p_lg import *
0010
0011 from p_lgvx8550 import *
0014
0015 UINT=UINTlsb
0017 BOOL=BOOLlsb
0018
0019 NUMSPEEDDIALS=1000
0020 FIRSTSPEEDDIAL=1
0021 LASTSPEEDDIAL=999
0022
0023 NUMEMERGENCYCONTACTS=3
0024
0025 BREW_FILE_SYSTEM=2
0026
0027 INDEX_RT_TYPE=257
0028 INDEX_SOUND_TYPE=2
0029 INDEX_VIDEO_TYPE=3
0030 INDEX_IMAGE_TYPE=0
0031 INDEX_SDIMAGE_TYPE=16
0032 INDEX_SDVIDEO_TYPE=19
0033 INDEX_SDSOUND_TYPE=18
0034
0035 MAX_PHONEBOOK_GROUPS=30
0036 PB_ENTRY_SOR='<PE>'
0037 PB_ENTRY_EOF='<HPE>\x00VX9100\x00\x00\x00\x00\xD8\x07\x06\x00\x10\x00\x0F\x00\x14\x00\x30'+'\x00'*222+'</HPE>\x00'
0038 PB_NUMBER_SOR='<PN>'
0039
0040 pb_group_filename='pim/pbgroup.dat'
0041 pb_recordid_filename='pim/record_id.dat'
0042 pb_ice_file_name = 'pim/pbiceentry.dat'
0043
0044 NUMCALENDARENTRIES=300
0045
0046 inbox_index = "dload/inbox.dat"
0048 outbox_index = "dload/outbox.dat"
0049 drafts_index = "dload/drafts.dat"
0050
0051 class indexentry(BaseProtogenClass):
0052 __fields=['filename', 'size', 'date', 'type', 'dunno']
0053
0054 def __init__(self, *args, **kwargs):
0055 dict={}
0056 dict.update(kwargs)
0058 super(indexentry,self).__init__(**dict)
0060 if self.__class__ is indexentry:
0061 self._update(args,dict)
0062
0063
0064 def getfields(self):
0065 return self.__fields
0066
0067
0068 def _update(self, args, kwargs):
0069 super(indexentry,self)._update(args,kwargs)
0070 keys=kwargs.keys()
0071 for key in keys:
0072 if key in self.__fields:
0073 setattr(self, key, kwargs[key])
0074 del kwargs[key]
0075 if __debug__:
0077 self._complainaboutunusedargs(indexentry,kwargs)
0078 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0079
0081
0082 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0083 'Writes this packet to the supplied buffer'
0084 self._bufferstartoffset=buf.getcurrentoffset()
0085 self.__field_filename.writetobuffer(buf)
0086 self.__field_size.writetobuffer(buf)
0087 try: self.__field_date
0088 except:
0089 self.__field_date=GPSDATE(**{'sizeinbytes': 4, 'default': GPSDATE.now()})
0090 self.__field_date.writetobuffer(buf)
0091 self.__field_type.writetobuffer(buf)
0092 try: self.__field_dunno
0093 except:
0094 self.__field_dunno=UINT(**{'sizeinbytes': 4, 'default': 0 })
0095 self.__field_dunno.writetobuffer(buf)
0096 self._bufferendoffset=buf.getcurrentoffset()
0097 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0098
0099
0100 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0101 'Reads this packet from the supplied buffer'
0102 self._bufferstartoffset=buf.getcurrentoffset()
0103 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0104 self.__field_filename=USTRING(**{'sizeinbytes': 256, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'raiseontruncate': False })
0105 self.__field_filename.readfrombuffer(buf)
0106 self.__field_size=UINT(**{'sizeinbytes': 4})
0107 self.__field_size.readfrombuffer(buf)
0108 self.__field_date=GPSDATE(**{'sizeinbytes': 4, 'default': GPSDATE.now()})
0109 self.__field_date.readfrombuffer(buf)
0110 self.__field_type=UINT(**{'sizeinbytes': 4})
0111 self.__field_type.readfrombuffer(buf)
0112 self.__field_dunno=UINT(**{'sizeinbytes': 4, 'default': 0 })
0113 self.__field_dunno.readfrombuffer(buf)
0114 self._bufferendoffset=buf.getcurrentoffset()
0115
0116
0117 def __getfield_filename(self):
0118 return self.__field_filename.getvalue()
0119
0120 def __setfield_filename(self, value):
0121 if isinstance(value,USTRING):
0122 self.__field_filename=value
0123 else:
0124 self.__field_filename=USTRING(value,**{'sizeinbytes': 256, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'raiseontruncate': False })
0125
0126 def __delfield_filename(self): del self.__field_filename
0127
0128 filename=property(__getfield_filename, __setfield_filename, __delfield_filename, "full pathname")
0129
0130 def __getfield_size(self):
0131 return self.__field_size.getvalue()
0132
0133 def __setfield_size(self, value):
0134 if isinstance(value,UINT):
0135 self.__field_size=value
0136 else:
0137 self.__field_size=UINT(value,**{'sizeinbytes': 4})
0138
0139 def __delfield_size(self): del self.__field_size
0140
0141 size=property(__getfield_size, __setfield_size, __delfield_size, None)
0142
0143 def __getfield_date(self):
0144 try: self.__field_date
0145 except:
0146 self.__field_date=GPSDATE(**{'sizeinbytes': 4, 'default': GPSDATE.now()})
0147 return self.__field_date.getvalue()
0148
0149 def __setfield_date(self, value):
0150 if isinstance(value,GPSDATE):
0151 self.__field_date=value
0152 else:
0153 self.__field_date=GPSDATE(value,**{'sizeinbytes': 4, 'default': GPSDATE.now()})
0154
0155 def __delfield_date(self): del self.__field_date
0156
0157 date=property(__getfield_date, __setfield_date, __delfield_date, None)
0158
0159 def __getfield_type(self):
0160 return self.__field_type.getvalue()
0161
0162 def __setfield_type(self, value):
0163 if isinstance(value,UINT):
0164 self.__field_type=value
0165 else:
0166 self.__field_type=UINT(value,**{'sizeinbytes': 4})
0167
0168 def __delfield_type(self): del self.__field_type
0169
0170 type=property(__getfield_type, __setfield_type, __delfield_type, None)
0171
0172 def __getfield_dunno(self):
0173 try: self.__field_dunno
0174 except:
0175 self.__field_dunno=UINT(**{'sizeinbytes': 4, 'default': 0 })
0176 return self.__field_dunno.getvalue()
0177
0178 def __setfield_dunno(self, value):
0179 if isinstance(value,UINT):
0180 self.__field_dunno=value
0181 else:
0182 self.__field_dunno=UINT(value,**{'sizeinbytes': 4, 'default': 0 })
0183
0184 def __delfield_dunno(self): del self.__field_dunno
0185
0186 dunno=property(__getfield_dunno, __setfield_dunno, __delfield_dunno, None)
0187
0188 def iscontainer(self):
0189 return True
0190
0191 def containerelements(self):
0192 yield ('filename', self.__field_filename, "full pathname")
0193 yield ('size', self.__field_size, None)
0194 yield ('date', self.__field_date, None)
0195 yield ('type', self.__field_type, None)
0196 yield ('dunno', self.__field_dunno, None)
0197
0198
0199
0200
0201 class indexfile(BaseProtogenClass):
0202 "Used for tracking wallpaper and ringtones"
0203 __fields=['items']
0204
0205 def __init__(self, *args, **kwargs):
0206 dict={}
0207 dict.update(kwargs)
0209 super(indexfile,self).__init__(**dict)
0211 if self.__class__ is indexfile:
0212 self._update(args,dict)
0213
0214
0215 def getfields(self):
0216 return self.__fields
0217
0218
0219 def _update(self, args, kwargs):
0220 super(indexfile,self)._update(args,kwargs)
0221 keys=kwargs.keys()
0222 for key in keys:
0223 if key in self.__fields:
0224 setattr(self, key, kwargs[key])
0225 del kwargs[key]
0226 if __debug__:
0228 self._complainaboutunusedargs(indexfile,kwargs)
0229 if len(args):
0230 dict2={'elementclass': indexentry, 'createdefault': True}
0231 dict2.update(kwargs)
0232 kwargs=dict2
0233 self.__field_items=LIST(*args,**dict2)
0234
0236
0237 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0238 'Writes this packet to the supplied buffer'
0239 self._bufferstartoffset=buf.getcurrentoffset()
0240 try: self.__field_items
0241 except:
0242 self.__field_items=LIST(**{'elementclass': indexentry, 'createdefault': True})
0243 self.__field_items.writetobuffer(buf)
0244 self._bufferendoffset=buf.getcurrentoffset()
0245 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0246
0247
0248 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0249 'Reads this packet from the supplied buffer'
0250 self._bufferstartoffset=buf.getcurrentoffset()
0251 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0252 self.__field_items=LIST(**{'elementclass': indexentry, 'createdefault': True})
0253 self.__field_items.readfrombuffer(buf)
0254 self._bufferendoffset=buf.getcurrentoffset()
0255
0256
0257 def __getfield_items(self):
0258 try: self.__field_items
0259 except:
0260 self.__field_items=LIST(**{'elementclass': indexentry, 'createdefault': True})
0261 return self.__field_items.getvalue()
0262
0263 def __setfield_items(self, value):
0264 if isinstance(value,LIST):
0265 self.__field_items=value
0266 else:
0267 self.__field_items=LIST(value,**{'elementclass': indexentry, 'createdefault': True})
0268
0269 def __delfield_items(self): del self.__field_items
0270
0271 items=property(__getfield_items, __setfield_items, __delfield_items, None)
0272
0273 def iscontainer(self):
0274 return True
0275
0276 def containerelements(self):
0277 yield ('items', self.__field_items, None)
0278
0279
0280
0281
0282 class pbgroup(BaseProtogenClass):
0283 __fields=['name', 'groupid', 'user_added']
0284
0285 def __init__(self, *args, **kwargs):
0286 dict={}
0287 dict.update(kwargs)
0289 super(pbgroup,self).__init__(**dict)
0291 if self.__class__ is pbgroup:
0292 self._update(args,dict)
0293
0294
0295 def getfields(self):
0296 return self.__fields
0297
0298
0299 def _update(self, args, kwargs):
0300 super(pbgroup,self)._update(args,kwargs)
0301 keys=kwargs.keys()
0302 for key in keys:
0303 if key in self.__fields:
0304 setattr(self, key, kwargs[key])
0305 del kwargs[key]
0306 if __debug__:
0308 self._complainaboutunusedargs(pbgroup,kwargs)
0309 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0310
0312
0313 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0314 'Writes this packet to the supplied buffer'
0315 self._bufferstartoffset=buf.getcurrentoffset()
0316 try: self.__field_name
0317 except:
0318 self.__field_name=USTRING(**{'sizeinbytes': 33, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'default': '' })
0319 self.__field_name.writetobuffer(buf)
0320 try: self.__field_groupid
0321 except:
0322 self.__field_groupid=UINT(**{'sizeinbytes': 2, 'default': 0 })
0323 self.__field_groupid.writetobuffer(buf)
0324 try: self.__field_user_added
0325 except:
0326 self.__field_user_added=UINT(**{'sizeinbytes': 1, 'default': 0})
0327 self.__field_user_added.writetobuffer(buf)
0328 self._bufferendoffset=buf.getcurrentoffset()
0329 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0330
0331
0332 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0333 'Reads this packet from the supplied buffer'
0334 self._bufferstartoffset=buf.getcurrentoffset()
0335 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0336 self.__field_name=USTRING(**{'sizeinbytes': 33, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'default': '' })
0337 self.__field_name.readfrombuffer(buf)
0338 self.__field_groupid=UINT(**{'sizeinbytes': 2, 'default': 0 })
0339 self.__field_groupid.readfrombuffer(buf)
0340 self.__field_user_added=UINT(**{'sizeinbytes': 1, 'default': 0})
0341 self.__field_user_added.readfrombuffer(buf)
0342 self._bufferendoffset=buf.getcurrentoffset()
0343
0344
0345 def __getfield_name(self):
0346 try: self.__field_name
0347 except:
0348 self.__field_name=USTRING(**{'sizeinbytes': 33, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'default': '' })
0349 return self.__field_name.getvalue()
0350
0351 def __setfield_name(self, value):
0352 if isinstance(value,USTRING):
0353 self.__field_name=value
0354 else:
0355 self.__field_name=USTRING(value,**{'sizeinbytes': 33, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'default': '' })
0356
0357 def __delfield_name(self): del self.__field_name
0358
0359 name=property(__getfield_name, __setfield_name, __delfield_name, None)
0360
0361 def __getfield_groupid(self):
0362 try: self.__field_groupid
0363 except:
0364 self.__field_groupid=UINT(**{'sizeinbytes': 2, 'default': 0 })
0365 return self.__field_groupid.getvalue()
0366
0367 def __setfield_groupid(self, value):
0368 if isinstance(value,UINT):
0369 self.__field_groupid=value
0370 else:
0371 self.__field_groupid=UINT(value,**{'sizeinbytes': 2, 'default': 0 })
0372
0373 def __delfield_groupid(self): del self.__field_groupid
0374
0375 groupid=property(__getfield_groupid, __setfield_groupid, __delfield_groupid, None)
0376
0377 def __getfield_user_added(self):
0378 try: self.__field_user_added
0379 except:
0380 self.__field_user_added=UINT(**{'sizeinbytes': 1, 'default': 0})
0381 return self.__field_user_added.getvalue()
0382
0383 def __setfield_user_added(self, value):
0384 if isinstance(value,UINT):
0385 self.__field_user_added=value
0386 else:
0387 self.__field_user_added=UINT(value,**{'sizeinbytes': 1, 'default': 0})
0388
0389 def __delfield_user_added(self): del self.__field_user_added
0390
0391 user_added=property(__getfield_user_added, __setfield_user_added, __delfield_user_added, "=1 when was added by user")
0392
0393 def iscontainer(self):
0394 return True
0395
0396 def containerelements(self):
0397 yield ('name', self.__field_name, None)
0398 yield ('groupid', self.__field_groupid, None)
0399 yield ('user_added', self.__field_user_added, "=1 when was added by user")
0400
0401
0402
0403
0404 class pbgroups(BaseProtogenClass):
0405 "Phonebook groups"
0406 __fields=['groups']
0407
0408 def __init__(self, *args, **kwargs):
0409 dict={}
0410 dict.update(kwargs)
0412 super(pbgroups,self).__init__(**dict)
0414 if self.__class__ is pbgroups:
0415 self._update(args,dict)
0416
0417
0418 def getfields(self):
0419 return self.__fields
0420
0421
0422 def _update(self, args, kwargs):
0423 super(pbgroups,self)._update(args,kwargs)
0424 keys=kwargs.keys()
0425 for key in keys:
0426 if key in self.__fields:
0427 setattr(self, key, kwargs[key])
0428 del kwargs[key]
0429 if __debug__:
0431 self._complainaboutunusedargs(pbgroups,kwargs)
0432 if len(args):
0433 dict2={'elementclass': pbgroup, 'length': MAX_PHONEBOOK_GROUPS, 'createdefault': True}
0434 dict2.update(kwargs)
0435 kwargs=dict2
0436 self.__field_groups=LIST(*args,**dict2)
0437
0439
0440 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0441 'Writes this packet to the supplied buffer'
0442 self._bufferstartoffset=buf.getcurrentoffset()
0443 try: self.__field_groups
0444 except:
0445 self.__field_groups=LIST(**{'elementclass': pbgroup, 'length': MAX_PHONEBOOK_GROUPS, 'createdefault': True})
0446 self.__field_groups.writetobuffer(buf)
0447 self._bufferendoffset=buf.getcurrentoffset()
0448 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0449
0450
0451 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0452 'Reads this packet from the supplied buffer'
0453 self._bufferstartoffset=buf.getcurrentoffset()
0454 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0455 self.__field_groups=LIST(**{'elementclass': pbgroup, 'length': MAX_PHONEBOOK_GROUPS, 'createdefault': True})
0456 self.__field_groups.readfrombuffer(buf)
0457 self._bufferendoffset=buf.getcurrentoffset()
0458
0459
0460 def __getfield_groups(self):
0461 try: self.__field_groups
0462 except:
0463 self.__field_groups=LIST(**{'elementclass': pbgroup, 'length': MAX_PHONEBOOK_GROUPS, 'createdefault': True})
0464 return self.__field_groups.getvalue()
0465
0466 def __setfield_groups(self, value):
0467 if isinstance(value,LIST):
0468 self.__field_groups=value
0469 else:
0470 self.__field_groups=LIST(value,**{'elementclass': pbgroup, 'length': MAX_PHONEBOOK_GROUPS, 'createdefault': True})
0471
0472 def __delfield_groups(self): del self.__field_groups
0473
0474 groups=property(__getfield_groups, __setfield_groups, __delfield_groups, None)
0475
0476 def iscontainer(self):
0477 return True
0478
0479 def containerelements(self):
0480 yield ('groups', self.__field_groups, None)
0481
0482
0483
0484
0485 class speeddial(BaseProtogenClass):
0486 __fields=['entry', 'number']
0487
0488 def __init__(self, *args, **kwargs):
0489 dict={}
0490 dict.update(kwargs)
0492 super(speeddial,self).__init__(**dict)
0494 if self.__class__ is speeddial:
0495 self._update(args,dict)
0496
0497
0498 def getfields(self):
0499 return self.__fields
0500
0501
0502 def _update(self, args, kwargs):
0503 super(speeddial,self)._update(args,kwargs)
0504 keys=kwargs.keys()
0505 for key in keys:
0506 if key in self.__fields:
0507 setattr(self, key, kwargs[key])
0508 del kwargs[key]
0509 if __debug__:
0511 self._complainaboutunusedargs(speeddial,kwargs)
0512 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0513
0515
0516 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0517 'Writes this packet to the supplied buffer'
0518 self._bufferstartoffset=buf.getcurrentoffset()
0519 try: self.__field_entry
0520 except:
0521 self.__field_entry=UINT(**{'sizeinbytes': 2, 'default': 0xffff})
0522 self.__field_entry.writetobuffer(buf)
0523 try: self.__field_number
0524 except:
0525 self.__field_number=UINT(**{'sizeinbytes': 1, 'default': 0xff})
0526 self.__field_number.writetobuffer(buf)
0527 self._bufferendoffset=buf.getcurrentoffset()
0528 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0529
0530
0531 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0532 'Reads this packet from the supplied buffer'
0533 self._bufferstartoffset=buf.getcurrentoffset()
0534 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0535 self.__field_entry=UINT(**{'sizeinbytes': 2, 'default': 0xffff})
0536 self.__field_entry.readfrombuffer(buf)
0537 self.__field_number=UINT(**{'sizeinbytes': 1, 'default': 0xff})
0538 self.__field_number.readfrombuffer(buf)
0539 self._bufferendoffset=buf.getcurrentoffset()
0540
0541
0542 def __getfield_entry(self):
0543 try: self.__field_entry
0544 except:
0545 self.__field_entry=UINT(**{'sizeinbytes': 2, 'default': 0xffff})
0546 return self.__field_entry.getvalue()
0547
0548 def __setfield_entry(self, value):
0549 if isinstance(value,UINT):
0550 self.__field_entry=value
0551 else:
0552 self.__field_entry=UINT(value,**{'sizeinbytes': 2, 'default': 0xffff})
0553
0554 def __delfield_entry(self): del self.__field_entry
0555
0556 entry=property(__getfield_entry, __setfield_entry, __delfield_entry, "0-based entry number")
0557
0558 def __getfield_number(self):
0559 try: self.__field_number
0560 except:
0561 self.__field_number=UINT(**{'sizeinbytes': 1, 'default': 0xff})
0562 return self.__field_number.getvalue()
0563
0564 def __setfield_number(self, value):
0565 if isinstance(value,UINT):
0566 self.__field_number=value
0567 else:
0568 self.__field_number=UINT(value,**{'sizeinbytes': 1, 'default': 0xff})
0569
0570 def __delfield_number(self): del self.__field_number
0571
0572 number=property(__getfield_number, __setfield_number, __delfield_number, "number type")
0573
0574 def iscontainer(self):
0575 return True
0576
0577 def containerelements(self):
0578 yield ('entry', self.__field_entry, "0-based entry number")
0579 yield ('number', self.__field_number, "number type")
0580
0581 def valid(self):
0582 return self.entry!=0xffff
0583
0584
0585
0586
0587 class speeddials(BaseProtogenClass):
0588 __fields=['speeddials']
0589
0590 def __init__(self, *args, **kwargs):
0591 dict={}
0592 dict.update(kwargs)
0594 super(speeddials,self).__init__(**dict)
0596 if self.__class__ is speeddials:
0597 self._update(args,dict)
0598
0599
0600 def getfields(self):
0601 return self.__fields
0602
0603
0604 def _update(self, args, kwargs):
0605 super(speeddials,self)._update(args,kwargs)
0606 keys=kwargs.keys()
0607 for key in keys:
0608 if key in self.__fields:
0609 setattr(self, key, kwargs[key])
0610 del kwargs[key]
0611 if __debug__:
0613 self._complainaboutunusedargs(speeddials,kwargs)
0614 if len(args):
0615 dict2={'length': NUMSPEEDDIALS, 'elementclass': speeddial}
0616 dict2.update(kwargs)
0617 kwargs=dict2
0618 self.__field_speeddials=LIST(*args,**dict2)
0619
0621
0622 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0623 'Writes this packet to the supplied buffer'
0624 self._bufferstartoffset=buf.getcurrentoffset()
0625 try: self.__field_speeddials
0626 except:
0627 self.__field_speeddials=LIST(**{'length': NUMSPEEDDIALS, 'elementclass': speeddial})
0628 self.__field_speeddials.writetobuffer(buf)
0629 self._bufferendoffset=buf.getcurrentoffset()
0630 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0631
0632
0633 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0634 'Reads this packet from the supplied buffer'
0635 self._bufferstartoffset=buf.getcurrentoffset()
0636 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0637 self.__field_speeddials=LIST(**{'length': NUMSPEEDDIALS, 'elementclass': speeddial})
0638 self.__field_speeddials.readfrombuffer(buf)
0639 self._bufferendoffset=buf.getcurrentoffset()
0640
0641
0642 def __getfield_speeddials(self):
0643 try: self.__field_speeddials
0644 except:
0645 self.__field_speeddials=LIST(**{'length': NUMSPEEDDIALS, 'elementclass': speeddial})
0646 return self.__field_speeddials.getvalue()
0647
0648 def __setfield_speeddials(self, value):
0649 if isinstance(value,LIST):
0650 self.__field_speeddials=value
0651 else:
0652 self.__field_speeddials=LIST(value,**{'length': NUMSPEEDDIALS, 'elementclass': speeddial})
0653
0654 def __delfield_speeddials(self): del self.__field_speeddials
0655
0656 speeddials=property(__getfield_speeddials, __setfield_speeddials, __delfield_speeddials, None)
0657
0658 def iscontainer(self):
0659 return True
0660
0661 def containerelements(self):
0662 yield ('speeddials', self.__field_speeddials, None)
0663
0664
0665
0666
0667 class pbfileentry(BaseProtogenClass):
0668 __fields=['entry_tag', 'pad00', 'mod_date', 'unk0', 'entry_number1', 'entry_number0', 'name', 'group', 'emails', 'ringtone', 'wallpaper', 'numbertypes', 'numberindices', 'memo', 'exit_tag', 'dontcare']
0669
0670 def __init__(self, *args, **kwargs):
0671 dict={}
0672 dict.update(kwargs)
0674 super(pbfileentry,self).__init__(**dict)
0676 if self.__class__ is pbfileentry:
0677 self._update(args,dict)
0678
0679
0680 def getfields(self):
0681 return self.__fields
0682
0683
0684 def _update(self, args, kwargs):
0685 super(pbfileentry,self)._update(args,kwargs)
0686 keys=kwargs.keys()
0687 for key in keys:
0688 if key in self.__fields:
0689 setattr(self, key, kwargs[key])
0690 del kwargs[key]
0691 if __debug__:
0693 self._complainaboutunusedargs(pbfileentry,kwargs)
0694 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
0695
0697
0698 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
0699 'Writes this packet to the supplied buffer'
0700 self._bufferstartoffset=buf.getcurrentoffset()
0701 try: self.__field_entry_tag
0702 except:
0703 self.__field_entry_tag=STRING(**{'sizeinbytes': 4, 'terminator': None, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'default': '\xff\xff\xff\xff'})
0704 self.__field_entry_tag.writetobuffer(buf)
0705 if self.entry_tag==PB_ENTRY_SOR:
0706 try: self.__field_pad00
0707 except:
0708 self.__field_pad00=UINT(**{'sizeinbytes': 1, 'default': 0 })
0709 self.__field_pad00.writetobuffer(buf)
0710 try: self.__field_mod_date
0711 except:
0712 self.__field_mod_date=PBDateTime(**{ 'defaulttocurrenttime': True })
0713 self.__field_mod_date.writetobuffer(buf)
0714 try: self.__field_unk0
0715 except:
0716 self.__field_unk0=STRING(**{'sizeinbytes': 6, 'terminator': None, 'default': '\xff\xff\xff\xff\xff\xff' })
0717 self.__field_unk0.writetobuffer(buf)
0718 self.__field_entry_number1.writetobuffer(buf)
0719 self.__field_entry_number0.writetobuffer(buf)
0720 try: self.__field_name
0721 except:
0722 self.__field_name=USTRING(**{'sizeinbytes': 33, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'raiseontruncate': False })
0723 self.__field_name.writetobuffer(buf)
0724 try: self.__field_group
0725 except:
0726 self.__field_group=UINT(**{'sizeinbytes': 2, 'default': 0 })
0727 self.__field_group.writetobuffer(buf)
0728 try: self.__field_emails
0729 except:
0730 self.__field_emails=LIST(**{'elementclass': _gen_p_lgvx9100_126, 'length': NUMEMAILS})
0731 self.__field_emails.writetobuffer(buf)
0732 try: self.__field_ringtone
0733 except:
0734 self.__field_ringtone=UINT(**{'sizeinbytes': 2, 'default': 0xffff })
0735 self.__field_ringtone.writetobuffer(buf)
0736 try: self.__field_wallpaper
0737 except:
0738 self.__field_wallpaper=UINT(**{'sizeinbytes': 2, 'default': 0 })
0739 self.__field_wallpaper.writetobuffer(buf)
0740 try: self.__field_numbertypes
0741 except:
0742 self.__field_numbertypes=LIST(**{'elementclass': _gen_p_lgvx9100_130, 'length': NUMPHONENUMBERS})
0743 self.__field_numbertypes.writetobuffer(buf)
0744 try: self.__field_numberindices
0745 except:
0746 self.__field_numberindices=LIST(**{'elementclass': _gen_p_lgvx9100_132, 'length': NUMPHONENUMBERS})
0747 self.__field_numberindices.writetobuffer(buf)
0748 try: self.__field_memo
0749 except:
0750 self.__field_memo=USTRING(**{'sizeinbytes': 69, 'raiseonunterminatedread': False, 'default': '', 'encoding': PHONE_ENCODING })
0751 self.__field_memo.writetobuffer(buf)
0752 try: self.__field_exit_tag
0753 except:
0754 self.__field_exit_tag=USTRING(**{'sizeinbytes': 6, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'default': '</PE>'})
0755 self.__field_exit_tag.writetobuffer(buf)
0756 else:
0757 try: self.__field_dontcare
0758 except:
0759 self.__field_dontcare=DATA(**{'sizeinbytes': 252, 'default': '\xff'*252 })
0760 self.__field_dontcare.writetobuffer(buf)
0761 self._bufferendoffset=buf.getcurrentoffset()
0762 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
0763
0764
0765 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
0766 'Reads this packet from the supplied buffer'
0767 self._bufferstartoffset=buf.getcurrentoffset()
0768 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
0769 self.__field_entry_tag=STRING(**{'sizeinbytes': 4, 'terminator': None, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'default': '\xff\xff\xff\xff'})
0770 self.__field_entry_tag.readfrombuffer(buf)
0771 if self.entry_tag==PB_ENTRY_SOR:
0772 self.__field_pad00=UINT(**{'sizeinbytes': 1, 'default': 0 })
0773 self.__field_pad00.readfrombuffer(buf)
0774 self.__field_mod_date=PBDateTime(**{ 'defaulttocurrenttime': True })
0775 self.__field_mod_date.readfrombuffer(buf)
0776 self.__field_unk0=STRING(**{'sizeinbytes': 6, 'terminator': None, 'default': '\xff\xff\xff\xff\xff\xff' })
0777 self.__field_unk0.readfrombuffer(buf)
0778 self.__field_entry_number1=UINT(**{'sizeinbytes': 4})
0779 self.__field_entry_number1.readfrombuffer(buf)
0780 self.__field_entry_number0=UINT(**{'sizeinbytes': 2})
0781 self.__field_entry_number0.readfrombuffer(buf)
0782 self.__field_name=USTRING(**{'sizeinbytes': 33, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'raiseontruncate': False })
0783 self.__field_name.readfrombuffer(buf)
0784 self.__field_group=UINT(**{'sizeinbytes': 2, 'default': 0 })
0785 self.__field_group.readfrombuffer(buf)
0786 self.__field_emails=LIST(**{'elementclass': _gen_p_lgvx9100_126, 'length': NUMEMAILS})
0787 self.__field_emails.readfrombuffer(buf)
0788 self.__field_ringtone=UINT(**{'sizeinbytes': 2, 'default': 0xffff })
0789 self.__field_ringtone.readfrombuffer(buf)
0790 self.__field_wallpaper=UINT(**{'sizeinbytes': 2, 'default': 0 })
0791 self.__field_wallpaper.readfrombuffer(buf)
0792 self.__field_numbertypes=LIST(**{'elementclass': _gen_p_lgvx9100_130, 'length': NUMPHONENUMBERS})
0793 self.__field_numbertypes.readfrombuffer(buf)
0794 self.__field_numberindices=LIST(**{'elementclass': _gen_p_lgvx9100_132, 'length': NUMPHONENUMBERS})
0795 self.__field_numberindices.readfrombuffer(buf)
0796 self.__field_memo=USTRING(**{'sizeinbytes': 69, 'raiseonunterminatedread': False, 'default': '', 'encoding': PHONE_ENCODING })
0797 self.__field_memo.readfrombuffer(buf)
0798 self.__field_exit_tag=USTRING(**{'sizeinbytes': 6, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'default': '</PE>'})
0799 self.__field_exit_tag.readfrombuffer(buf)
0800 else:
0801 self.__field_dontcare=DATA(**{'sizeinbytes': 252, 'default': '\xff'*252 })
0802 self.__field_dontcare.readfrombuffer(buf)
0803 self._bufferendoffset=buf.getcurrentoffset()
0804
0805
0806 def __getfield_entry_tag(self):
0807 try: self.__field_entry_tag
0808 except:
0809 self.__field_entry_tag=STRING(**{'sizeinbytes': 4, 'terminator': None, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'default': '\xff\xff\xff\xff'})
0810 return self.__field_entry_tag.getvalue()
0811
0812 def __setfield_entry_tag(self, value):
0813 if isinstance(value,STRING):
0814 self.__field_entry_tag=value
0815 else:
0816 self.__field_entry_tag=STRING(value,**{'sizeinbytes': 4, 'terminator': None, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'default': '\xff\xff\xff\xff'})
0817
0818 def __delfield_entry_tag(self): del self.__field_entry_tag
0819
0820 entry_tag=property(__getfield_entry_tag, __setfield_entry_tag, __delfield_entry_tag, None)
0821
0822 def __getfield_pad00(self):
0823 try: self.__field_pad00
0824 except:
0825 self.__field_pad00=UINT(**{'sizeinbytes': 1, 'default': 0 })
0826 return self.__field_pad00.getvalue()
0827
0828 def __setfield_pad00(self, value):
0829 if isinstance(value,UINT):
0830 self.__field_pad00=value
0831 else:
0832 self.__field_pad00=UINT(value,**{'sizeinbytes': 1, 'default': 0 })
0833
0834 def __delfield_pad00(self): del self.__field_pad00
0835
0836 pad00=property(__getfield_pad00, __setfield_pad00, __delfield_pad00, None)
0837
0838 def __getfield_mod_date(self):
0839 try: self.__field_mod_date
0840 except:
0841 self.__field_mod_date=PBDateTime(**{ 'defaulttocurrenttime': True })
0842 return self.__field_mod_date.getvalue()
0843
0844 def __setfield_mod_date(self, value):
0845 if isinstance(value,PBDateTime):
0846 self.__field_mod_date=value
0847 else:
0848 self.__field_mod_date=PBDateTime(value,**{ 'defaulttocurrenttime': True })
0849
0850 def __delfield_mod_date(self): del self.__field_mod_date
0851
0852 mod_date=property(__getfield_mod_date, __setfield_mod_date, __delfield_mod_date, None)
0853
0854 def __getfield_unk0(self):
0855 try: self.__field_unk0
0856 except:
0857 self.__field_unk0=STRING(**{'sizeinbytes': 6, 'terminator': None, 'default': '\xff\xff\xff\xff\xff\xff' })
0858 return self.__field_unk0.getvalue()
0859
0860 def __setfield_unk0(self, value):
0861 if isinstance(value,STRING):
0862 self.__field_unk0=value
0863 else:
0864 self.__field_unk0=STRING(value,**{'sizeinbytes': 6, 'terminator': None, 'default': '\xff\xff\xff\xff\xff\xff' })
0865
0866 def __delfield_unk0(self): del self.__field_unk0
0867
0868 unk0=property(__getfield_unk0, __setfield_unk0, __delfield_unk0, None)
0869
0870 def __getfield_entry_number1(self):
0871 return self.__field_entry_number1.getvalue()
0872
0873 def __setfield_entry_number1(self, value):
0874 if isinstance(value,UINT):
0875 self.__field_entry_number1=value
0876 else:
0877 self.__field_entry_number1=UINT(value,**{'sizeinbytes': 4})
0878
0879 def __delfield_entry_number1(self): del self.__field_entry_number1
0880
0881 entry_number1=property(__getfield_entry_number1, __setfield_entry_number1, __delfield_entry_number1, None)
0882
0883 def __getfield_entry_number0(self):
0884 return self.__field_entry_number0.getvalue()
0885
0886 def __setfield_entry_number0(self, value):
0887 if isinstance(value,UINT):
0888 self.__field_entry_number0=value
0889 else:
0890 self.__field_entry_number0=UINT(value,**{'sizeinbytes': 2})
0891
0892 def __delfield_entry_number0(self): del self.__field_entry_number0
0893
0894 entry_number0=property(__getfield_entry_number0, __setfield_entry_number0, __delfield_entry_number0, None)
0895
0896 def __getfield_name(self):
0897 try: self.__field_name
0898 except:
0899 self.__field_name=USTRING(**{'sizeinbytes': 33, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'raiseontruncate': False })
0900 return self.__field_name.getvalue()
0901
0902 def __setfield_name(self, value):
0903 if isinstance(value,USTRING):
0904 self.__field_name=value
0905 else:
0906 self.__field_name=USTRING(value,**{'sizeinbytes': 33, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'raiseontruncate': False })
0907
0908 def __delfield_name(self): del self.__field_name
0909
0910 name=property(__getfield_name, __setfield_name, __delfield_name, None)
0911
0912 def __getfield_group(self):
0913 try: self.__field_group
0914 except:
0915 self.__field_group=UINT(**{'sizeinbytes': 2, 'default': 0 })
0916 return self.__field_group.getvalue()
0917
0918 def __setfield_group(self, value):
0919 if isinstance(value,UINT):
0920 self.__field_group=value
0921 else:
0922 self.__field_group=UINT(value,**{'sizeinbytes': 2, 'default': 0 })
0923
0924 def __delfield_group(self): del self.__field_group
0925
0926 group=property(__getfield_group, __setfield_group, __delfield_group, None)
0927
0928 def __getfield_emails(self):
0929 try: self.__field_emails
0930 except:
0931 self.__field_emails=LIST(**{'elementclass': _gen_p_lgvx9100_126, 'length': NUMEMAILS})
0932 return self.__field_emails.getvalue()
0933
0934 def __setfield_emails(self, value):
0935 if isinstance(value,LIST):
0936 self.__field_emails=value
0937 else:
0938 self.__field_emails=LIST(value,**{'elementclass': _gen_p_lgvx9100_126, 'length': NUMEMAILS})
0939
0940 def __delfield_emails(self): del self.__field_emails
0941
0942 emails=property(__getfield_emails, __setfield_emails, __delfield_emails, None)
0943
0944 def __getfield_ringtone(self):
0945 try: self.__field_ringtone
0946 except:
0947 self.__field_ringtone=UINT(**{'sizeinbytes': 2, 'default': 0xffff })
0948 return self.__field_ringtone.getvalue()
0949
0950 def __setfield_ringtone(self, value):
0951 if isinstance(value,UINT):
0952 self.__field_ringtone=value
0953 else:
0954 self.__field_ringtone=UINT(value,**{'sizeinbytes': 2, 'default': 0xffff })
0955
0956 def __delfield_ringtone(self): del self.__field_ringtone
0957
0958 ringtone=property(__getfield_ringtone, __setfield_ringtone, __delfield_ringtone, None)
0959
0960 def __getfield_wallpaper(self):
0961 try: self.__field_wallpaper
0962 except:
0963 self.__field_wallpaper=UINT(**{'sizeinbytes': 2, 'default': 0 })
0964 return self.__field_wallpaper.getvalue()
0965
0966 def __setfield_wallpaper(self, value):
0967 if isinstance(value,UINT):
0968 self.__field_wallpaper=value
0969 else:
0970 self.__field_wallpaper=UINT(value,**{'sizeinbytes': 2, 'default': 0 })
0971
0972 def __delfield_wallpaper(self): del self.__field_wallpaper
0973
0974 wallpaper=property(__getfield_wallpaper, __setfield_wallpaper, __delfield_wallpaper, None)
0975
0976 def __getfield_numbertypes(self):
0977 try: self.__field_numbertypes
0978 except:
0979 self.__field_numbertypes=LIST(**{'elementclass': _gen_p_lgvx9100_130, 'length': NUMPHONENUMBERS})
0980 return self.__field_numbertypes.getvalue()
0981
0982 def __setfield_numbertypes(self, value):
0983 if isinstance(value,LIST):
0984 self.__field_numbertypes=value
0985 else:
0986 self.__field_numbertypes=LIST(value,**{'elementclass': _gen_p_lgvx9100_130, 'length': NUMPHONENUMBERS})
0987
0988 def __delfield_numbertypes(self): del self.__field_numbertypes
0989
0990 numbertypes=property(__getfield_numbertypes, __setfield_numbertypes, __delfield_numbertypes, None)
0991
0992 def __getfield_numberindices(self):
0993 try: self.__field_numberindices
0994 except:
0995 self.__field_numberindices=LIST(**{'elementclass': _gen_p_lgvx9100_132, 'length': NUMPHONENUMBERS})
0996 return self.__field_numberindices.getvalue()
0997
0998 def __setfield_numberindices(self, value):
0999 if isinstance(value,LIST):
1000 self.__field_numberindices=value
1001 else:
1002 self.__field_numberindices=LIST(value,**{'elementclass': _gen_p_lgvx9100_132, 'length': NUMPHONENUMBERS})
1003
1004 def __delfield_numberindices(self): del self.__field_numberindices
1005
1006 numberindices=property(__getfield_numberindices, __setfield_numberindices, __delfield_numberindices, None)
1007
1008 def __getfield_memo(self):
1009 try: self.__field_memo
1010 except:
1011 self.__field_memo=USTRING(**{'sizeinbytes': 69, 'raiseonunterminatedread': False, 'default': '', 'encoding': PHONE_ENCODING })
1012 return self.__field_memo.getvalue()
1013
1014 def __setfield_memo(self, value):
1015 if isinstance(value,USTRING):
1016 self.__field_memo=value
1017 else:
1018 self.__field_memo=USTRING(value,**{'sizeinbytes': 69, 'raiseonunterminatedread': False, 'default': '', 'encoding': PHONE_ENCODING })
1019
1020 def __delfield_memo(self): del self.__field_memo
1021
1022 memo=property(__getfield_memo, __setfield_memo, __delfield_memo, None)
1023
1024 def __getfield_exit_tag(self):
1025 try: self.__field_exit_tag
1026 except:
1027 self.__field_exit_tag=USTRING(**{'sizeinbytes': 6, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'default': '</PE>'})
1028 return self.__field_exit_tag.getvalue()
1029
1030 def __setfield_exit_tag(self, value):
1031 if isinstance(value,USTRING):
1032 self.__field_exit_tag=value
1033 else:
1034 self.__field_exit_tag=USTRING(value,**{'sizeinbytes': 6, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'default': '</PE>'})
1035
1036 def __delfield_exit_tag(self): del self.__field_exit_tag
1037
1038 exit_tag=property(__getfield_exit_tag, __setfield_exit_tag, __delfield_exit_tag, None)
1039
1040 def __getfield_dontcare(self):
1041 try: self.__field_dontcare
1042 except:
1043 self.__field_dontcare=DATA(**{'sizeinbytes': 252, 'default': '\xff'*252 })
1044 return self.__field_dontcare.getvalue()
1045
1046 def __setfield_dontcare(self, value):
1047 if isinstance(value,DATA):
1048 self.__field_dontcare=value
1049 else:
1050 self.__field_dontcare=DATA(value,**{'sizeinbytes': 252, 'default': '\xff'*252 })
1051
1052 def __delfield_dontcare(self): del self.__field_dontcare
1053
1054 dontcare=property(__getfield_dontcare, __setfield_dontcare, __delfield_dontcare, None)
1055
1056 def iscontainer(self):
1057 return True
1058
1059 def containerelements(self):
1060 yield ('entry_tag', self.__field_entry_tag, None)
1061 if self.entry_tag==PB_ENTRY_SOR:
1062 yield ('pad00', self.__field_pad00, None)
1063 yield ('mod_date', self.__field_mod_date, None)
1064 yield ('unk0', self.__field_unk0, None)
1065 yield ('entry_number1', self.__field_entry_number1, None)
1066 yield ('entry_number0', self.__field_entry_number0, None)
1067 yield ('name', self.__field_name, None)
1068 yield ('group', self.__field_group, None)
1069 yield ('emails', self.__field_emails, None)
1070 yield ('ringtone', self.__field_ringtone, None)
1071 yield ('wallpaper', self.__field_wallpaper, None)
1072 yield ('numbertypes', self.__field_numbertypes, None)
1073 yield ('numberindices', self.__field_numberindices, None)
1074 yield ('memo', self.__field_memo, None)
1075 yield ('exit_tag', self.__field_exit_tag, None)
1076 else:
1077 yield ('dontcare', self.__field_dontcare, None)
1078
1079 def valid(self):
1080 global PB_ENTRY_SOR
1081 return self.entry_tag==PB_ENTRY_SOR
1082
1083
1084
1085
1086 class _gen_p_lgvx9100_126(BaseProtogenClass):
1087 'Anonymous inner class'
1088 __fields=['email']
1089
1090 def __init__(self, *args, **kwargs):
1091 dict={}
1092 dict.update(kwargs)
1094 super(_gen_p_lgvx9100_126,self).__init__(**dict)
1096 if self.__class__ is _gen_p_lgvx9100_126:
1097 self._update(args,dict)
1098
1099
1100 def getfields(self):
1101 return self.__fields
1102
1103
1104 def _update(self, args, kwargs):
1105 super(_gen_p_lgvx9100_126,self)._update(args,kwargs)
1106 keys=kwargs.keys()
1107 for key in keys:
1108 if key in self.__fields:
1109 setattr(self, key, kwargs[key])
1110 del kwargs[key]
1111 if __debug__:
1113 self._complainaboutunusedargs(_gen_p_lgvx9100_126,kwargs)
1114 if len(args):
1115 dict2={'sizeinbytes': 49, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False}
1116 dict2.update(kwargs)
1117 kwargs=dict2
1118 self.__field_email=USTRING(*args,**dict2)
1119
1121
1122 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1123 'Writes this packet to the supplied buffer'
1124 self._bufferstartoffset=buf.getcurrentoffset()
1125 self.__field_email.writetobuffer(buf)
1126 self._bufferendoffset=buf.getcurrentoffset()
1127 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1128
1129
1130 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1131 'Reads this packet from the supplied buffer'
1132 self._bufferstartoffset=buf.getcurrentoffset()
1133 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1134 self.__field_email=USTRING(**{'sizeinbytes': 49, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False})
1135 self.__field_email.readfrombuffer(buf)
1136 self._bufferendoffset=buf.getcurrentoffset()
1137
1138
1139 def __getfield_email(self):
1140 return self.__field_email.getvalue()
1141
1142 def __setfield_email(self, value):
1143 if isinstance(value,USTRING):
1144 self.__field_email=value
1145 else:
1146 self.__field_email=USTRING(value,**{'sizeinbytes': 49, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False})
1147
1148 def __delfield_email(self): del self.__field_email
1149
1150 email=property(__getfield_email, __setfield_email, __delfield_email, None)
1151
1152 def iscontainer(self):
1153 return True
1154
1155 def containerelements(self):
1156 yield ('email', self.__field_email, None)
1157
1158
1159
1160
1161 class _gen_p_lgvx9100_130(BaseProtogenClass):
1162 'Anonymous inner class'
1163 __fields=['numbertype']
1164
1165 def __init__(self, *args, **kwargs):
1166 dict={}
1167 dict.update(kwargs)
1169 super(_gen_p_lgvx9100_130,self).__init__(**dict)
1171 if self.__class__ is _gen_p_lgvx9100_130:
1172 self._update(args,dict)
1173
1174
1175 def getfields(self):
1176 return self.__fields
1177
1178
1179 def _update(self, args, kwargs):
1180 super(_gen_p_lgvx9100_130,self)._update(args,kwargs)
1181 keys=kwargs.keys()
1182 for key in keys:
1183 if key in self.__fields:
1184 setattr(self, key, kwargs[key])
1185 del kwargs[key]
1186 if __debug__:
1188 self._complainaboutunusedargs(_gen_p_lgvx9100_130,kwargs)
1189 if len(args):
1190 dict2={'sizeinbytes': 1, 'default': 0 }
1191 dict2.update(kwargs)
1192 kwargs=dict2
1193 self.__field_numbertype=UINT(*args,**dict2)
1194
1196
1197 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1198 'Writes this packet to the supplied buffer'
1199 self._bufferstartoffset=buf.getcurrentoffset()
1200 self.__field_numbertype.writetobuffer(buf)
1201 self._bufferendoffset=buf.getcurrentoffset()
1202 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1203
1204
1205 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1206 'Reads this packet from the supplied buffer'
1207 self._bufferstartoffset=buf.getcurrentoffset()
1208 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1209 self.__field_numbertype=UINT(**{'sizeinbytes': 1, 'default': 0 })
1210 self.__field_numbertype.readfrombuffer(buf)
1211 self._bufferendoffset=buf.getcurrentoffset()
1212
1213
1214 def __getfield_numbertype(self):
1215 return self.__field_numbertype.getvalue()
1216
1217 def __setfield_numbertype(self, value):
1218 if isinstance(value,UINT):
1219 self.__field_numbertype=value
1220 else:
1221 self.__field_numbertype=UINT(value,**{'sizeinbytes': 1, 'default': 0 })
1222
1223 def __delfield_numbertype(self): del self.__field_numbertype
1224
1225 numbertype=property(__getfield_numbertype, __setfield_numbertype, __delfield_numbertype, None)
1226
1227 def iscontainer(self):
1228 return True
1229
1230 def containerelements(self):
1231 yield ('numbertype', self.__field_numbertype, None)
1232
1233
1234
1235
1236 class _gen_p_lgvx9100_132(BaseProtogenClass):
1237 'Anonymous inner class'
1238 __fields=['numberindex']
1239
1240 def __init__(self, *args, **kwargs):
1241 dict={}
1242 dict.update(kwargs)
1244 super(_gen_p_lgvx9100_132,self).__init__(**dict)
1246 if self.__class__ is _gen_p_lgvx9100_132:
1247 self._update(args,dict)
1248
1249
1250 def getfields(self):
1251 return self.__fields
1252
1253
1254 def _update(self, args, kwargs):
1255 super(_gen_p_lgvx9100_132,self)._update(args,kwargs)
1256 keys=kwargs.keys()
1257 for key in keys:
1258 if key in self.__fields:
1259 setattr(self, key, kwargs[key])
1260 del kwargs[key]
1261 if __debug__:
1263 self._complainaboutunusedargs(_gen_p_lgvx9100_132,kwargs)
1264 if len(args):
1265 dict2={'sizeinbytes': 2, 'default': 0xffff }
1266 dict2.update(kwargs)
1267 kwargs=dict2
1268 self.__field_numberindex=UINT(*args,**dict2)
1269
1271
1272 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1273 'Writes this packet to the supplied buffer'
1274 self._bufferstartoffset=buf.getcurrentoffset()
1275 self.__field_numberindex.writetobuffer(buf)
1276 self._bufferendoffset=buf.getcurrentoffset()
1277 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1278
1279
1280 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1281 'Reads this packet from the supplied buffer'
1282 self._bufferstartoffset=buf.getcurrentoffset()
1283 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1284 self.__field_numberindex=UINT(**{'sizeinbytes': 2, 'default': 0xffff })
1285 self.__field_numberindex.readfrombuffer(buf)
1286 self._bufferendoffset=buf.getcurrentoffset()
1287
1288
1289 def __getfield_numberindex(self):
1290 return self.__field_numberindex.getvalue()
1291
1292 def __setfield_numberindex(self, value):
1293 if isinstance(value,UINT):
1294 self.__field_numberindex=value
1295 else:
1296 self.__field_numberindex=UINT(value,**{'sizeinbytes': 2, 'default': 0xffff })
1297
1298 def __delfield_numberindex(self): del self.__field_numberindex
1299
1300 numberindex=property(__getfield_numberindex, __setfield_numberindex, __delfield_numberindex, None)
1301
1302 def iscontainer(self):
1303 return True
1304
1305 def containerelements(self):
1306 yield ('numberindex', self.__field_numberindex, None)
1307
1308
1309
1310
1311 class pbfile(BaseProtogenClass):
1312 __fields=['items', 'eof_tag', 'model_name', 'mod_date', 'blanks', 'eof_close_tag']
1313
1314 def __init__(self, *args, **kwargs):
1315 dict={}
1316 dict.update(kwargs)
1318 super(pbfile,self).__init__(**dict)
1320 if self.__class__ is pbfile:
1321 self._update(args,dict)
1322
1323
1324 def getfields(self):
1325 return self.__fields
1326
1327
1328 def _update(self, args, kwargs):
1329 super(pbfile,self)._update(args,kwargs)
1330 keys=kwargs.keys()
1331 for key in keys:
1332 if key in self.__fields:
1333 setattr(self, key, kwargs[key])
1334 del kwargs[key]
1335 if __debug__:
1337 self._complainaboutunusedargs(pbfile,kwargs)
1338 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1339
1341
1342 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1343 'Writes this packet to the supplied buffer'
1344 self._bufferstartoffset=buf.getcurrentoffset()
1345 try: self.__field_items
1346 except:
1347 self.__field_items=LIST(**{ 'elementclass': pbfileentry, 'length': NUMPHONEBOOKENTRIES, 'createdefault': True})
1348 self.__field_items.writetobuffer(buf)
1349 try: self.__field_eof_tag
1350 except:
1351 self.__field_eof_tag=STRING(**{'sizeinbytes': 6, 'default': '<HPE>', 'raiseonunterminatedread': False, 'raiseontruncate': False })
1352 self.__field_eof_tag.writetobuffer(buf)
1353 try: self.__field_model_name
1354 except:
1355 self.__field_model_name=STRING(**{'sizeinbytes': 10, 'default': 'VX9100' })
1356 self.__field_model_name.writetobuffer(buf)
1357 try: self.__field_mod_date
1358 except:
1359 self.__field_mod_date=PBDateTime(**{ 'defaulttocurrenttime': True })
1360 self.__field_mod_date.writetobuffer(buf)
1361 try: self.__field_blanks
1362 except:
1363 self.__field_blanks=STRING(**{'sizeinbytes': 221, 'default': '' })
1364 self.__field_blanks.writetobuffer(buf)
1365 try: self.__field_eof_close_tag
1366 except:
1367 self.__field_eof_close_tag=STRING(**{'sizeinbytes': 7, 'default': '</HPE>', 'raiseonunterminatedread': False, 'raiseontruncate': False })
1368 self.__field_eof_close_tag.writetobuffer(buf)
1369 self._bufferendoffset=buf.getcurrentoffset()
1370 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1371
1372
1373 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1374 'Reads this packet from the supplied buffer'
1375 self._bufferstartoffset=buf.getcurrentoffset()
1376 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1377 self.__field_items=LIST(**{ 'elementclass': pbfileentry, 'length': NUMPHONEBOOKENTRIES, 'createdefault': True})
1378 self.__field_items.readfrombuffer(buf)
1379 self.__field_eof_tag=STRING(**{'sizeinbytes': 6, 'default': '<HPE>', 'raiseonunterminatedread': False, 'raiseontruncate': False })
1380 self.__field_eof_tag.readfrombuffer(buf)
1381 self.__field_model_name=STRING(**{'sizeinbytes': 10, 'default': 'VX9100' })
1382 self.__field_model_name.readfrombuffer(buf)
1383 self.__field_mod_date=PBDateTime(**{ 'defaulttocurrenttime': True })
1384 self.__field_mod_date.readfrombuffer(buf)
1385 self.__field_blanks=STRING(**{'sizeinbytes': 221, 'default': '' })
1386 self.__field_blanks.readfrombuffer(buf)
1387 self.__field_eof_close_tag=STRING(**{'sizeinbytes': 7, 'default': '</HPE>', 'raiseonunterminatedread': False, 'raiseontruncate': False })
1388 self.__field_eof_close_tag.readfrombuffer(buf)
1389 self._bufferendoffset=buf.getcurrentoffset()
1390
1391
1392 def __getfield_items(self):
1393 try: self.__field_items
1394 except:
1395 self.__field_items=LIST(**{ 'elementclass': pbfileentry, 'length': NUMPHONEBOOKENTRIES, 'createdefault': True})
1396 return self.__field_items.getvalue()
1397
1398 def __setfield_items(self, value):
1399 if isinstance(value,LIST):
1400 self.__field_items=value
1401 else:
1402 self.__field_items=LIST(value,**{ 'elementclass': pbfileentry, 'length': NUMPHONEBOOKENTRIES, 'createdefault': True})
1403
1404 def __delfield_items(self): del self.__field_items
1405
1406 items=property(__getfield_items, __setfield_items, __delfield_items, None)
1407
1408 def __getfield_eof_tag(self):
1409 try: self.__field_eof_tag
1410 except:
1411 self.__field_eof_tag=STRING(**{'sizeinbytes': 6, 'default': '<HPE>', 'raiseonunterminatedread': False, 'raiseontruncate': False })
1412 return self.__field_eof_tag.getvalue()
1413
1414 def __setfield_eof_tag(self, value):
1415 if isinstance(value,STRING):
1416 self.__field_eof_tag=value
1417 else:
1418 self.__field_eof_tag=STRING(value,**{'sizeinbytes': 6, 'default': '<HPE>', 'raiseonunterminatedread': False, 'raiseontruncate': False })
1419
1420 def __delfield_eof_tag(self): del self.__field_eof_tag
1421
1422 eof_tag=property(__getfield_eof_tag, __setfield_eof_tag, __delfield_eof_tag, None)
1423
1424 def __getfield_model_name(self):
1425 try: self.__field_model_name
1426 except:
1427 self.__field_model_name=STRING(**{'sizeinbytes': 10, 'default': 'VX9100' })
1428 return self.__field_model_name.getvalue()
1429
1430 def __setfield_model_name(self, value):
1431 if isinstance(value,STRING):
1432 self.__field_model_name=value
1433 else:
1434 self.__field_model_name=STRING(value,**{'sizeinbytes': 10, 'default': 'VX9100' })
1435
1436 def __delfield_model_name(self): del self.__field_model_name
1437
1438 model_name=property(__getfield_model_name, __setfield_model_name, __delfield_model_name, None)
1439
1440 def __getfield_mod_date(self):
1441 try: self.__field_mod_date
1442 except:
1443 self.__field_mod_date=PBDateTime(**{ 'defaulttocurrenttime': True })
1444 return self.__field_mod_date.getvalue()
1445
1446 def __setfield_mod_date(self, value):
1447 if isinstance(value,PBDateTime):
1448 self.__field_mod_date=value
1449 else:
1450 self.__field_mod_date=PBDateTime(value,**{ 'defaulttocurrenttime': True })
1451
1452 def __delfield_mod_date(self): del self.__field_mod_date
1453
1454 mod_date=property(__getfield_mod_date, __setfield_mod_date, __delfield_mod_date, None)
1455
1456 def __getfield_blanks(self):
1457 try: self.__field_blanks
1458 except:
1459 self.__field_blanks=STRING(**{'sizeinbytes': 221, 'default': '' })
1460 return self.__field_blanks.getvalue()
1461
1462 def __setfield_blanks(self, value):
1463 if isinstance(value,STRING):
1464 self.__field_blanks=value
1465 else:
1466 self.__field_blanks=STRING(value,**{'sizeinbytes': 221, 'default': '' })
1467
1468 def __delfield_blanks(self): del self.__field_blanks
1469
1470 blanks=property(__getfield_blanks, __setfield_blanks, __delfield_blanks, None)
1471
1472 def __getfield_eof_close_tag(self):
1473 try: self.__field_eof_close_tag
1474 except:
1475 self.__field_eof_close_tag=STRING(**{'sizeinbytes': 7, 'default': '</HPE>', 'raiseonunterminatedread': False, 'raiseontruncate': False })
1476 return self.__field_eof_close_tag.getvalue()
1477
1478 def __setfield_eof_close_tag(self, value):
1479 if isinstance(value,STRING):
1480 self.__field_eof_close_tag=value
1481 else:
1482 self.__field_eof_close_tag=STRING(value,**{'sizeinbytes': 7, 'default': '</HPE>', 'raiseonunterminatedread': False, 'raiseontruncate': False })
1483
1484 def __delfield_eof_close_tag(self): del self.__field_eof_close_tag
1485
1486 eof_close_tag=property(__getfield_eof_close_tag, __setfield_eof_close_tag, __delfield_eof_close_tag, None)
1487
1488 def iscontainer(self):
1489 return True
1490
1491 def containerelements(self):
1492 yield ('items', self.__field_items, None)
1493 yield ('eof_tag', self.__field_eof_tag, None)
1494 yield ('model_name', self.__field_model_name, None)
1495 yield ('mod_date', self.__field_mod_date, None)
1496 yield ('blanks', self.__field_blanks, None)
1497 yield ('eof_close_tag', self.__field_eof_close_tag, None)
1498
1499
1500
1501
1502 class pnfileentry(BaseProtogenClass):
1503 __fields=['entry_tag', 'pad00', 'mod_date', 'unk0', 'pn_id', 'pe_id', 'pn_order', 'phone_number', 'type', 'unk2', 'exit_tag', 'blanks']
1504
1505 def __init__(self, *args, **kwargs):
1506 dict={}
1507 dict.update(kwargs)
1509 super(pnfileentry,self).__init__(**dict)
1511 if self.__class__ is pnfileentry:
1512 self._update(args,dict)
1513
1514
1515 def getfields(self):
1516 return self.__fields
1517
1518
1519 def _update(self, args, kwargs):
1520 super(pnfileentry,self)._update(args,kwargs)
1521 keys=kwargs.keys()
1522 for key in keys:
1523 if key in self.__fields:
1524 setattr(self, key, kwargs[key])
1525 del kwargs[key]
1526 if __debug__:
1528 self._complainaboutunusedargs(pnfileentry,kwargs)
1529 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
1530
1532
1533 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1534 'Writes this packet to the supplied buffer'
1535 self._bufferstartoffset=buf.getcurrentoffset()
1536 try: self.__field_entry_tag
1537 except:
1538 self.__field_entry_tag=STRING(**{'sizeinbytes': 4, 'terminator': None, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'default': '\xff\xff\xff\xff'})
1539 self.__field_entry_tag.writetobuffer(buf)
1540 if self.entry_tag==PB_NUMBER_SOR:
1541 try: self.__field_pad00
1542 except:
1543 self.__field_pad00=UINT(**{'sizeinbytes': 1, 'default': 0 })
1544 self.__field_pad00.writetobuffer(buf)
1545 try: self.__field_mod_date
1546 except:
1547 self.__field_mod_date=PBDateTime(**{'defaulttocurrenttime': True })
1548 self.__field_mod_date.writetobuffer(buf)
1549 try: self.__field_unk0
1550 except:
1551 self.__field_unk0=STRING(**{'sizeinbytes': 6, 'default': '', 'raiseonunterminatedread': False })
1552 self.__field_unk0.writetobuffer(buf)
1553 self.__field_pn_id.writetobuffer(buf)
1554 self.__field_pe_id.writetobuffer(buf)
1555 self.__field_pn_order.writetobuffer(buf)
1556 self.__field_phone_number.writetobuffer(buf)
1557 self.__field_type.writetobuffer(buf)
1558 try: self.__field_unk2
1559 except:
1560 self.__field_unk2=UINT(**{'sizeinbytes': 3, 'default': 0 })
1561 self.__field_unk2.writetobuffer(buf)
1562 try: self.__field_exit_tag
1563 except:
1564 self.__field_exit_tag=USTRING(**{'sizeinbytes': 6, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'default': '</PN>'})
1565 self.__field_exit_tag.writetobuffer(buf)
1566 else:
1567 try: self.__field_blanks
1568 except:
1569 self.__field_blanks=DATA(**{'sizeinbytes': 60, 'default': '\xFF'*60 })
1570 self.__field_blanks.writetobuffer(buf)
1571 self._bufferendoffset=buf.getcurrentoffset()
1572 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1573
1574
1575 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1576 'Reads this packet from the supplied buffer'
1577 self._bufferstartoffset=buf.getcurrentoffset()
1578 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1579 self.__field_entry_tag=STRING(**{'sizeinbytes': 4, 'terminator': None, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'default': '\xff\xff\xff\xff'})
1580 self.__field_entry_tag.readfrombuffer(buf)
1581 if self.entry_tag==PB_NUMBER_SOR:
1582 self.__field_pad00=UINT(**{'sizeinbytes': 1, 'default': 0 })
1583 self.__field_pad00.readfrombuffer(buf)
1584 self.__field_mod_date=PBDateTime(**{'defaulttocurrenttime': True })
1585 self.__field_mod_date.readfrombuffer(buf)
1586 self.__field_unk0=STRING(**{'sizeinbytes': 6, 'default': '', 'raiseonunterminatedread': False })
1587 self.__field_unk0.readfrombuffer(buf)
1588 self.__field_pn_id=UINT(**{'sizeinbytes': 2})
1589 self.__field_pn_id.readfrombuffer(buf)
1590 self.__field_pe_id=UINT(**{'sizeinbytes': 2})
1591 self.__field_pe_id.readfrombuffer(buf)
1592 self.__field_pn_order=UINT(**{'sizeinbytes': 1})
1593 self.__field_pn_order.readfrombuffer(buf)
1594 self.__field_phone_number=LGHEXPN(**{'sizeinbytes': 25})
1595 self.__field_phone_number.readfrombuffer(buf)
1596 self.__field_type=UINT(**{'sizeinbytes': 2})
1597 self.__field_type.readfrombuffer(buf)
1598 self.__field_unk2=UINT(**{'sizeinbytes': 3, 'default': 0 })
1599 self.__field_unk2.readfrombuffer(buf)
1600 self.__field_exit_tag=USTRING(**{'sizeinbytes': 6, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'default': '</PN>'})
1601 self.__field_exit_tag.readfrombuffer(buf)
1602 else:
1603 self.__field_blanks=DATA(**{'sizeinbytes': 60, 'default': '\xFF'*60 })
1604 self.__field_blanks.readfrombuffer(buf)
1605 self._bufferendoffset=buf.getcurrentoffset()
1606
1607
1608 def __getfield_entry_tag(self):
1609 try: self.__field_entry_tag
1610 except:
1611 self.__field_entry_tag=STRING(**{'sizeinbytes': 4, 'terminator': None, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'default': '\xff\xff\xff\xff'})
1612 return self.__field_entry_tag.getvalue()
1613
1614 def __setfield_entry_tag(self, value):
1615 if isinstance(value,STRING):
1616 self.__field_entry_tag=value
1617 else:
1618 self.__field_entry_tag=STRING(value,**{'sizeinbytes': 4, 'terminator': None, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'default': '\xff\xff\xff\xff'})
1619
1620 def __delfield_entry_tag(self): del self.__field_entry_tag
1621
1622 entry_tag=property(__getfield_entry_tag, __setfield_entry_tag, __delfield_entry_tag, None)
1623
1624 def __getfield_pad00(self):
1625 try: self.__field_pad00
1626 except:
1627 self.__field_pad00=UINT(**{'sizeinbytes': 1, 'default': 0 })
1628 return self.__field_pad00.getvalue()
1629
1630 def __setfield_pad00(self, value):
1631 if isinstance(value,UINT):
1632 self.__field_pad00=value
1633 else:
1634 self.__field_pad00=UINT(value,**{'sizeinbytes': 1, 'default': 0 })
1635
1636 def __delfield_pad00(self): del self.__field_pad00
1637
1638 pad00=property(__getfield_pad00, __setfield_pad00, __delfield_pad00, None)
1639
1640 def __getfield_mod_date(self):
1641 try: self.__field_mod_date
1642 except:
1643 self.__field_mod_date=PBDateTime(**{'defaulttocurrenttime': True })
1644 return self.__field_mod_date.getvalue()
1645
1646 def __setfield_mod_date(self, value):
1647 if isinstance(value,PBDateTime):
1648 self.__field_mod_date=value
1649 else:
1650 self.__field_mod_date=PBDateTime(value,**{'defaulttocurrenttime': True })
1651
1652 def __delfield_mod_date(self): del self.__field_mod_date
1653
1654 mod_date=property(__getfield_mod_date, __setfield_mod_date, __delfield_mod_date, None)
1655
1656 def __getfield_unk0(self):
1657 try: self.__field_unk0
1658 except:
1659 self.__field_unk0=STRING(**{'sizeinbytes': 6, 'default': '', 'raiseonunterminatedread': False })
1660 return self.__field_unk0.getvalue()
1661
1662 def __setfield_unk0(self, value):
1663 if isinstance(value,STRING):
1664 self.__field_unk0=value
1665 else:
1666 self.__field_unk0=STRING(value,**{'sizeinbytes': 6, 'default': '', 'raiseonunterminatedread': False })
1667
1668 def __delfield_unk0(self): del self.__field_unk0
1669
1670 unk0=property(__getfield_unk0, __setfield_unk0, __delfield_unk0, None)
1671
1672 def __getfield_pn_id(self):
1673 return self.__field_pn_id.getvalue()
1674
1675 def __setfield_pn_id(self, value):
1676 if isinstance(value,UINT):
1677 self.__field_pn_id=value
1678 else:
1679 self.__field_pn_id=UINT(value,**{'sizeinbytes': 2})
1680
1681 def __delfield_pn_id(self): del self.__field_pn_id
1682
1683 pn_id=property(__getfield_pn_id, __setfield_pn_id, __delfield_pn_id, None)
1684
1685 def __getfield_pe_id(self):
1686 return self.__field_pe_id.getvalue()
1687
1688 def __setfield_pe_id(self, value):
1689 if isinstance(value,UINT):
1690 self.__field_pe_id=value
1691 else:
1692 self.__field_pe_id=UINT(value,**{'sizeinbytes': 2})
1693
1694 def __delfield_pe_id(self): del self.__field_pe_id
1695
1696 pe_id=property(__getfield_pe_id, __setfield_pe_id, __delfield_pe_id, None)
1697
1698 def __getfield_pn_order(self):
1699 return self.__field_pn_order.getvalue()
1700
1701 def __setfield_pn_order(self, value):
1702 if isinstance(value,UINT):
1703 self.__field_pn_order=value
1704 else:
1705 self.__field_pn_order=UINT(value,**{'sizeinbytes': 1})
1706
1707 def __delfield_pn_order(self): del self.__field_pn_order
1708
1709 pn_order=property(__getfield_pn_order, __setfield_pn_order, __delfield_pn_order, "0-based order of this phone within this contact")
1710
1711 def __getfield_phone_number(self):
1712 return self.__field_phone_number.getvalue()
1713
1714 def __setfield_phone_number(self, value):
1715 if isinstance(value,LGHEXPN):
1716 self.__field_phone_number=value
1717 else:
1718 self.__field_phone_number=LGHEXPN(value,**{'sizeinbytes': 25})
1719
1720 def __delfield_phone_number(self): del self.__field_phone_number
1721
1722 phone_number=property(__getfield_phone_number, __setfield_phone_number, __delfield_phone_number, None)
1723
1724 def __getfield_type(self):
1725 return self.__field_type.getvalue()
1726
1727 def __setfield_type(self, value):
1728 if isinstance(value,UINT):
1729 self.__field_type=value
1730 else:
1731 self.__field_type=UINT(value,**{'sizeinbytes': 2})
1732
1733 def __delfield_type(self): del self.__field_type
1734
1735 type=property(__getfield_type, __setfield_type, __delfield_type, None)
1736
1737 def __getfield_unk2(self):
1738 try: self.__field_unk2
1739 except:
1740 self.__field_unk2=UINT(**{'sizeinbytes': 3, 'default': 0 })
1741 return self.__field_unk2.getvalue()
1742
1743 def __setfield_unk2(self, value):
1744 if isinstance(value,UINT):
1745 self.__field_unk2=value
1746 else:
1747 self.__field_unk2=UINT(value,**{'sizeinbytes': 3, 'default': 0 })
1748
1749 def __delfield_unk2(self): del self.__field_unk2
1750
1751 unk2=property(__getfield_unk2, __setfield_unk2, __delfield_unk2, None)
1752
1753 def __getfield_exit_tag(self):
1754 try: self.__field_exit_tag
1755 except:
1756 self.__field_exit_tag=USTRING(**{'sizeinbytes': 6, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'default': '</PN>'})
1757 return self.__field_exit_tag.getvalue()
1758
1759 def __setfield_exit_tag(self, value):
1760 if isinstance(value,USTRING):
1761 self.__field_exit_tag=value
1762 else:
1763 self.__field_exit_tag=USTRING(value,**{'sizeinbytes': 6, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'default': '</PN>'})
1764
1765 def __delfield_exit_tag(self): del self.__field_exit_tag
1766
1767 exit_tag=property(__getfield_exit_tag, __setfield_exit_tag, __delfield_exit_tag, None)
1768
1769 def __getfield_blanks(self):
1770 try: self.__field_blanks
1771 except:
1772 self.__field_blanks=DATA(**{'sizeinbytes': 60, 'default': '\xFF'*60 })
1773 return self.__field_blanks.getvalue()
1774
1775 def __setfield_blanks(self, value):
1776 if isinstance(value,DATA):
1777 self.__field_blanks=value
1778 else:
1779 self.__field_blanks=DATA(value,**{'sizeinbytes': 60, 'default': '\xFF'*60 })
1780
1781 def __delfield_blanks(self): del self.__field_blanks
1782
1783 blanks=property(__getfield_blanks, __setfield_blanks, __delfield_blanks, None)
1784
1785 def iscontainer(self):
1786 return True
1787
1788 def containerelements(self):
1789 yield ('entry_tag', self.__field_entry_tag, None)
1790 if self.entry_tag==PB_NUMBER_SOR:
1791 yield ('pad00', self.__field_pad00, None)
1792 yield ('mod_date', self.__field_mod_date, None)
1793 yield ('unk0', self.__field_unk0, None)
1794 yield ('pn_id', self.__field_pn_id, None)
1795 yield ('pe_id', self.__field_pe_id, None)
1796 yield ('pn_order', self.__field_pn_order, "0-based order of this phone within this contact")
1797 yield ('phone_number', self.__field_phone_number, None)
1798 yield ('type', self.__field_type, None)
1799 yield ('unk2', self.__field_unk2, None)
1800 yield ('exit_tag', self.__field_exit_tag, None)
1801 else:
1802 yield ('blanks', self.__field_blanks, None)
1803
1804 def valid(self):
1805 global PB_NUMBER_SOR
1806 return self.entry_tag==PB_NUMBER_SOR
1807
1808
1809
1810
1811 class pnfile(BaseProtogenClass):
1812 __fields=['items']
1813
1814 def __init__(self, *args, **kwargs):
1815 dict={}
1816 dict.update(kwargs)
1818 super(pnfile,self).__init__(**dict)
1820 if self.__class__ is pnfile:
1821 self._update(args,dict)
1822
1823
1824 def getfields(self):
1825 return self.__fields
1826
1827
1828 def _update(self, args, kwargs):
1829 super(pnfile,self)._update(args,kwargs)
1830 keys=kwargs.keys()
1831 for key in keys:
1832 if key in self.__fields:
1833 setattr(self, key, kwargs[key])
1834 del kwargs[key]
1835 if __debug__:
1837 self._complainaboutunusedargs(pnfile,kwargs)
1838 if len(args):
1839 dict2={ 'elementclass': pnfileentry, 'createdefault': True, 'length': NUMPHONENUMBERENTRIES }
1840 dict2.update(kwargs)
1841 kwargs=dict2
1842 self.__field_items=LIST(*args,**dict2)
1843
1845
1846 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1847 'Writes this packet to the supplied buffer'
1848 self._bufferstartoffset=buf.getcurrentoffset()
1849 try: self.__field_items
1850 except:
1851 self.__field_items=LIST(**{ 'elementclass': pnfileentry, 'createdefault': True, 'length': NUMPHONENUMBERENTRIES })
1852 self.__field_items.writetobuffer(buf)
1853 self._bufferendoffset=buf.getcurrentoffset()
1854 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1855
1856
1857 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1858 'Reads this packet from the supplied buffer'
1859 self._bufferstartoffset=buf.getcurrentoffset()
1860 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1861 self.__field_items=LIST(**{ 'elementclass': pnfileentry, 'createdefault': True, 'length': NUMPHONENUMBERENTRIES })
1862 self.__field_items.readfrombuffer(buf)
1863 self._bufferendoffset=buf.getcurrentoffset()
1864
1865
1866 def __getfield_items(self):
1867 try: self.__field_items
1868 except:
1869 self.__field_items=LIST(**{ 'elementclass': pnfileentry, 'createdefault': True, 'length': NUMPHONENUMBERENTRIES })
1870 return self.__field_items.getvalue()
1871
1872 def __setfield_items(self, value):
1873 if isinstance(value,LIST):
1874 self.__field_items=value
1875 else:
1876 self.__field_items=LIST(value,**{ 'elementclass': pnfileentry, 'createdefault': True, 'length': NUMPHONENUMBERENTRIES })
1877
1878 def __delfield_items(self): del self.__field_items
1879
1880 items=property(__getfield_items, __setfield_items, __delfield_items, None)
1881
1882 def iscontainer(self):
1883 return True
1884
1885 def containerelements(self):
1886 yield ('items', self.__field_items, None)
1887
1888
1889
1890
1891 class PathIndexEntry(BaseProtogenClass):
1892 __fields=['pathname']
1893
1894 def __init__(self, *args, **kwargs):
1895 dict={}
1896 dict.update(kwargs)
1898 super(PathIndexEntry,self).__init__(**dict)
1900 if self.__class__ is PathIndexEntry:
1901 self._update(args,dict)
1902
1903
1904 def getfields(self):
1905 return self.__fields
1906
1907
1908 def _update(self, args, kwargs):
1909 super(PathIndexEntry,self)._update(args,kwargs)
1910 keys=kwargs.keys()
1911 for key in keys:
1912 if key in self.__fields:
1913 setattr(self, key, kwargs[key])
1914 del kwargs[key]
1915 if __debug__:
1917 self._complainaboutunusedargs(PathIndexEntry,kwargs)
1918 if len(args):
1919 dict2={'sizeinbytes': 255, 'encoding': PHONE_ENCODING, 'default': '' }
1920 dict2.update(kwargs)
1921 kwargs=dict2
1922 self.__field_pathname=USTRING(*args,**dict2)
1923
1925
1926 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
1927 'Writes this packet to the supplied buffer'
1928 self._bufferstartoffset=buf.getcurrentoffset()
1929 try: self.__field_pathname
1930 except:
1931 self.__field_pathname=USTRING(**{'sizeinbytes': 255, 'encoding': PHONE_ENCODING, 'default': '' })
1932 self.__field_pathname.writetobuffer(buf)
1933 self._bufferendoffset=buf.getcurrentoffset()
1934 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
1935
1936
1937 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
1938 'Reads this packet from the supplied buffer'
1939 self._bufferstartoffset=buf.getcurrentoffset()
1940 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
1941 self.__field_pathname=USTRING(**{'sizeinbytes': 255, 'encoding': PHONE_ENCODING, 'default': '' })
1942 self.__field_pathname.readfrombuffer(buf)
1943 self._bufferendoffset=buf.getcurrentoffset()
1944
1945
1946 def __getfield_pathname(self):
1947 try: self.__field_pathname
1948 except:
1949 self.__field_pathname=USTRING(**{'sizeinbytes': 255, 'encoding': PHONE_ENCODING, 'default': '' })
1950 return self.__field_pathname.getvalue()
1951
1952 def __setfield_pathname(self, value):
1953 if isinstance(value,USTRING):
1954 self.__field_pathname=value
1955 else:
1956 self.__field_pathname=USTRING(value,**{'sizeinbytes': 255, 'encoding': PHONE_ENCODING, 'default': '' })
1957
1958 def __delfield_pathname(self): del self.__field_pathname
1959
1960 pathname=property(__getfield_pathname, __setfield_pathname, __delfield_pathname, None)
1961
1962 def iscontainer(self):
1963 return True
1964
1965 def containerelements(self):
1966 yield ('pathname', self.__field_pathname, None)
1967
1968
1969
1970
1971 class PathIndexFile(BaseProtogenClass):
1972 __fields=['items']
1973
1974 def __init__(self, *args, **kwargs):
1975 dict={}
1976 dict.update(kwargs)
1978 super(PathIndexFile,self).__init__(**dict)
1980 if self.__class__ is PathIndexFile:
1981 self._update(args,dict)
1982
1983
1984 def getfields(self):
1985 return self.__fields
1986
1987
1988 def _update(self, args, kwargs):
1989 super(PathIndexFile,self)._update(args,kwargs)
1990 keys=kwargs.keys()
1991 for key in keys:
1992 if key in self.__fields:
1993 setattr(self, key, kwargs[key])
1994 del kwargs[key]
1995 if __debug__:
1997 self._complainaboutunusedargs(PathIndexFile,kwargs)
1998 if len(args):
1999 dict2={ 'elementclass': PathIndexEntry, 'createdefault': True, 'length': NUMPHONEBOOKENTRIES }
2000 dict2.update(kwargs)
2001 kwargs=dict2
2002 self.__field_items=LIST(*args,**dict2)
2003
2005
2006 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2007 'Writes this packet to the supplied buffer'
2008 self._bufferstartoffset=buf.getcurrentoffset()
2009 try: self.__field_items
2010 except:
2011 self.__field_items=LIST(**{ 'elementclass': PathIndexEntry, 'createdefault': True, 'length': NUMPHONEBOOKENTRIES })
2012 self.__field_items.writetobuffer(buf)
2013 self._bufferendoffset=buf.getcurrentoffset()
2014 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2015
2016
2017 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2018 'Reads this packet from the supplied buffer'
2019 self._bufferstartoffset=buf.getcurrentoffset()
2020 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2021 self.__field_items=LIST(**{ 'elementclass': PathIndexEntry, 'createdefault': True, 'length': NUMPHONEBOOKENTRIES })
2022 self.__field_items.readfrombuffer(buf)
2023 self._bufferendoffset=buf.getcurrentoffset()
2024
2025
2026 def __getfield_items(self):
2027 try: self.__field_items
2028 except:
2029 self.__field_items=LIST(**{ 'elementclass': PathIndexEntry, 'createdefault': True, 'length': NUMPHONEBOOKENTRIES })
2030 return self.__field_items.getvalue()
2031
2032 def __setfield_items(self, value):
2033 if isinstance(value,LIST):
2034 self.__field_items=value
2035 else:
2036 self.__field_items=LIST(value,**{ 'elementclass': PathIndexEntry, 'createdefault': True, 'length': NUMPHONEBOOKENTRIES })
2037
2038 def __delfield_items(self): del self.__field_items
2039
2040 items=property(__getfield_items, __setfield_items, __delfield_items, None)
2041
2042 def iscontainer(self):
2043 return True
2044
2045 def containerelements(self):
2046 yield ('items', self.__field_items, None)
2047
2048
2049
2050
2051 class RecordIdEntry(BaseProtogenClass):
2052 __fields=['idnum']
2053
2054 def __init__(self, *args, **kwargs):
2055 dict={}
2056 dict.update(kwargs)
2058 super(RecordIdEntry,self).__init__(**dict)
2060 if self.__class__ is RecordIdEntry:
2061 self._update(args,dict)
2062
2063
2064 def getfields(self):
2065 return self.__fields
2066
2067
2068 def _update(self, args, kwargs):
2069 super(RecordIdEntry,self)._update(args,kwargs)
2070 keys=kwargs.keys()
2071 for key in keys:
2072 if key in self.__fields:
2073 setattr(self, key, kwargs[key])
2074 del kwargs[key]
2075 if __debug__:
2077 self._complainaboutunusedargs(RecordIdEntry,kwargs)
2078 if len(args):
2079 dict2={'sizeinbytes': 4}
2080 dict2.update(kwargs)
2081 kwargs=dict2
2082 self.__field_idnum=UINT(*args,**dict2)
2083
2085
2086 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2087 'Writes this packet to the supplied buffer'
2088 self._bufferstartoffset=buf.getcurrentoffset()
2089 self.__field_idnum.writetobuffer(buf)
2090 self._bufferendoffset=buf.getcurrentoffset()
2091 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2092
2093
2094 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2095 'Reads this packet from the supplied buffer'
2096 self._bufferstartoffset=buf.getcurrentoffset()
2097 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2098 self.__field_idnum=UINT(**{'sizeinbytes': 4})
2099 self.__field_idnum.readfrombuffer(buf)
2100 self._bufferendoffset=buf.getcurrentoffset()
2101
2102
2103 def __getfield_idnum(self):
2104 return self.__field_idnum.getvalue()
2105
2106 def __setfield_idnum(self, value):
2107 if isinstance(value,UINT):
2108 self.__field_idnum=value
2109 else:
2110 self.__field_idnum=UINT(value,**{'sizeinbytes': 4})
2111
2112 def __delfield_idnum(self): del self.__field_idnum
2113
2114 idnum=property(__getfield_idnum, __setfield_idnum, __delfield_idnum, None)
2115
2116 def iscontainer(self):
2117 return True
2118
2119 def containerelements(self):
2120 yield ('idnum', self.__field_idnum, None)
2121
2122
2123
2124
2125 class iceentry(BaseProtogenClass):
2126 "ICE index entries"
2127 __fields=['entry_assigned', 'entry_number', 'pb_index', 'dontcare']
2128
2129 def __init__(self, *args, **kwargs):
2130 dict={}
2131 dict.update(kwargs)
2133 super(iceentry,self).__init__(**dict)
2135 if self.__class__ is iceentry:
2136 self._update(args,dict)
2137
2138
2139 def getfields(self):
2140 return self.__fields
2141
2142
2143 def _update(self, args, kwargs):
2144 super(iceentry,self)._update(args,kwargs)
2145 keys=kwargs.keys()
2146 for key in keys:
2147 if key in self.__fields:
2148 setattr(self, key, kwargs[key])
2149 del kwargs[key]
2150 if __debug__:
2152 self._complainaboutunusedargs(iceentry,kwargs)
2153 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2154
2156
2157 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2158 'Writes this packet to the supplied buffer'
2159 self._bufferstartoffset=buf.getcurrentoffset()
2160 try: self.__field_entry_assigned
2161 except:
2162 self.__field_entry_assigned=UINT(**{'sizeinbytes': 2, 'default': 0x0000 })
2163 self.__field_entry_assigned.writetobuffer(buf)
2164 try: self.__field_entry_number
2165 except:
2166 self.__field_entry_number=UINT(**{'sizeinbytes': 2, 'default': 0xFFFF })
2167 self.__field_entry_number.writetobuffer(buf)
2168 try: self.__field_pb_index
2169 except:
2170 self.__field_pb_index=UINT(**{'sizeinbytes': 2, 'default': 0x0000 })
2171 self.__field_pb_index.writetobuffer(buf)
2172 try: self.__field_dontcare
2173 except:
2174 self.__field_dontcare=DATA(**{'sizeinbytes': 82, 'default': '\x00'*82 })
2175 self.__field_dontcare.writetobuffer(buf)
2176 self._bufferendoffset=buf.getcurrentoffset()
2177 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2178
2179
2180 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2181 'Reads this packet from the supplied buffer'
2182 self._bufferstartoffset=buf.getcurrentoffset()
2183 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2184 self.__field_entry_assigned=UINT(**{'sizeinbytes': 2, 'default': 0x0000 })
2185 self.__field_entry_assigned.readfrombuffer(buf)
2186 self.__field_entry_number=UINT(**{'sizeinbytes': 2, 'default': 0xFFFF })
2187 self.__field_entry_number.readfrombuffer(buf)
2188 self.__field_pb_index=UINT(**{'sizeinbytes': 2, 'default': 0x0000 })
2189 self.__field_pb_index.readfrombuffer(buf)
2190 self.__field_dontcare=DATA(**{'sizeinbytes': 82, 'default': '\x00'*82 })
2191 self.__field_dontcare.readfrombuffer(buf)
2192 self._bufferendoffset=buf.getcurrentoffset()
2193
2194
2195 def __getfield_entry_assigned(self):
2196 try: self.__field_entry_assigned
2197 except:
2198 self.__field_entry_assigned=UINT(**{'sizeinbytes': 2, 'default': 0x0000 })
2199 return self.__field_entry_assigned.getvalue()
2200
2201 def __setfield_entry_assigned(self, value):
2202 if isinstance(value,UINT):
2203 self.__field_entry_assigned=value
2204 else:
2205 self.__field_entry_assigned=UINT(value,**{'sizeinbytes': 2, 'default': 0x0000 })
2206
2207 def __delfield_entry_assigned(self): del self.__field_entry_assigned
2208
2209 entry_assigned=property(__getfield_entry_assigned, __setfield_entry_assigned, __delfield_entry_assigned, "0 if not assigned, 1 if assigned")
2210
2211 def __getfield_entry_number(self):
2212 try: self.__field_entry_number
2213 except:
2214 self.__field_entry_number=UINT(**{'sizeinbytes': 2, 'default': 0xFFFF })
2215 return self.__field_entry_number.getvalue()
2216
2217 def __setfield_entry_number(self, value):
2218 if isinstance(value,UINT):
2219 self.__field_entry_number=value
2220 else:
2221 self.__field_entry_number=UINT(value,**{'sizeinbytes': 2, 'default': 0xFFFF })
2222
2223 def __delfield_entry_number(self): del self.__field_entry_number
2224
2225 entry_number=property(__getfield_entry_number, __setfield_entry_number, __delfield_entry_number, "0-based ICE entry number when assigned, 0xffff if unassigned")
2226
2227 def __getfield_pb_index(self):
2228 try: self.__field_pb_index
2229 except:
2230 self.__field_pb_index=UINT(**{'sizeinbytes': 2, 'default': 0x0000 })
2231 return self.__field_pb_index.getvalue()
2232
2233 def __setfield_pb_index(self, value):
2234 if isinstance(value,UINT):
2235 self.__field_pb_index=value
2236 else:
2237 self.__field_pb_index=UINT(value,**{'sizeinbytes': 2, 'default': 0x0000 })
2238
2239 def __delfield_pb_index(self): del self.__field_pb_index
2240
2241 pb_index=property(__getfield_pb_index, __setfield_pb_index, __delfield_pb_index, "0-based phone book entry number")
2242
2243 def __getfield_dontcare(self):
2244 try: self.__field_dontcare
2245 except:
2246 self.__field_dontcare=DATA(**{'sizeinbytes': 82, 'default': '\x00'*82 })
2247 return self.__field_dontcare.getvalue()
2248
2249 def __setfield_dontcare(self, value):
2250 if isinstance(value,DATA):
2251 self.__field_dontcare=value
2252 else:
2253 self.__field_dontcare=DATA(value,**{'sizeinbytes': 82, 'default': '\x00'*82 })
2254
2255 def __delfield_dontcare(self): del self.__field_dontcare
2256
2257 dontcare=property(__getfield_dontcare, __setfield_dontcare, __delfield_dontcare, None)
2258
2259 def iscontainer(self):
2260 return True
2261
2262 def containerelements(self):
2263 yield ('entry_assigned', self.__field_entry_assigned, "0 if not assigned, 1 if assigned")
2264 yield ('entry_number', self.__field_entry_number, "0-based ICE entry number when assigned, 0xffff if unassigned")
2265 yield ('pb_index', self.__field_pb_index, "0-based phone book entry number")
2266 yield ('dontcare', self.__field_dontcare, None)
2267
2268 def valid(self):
2269 return self.entry_assigned==1 and \
2270 self.entry_number<NUMEMERGENCYCONTACTS and \
2271 self.pb_index<NUMPHONEBOOKENTRIES
2272
2273
2274
2275
2276 class iceentryfile(BaseProtogenClass):
2277 __fields=['items']
2278
2279 def __init__(self, *args, **kwargs):
2280 dict={}
2281 dict.update(kwargs)
2283 super(iceentryfile,self).__init__(**dict)
2285 if self.__class__ is iceentryfile:
2286 self._update(args,dict)
2287
2288
2289 def getfields(self):
2290 return self.__fields
2291
2292
2293 def _update(self, args, kwargs):
2294 super(iceentryfile,self)._update(args,kwargs)
2295 keys=kwargs.keys()
2296 for key in keys:
2297 if key in self.__fields:
2298 setattr(self, key, kwargs[key])
2299 del kwargs[key]
2300 if __debug__:
2302 self._complainaboutunusedargs(iceentryfile,kwargs)
2303 if len(args):
2304 dict2={ 'elementclass': iceentry, 'createdefault': True, 'length': NUMEMERGENCYCONTACTS }
2305 dict2.update(kwargs)
2306 kwargs=dict2
2307 self.__field_items=LIST(*args,**dict2)
2308
2310
2311 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2312 'Writes this packet to the supplied buffer'
2313 self._bufferstartoffset=buf.getcurrentoffset()
2314 try: self.__field_items
2315 except:
2316 self.__field_items=LIST(**{ 'elementclass': iceentry, 'createdefault': True, 'length': NUMEMERGENCYCONTACTS })
2317 self.__field_items.writetobuffer(buf)
2318 self._bufferendoffset=buf.getcurrentoffset()
2319 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2320
2321
2322 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2323 'Reads this packet from the supplied buffer'
2324 self._bufferstartoffset=buf.getcurrentoffset()
2325 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2326 self.__field_items=LIST(**{ 'elementclass': iceentry, 'createdefault': True, 'length': NUMEMERGENCYCONTACTS })
2327 self.__field_items.readfrombuffer(buf)
2328 self._bufferendoffset=buf.getcurrentoffset()
2329
2330
2331 def __getfield_items(self):
2332 try: self.__field_items
2333 except:
2334 self.__field_items=LIST(**{ 'elementclass': iceentry, 'createdefault': True, 'length': NUMEMERGENCYCONTACTS })
2335 return self.__field_items.getvalue()
2336
2337 def __setfield_items(self, value):
2338 if isinstance(value,LIST):
2339 self.__field_items=value
2340 else:
2341 self.__field_items=LIST(value,**{ 'elementclass': iceentry, 'createdefault': True, 'length': NUMEMERGENCYCONTACTS })
2342
2343 def __delfield_items(self): del self.__field_items
2344
2345 items=property(__getfield_items, __setfield_items, __delfield_items, None)
2346
2347 def iscontainer(self):
2348 return True
2349
2350 def containerelements(self):
2351 yield ('items', self.__field_items, None)
2352
2353
2354
2355
2356 class scheduleevent(BaseProtogenClass):
2357 __fields=['packet_size', 'pos', 'description', 'cdate', 'mdate', 'start', 'end_time', 'end_date', 'repeat', 'alarmindex_vibrate', 'ringtone', 'unknown1', 'alarmminutes', 'alarmhours', 'unknown2', 'unknown3', 'unknown4', 'serial_number', 'blanks']
2358
2359 def __init__(self, *args, **kwargs):
2360 dict={}
2361 dict.update(kwargs)
2363 super(scheduleevent,self).__init__(**dict)
2365 if self.__class__ is scheduleevent:
2366 self._update(args,dict)
2367
2368
2369 def getfields(self):
2370 return self.__fields
2371
2372
2373 def _update(self, args, kwargs):
2374 super(scheduleevent,self)._update(args,kwargs)
2375 keys=kwargs.keys()
2376 for key in keys:
2377 if key in self.__fields:
2378 setattr(self, key, kwargs[key])
2379 del kwargs[key]
2380 if __debug__:
2382 self._complainaboutunusedargs(scheduleevent,kwargs)
2383 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2384 try: self.__field_packet_size
2386 except:
2387 self.__field_packet_size=UINT(**{ 'constant': 138 })
2388
2389
2390 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2391 'Writes this packet to the supplied buffer'
2392 self._bufferstartoffset=buf.getcurrentoffset()
2393 try: self.__field_pos
2394 except:
2395 self.__field_pos=UINT(**{'sizeinbytes': 4, 'default': 0xffffffff })
2396 self.__field_pos.writetobuffer(buf)
2397 if self.pos!=0xffffffff:
2398 try: self.__field_description
2399 except:
2400 self.__field_description=USTRING(**{'sizeinbytes': 33, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'default': '' })
2401 self.__field_description.writetobuffer(buf)
2402 try: self.__field_cdate
2403 except:
2404 self.__field_cdate=GPSDATE(**{'sizeinbytes': 4, 'default': GPSDATE.now() })
2405 self.__field_cdate.writetobuffer(buf)
2406 try: self.__field_mdate
2407 except:
2408 self.__field_mdate=GPSDATE(**{'sizeinbytes': 4, 'default': GPSDATE.now() })
2409 self.__field_mdate.writetobuffer(buf)
2410 try: self.__field_start
2411 except:
2412 self.__field_start=LGCALDATE(**{'sizeinbytes': 4, 'default': (0,0,0,0,0) })
2413 self.__field_start.writetobuffer(buf)
2414 try: self.__field_end_time
2415 except:
2416 self.__field_end_time=LGCALDATE(**{'sizeinbytes': 4, 'default': (0,0,0,0,0) })
2417 self.__field_end_time.writetobuffer(buf)
2418 try: self.__field_end_date
2419 except:
2420 self.__field_end_date=LGCALDATE(**{'sizeinbytes': 4, 'default': (0,0,0,0,0) })
2421 self.__field_end_date.writetobuffer(buf)
2422 try: self.__field_repeat
2423 except:
2424 self.__field_repeat=LGCALREPEAT(**{'sizeinbytes': 4, 'default': (0,0,0,0,0) })
2425 self.__field_repeat.writetobuffer(buf)
2426 try: self.__field_alarmindex_vibrate
2427 except:
2428 self.__field_alarmindex_vibrate=UINT(**{'sizeinbytes': 1, 'default': 0 })
2429 self.__field_alarmindex_vibrate.writetobuffer(buf)
2430 try: self.__field_ringtone
2431 except:
2432 self.__field_ringtone=UINT(**{'sizeinbytes': 1, 'default': 0 })
2433 self.__field_ringtone.writetobuffer(buf)
2434 try: self.__field_unknown1
2435 except:
2436 self.__field_unknown1=UINT(**{'sizeinbytes': 1, 'default': 0 })
2437 self.__field_unknown1.writetobuffer(buf)
2438 try: self.__field_alarmminutes
2439 except:
2440 self.__field_alarmminutes=UINT(**{'sizeinbytes': 1, 'default': 0xff })
2441 self.__field_alarmminutes.writetobuffer(buf)
2442 try: self.__field_alarmhours
2443 except:
2444 self.__field_alarmhours=UINT(**{'sizeinbytes': 1, 'default': 0xff })
2445 self.__field_alarmhours.writetobuffer(buf)
2446 try: self.__field_unknown2
2447 except:
2448 self.__field_unknown2=UINT(**{'sizeinbytes': 1, 'default': 0 })
2449 self.__field_unknown2.writetobuffer(buf)
2450 try: self.__field_unknown3
2451 except:
2452 self.__field_unknown3=UINT(**{'sizeinbytes': 2, 'default': 0x01FC })
2453 self.__field_unknown3.writetobuffer(buf)
2454 try: self.__field_unknown4
2455 except:
2456 self.__field_unknown4=UINT(**{'sizeinbytes': 4, 'default': 0 })
2457 self.__field_unknown4.writetobuffer(buf)
2458 try: self.__field_serial_number
2459 except:
2460 self.__field_serial_number=USTRING(**{'sizeinbytes': 65, 'default': '000000d1-00000000-0000000000-VX910V03', 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'raiseontruncate': False })
2461 self.__field_serial_number.writetobuffer(buf)
2462 else:
2463 try: self.__field_blanks
2464 except:
2465 self.__field_blanks=STRING(**{'sizeinbytes': 134, 'default': '', 'terminator': 0xff, 'pad': 0xff })
2466 self.__field_blanks.writetobuffer(buf)
2467 self._bufferendoffset=buf.getcurrentoffset()
2468 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2469
2470
2471 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2472 'Reads this packet from the supplied buffer'
2473 self._bufferstartoffset=buf.getcurrentoffset()
2474 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2475 self.__field_pos=UINT(**{'sizeinbytes': 4, 'default': 0xffffffff })
2476 self.__field_pos.readfrombuffer(buf)
2477 if self.pos!=0xffffffff:
2478 self.__field_description=USTRING(**{'sizeinbytes': 33, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'default': '' })
2479 self.__field_description.readfrombuffer(buf)
2480 self.__field_cdate=GPSDATE(**{'sizeinbytes': 4, 'default': GPSDATE.now() })
2481 self.__field_cdate.readfrombuffer(buf)
2482 self.__field_mdate=GPSDATE(**{'sizeinbytes': 4, 'default': GPSDATE.now() })
2483 self.__field_mdate.readfrombuffer(buf)
2484 self.__field_start=LGCALDATE(**{'sizeinbytes': 4, 'default': (0,0,0,0,0) })
2485 self.__field_start.readfrombuffer(buf)
2486 self.__field_end_time=LGCALDATE(**{'sizeinbytes': 4, 'default': (0,0,0,0,0) })
2487 self.__field_end_time.readfrombuffer(buf)
2488 self.__field_end_date=LGCALDATE(**{'sizeinbytes': 4, 'default': (0,0,0,0,0) })
2489 self.__field_end_date.readfrombuffer(buf)
2490 self.__field_repeat=LGCALREPEAT(**{'sizeinbytes': 4, 'default': (0,0,0,0,0) })
2491 self.__field_repeat.readfrombuffer(buf)
2492 self.__field_alarmindex_vibrate=UINT(**{'sizeinbytes': 1, 'default': 0 })
2493 self.__field_alarmindex_vibrate.readfrombuffer(buf)
2494 self.__field_ringtone=UINT(**{'sizeinbytes': 1, 'default': 0 })
2495 self.__field_ringtone.readfrombuffer(buf)
2496 self.__field_unknown1=UINT(**{'sizeinbytes': 1, 'default': 0 })
2497 self.__field_unknown1.readfrombuffer(buf)
2498 self.__field_alarmminutes=UINT(**{'sizeinbytes': 1, 'default': 0xff })
2499 self.__field_alarmminutes.readfrombuffer(buf)
2500 self.__field_alarmhours=UINT(**{'sizeinbytes': 1, 'default': 0xff })
2501 self.__field_alarmhours.readfrombuffer(buf)
2502 self.__field_unknown2=UINT(**{'sizeinbytes': 1, 'default': 0 })
2503 self.__field_unknown2.readfrombuffer(buf)
2504 self.__field_unknown3=UINT(**{'sizeinbytes': 2, 'default': 0x01FC })
2505 self.__field_unknown3.readfrombuffer(buf)
2506 self.__field_unknown4=UINT(**{'sizeinbytes': 4, 'default': 0 })
2507 self.__field_unknown4.readfrombuffer(buf)
2508 self.__field_serial_number=USTRING(**{'sizeinbytes': 65, 'default': '000000d1-00000000-0000000000-VX910V03', 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'raiseontruncate': False })
2509 self.__field_serial_number.readfrombuffer(buf)
2510 else:
2511 self.__field_blanks=STRING(**{'sizeinbytes': 134, 'default': '', 'terminator': 0xff, 'pad': 0xff })
2512 self.__field_blanks.readfrombuffer(buf)
2513 self._bufferendoffset=buf.getcurrentoffset()
2514
2515
2516 def __getfield_packet_size(self):
2517 return self.__field_packet_size.getvalue()
2518
2519 def __setfield_packet_size(self, value):
2520 if isinstance(value,UINT):
2521 self.__field_packet_size=value
2522 else:
2523 self.__field_packet_size=UINT(value,**{ 'constant': 138 })
2524
2525 def __delfield_packet_size(self): del self.__field_packet_size
2526
2527 packet_size=property(__getfield_packet_size, __setfield_packet_size, __delfield_packet_size, None)
2528
2529 def __getfield_pos(self):
2530 try: self.__field_pos
2531 except:
2532 self.__field_pos=UINT(**{'sizeinbytes': 4, 'default': 0xffffffff })
2533 return self.__field_pos.getvalue()
2534
2535 def __setfield_pos(self, value):
2536 if isinstance(value,UINT):
2537 self.__field_pos=value
2538 else:
2539 self.__field_pos=UINT(value,**{'sizeinbytes': 4, 'default': 0xffffffff })
2540
2541 def __delfield_pos(self): del self.__field_pos
2542
2543 pos=property(__getfield_pos, __setfield_pos, __delfield_pos, "position within file, used as an event id")
2544
2545 def __getfield_description(self):
2546 try: self.__field_description
2547 except:
2548 self.__field_description=USTRING(**{'sizeinbytes': 33, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'default': '' })
2549 return self.__field_description.getvalue()
2550
2551 def __setfield_description(self, value):
2552 if isinstance(value,USTRING):
2553 self.__field_description=value
2554 else:
2555 self.__field_description=USTRING(value,**{'sizeinbytes': 33, 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'raiseontruncate': False, 'default': '' })
2556
2557 def __delfield_description(self): del self.__field_description
2558
2559 description=property(__getfield_description, __setfield_description, __delfield_description, None)
2560
2561 def __getfield_cdate(self):
2562 try: self.__field_cdate
2563 except:
2564 self.__field_cdate=GPSDATE(**{'sizeinbytes': 4, 'default': GPSDATE.now() })
2565 return self.__field_cdate.getvalue()
2566
2567 def __setfield_cdate(self, value):
2568 if isinstance(value,GPSDATE):
2569 self.__field_cdate=value
2570 else:
2571 self.__field_cdate=GPSDATE(value,**{'sizeinbytes': 4, 'default': GPSDATE.now() })
2572
2573 def __delfield_cdate(self): del self.__field_cdate
2574
2575 cdate=property(__getfield_cdate, __setfield_cdate, __delfield_cdate, None)
2576
2577 def __getfield_mdate(self):
2578 try: self.__field_mdate
2579 except:
2580 self.__field_mdate=GPSDATE(**{'sizeinbytes': 4, 'default': GPSDATE.now() })
2581 return self.__field_mdate.getvalue()
2582
2583 def __setfield_mdate(self, value):
2584 if isinstance(value,GPSDATE):
2585 self.__field_mdate=value
2586 else:
2587 self.__field_mdate=GPSDATE(value,**{'sizeinbytes': 4, 'default': GPSDATE.now() })
2588
2589 def __delfield_mdate(self): del self.__field_mdate
2590
2591 mdate=property(__getfield_mdate, __setfield_mdate, __delfield_mdate, None)
2592
2593 def __getfield_start(self):
2594 try: self.__field_start
2595 except:
2596 self.__field_start=LGCALDATE(**{'sizeinbytes': 4, 'default': (0,0,0,0,0) })
2597 return self.__field_start.getvalue()
2598
2599 def __setfield_start(self, value):
2600 if isinstance(value,LGCALDATE):
2601 self.__field_start=value
2602 else:
2603 self.__field_start=LGCALDATE(value,**{'sizeinbytes': 4, 'default': (0,0,0,0,0) })
2604
2605 def __delfield_start(self): del self.__field_start
2606
2607 start=property(__getfield_start, __setfield_start, __delfield_start, None)
2608
2609 def __getfield_end_time(self):
2610 try: self.__field_end_time
2611 except:
2612 self.__field_end_time=LGCALDATE(**{'sizeinbytes': 4, 'default': (0,0,0,0,0) })
2613 return self.__field_end_time.getvalue()
2614
2615 def __setfield_end_time(self, value):
2616 if isinstance(value,LGCALDATE):
2617 self.__field_end_time=value
2618 else:
2619 self.__field_end_time=LGCALDATE(value,**{'sizeinbytes': 4, 'default': (0,0,0,0,0) })
2620
2621 def __delfield_end_time(self): del self.__field_end_time
2622
2623 end_time=property(__getfield_end_time, __setfield_end_time, __delfield_end_time, None)
2624
2625 def __getfield_end_date(self):
2626 try: self.__field_end_date
2627 except:
2628 self.__field_end_date=LGCALDATE(**{'sizeinbytes': 4, 'default': (0,0,0,0,0) })
2629 return self.__field_end_date.getvalue()
2630
2631 def __setfield_end_date(self, value):
2632 if isinstance(value,LGCALDATE):
2633 self.__field_end_date=value
2634 else:
2635 self.__field_end_date=LGCALDATE(value,**{'sizeinbytes': 4, 'default': (0,0,0,0,0) })
2636
2637 def __delfield_end_date(self): del self.__field_end_date
2638
2639 end_date=property(__getfield_end_date, __setfield_end_date, __delfield_end_date, None)
2640
2641 def __getfield_repeat(self):
2642 try: self.__field_repeat
2643 except:
2644 self.__field_repeat=LGCALREPEAT(**{'sizeinbytes': 4, 'default': (0,0,0,0,0) })
2645 return self.__field_repeat.getvalue()
2646
2647 def __setfield_repeat(self, value):
2648 if isinstance(value,LGCALREPEAT):
2649 self.__field_repeat=value
2650 else:
2651 self.__field_repeat=LGCALREPEAT(value,**{'sizeinbytes': 4, 'default': (0,0,0,0,0) })
2652
2653 def __delfield_repeat(self): del self.__field_repeat
2654
2655 repeat=property(__getfield_repeat, __setfield_repeat, __delfield_repeat, None)
2656
2657 def __getfield_alarmindex_vibrate(self):
2658 try: self.__field_alarmindex_vibrate
2659 except:
2660 self.__field_alarmindex_vibrate=UINT(**{'sizeinbytes': 1, 'default': 0 })
2661 return self.__field_alarmindex_vibrate.getvalue()
2662
2663 def __setfield_alarmindex_vibrate(self, value):
2664 if isinstance(value,UINT):
2665 self.__field_alarmindex_vibrate=value
2666 else:
2667 self.__field_alarmindex_vibrate=UINT(value,**{'sizeinbytes': 1, 'default': 0 })
2668
2669 def __delfield_alarmindex_vibrate(self): del self.__field_alarmindex_vibrate
2670
2671 alarmindex_vibrate=property(__getfield_alarmindex_vibrate, __setfield_alarmindex_vibrate, __delfield_alarmindex_vibrate, None)
2672
2673 def __getfield_ringtone(self):
2674 try: self.__field_ringtone
2675 except:
2676 self.__field_ringtone=UINT(**{'sizeinbytes': 1, 'default': 0 })
2677 return self.__field_ringtone.getvalue()
2678
2679 def __setfield_ringtone(self, value):
2680 if isinstance(value,UINT):
2681 self.__field_ringtone=value
2682 else:
2683 self.__field_ringtone=UINT(value,**{'sizeinbytes': 1, 'default': 0 })
2684
2685 def __delfield_ringtone(self): del self.__field_ringtone
2686
2687 ringtone=property(__getfield_ringtone, __setfield_ringtone, __delfield_ringtone, None)
2688
2689 def __getfield_unknown1(self):
2690 try: self.__field_unknown1
2691 except:
2692 self.__field_unknown1=UINT(**{'sizeinbytes': 1, 'default': 0 })
2693 return self.__field_unknown1.getvalue()
2694
2695 def __setfield_unknown1(self, value):
2696 if isinstance(value,UINT):
2697 self.__field_unknown1=value
2698 else:
2699 self.__field_unknown1=UINT(value,**{'sizeinbytes': 1, 'default': 0 })
2700
2701 def __delfield_unknown1(self): del self.__field_unknown1
2702
2703 unknown1=property(__getfield_unknown1, __setfield_unknown1, __delfield_unknown1, None)
2704
2705 def __getfield_alarmminutes(self):
2706 try: self.__field_alarmminutes
2707 except:
2708 self.__field_alarmminutes=UINT(**{'sizeinbytes': 1, 'default': 0xff })
2709 return self.__field_alarmminutes.getvalue()
2710
2711 def __setfield_alarmminutes(self, value):
2712 if isinstance(value,UINT):
2713 self.__field_alarmminutes=value
2714 else:
2715 self.__field_alarmminutes=UINT(value,**{'sizeinbytes': 1, 'default': 0xff })
2716
2717 def __delfield_alarmminutes(self): del self.__field_alarmminutes
2718
2719 alarmminutes=property(__getfield_alarmminutes, __setfield_alarmminutes, __delfield_alarmminutes, "a value of 0xFF indicates not set")
2720
2721 def __getfield_alarmhours(self):
2722 try: self.__field_alarmhours
2723 except:
2724 self.__field_alarmhours=UINT(**{'sizeinbytes': 1, 'default': 0xff })
2725 return self.__field_alarmhours.getvalue()
2726
2727 def __setfield_alarmhours(self, value):
2728 if isinstance(value,UINT):
2729 self.__field_alarmhours=value
2730 else:
2731 self.__field_alarmhours=UINT(value,**{'sizeinbytes': 1, 'default': 0xff })
2732
2733 def __delfield_alarmhours(self): del self.__field_alarmhours
2734
2735 alarmhours=property(__getfield_alarmhours, __setfield_alarmhours, __delfield_alarmhours, "a value of 0xFF indicates not set")
2736
2737 def __getfield_unknown2(self):
2738 try: self.__field_unknown2
2739 except:
2740 self.__field_unknown2=UINT(**{'sizeinbytes': 1, 'default': 0 })
2741 return self.__field_unknown2.getvalue()
2742
2743 def __setfield_unknown2(self, value):
2744 if isinstance(value,UINT):
2745 self.__field_unknown2=value
2746 else:
2747 self.__field_unknown2=UINT(value,**{'sizeinbytes': 1, 'default': 0 })
2748
2749 def __delfield_unknown2(self): del self.__field_unknown2
2750
2751 unknown2=property(__getfield_unknown2, __setfield_unknown2, __delfield_unknown2, None)
2752
2753 def __getfield_unknown3(self):
2754 try: self.__field_unknown3
2755 except:
2756 self.__field_unknown3=UINT(**{'sizeinbytes': 2, 'default': 0x01FC })
2757 return self.__field_unknown3.getvalue()
2758
2759 def __setfield_unknown3(self, value):
2760 if isinstance(value,UINT):
2761 self.__field_unknown3=value
2762 else:
2763 self.__field_unknown3=UINT(value,**{'sizeinbytes': 2, 'default': 0x01FC })
2764
2765 def __delfield_unknown3(self): del self.__field_unknown3
2766
2767 unknown3=property(__getfield_unknown3, __setfield_unknown3, __delfield_unknown3, None)
2768
2769 def __getfield_unknown4(self):
2770 try: self.__field_unknown4
2771 except:
2772 self.__field_unknown4=UINT(**{'sizeinbytes': 4, 'default': 0 })
2773 return self.__field_unknown4.getvalue()
2774
2775 def __setfield_unknown4(self, value):
2776 if isinstance(value,UINT):
2777 self.__field_unknown4=value
2778 else:
2779 self.__field_unknown4=UINT(value,**{'sizeinbytes': 4, 'default': 0 })
2780
2781 def __delfield_unknown4(self): del self.__field_unknown4
2782
2783 unknown4=property(__getfield_unknown4, __setfield_unknown4, __delfield_unknown4, None)
2784
2785 def __getfield_serial_number(self):
2786 try: self.__field_serial_number
2787 except:
2788 self.__field_serial_number=USTRING(**{'sizeinbytes': 65, 'default': '000000d1-00000000-0000000000-VX910V03', 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'raiseontruncate': False })
2789 return self.__field_serial_number.getvalue()
2790
2791 def __setfield_serial_number(self, value):
2792 if isinstance(value,USTRING):
2793 self.__field_serial_number=value
2794 else:
2795 self.__field_serial_number=USTRING(value,**{'sizeinbytes': 65, 'default': '000000d1-00000000-0000000000-VX910V03', 'encoding': PHONE_ENCODING, 'raiseonunterminatedread': False, 'raiseontruncate': False })
2796
2797 def __delfield_serial_number(self): del self.__field_serial_number
2798
2799 serial_number=property(__getfield_serial_number, __setfield_serial_number, __delfield_serial_number, None)
2800
2801 def __getfield_blanks(self):
2802 try: self.__field_blanks
2803 except:
2804 self.__field_blanks=STRING(**{'sizeinbytes': 134, 'default': '', 'terminator': 0xff, 'pad': 0xff })
2805 return self.__field_blanks.getvalue()
2806
2807 def __setfield_blanks(self, value):
2808 if isinstance(value,STRING):
2809 self.__field_blanks=value
2810 else:
2811 self.__field_blanks=STRING(value,**{'sizeinbytes': 134, 'default': '', 'terminator': 0xff, 'pad': 0xff })
2812
2813 def __delfield_blanks(self): del self.__field_blanks
2814
2815 blanks=property(__getfield_blanks, __setfield_blanks, __delfield_blanks, None)
2816
2817 def iscontainer(self):
2818 return True
2819
2820 def containerelements(self):
2821 yield ('packet_size', self.__field_packet_size, None)
2822 yield ('pos', self.__field_pos, "position within file, used as an event id")
2823 if self.pos!=0xffffffff:
2824 yield ('description', self.__field_description, None)
2825 yield ('cdate', self.__field_cdate, None)
2826 yield ('mdate', self.__field_mdate, None)
2827 yield ('start', self.__field_start, None)
2828 yield ('end_time', self.__field_end_time, None)
2829 yield ('end_date', self.__field_end_date, None)
2830 yield ('repeat', self.__field_repeat, None)
2831 yield ('alarmindex_vibrate', self.__field_alarmindex_vibrate, None)
2832 yield ('ringtone', self.__field_ringtone, None)
2833 yield ('unknown1', self.__field_unknown1, None)
2834 yield ('alarmminutes', self.__field_alarmminutes, "a value of 0xFF indicates not set")
2835 yield ('alarmhours', self.__field_alarmhours, "a value of 0xFF indicates not set")
2836 yield ('unknown2', self.__field_unknown2, None)
2837 yield ('unknown3', self.__field_unknown3, None)
2838 yield ('unknown4', self.__field_unknown4, None)
2839 yield ('serial_number', self.__field_serial_number, None)
2840 else:
2841 yield ('blanks', self.__field_blanks, None)
2842
2843
2844
2845
2846 class schedulefile(BaseProtogenClass):
2847 __fields=['numactiveitems', 'events']
2848
2849 def __init__(self, *args, **kwargs):
2850 dict={}
2851 dict.update(kwargs)
2853 super(schedulefile,self).__init__(**dict)
2855 if self.__class__ is schedulefile:
2856 self._update(args,dict)
2857
2858
2859 def getfields(self):
2860 return self.__fields
2861
2862
2863 def _update(self, args, kwargs):
2864 super(schedulefile,self)._update(args,kwargs)
2865 keys=kwargs.keys()
2866 for key in keys:
2867 if key in self.__fields:
2868 setattr(self, key, kwargs[key])
2869 del kwargs[key]
2870 if __debug__:
2872 self._complainaboutunusedargs(schedulefile,kwargs)
2873 if len(args): raise TypeError('Unexpected arguments supplied: '+`args`)
2874
2876
2877 def writetobuffer(self,buf,autolog=True,logtitle="<written data>"):
2878 'Writes this packet to the supplied buffer'
2879 self._bufferstartoffset=buf.getcurrentoffset()
2880 self.__field_numactiveitems.writetobuffer(buf)
2881 try: self.__field_events
2882 except:
2883 self.__field_events=LIST(**{ 'elementclass': scheduleevent, 'length': NUMCALENDARENTRIES, 'createdefault': True })
2884 self.__field_events.writetobuffer(buf)
2885 self._bufferendoffset=buf.getcurrentoffset()
2886 if autolog and self._bufferstartoffset==0: self.autologwrite(buf, logtitle=logtitle)
2887
2888
2889 def readfrombuffer(self,buf,autolog=True,logtitle="<read data>"):
2890 'Reads this packet from the supplied buffer'
2891 self._bufferstartoffset=buf.getcurrentoffset()
2892 if autolog and self._bufferstartoffset==0: self.autologread(buf, logtitle=logtitle)
2893 self.__field_numactiveitems=UINT(**{'sizeinbytes': 2})
2894 self.__field_numactiveitems.readfrombuffer(buf)
2895 self.__field_events=LIST(**{ 'elementclass': scheduleevent, 'length': NUMCALENDARENTRIES, 'createdefault': True })
2896 self.__field_events.readfrombuffer(buf)
2897 self._bufferendoffset=buf.getcurrentoffset()
2898
2899
2900 def __getfield_numactiveitems(self):
2901 return self.__field_numactiveitems.getvalue()
2902
2903 def __setfield_numactiveitems(self, value):
2904 if isinstance(value,UINT):
2905 self.__field_numactiveitems=value
2906 else:
2907 self.__field_numactiveitems=UINT(value,**{'sizeinbytes': 2})
2908
2909 def __delfield_numactiveitems(self): del self.__field_numactiveitems