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