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