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