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