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